Lambada表达式

简化接口编程方式
是匿名内部类的简化书写方式

  1.     //把new Runnable（）这个对象当做参数
  2.     Thread thread = new Thread(new Runnable(){
  3.         //重写run方法
  4.         public void run(){
  5.             sout（“匿名内部类写法”）;
  6.         }
  7.     });
  8.     thread.star();

lambada表达式简化
把 ( ) -> { } 作为参数

  1. Thread thread = new Thread(()->{
  2.     sout("lambada表达式写法");
  3. });
  4. thread.star();

进一步简化

  1. new Thread(()->{sout("lambada表达式写法");}).star();

Stream流

干掉for循环和迭代器遍历

数据源、数据处理、收集结果

  1. //Stream流
  2. //1.数据源(在集合中筛选出年龄大于21，切薪资大于2000的人)
  3. Predicate<User> pre1= user -> user.getAge() < 21;
  4. Predicate<User> pre2= user -> user.getSalary() > 2000;
  5.     List<User> collect = list.stream()
  6.         .filter(pre1)//过滤条件1
  7.         .filter(pre2)
  8.         .collect(Collectors.toList());//将收集到的数据放入新的集合
  9. System.out.println(collect);

也可以简化为

  1. List<User> collect = list.stream()
  2.     .filter(user.getAge() < 21)//过滤条件1
  3.     .filter(user.getSalary() > 2000)
  4.     .collect(Collectors.toList());//将收集到的数据放入新的集合
  5. System.out.println(collect);

或者

  1. Predicate<User> pre1= user -> user.getAge() < 21
  2. Predicate<User> pre2= user -> user.getSalary() > 2000
  3.     List<User> collect = list.stream()
  4.         .filter(pre1.and(pre2))        //如果是或关系，可以吧and改为or
  5.         .collect(Collectors.toList());//将收集到的数据放入新的集合
  6. System.out.println(collect);

filter筛选

filter得到的结果是一个集合

  1. List<String> list = Arrays.asList("hello","world","java");
  2.     list.stream()
  3.     .filter( str -> str.length()>=5 )    //将长度大于，等于5的字符串过滤，放进str集合，并遍历
  4.     .forEach(str -> sout(str));

lilimit截取

  1. // 截取list集合的前两个字符串，放进str集合遍历输出
  2. list.stream()
  3.     .limit(2)
  4.     .forEach(str -> sout(str));

sorted排序

  1. List<Integer> list = Array.asList(1,5,4,8,3,2);
  2. list.stream()
  3.     .sorted()    //默认升序排列，在sorted（Comparator）表示降序排序。
  4.     .forEach( num -> sout(num) );

最大值、最小值、长度

  1. List<Integer> list = Array.asList(1,5,4,8,3,2);
  2. //最大
  3. sout(list.stream()
  4.         .max(Integer :: compareTo).get());
  5. //最小
  6. sout(list.stream()
  7.         .min(Integer :: compareTo).get());
  8. //长度
  9. sout(list.stream().count());

map对集合执行特定操作后，作为对象输出

  1. List<Integer> list = Array.asList(1,5,4,8,3,2);
  2.     list.stream()
  3.         .map( num -> num+10 );
  4.         .forEach( num -> sout(num) );    //得到结果：11，15，14，18，13，12

reduce

对传入的元素进行指定操作后作为对象输出
区别于map输出多个值，reduce只输出一个

  1. //表示累加，两集合里的所有值累加
  2. List<Integer> list = Array.asList(1,5,4,8,3,2);
  3. sout(
  4. list.stream()
  5.     .reduce( (sum,num )-> sum+num).get() 
  6. );

collectors

基于目标集合生成新的集合

  1. //收集当前集合中的所有偶数，并输出偶数集合
  2. List<Integer> list = Array.asList(1,5,4,8,3,2);
  3. sout(
  4. list.stream()
  5.     .filter( num -> num%2==0 )
  6.     .collect( Collectors.toList() );
  7.  );