blocks|key|121154|text|for循环至少可以被简化，从而导致：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|121155|return+(list1.size()==list2.size()+&&
++++++++IntStream.range(0,+list1.size())
+++++++++++++++++.allMatch(i+->+Arrays.equals(list1.get(i),+list2.get(i)));|code-block|syntax|javascript|121156|entityMap^0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

The <code>for</code> loop at least can be streamified, leading to:

<pre><code>return (list1.size()==list2.size() &amp;&amp;
 IntStream.range(0, list1.size())
 .allMatch(i -&gt; Arrays.equals(list1.get(i), list2.get(i)));
</code></pre>

blocks|key|2671944|text|如果列表是随机访问列表(因此对get的调用速度很快-通常时间不变)，则可以使用流，从而导致：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2671945|//checks+for+null+and+size+before
boolean+same+=+IntStream.range(0,+list1.size()).allMatch(i+->+Arrays.equals(list1.get(i),+list2.get(i)));|code-block|syntax|javascript|2671946|但是，您可能会给出一些不作为参数的实现(例如LinkedLists)。在这种情况下，最好的方法是显式地使用迭代器。类似于：|2671947|boolean+compare(List<String[]>+list1,+List<String[]>+list2)+{

++++//checks+for+null+and+size

++++Iterator<String[]>+iteList1+=+list1.iterator();
++++Iterator<String[]>+iteList2+=+list2.iterator();

++++while(iteList1.hasNext())+{
++++++++if(!Arrays.equals(iteList1.next(),+iteList2.next()))+{
++++++++++++return+false;
++++++++}
++++}
++++return+true;
}|2671948|entityMap^0|F|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

You could use a stream if the lists are random access lists (so that a call to <code>get</code> is fast - generally constant time) leading to:

<pre><code>//checks for null and size before
boolean same = IntStream.range(0, list1.size()).allMatch(i -&gt; Arrays.equals(list1.get(i), list2.get(i)));
</code></pre>

However, you might give as parameters some implementations that are not (such as LinkedLists). In this case, the best way is to use the iterator explicitly. Something like:

<pre><code>boolean compare(List&lt;String[]&gt; list1, List&lt;String[]&gt; list2) {

 //checks for null and size

 Iterator&lt;String[]&gt; iteList1 = list1.iterator();
 Iterator&lt;String[]&gt; iteList2 = list2.iterator();

 while(iteList1.hasNext()) {
 if(!Arrays.equals(iteList1.next(), iteList2.next())) {
 return false;
 }
 }
 return true;
}
</code></pre>

blocks|key|2671954|text|使用https://stackoverflow.com/a/23529010/755183中的zip+(源自lambda+b93)函数，代码可能如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2671955|boolean+match+=+a.size()+==+b.size()+&&+
++++++++++++++++zip(a.stream(),+b.stream(),+Arrays::deepEquals).
++++++++++++++++allMatch(equal+->+equal)|code-block|syntax|javascript|2671956|更新|2671957|为了先检查数组的大小，然后再检查内容，这可能是一个需要考虑的解决方案|2671958|final+boolean+match+=+a.size()+==+b.size()+
+++++++++++++++++++&&+zip(a.stream(),+b.stream(),+(as,+bs)+->+as.length+==+bs.length).
++++++++++++++++++++++allMatch(equal+->+equal)
+++++++++++++++++++&&+zip(a.stream(),+b.stream(),+Arrays::deepEquals).
++++++++++++++++++++++allMatch(equal+->+equal);|2671959|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/23529010/755183^0|1B|3|2|17|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

using <code>zip</code> (which originates from lambda b93) function from <a href="https://stackoverflow.com/a/23529010/755183">https://stackoverflow.com/a/23529010/755183</a>, code could look like:

<pre><code>boolean match = a.size() == b.size() &amp;&amp; 
 zip(a.stream(), b.stream(), Arrays::deepEquals).
 allMatch(equal -&gt; equal)
</code></pre>

<h2>update</h2>

in order to check size of arrays first and then content this could be a solution to consider

<pre><code>final boolean match = a.size() == b.size() 
 &amp;&amp; zip(a.stream(), b.stream(), (as, bs) -&gt; as.length == bs.length).
 allMatch(equal -&gt; equal)
 &amp;&amp; zip(a.stream(), b.stream(), Arrays::deepEquals).
 allMatch(equal -&gt; equal);
</code></pre>

blocks|key|2671975|text|1)基于Java8+streams的解决方案：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2671976|List<List<String>>+first+=+list1.stream().map(Arrays::asList).collect(toList());
List<List<String>>+second+=+list2.stream().map(Arrays::asList).collect(toList());
return+first.equals(second);|code-block|syntax|javascript|2671977|Java+2)更简单的解决方案(适用于+5%2B)：|2671978|return+Arrays.deepEquals(list1.toArray(),+list2.toArray());|2671979|3)关于您的新需求(为了首先检查包含的字符串数组长度)，您可以编写一个泛型帮助器方法，对转换后的列表执行相等性检查：|2671980|<T,+U>+boolean+equal(List<T>+list1,+List<T>+list2,+Function<T,+U>+mapper)+{
++++List+first+=+list1.stream().map(mapper).collect(toList());
++++List+second+=+list2.stream().map(mapper).collect(toList());
++++return+first.equals(second);
}|2671981|那么解决方案可能是：|2671982|return+equal(list1,+list2,+s+->+s.length)
++++&&+equal(list1,+list2,+Arrays::asList);|2671983|entityMap^0|0|I|0|0|J|5|0|0|0|1M|0|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|X|$]]

