JDK8 函数式编程

JDK8 函数式编程

1.接口中与默认方法（Default Methods）

接口中通过defalut关键字向接口中添加非抽象方法，此功能也叫**虚拟扩展方法**

默认方法直接可以实现。例子：

public interface Person {
    
    void eat();
    
    default void paly(){
        System.out.println("通用的chi");
    }
    
}

public class Tom implements Person{
    @Override
    public void eat() {
        System.out.println("eat");
    }

    public static void main(String[] args) {
        Tom tom = new Tom();
        tom.eat();
        tom.paly();
    }
}

注意：
    1.JDK1.8之前 接口中只能由静态属性，静态方法
    2.JDK1.8之后 可以允许有default 修饰的非抽象方法

2.Lamdab表达式

1.本质是接口的实现（匿名类部类）

public interface Person {

    void eat(String mesg);

    default void paly(){
        System.out.println("通用的chi");
    }

}

1.匿名内部类
     Person p=new Person() {
            @Override
            public void eat(String mesg) {
                System.out.println("mesg");
            }
        };

2.简化（有参数的）
      Person pp=(mesg)->{
            System.out.println("mesg");
        };

3.    Person pp=(mesg)->System.out.println("mesg");
4.    Person pp=mesg->System.out.println("mesg");

3.常见的函数式接口（四个）

1. 函数式接口与lamdba表达式结合使用（函数式接口即为接口中只有一个抽象方法的接口，并且使用@FunctionalInterface）

消费型 Consumer

accept方法，能够把传入的一个对象消费掉

Consumer c=(mesg)->System.out.println("Consumer 接口 消费了"+mesg);
c.accept("44444");

供给型 Supplier

没有任何入参返回 泛型T的对象 get方法

Supplier<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据

Supplier supplier=()->{ return new User("1","2"); };   

User u= (User) supplier.get();   //每一次调用get方法都会生成新的对象

System.out.println(u.getName()+","+u.getSex());

函数型 Function

对实例对象进行转换的接口

//与supplier接口使用实例
Function<User,String> ft=(User user)->{
          return user.getSex();
        };
        
        ft.apply((User) supplier.get());
//创建对象
Function<String,User> ft1=(str)->{
            return new User("1",str);
        };
        User user = ft1.apply("4");
        System.out.println(user);
        User user1 = ft1.apply("4");
        System.out.println(user1);

断言型 Predicate

返回boolean

Predicate<String> predicate=(String mesg)->{
            return "1".equals(mesg);
        };
        System.out.println(predicate.test("3"));

4.Stream流处理

• Stream 就好像一个高级的迭代器，但只能遍历一次，就好像一江春水向东流；在流的过程中，对流中的元素执行一些操作，比如“过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等。
• 配合lamdba表达式同时进行
• 数据源为 数组，集合 告别for循环

1. 例子,distinct() 方法是一个中间操作（去重），它会返回一个新的流（没有共同元素）。count() 方法是一个终端操作，返回流中的元素个数。

List<String> list = new ArrayList<>();
list.add("武汉加油");
list.add("中国加油");
list.add("世界加油");
list.add("世界加油");

long count = list.stream().distinct().count();
System.out.println(count);

2. 流程

1.先把集合转为流
    list.Stream()
    list.parallelStream()
2.操作流

3. 操作符，中间操作符，终止操作符
4. 中间操作符

//1.filter方法，参数是一个断言接口 predicate
    //过滤不符合的元素
List<String> list = new ArrayList<>();
        list.add("aaaaab");
        list.add("aaaaab");
        list.add("ffffvv");
        list.add("safafsad");

        List<String> d = list.stream().filter((str) -> {
            return str.contains("d");
        }).collect(Collectors.toList());  //返回一个集合
        System.out.println(d.get(0));

//2.distinct  去重
	//如果list中的元素是新new的对象，则无法去重  hashcode不同,可修改 
  List<String> collect = list.stream().distinct().collect(Collectors.toList());
        System.out.println(collect);

