常用Java8新特性（了解常用即可）

一、Lambda表达式（六大常用方式）

1、无参无返回值

 @Test
  public void test01(){
    //实现接口的方式
    Runnable a1 = new Runnable() {
      @Override
      public void run() {
        System.out.println("fghj");
      }
    };
    a1.run();
      
    //Lambda方式
    Runnable a2=()->{
      System.out.println("56789");
    };
    a2.run();
  }

2、有参无返回值

 @Test
    public void test02() {
        //接口消费者
        Consumer<String> a = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        a.accept("56789");

        //Lambda表达式
        Consumer<String> b = (String string) -> {
            System.out.println(string);
        };
        b.accept("56789");
    }

3、省略数据类型（类型推断）

@Test
    public void test03() {
        //同上（使用编译器的类型推断）
        Consumer<String> c = (str) -> {
            System.out.println(str);
        };
        c.accept("5678");
        //对编译器的类型推断(后面泛型忽略，前面推断到后面)
        ArrayList<String> list = new ArrayList<>();
    }

4、一个参数，省略括号

   @Test
    public void test04() {
        Consumer<String> c=str->{
            System.out.println(str);
        };
    }

5、两个及以上参数，多条执行语句，可有return

    @Test
    public void test05() {
        Comparator<Integer> comparator = (o1,o2)->{
            System.out.println("678");
            System.out.println("ghj");
            return o1.compareTo(o2);
        };
        int compare = comparator.compare(12, 89);
        System.out.println(compare);
    }

6、只有只有一条语句，{}和return都可省略

    @Test
    public void test06() {
        Comparator<Integer> comparator = (o1, o2) -> o1.compareTo(o2);;
        int compare = comparator.compare(12, 89);
        System.out.println(compare);
    }

小结：

1.— >Lambda操作符

2.左边：接口中的形参

3.右边：方法体

4.左边多参不可省略（）

5.右边多语句不能省略{}

6.右边单语句可省略return

7.@FunctionalInterface（使用该函数式注解的一定能使用Lambda表达式；该注解使用情况接口中只有一个实现方法才能用）

二、方法引用（::）

总=》类::方法名字

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author xusj
 * <br>CreateDate 2022/3/13 16:31
 */
public class Test {
    public static void main(String[] args) {
        User u1 = new User(1, "jack");
        User u2 = new User(2, "rouse");
        List<User> list = new ArrayList<>();
        list.add(u1);
        list.add(u2);
        // 1.普通方式
        List<String> nameList01 = new ArrayList<>();
        for (User user : list) {
            nameList01.add(user.getName());
        }
        for (String s : nameList01) {
            System.out.println("nameList01" + s);
        }
        // 2.函数表达式=》方法应用方式
  List<String> nameList02 =list.stream().map(User::getName).collect(Collectors.toList());
        for (String s : nameList02) {
            System.out.println("nameList02" + s);
        }
    }
}

class User {
    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

三、强大的Stream API

import java.util.ArrayList;
import java.util.List;

/**
 * 强大的stream API ，
 * 1.集合（list.stream）或数组(Arrays.stream)
 * 2.具体.【一系列】中间操作.中止操作 
 * @author xusj
 * <br>CreateDate 2022/3/13 17:02
 */
public class StreamTest {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        // 1.顺序流流，通过集合去调用,顺序去操作流中的元素
        list.stream().forEach();
        // 2.并行流，开多个内部线程去操作每一个元素，数据太大的时候效率更高
        list.parallelStream().forEach();
        // 3.排序(流.中间操作.终止操作)
        list.stream().sorted().forEach(System.out::println);
    }
}

stream流式操作

  //使用流过滤
  public static void main(String[] args) { 
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");
    list.stream().filter(s->s.startsWith("张")).filter(s-> s.length() == 3).forEach(System.out::println);
    
  //流map 
  
      //1.将流中的元素映射到另一个流中，这个是在后期经常用到的，比如方法所接收的返回值是A,但是接收的却是B
    list.stream().map(item -> {
                    ProductInfoAttributes productInfoAttributes = new ProductInfoAttributes();
                    BeanUtils.copyProperties(item, productInfoAttributes);
                    productInfoAttributes.setProductId(productId);
                    productInfoAttributes.setAttributeId(IDGenerator.getId());
                    return productInfoAttributes;
                }).collect(Collectors.toList());
   
      //2.将String类型的流转换为Integer 类型
              Stream<String> stringStream = Stream.of("1", "2", "3", "4", "5", "6");
        stringStream.map(str->Integer.parseInt(str)).forEach(System.out::println);
	
      //3.方法需要返回的是List <String>，但是这里只有List<Category>,此时就要想到stream().map
          public  List<String> queryNamesByIds(List<Long> ids){
        
              List<Category> categories = this.categoryMapper.selectByIdList(ids);
       
    return  categories.stream().map(category -> 					            
                                    category.getName()).collect(Collectors.toList());
    }
      
// 3.排序(流.中间操作.终止操作)
        list.stream().sorted().forEach(System.out::println);
      
      

      
      
      //规约：集合中所有值的和
      
      
       public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(2);
        list.add(2);
        list.stream().reduce(0,Integer::sum); //Number基本上都有加减乘除这些级别操作
    }