[NP] 1.3 Низа од цели броеви (int[]) (Solved)

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
import java.util.stream.IntStream;

public class IntegerArrayTester {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        IntegerArray ia = null;
        switch (s) {
            case "testSimpleMethods":
                ia = new IntegerArray(generateRandomArray(scanner.nextInt()));
                testSimpleMethods(ia);
                break;
            case "testConcat":
                testConcat(scanner);
                break;
            case "testEquals":
                testEquals(scanner);
                break;
            case "testSorting":
                testSorting(scanner);
                break;
            case "testReading":
                testReading(new ByteArrayInputStream(scanner.nextLine().getBytes()));
                break;
            case "testImmutability":
                int a[] = generateRandomArray(scanner.nextInt());
                ia = new IntegerArray(a);
                testSimpleMethods(ia);
                testSimpleMethods(ia);
                IntegerArray sorted_ia = ia.getSorted();
                testSimpleMethods(ia);
                testSimpleMethods(sorted_ia);
                sorted_ia.getSorted();
                testSimpleMethods(sorted_ia);
                testSimpleMethods(ia);
                a[0] += 2;
                testSimpleMethods(ia);
                ia = ArrayReader.readIntegerArray(new ByteArrayInputStream(integerArrayToString(ia).getBytes()));
                testSimpleMethods(ia);
                break;
        }
        scanner.close();
    }

    static void testReading(InputStream in) {
        IntegerArray read = ArrayReader.readIntegerArray(in);
        System.out.println(read);
    }

    static void testSorting(Scanner scanner) {
        int[] a = readArray(scanner);
        IntegerArray ia = new IntegerArray(a);
        System.out.println(ia.getSorted());
    }

    static void testEquals(Scanner scanner) {
        int[] a = readArray(scanner);
        int[] b = readArray(scanner);
        int[] c = readArray(scanner);
        IntegerArray ia = new IntegerArray(a);
        IntegerArray ib = new IntegerArray(b);
        IntegerArray ic = new IntegerArray(c);
        System.out.println(ia.equals(ib));
        System.out.println(ia.equals(ic));
        System.out.println(ib.equals(ic));
    }

    static void testConcat(Scanner scanner) {
        int[] a = readArray(scanner);
        int[] b = readArray(scanner);
        IntegerArray array1 = new IntegerArray(a);
        IntegerArray array2 = new IntegerArray(b);
        IntegerArray concatenated = array1.concat(array2);
        System.out.println(concatenated);
    }

    static void testSimpleMethods(IntegerArray ia) {
        System.out.print(integerArrayToString(ia));
        System.out.println(ia);
        System.out.println(ia.sum());
        System.out.printf("%.2f\n", ia.average());
    }


    static String integerArrayToString(IntegerArray ia) {
        StringBuilder sb = new StringBuilder();
        sb.append(ia.length()).append('\n');
        for (int i = 0; i < ia.length(); ++i)
            sb.append(ia.getElementAt(i)).append(' ');
        sb.append('\n');
        return sb.toString();
    }

    static int[] readArray(Scanner scanner) {
        int n = scanner.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; ++i) {
            a[i] = scanner.nextInt();
        }
        return a;
    }


    static int[] generateRandomArray(int k) {
        Random rnd = new Random(k);
        int n = rnd.nextInt(8) + 2;
        int a[] = new int[n];
        for (int i = 0; i < n; ++i) {
            a[i] = rnd.nextInt(20) - 5;
        }
        return a;
    }

}

final class IntegerArray {
    private int arr[];

    IntegerArray(int a[]) {
        arr = new int[a.length];
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }
    }

    public int length() {
        return arr.length;
    }

    public int getElementAt(int i) {
        if (0 <= i && i <= length() - 1) {
            return arr[i];
        } else {
            return -1;
        }
    }

    public int sum() {
    /*
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    */
        return Arrays.stream(arr).sum();
    }

    public double average() {
    /*
        return (double) sum() / length();
    */
        return Arrays.stream(arr).average().getAsDouble();
    }

    public IntegerArray getSorted() {
    /*
        int len = length();
        int[] copy = Arrays.copyOf(arr, len);
        Arrays.sort(copy);
        return new IntegerArray(copy);
    */
        return new IntegerArray(Arrays.stream(arr).sorted().toArray());
    }

    public IntegerArray concat(IntegerArray ia) {
    /*
        int len = length();
        int ialen = ia.length();
        int both[] = new int [len + ialen];
        for (int i = 0; i < len; i++) {
            both[i] = arr[i];
        }
        for (int i = 0; i < ialen; i++) {
            both[i + len] = ia.getElementAt(i);
        }
        return new IntegerArray(both);
    */
        int both[] = new int[this.length() + ia.length()];
        System.arraycopy(this.arr, 0, both, 0, this.length());
        System.arraycopy(ia.arr, 0, both, this.length(), ia.length());
        return new IntegerArray(both);
    }

    @Override
    public String toString() {
        return Arrays.toString(arr);
    }

    /*@Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }

        IntegerArray that = (IntegerArray) obj;
        if (arr.length != that.length()) {
            return false;
        }

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != that.getElementAt(i)) {
                return false;
            }
        }

        if (IntStream.range(0, this.length()).anyMatch(i -> this.arr[i] != that.arr[i])) {
            return false;
        }
        return true;
    }*/

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        IntegerArray that = (IntegerArray) o;

        return Arrays.equals(arr, that.arr);
    }

    @Override
    public int hashCode() {
        return Arrays.hashCode(arr);
    }
}

class ArrayReader {
    public static IntegerArray readIntegerArray(InputStream input) {
        Scanner scanner = new Scanner(input);
        int len = scanner.nextInt();
        int numbers[] = new int[len];
        /*for (int i = 0; i < len; i++) {
            numbers[i] = scanner.nextInt();
        }*/
        IntStream.range(0, len).forEach(i -> numbers[i] = scanner.nextInt());
        return new IntegerArray(numbers);
    }
}