JDK1.8的新特性--Lambda和Stream

1.Lambda

Lambda的标准格式介绍

(数据类型 变量名,数据类型 变量名)->{方法体;返回值}
1.()相当与方法的参数列表
2.-> 固定用法
3.{} 这里面写具体的方法体,如果有返回值需要写return语句

Lambda的省略模式

1.参数的数据类型,可以无条件省略
2.如果参数只有一个,那么小括号可以省略
3.如果方法体中只有一句代码,那么{},return,和后面的分号,可以省略

参数和返回值 示例

import java.util.Arrays;

public class Lambda {
    public static void main(String[] args) {
        Integer arr[] = {1, 2, 3, 5, 4, 8, 7, 0};

//        Arrays.sort(arr, (Integer o1, Integer o2) -> {
//            return o1 - o2;
//        });

        Arrays.sort(arr, (o1, o2) -> o1 - o2);

        for (Integer num : arr) {
            System.out.println(num);
        }
    }
}

Lambda的使用前提

1.Lambda只能用于简化只有一个抽象方法的接口(这种接口称为函数式接口)的匿名内部类对象

2.Stream流

获取流的两种方式

1.集合获取流

public Stream<T> stream(); 获取集合的流对象(只有单列集合)

2.数组获取流

public static Stream<T> of(T... objs); Stream的静态方法获取数组的流对象

示例:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        //1.集合获取流(单列集合)
        ArrayList<Integer> arr = new ArrayList<>();
        java.util.stream.Stream<Integer> stream1 = arr.stream();
        java.util.stream.Stream<String> stream2 = new HashSet<String>().stream();

        //2.数组获取流
        Integer[] nums = {10,20,40,30,50};
        Stream<Integer> stream3 = Stream.of(nums);

        Stream<String> stream4 = Stream.of("jack", "rose", "tom");

    }
}

流中常用的方法

import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        Stream<String> stream5 = Stream.of("1", "22", "333", "4444", "55555", "666666");
        Stream<String> stream6 = Stream.of("1", "22", "333", "4444", "55555", "666666");
        //1.forEach示例
//        stream5.forEach(s-> System.out.println("元素:"+s));

        //2.filter示例
//        stream5.filter(s -> s.length()>3).forEach(s -> System.out.println(s));

        //3.count示例
//        System.out.println(stream5.count());

        //4.limit示例
//        stream5.limit(3L).forEach(s -> System.out.println(s));

        //5.skip 跳过前几个示例
//        stream5.skip(2).forEach(s-> System.out.println(s));

        //6.concat 将两个流合并到一个流
//        Stream<String> concat = Stream.concat(stream6, stream5);
//        concat.forEach(s-> System.out.println(s));

        //7.map- 根据姓名创建 Person 对象(自行创建)；
//        Stream<Person> personStream = concat.map(s -> new Person(s));
    }
}

收集Stream的结果

public List/Set collector(Collectors.toList()/Collectors.toSet());收集到List或者Set集合中

public Object[] toArray();收集到数组中

        //收集流结果
//        List<String> collect = stream5.collect(Collectors.toList());
//        for (String s : collect) {
//            System.out.println(s);
//        }

//        Set<String> collect1 = stream5.collect(Collectors.toSet());
//        for (String s : collect1) {
//            System.out.println(s);
//        }

//        Object[] objects = stream5.toArray();
//        for (Object object : objects) {
//            System.out.println(object);
//        }