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.常见的函数式接口（四个）
- 函数式接口与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循环
- 例子,
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);
- 流程
1.先把集合转为流
list.Stream()
list.parallelStream()
2.操作流
- 操作符，中间操作符，终止操作符
- 中间操作符
//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;
})
- 中止操作
//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
- Optional 防止空指针污染，是一个容器类，可以保存类型T的值 代表这个类存在
User user = new User();
Optional<User> user1 = Optional.of(user); //保证user非空
user=null;
Optional<User> user2 = Optional.ofNullable(user); //传入对象可以为空
- 实例
user=null;
Optional<User> user2 = Optional.ofNullable(user); //传入对象可以为空
User user3 = user2.orElse(null);// 如果Optional 内部返回努力了，则返回自己默认的值，否则返回自己的值
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
