JAVA8 lambda表达式深度解析！

JAVA8 lambda关系式权威性实例教程！

Java 8新特点—-Stream流

jdk8是Java 语言表达开发设计的一个关键版本号，它适用函数式编程，新的 JavaScript 模块，新的日期 API，新的Stream API 这些。今日就关键详细介绍一个十分关键得特点之一 lambda关系式

一：什么叫 Stream？

Stream（流）是一个来源于数据库的原素序列并适用汇聚实际操作

Java中的Stream并不会储存原素，只是按需测算。 数据库 流的来源于。 能够 是结合，二维数组，I/O channel， 发生器generator 等。

汇聚实际操作 相近SQL句子一样的实际操作， 例如filter, map, reduce, find, match, sorted等。 和之前的Collection实际操作不一样，Stream实际操作也有2个基本的特点以下：

• Pipelining: 正中间实际操作都是会回到流目标自身。 那样好几个实际操作能够 串连成一个管路， 好似流式的设计风格。 那样做能够 对实际操作开展提升， 例如延迟时间实行和短路故障。

• 內部迭代更新： 之前对结合解析xml全是根据Iterator或是For-Each的方法, 显式的在结合外界开展迭代更新， 这叫>做外界迭代更新。 Stream给予了內部迭代更新的方法， 根据访问者模式(Visitor)完成。

二：Stream API 应用

1:应用Stream流程：

(1)先造成一个流(Stream)一个数据库，获得一个流。

(2)正中间链条式实际操作 一个正中间的实际操作链，对数据库的数据信息开展解决。

(3)造成一个新流：一个停止实际操作，实行正中间实际操作，造成結果。

留意：Stream实际操作是延迟时间实行，她们会等必须結果的情况下才会实行。

汇总：

• 正中间实际操作常见方式 有：挑选：filter 投射：map 排列：sorted获取与组成 搜集：collect。

• 停止实际操作：解析xml：foreach 配对：find、match 通信规约：reduce 汇聚：max、min、count。

2:建立Stream的方式 的4种方法

    【1】Collection插口中的方式 ：
        default Stream<E> stream()  获得串行通信流
        default Stream<E> parallelStream() 获得并行处理流
      实例：

//方法1：Collection插口的方式 
Collection collection = new ArrayList();
Stream stream = collection.stream();
Stream stream1 = collection.parallelStream();

//方法2：根据Arrays中的Stream方式   二维数组
IntStream stream2 = Arrays.stream(new int[]{1, 2, 3, 4, 5});

//方法3：Stream中的of方式 
Stream<String> stream3 = Stream.of("111", "222", "333");

//方法4：Stream中的方式   建立无cp  （結果是无线网络个）
Stream<Integer> iterate = Stream.iterate(2, (x) -> x   2);
        

3:正中间实际操作

1:挑选与切成片

① Stream filter(Predicate<?super T> predicate)回到由与此给出谓词配对的此流的元素组成的流。 —>接受Lambda，从流中清除一些原素。

 //1：建立Stream;
  Stream<Student> stream = list.stream();

 //2：filter方法（寻找年纪高于或等于18岁的学员）
 Stream<Student> studentStream = stream.filter((student) -> student.getAge() >= 18);

  //3：停止实际操作;要是没有停止实际操作得话，上边的第二步正中间实际操作不实行
   studentStream.forEach(System.out::println);
   /**
    * 留意：假如值实行1,2实际操作得话，不容易有一切結果。
    * 认证出Steam实际操作是延迟时间的，仅有开展了停止实际操作，才会实行正中间实际操作！这就是说白了的延迟时间载入
*/

②Stream limit(Long maxSize) 回到由该流的元素组成的流，断开长短不可以超出maxSize. 仅有寻找maxSize个符合条件的就可以。 —->断开流，使其原素不超过给出的总数。

  public void limitTest02() {
        //Limit方式  短路故障(高效率提高)，只需找到两个符合条件的，后边的迭代更新实际操作就没有实行了！
        list.stream().filter(x -> {
            System.out.println("已经过虑！！");
            return x.getAge() > 18;
        }).limit(2).forEach(System.out::println);
    }

