java8——lambda

lambda
1.lambda就是一个语法糖，额，语法糖
2.语法较为简单， 基本语法：(parameters) -> expression 或 (parameters) ->{ statements; }
  简单例子：
    // 1. 不需要参数,返回值为 5  
    () -> 5  
      
    // 2. 接收一个参数(数字类型),返回其2倍的值  
    x -> 2 * x  
      
    // 3. 接受2个参数(数字),并返回他们的差值  
    (x, y) -> x – y  
      
    // 4. 接收2个int型整数,返回他们的和  
    (int x, int y) -> x + y  
      
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
    (String s) -> System.out.print(s)
   当我看到这几个列子，我感觉，lambda就是一个函数，对，还是匿名的。
3.使用lambda进行for循环
    //传统的for循环
    List<String> list=new ArrayList();
    list.add("哈哈");
    list.add("xixi");
    for(String str:list){
        System.out.println(str.length());
    }
    System.out.println("----------------");
    //lambda的for循环
    list.forEach((str) -> System.out.println(str.length()));

4.匿名类可以使用lambda表达式来代替
    // 1.1使用匿名内部类  
    new Thread(new Runnable() {  
        @Override  
        public void run() {  
        System.out.println("Hello world !");  
        }  
    }).start();  
      
    // 1.2使用 lambda expression  
    new Thread(() -> System.out.println("Hello world !")).start();  
      
    // 2.1使用匿名内部类  
    Runnable race1 = new Runnable() {  
        @Override  
        public void run() {  
        System.out.println("Hello world !");  
        }  
    };  
      
    // 2.2使用 lambda expression  
    Runnable race2 = () -> System.out.println("Hello world !");  
       
    // 直接调用 run 方法(没开新线程哦!)  
    race1.run();  
    race2.run();
当我看到这里的时候，我有个疑惑，以前实现线程都需要把逻辑写在run()方法里面，但是，lambda替换后，
如何知道我lambda表达式替换的是run方法呢？

解决：函数接口里面有且仅有一个抽象方法，好的，意思就是说，接口里面只有一个抽象方法，我就可以
      直接找到这个抽象方法了
看一下 Runable接口，好吧，里面只有一个抽象方法，就是run()，
那，是不是就是意味着，lambda只能替换这种(函数接口里面有且仅有一个抽象方法)呢？是的

 

stream：操作集合的，性能好像是没有for循环的高，不过差距也不大
/*
         * stream 常用方法
         */
        //1.Stream.filter()和Stream.count()
        List<Person> persons = new PersonFactory().getPersons(10);
        
        long count = persons.stream().filter(p -> p.getGen().equals("男")).count();
        System.out.println(count);
        
        //2.forEach
        list.stream().forEach(str -> System.out.println(str));
        list.forEach(System.out::println);
        list.forEach(String::length);
        
        //3.map,filter过滤器，得到集合的是小于原来长度，map是一对一转换
        List<Integer> collect = list.stream().map(str -> str.length()).collect(Collectors.toList());
        
        //4.limit,获取指定数量
        ints.limit(10).forEach(System.out::print);
        
        //5.sorter,进行排序
        new Random().ints().limit(10).sorted().forEach(System.out::print);
        
        System.out.println("---------------");

        //6.并行程序，说实话，现在还不知道具体的作用
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        // 获取空字符串的数量
        int co = (int) strings.parallelStream().filter(string -> string.isEmpty()).count();
        System.out.println(co);
        
        //7.collect，Collectors转成list
        List<Integer> col= list.stream().map(str -> str.length()).collect(Collectors.toList());
        strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
        String string = strings.stream().filter(str -> !str.isEmpty()).collect((Collectors.joining(", ")));
        
        //8.进行统计
        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
        stats.getMax();
        stats.getAverage();
        
        //9.联用
        IntSummaryStatistics summaryStatistics = numbers.stream().filter(num -> num>3).mapToInt(x -> x).summaryStatistics();
        System.out.println(summaryStatistics.getMin());
        
        //10合并
        List<String> st=new ArrayList<String>();
        st.add("1");
        st.add("2");
        List<String> collect2 = Stream.of(st,strings).flatMap(str -> str.stream()).collect(Collectors.toList());
                        
        //11.求和
        Stream.of(1, 2, 3, 4).reduce(0, (num,sum) ->(sum+num) ); //0相当于第一次传值的sum  sum+num=0+1
        Stream.of(1, 2, 3, 4).reduce(0,Integer::sum);