Одинаковые элементы массива

Для этого вы можете использовать следующее:

String[] strArray1;
String[] strArray2;

Я переименовал их в strArray вместо strList для логичности, а затем:

private <T> boolean containsAll(final T[] a1, final T[] a2) {
    return Arrays.asList(a1).containsAll(Arrays.asList(a2));
}

и назовите его:

boolean exactMath = containsAll(strArray1, strArray2) 
        && containsAll(strArray2, strArray1);

Обратите внимание, что Arrays.asList(T[] array) создает оболочку List<T> вокруг T[] array, на самом деле она не делает копию T[] array. Если вы измените List<T>, он также изменит T[] array.

Вы можете использовать хеш-карту. Этот метод имеет более низкую временную сложность, поскольку сортировка и поиск не требуются, но используется более высокая сложность пространства в качестве хэш-карты:

        String[] strList1 = {"ABC", "CDE", "EFG"};
        String[] strList2 = {"ABC", "EFG", "CDE"};
        Boolean flag = true;
        Map<String, Integer> map = new HashMap<String, Integer>();

        /*Initial Check*/

        if(strList1.length != strList2.length) {
           System.out.print("Array equals: false");
           return 0;
        }

        /*Add all strings from list1 and their frequency to map*/

        for(int i=0; i<strList1.length;i++) {
            if(map.get(strList1[i]) != null) 
               map.put(strList1[i], map.get(strList1[i]) + 1);
            else
               map.put(strList1[i], 0); 
        }

        /*If string found in map from list2, decrement count in map
          else list2 contains a string not in map, then arrays 
          unequal as list2 contains a string not in list1*/

        for(int i=0; i<strList2.length;i++) {
            if(map.get(strList2[i]) != null)
               map.put(strList2[i], map.get(strList2[i]) - 1);
            else {  
                System.out.print("Array equals: false");
                flag = false;
            }
        }

        /*If map contains the same value for every string i.e. 0, then they occur
          equal no. of times in both arrays. Hence, Set values will contain 
          only one value so (values.size() == 1) will be equal true, else false*/

        if(flag) {
            Set<Integer> values = new HashSet<Integer>(map.values());
            System.out.print("Array equals: " + (values.size() == 1));
        }
        return 0;

Для вашего ввода это будет выводиться: Array equals: true.
Этот метод также учитывает повторяющиеся строки во входных массивах.

Используйте Arrays.equals:

Arrays.equals(ary, ary2));

Или Arrays.deepEquals

Возвращает true, если два указанных массива глубоко равны друг другу. В отличие от метода @link {#equals {Object [], Object []), этот метод подходит для использования с вложенными массивами произвольной глубины. Две ссылки на массивы считаются глубоко равными, если оба они являются нулевыми или относятся к массивам, которые содержат одинаковое количество элементов, и все соответствующие пары элементов в двух массивах глубоко равны.

Два, возможно, нулевые элементы e1 и e2 являются глубоко равными, если выполнено одно из следующих условий:

e1 и e2 - оба массива типов ссылочных объектов, а Arrays.deepEquals(e1, e2) вернет true
e1 и e2 - массивы одного и того же примитивного типа, и соответствующая перегрузка Arrays.equals(e1, e2) вернет true.
e1 == e2
e1.equals(e2) вернет true.

Arrays#deepEquals(java.lang.Object[], java.lang.Object[])

Он обеспечивает, что ссылки на два массива считаются глубоко равными или нет.

Arrays.deepEquals(e1,e2);

Два, возможно, нулевые элементы e1 и e2 являются глубоко равными, если выполнено одно из следующих условий:

 - e1 and e2 are both arrays of object reference types, and
   Arrays.deepEquals(e1, e2) would return true
 - e1 and e2 are arrays of the same primitive type, and the appropriate
   overloading of Arrays.equals(e1, e2) would return true.
 - e1 == e2
 - e1.equals(e2) would return true.

Note that this definition permits null elements at any depth.

Документация

В отличие от метода Arrays#equals(Object[],Object[]) этот метод подходит для использования с вложенными массивами произвольной глубины.

Вы можете использовать метод listAllAll

strList2.removeAll(strList1)

if(strList2.isEmpty)
{
  // Exact match
}
else{

  // failed
}

public static boolean equals(int[] a, int[] a2)

Возвращает true, если два указанных массива ints равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов, а все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одни и те же элементы в одном порядке. Кроме того, две ссылки на массивы считаются равными, если оба значения равны нулю.