1) Solution based on Java 8 streams:

<pre><code>List&lt;List&lt;String&gt;&gt; first = list1.stream().map(Arrays::asList).collect(toList());
List&lt;List&lt;String&gt;&gt; second = list2.stream().map(Arrays::asList).collect(toList());
return first.equals(second);
</code></pre>

2) Much simpler solution (works in Java 5+):

<pre><code>return Arrays.deepEquals(list1.toArray(), list2.toArray());
</code></pre>

3) Regarding your new requirement (to check the contained String arrays length first), you could write a generic helper method that does equality check for transformed lists:

<pre><code>&lt;T, U&gt; boolean equal(List&lt;T&gt; list1, List&lt;T&gt; list2, Function&lt;T, U&gt; mapper) {
 List&lt;U&gt; first = list1.stream().map(mapper).collect(toList());
 List&lt;U&gt; second = list2.stream().map(mapper).collect(toList());
 return first.equals(second);
}
</code></pre>

Then the solution could be:

<pre><code>return equal(list1, list2, s -&gt; s.length)
 &amp;&amp; equal(list1, list2, Arrays::asList);
</code></pre>

blocks|key|2883221|text|您可以使用迭代器在一个列表上进行流式传输，并与另一个列表中的每个元素进行比较：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2883222|Iterator<String[]>+it+=+list1.iterator();
boolean+match+=+list1.size()+==+list2.size()+&&
++++++++++++++++list2.stream().allMatch(a+->+Arrays.equals(a,+it.next()));|code-block|syntax|javascript|2883223|在第一个列表上使用迭代器而不是get(index)方法更好，因为列表是否为RandomAccess并不重要。|offset|length|style|CODE|2883224|注意:这只适用于顺序流。使用并行流将导致错误的结果。|2883225|2883226|编辑:根据上次编辑的问题，提前检查每一对数组的长度会更好，我认为只要稍微修改一下我之前的代码就可以实现：|2883227|Iterator<String[]>+itLength+=+list1.iterator();
Iterator<String[]>+itContents+=+list1.iterator();

boolean+match+=+
++++++++list1.size()+==+list2.size()
++++&&+
++++++++list2.stream()
++++++++++++.allMatch(a+->+{
++++++++++++++++String[]+s+=+itLength.next();
++++++++++++++++return+s+==+null+?+a+==+null+:
+++++++++++++++++++++++a+==+null+?+s+==+null+:
+++++++++++++++++++++++a.length+==+s.length;
++++++++++++})
++++&&+
++++++++list2.stream()
++++++++++++.allMatch(a+->+Arrays.equals(a,+itContents.next()));|2883228|在这里，我使用了两个迭代器，并流式传输了两次list2，但在检查第一对数组的内容之前，我看不到其他方法来检查所有长度。检查长度是空安全的，而检查内容则委托给Arrays.equals(array1,+array2)方法。|2883229|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#equals-java.lang.Object:A-java.lang.Object:A-^0|0|0|F|A|11|C|0|0|0|0|0|M|5|26|T|26|T|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@$I|16|J|17|K|L]|$I|18|J|19|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1C|8|@]|9|@]|A|$]]|$1|R|3|S|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|T|3|U|5|6|7|1E|8|@$I|1F|J|1G|K|L]|$I|1H|J|1I|K|L]]|9|@$I|1J|J|1K|1|1L]]|A|$]]|$1|V|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]]]

You could stream over one list and compare to each element of the other by using an iterator:

<pre><code>Iterator&lt;String[]&gt; it = list1.iterator();
boolean match = list1.size() == list2.size() &amp;&amp;
 list2.stream().allMatch(a -&gt; Arrays.equals(a, it.next()));
</code></pre>

Using an iterator instead of the <code>get(index)</code> method on the first list is better because it doesn't matter whether the list is <code>RandomAccess</code> or not.

Note: this only works with a sequential stream. Using a parallel stream will lead to wrong results.

<hr>

EDIT: As per the question last edit, which indicates it would be better to check the length of every pair of arrays in advance, I think it could be achieved with a slight modification to my previous code:

<pre><code>Iterator&lt;String[]&gt; itLength = list1.iterator();
Iterator&lt;String[]&gt; itContents = list1.iterator();

boolean match = 
 list1.size() == list2.size()
 &amp;&amp; 
 list2.stream()
 .allMatch(a -&gt; {
 String[] s = itLength.next();
 return s == null ? a == null :
 a == null ? s == null :
 a.length == s.length;
 })
 &amp;&amp; 
 list2.stream()
 .allMatch(a -&gt; Arrays.equals(a, itContents.next()));
</code></pre>

Here I'm using two iterators and am streaming <code>list2</code> twice, but I see no other way to check all lengths before checking the contents of the first pair of arrays. Check for lengths is null-safe, while check for contents is delegated to the <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#equals-java.lang.Object:A-java.lang.Object:A-" rel="nofollow"><code>Arrays.equals(array1, array2)</code></a> method.

I have two lists of arrays. 

How do I easily compare equality of these with Java 8 and its features, without using external libraries? I am looking for a "better" (higher-level, shorter, more efficient) solution than brute-force code like this (untested code, may contain typos etc, not the point of the question):

<pre><code>boolean compare(List&lt;String[]&gt; list1, List&lt;String[]&gt; list2) 
{
 // tests for nulls etc omitted
 if(list1.size() != list2.size()) {
 return false;
 }
 for(i=0; i&lt;list1.size(); ++i) {
 if(!Arrays.equals(list1.get(i), list2.get(i))) {
 return false;
 }
 }
 return true;
}
</code></pre>

Or, if there isn't any nicer way, that's a valid answer too.

Bonus: If Java 9 offers an even better way what whaterver Java 8 can offer, feel free to mention it as well.

Edit: After looking at the comments, and seeing how this question has become moderately hot, I think the "better" should include first checking lengths of all arrays, before checking array contents, because that has potential to find inequality much quicker, if inner arrays are long.

How to compare equality of lists of arrays with modern Java?

Java

我有两个数组列表。在不使用外部库的情况下，我如何轻松地将这些与Java 8及其特性的等价性进行比较？我正在寻找一个“更好的”(更高级别，更短，更高效)的解决方案，而不是像这样的暴力代码(未经测试的代码，可能包含打字错误等，不是问题的重点)：boolean compare(List<String[]> list1, Li...

问如何将数组列表的相等性与现代Java进行比较？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将数组列表的相等性与现代Java进行比较？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将数组列表的相等性与现代Java进行比较？
EN