③Stream skip(Long n) 在丢弃流的第一个n元素后，回到由该流的n元素构成的流，假如此流包括低于n元素，那麼将回到一个空流。 —->绕过原素，回到一个丢掉了前n个原素的流。 假如流中的原素不够n个，则回到一个空流，与limit(n)相辅相成。

public void skipTest03() {
     //skip 方式 绕过前两个符合条件的  留有后边符合条件的結果！！
     list.stream().filter(x -> {
         System.out.println("已经过虑后边符合条件的結果");
         return x.getAge() > 18;
     }).skip(2).forEach(System.out::println);
 }

④Stream distinct()

留意： 自定的类在去重复的全过程中务必重新hashCode和equals方式 ，由于distinct完成的情况下最底层去找这两个方式 。

 public void distinctTest04() {
   //distinct 去重复实际操作！
       list.stream().distinct().forEach(System.out::println);
   }

⑤ map投射：

假如必须将流中的原素投射到另一个流中，能够 应用map方法。方式 签字： Stream map(Function<? super T, ? extends R> mapper); 该插口必须一个Function函数式接口主要参数，能够 将当今流中的T种类数据交换为另一种R种类的流。 Stream流中的map方法基本上应用的编码如：

@Test
public void testMap() {
    Stream<String> original = Stream.of("11", "22", "33");
    Stream<Integer> result = original.map(Integer::parseInt);
    result.forEach(s -> System.out.println(s   10));
}
//这一段编码中，map方法的主要参数根据方式 引入，将字符串类型变换变成了int类型（并全自动装车为Integer类目标）。

⑥ 排列 (二种方法)

（1）Stream sorted()回到此流元素组成的流，依据当然次序排列。最底层依照內部电压比较器开展排列，完成Comparable插口中的compareTo方式 。

（2）Stream sorted(Comparator<?super T>comparator) 回到从而元素组成的流，依据挺的Comparator开展次序排列。特定次序。 特定排列对策：最底层依照外界电压比较器开展排列 Comparator插口一定要再次Compare方式 。

基本上应用
Stream流中的sorted方式 基本上应用的编码如：
@Test
public void testSorted() {
    // sorted(): 依据原素的当然次序排列
    // sorted(Comparator<? super T> comparator): 依据电压比较器特定的标准排列
    Stream.of(33, 22, 11, 55)
            .sorted()
            .sorted((o1, o2) -> o2 - o1)
            .forEach(System.out::println);
}
这一段编码中，sorted方式 依据原素的当然次序排列，还可以特定电压比较器排列。

4：停止实际操作

①搜索(find)和配对(match)

假如必须寻找一些数据信息，能够 应用find有关方式 。方式 签字：

• Optional findFirst();
• Optional findAny();

Stream流中的find有关方式 应用编码：

@Test
public void testFind() {
    Optional<Integer> first = Stream.of(5, 3, 6, 1).findFirst();
    System.out.println("first = "   first.get());

    Optional<Integer> any = Stream.of(5, 3, 6, 1).findAny();
    System.out.println("any = "   any.get());
}

Stream流的match方式

假如必须分辨数据信息是不是配对特定的标准，能够 应用Match有关方式 。方式 签字：

• boolean allMatch(Predicate<? super T> predicate);
• boolean anyMatch(Predicate<? super T> predicate);
• boolean noneMatch(Predicate<? super T> predicate); 基本上应用 Stream流中的Match有关方式 应用编码如：

@Test
public void testMatch() {
    boolean b = Stream.of(5, 3, 6, 1)
            // .allMatch(e -> e > 0); // allMatch: 原素是不是所有符合条件
            // .anyMatch(e -> e > 5); // anyMatch: 原素是不是随意有一个符合条件
            .noneMatch(e -> e < 0); // noneMatch: 原素是不是所有不符合条件
    System.out.println("b = "   b);
}    

②：解析xml foreach

//forEach 用于解析xml流中的数据信息
 @Test
    public void test02() {
        //实例1、2下边二种书写等同于
        list.stream().map((x)->x.getName()).forEach(System.out::println);
        list.stream().map(Student::getName).forEach(System.out::println);
    }

③Stream流的max、min

