4.7学习总结

java学习

一.Stream流

(一.)概念:

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。Stream流是对集合（Collection）对象功能的增强，与Lambda表达式结合，可以提高编程效率、间接性和程序可读性。

特点:

• stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
• stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
• stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

  (二.)Stream的创建

  1.Collection集合创建

  List integerList = new ArrayList();
  Collection.addAll(integerList,1,2,3,4,5);        
  Stream listStream = integerList.stream();

  2.Stream创建对象

  List list = new ArrayList();
  Stream stream = list.stream();  //串行流
  Stream parallelStream = list.parallelStream(); //并行流
  

  3.Arrays数组创建

  int[] Arr = {1, 2, 3, 4, 5};
  IntStream arrayStream = Arrays.stream(Arr);

  

  (三.)操作符

  1.中间操作符

   中间操作会返回一个新的流，一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后会返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。而是在终结操作开始的时候才真正开始执行。

  

  public class stream4 {
      public static void main(String[] args) {
          //中间方法,返回新的steam流,原来的stream流只能使用一次
          //修改stream流中的数据,不会改变原来集合中的元素
          ArrayList list=new ArrayList();
          Collections.addAll(list,"张三","张三疯","喜洋洋","美洋洋","柳如烟","李四");
          //1.filter 过滤作用
          list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(s-> System.out.println(s));
          System.out.println("--------------------------------");
          //2.skip 跳过元素
          list.stream().skip(3).forEach(s-> System.out.println(s));
          System.out.println("--------------------------------");
          //3.limit 获取前几个元素
          list.stream().limit(3).forEach(s-> System.out.println(s));
          System.out.println("--------------------------------");
          //4.获取中间的两元素的方法:
          //1.仙截取后跳过
          list.stream().limit(4).skip(2).forEach(s-> System.out.println(s));
          System.out.println("--------------------------------");
          //2.仙跳过后截取
          list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
          System.out.println("--------------------------------");
      }
  }

   运行结果:

  

  2.终结操作符

   终结操作是指返回最终的结果。一个流只能有一个终结操作，当这个操作执行后，这个流就被使用“光”了，无法再被操作。所以这必定这个流的最后一个操作。只有终结操作执行的时候，才会真正开始流的遍历，并且会生成一个结果。

  

  (四.)使用实例

  要求将一组数据中,对大于一定年龄的人放入到map集合中,并进行输出

  public class TEXT2 {
      public static void main(String[] args) {
          ArrayList list=new ArrayList();
          Collections.addAll(list,"张三,12","李四,15","王五,16");
          //匿名内部类的写法
          Map map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 15).collect(Collectors.toMap(new Function() {
              @Override
              public String apply(String s) {
                  return s.split(",")[0];
              }
          }, new Function() {
              @Override
              public Integer apply(String s) {
                  return Integer.parseInt(s.split(",")[1]);
              }
          }));
          System.out.println(map);
          System.out.println("---------------------------");
          //lambda表达式写法
          Map map2 = list.stream()
                  .filter(s -> Integer.parseInt(s.split(",")[1]) >= 15)
                  .collect(Collectors.toMap(s -> s.split(",")[1],
                          s -> s.split(",")[0]));
          System.out.println(map2);
          System.out.println("----------------------------");
      }
  }

  运行结果:

  二.方法引用

  (一.)方法引用的概念和规则

  方法引用:把已经有的方法拿过来用,当做函数式接口中抽象方法的方法体.

  方法引用的规则:

  1.需要具有函数式接口

  2.被引用的方法必须存在.

  3.被引用的方法和返回值和形参与抽象方法一致.

  4.被引用方法的功能要满足当前需求.

  (二.)引用静态方法

  格式:类名::静态方法

  引用类方法，其实就是引用类的静态方法

  public class yinyong {
      public static void main(String[] args) {
          ArrayList list =new ArrayList();
          Collections.addAll(list,"1","2","3","15564222","126");
          list.stream().map(new Function() {
              @Override
              public Integer apply(String s) {
                  Integer i = Integer.parseInt(s);
                  return i;
              }
          }).forEach(s-> System.out.println(s));
          System.out.println("-------------------");
          //1.方法需要已经存在
          //2.方法的形参和返回值需要跟抽象方法的形参和返回值一样
          //3.方法的功能需要吧形参的字符串转换成整数
          list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));
      }
  }

   

  (三).引用成员方法

  格式:对象::成员方法

  引用对象的实例方法，其实就引用类中的成员方法

  public class StringOperation {
      public boolean stringJudge(String s) {
          return s.startsWith("张");
      }
  }
  public class yinyong2 {
      public static void main(String[] args) {
          ArrayList list =new ArrayList();
          Collections.addAll(list,"张三","李四","王五","张飞","客小二");
          //通过在其他类中进行引用
          //先创建对象,在进行引用
          list.stream()
                  .filter(new StringOperation()::stringJudge)
                  .forEach(s-> System.out.println(s));
      }
  }

  (四.)引用构造器

  格式:类名::构造方法

  (注意构造方法中的形参必须和抽象方法保持一致)

  public class Student {
      private String name;
      private int age;
      public Student(String s) {
          String[] arr=s.split(",");
          this.name=arr[0];
          this.age=Integer.parseInt(arr[1]);
      }
      public Student(String name, int age) {
          this.name = name;
          this.age = age;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public int getAge() {
          return age;
      }
      public void setAge(int age) {
          this.age = age;
      }
  }
  public class yinyong3 {
      public static void main(String[] args) {
          ArrayList list=new ArrayList();
          Collections.addAll(list,"张三,15","李四,16","王五,17");
          List cc = list.stream().map(Student::new).collect(Collectors.toList());
          System.out.println(cc);
      }
  }