一、Java8新特性
1、新特性
接口的变化
第三代日期时间API
HashMap底层变化
...
Lambda表达式
StreamAPI
Optional类
2、Lambda表达式是一种新的语法糖，它是让Java开始支持“函数式编程”的语法。
Java原来说自己是面向对象的编程语言，所有的操作几乎都是基于对象，“一切皆对象”，
如果某个变量或形参是引用数据类型，那么必须给他赋值一个对象。
在开发中，有时候我们并不关心这个对象，我们关心的是这个对象的某个方法的功能，方法体代码，其实就是函数的实现。
按照面向对象的编程思想，为了传递这段代码，还要new一个对象，就显得有点啰嗦。
函数式编程思想：把函数当成数据传递
public class TestJava8 {
@Test
public void test06(){
//有一个字符串数组
String[] arr = {"hello","Hi","Chai","Jock","world","atguigu"};
//希望对这个数组进行排序，不区分大小写的排序
//调用Arrays工具类有sort方法
Arrays.sort(arr);//区分大小写的，因为这个方法是调用元素的类型String的compareTo方法排序
System.out.println(Arrays.toString(arr));//[Chai, Hi, Jock, atguigu, hello, world]
Arrays.sort(arr, String::compareToIgnoreCase);
System.out.println(Arrays.toString(arr));//[atguigu, Chai, hello, Hi, Jock, world]
}
@Test
public void test05(){
//有一个字符串数组
String[] arr = {"hello","Hi","Chai","Jock","world","atguigu"};
//希望对这个数组进行排序，不区分大小写的排序
//调用Arrays工具类有sort方法
Arrays.sort(arr);//区分大小写的，因为这个方法是调用元素的类型String的compareTo方法排序
System.out.println(Arrays.toString(arr));//[Chai, Hi, Jock, atguigu, hello, world]
Arrays.sort(arr, (o1, o2) -> o1.compareToIgnoreCase(o2));
System.out.println(Arrays.toString(arr));//[atguigu, Chai, hello, Hi, Jock, world]
}
@Test
public void test04(){
//有一个字符串数组
String[] arr = {"hello","Hi","Chai","Jock","world","atguigu"};
//希望对这个数组进行排序，不区分大小写的排序
//调用Arrays工具类有sort方法
Arrays.sort(arr);//区分大小写的，因为这个方法是调用元素的类型String的compareTo方法排序
System.out.println(Arrays.toString(arr));//[Chai, Hi, Jock, atguigu, hello, world]
Arrays.sort(arr, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareToIgnoreCase(o2);
}
});
System.out.println(Arrays.toString(arr));//[atguigu, Chai, hello, Hi, Jock, world]
}
@Test
public void test03(){
//需求：用实现Runnable接口的方式启动一个线程，打印“hello"
new Thread(() ->System.out.println("hello")).start();
}
@Test
public void test02(){
//需求：用实现Runnable接口的方式启动一个线程，打印“hello"
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
}).start();
}
@Test
public void test01(){
//需求：用实现Runnable接口的方式启动一个线程，打印“hello"
MyRunnable my = new MyRunnable();
Thread t = new Thread(my);
t.start();
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("hello");
}
}二、函数式接口
Java中引入了函数式编程思想，但是只有部分情况才支持使用。
Lambda表达式只针对“函数式接口”使用。
1、函数式接口，是SAM接口（Single Abstract Method）有唯一的抽象方法的接口。
回忆之前学过的接口：
1）java.lang.Runnable：
抽象方法：public abstract void run();
（2）java.util.Comparator<T>
抽象方法： int compare(T o1, T o2);
从Comparator<T>接口中看有一个boolean equals(Object obj);，形式也像是抽象方法，
但是不要求我们实现Comparator<T>接口的类强制重写，因为实现类默认从Object继承了一个equals方法的实现。
但是它建议我们重写equals方法。希望equals方法的实现与compare方法的实现，逻辑一致。
例如：Student类 有重写equals方法，按照id来比较的，认为两个id相同的学生对象就是同一个学生对象，
Student类有一个Comparator的比较器StudentComparator，它实现Comparator<T>接口，重写compare方法，
这个方法中说两个学生的成绩score相等，就返回0，就代表他们是“相等”的对象。
如果说，我们把学生对象放到TreeSet中，有序的集合。
（3）java.lang.Comparable<T>
抽象方法：int compareTo(T o);
（4）java.lang.Iterable<T> ：实现它，支持foreach遍历
抽象方法：Iterator<T> iterator();
（5）java.util.Iterator<T> 不是函数式接口，因为有多个抽象方法
抽象方法：
boolean hasNext();
E next();
（6）java.io.Serializable：不是函数式接口，因为没有抽象方法
（7）java.lang.Cloneable：不是函数式接口，因为没有抽象方法
（8）Collection,List,Set,Map都不是，因为有多个抽象方法
（9）java.io.FileFilter
抽象方法：
boolean accept(File pathname);总结：之前学过的接口中，满足函数式接口的要求的
java.lang.Runnable、java.util.Comparator<T>、java.lang.Comparable<T>、java.lang.Iterable<T>、java.io.FileFilter
2、建议对满足函数式接口的特点的接口，并且接口上面标记了@FunctionalInterface注解的接口，再使用Lambda表达式。
上面满足函数式接口的特点的接口中，标记@FunctionalInterface注解的有：
java.lang.Runnable
java.util.Comparator<T>
java.io.FileFilter
java.lang.Comparable<T>接口，没有标记@FunctionalInterface注解，因为它的实现类通常是要比较大小的元素的类型，
例如：Student类本身实现这个接口，这个类里面信息非常丰富，一般不会只关注 compareTo这一个方法。
而我们使用Lambda表达式的场景，通常都是只关注接口的抽象方法的实现的常量。
java.lang.Iterable<T>接口，也没有标记@FunctionalInterface注解，因为它的实现类通常都是容器，ArrayList等，
它里面也不可能值关注Iterator<T> iterator();这一个方法。需要关注更多的add等方法。
总结：学过的接口中只有三个接口，可以使用Lambda表达式。其他的暂时不建议使用。
public class TestFunctionalInterface {
public static void main(String[] args) {
//TreeSet的特点：有序（按大小顺序），不可重复
TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getScore() - o2.getScore();
}//错误的
/* @Override
public int compare(Student o1, Student o2) {
int result = o1.getScore() - o2.getScore();
return result == 0 ? o1.getId() - o2.getId(): result;
}*/
});
set.add(new Student(1,"张三",86));
set.add(new Student(1,"张三",86));
set.add(new Student(2,"李四",86));
System.out.println(set);//[Student{id=1, name='张三', score=86}]
}
}
class Student{
private int id;
private String name;
private int score;
public Student(int id, String name, int score) {
this.id = id;
this.name = name;
this.score = score;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", score=" + score +
'}';
}
/*@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return id == student.id; //为了突出问题，故意只选id
}
@Override
public int hashCode() {
return Objects.hash(id);
}*/
}三、Lambda表达式
1、语法结构
（Lambda表达式的形参列表） -> {Lambda体}
说明：
（1）->：称为箭头操作符，或Lambda操作符
由减号和大于号组成，中间不能有空格
（2） （Lambda表达式的形参列表），它其实就是 你的lambda表达式要针对的函数式接口的抽象方法的形参列表
例如：Lambda表达式是针对java.lang.Runnable接口使用，Lambda表达式的形参列表就是()
因为java.lang.Runnable接口的抽象方法 void run()
Lambda表达式是针对java.util.Comparator<T>接口使用，Lambda表达式的形参列表就是(T t1, T t2)
因为java.util.Comparator<T>接口的抽象方法 int compare(T t1, T t2)
Lambda表达式是针对java.util.function.Consumer<T>接口使用，Lambda表达式的形参列表就是(T t)
因为 java.util.function.Consumer<T>接口的抽象方法void accept(T t)
（3） {Lambda体}，它其实就是你实现这个抽象方法的方法体
2、Lambda表达式的作用是给函数式接口的变量/形参赋值的
3、Lambda表达式可以简化
（1）当{Lambda体}只有一个语句，可以省略{}和语句后面的;
（2）当{Lambda体}只有一个语句，可以省略{}和语句后面的;。如果此时是return语句，要把return也省略
（3）当（Lambda表达式的形参列表）的形参列表的形参类型是已知的，或者是可以根据泛型自动推断的，那么类型可以省略
（4）如果（Lambda表达式的形参列表）的形参列表的类型省略了，并且形参只有一个，那么()可以省略，
如果形参列表是多个参数，()不能省略
如果形参列表是空参()，那么()不能省略
public class TestLambda {
@Test
public void test04(){
//需求：列出"D:\to_student\尚硅谷_210728Java_柴林燕_JavaSE\预装软件"目录下的.exe文件
File dir = new File("D:\\to_student\\尚硅谷_210728Java_柴林燕_JavaSE\\预装软件");
/*
调用java.io.File类的public File[] listFiles(FileFilter filter)方法
这个方法的形参是 (FileFilter filter)，FileFilter是函数式接口，可以使用Lambda表达式赋值
FileFilter接口的抽象方法 boolean accept(File pathname)
Lambda表达式 ：(File pathname) -> { 过滤文件或目录的条件}
Lambda表达式 ：(File pathname) -> { return pathname.getName().endsWith(".exe");}
*/
// File[] files = dir.listFiles((File pathname) -> { return pathname.getName().endsWith(".exe");});
//（2）当{Lambda体}只有一个语句，可以省略{}和语句后面的;。如果此时是return语句，要把return也省略
// File[] files = dir.listFiles((File pathname) ->pathname.getName().endsWith(".exe"));
//（3）当（Lambda表达式的形参列表）的形参列表的形参类型是已知的，或者是可以根据泛型自动推断的，那么类型可以省略
// File[] files = dir.listFiles((pathname) ->pathname.getName().endsWith(".exe"));
//（4）如果（Lambda表达式的形参列表）的形参列表的类型省略了，并且形参只有一个，那么()可以省略，
File[] files = dir.listFiles(pathname ->pathname.getName().endsWith(".exe"));
for (File file : files) {
System.out.println(file);
}
}
@Test
public void test03(){
//需求：列出"D:\to_student\尚硅谷_210728Java_柴林燕_JavaSE\预装软件"目录下的.exe文件
File dir = new File("D:\\to_student\\尚硅谷_210728Java_柴林燕_JavaSE\\预装软件");
File[] files = dir.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {//(File pathname)参数是dir这个目录的下一级文件或目录对象
return pathname.getName().endsWith(".exe");
}
});
for (File file : files) {
System.out.println(file);
}
}
@Test
public void test02(){
//有一个字符串数组
String[] arr = {"hello","Hi","Chai","Jock","world","atguigu"};
//希望对这个数组进行排序，不区分大小写的排序
//调用Arrays工具类有public static <T> void sort(T[] a, Comparator<? super T> c)
//T[] a：接收一个对象数组，给哪个数组排序，就传哪个数组
//Comparator<? super T> c：需要一个Comparator接口的实现类对象
/*
这里不传Comparator接口的实现类对象，我们用Lambda表达式给他赋值。
Comparator接口的抽象方法 int compare(T t1, T t2)
Lambda表达式：
(T t1, T t2) -> {写t1,t2的排序规则}
T类型是什么？ 因为Comparator接口的实现类对象，或者说，int compare(T t1, T t2)是给arr数组的元素排序，
这个数组是String[]类型，元素是String类型，这个T就是String类型
Lambda表达式：
(String t1, String t2) -> {写t1,t2的排序规则,区分大小写的排序}
(String t1, String t2) -> {t1.compareToIgnoreCase(t2);}
因为 int compare(T t1, T t2)有返回值类型，是int，所以在{}中需要return语句
Lambda表达式：
(String t1, String t2) -> {return t1.compareToIgnoreCase(t2);}
*/
// Arrays.sort(arr, (String t1, String t2) -> {return t1.compareToIgnoreCase(t2);});
//（2）当{Lambda体}只有一个语句，可以省略{}和语句后面的;。如果此时是return语句，要把return也省略
// Arrays.sort(arr, (String t1, String t2) -> t1.compareToIgnoreCase(t2));
//（3）当（Lambda表达式的形参列表）的形参列表的形参类型是已知的，或者是可以根据泛型自动推断的，那么类型可以省略
Arrays.sort(arr, (t1, t2) -> t1.compareToIgnoreCase(t2));
}
@Test
public void test01(){
//需求：用实现Runnable接口的方式启动一个线程，打印“hello"
//Thread(Runnable target)，构造器需要一个Runnable接口的实现类对象，现在要传Lambda表达式
/*
使用Lambda表达式给(Runnable target)参数赋值。
java.lang.Runnable接口的抽象方法 void run()
Lambda表达式:
() -> {System.out.println("hell");}
*/
// new Thread(() -> {System.out.println("hello");}).start();
//当{Lambda体}只有一个语句，可以省略{}和语句后面的;
new Thread(() -> System.out.println("hello")).start();
}
}4、演示Java8新增的函数式接口的Lambda表达式的应用
（1）消费型接口
Consumer<T> void accept(T t)
Java8不仅增加了函数式接口，还升级了集合框架的API。
在Java8版的java.lang.Iterable<T>接口中新增了一个默认方法：
default void forEach(Consumer<? super T> action)：这个方法的作用是用来遍历/迭代 容器中的元素
观察这个方法的形参列表是 (Consumer<? super T> action)，形参的类型Consumer是函数式接口，
所以调用这个方法，可以传入Lambda表达式。
因为Collection系列的集合继承/实现了Iterable<T>接口，所以Collection系列的集合都有了forEach方法。
（2）消费型接口
BiConsumer<T,U> 抽象方法 void accept(T t, U u)
Java8在java.util.Map<K,V>接口中也增加
default void forEach(BiConsumer<? super K,? super V> action)
forEach方法的形参：BiConsumer，它也是函数式接口，并且是Consumer的变形，也是消费性接口
（3）判断型接口
Predicate<T> 抽象方法 boolean test(T t)
Java8版本，对Collection接口增加了方法 default boolean removeIf(Predicate<? super E> filter)
这个方法的形参类型：Predicate，它是函数式接口，是判断型函数式接口
（4）功能型接口
BiFunction<T,U,R> 抽象方法 R apply(T t, U u)
在JDK1.8时Map接口增加方法：
default void replaceAll(BiFunction<? super K,? super V,? extends V> function)
replaceAll方法的形参是 BiFunction,它是功能型接口
public class TestLambda2 {
@Test
public void test05(){
HashMap<Integer,String> map = new HashMap<>();
map.put(1,"hello");
map.put(2,"world");
map.put(3,"java");
//需求：把value的字符串中包含o字母的字符串，换成大写
//调用default void replaceAll(BiFunction<? super K,? super V,? extends V> function)
/*
replaceAll方法的形参是 BiFunction,它是功能型接口,抽象方法 R apply(T t, U u)
Lambda表达式：
T：是map的key类型
U：是map的value类型
(Integer key, String value) -> {把value的字符串中包含o字母的字符串，换成大写}
(Integer key, String value) -> {
if(value.contains("o")){
return value.toUpperCase();//返回转为大写的value
}
return value;//返回原来的value
}
*/
map.replaceAll((Integer key, String value) -> {
if(value.contains("o")){
return value.toUpperCase();//返回转为大写的value
}
return value;//返回原来的value
});
//简化：
map.replaceAll((key, value) -> value.contains("o") ? value.toUpperCase() : value);
System.out.println(map);
}
@Test
public void test04(){
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "hello","java","world","mysql");
//需求，删除字符串中包含o字母的字符串
//调用default boolean removeIf(Predicate<? super E> filter)
/*
形参是Predicate，它是函数式接口，是判断型函数式接口，抽象方法boolean test(T t)
调用这个方法，需要传递参数，这个参数传递进去之后，在test方法肯定是用于条件判断，满足xx条件返回true，否则返回false。
Lambda表达式：(T t)->{判断t是否满足删除条件}
T类型就是集合元素的类型，String类型
Lambda表达式：(String t)->{ return t.contains("o");}
*/
// list.removeIf((String t)->{ return t.contains("o");});
//简化
// list.removeIf(t->t.contains("o"));
list.removeIf(element->element.contains("o")); //修改形参名，使得可读性更强
System.out.println(list);
}
@Test
public void test03(){
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "hello","java","world","mysql");
//需求，删除字符串中包含o字母的字符串
//原来Collection系列的集合，要根据条件删除，必须使用Iterator迭代器
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
String str = iterator.next();
if(str.contains("o")){
iterator.remove();
}
}
}
@Test
public void test02(){
HashMap<Integer,String> map = new HashMap<>();
map.put(1,"hello");
map.put(2,"world");
map.put(3,"java");
//调用map的default void forEach(BiConsumer<? super K,? super V> action)
/*
形参BiConsumer，它也是函数式接口，它的抽象方法void accept(T t, U u)
Lambda表达式： (T t, U u) 这个T和U其实就是Map的K,V
（Integer key, String value) -> {遍历键值对}
*/
// map.forEach((Integer key, String value) -> {System.out.println(key+":" + value);});
//简化
map.forEach((key, value) -> System.out.println(key+":" + value));
}
@Test
public void test01(){
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "hello","java","world","mysql");
//调用default void forEach(Consumer<? super T> action)方法
/*
形参是：Consumer类型，它是函数式接口，它的抽象方法 void accept(T t)
lambda表达式：
(T t) -> {遍历集合的元素}
T的类型，由集合的元素类型决定，是String类型
lambda表达式：
(String t) -> {System.out.println(t);}
*/
// list.forEach((String t) -> {System.out.println(t);} );
//简化
list.forEach(t -> System.out.println(t));
}
}四、方法引用和构造器引用
1、Lambda表达式是用于给“函数式接口（SAM接口，只有一个抽象方法的接口）”的变量/形参赋值的一种语法。
可以简化/替代原来的匿名内部类的方式实现函数式接口的代码。
方法引用是对Lambda表达式的再次简化。
2、方法引用和构造器引用的语法格式：
方法引用： 类名/对象名 :: 方法名
构造器引用： 类名 :: new
3、说明
（1）当{lambda体}中只有一个语句，并且这个语句是调用现有的对象/类的方法来完成。
（2）Lambda表达式的(形参列表)中的形参，要么作为调用方法的对象，要么作为调用方法的实参，所有形参都用上了
（3）在整个{lambda体}中，没有使用到额外的数据/对象等
例如：Arrays.sort(arr, (t1, t2) -> t1.compareToIgnoreCase(t2));
（1）{lambda体}中只有一个语句 return t1.compareToIgnoreCase(t2);
（2）Lambda表达式的(形参列表)是(t1, t2)，t1是作为调用compareToIgnoreCase方法的对象，
t2是作为调用compareToIgnoreCase方法的实参。
例如：list.forEach(t -> System.out.println(t));
（1）{lambda体}中只有一个语句 System.out.println(t)
（2）Lambda表达式的(形参列表)是(String t) , t作为println方法调用的实参。
例如：new Thread(()->System.out.println("hello")).start();
（1）{lambda体}中只有一个语句 System.out.println("hello")
（2）Lambda表达式的(形参列表)是()，没有参数可以使用
（3）在整个{lambda体}中，没有使用到额外的数据/对象等 不满足，因为出现了"hello"
public class TestFunction {
@Test
public void test04(){
//供给型接口Supplier<T>，抽象方法T get()
//Lambda表达式可以直接给函数式接口的变量赋值
// Supplier<String> s = () -> new String();
//使用构造器引用进行简化
Supplier<String> s = String :: new;
}
@Test
public void test03(){
//需求：用实现Runnable接口的方式启动一个线程，打印“hello"
new Thread(()->System.out.println("hello")).start();//多线程打印了一个"hello"
//是否可以使用方法引用进行简化呢？ 不能简化
new Thread(System.out::println).start(); //多线程只是打印了一个空行
}
@Test
public void test02(){
//集合遍历
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"hello","java","world");
//调用forEach方法进行遍历
//forEach的形参类型是Consumer<T>，抽象方法 void accept(T t)
// list.forEach(t -> System.out.println(t));
//使用方法引用进行简化
list.forEach(System.out::println);
}
@Test
public void test01(){
//有一个字符串数组
String[] arr = {"hello","Hi","Chai","Jock","world","atguigu"};
//实现排序，不区分大小写的排序
// Arrays.sort(arr, (t1, t2) -> t1.compareToIgnoreCase(t2));
//使用方法引用来进行简化
Arrays.sort(arr, String::compareToIgnoreCase);
System.out.println(Arrays.toString(arr));
}
}4、JDK1.8中新增加了很多函数式接口给我们使用，它们在java.util.function包。
四大代表：
（1）Consumer<T>，消费型接口 抽象方法：void accept(T t)
特点：有参无返回值 调用这个方法，需要给他传递实参，但是得不到返回值，“有去无回”
（2）Supplier<T>，供给型接口 抽象方法：T get()
特点：无参有返回值 调用者方法，不需要传递参数，但是可以得到一个返回值，“空手套白狼” 这个接口的抽象方法，相当于“奉献型”
（3）Predicate<T>，判断型接口，断定型接口 抽象方法：boolean test(T t)
特点：有参有返回值，但是返回值类型是boolean
调用这个方法，需要传递参数，这个参数传递进去之后，在test方法肯定是用于条件判断，满足xx条件返回true，否则返回false。
（4）Function<T,R>：功能型接口 抽象方法：R apply(T t)
特点：有参有返回值，参数的类型和返回值的类型不确定，并且可能不一样
调用这个方法，需要传递参数，也可以得到一个返回值，但是参数的类型和返回值的类型，需要在使用时才能确定，什么都有可能。所以这个方法相当于只是完成一个功能。
其他接口，都是上面这些接口的变形：
（1）Consumer<T>，消费型接口
bi：binary二元的，两个的
（2）Supplier<T>，供给型接口
（3）（3）Predicate<T>，判断型接口，断定型接口
（4）Function<T,R>：功能型接口
UnaryOperator：一元的，一个参数一个返回值，参数类型和返回值类型一样
BinaryOperator = Bi + UnaryOperator，有两个参数，一个返回值，参数和返回值的类型都是一样的
5、自定义函数式接口
（1）这个接口只能定义一个抽象方法
（2）这个接口加@FunctionalInterface注解
public class TestFunctionalInterface3 {
}
@FunctionalInterface
interface MyInterface{
void method();
}
//下面这个接口就没必要定义，因为java8的 java.util.function包下已经有相似的类型
//| IntConsumer | void accept(int value) | 接收一个int值
@FunctionalInterface
interface OtherInterface{
void method(int a);
}五、Java8新增了一个工具类/容器：java.util.Optional<T>
1、Optional类的对象是一个容器，容器就是用来装对象的
可能里面是空的，可能里面有一个对象，
这个类通常用来当做一个方法的返回值来使用，避免返回null值。
到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。
以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，
Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。
受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
例如：Stream的API中的一些方法返回值就是Optional类。
| **Optional<T>** **findFirst()** | 返回第一个元素 |
| **Optional<T>** **findAny()** | 返回当前流中的任意元素 | |
| **Optional<T>** **max(Comparator c)** | 返回流中最大值 |
| **Optional<T>** **min(Comparator c)** |返回流中的最小值
因为流中可能没有元素，那么这些方法就没有真正的元素返回，如果没有Optional，就需要返回null，
调用这些方法的地方，就可能发生空指针异常。
2、如何创建一个Optional类的对象
（1）创建一个空的容器对象 Optional.empty();
（2）创建一个容器对象，里面可能包含空值，可能包含具体值 Optional.ofNullable(x); x可能为空
（3）创建一个非空的容器对象， Optional.of(x); x一定是非空
3、如花使用Optional
（1）判断是否为空
boolean isPresent()
（2）获取里面的对象
T get() ：取出Optional容器中的对象，要求里面必须有对象，否则抛出 NoSuchElementException
T orElse(T other) ：如果Optional容器中有对象，那么直接返回里面 的对象，否则返回备胎
T orElseGet(Supplier<? extends T> other) ：如果Optional容器中有对象，那么直接返回里面 的对象，否则返回Supplier供给型接口提供的备胎
（3）void ifPresent(Consumer<? super T> consumer)
public class TestOptional {
@Test
public void test01(){
Optional<Object> empty = Optional.empty();
System.out.println(empty);
}
@Test
public void test03(){
Optional<String> opt = findGirlFriend2("汪飞");
System.out.println(opt);
System.out.println("汪飞的女朋有是否存在： " + opt.isPresent());
System.out.println("女朋友：" + opt.get());
opt.ifPresent(System.out::println);//如果女朋友存在，就打印，否则就不打印
Optional<String> opt2 = findGirlFriend2("李天棋");
System.out.println("opt2 = " + opt2);// Optional.empty
System.out.println("李天棋的女朋有是否存在： " + opt2.isPresent());
// System.out.println("女朋友：" + opt2.get());
System.out.println("女朋友：" + opt2.orElse("石榴姐"));
System.out.println("女朋友：" + opt2.orElseGet(String::new));//空字符串
opt2.ifPresent(System.out::println);//如果女朋友存在，就打印，否则就不打印
}
public Optional<String> findGirlFriend2(String boyName){
HashMap<String,String > map = new HashMap<>();//这个集合后面是数据库中的数据
map.put("汪飞", "如花");
map.put("二虎", "翠花");
map.put("邱世玉", "似玉");
map.put("李天棋", null);
return Optional.ofNullable(map.get(boyName));
}
@Test
public void test02(){
String girl1 = findGirlFriend("汪飞");
System.out.println("girl1 = " + girl1);
System.out.println("姓：" + girl1.charAt(0));
String girl2 = findGirlFriend("李天棋");
System.out.println("girl2 = " + girl2);
System.out.println("姓：" + girl2.charAt(0));
}
public String findGirlFriend(String boyName){
HashMap<String,String > map = new HashMap<>();//这个集合后面是数据库中的数据
map.put("汪飞", "如花");
map.put("二虎", "翠花");
map.put("邱世玉", "似玉");
map.put("李天棋", null);
return map.get(boyName);
}
}六、StreamAPI
1、Stream：流
我们之前在IO章节学习的 InputStream,OutputStream 和我们今天要学习的Stream不是一回事，没关系。
2、Java8新增的包，java.util.stream
作用：针对集合等容器中的数据进行操作的。
使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。
数据库：简单理解数据仓库，用来存储数据的。
数据库是一个管理系统，可以用来存储数据，并且管理数据（增删改查，备份...）
数据库分为：
文件系统的数据库（数据存储在硬盘上）
内存数据库（数据存储在内存中）
存在硬盘上的好处：永久性保存，就算系统断电了，数据是不会丢失的
内存数据库的好处：速度快
3、Stream的API的使用分为三步：
第一步：创建Stream
告诉Stream的数据来源是什么
第二步：中间操作，对数据进行处理
第三步：终结操作，看最后结果
4、Stream的API的特点
（1）Stream的对象是不可变对象，凡是修改会产生新Stream对象，必须重新接收
（2）Stream流的操作不会改变原数据
（3）中间操作可以是0~n步
（4）中间操作是一个延迟操作，在执行终结操作之前，中间不会执行，直到我们要执行终结操作，一口气执行
（5）一旦终结就结束了，除非创建新的Stream
（6）Stream不负责存储数据，只负责处理数据
public class TestStream {
@Test
public void test2() {
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("张三",89));
list.add(new Student("李四",45));
list.add(new Student("王五",75));
//第一步：创建Stream
Stream<Student> stream = list.stream();
//第二步：中间操作，对数据进行处理
stream = stream.filter(s -> s.getScore()<60);//找出成绩不及格
// 第三步：终结操作，看最后结果
stream.forEach(System.out::println);
}
@Test
public void test(){
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"hello","world","java","hao");
//第一步：创建Stream
Stream<String> stream = list.stream();
//第二步：中间操作，对数据进行处理
stream = stream.filter(t -> t.contains("o"));//只留下包含“o”字母的单词
stream = stream.sorted();
// 第三步：终结操作，看最后结果
stream.forEach(System.out::println);
System.out.println(list);
}
}
class Student{
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
System.out.println("getScore方法被调用了");
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
}5、创建Stream的方式
（1）集合.stream()
Collection系列的集合，在Java8之后增加了一个方法：default Stream<E> stream()
Map系列的集合，要先转为Collection系列的集合再获取Stream。
（2）Arrays.stream(数组)
在数组工具类Arrays中增加了一批stream，可以根据数组来创建Stream
（3）Stream接口的静态方法，of方法，创建一个有限的Stream
Stream.of(T... args)
Stream.of(T t)
（4）Stream接口的静态方法，generate和iterate，创建无限的Stream
static <T> Stream<T> generate(Supplier<T> s)
static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)
public class TestCreateStream {
@Test
public void test11(){
/*
static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)
iterate方法的形参有两个：
第一个是T seed，种子
第二个是UnaryOperator<T>，它是今天学习的函数式接口的一种，
UnaryOperator<T>抽象方法T apply(T t) ，有参有返回值，参数和返回值的类型一样
需求：从种子（数字1）开始，不断的累加2
*/
//第一步创建Stream
Stream<Integer> stream = Stream.iterate(1, t -> t + 2);
//第三步：终结操作
stream.forEach(System.out::println);
}
@Test
public void test10(){
/*
static <T> Stream<T> generate(Supplier<T> s)
generate方法的形参类型是Supplier<T>，它是供给型函数式接口，抽象方法：T get()
Lambda表达式可以给 (Supplier<T> s)形参赋值
Lambda表达式：
() -> {有一个语句，可以产生数据}
*/
//第一步创建Stream
// Stream<Double> stream = Stream.generate(() -> {return Math.random();});
// Stream<Double> stream = Stream.generate(() -> Math.random());
//使用方法引用简化
Stream<Double> stream = Stream.generate(Math::random);
//第三步：终结操作
stream.forEach(System.out::println);
}
@Test
public void test9(){
Stream<String> stream = Stream.of("hello", "java", "world");
}
@Test
public void test8(){
Integer[] arr = {1,2,3,4};
Stream<Integer> stream = Arrays.stream(arr);
}
@Test
public void test4(){
int[] arr = {1,2,3,4};
IntStream stream = Arrays.stream(arr);
}
@Test
public void test3(){
String[] arr = {"hello","java","world"};
Stream<String> stream = Arrays.stream(arr);
}
@Test
public void test2(){
HashMap<Integer,String> map = new HashMap<>();
map.put(1,"hello");
map.put(2,"world");
map.put(3,"java");
Set<Integer> keys = map.keySet();
Stream<Integer> keyStream = keys.stream();
System.out.println("-------------------------");
Collection<String> values = map.values();
Stream<String> valueStream = values.stream();
System.out.println("-------------------------");
Set<Map.Entry<Integer, String>> entries = map.entrySet();
Stream<Map.Entry<Integer, String>> entryStream = entries.stream();
}
@Test
public void test(){
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"hello","world","java","hao");
Stream<String> stream = list.stream();
}
}6、Stream的中间操作：这些方法的返回值类型都是Stream
（1）filter过滤
（2）distinct() 去重
（3）limit(long maxSize) 限制个数
（4）skip(long n)跳过前面的几个
（5）sorted()：使用元素的自然排序，要求元素实现Comparable接口
sorted(Comparator com)，使用定制排序，指定Comparator比较规则
（6）peek(Consumer action)：对流中的元素做action指定的操作，但是不修改元素
(7)map(Function f)：对流中的每一个元素映射xxx操作
（8）flatMap(Function f)：把f函数式接口中的方法体得到的小的流的结果再合成大的Stream
public class TestMiddleStream {
@Test
public void test14(){
String[] arr = {"hello","world","java"};
//第一步：创建Stream
Stream<String> stream = Arrays.stream(arr);
//第二步：中间处理，把上面流中的每一个单词，拆开一个一个的字母
//t.split("|")：拆分字符串，得到一个一个的String[]数组，元素是单个的字母
//Stream.of(t.split("|")：把数组又构建成了一个小的Stream
//map：把Stream.of(t.split("|")得到Stream作为新的流的元素
Stream<Stream<String>> streamStream = stream.map(t -> Stream.of(t.split("|")));
//第三步：终结操作
streamStream.forEach(System.out::println);
}
@Test
public void test13(){
String str = "hello";
String[] strings = str.split("|");
System.out.println(Arrays.toString(strings));//[h, e, l, l, o]
}
@Test
public void test12(){
String[] arr = {"hello","world","java"};
//第一步：创建Stream
Stream<String> stream = Arrays.stream(arr);
//第二步：中间处理，把上面流中的每一个单词，拆开一个一个的字母
//t.split("|")：拆分字符串，得到一个一个的String[]数组，元素是单个的字母
//Stream.of(t.split("|")：把数组又构建成了一个小的Stream
//flatMap：把Stream.of(t.split("|")得到的一个一个的Stream，又合并成一个大的Stream
Stream<String> stringStream = stream.flatMap(t -> Stream.of(t.split("|")));
//第三步：终结操作
stringStream.forEach(System.out::println);
}
@Test
public void test10(){
//有一个字符串数组
String[] arr = {"hello","Hi","Chai","Jock","world","atguigu"};
//取出每一个字符串的首字母
/*
map(Function f)方法的形参是Function<T,R>功能型接口，抽象方法：R apply(T t)
*/
Arrays.stream(arr).map(t-> t.charAt(0)).forEach(System.out::println);
/* //第一步：创建Stream
Stream<String> stream = Arrays.stream(arr);
//第二步：中间处理
Stream<Character> characterStream = stream.map(t -> t.charAt(0));
//第三步：终结
characterStream.forEach(System.out::println);*/
}
@Test
public void test09(){
//随机产生10个[0,100)的整数，然后取出前三名最大的数字
List<Integer> collect = Stream.generate(() -> (int) (Math.random() * 100))
.limit(10)
.peek(System.out::println)
.sorted((t1,t2)-> t2-t1)
.limit(3)
.collect(Collectors.toList());
System.out.println(collect);
}
@Test
public void test08(){
//随机产生10个[0,100)的整数，然后取出前三名最大的数字
List<Integer> collect = Stream.generate(() -> (int) (Math.random() * 100))
.limit(10)
.peek(System.out::println)
.sorted()
.skip(7)
.collect(Collectors.toList());
System.out.println(collect);
}
@Test
public void test07(){
//随机产生10个[0,100)的整数，然后取出前三名最大的数字
Stream.generate(() -> (int)(Math.random()*100)).limit(10).sorted().skip(7).forEach(System.out::println);
}
@Test
public void test06(){
//有一个字符串数组
String[] arr = {"hello","Hi","Chai","Jock","world","atguigu"};
//按照字符串大小排序，不区分大小写
//方案一：Arrays.sort
//方案二：使用Stream
Arrays.stream(arr).sorted(String::compareToIgnoreCase).forEach(System.out::println);
}
@Test
public void test05() {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8);
//跳过前面3个，再取3个
list.stream().skip(3).limit(3).forEach(System.out::println);
}
@Test
public void test04(){
//使用Math.random()方法随机产生一些数据，取前10个
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
@Test
public void test03(){
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8);
//获取集合中不重复的元素，即去掉重复元素
//方案一：可以放到set中
//方案二：可以使用Stream
//三步连起来
list.stream().distinct().forEach(System.out::println);
}
@Test
public void test02(){
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,1,2,3,4,5,6,7,8);
//获取list集合中的所有偶数
//三步连起来
list.stream().filter(t -> t % 2 == 0).forEach(System.out::println);
}
@Test
public void test01(){
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,1,2,3,4,5,6,7,8);
//获取list集合中的所有偶数
//第一步：创建Stream
Stream<Integer> stream = list.stream();
//第二步：过滤，把偶数留下
/*
filter(Predicate p)方法的形参是判断型接口Predicate<T>，抽象方法 boolean test(T t)
*/
stream = stream.filter(t -> t % 2 == 0);
//第三步：终结操作，打印结果
stream.forEach(System.out::println);
}
}7、Stream终结操作：当我们调用了Stream的某个方法，这个方法的返回值类型不是Stream类型，那么就说明这个操作是终结操作
（1）allMatch：判断流中的元素是否某匹配xx条件
（2）anyMatch：任意一个匹配
（3）noneMatch：没有一个匹配，都不匹配xx条件
（4）findFirst：返回第一个
findAny：返回任意一个 如果这个流的数据是固定，那么findAny和findFirst
如果流是一个无限流，或者流中元素不固定，findAny的结果就和findFirst不同
（5）long count()
（6）Optional<T> max(Comparator c)
Optional<T> min(Comparator c)
（7）void forEach(Consumer c)
（8）T reduce(T iden, BinaryOperator b)
U reduce(BinaryOperator b)
（9）R collect(Collector c)：把流中剩下的元素收集到集合或其他的容器中
这个方法需要配合Collectors工具类
public class TestEndStream {
@Test
public void test11() {
//随机产生10个[0,10)之间的整数，打印10个整数，收集其中的偶数，不能重复
List<Integer> list = Stream.generate(() -> (int) (Math.random() * 10))
.limit(10)
.peek(System.out::println)
.filter(t->t%2==0)
.distinct()
.collect(Collectors.toList());
System.out.println("list = " + list);
}
@Test
public void test10() {
//随机产生10个[0,10)之间的整数，打印10个整数，收集其中的偶数，不能重复
Set<Integer> set = Stream.generate(() -> (int) (Math.random() * 10))
.limit(10)
.peek(System.out::println)
.filter(t -> t % 2 == 0)
.collect(Collectors.toSet());
System.out.println("set = " + set);
}
@Test
public void test09() {
//随机产生10个[0,10)之间的整数，打印10个整数，收集其中的偶数
List<Integer> list = Stream.generate(() -> (int) (Math.random() * 10))
.limit(10)
.peek(System.out::println)
.filter(t->t%2==0)
.collect(Collectors.toList());
System.out.println("list = " + list);
}
@Test
public void test08() {
//随机产生10个[0,10)之间的整数，打印10个整数，累加它们的和
Optional<Integer> result = Stream.generate(() -> (int) (Math.random() * 10))
.limit(10)
.peek(System.out::println)
.reduce((t1, t2) -> t1 + t2);
/*
reduce（BinaryOperator b）形参BinaryOperator<T>是函数式接口，抽象方法T apply(T t, T u)
*/
System.out.println("result = " + result);
}
@Test
public void test07() {
//随机产生10个[0,100)之间的整数，打印10个整数，并且返回最大值
Optional<Integer> max = Stream.generate(() -> (int) (Math.random() * 100))
.limit(10)
.peek(System.out::println)
.max((t1, t2) -> t1 - t2);
System.out.println("max = " + max);
}
@Test
public void test06() {
//随机产生10个[0,100)之间的整数，打印10个整数，并统计里面的偶数个数
ArrayList<Integer> list = new ArrayList<>();
int count = 0;
for(int i=0; i<10; i++){
int num = (int) (Math.random() * 100);
list.add(num);
if(num%2==0){
count++;
}
}
System.out.println(list);
System.out.println("偶数的个数count = " + count);
}
@Test
public void test05() {
//随机产生10个[0,100)之间的整数，打印10个整数，并统计里面的偶数个数
long count = Stream.generate(() -> (int) (Math.random() * 100))
.limit(10)
.peek(System.out::println)
.filter(t -> t % 2 == 0)
.count();
System.out.println("偶数的个数count = " + count);
}
@Test
public void test04() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
//第一步：创建Stream
Stream<Integer> stream = list.stream();
//第二步：留下比5大的整数
stream = stream.filter(t -> t>5);
//第三步：findFirst
Optional<Integer> first = stream.findFirst(); //Optional是一个容器，它用来包装返回值结果
System.out.println("first = " + first);//Optional.empty
}
@Test
public void test03() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
//第一步：创建Stream
Stream<Integer> stream = list.stream();
//第三步：findFirst
Optional<Integer> first = stream.findFirst(); //Optional是一个容器，它用来包装返回值结果
System.out.println("first = " + first);
}
@Test
public void test02(){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
//第一步：创建Stream
Stream<Integer> stream = list.stream();
//第二步：过滤
stream = stream.filter(t -> t % 2 == 0);//只留下偶数
//第三步：终结操作
boolean result = stream.allMatch(t -> t % 2 == 0);
System.out.println("result = " + result);
}
@Test
public void test01(){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
//第一步：创建Stream
Stream<Integer> stream = list.stream();
//第三步：终结操作
boolean result = stream.allMatch(t -> t % 2 == 0);
System.out.println("result = " + result);
}
}
1461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
