使用java8特性：stream与lambda 完成对数组排序、并集、差集、去重操作

1、概念

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

 

Stream的作用就是通过一系列操作将数据源（集合、数组）转化为想要的结果。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

Stream（流）是一个来自数据源的元素队列并支持聚合操作

• 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
• 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。
• 通过访问者模式实现内部迭代（for循环或者迭代器迭代是外部迭代）

2、语法

Lambda语法：(parameters) -> expression 或 (parameters) ->{ statements; }

示例：

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)



    //示例
    public static void main(String args[]) {
        final int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
        s.convert(2);  // 输出结果为 3
    }
 
    public interface Converter<T1, T2> {
        void convert(int i);
    }

• stream() − 为集合创建串行流。

• parallelStream() − 为集合创建并行流。

    //过滤空串
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

    //forEach 与 limit
    //Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。以下代码片段使用 forEach、limit 输出了10个随机数
    Random random = new Random();
    random.ints().limit(10).forEach(System.out::println);

    //map
    //map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：    
    List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
    // 获取对应的平方数
    List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

    //filter
    //filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：
    List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    // 获取空字符串的数量
    long count = strings.stream().filter(string -> string.isEmpty()).count();

    //sorted
    //sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：
    Random random = new Random();
    random.ints().limit(10).sorted().forEach(System.out::println);

    //并行（parallel）程序
    //parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    // 获取空字符串的数量
    int count = strings.parallelStream().filter(string -> string.isEmpty()).count();

    //Collectors
    //Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
    List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    List<String> filtered = strings.stream().filter(string ->     !string.isEmpty()).collect(Collectors.toList());
    System.out.println("筛选列表: " + filtered);
    String mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
    System.out.println("合并字符串: " + mergedString);

    //统计
    //另外，一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。
    List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
    IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
    System.out.println("列表中最大的数 : " + stats.getMax());
    System.out.println("列表中最小的数 : " + stats.getMin());
    System.out.println("所有数之和 : " + stats.getSum());
    System.out.println("平均数 : " + stats.getAverage());

3、实例

     3.1需求整理

     存在一个对象C，对象有字段d、字段e、字段f与其他字段。

class C {
    private int d;
    private int e;
    private int f;
    private int qt;//其他

    //set get方法 构造方法。。。
}

     现在规定 C(d1,e1,f1) 与C(d1,f1,e1)相等

     需求：

     1、对一组List集合L1中C1、C2、C3.。。进行去重。

     2、对两组 List<C> L1 与 List<C> L2 取差集（L1-L2）。

     3.2 需求分析

     在java8特性之前大家处理这种需求大多是遍历+判断取去重与差集。这种方式比较繁琐，效率也比较差。

     如何灵活运用工具对日常开发非常重要。废话不多提，下边进入正题。

     网上对Lambda与stream的运用大多是对int集合、double集合等基本数据类型的集合进行处理。对于复杂的类集合的处理比较少。首先我们需要知道Lambda与stream能够对比、排序等操作是基于实体类的hashcode进行统计的。

     由于需求中 C(d1,e1,f1) 与C(d1,f1,e1)是相等的，所以我们需要重写实体类的hashcode于equels方法，然后使用stream与Lambda完成我们的需求。

     3.3 需求开发

          3.3.1重写实体类的hashcode与equels方法

class C {
    private int d;
    private int e;
    private int f;
    private int qt;//其他

    //set get方法 构造方法。。。
	
        //重写hashCode、equals
        @Override
	public int hashCode() {
                //此写法避免空指针
		int hashCode = 30;
	    	int a = e;
	    	int b = f;
	        if(e>f){
	    	    a = f;
	    	    b = e;
	    	}
	        hashCode = (hashCode << 5) - hashCode + d;
	        hashCode = (hashCode << 5) - hashCode + a;
	        hashCode = (hashCode << 5) - hashCode + b;
	        return hashCode;
	}
	@Override
	public boolean equals(Object obj) {
                C c1 = (C) obj;
		return this.d==c1.d&&((this.e==c1.e&&this.f==c1.f)||(this.e==c1.f&&this.f==c1.e));
	}
}

          3.3.2 实现去重和取差集

 //对一组List集合L1中C1、C2、C3.。。进行去重
 //L3去重后的集合、使用java8 Stream特性去重  重写了实体类equals和hashcode
 List<C> L3 = L1.stream().distinct().collect(Collectors.toList());


 //对两组 List<C> L1 与 List<C> L2 取差集（L1-L2）
 //L4处理好的差集 使用java8 Stream特性和lambda取差集
 List<C> L4 = L1.stream().filter(item -> !L2.contains(item)).collect(toList());