stream方法获取指向当前Collection对象的流对象，filter将对流中元素进行过滤，结合lambda表达式，需要在filter参数中实现一个类似于比较器的Predicate对象，返回一个boolean类型返回值，只有返回为true的Collection中的元素才会进入到forEach的循环中。
 

List<String> strArr = Arrays.asList("21", "22", "3", "4");
 
        strArr.stream().filter(str ->{
            return str.startsWith("2");
        }).filter(str ->{
            return str.equals("22");
        }).forEach(str ->{
            System.out.println(str);
        });

 使用collect将stream转化为list

List<String> result1 = lines.stream()  // convert list to stream
        .filter(line -> !"mkyong".equals(line)) // filter the line which equals to "mkyong"
        .collect(Collectors.toList());  // collect the output and convert streams to a list
 
    result1.forEach(System.out::println); // o

Stream.distinct()  :字符串去重

 List<String> list = Arrays.asList("AA", "BB", "CC", "BB", "CC", "AA", "AA");
        long l = list.stream().distinct().count();
        System.out.println("No. of distinct elements:"+l);
        String output = list.stream().distinct().collect(Collectors.joining(","));
        System.out.println(output);

2. Stream.distinct() with List of Objects

在此示例中，我们有一个Book对象列表。 为了对列表进行去重，该类将重写hashCode（）和equals（）。

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;
    }
} 

List<Book> list = new ArrayList<>();
        {
           list.add(new Book("Core Java", 200));
           list.add(new Book("Core Java", 200));
           list.add(new Book("Learning Freemarker", 150));        	
           list.add(new Book("Spring MVC", 300));
           list.add(new Book("Spring MVC", 300));
        }
        long l = list.stream().distinct().count();
        System.out.println("No. of distinct books:"+l);
        list.stream().distinct().forEach(b -> System.out.println(b.getName()+ "," + b.getPrice()));

3. Distinct by Property

distinct（）不提供按照属性对对象列表进行去重的直接实现。它是基于hashCode（）和equals（）工作的。如果我们想要按照对象的属性，对对象列表进行去重，我们可以通过其它方法来实现。如下代码段所示：

static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}

上面的方法可以被Stream接口的 filter()接收为参数，如下所示：

list.stream().filter(distinctByKey(b -> b.getName()));

distinctByKey()方法返回一个使用ConcurrentHashMap 来维护先前所见状态的 Predicate 实例，如下是一个完整的使用对象属性来进行去重的示例。

public class DistinctByProperty {
    public static void main(String[] args) {
        List<Book> list = new ArrayList<>();
        {
        	list.add(new Book("Core Java", 200));
        	list.add(new Book("Core Java", 300));
        	list.add(new Book("Learning Freemarker", 150));
        	list.add(new Book("Spring MVC", 200));
        	list.add(new Book("Hibernate", 300));
        }
        list.stream().filter(distinctByKey(b -> b.getName()))
              .forEach(b -> System.out.println(b.getName()+ "," + b.getPrice()));   
    }
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
}