Java8新特性

1.Lambda表达式概念

Lambda表达式是JDK1.8开始之后的新技术，是一种代码的新语法。
作用：核心目的是为了简化匿名内部类的代码写法。
使用：Lambda表达式不能简化所有匿名内部类的写法，只能简化接口中只有一个抽象方法的内部类形式。
案例：

1.1 lambda表达式简化Comparator接口

// lambda表达式简化Comparator接口
public static void main(String[] args) {
List<Student> list=new ArrayList();
Student student1 =new Student("李四",20,'男');
Student student2 =new Student("王五",55,'女');
Student student3 =new Student("二麻子",22,'男');
Collections.addAll(list,student1,student2,student3);
//        Collections.sort(list, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });
Collections.sort(list,(Student t1, Student t2) ->{
return t1.getAge()-t2.getAge();
});
System.out.println(list);
    }

2.lambda表达式简化Runable接口

public static void main(String[] args) {
    Thread thread=new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"执行了~~~~");
        }
    });
    thread.start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"执行了~~~~");
        }
    }).start();
    // lambda表达式
    new Thread(()->{
        System.out.println(Thread.currentThread().getName()+"执行了~~~~");
    }).start();
    }

2. Lambda表达式的省略写法（进一步在Lambda表达式的基础上继续简化）

（1）方法体代码只有一行代码。可以省略大括号不写,同时要省略分号。<br />        此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写<br />    （2）如果只有一个参数，参数类型可以省略，同时()也可以省略。

3.方法引用

      方法引用是为了进一步简化Lambda表达式的写法。<br />          方法引用的格式：类型或者对象::引用的方法

3.1 静态方法的引用

public static int CompareByAge(Student o1,Student o2){
    return o1.age-o2.age;
}
Collections.sort(list,Student::CompareByAge);

3.2 实例方法的引用

// 对象是 System.out = new PrintStream();
// 实例方法：println()
// 前后参数正好都是一个
lists.forEach(s -> System.out.println(s));
// 实例方法的引用
lists.forEach(System.out::println);

3.3 特定方法的引用

// String中的特定方法
// 特定类型的方法引用：
Arrays.sort(strs,  String::compareToIgnoreCase);

3.4 构造器引用

String[] arr=list.stream().toArray(String[]::new);
System.out.println(Arrays.toString(arr));

3.stream流

1.Lambda所带来的函数式编程，引入了一个全新的Stream流概念 ，用于解决已有集合/数组类库有的弊端。
stream流解决了已有集合类库或者数组API的弊端，简化集合和数组的操作！

3.1 stream流的获取

public static void main(String[] args) {
        //Map集合获取流
        // Collection集合如何获取Stream流。
        Collection<String> c = new ArrayList<>();
        Stream<String> ss = c.stream();
        //Map集合获取流
        Map<String, Integer> map = new HashMap<>();
        // 先获取键的Stream流。
        Stream<String> keyss = map.keySet().stream();
        // 在获取值的Stream流
        Stream<Integer> valuess = map.values().stream();
        // 获取键值对的Stream流（key=value： Map.Entry<String,Integer>）
        Stream<Map.Entry<String,Integer>> keyAndValues = map.entrySet().stream();
        //数组获取流
        String[] arrs = new String[]{"Java", "JavaEE" ,"Spring Boot"};
        Stream<String> arrsSS1 = Arrays.stream(arrs);
        Stream<String> arrsSS2 = Stream.of(arrs);
    }

3.2 stream流常见API

    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李三");
        list.add("李四");
        list.add("王三");
        list.add("张六");
        list.add("张天明");
        //filter():过滤元素  forEach() : 逐一处理
        list.stream().filter(s->s.startsWith("张")).filter(s ->s.length()==2).forEach(System.out::println);
        // count():统计个数
        long size=list.stream().filter(s->s.length()==2).count();
        System.out.println(size);
        // limit():取前几个元素
        list.stream().filter(s->s.length()==2).limit(2).forEach(s -> System.out.println(s));
        // skip(): 跳过前几个
        list.stream().filter(s->s.length()==2).skip(2).forEach(s -> System.out.println(s));
        // map():加工方法（把原来的元素加工以后，从新放上去）
        list.stream().map(s->"盒子"+s).forEach(s-> System.out.println(s));
        list.stream().map(s->new Student(s)).forEach(s-> System.out.println(s));
        // concat(): 合并流
        Stream<Integer> s1=Stream.of(1,5,6,8);
        Stream<String> s2=list.stream();
        Stream<Object> s3=Stream.concat(s1,s2);
        s3.forEach(s-> System.out.println(s));
    }

3.3 收集流

    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李三");
        list.add("李四");
        list.add("王三");
        list.add("张六");
        list.add("张天明");
        list.add("张天明");      
        //set
        Set<String>set=list.stream().collect(Collectors.toSet());
        System.out.println(set);
        //list
        List<String>newList=list.stream().collect(Collectors.toList());
        System.out.println(newList);
        //数组
        String [] arr=list.stream().toArray(String[]::new);
        System.out.println(Arrays.toString(arr));
    }