Java 8 Concat Streams, Lists, Sets, Arrays詳解

Stream提供concat（）方法來連接配接兩個流并傳回一個流。 要連接配接Lists，Sets和Arrays，我們首先将它們轉換為流，然後使用concat（）将它們組合起來。 可以使用收集器的方法将輸出流轉換為List，Set等，例如toList（），toSet（）等。

static <T> Stream<T> concat(
Stream<? extends T> a, Stream<? extends T> b)            

concat（）建立延遲連接配接流。 此流包含第一個流的所有元素，後跟第二個流的所有元素。 如果訂購了兩個輸入流，則将對所得到的流進行排序。 如果兩個流中的任何一個是平行的，則得到的流将是平行的。

import java.util.stream.Stream;
public class ConcatStreamsDemo {
    public static void main(String[] args) {
        Stream<String> s1 = Stream.of("AA", "BB", "CC");
        Stream<String> s2 = Stream.of("AA", "BB", "DD");
        Stream<String> s = Stream.concat(s1, s2);
        s.forEach(e->System.out.print(e+" "));
        //Remove duplicates using distinct()
        s1 = Stream.of("AA", "BB", "CC");
        s2 = Stream.of("AA", "BB", "DD");
        System.out.println("\nRemove duplicates using distinct()");
        s = Stream.concat(s1, s2).distinct();
        s.forEach(e->System.out.print(e+" "));
    }
}           

輸出：

AA BB CC AA BB DD 
Remove duplicates using distinct()
AA BB CC DD            

Concat Lists

在這個例子中，我們有兩個清單。 這些清單将轉換為流，然後使用concat（）方法連接配接它們。 輸出流将使用Collectors.toList（）轉換為List。 獲得不同的元素

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class ConcatListsDemo {
    public static void main(String[] args) {
        List<Book> list1 = new ArrayList<>();
        List<Book> list2 = new ArrayList<>();
        {
           list1.add(new Book("Core Java", 200));
           list1.add(new Book("Spring MVC", 300));
           list1.add(new Book("Learning Freemarker", 150));  
           
           list2.add(new Book("Core Java", 200));
           list2.add(new Book("Spring MVC", 300));
           list2.add(new Book("Learning Hibernate", 400));            
        }
        List<Book> list = Stream.concat(list1.stream(), list2.stream()).collect(Collectors.toList());
        list.forEach(b->System.out.println(b.getName()+", "+ b.getPrice()));
        
        //Remove duplicates using distinct()
        System.out.println("--Remove duplicates using distinct()--");
        list = Stream.concat(list1.stream(), list2.stream()).distinct().collect(Collectors.toList());
        list.forEach(b->System.out.println(b.getName()+", "+ b.getPrice()));        
    }
}            

public class Book {
    private String name;
    private int price;
    public Book(String name, int price) {
    this.name = name;
    this.price = price;
    }
    public String getName() {
  return name;
    }
    public int getPrice() {
  return price;
    }
    @Override
    public boolean equals(final Object obj) {
      if (obj == null) {
         return false;
      }
      final Book book = (Book) obj;
      if (this == book) {
         return true;
      } else {
         return (this.name.equals(book.name) && 
                 this.price == book.price);
      }
    }
    @Override
    public int hashCode() {
      int hashno = 7;
      hashno = 13 * hashno + (name == null ? 0 : 
                              name.hashCode());
      return hashno;
    }
}           

Core Java, 200
Spring MVC, 300
Learning Freemarker, 150
Core Java, 200
Spring MVC, 300
Learning Hibernate, 400
--Remove duplicates using distinct()--
Core Java, 200
Spring MVC, 300
Learning Freemarker, 150
Learning Hibernate, 400            

Concat Arrays

這些數組将轉換為流，然後使用concat（）方法連接配接它們。 輸出流将使用Stream.toArray（）轉換為數組。 獲得不同的元素

import java.util.stream.Stream;
public class ConcatArraysDemo {
    public static void main(String[] args) {
        Book[] bk1 = new Book[3];
        Book[] bk2 = new Book[3];        
        {
           bk1[0] = new Book("Core Java", 200);
           bk1[1] = new Book("Spring MVC", 300);
           bk1[2] = new Book("Learning Freemarker", 150);          
           bk2[0] = new Book("Core Java", 200);
           bk2[1] = new Book("Spring MVC", 300);
           bk2[2] = new Book("Learning Hibernate", 400);           
        }
        Book[] bks = (Book[]) Stream.concat(Stream.of(bk1), 
                      Stream.of(bk2)).toArray(b -> new Book[b]);
        for(Book b : bks) {
          System.out.println(b.getName()+", "+ b.getPrice());
        }
    
        //Remove duplicates using distinct()
        System.out.println("--Remove duplicates using distinct()--");
        bks = (Book[]) Stream.concat(Stream.of(bk1), Stream.of(bk2)).distinct().toArray(b -> new Book[b]);
        for(Book b : bks) {
          System.out.println(b.getName()+", "+ b.getPrice());
        }
    }
}           

Core Java, 200
Spring MVC, 300
Learning Freemarker, 150
Core Java, 200
Spring MVC, 300
Learning Hibernate, 400
--Remove duplicates using distinct()--
Core Java, 200
Spring MVC, 300
Learning Freemarker, 150
Learning Hibernate, 400            

Concat Sets

這些集合将轉換為流，然後使用concat（）方法連接配接它們。 輸出流将使用Collectors.toSet（）轉換為Set。

import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class ConcatSetsDemo {
    public static void main(String[] args) {
        Set<Book> set1 = new HashSet<>();
        Set<Book> set2 = new HashSet<>();
        {
           set1.add(new Book("Core Java", 200));
           set1.add(new Book("Spring MVC", 300));
           set1.add(new Book("Learning Freemarker", 150));  
           
           set2.add(new Book("Core Java", 200));
           set2.add(new Book("Spring MVC", 300));
           set2.add(new Book("Learning Hibernate", 400));           
        }
        Set<Book> set = Stream.concat(set1.stream(), set2.stream()).collect(Collectors.toSet());
        set.forEach(b->System.out.println(b.getName()+", "+ b.getPrice()));
    }
}            

Spring MVC, 300
Learning Freemarker, 150
Learning Hibernate, 400
Core Java, 200