JDK1.8新特性 1.lambda 2.方法引用3.Stream流

目录

1.lambda 表达式:

a.简单线程，匿名内部类

b.一个参数无返回值的lambda

c.有俩个参数并且有返回值的情况

 2.方法引用

 1.类名::静态方法名

3.stream流 

1.1 IntStream.generate         生成随机数

1.2 IntStream.range() IntStream.rangeClosed()         指定区间生成数字

1.3IntStream.of //使用一组给定值生成stream

1.4 IntStream.empty() //生成一个空流

1.5IntStream.builder 通过add方法添加多个元素

   1.6IntStream.iterate//生成一个有序无限的Int数据流  

1.7IntStream.concat        // 合并流，使用concat方法将连个不同流合并为一个流输出

 1.8 //转换map已给定操作生成新值，并用新值替换旧值

 2.0 //mapToObj//mapObj可以将元素转换为其他任意类型

 2.1//mapToObj将int类型装换为String类型

 2.3//mapToLong将int类型转换为Long类型

  2.4mapToDouble

将int类型转换为Double类型

2.5asLongStream //直接将int流转换为long类型的流

2.6 asDoubleStream

3.1 //扁平化操作flatMap

 3.2去重操作distinct

 3.3//排序操作sorted

3.4 //查看元素peek

  3.5 //使用skip跳过指定个数的元素

  3.6//顺序输出forEachOrdered

3.7数学运算 

 3.8查询操作 

---

1.lambda 表达式:

a.简单线程，匿名内部类

//调用线程
public class Mytest implements Runnable{
    @Override
    public void run() {
        System.out.println("我是一个调用线程的线程");
    }
}

public static void main(String[] args) {
    Mytest mytest = new Mytest();
    Thread 调用类 = new Thread(mytest);
    调用类.run();//调佣方法 不是开启线程
    System.out.println(调用类);

    //匿名内部类,不再需要调用
    Thread 匿名内部类 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("我是一个最简单的线程");
        }
    });
    匿名内部类.run();
    //格式1:无参，无返回值，只有一个lambda表达式
    new Thread(()-> System.out.println("我是一个lambda线程")).run();
}

//控制台打印
我是一个调用线程的线程
我是一个最简单的线程
我是一个lambda线程

b.一个参数无返回值的lambda

public static void main(String[] args) {
    //一个参数无返回值
    Consumer<String> consumer = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumer.accept("这是一个简单的consumer");
    //使用lambda
    Consumer<String> consumer1 = (s)->System.out.println(s);
    consumer1.accept("这是一使用lambda简单的consumer");
    //只有一个参数的的时候可以去掉括号
    Consumer<String> comsumer2=s-> System.out.println(s);
    comsumer2.accept("lamdba格式");
}

控制台打印

这是一个简单的consumer

这是一使用lambda简单的consumer
lamdba格式

c.有俩个参数并且有返回值的情况

public static void main(String[] args) {
    Comparator<Integer> comparator = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1 > o2 ? o1 : o2;
        }
    };
    int compare = comparator.compare(10, 20);
    System.out.println("最大值为"+compare);
//有俩个参数并且有返回值的情况
//格式省略往下看
    Comparator<Integer> comparator1 = (i1,i2)->{
        return i1 < i2 ? i1 : i2;
    };
    int compare2 = comparator1.compare(100, 200);
    System.out.println("最小值为" +compare2);
//当返回语句中只有一条语句的时候 可以省略{retuen}
Comparator<Integer> comparator1 = (i1,i2)-> i1 < i2 ? i1 : i2;
int compare3 = comparator1.compare(100, 200);
System.out.println("最小值为" +compare3);
}

//控制台打印

20

100

 2.方法引用

1. 类名::静态方法名
2. 引用名(对象名)::实例方法名
3. 类名::实例方法名（较难理解）
4. 构造方法引用：类名::new （实际上就是调用一个类的构造方法来生成这个类的对象）

public static void main(String[] args) {
    //方法引用   ::  
//语法形式为：类名::方法名。
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return NumberMin.compare(o1,o2);
            }
        };
        int compare = comparator.compare(10, 20);
        System.out.println("最大值为"+compare);

        Comparator<Integer> comparator1 = NumberMin::compare;
        int compare2 = comparator1.compare(100, 200);
        System.out.println("最小值为" +compare2);
    }

