JDK8新特性
关于jdk8的改变大体有对lambda表达式(借鉴其他语言的函数式编程方式)简化很多啰嗦的代码,还有就是流的操作,类似把集合当做数据库,java的流操作当做SQL,这样方便对集合的数据进行操作,当然对JDK的升级还有很多,这里只是小结一些常用的.
GitHub https://github.com/zhang-xiaoxiang/jdk8
1lambda表达式简单试用
package java1;
import org.junit.Test;
import java.util.Comparator;
/**
* LambdaTest:Lambda表达式的使用举例
*
* @author zhangxiaoxiang
* @date 2019/9/8
*/
public class LambdaTest {
/**
* 例子1
*/
@Test
public void test1() {
/**
* 没有使用lambda表达式的写法(其实idea会提示使用)
*/
//线程的匿名实现类的写法
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("我是常规写法,匿名实现的写法!");
}
};
r1.run();
System.out.println("lambda表达式写法*************************");
//lambda表达式写法
Runnable r2 = () -> System.out.println("我是jdk8提供的lambda写法");
r2.run();
}
/**
* 例子2
*/
@Test
public void test2() {
//Comparator用于比较的类
Comparator com1 = new Comparator() {
/**
* o1比o2大返回1小则返回-1,相等返回0
* @param o1
* @param o2
* @return
*/
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
int compare1 = com1.compare(12, 21);
System.out.println(compare1);
System.out.println("Lambda表达式的写法(常规一点的)***********************");
//Lambda表达式的写法(还可以改.idea会提示你)
Comparator com2 = (o1, o2) -> Integer.compare(o1, o2);
int compare2 = com2.compare(32, 21);
System.out.println(compare2);
System.out.println("Lambda表达式的写法(方法引用的方式)***********************");
//方法引用
Comparator com3 = Integer::compare;
int compare3 = com3.compare(32, 21);
System.out.println(compare3);
}
}
2lambda表达式详细写法小结
package java1;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;
/**
* 1.举例： (o1,o2) -> Integer.compare(o1,o2);
* 2.格式：
* -> :lambda操作符 或 箭头操作符
* ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
* ->右边：lambda体 （其实就是重写的抽象方法的方法体）
* 3. Lambda表达式的使用：（分为6种情况介绍）
* 总结：
* ->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个参数，其一对()也可以省略
* ->右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字
* 4.Lambda表达式的本质：作为函数式接口的实例
* 5. 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，
* 这样做可以检查它是否是一个函数式接口。
* 6. 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。
*/
public class LambdaTest1 {
/**
* 语法格式一：无参，无返回值
*/
@Test
public void test1() {
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("语法格式一：无参，无返回值");
}
};
r1.run();
System.out.println("***********************");
Runnable r2 = () -> {
System.out.println("语法格式一：无参，无返回值");
};
r2.run();
}
/**
* 语法格式二：Lambda 需要一个参数，但是没有返回值。
* 其实就是消费型
*/
@Test
public void test2() {
Consumer con = new Consumer() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("我是入参");
System.out.println("*******************");
//如果只有一段实现代码,{}也可以不要
Consumer con1 = (String s) -> System.out.println(s);
con1.accept("我是Lambda格式的入参,左边是形参 ->右边是实现,用于消费形参的哈");
}
/**
* 语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
*/
@Test
public void test3() {
//idea会建议Lambda can be replaced with method reference
Consumer con1 = (String s) -> {
System.out.println(s);
};
con1.accept("数据类型可以省略,类型推断");
System.out.println("*******************");
Consumer con2 = System.out::println;
con2.accept("::就是方法引用的方式,称为“类型推断”");
}
/**
* 凑数的测试
*/
@Test
public void test3A() {
//类型推断
ArrayList list = new ArrayList<>();
//类型推断
int[] arr = {1, 2, 3};
}
/**
* 语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
*/
@Test
public void test4() {
Consumer con1 = (s) -> {
System.out.println(s);
};
con1.accept("语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略");
System.out.println("*******************");
Consumer con2 = s -> {
System.out.println(s);
};
con2.accept("语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略");
}
/**
* 语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
*/
@Test
public void test5() {
Comparator com1 = new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
};
System.out.println(com1.compare(12, 21));
System.out.println("*****************************");
Comparator com2 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(com2.compare(12, 6));
}
/**
* 语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
*/
@Test
public void test6() {
Comparator com1 = (o1, o2) -> {
return o1.compareTo(o2);
};
System.out.println(com1.compare(12, 6));
System.out.println("*****************************");
//可以使用方法应用的方式 Comparator com2 = Integer::compareTo;
Comparator com2 = (o1, o2) -> o1.compareTo(o2);
System.out.println(com2.compare(12, 21));
}
}
3java内置函数式接口(这里只提供了2个示例)
package java1;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
/**
* LambdaTest2 :内置函数式接口
*
* 消费型接口 Consumer void accept(T t)
* 供给型接口 Supplier T get()
* 函数型接口 Function R apply(T t)
* 断定型接口 Predicate boolean test(T t)
*
* @author zhangxiaoxiang
* @date 2019/9/8
*/
public class LambdaTest2 {
/**
* 消费型接口 输入参数有因无果,被消费了你说气了不气人
*
* @param money
* @param con
*/
public void happyTime(double money, Consumer con) {
con.accept(money);
}
/**
* 测试消费型
*/
@Test
public void test1() {
happyTime(500, new Consumer() {
@Override
public void accept(Double aDouble) {
System.out.println("消费输出:您老消费的价格是" + aDouble);
}
});
System.out.println("********************");
happyTime(400, money -> System.out.println("消费输出:您老消费的价格是：" + money));
}
/**
* 断定型接口
*
* 根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
*
* @param list 给定基础数据数据
* @param pre 断定规则
* @return
*/
public List filterString(List list, Predicate pre) {
ArrayList filterList = new ArrayList<>();
for (String s : list) {
if (pre.test(s)) {
filterList.add(s);
}
}
return filterList;
}
/**
* 测试断定型接口
*/
@Test
public void test2() {
List list = Arrays.asList("北京", "南京", "天津", "东京", "西京", "普京");
List filterStrS = filterString(list, new Predicate() {
@Override
public boolean test(String s) {
return s.contains("京");
}
});
System.out.println(filterStrS);
List filterStrS1 = filterString(list, s -> s.contains("京"));
System.out.println(filterStrS1);
}
}
4自定义函数式接口
package java1;
/**
* MyInterface:自定义函数式接口
*
* @author zhangxiaoxiang
* @date 2019/9/8
*/
@FunctionalInterface
public interface MyInterface {
void method1();
// void method2();
}
流待写....