java jdk8 新特性_GitHub - xiexiely/jdk8: Jdk 8 新特性

最新推荐文章于 2022-02-14 08:59:33 发布

weixin_39576149

最新推荐文章于 2022-02-14 08:59:33 发布

阅读量162

点赞数

文章标签： java jdk8 新特性

本文链接：https://blog.csdn.net/weixin_39576149/article/details/114531247

版权

jdk8

Jdk 8 新特性

Lambda表达式

Java匿名内部类

public class SwingTest {

public static void main(String[] args) {

System.out.println("hello world");

JFrame jFrame = new JFrame("My Jframe");

JButton jButton = new JButton("My JButton");

//增加事件处理器点击触发事件

jButton.addActionListener(e -> System.out.println("Button Pressed"));

jFrame.add(jButton);

jFrame.pack();

jFrame.setVisible(true);

jFrame.setDefaultCloseOperation(jFrame.EXIT_ON_CLOSE);

}

Lambda表达式基本结构

(param1 , param2 , param3) -> {

system.out.println("hello world");

};

函数式接口

The type is an interface type and not an annotation type, enum, or class.

The annotated type satisfies the requirements of a functional interface.

数组遍历

public class Test1 {

public static void main(String[] args) {

//集合

List list = Arrays.asList(1,2,3,4,5,6,7,8);

System.out.println("---------普通遍历list-----------");

//普通遍历list

for (int i = 0 ; i

System.out.print(list.get(i));

}

System.out.println();

System.out.println("----------增强for循环外部迭代------------");

//增强for循环

for (Integer i : list){

System.out.print(i);

}

System.out.println();

System.out.println("---------Consumer内部迭代-------------");

//jdk8 Consumer 匿名内部类

list.forEach(new Consumer() {

@Override

public void accept(Integer integer) {

System.out.print(integer);

}

});

System.out.println();

System.out.println("---------lambda-------------");

//jdk8 lambda 表达式

list.forEach( (integer) -> {

System.out.print(integer);

});

System.out.println();

System.out.println("------方法引用---------");

list.forEach(System.out::print);

}

MyInterface myInterface = () -> {

System.out.println("hello");

};

函数式接口可以通过3种方式实现

lambda表达式引用

方法引用

构造方法引用

lambda 表达式基本语法

public boolean createList(List managers, String wishApplyId, String userId) {

List list = new ArrayList<>();

managers.forEach(wishManager -> {

WishAuthorize wishAuthorize = new WishAuthorize();

wishAuthorize.setCreateUserId(userId);

wishAuthorize.setUserId(wishManager.getUserId());

wishAuthorize.setWishApplyId(wishApplyId);

list.add(wishAuthorize);

});

return worthServiceprovider.getWishAuthorizeService().insertBatch(list);

}

Function

compose andThen 方法的调用

compose : 先操作最后一个参数，然后再操作前一个参数

andThen ：先操作第一个参数，然后再操作后一个参数

函数式编程:四则运算

函数式编程 Function 、BiFunction实现的多种方式

函数式编程 Predicate 判断 true Or false

Predicate 进阶

public class PredicateTest2 {

public static void main(String[] args) {

List list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

PredicateTest2 predicateTest2 = new PredicateTest2();

//找到集合所有的奇数

predicateTest2.conditionFilter(list,item ->item % 2 != 0);

System.out.println("------------------");

//找到集合所有的偶数

predicateTest2.conditionFilter(list,item ->item % 2 == 0);

System.out.println("------------------");

//找到集合大于5的数

predicateTest2.conditionFilter(list,item -> item > 5);

System.out.println("------------------");

//打印集合所有元素

predicateTest2.conditionFilter(list,item -> true );

}

//函数式编程传递行为不传递值传递2个值一个数组，第二个行为

public void conditionFilter(List list, Predicate predicate){

for (Integer integer : list){

if (predicate.test(integer)){

System.out.print(" "+integer);

}

System.out.println();

}

//面向对象

public void findAllEven(List list){

for(Integer i : list){

if(i % 2 == 0){

System.out.print(" "+integer);

}

Predicate And Or Negate

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.function.Predicate;

/**

* @Auther: 梓

* @Date: 2019/3/8 15:14

* @Description:

public class PredicateTest3 {

public static void main(String[] args) {

//要求找出当前集合所有大于5 而且是偶数的集合

List list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

PredicateTest3 predicateTest3 = new PredicateTest3();

System.out.println("------------AND----------------------");

predicateTest3.conditonFilter(list,item -> item > 5 ,item -> item % 2 ==0);

System.out.println("-------------OR----------------------");

predicateTest3.conditonFilter2(list,item -> item > 5 ,item -> item % 2 ==0);

System.out.println("-------------Negate------------------");

predicateTest3.conditonFilter3(list,item -> item > 5 ,item -> item % 2 ==0);

System.out.println("------------equls---------------------");

String a = "test";

if ("test".equals(a)){

System.out.println(a);

}

System.out.println("----------------isEqual----------------");

System.out.println(Predicate.isEqual("test").test("a"));

}

public void conditonFilter(List list, Predicate predicate,Predicate predicate2){

for(Integer integer : list){

if (predicate.and(predicate2).test(integer)){

System.out.print( " "+integer);

}

System.out.println();

}

public void conditonFilter2(List list, Predicate predicate,Predicate predicate2){

for(Integer integer : list){

if (predicate.or(predicate2).test(integer)){

System.out.print(" "+integer);

}

System.out.println();

}

public void conditonFilter3(List list, Predicate predicate,Predicate predicate2){

for(Integer integer : list){

if (predicate.and(predicate2).negate().test(integer)){

System.out.print(" "+integer);

}

System.out.println();

}

public Predicate isEqual (Object object){

return Predicate.isEqual(object);

}

Supplier 函数式接口 : get()

实际场合常用于工厂类

public class StudentTest {

public static void main(String[] args) {

System.out.println("----------Supplier---");

Supplier studentSupplier = () -> new Student();

System.out.println(studentSupplier.get().getAge());

System.out.println("---构造方法引用----");

Supplier studentSupplier1 = Student::new;

System.out.println(studentSupplier1.get().getName());

}

BinaryOpertor : 比较二个参数

public class BinaryOpertorTest {

public static void main(String[] args) {

BinaryOpertorTest binaryOperator = new BinaryOpertorTest();

System.out.println(binaryOperator.compute(1,2,(value,value2) -> value + value2));

System.out.println("------minBy--长度--------");

System.out.println(binaryOperator.getShort("hello123","hello4567", (a,b) -> a.length() - b.length() ));

System.out.println("------minBy--首字母--------");

System.out.println(binaryOperator.getShort("hello","aorld",(a,b) ->a.charAt(0) - b.charAt(0)));

}

public int compute (int a ,int b , BinaryOperator binaryOperator){

return binaryOperator.apply(a,b);

}

public String getShort (String a ,String b,Comparator comparator){

return BinaryOperator.minBy(comparator).apply(a,b);

}

Optional ：函数式判断NPE 从数据库取出来的数据不一定知道为空使用isNotable

public class OptionalTest {

public static void main(String[] args) {

// Optional optional = Optional.of("hello");

Optional optional = Optional.empty();

//取值

if (optional.isPresent()){

System.out.println(optional.get());

}

//推薦使用構建一個為空的Optional

optional.ifPresent(item -> System.out.println(item));

System.out.println("---------------");

System.out.println(optional.orElse("world"));

System.out.println("----------------");

System.out.println(optional.orElseGet(() -> "nihao"));

}

Optional 推荐用法

public class Employee {

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public class Comany {

private String name;

private List employeeList;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public List getEmployeeList() {

return employeeList;

}

public void setEmployeeList(List employeeList) {

this.employeeList = employeeList;

}

public class OptionalComany {

public static void main(String[] args) {

Employee employee = new Employee();

employee.setName("zhangshan");

Employee employee1 = new Employee();

employee1.setName("lisi");

Comany comany = new Comany();

comany.setName("comany1");

List employees = Arrays.asList(employee,employee1);

comany.setEmployeeList(employees);

//如果存在則返回，不存在返回空數組

// List list = comany.getEmployeeList();

// if (null != list){

// return list;

// }else

// return new ArrayList();

Optional optional = Optional.ofNullable(comany);

System.out.println(optional.map(theCompany -> theCompany.getEmployeeList())

.orElse(Collections.emptyList()));

}

//不要試圖將Optional作為方法參數或者在類中聲明optional的成員變量

public void test(Optional optional){

}

方法引用 lamda 表达式的语法糖 :: lamdba表达式只有一个语句而刚好jdk里面又有方法实现

方法引用分类 :

- 类名::静态方法名

- 引用(对象名)::实例方法名

- 类名::实例方法名

- 构造方法引用::类名::new

我们可以方法引用看作【函数指针】 function pointer 指向另外一个函数

classname::staticmethod (方法引用类似函数指针指向方法)

classname.staticmethod (方法调用)

List list = Arrays.asList("0","12");

list.forEach(item -> System.out.println(item));

list.forEach(System.out::print);

public class Student {

private String name;

private int score;

public Student(String name, int score) {

this.name = name;

this.score = score;

}

//排序方法[分数] 升序规则 -正 0 同 1倒序

public static int compareStudentByScore(Student s1 ,Student s2){

return s1.getScore() - s2.getScore();

}

//根据名字asrcl

public static int compareStudentByName(Student s1 ,Student s2){

return s1.getName().compareToIgnoreCase(s2.getName());

}

public int compareByScore(Student student){

return this.getScore() - student.getScore();

}

public int compareBySName(Student student){

return this.getName().compareToIgnoreCase(student.getName());

}

public class StudentComparator {

public int comparatorStudentByScore(Student s1,Student s2){

return s1.getScore() - s2.getScore();

}

public int comparatorStudentByName(Student s1 , Student s2 ){

return s1.getName().compareToIgnoreCase(s2.getName());

}

public class StudentMethondRefTest {

public String getString(Supplier supplier){

return supplier.get()+"test";

}

public String getString2 (String str , Function function){

return function.apply(str);

}

public static void main(String[] args) {

Student student1 = new Student("zhangsan",4);

Student student2 = new Student("lisi",5);

Student student3 = new Student("wangwu",3);

Student student4 = new Student("zhaoliu",6);

List studentList = Arrays.asList(student1,student2,student3,student4);

//lambda 集合排序

studentList.sort((s1,s2) -> Student.compareStudentByScore(s1,s2));

studentList.forEach(student -> System.out.print(" "+student.getScore()));

System.out.println();

System.out.println("-----------1.类名::静态方法名-------------");

//方法引用

studentList.sort(Student::compareStudentByScore);

studentList.forEach(student -> System.out.print(" "+student.getScore()));

System.out.println();

System.out.println("-----------2.引用(对象名)::实例方法名-------------");

//lambda表达式写法

StudentComparator studentComparator = new StudentComparator();

studentList.sort((s1,s2)-> studentComparator.comparatorStudentByScore(s1,s2));

studentList.forEach(student -> System.out.print(" "+student.getScore()));

//方法引用

studentList.sort(studentComparator::comparatorStudentByScore);

studentList.forEach(student -> System.out.print(" "+student.getScore()));

System.out.println();

System.out.println("-----------3.类名::实例方法名-------------");

//lambda表达式写法

studentList.sort(Student::compareByScore);

studentList.forEach(student -> System.out.print(" "+student.getScore()));

System.out.println();

System.out.println("-----------4.jdk自带的排序-------------");

List cities =Arrays.asList("qiandao","chongqing","tianjin","beijing");

Collections.sort(cities,(ctiy1,city2) -> ctiy1.compareToIgnoreCase(city2));

cities.forEach(city-> System.out.print(" "+city));

//等价于

Collections.sort(cities,String::compareToIgnoreCase);

cities.forEach(city-> System.out.print(" "+city));

System.out.println();

System.out.println("-----------5.构造方法引用::类名::new-------------");

StudentMethondRefTest studentMethondRefTest = new StudentMethondRefTest();

System.out.println(studentMethondRefTest.getString(String::new));

System.out.println(studentMethondRefTest.getString2("hello",String::new));

}

默认构造方法

public interface MyInterface {

default void myMythod(){

System.out.println("MyMethod");

}

public interface MyInterface2 {

default void myMythod(){

System.out.println("MyMethod2");

}

public class MyInterfaceImpl implements MyInterface {

@Override

public void myMythod() {

System.out.println("MyImpl");

}

public class MyClass implements MyInterface,MyInterface2 {

@Override

public void myMythod() {

MyInterface.super.myMythod();

MyInterface2.super.myMythod();

System.out.println("Myclass");

}

public static void main(String[] args) {

MyClass myClass = new MyClass();

myClass.myMythod();

}

MyMethod

MyMethod2

Myclass

public class MyClass extends MyInterfaceImpl implements MyInterface2 {

// @Override

// public void myMythod() {

// MyInterface.super.myMythod();

// MyInterface2.super.myMythod();

// System.out.println("Myclass");

// }

public static void main(String[] args) {

MyClass myClass = new MyClass();

myClass.myMythod();

}

MyImpl

Stream stream能更好的操作集合

流操作

-源

- 零个或多个中间操作

-终止操作

流操作的分类

-惰性求值

-及早求值

stream.xxx().yyy().zzz().count();

-("惰性求值 (中间操作): xxx().yyy().zzz()" )

-中间操作什么时候被发起 : 只有当 "count()"发起时，中间操作才会被执行

- ("及早求值 : count(): 立马求出值" )

public void getPublishListHash(Map map, List list) {

if (list == null || list.size() <= 0)

return;

List skillIds = list.stream().map(Skill::getId).collect(Collectors.toList());

List skillRegisters = worthServiceprovider.getSkillRegisterService().getRegList(skillIds);

Map registerCountHash = skillRegisters.stream()

.collect(groupingBy(SkillRegister::getSkillId, Collectors.counting()));

Map registerSuccessCountHash = skillRegisters.stream()

.filter(e -> e.getStatus().equals(SkillRegisterStatus.SUCCESS.status))

.collect(groupingBy(SkillRegister::getSkillId, Collectors.counting()));

map.put("registerCountHash", registerCountHash);

map.put("registerSuccessCountHash", registerSuccessCountHash);

}

weixin_39576149

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java jdk8 新特性_GitHub - xiexiely/jdk8: Jdk 8 新特性

jdk8Jdk 8 新特性Lambda表达式Java匿名内部类public class SwingTest {public static void main(String[] args) {System.out.println("hello world");JFrame jFrame = new JFrame("My Jframe");JButton jButton = new JButton("...
复制链接

扫一扫