public class NumberMin {
    public static int compare(int i1,int i2){
        return i1>i2?i1:i2;
    }
}

 1.类名::静态方法名

public static void main(String[] args) {
    UserMssage userMssage = new UserMssage();
    userMssage.setName("张三");
    userMssage.setAge(12);
    userMssage.setSex("男");
    //静态方法引用
    //静态方法引用：它的语法是Class::static_method
    ArrayList<UserMssage> dataInfoList = new ArrayList<>();
    dataInfoList.add(userMssage);
    dataInfoList.forEach(UserMssage::getUserMssage);
}

//实体类UserMessage
@Data
public class UserMssage {
    private String name;
    private Integer age;
    private String sex;
        public static  void getUserMssage(UserMssage userMssage) {
            System.out.println("DataInfo ： " + userMssage.toString());
        }

    @Override
    public String toString() {
        return "UserMssage{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

3.stream流 

1.1 IntStream.generate
         生成随机数

 Random random=new Random();
 IntStream.generate(()->random.nextInt(10000))
.limit(4)
.forEach(System.out::println);
//limit：随机数的个数
//System.out::println :方法引用 控制台打印

1.2 IntStream.range()
 IntStream.rangeClosed()
         指定区间生成数字

System.out.println("左闭右开,包前不包后");
 IntStream.range(0,5).forEach(System.out::println);
 System.out.println("左闭右闭,");
 IntStream.rangeClosed(0,5).forEach(System.out::println);

1.3IntStream.of
 //使用一组给定值生成stream

 IntStream.of(2,4,8,10).forEach(System.out::println);

1.4 IntStream.empty()
 //生成一个空流

    //生成一个空流
     int sum= IntStream.empty().sum();
     System.out.println(sum);
     IntStream.empty().forEach(System.out::println);
 //生成空流的第二个例子
 Stream<String> stream = Stream.empty();
 List<String> list = List.of("I","love","you","and","you","love","me");
 //stream.forEach(System.out::print);
 Stream<String> stream1 = Stream.concat(stream, list.stream());
 stream1.forEach(System.out::print);

1.5IntStream.builder 通过add方法添加多个元素

  //使用类似于建造者模式构建一个流，可以通过add方法添加多个元素，最后用build获取流对象
    

IntStream.builder().add(10).add(100).add(88).build().forEach(System.out::println);

   1.6IntStream.iterate
//生成一个有序无限的Int数据流
  

//通过迭代函数，生成一个有序无限的Int数据流。（由于是无限流，一般都是配合limit来使用）
   /**
    *         参数一:seed初始值
    *         参数二:IntUnaryOperator用前一个元素以生成新元素的函数次幂
    *  用limit截断,防止无限输出
    */
IntStream.iterate(1, x->x*2).limit(5).forEach(System.out::println);

1.7IntStream.concat

        // 合并流，使用concat方法将连个不同流合并为一个流输出

 IntStream stream1=IntStream.of(12,55,10,14);
 IntStream stream2= IntStream.builder().add(10).add(8).add(15).build();//builder可以通过add方法添加多个元素，最后用build获取流对象
 IntStream.concat(stream1,stream2).forEach(System.out::println);
 
 //过滤操作filter
 //将下列大于等于60的元素筛选出来，并打印在控制台
 IntStream score = IntStream.of(88, 45, 60, 99, 59, 90);
 score.filter(x->x>=60).forEach(System.out::println);

 1.8 //转换map
已给定操作生成新值，并用新值替换旧值
 

 IntStream.rangeClosed(2,6).map(x->x*2).forEach(System.out::println);

 2.0 //mapToObj
//mapObj可以将元素转换为其他任意类型

 2.1//mapToObj将int类型装换为String类型

 Stream<String> stringStream = IntStream.rangeClosed(10, 15).mapToObj(s -> String.valueOf(s));
 stringStream.forEach(v->{
     System.out.println(v+" "+v.getClass());
 });
 

 2.3//mapToLong
将int类型转换为Long类型
 

 LongStream longStream = IntStream.rangeClosed(10, 15).mapToLong(e -> e);
 longStream.forEach(v->{
     System.out.println(v+" "+((Object)v).getClass());
 });

  2.4mapToDouble

将int类型转换为Double类型
 

 DoubleStream doubleStream = DoubleStream.of(10,20,30,40).boxed().mapToDouble(e->e*2);
 doubleStream.forEach(imt->{
     System.out.println(imt+""+((Object)imt).getClass());
 });

2.5asLongStream
 //直接将int流转换为long类型的流

 LongStream longStream = IntStream.rangeClosed(10,20).asLongStream();
 longStream.forEach(v->{
     System.out.println(v+" "+((Object)v).getClass());
 });

2.6 asDoubleStream

 //mapToDouble，将int类型转换为Double类型

 DoubleStream doubleStream = IntStream.of(10,20,30,40,50).asDoubleStream();
 doubleStream.forEach(imt->{
     System.out.println(imt+""+((Object)imt).getClass());
 });

3.1 //扁平化操作flatMap

 //flatMap将IntStream流中的元素依次处理，并将其每个元素转换为一个流，最终将每个流合成一个大的IntStream返回
 IntStream.rangeClosed(1,3).flatMap(e -> IntStream.rangeClosed(0,e)).forEach(System.out::println);

 3.2去重操作distinct
 

 //利用distinct对流中重复的元素进行去重，测试和运行结果如下:
 IntStream.of(99,88,60,99,90,60).distinct().forEach(System.out::println);

 3.3//排序操作sorted

 //用于给元素排序，测试和运行结果如下：
 IntStream.of(9, 80, 34, 2, 24).sorted().forEach(System.out::println);

3.4 //查看元素peek

// 该操作可以获取每个元素然后给定特定的操作，测试和运行结果如下:
           /*
 注意:peek后必须添加遍历操作，不然不会有任何输出
         */
IntStream.range(1,10).peek(e-> System.out.printf("filter map element:%d\n",e)).mapToObj(e->String.valueOf(e)).forEach(System.out::println);

 
 3.5 //使用skip跳过指定个数的元素
 

 //skip括号放常量，常量之前的不操作
 IntStream.rangeClosed(1, 9).skip(2).forEach(System.out::println);

 
 3.6//顺序输出forEachOrdered

 //并行处理parallel，并行流输出的元素并不能保证按照原始顺序输出，如果需要，则可以使用forEachOrdered保证输出顺序(初始状态的顺序)，测试和运行结果如下:
 System.out.println("forEach输出并行流中的元素");
 IntStream.of(5,10,20,4,19,50).parallel().forEach(value -> System.out.print(value+" "));
 System.out.println();
 System.out.println("forEachOrdered,按照初始顺序输出并行流:");
 IntStream.of(5,10,20,4,19,50).parallel().forEachOrdered(value -> System.out.print(value+" "));

3.7数学运算 

 System.out.println("最大值：");
 System.out.println(IntStream.of(3, 90, 988, 1, 76).max().getAsInt());
 System.out.println("最小值：");
 System.out.println(IntStream.of(3, 90, 988, 1, 76).min().getAsInt());
 System.out.println("平均值：");
 System.out.println(IntStream.of(3, 90, 988, 1, 76).average().getAsDouble());
 System.out.println("元素个数：");
 System.out.println(IntStream.of(3, 90, 988, 1, 76).count());
 System.out.println("元素总和：");
 System.out.println(IntStream.of(3, 90, 988, 1, 76).sum());
 System.out.println("使用summaryStatistics进行数学运算：");
 IntSummaryStatistics summaryStatistics = IntStream.of(-2, 2, -9, 10, 9).summaryStatistics();
 System.out.println("总和：" + summaryStatistics.getSum());
 System.out.println("最大值：" + summaryStatistics.getMax());
 System.out.println("最小值：" + summaryStatistics.getMin());
 System.out.println("元素个数：" + summaryStatistics.getCount());
 System.out.println("平均值：" + summaryStatistics.getAverage());

 3.8查询操作
 

//返回特定的元素，如首个元素等，测试和输出如下
 int findFirst = IntStream.of(40, 5, 5, 5).findFirst().getAsInt();
 System.out.println("findFirst: " + findFirst);
 int findAny = IntStream.of(100, 25, 52, 54).findAny().getAsInt();
 System.out.println("findAny: " + findAny);