Java合并流并保留唯一元素

合并数字和字符串流

在合并两个流时，我们可以使用 distinct() API，结果流将只包含唯一的元素。

import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Main 
{
	public static void main(String[] args) 
	{
		Stream<Integer> firstStream = Stream.of(1, 2, 3, 4, 5, 6);
		Stream<Integer> secondStream = Stream.of(4, 5, 6, 7, 8, 9);
		Stream<Integer> resultingStream = Stream.concat(firstStream, secondStream)
												.distinct();
		System.out.println( resultingStream.collect(Collectors.toList()) );
	}
}

Java 合并自定义对象流

在合并自定义对象流的情况下，我们可以在流迭代期间删除重复的元素。

我们可以使用为 java 流创建的 distinctByKey() 函数根据对象的属性进行区分。

import java.util.ArrayList;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Main 
{
	public static void main(String[] args) 
	{
		Stream<Employee> stream1 = getEmployeeListOne().stream();
		Stream<Employee> stream2 = getEmployeeListTwo().stream();

		Stream<Employee> resultingStream = Stream.concat(stream1, stream2)
				.filter(distinctByKey(Employee::getFirstName));

		System.out.println( resultingStream.collect(Collectors.toList()) );
	}

	public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor)
	{
	    Map<Object, Boolean> map = new ConcurrentHashMap<>();
	    return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
	}
	private static ArrayList<Employee> getEmployeeListOne() 
	{
		ArrayList<Employee> list = new ArrayList<>();
		list.add( new Employee(1l, "JackLi", "Gupta") );
		list.add( new Employee(5l, "BobRobert", "Piper") );
		list.add( new Employee(7l, "Lucie", "Piper") );
		list.add( new Employee(6l, "Tomm", "Beckham") );
        return list;
	}

	private static ArrayList<Employee> getEmployeeListTwo() 
	{
		ArrayList<Employee> list = new ArrayList<>();
		list.add( new Employee(2l, "JackLi", "Gupta") );
		list.add( new Employee(4l, "BobRobert", "Piper") );
		list.add( new Employee(3l, "Tomm", "Beckham") );
        return list;
	}
}

用 Stream.concat() 方法用于将两个流合并为一个流，该流由两个被合并流的所有元素组成。

Java合并多个流 示例

import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.util.stream.Stream.*;
public class Main 
{
	public static void main(String[] args) 
	{
		Stream<Integer> first = Stream.of(1, 2);
	    Stream<Integer> second = Stream.of(3,4);
	    Stream<Integer> third = Stream.of(5, 6);
	    Stream<Integer> fourth = Stream.of(7,8);

	    Stream<Integer> resultingStream = Stream.concat(first, concat(second, concat(third, fourth)));

	    System.out.println( resultingStream.collect(Collectors.toList()) );
	}
}

Java 合并两个流示例

import java.util.stream.Stream;
public class Main 
{
	public static void main(String[] args) 
	{
		Stream<Integer> firstStream = Stream.of(1, 2, 3);
	    Stream<Integer> secondStream = Stream.of(4, 5, 6);

	    Stream<Integer> resultingStream = Stream.concat(firstStream, secondStream);

	    System.out.println( resultingStream.collect(Collectors.toList()) );
	}
}

Stream concat()方法

static <T> Stream<T> concat(Stream<? extends T> firstStream,
                            Stream<? extends T> secondStream)

• 此方法创建一个延迟连接的流，其元素是 firstStream 的所有元素，后跟 secondStream 的所有元素。
• 如果两个输入流都是有序的，则结果流是有序的。
• 如果任一输入流是并行的，则结果流是并行的。
• 当结果流被关闭时，两个输入流的关闭处理程序都会被调用。