Нужно получить уникальные числа из двух массивов

package ru.ismoke;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
public class Cyber {
 
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {7, 8, 3, 4, 5};
        List<Integer> list = new ArrayList<>();
 
        for (int item : arr1) {
            if (!isPresent(arr2, item)) list.add(item);
        }
        for (int item : arr2) {
            if (!isPresent(arr1, item)) list.add(item);
        }
 
        Integer[] result = list.toArray(new Integer[0]);
        System.out.println(Arrays.toString(result));
 
    }
 
    private static boolean isPresent(int[] arr, int item) {
        for (int elem : arr) {
            if (elem == item) return true;
        }
        return false;
    }
}

public class MyClass {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,8};
        int[] b = {3,4,5,6,7,8,9};
        MyClass.newArray(a, b);
    }
    static void newArray(int[] a, int[] b) {    
        Item[] sumArray = new Item[a.length + b.length];
        for(int i=0; i<a.length; i++) 
            sumArray[i] = new Item(a[i]);
        for(int i=a.length, j=0; i<b.length+a.length; i++, j++) 
            sumArray[i] = new Item(b[j]);
        for(int i=0; i<sumArray.length; i++) 
            if(sumArray[i].isUnicueInArray(sumArray)) 
                System.out.println(sumArray[i].i);
    }
}
class Item {
    public Item(int i) { 
        this.i = i;
    }
    int i, count=0;
    boolean isUnicueInArray(Item[] a) {
        for(Item j : a) 
            count = this.i==j.i? count+1 : count;
        return count == 1;
    }
}

            count = this.i==j.i? count++ : count;

Integer[] arr1 = {1, 2, 3, 4, 5, 3, 4, 5, 6, 7, 5, 4, 8, 3, 6, 5, 4};
        Integer[] arr2 = {7, 8, 3, 4, 5};
 
        List<Integer> list1 = Arrays.asList(arr1);
        List<Integer> list2 = Arrays.asList(arr2);
 
        Integer[] resultArray = Stream.concat(list1.stream(), list2.stream())
                .distinct()
                .filter(x -> !list2.contains(x) || !list1.contains(x))
                .toArray(Integer[]::new);
 
        System.out.println(Arrays.toString(resultArray));

public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5, 3, 4, 5, 6, 7, 5, 4, 8, 3, 6, 5, 4};
        int[] arr2 = {7, 8, 3, 4, 5};
 
        List<Integer> list1 = Arrays.stream(arr1)
                .boxed()
                .collect(Collectors.toList());
 
        List<Integer> list2 = Arrays.stream(arr2)
                .boxed()
                .collect(Collectors.toList());
 
 
        Integer[] resultArray = Stream.concat(list1.stream(), list2.stream())
                .distinct()
                .filter(x -> !list2.contains(x) || !list1.contains(x))
                .toArray(Integer[]::new);
 
        System.out.println(Arrays.toString(resultArray));
    }

Integer[] result = Stream.concat(Arrays.stream(arr1).boxed(), Arrays.stream(arr2).boxed())
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                .entrySet()
                .stream()
                .filter(x -> x.getValue() == 1)
                .map(Map.Entry::getKey)
                .toArray(Integer[]::new);

private static int[] identic(int[]... arrays) {
    return Stream.of(
            Arrays.stream(arrays)
                    .map(i -> Arrays.stream(i).boxed())
    )
            .flatMap(i -> i)
            .flatMap(i -> i)
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
            .entrySet()
            .stream()
            .filter(x -> x.getValue() == 1)
            .mapToInt(Map.Entry::getKey)
            .toArray();
}

private static int[] identic(int[]... arrays) {
    List<Integer> a = Stream.of(
            Arrays.stream(arrays)
                    .map(i -> Arrays.stream(i).boxed())
)
            .flatMap(i -> i)
            .flatMap(i -> i)
            .collect(Collectors.toList());
 
    return a.stream()
            .filter(b -> Collections.frequency(a, b) == 1)
            .mapToInt(i -> i)
            .toArray();
}