Java8 Streams-比较两个List的对象值并将值添加到新的List? [英] Java8 Streams - Compare two List's object values and add value to new List?
问题描述
我有两个包含此类对象的列表:
I have two Lists containing objects of this class:
public class SchoolObj
{
private String name;
private String school;
public SchoolObj()
{
this(null, null);
}
public SchoolObj(String nameStr, String schoolStr)
{
this.setName(nameStr);
this.setSchool(schoolStr);
}
public String getName()
{
return this.name;
}
public void setName(String name)
{
this.name = name;
}
public String getSchool()
{
return this.school;
}
public void setSchool(String school)
{
this.school = school;
}
@Override
public String toString()
{
return this.getName() + ' ' + this.getSchool();
}
}
我想通过name和school比较这两个列表中的对象.如果它们相等，则需要创建一个新的List，其中包含在两个列表中都找到的SchoolObj对象.
I want to compare the objects in those two lists by name and school. If they are equal I need to create a new List containing those SchoolObj objects which are found in both Lists.
我知道我们可以使用两个for循环，并且可以在下面的createSharedListViaLoop方法中进行.
I know we can use two for loops and do it is in the createSharedListViaLoop method below.
我的问题是，如何用Java流完成相同的事情?
My question is, how can I accomplish the same thing with Java streams?
我在下面尝试过createSharedListViaStream，但是它没有按预期工作.
I tried with createSharedListViaStream below, but it is not working as expected.
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class StreamTest
{
public static void main(String[] args)
{
List<SchoolObj> listOne = new ArrayList<SchoolObj>();
// TODO: Add sample data to listOne.
listOne.add(new SchoolObj("nameA", "schoolX"));
listOne.add(new SchoolObj("nameC", "schoolZ"));
List<SchoolObj> listTwo = new ArrayList<SchoolObj>();
// TODO: Add sample data to listTwo.
listTwo.add(new SchoolObj("nameA", "schoolX"));
listTwo.add(new SchoolObj("nameB", "schoolY"));
// Print results from loop method.
System.out.println("Results from loop method:");
List<SchoolObj> resultsViaLoop = StreamTest.createSharedListViaLoop(listOne, listTwo);
for (SchoolObj obj : resultsViaLoop)
{
System.out.println(obj);
}
// Print results from stream method.
System.out.println("Results from stream method:");
List<SchoolObj> resultsViaStream = StreamTest.createSharedListViaStream(listOne, listTwo);
for (SchoolObj obj : resultsViaStream)
{
System.out.println(obj);
}
}
public static List<SchoolObj> createSharedListViaLoop(List<SchoolObj> listOne, List<SchoolObj> listTwo)
{
List<SchoolObj> result = new ArrayList<SchoolObj>();
for (SchoolObj one : listOne)
{
for (SchoolObj two : listTwo)
{
if (one.getName().equals(two.getName()) && one.getSchool().equals(two.getSchool()))
{
result.add(one);
}
}
}
return result;
}
public static List<SchoolObj> createSharedListViaStream(List<SchoolObj> listOne, List<SchoolObj> listTwo)
{
List<SchoolObj> listOneList = listOne.stream().filter(two -> listTwo.stream()
.anyMatch(one -> one.getName().equals(two.getName()) && two.getSchool().equals(one.getSchool())))
.collect(Collectors.toList());
return listOneList;
}
}
推荐答案
让我们遍历代码的每个部分.首先，createSharedListViaStream:
Let's run through each part of the code. First, createSharedListViaStream:
public static List<SchoolObj> createSharedListViaStream(List<SchoolObj> listOne, List<SchoolObj> listTwo)
{
// We create a stream of elements from the first list.
List<SchoolObj> listOneList = listOne.stream()
// We select any elements such that in the stream of elements from the second list
.filter(two -> listTwo.stream()
// there is an element that has the same name and school as this element,
.anyMatch(one -> one.getName().equals(two.getName())
&& two.getSchool().equals(one.getSchool())))
// and collect all matching elements from the first list into a new list.
.collect(Collectors.toList());
// We return the collected list.
return listOneList;
}
运行完代码后，它会完全按照您想要的去做.现在，让我们来看一下createSharedListViaLoop:
After running through the code, it does exactly what you want it to do. Now, let's run through createSharedListViaLoop:
public static List<SchoolObj> createSharedListViaLoop(List<SchoolObj> listOne, List<SchoolObj> listTwo)
{
// We build up a result by...
List<SchoolObj> result = new ArrayList<SchoolObj>();
// going through each element in the first list,
for (SchoolObj one : listOne)
{
// going through each element in the second list,
for (SchoolObj two : listTwo)
{
// and collecting the first list's element if it matches the second list's element.
if (one.getName().equals(two.getName()) && one.getSchool().equals(two.getSchool()))
{
result.add(one);
}
}
}
// We return the collected list
return result;
}
到目前为止，太好了...对吗?实际上，您在createSharedListViaStream中的代码从根本上是正确的.相反，可能是您的createSharedListViaLoop可能导致输出差异.
So far, so good... right? In fact, your code in createSharedListViaStream is fundamentally correct; instead, it is your createSharedListViaLoop that may be causing discrepancies in output.
请考虑以下输入设置:
List1 = [SchoolObj("nameA","SchoolX"), SchoolObj("nameC","SchoolZ")]
List2 = [SchoolObj("nameA","SchoolX"), SchoolObj("nameA","SchoolX"), SchoolObj("nameB","SchoolY")]
Think about the following set of inputs:
List1 = [SchoolObj("nameA","SchoolX"), SchoolObj("nameC","SchoolZ")]
List2 = [SchoolObj("nameA","SchoolX"), SchoolObj("nameA","SchoolX"), SchoolObj("nameB","SchoolY")]
在这里，createSharedListViaStream将返回出现在两个列表中的第一个列表的唯一元素:SchoolObj("nameA","SchoolX").但是，createSharedListViaLoop将返回以下列表:[SchoolObj("nameA","SchoolX"),SchoolObj("nameA","SchoolX")].更准确地说，createSharedListViaLoop将收集正确的对象，但是它将收集两次.我怀疑这是基于与createSharedListViaLoop的输出进行比较而导致createSharedListViaStream的输出为不正确"的原因.
Here, createSharedListViaStream will return the only element of the first list that appears in both lists: SchoolObj("nameA","SchoolX"). However, createSharedListViaLoop will return the following list: [SchoolObj("nameA","SchoolX"),SchoolObj("nameA","SchoolX")]. More precisely, createSharedListViaLoop will collect the correct object, but it will do so twice. I suspect this to be the reason for the output of createSharedListViaStream to be "incorrect" based on comparison to the output of createSharedListViaLoop.
createSharedListViaLoop进行此复制的原因是由于其内部for循环缺少终止.尽管我们遍历第一个列表的所有元素以检查第二个列表中是否存在这些元素，但是找到单个匹配项足以将元素添加到结果中.我们可以通过将内部循环更改为以下内容来避免添加多余的元素:
The reason that createSharedListViaLoop does this duplication is based on the lack of termination of its inner for loop. Although we iterate over all elements of the first list to check if they are present in the second, finding a single match will suffice to add the element to the result. We can avoid redundant element addition by changing the inner loop to the following:
for (SchoolObj one : listOne)
{
for (SchoolObj two : listTwo)
{
if (one.getName().equals(two.getName()) && one.getSchool().equals(two.getSchool()))
{
result.add(one);
break;
}
}
}
此外，如果您不想在列表中重复对象(按内存中的位置)，则可以使用
Additionally, if you don't want duplicate Objects in your list (by location in memory), you can use distinct like so:
List<SchoolObj> result = ...;
result = result.stream().distinct().collect(Collectors.toList());
作为最后的警告，在以下情况下，以上内容将使结果与众不同:
As a final caution, the above will keep the results distinct in the following scenario:
List<SchoolObj> list = new ArrayList<>();
SchoolObj duplicate = new SchoolObj("nameC", "schoolD");
listOne.add(duplicate);
listOne.add(duplicate);
list.stream().distinct().forEach(System.out::println);
// prints:
// nameC schoolD
However, it will not work in the following scenario, unless you override the equals method for SchoolObj:
List<SchoolObj> list = new ArrayList<>();
listOne.add(new SchoolObj("nameC", "schoolD"));
listOne.add(new SchoolObj("nameC", "schoolD"));
list.stream().distinct().forEach(System.out::println);
// prints (unless Object::equals overridden)
// nameC schoolD
// nameC schoolD
这篇关于Java8 Streams-比较两个List的对象值并将值添加到新的List?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
