Question

在这种情况下，使用ArrayList库中的public boolean contains(Object o)不起作用。考虑

ArrayList<int[][]> test = new ArrayList<>();

int[][] one = {
    {1,2,3},
    {4,5,6}
};
int[][] two = {
    {1,2,3},
    {4,5,6}
};
int[][] three = {
    {9,7,5},
    {1,2,4},
    {5,6,7}
};

test.add(one);
System.out.println(test.contains(one));
System.out.println(test.contains(two));
System.out.println(test.contains(three));

上面的代码返回

true
false
false

有没有办法检查两者之间的相等性，并确保没有重复的值进入列表？

Answer 1

一种解决方案是将数组包装在一个提供适当equals实现的类中。

class SquareArray {
    private int[][] array;

    public SquareArray(int[][] array) {
        this.array = array;
    }

    public int[][] getArray() {
        return array;
    }

    @Override
    public boolean equals(Object o) {
        return (o instanceof SquareArray) && 
               Arrays.deepEquals(array, ((SquareArray)o).array);
    }

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

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

现在你要使用List<SquareArray>;例如：

int[][] a = {{1,2,3}, {4,5,6}};
int[][] b = {{1,2},{3,4},{5,6}};
int[][] c = {{1,2,3}, {4,5,6}};

SquareArray x = new SquareArray(a);
SquareArray y = new SquareArray(b);
SquareArray z = new SquareArray(c);

List<SquareArray> list = new ArrayList<>();
list.add(x);
System.out.println(list.contains(x));
System.out.println(list.contains(y));
System.out.println(list.contains(z));

true
false
true

<强>参考：

Answer 2

我知道最简单的方法是使用Arrays.deepEquals(Object[], Object[])将其提取到方法中，例如 -

public static boolean contains(List<int[][]> al, int[][] toFind) {
    for (int[][] arr : al) {
        if (Arrays.deepEquals(arr, toFind)) {
            return true;
        }
    }
    return false;
}

然后你可以像

那样进行测试

public static void main(String[] args) {
    ArrayList<int[][]> test = new ArrayList<int[][]>();
    int[][] one = { { 1, 2, 3 }, { 4, 5, 6 } };
    int[][] two = { { 1, 2, 3 }, { 4, 5, 6 } };
    int[][] three = { { 9, 7, 5 }, { 1, 2, 4 }, { 5, 6, 7 } };
    test.add(one);
    if (contains(test, two)) {
        System.out.println("Found two");
    }
}

输出

Found two

Answer 3

我想提出另一种使用Java 8流和谓词的解决方案：

Stream#anyMatch方法可用于检查给定列表是否包含某个元素。可以使用Arrays#deepEquals简洁地构建所需的谓词：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class GenericContainsTest
{
    public static void main(String[] args)
    {
        List<int[][]> list = new ArrayList<int[][]>();
        int[][] one =
        { { 1, 2, 3 },
          { 4, 5, 6 } };
        int[][] two =
        { { 1, 2, 3 },
          { 4, 5, 6 } };
        list.add(one);
        if (list.stream().anyMatch(e->Arrays.deepEquals(e, two)))
        {
            System.out.println("Found two");
        }
    }
}

但是，你提到你的目的是......

...确保没有重复的值进入列表

在这种情况下，您至少应该考虑不使用List，而是Set - 尤其是Set<SquareArray>使用SquareArray类{{1}} }}。

Answer 4

contains方法使用方法equals(e)，当您在数组上使用equals时，它与使用==相同，因此您检查引用相等，而不是内容。要检查两个数组是否相等，您必须对嵌套数组使用Arrays.equals (array1, array2)或Arrays.deepEquals (nestedArray1, nestedArray2)。

使用ArrayList <int [] []>时如何查看元素是否已经在列表中？</int [] []>

4 个答案: