Java 如何测试字符串数组列表的相等性

我想我看不见森林，看不见树木。。。如何递归地测试字符串数组列表中所有元素的相等性（而不是一致性）？下面是一个简单的例子：

List<String[]> left = new ArrayList<>();
left.add(new String[]{"one", "two"});

List<String[]> right = new ArrayList<>();
right.add(new String[]{"one", "two"});

System.out.println(left.equals(right) ? "Yeah!" : "This is not what I want.");

List left=new ArrayList（）；
添加（新字符串[]{“一”，“二”}）；
List right=new ArrayList（）；
添加（新字符串[]{“一”，“二”}）；
System.out.println（左。等于（右）？“是的！”：“这不是我想要的。”）；

我想在单元测试中使用它

---

更详细一点：我有一个类，它包含几个字段，其中一些是

String

数组的

List

，一些是

Set

String数组的

s。该类是解析器的结果（实际上是解析器级联中的中间步骤）。为了测试解析器，我想检查相关类的实例是否相等。IDE自动生成的
equals
实现使用了一个级联的
对象。equals
调用几个
列表
和
集合
字段，这相当于我上面提供的最小示例
 测试两个列表的大小是否相同。然后，如果他们这样做了，则对每一个数组进行迭代，并使用

如果您有一个列表列表（
List
），这会更容易，因为可以使用
equals（）
直接比较列表。
测试两个列表的大小是否相同。然后，如果他们这样做了，则对每一个数组进行迭代，并使用

如果您有一个列表列表（
List
），这会更容易，因为可以使用
equals（）
直接比较列表。
如果您需要比较列表，请尝试使用该特定列表实例的
equals（）
，提供另一个要比较的列表实例

如果需要比较数组，请尝试使用
arrays.equals（）

如果您在测试方法
org.junit.Assert
的
assertarayequals（）
或
assertEquals（）
中执行此操作，则应按照它们将在封面后面调用的方法进行操作。
如果您需要比较列表，请尝试使用该特定列表实例的
equals（）
，提供另一个要比较的实例

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

import javax.swing.text.html.HTMLDocument.Iterator;


public class test 
{
  public static void main(String args[])
  {

      List<String[]> left = new ArrayList<String[]>();
      left.add(new String[]{"one", "two"});

      List<String[]> right = new ArrayList<String[]>();
      right.add(new String[]{"one", "two"});

      java.util.Iterator<String[]> leftIterator =left.iterator();
      java.util.Iterator<String[]> rightIterator =right.iterator();
      if(left.size() !=right.size())   System.out.println("not equal");
      for(;leftIterator.hasNext();)
      {
         if(Arrays.equals(leftIterator.next(), rightIterator.next())) continue;
         else
         {
             System.out.print("not equal");
             break;
         }
      }


  }
}

如果需要比较数组，请尝试使用
arrays.equals（）

如果您是在测试方法
org.junit.Assert
的
assertarayequals（）
或
assertEquals（）
中执行此操作，则应在封面后面调用这些方法；
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.swing.text.html.HTMLDocument.Iterator;


public class test 
{
  public static void main(String args[])
  {

      List<String[]> left = new ArrayList<String[]>();
      left.add(new String[]{"one", "two"});

      List<String[]> right = new ArrayList<String[]>();
      right.add(new String[]{"one", "two"});

      java.util.Iterator<String[]> leftIterator =left.iterator();
      java.util.Iterator<String[]> rightIterator =right.iterator();
      if(left.size() !=right.size())   System.out.println("not equal");
      for(;leftIterator.hasNext();)
      {
         if(Arrays.equals(leftIterator.next(), rightIterator.next())) continue;
         else
         {
             System.out.print("not equal");
             break;
         }
      }


  }
}

导入java.util.array；
导入java.util.List；
导入javax.swing.text.html.HTMLDocument.Iterator；
公开课考试
{
公共静态void main（字符串参数[]）
{
左列表=新建ArrayList（）；
添加（新字符串[]{“一”，“二”}）；
List right=new ArrayList（）；
添加（新字符串[]{“一”，“二”}）；
java.util.Iterator leftIterator=left.Iterator（）；
java.util.Iterator rightIterator=right.Iterator（）；
if（left.size（）！=right.size（））System.out.println（“不相等”）；
对于（；leftIterator.hasNext（）；）
{
如果（Arrays.equals（leftIterator.next（），righIterator.next（））继续；
其他的
{
系统输出打印（“不相等”）；
打破
}
}
}
}

导入java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入javax.swing.text.html.HTMLDocument.Iterator；
公开课考试
{
公共静态void main（字符串参数[]）
{
左列表=新建ArrayList（）；
添加（新字符串[]{“一”，“二”}）；
List right=new ArrayList（）；
添加（新字符串[]{“一”，“二”}）；
java.util.Iterator leftIterator=left.Iterator（）；
java.util.Iterator rightIterator=right.Iterator（）；
if（left.size（）！=right.size（））System.out.println（“不相等”）；
对于（；leftIterator.hasNext（）；）
{
如果（Arrays.equals（leftIterator.next（），righIterator.next（））继续；
其他的
{
系统输出打印（“不相等”）；
打破
}
}
}
}

Java文档要求list

equals（）

在您使用它时起作用，因此，如果这些是

列表中的
列表，那么您的代码可以工作：

布尔等于（对象o）

比较指定对象与此列表是否相等。当且仅当指定对象也是列表、两个列表的大小相同且两个列表中所有对应的元素对相等时，返回true。（如果（e1==null？e2==null:e1.equals（e2）），则两个元素e1和e2是相等的。）换句话说，如果两个列表以相同的顺序包含相同的元素，则将它们定义为相等。此定义确保equals方法在列表接口的不同实现中正常工作

然而，在“叶子”处，您有普通的Java数组。它们将使用
equals
的
对象定义，该定义测试的是引用标识，而不是值相等

在测试中解决这个问题的一种方法是编写一个小助手工厂例程，它接受
String
s的变量参数列表，并生成
list
返回来替换当前使用的Java数组。那么一切都应该顺利进行。您的示例如下所示：

// A little helper to avoid the awkward syntax
// Arrays.asList(new String [] { "one", "two" })
public static List<String> listOf(String ... strings) {
    return Arrays.asList(strings);
}

public static void main(String[] args) {
    List<List<String>> left = new ArrayList<>();
    left.add(listOf("one", "two"));

    List<List<String>> right = new ArrayList<>();
    right.add(listOf("one", "two"));

    System.out.println(left.equals(right) ? "Yeah!" : "This is not what I want.");
}

//一个小帮手，可以避免笨拙的语法
//asList（新字符串[]{“一”，“二”}）
公共静态列表列表（字符串…字符串）{
返回数组.asList（字符串）；
}
公共静态void main（字符串[]args）{
左列表=新建ArrayList（）；
左图。添加（列表中的“一”、“二”）；
List right=new ArrayList（）；
对。添加（列表中的“一”、“二”）；
System.out.println（左。等于（右）？“是的！”：“这不是我想要的。”）；
}
Java文档要求list
equals（）
在您使用它时起作用，因此如果这些是
list
s个
列表，您的代码就可以工作protected static boolean equalsCollectionOfArrays(Collection<? extends Object[]> leftCollection,
                                                   Collection<? extends Object[]> rightCollection) {
    if (leftCollection.size() != rightCollection.size()) {
        return false;
    } else {
        Iterator<? extends Object[]> left = leftCollection.iterator();
        Iterator<? extends Object[]> right = rightCollection.iterator();
        while (left.hasNext()) {
            if (!Arrays.equals(left.next(), right.next())) {
                return false;
            }
        }
        return true;
    }
}

protected static int hashCodeCollectionOfArrays(Collection<? extends Object[]> collection) {
    int hash = 3;
    for (Object[] objects : collection) {
        hash = 67 * hash + Arrays.hashCode(objects);
    }
    return hash;
}