How would I remove duplicates from an Arraylist<Integer[]>? (Java)

Question says it all really. I tried using a LinkedHashSet but that did not work. If im not wrong, the comparisons were not being done correctly due to the fact that it was comparing Integer arrays.

My aim is to create a static method removeDuplicates(ArrayList&lt;Integer&gt;). The method should compare based on content of the arrays. My attempt so far:

import java.util.ArrayList;
import java.util.LinkedHashSet;

public class test {
    public static void main(String[] args) {
        ArrayList<Integer[]> arrayList = new ArrayList<>();

        Integer[] array1 = new Integer[2];
        array1[0] = 1;
        array1[1] = 4;

        Integer[] array2 = new Integer[2];
        array2[0] = 1;
        array2[1] = 4;

        arrayList.add(array1);
        arrayList.add(array2);

        LinkedHashSet<Integer[]> hashSet = new LinkedHashSet<>(arrayList);

        ArrayList<Integer[]> listWithoutDuplicates = new ArrayList<>(hashSet);

        System.out.println("Number of elements before using linkedhashset: " + arrayList.size());
        System.out.println("number of elements after: (expecting 1) " + listWithoutDuplicates.size());
    }
}

gives the result:

Number of elements before using linkedhashset: 2
number of elements after (expecting 1):  2

A possible solution would be saving the number of occurrences of each number in each array in the list to consider duplicate numbers, and check whether this instance was already added or not:

private static List<Integer[]> removeDuplicates(List<Integer[]> list) {
		List<HashMap<Integer,Integer>> instances = new ArrayList<>();
		List<Integer[]> res = new ArrayList<>();
		for(Integer[] arr : list) {
			HashMap<Integer,Integer> map = new HashMap<>();
			for(Integer num : arr) {
				if(map.containsKey(num))
					map.replace(num, map.get(num)+1);
				else
					map.put(num,1);
			}
			if(!instances.contains(map)) {
				instances.add(map);
				res.add(arr);
			}
		}
		return res;
}

You can use following approach

List<Integer[]> listWithoutDuplicates = arrayList.stream()
            .map(arr -> Arrays.asList(arr))
            .distinct()
            .map(list -> list.toArray(new Integer[0]))
            .collect(Collectors.toList());

The trick here is that mapping Integer[] to List<Integer> allows you to utilize List::equals() method that can detect if two Lists are equal (= "both contain same elements in same order"). In conjunction with Stream::distinct() that will cut off duplicates, and then every unique List is converted back to Integer[].