/**
* 【接口中 默认方法 有方法体】
* JDK8之前，接口中可以定义 变量、方法：
* 变量 必须 为 public static final修饰
* 方法 必须 为 public abstract 修饰
*
* JDK8及以后，接口中可以定义 普通方法（有方法体）
* default
* static
*
*/
interface MyJDK8{
void test1();
default void test2(){
System.out.println("test2...");
}
static void test3(){
System.out.println("test3...");
}
}
class MyJDK8Impl implements MyJDK8{
@Override
public void test1() {
System.out.println("test1...");
}
}
/**
* 【lambda表达式】
* why？
* 期望 使用 接口的方法：
* a,写一个class 实现接口；
* b,使用匿名内部类；
* 好处：
* 简化 匿名内部类的调用；
*
* How？
* 使用 lambda表达式 依赖于 函数式接口；
*
* 【函数式接口】
* what？
* 接口 只有 一个 抽象方法，可以 认为该接口是 函数式接口，可以用 @FunctionalInterface 标识
* 规范：
* 函数式接口中 允许 重新 Object方法；
* 函数式接口中 允许 default、static方法；
*
* 语法：
* () :参数列表
* -> ：分隔符
* {} :方法体
*
* 使用：
* a, 无参
* b, 有参
*
*/
interface MyLambda{
void test();
}
void testInterfaceMethod(){
// 使用匿名内部类
new MyLambda(){
@Override
public void test() {
System.out.println("test...");
}
}.test();
// 使用lambda
((MyLambda) () -> System.out.println("test...")).test();
}
@FunctionalInterface
interface MyFuncInterface{
// 唯一 抽象方法
void test();
default void test1(){
System.out.println("test1...");
}
static void test2(){
System.out.println("test2...");
}
// Object 方法
String toString();
}
void testMyFuncInterface(){
MyFuncInterface m = () -> System.out.println("aa");
m.test();
// 简化
((MyFuncInterface) () -> System.out.println("aa")).test();
}
@FunctionalInterface
interface MyFuncInterface1{
String test(String a, String b);
}
void testMyFuncInterface1(){
MyFuncInterface1 m = (a, b) -> {
return a + ":" + b;
};
m.test("a", "b");
// 简化
MyFuncInterface1 m1 = (a, b) -> a + ":" + b;
((MyFuncInterface1) (a, b) -> a + ":" + b).test("aaaa", "bbbbb");
}
/**
* 【Stream】
* 基于 pipeline 设计：
* 数据源 => pipeline（过滤 | 排序...执行器） => 结果数据
* （每个 执行器 都会生成一个新的pipeline）
* （生成新的pipeline后，老的将不会存在）
*
* 特性：
* a, stream不存储数据，变量都在局部变量；
* b, 数据源不会变化；
* c, stream不可以重复使用；
*
* stream的3种操作：
* a,生成初始stream
* b,中间操作
* 返回一个stream
* 可以多个
* c,终值操作
* 仅有一个
*
* stream的执行顺序：
* 每条数据 按pipeline的流程 依次执行；
* eg：pipeline: a-b
* 第一条数据 -a-b-
* 第二条数据 -a-b-
*
* JDK自带的函数式接口：
*
* 方法引用：
* 结合 lambda表达式， 让代码 更加精简；
*
* 种类：
* static方法引用： 类名::static方法
* 对象方法引用： 类名::实例方法
* 实例方法引用： new 对象::实例方法
* 构造函数引用： 类名::new
*
*/
/**
* 【stream的3种操作】
*/
/**
* 初始stream
*/
void initStream(){
Stream<String> stringStream = Stream.of("a", "b");
IntStream intStream = Arrays.stream(new int[]{1, 3});
}
/**
* 中间操作
*/
void middleStream(){
Arrays.asList("a", "b").stream()
.filter(a->{
System.out.println("aa");
return a.equals("aa");
}
);
}
/**
* 终值操作
*/
void finalStream(){
Arrays.asList("a", "b").stream().filter(a->{
System.out.println("aa");
return a.equals("aa");
}).count();
}
class Person{
Person(){
}
Person(String name, Integer age){
this.name = name;
this.age = age;
}
String name;
Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
void testStream(){
Person person = new Person("1", 1);
Person person1 = new Person("2", 2);
// 【转Set】
Set<Person> set = Arrays.asList(person, person1)
.stream()
.collect(Collectors.toSet());
// 【转map】
Map<String, Integer> map = Arrays.asList(person, person1)
.stream()
.collect(Collectors.toMap(
new Function<Person, String>() {
@Override
public String apply(Person person) {
return person.getName();
}
},
new Function<Person, Integer>() {
@Override
public Integer apply(Person person) {
return person.getAge();
}
}
));
// 简化
Map<String, Integer> map1 = Arrays.asList(person, person1)
.stream()
.collect(Collectors.toMap(p -> p.getName(), p -> p.getAge()));
System.out.println(map1);
// 【求和】
Person countPerson = Arrays.asList(person, person1)
.stream()
.reduce(new BinaryOperator<Person>() {
@Override
public Person apply(Person person, Person person2) {
Person p = new Person();
p.setAge(person.getAge() + person2.getAge());
return p;
}
})
.get();
// 简化
Person countPerson1 = Arrays.asList(person, person1)
.stream()
.reduce((p1, p2) -> {
Person p = new Person();
p.setAge(p1.getAge() + p2.getAge());
return p;
})
.get();
System.out.println(countPerson1.getAge());
// 【max || min】
Person maxPerson = Arrays.asList(person, person1)
.stream()
.max(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
})
.get();
// 简化
Person maxPerson1 = Arrays.asList(person, person1)
.stream()
.max((p1, p2) -> p1.getAge() - p2.getAge())
.get();
System.out.println(maxPerson1.getAge());
// 【match】
boolean match = Arrays.asList(person, person1)
.stream()
.anyMatch(new Predicate<Person>() {
@Override
public boolean test(Person person) {
return person.getName().equals("jack");
}
});
// 简化
boolean match1 = Arrays.asList(person, person1)
.stream()
.anyMatch(p -> p.getName().equals("jack"));
System.out.println(match1);
// 【Filter】
Set<Person> filter1 = Arrays.asList(person, person1)
.stream()
.filter(new Predicate<Person>() {
@Override
public boolean test(Person person) {
return person.getName().equals("jack");
}
})
.collect(Collectors.toSet());
// 简化
Set<Person> filter2 = Arrays.asList(person, person1)
.stream()
.filter(p -> p.getName().equals("jack"))
.collect(Collectors.toSet());
System.out.println(filter2);
// 【分页】
Set<Person> limit1 = Arrays.asList(person, person1)
.stream()
.skip(0)
.limit(3)
.collect(Collectors.toSet());
System.out.println(limit1);
// 【排序】
Set<Person> sort = Arrays.asList(person, person1)
.stream()
.sorted(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o2.getAge() - o1.getAge();
}
})
.collect(Collectors.toSet());
// 简化
Set<Person> sort1 = Arrays.asList(person, person1)
.stream()
.sorted((p1, p2) -> p2.getAge() - p1.getAge())
.collect(Collectors.toSet());
System.out.println(sort1);
}
