前言:

java8的好处: 速度更快、代码更少(Lambda表达式)、强大的Stream API、便于并行、最大化减少空指针异常(Optoinal)、Nashorn引擎，允许在JVM上运行JS应用等

1.Lambda表达式*

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是 一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

public class test_Lambda{// 1.举例: (o1,o2) -> Integer.compare(o1,o2);// 2.格式://      -> :Lambda操作符，或 箭头操作符//          左边：Lambda形参列表(其实是接口中的抽象方法的形参列表)//          右边：Lambda体(其实是重写抽象方法的方法体)// 3.使用: 分为6种情况(格式)介绍//      * 左边：Lambda形参列表的参数类型可以省略; Lambda若只有一个参数，可以省略小括号//      * 右边：Lambda体应使用一对大括号包裹；Lambda体若只有一条执行语句(包含return语句),可以省略该大括号和return关键字(省略大括号则必须省略return);// 4.本质: 作为函数式接口的实例(实现类对象)[只有一个抽象方法的接口，也称为函数式接口]/* 1.无参无返回值 */public static void t1(){Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("我爱北京天安门~");}};r1.run();System.out.println("------------");Runnable r2 = () -> {System.out.println("我爱地球!");};r2.run();}/* 2.有参数无返回值 */public static void t2(){Consumer<String> con = new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}};con.accept("abc");System.out.println("-------------");Consumer<String> con1 = (String s) -> {System.out.println(s);};con1.accept("def");}/* 3.数据类型可以省略，因为可由编译器推断得出，称为 “类型推断” */public static void t3(){Consumer<String> con1 = (String s) -> {System.out.println(s);};con1.accept("def");System.out.println("-------------");Consumer<String> con2 = (s) -> {System.out.println(s);};con1.accept("def2");}/* 4.Lambda若需要一个参数，参数的小括号可以省略 */public static void t4(){Consumer<String> con1 = (s) -> {System.out.println(s);};con1.accept("def1");System.out.println("----------");Consumer<String> con2 = s -> {System.out.println(s);};con1.accept("def2");}/* 5.Lambda若需要两个或以上的参数，多条执行语句，并且可以有返回值 */public static void t5(){Comparator<Integer> com1 = new Comparator<Integer>() {@Overridepublic 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<Integer> com2 = (o1,o2) -> {System.out.println(o1);System.out.println(o2);return o1.compareTo(o2);};System.out.println(com2.compare(12, 21));}/* 6.若Lambda体只有一条语句时，return与大括号若有，都可以省略 */public static void t6(){Comparator<Integer> com1 = (o1,o2) -> {return o1.compareTo(o2);};System.out.println(com1.compare(12, 21));System.out.println("-------------");Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);System.out.println(com2.compare(12, 21));}public static void main(String[] args) {t6();}
}

2.函数式(Functoinal)接口

如果一个接口中，只声明了一个抽象式方法，则此接口就称为函数式接口
 
你可以通过Lambda表达式来创建该接的对象。（若Lambda表达式抛出一个受检异常（即：非运行时异常），那么该异常需要在目标接口的抽象方法上进行声明)
 
我们可以在一个接口上使用 @Functionallnterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。
 
在java.util.function包下定义了Java8的丰富的函数式接口

public class test {public static void t1(double money, Consumer<Double> con){con.accept(money);}public static List<String> t2(List<String> list, Predicate<String> pre){// 根据给定的pre规则来过滤字符串ArrayList<String> list1 = new ArrayList<>();for (String s : list) {if(pre.test(s)){list1.add(s);}}return list1;}public static void main(String[] args) {/* 1.Consumer */t1(100, new Consumer<Double>() {@Overridepublic void accept(Double aDouble) {System.out.println("消费了"+ aDouble + "r");}});System.out.println("----------");t1(100,aDouble -> System.out.println("消费了"+ aDouble + "r"));System.out.println("-----------");/* 2.Predicate */List<String> list = new ArrayList<>();list.add("ad");list.add("abc");list.add("fwf");list.add("w");List<String> strings = t2(list, new Predicate<String>() {@Overridepublic boolean test(String s) {return s.length() >= 2;}});System.out.println(strings);System.out.println("------------");List<String> strings1 = t2(list, s -> s.length() >= 2);System.out.println(strings1);}}

3.方法引用和构造器引用

● 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
 
● 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
 
● 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的
方法的参数列表和返回值类型保持一致！
 
● 格式：使用操作符“：”将类（或对象）与方法名分隔开来。
 
● 如下三种主要使用情况：
   对象：实例方法名
   类：静态方法名
   类：实例方法名

3.1 对象 :: 非静态方法

public class test {/*方法引用的使用1.使用情境: Lambda体的操作已经有实现的方法，可以使用方法引用2.方法引用: 本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例，所以方法引用，也是函数式接口的实例3.使用格式: 类(或对象) :: 方法名4.具体分为如下三种情况:对象 :: 非静态方法类   :: 静态方法类   :: 非静态方法5.方法引用的要求: 要求接口中的抽象方法形参列表和返回值类型与方法引用中的形参列表和返回值类型相同*//* 情况1：对象 :: 非静态方法 */// Consumer中的 void accept(T t)// PrintStream中的 void println(T t)public static void t1(){Consumer<String> con1 = str -> System.out.println(str);con1.accept("abc");System.out.println("---------------");PrintStream ps = System.out;Consumer<String> con2 = ps::println;con2.accept("123");}// Supplier中的 T get()// person中的 String getName()public static void t2(){person p = new person(12,"张三");Supplier<String> sup1 = () -> p.getName();System.out.println(sup1.get());System.out.println("--------------");Supplier<String> sup2 = p::getName;System.out.println(sup2.get());}public static void main(String[] args) {t2();}
}

3.2 类 :: 静态方法

public class test {/* 情况2: 类 :: 静态方法 */// Comparator中的 int compare(T t1,T t2)// Integer中的 int compare(T t1,T t2)public static void t1(){Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1,t2);System.out.println(com1.compare(12, 13));System.out.println("------------");Comparator<Integer> com2 = Integer::compare;System.out.println(com2.compare(13, 12));// Function中的 R apply(T t)// Math中的 Long Math(Double d)}/* 情况3 类 :: 非静态方法 */// Comparator中的 int compara(T t1,T t2)// String中的 int t1.compareTo(t2)public static void t2(){Comparator<String> com1 = (t1,t2) -> t1.compareTo(t2);System.out.println(com1.compare("abc", "ade"));System.out.println("------------");Comparator<String> com2 = String::compareTo;System.out.println(com2.compare("ade", "abc"));}// Function中的 R apply(T t)// person中的 String getName()public static void t3(){person p = new person(12,"李四");Function<person,String> func1 = e -> e.getName();System.out.println(func1.apply(p));System.out.println("-------------");Function<person,String> func2 = person::getName;System.out.println(func2.apply(p));}public static void main(String[] args) {t3();}
}

3.3 构造器引用

public class test {/* 1.构造器引用: 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的对 */// Supplier中的 T get()// person的 new person()public static void t1(){Supplier<person> sup1 = () -> new person();person person1 = sup1.get();System.out.println(person1);System.out.println("----------");Supplier<person> sup2 = person::new;package1.person person2 = sup2.get();System.out.println(person2);}// Function中的 R apply(T t)// peron的 person(int age)public static void t2(){Function<Integer,person> func1 = age -> new person(age);person apply1 = func1.apply(12);System.out.println(apply1);System.out.println("------------");Function<Integer,person> func2 = person::new;person apply2 = func2.apply(34);System.out.println(apply2);}// BiFunction中的 R Function(T t,U u)// person中的 new person(int age,Strign name)public static void t3(){BiFunction<Integer,String,person> bif1 = (age,name) -> new person(age,name);person p1 = bif1.apply(12, "张三");System.out.println(p1);System.out.println("------------");BiFunction<Integer,String,person> bif2 = person::new;person p2 = bif2.apply(45, "李四");System.out.println(p2);}// 数组引用: 把数组看成一个特殊的类.和构造器引用一致// Function中的 R apply(T t)public static void t4(){Function<Integer,String[]> func1 = lenght -> new String[lenght];String[] apply1 = func1.apply(10);System.out.println(apply1.length);System.out.println("--------");Function<Integer,String[]> func2 = String[]::new;String[] apply2 = func2.apply(12);System.out.println(apply2.length);}public static void main(String[] args) {t4();}
}

4.Stream API*

● Java8中有两大最为重要的改变。第一个是 Lambda表达式; 另外一个则 是 Stream APl.
 
● Stream API(java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream APl可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
 
● Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查。也可以使用Stream API来并行执行操作。简言之，Stream API提供了一种高效且易于使用的处理数据的方式。

● 实际开发中，项目中多数数据源都来自于Mysql,Oracle等。但现在数据源可以更多了，有MongDB,Radis等，而这些NoSQL的数据就需要Java层面去处理。
 
● Stream和Collection集合的区别：Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU,通过CPU实现计算。
 
注意：
①Stream自己不会存储元素。
②Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

● 1.创建Stream
一个数据源（如：集合、数组），获取一个流
 
● 2.中间操作
一个中间操作链，对数据源的数据进行处理
 
● 3.终止操作（终端操作）
一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

4.1 Stream的实例化

public class Employee implements Comparable<Employee>{private int id;private String name;private int age;private double salary;public Employee(){}public Employee(int id, String name, int age, double salary) {this.id = id;this.name = name;this.age = age;this.salary = salary;}public String getName() {return name;}public int getAge() {return age;}public double getSalary() {return salary;}@Overridepublic String toString() {return "Employee{" +"id=" + id +", name='" + name + '\'' +", age=" + age +", salary=" + salary +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Employee employee = (Employee) o;if (id != employee.id) return false;return name != null ? name.equals(employee.name) : employee.name == null;}@Overridepublic int hashCode() {int result = id;result = 31 * result + (name != null ? name.hashCode() : 0);return result;}@Overridepublic int compareTo(Employee e) {return Double.compare(salary,e.getSalary());}
}

public class EmployeeData {public static List<Employee> getEmployees(){List<Employee>list = new ArrayList<>();list.add(new Employee(1001,"马化腾",34,6000.38));list.add(new Employee(1002,"马云",12,9876.12));list.add(new Employee(1003,"刘强东",33,3000.82));list.add(new Employee(1004,"雷军",26,7657.37));list.add(new Employee(1005,"李彦宏",65,5555.32));list.add(new Employee(1006,"比尔盖茨",42,9500.43));list.add(new Employee(1007,"任正非",26,4333.32));list.add(new Employee(1008,"扎克伯格",35,2500.32));return list;}}

创建方式1：通过集合

Java8中的Collection接口被扩展，提供了两个获取流的方法：
● default Stream stream(): 返回一个顺序流
● default Stream parallelStream(): 返回一个并行流

public class Main{public static void main(String[] args){List<Employee> employees = EmployeeData.getEmployees();// default Stream<E> stream(): 返回一个顺序流Stream<Employee> stream = employees.stream(); // 按顺序取数据// default Stream<E> parallelStream(): 返回一个并行流Stream<Employee> employeeStream = employees.parallelStream(); // 并行取数据，通过线程}
}

创建方式2：通过数组

Java8中的Arrays的静态方法stream)可以获取数组流：
● static Stream stream(T[] array): 返回一个流
 
重载形式，能够处理对应基本类型的数组：
● public static IntStream stream(int[]array)
● public static LongStream stream(long[]array)
● public static DoubleStream stream(double[]array)

public class Main{public static void main(String[] args){int[] arr = new int[]{1,2,3,4,5,6};// 调用Arrays.类static<T>Stream<T>stream(T[]array):返回一个流IntStream stream = Arrays.stream(arr);Employee e1 = new Employee(1,"a",12,12);Employee e2 = new Employee(2,"b",13,22);Employee[] employees = new Employee[]{e1,e2};Stream<Employee> stream1 = Arrays.stream(employees);}
}

创建方式3: 通过Stream的of()

可以调用Stream类静态方法of),通过显示值创建一个
流。它可以接收任意数量的参数。
● public static Stream of(T.values): 返回一个流

public class Main{public static void main(String[] args){}
}

4.2 Stream的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”

4.2.1 筛选与切片

filter(Predicate p): 接收Lambda,从流中排除某些元素
limit(long maxSize): 截断流，使其元素不超过给定数量
skip(long n): 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
distinct(): 筛选，通过流所生成元素的hashCode()和equals()去除重复元素

public class Main{public static void main(String[] args) {List<Employee> list = EmployeeData.getEmployees();// 1.filter(Predicate p)Stream<Employee> stream = list.stream();// 查询工资大于7000的员工stream.filter(e -> e.getSalary()>7000).forEach(System.out::println);System.out.println("-----------");// 2.limit(long maxSize)Stream<Employee> stream1 = list.stream();stream1.limit(3).forEach(System.out::println);System.out.println("-----------");// 3.skip(long n)Stream<Employee> stream2 = list.stream();stream2.skip(3).forEach(System.out::println);System.out.println("-----------");// 4.distinct()list.add(new Employee(1001,"马化腾",45,4000));for (Employee employee : list) {System.out.println(employee);}System.out.println("我是分割线~");Stream<Employee> stream3 = list.stream();stream3.distinct().forEach(System.out::println);}
}

4.2.2 映射

map(Function f): 接收一个函数作为参效，该函数会被应用到母元素上，并将其映射成一个新的元素。
flatMap(Function f): 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
mapToDouble(ToDoubleFunction f): 接收一个函数作为参数，该数会被应用到每个元素上，产生一个新的DoubleStream。
mapTolnt(TolntFunction f): 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。
mapToLong(ToLongFunction f): 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream。

public class test{public static Stream<Character> fromStringToStream(String str){ArrayList<Character> list= new ArrayList<>();for(Character c:str.toCharArray()){list.add(c);}return list.stream();}public static void main(String[] args) {// 1.map(Function f)List<String> strings = Arrays.asList("aa", "bb", "cc", "dd");strings.stream().map(String::toUpperCase).forEach(System.out::println);System.out.println("---------");// 获取名字大于3的员工姓名List<Employee> employees = EmployeeData.getEmployees();Stream<String> stringStream = employees.stream().map(Employee::getName);stringStream.filter(str -> str.length()>3).forEach(System.out::println);System.out.println("---------");// 将流中的每个元素取出到一个流中Stream<Stream<Character>> streamStream = strings.stream().map(test::fromStringToStream);streamStream.forEach(s -> s.forEach(System.out::println));System.out.println("---------");// 2.flatMap(Function f)Stream<Character> characterStream = strings.stream().flatMap(test::fromStringToStream);characterStream.forEach(System.out::println);}
}

4.3.3 排序

sorted(): 产生一个新流，其中按自然顺序排序
sorted(Comparator com): 产生一个新流，其中按比较器顺序排序

public class test{public static void main(String[] args) {List<Integer> list = Arrays.asList(12, 45, 2, 12, 6, 90);// 1.自然排序list.stream().sorted().forEach(System.out::println);List<Employee> employees= EmployeeData.getEmployees();employees.stream().sorted().forEach(System.out::println);// 2.定制排序employees.stream().sorted((e1,e2) ->{int i = Integer.compare(e1.getAge(),e2.getAge());return i!=0?i:e1.getName().compareTo(e2.getName());}).forEach(System.out::println);}
}

4.3 Stream的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer或者是void。
流进行了终止操作后，不能再次使用。

4.3.1 匹配与查找

allMatch(Predicate p): 检查是否匹配所有元素
anyMatch(Predicate p): 检查是否至少匹配一个元素
noneMatch(Predicate p): 检查是否没有匹配所有元素
findFirst(): 返回第一个元素
findAny(): 返回当前流中的任意元素
count(): 返回流中元素总数
max(Comparator c): 返回流中最大值
min(Comparator c): 返回流中最小值
forEach(Consumer c): 内部迭代（使用Collection接口需要用户去做迭代，称为外部迭代。相反，Stream API使用内部迭代—它帮你把迭代做了)

public class test{public static void main(String[] args) {List<Employee> employees = EmployeeData.getEmployees();// 1.allMatch(Predicate p):// 是否所有员工的年龄都大于18System.out.println(employees.stream().allMatch(employee -> employee.getAge() > 18)); // false// 2.anyMatch(Predicate p):// 判断是否至少一个工资大于9000System.out.println(employees.stream().anyMatch(employee -> employee.getSalary() > 9000)); // true// 3.noneMatch(Predicate p)// 是否所有员工都不小于18System.out.println(employees.stream().noneMatch(employee -> employee.getSalary() < 2000)); // true// 4.findFirst()System.out.println(employees.stream().sorted().findFirst()); // Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]// 5.findAny()System.out.println(employees.stream().findAny()); // Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]// 6.count()System.out.println(employees.stream().filter(e -> e.getSalary()>5000).count()); // 5// 7.max(Comparator c)System.out.println(employees.stream().max(Employee::compareTo)); // Optional[Employee{id=1002, name='马云', age=12, salary=9876.12}]// 8.min(Comparator c)System.out.println(employees.stream().filter(e -> e.getName().length()>2).min(Employee::compareTo)); // Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]// 返回最低的工资Stream<Double> doubleStream = employees.stream().map(Employee::getSalary);System.out.println(doubleStream.min(Double::compareTo));// 9.forEach(Consumer c) -- 内部迭代employees.stream().filter(e -> e.getAge()>20).forEach(System.out::println); // ...employees.forEach(System.out::println);}
}

4.3.2 归约

reduce(T iden,BinaryOperator b): 可以将流中元素反复结合起来，得到一个值。返回T
educe(BinaryOperator b): 可以将流中元素反复结合起来，得到一个值。返回Optional<T>

public class test{public static void main(String[] args) {// 1.reduce(T iden,BinaryOperator b)// 计算1-10的和List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);System.out.println(list.stream().reduce(0, Integer::sum));// 计算所有员工工资和List<Employee> employees = EmployeeData.getEmployees();Stream<Double> doubleStream = employees.stream().map(Employee::getSalary);System.out.println(doubleStream.reduce(0.0, Double::sum));}
}

4.3.3 收集

collect(Collector c): 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
 
Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List、Set、Map).另外，Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下：

List<T> toList(): 把流中元素收集到List
Set<T> toSet(): 把流中元素收集到Set
Collection<T> toColletion(): 把流中元素收集到创建的集合

public class test{public static void main(String[] args) {List<Employee> employees = EmployeeData.getEmployees();// 查找工资大于6000的员工，将结果返回一个list或setList<Employee> collect = employees.stream().filter(e -> e.getSalary() > 7000).collect(Collectors.toList());collect.forEach(System.out::println);System.out.println("-----------");Set<Employee> collect1 = employees.stream().filter(e -> e.getSalary() > 7000).collect(Collectors.toSet());collect1.forEach(System.out::println);}
}

5.Optional类

● Optional<T>类Gava.util.Optional)是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存nul,表示这个值不存在。原来用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
 
● Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象

● Optiona提供很多有用的方法，这样我们就不用显式进行空值检测。
 
● 创建。ptional类对象的方法：
Optional.of(T t): 创建一个Optional实例，t必须非空；
Optional.empty(): 创建一个空的Optional实例
Optional…ofNullable(Tt): t可以为null
 
● 判断Optional容器中是否包含对象：
boolean isPresent(): 判断是否包含对象
void ifPresent(Consumer<?super T>consumer): 如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
 
● 获取Optional容器的对象：
T get(): 如果调用对象包含值，返回该值，否则抛异常
T orElse(T other)：如果有值则将其返回，否则返回指定的other对象。
T orElseGet(Supplier<？extends T>other): 如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
T orElseThrow(Supplier<?extends X?exceptionSupplier):如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

public class test{public static void newOptional(){// 实例化Employee e = new Employee();Optional<Employee> optional1 = Optional.of(e);Optional<Employee> optional2 = Optional.empty();Optional<Employee> optional3 = Optional.ofNullable(e); // return value == null ? empty() : of(value);}public static String getEmployeeName(Employee employee){return employee.getName();}// 未使用Optionalpublic static void t1(){Employee e = null;if(e != null){getEmployeeName(e);}}// 使用Optionalpublic static void t2(){Employee e = null;Optional<Employee> e1 = Optional.ofNullable(e);System.out.println(getEmployeeName(e1.orElse(new Employee(1, "12", 34, 23)))); // 如果不为空，返回T other}public static void main(String[] args) {t2();}
}

【JavaSE】java8 新特性相关推荐

1. 【Java8新特性】关于Java8的Stream API，看这一篇就够了！！

   写在前面 Java8中有两大最为重要的改变.第一个是 Lambda 表达式:另外一个则是 Stream API(java.util.stream.*)  ,那什么是Stream API呢?Java8中 ...

2. 【Java8新特性】浅谈方法引用和构造器引用

   写在前面 Java8中一个很牛逼的新特性就是方法引用和构造器引用,为什么说它很牛逼呢?往下看! 方法引用 当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用!这里需要注意的是:实现抽 ...

3. java8新特性_Java8新特性之Date API|乐字节

   大家好,我是乐字节的小乐,上篇文章讲述了<Java8新特性之Optional>,接下来,小乐将接着讲述Java8新特性之Date API 2019日历 Java8之Date API Jav ...

4. Java8 新特性之流式数据处理(转)

   转自:https://www.cnblogs.com/shenlanzhizun/p/6027042.html 一. 流式处理简介 在我接触到java8流式处理的时候,我的第一感觉是流式处理让集合操作 ...

5. java8新特性_乐字节-Java8新特性-接口默认方法

   总概 JAVA8 已经发布很久,而且毫无疑问,java8是自java5(2004年发布)之后的最重要的版本.其中包括语言.编译器.库.工具和JVM等诸多方面的新特性. Java8 新特性列表如下: 接 ...

6. java8新特性： lambda表达式：直接获得某个list/array/对象里面的字段集合

   java8新特性: lambda表达式:直接获得某个list/array/对象里面的字段集合 比如,我有一张表: entity Category.java service CategoryServic ...

7. java8新特性_乐字节-Java8新特性-函数式接口

   上一篇小乐带大家学过 Java8新特性-Lambda表达式,那什么时候可以使用Lambda?通常Lambda表达式是用在函数式接口上使用的.从Java8开始引入了函数式接口,其说明比较简单:函数式接口 ...

8. 使用Java8新特性（stream流、Lambda表达式）实现多个List 的笛卡尔乘积 返回需要的List＜JavaBean＞

   需求分析: 有两个Long类型的集合 : List<Long> tagsIds; List<Long> attributesIds; 现在需要将这两个Long类型的集合进行组合 ...

9. java8新特性简述

   Java8发布时间是2014年3月19日,距离今日已经很久了,那么Java8新特性你了解吗? java8是Java的一次重大升级,巨大的里程碑式的改进!! Java语言新特性: 1.与传统结合 -- ...

10. java8新特性（7）— Base64

    java8新特性(7)- Base64 新增Base64工具类 package com.common.jdk8;import java.io.UnsupportedEncodingException; ...

最新文章

1. jsp与java的关系_jsp教程中:jsp与servlet的区别和关系
2. 它又来了！C**HashMap是如何保证线程安全的？会用不就完了？
3. Java源码详解四：String源码分析--openjdk java 11源码
4. 待办事项桌面插件_求一款安卓手机上可添加小目标的桌面便签软件?
5. mongodb创建local库用户_mongodb用户与角色使用
6. 如何使用iToolab FixGo for mac修复iPhone/iPad的系统问题
7. 每周荐书：高可用架构、解忧程序员、财富自由之路（评论送书）
8. Linux：文件格式化与相关处理及sed工具
9. 字典树（前缀树/后缀树）
10. 图相关论文阅读与总结
11. C盘扩容：如何把D盘内存扩展到c盘？
12. PX Deq Credit: send blkd (3)---Script to monitor parallel queries (文档 ID 45
13. 2022年乡村医生考试精选模拟题及答案
14. 【NOIP2016提高组】天天爱跑步
15. 百度官方：网站优化中死链处理指南与总结
16. jQuery插件之图片预加载
17. Linux 电脑系统基本操作
18. java.sql.SQLException: null, message from server: “Host ‘xxx’ is not allowed to connect异常解决
19. 如何删除掉word中多加的分页符？
20. 带时间轴 歌词 示例_Web设计中时间轴的20个精彩示例

热门文章

1. /etc下的host配置文件们
2. Python将字符串转换为日期时间
3. Windows运行单个.bat文件或运行多个.bat文件
4. d3.js：取代d3.mouse的d3.pointer
5. 【python安装】其他支持库的安装
6. 快速排序的优化1: 选取中间值或随机值作为基准，C语言实现
7. 计算机基础课件第三章ppt,计算机应用基础（windows 7+office 2010）课件 第三章 Windows7操作系统.ppt.pdf-汇文网...
8. java中enhancer试什么_Java Enhancer類代碼示例
9. 海伦司上市在即：“嚣张”气势堪比瑞幸，核心竞争力存不存在？
10. Python正则表达式匹配各种标准形式整理