List<String> list13 = Arrays.asList("zhangsan","lisi","wangwu","xuwujing");
 int maxLines = list13.stream().mapToInt(String::length).max().getAsInt();
 int minLines = list13.stream().mapToInt(String::length).min().getAsInt();
 System.out.println("最多标识符的长短:"   maxLines ",最短标识符的长短:" minLines);
 //最多标识符的长短:8,最短标识符的长短:4

④Stream流的count

 // Stream流给予count方式 来统计分析在其中的原素数量：long count();
  //该方式 回到一个long值意味着原素数量。基本上应用：
@Test
public void testCount() {
   List<String> strList = new ArrayList<>();
   Collections.addAll(strList, "段誉", "周芷若", "赵敏", "小昭", "杨不悔);
   System.out.println(strList.stream().count());
}

⑤ 排序：groupingBy；

在我们应用Stream流解决数据信息后，能够 依据某一特性将数据信息排序：

// 实例：
    @Test
    public void testGroup() {
        Stream<Student> studentStream = Stream.of(
                new Student("李易峰", 52, 95),
                new Student("唐嫣", 56, 88),
                new Student("迪丽热巴", 56, 55),
                new Student("柳岩", 52, 33));
        // Map<Integer, List<Student>> map = studentStream.collect(Collectors.groupingBy(Student::getAge));
        // 将成绩超过60的分成一组,低于60分成另一组
        Map<String, List<Student>> map = studentStream.collect(Collectors.groupingBy((s) -> {
            if (s.getSocre() > 60) {
                return "合格";
            } else {
                return "不过关";
            }
        }));
        map.forEach((k, v) -> {
            System.out.println(k   "::"   v);
        });
    }

实际效果：
不过关::[Student{name='迪丽热巴', age=56, socre=55}, Student{name='柳岩', age=52, socre=33}]
合格::[Student{name='李易峰', age=52, socre=95}, Student{name='唐嫣', age=56, socre=88}]

⑥拼凑：joining

Collectors.joining会依据特定的连接符，将全部原素组合成一个字符串数组。
// 拼凑
@Test
public void testJoining() {
    Stream<Student> studentStream = Stream.of(
            new Student("李易峰", 52, 95),
            new Student("唐嫣", 56, 88),
            new Student("迪丽热巴", 56, 99),
            new Student("柳岩", 52, 77));
    String collect = studentStream
            .map(Student::getName)
            .collect(Collectors.joining(">_<", "^_^", "^v^"));
    System.out.println(collect);
}

实际效果：
^_^李易峰>_<唐嫣>_<迪丽热巴>_<柳岩^v^

⑦汇聚：toList,toSet,toMap;

Stream流给予collect方式 ，其主要参数必须一个java.util.stream.Collector<T,A, R>插口目标来特定搜集到哪一种结合中。

• public static Collector<T, ?, List> toList()：变换为List结合。
• public static Collector<T, ?, Set> toSet()：变换为Set结合。
• public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper):变换为Map结合。

下边是这两个方式 的基本上应用编码：

// 将流中数据采集到结合中
@Test
public void testStreamToCollection() {
    Stream<String> stream = Stream.of("aa", "bb", "cc");
    // List<String> strList = stream.collect(Collectors.toList());
    // Set<String>  strSet = stream.collect(Collectors.toSet());

    ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));
    HashSet<String> hashSet = stream.collect(Collectors.toCollection(HashSet::new));
}

toMap

  @Test
    public void testCollectToMap(){
        //实例1
        List<Integer> list = Arrays.asList(1, 2, 3);
        Map<String, String> collect1 = list.stream().map(i -> i).collect(Collectors.toMap(key -> "key"   key, value -> "value:"   value));
 
        //实体线list转换map id做为外键约束，目标做为value
        List<User> userList =new ArrayList<User>();
        UserTask userTask = new UserTask();
        userTask.setId(1);
        userTask.setName("检测");
        userList.add(userTask);
 
        Map<Integer,UserTask> taskMap = userList.stream().collect(Collectors.toMap(UserTask::getId, entity -> entity));
        System.out.println(collect1.toString());
        System.out.println(taskMap.toString());
    }