//3.limit  取前几个， skip 排除前几个除外的
List<String> limit = list.stream().limit(1).collect(Collectors.toList());
        System.out.println(limit);

 List<String> limit1 = list.stream().skip(2).collect(Collectors.toList());
        System.out.println(limit1);

//4.映射 map  flatmap
List<String> map = list.stream().map(str -> str.toUpperCase()).filter(str -> str.length() > 1).collect(Collectors.toList());
        System.out.println(map);


1.将每一个Employee的年龄增加一岁
2.将性别中的“M”换成“male”，F换成Female。
public static void main(String[] args){
    Employee e1 = new Employee(1,23,"M","Rick","Beethovan");
    Employee e2 = new Employee(2,13,"F","Martina","Hengis");
    Employee e3 = new Employee(3,43,"M","Ricky","Martin");
    List<Employee> employees = Arrays.asList(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);

    /*List<Employee> maped = employees.stream()
            .map(e -> {
                e.setAge(e.getAge() + 1);
                e.setGender(e.getGender().equals("M")?"male":"female");
                return e;
            }).collect(Collectors.toList());*/
    //由于map的参数e就是返回值，所以可以用peek函数。peek函数是一种特殊的map函数，当函数没有返回值或者参数就是返回值的时候可以使用peek函数。
    List<Employee> maped = employees.stream()
            .peek(e -> {
                e.setAge(e.getAge() + 1);
                e.setGender(e.getGender().equals("M")?"male":"female");
            }).collect(Collectors.toList());
    System.out.println(maped);
}



//5.排序 sorted
//sorted
List<String> sorted = list.stream().sorted().collect(Collectors.toList());
System.out.println(sorted);
//对象排序需要在sorted中定制
Stream<T> sorted(Comparator<? super T> comparator);
sorted( (a,b)->{
    xxxx
    return xxx;
})

5. 中止操作

//1.匹配与查找
allMatch（predicate）
    boolean allMatch = list.stream().allMatch(e -> e.length() > 4);  //是否所有数值字段长度大于4

anyMatch（predicate）
     boolean anyMatch = list.stream().anyMatch(e -> e.length() > 4); //只要有一个数值长度大于4，返回true

noneMatch（predicate）
    boolean noneMatch = list.stream().noneMatch(e -> e.length() > 4); //是否没有一个匹配的元素，是返回true

findFirst（）
	Optional<String> first = list.stream().findFirst();  //返回第一个元素

findAny()
    Optional<String> any = list.stream().findAny(); //返回任意一个元素

count（） //求个数
    
max(Comparator) //返回流中最大值
    list.stream().max((e1,e2)->{
            return e1.compareTo(e2);
        });

min(Comparator) //返回流中最大值
    list.stream().min((e1,e2)->{
            return e1.compareTo(e2);
        });
  
foreach(Consumer)
    list.stream().sorted().forEach(System.out::println);

//归约
reduce(T identity, BinaryOperator<T> accumulator);  可以将元素重复结合，得到一个值
     List<Integer> list1= Arrays.asList(1,2,3,4);
     Integer reduce = list1.stream().reduce(0, (e1, e2) -> e1 + e2);  0是初始值
     System.out.println(reduce);

reduce(BinaryOperator<T> accumulator);  //也可以直接计算，比如一个集合类中所有人工资总和

//收集
collect（Collector）
    看上述笔记

5.Optional类

为了解决空指针，所以引入Optional

1. Optional 防止空指针污染，是一个容器类，可以保存类型T的值 代表这个类存在

User user = new User();
Optional<User> user1 = Optional.of(user);  //保证user非空

user=null;
Optional<User> user2 = Optional.ofNullable(user); //传入对象可以为空

2. 实例

user=null;
Optional<User> user2 = Optional.ofNullable(user); //传入对象可以为空
User user3 = user2.orElse(null);// 如果Optional 内部返回努力了，则返回自己默认的值，否则返回自己的值