Java8新特性 – 小飞侠

一、Java8概述

Java8 (又称 JKD1.8) 是 Java 语言开发的一个主要版本。

Oracle公司于2014年3月18日发布Java8 。

支持Lambda表达式

函数式接口

新的Stream API

新的日期 API

其他特性

二、Lambda表达式

2.1 概念

Lambda表达式是特殊的匿名内部类，语法更简洁。

Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递。

2.2 语法

<函数式接口> <变量名> = (参数1，参数2…) -> {]()

//方法体

[};

2.3 基本使用

演示案例：

public class Demo1 {
	public static void main(String[] args) {
		//匿名内部类
		Runnable runnable=new Runnable() {
			
			@Override
			public void run() {
				System.out.println("子线程执行了.........");
			}
		};
		
		//Lambda表达式
		Runnable runnable2=()->System.out.println("子线程执行了2.........");
		
		new Thread(runnable2).start();
		new Thread(()->System.out.println("子线程执行了3.........")).start();
		
		/
		//匿名内部类
		Comparator<String> com=new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				// TODO Auto-generated method stub
				return o1.length()-o2.length();
			}
		};
		
		//Lambda表达式
		
		Comparator<String> com2=(String o1, String o2)-> {
			// TODO Auto-generated method stub
			return o1.length()-o2.length();
		};
		
		Comparator<String> com3=(o1,o2)->o1.length()-o2.length();
		
		TreeSet<String> treeSet=new TreeSet<>(com3);
	}
}

Lambda引入了新的操作符：->(箭头操作符)，->将表达式分成两部分：

左侧：(参数1，参数2…)表示参数列表

右侧：{ }内部是方法体

注意事项：

2.4 课堂案例

Usb接口：

@FunctionalInterface
public interface Usb {
	void service();
}

TestUsb类：

public class TestUsb {
	public static void main(String[] args) {
		//匿名内部类
		Usb mouse=new Usb() {
			
			@Override
			public void service() {
				System.out.println("鼠标开始工作了..........");
			}
		};
		
		Usb fan=()->System.out.println("风扇开始工作了..........");
		
		
		run(mouse);
		run(fan);
	}
	public static void run(Usb usb) {
		usb.service();
	}
}

三、函数式接口【
`重点`
】

3.1 概念

如果一个接口只有一个抽象方法，则该接口称之为函数式接口。

函数式接口可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上。

@FunctionalInterface 注解检测接口是否符合函数式接口规范。与 @Override 注解的作用类似

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。

下面是最简单的几个接口及使用示例。

3.2 常见函数式接口

接口	参数类型	返回类型	说明
Consumer< T > 消费型接口	T	void	void accept(T t);对类型为T的对象应用操作
Supplier< T > 供给型接口	无	T	T get(); 返回类型为T的对象
Function< T,R > 函数型接口	T	R	R apply(T t);对类型为T的对象应用操作，并返回类型为R类型的对象。
Predicate< T > 断言型接口	T	boolean	boolean test(T t);确定类型为T的对象是否满足条件，并返回boolean类型。

案例演示：

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

		//Lambda表达式
		Consumer<Double> consumer= t->System.out.println("聚餐消费:"+t);
		
		happy(t->System.out.println("聚餐消费:"+t), 1000);
		happy(t->System.out.println("唱歌消费:"+t), 2000);
		
		int[] arr=getNums(()->new Random().nextInt(100), 5);
		System.out.println(Arrays.toString(arr));
		int[] arr2=getNums(()->new Random().nextInt(1000), 10);
		System.out.println(Arrays.toString(arr2));
		
		String result=handlerString(s->s.toUpperCase(), "hello");
		System.out.println(result);
		String result2=handlerString(s->s.trim(), "   zhangsan        ");
		System.out.println(result2);
		
		List<String> list=new ArrayList<>();
		list.add("zhangsan");
		list.add("zhangwuji");
		list.add("lisi");
		list.add("wangwu");
		list.add("zhaoliu");
		List<String> result=filterNames(s->s.startsWith("zhang"), list);
		System.out.println(result.toString());
		
		List<String> result2=filterNames(s->s.length()>5, list);
		System.out.println(result2);
	}
	//Consumer 消费型接口
	public static void happy(Consumer<Double> consumer,double money) {
		consumer.accept(money);
	}
	
	//Supplier 供给型接口
	public static int[] getNums(Supplier<Integer> supplier,int count) {
		int[] arr=new int[count];
		for(int i=0;i<count;i++) {
			arr[i]=supplier.get();
		}
		return arr;
	}
	
	//Function函数型接口
	public static String handlerString(Function<String, String> function,String str) {
		return function.apply(str);
	}
	
	//Predicate 断言型接口
	
	public static List<String> filterNames(Predicate<String> predicate,List<String> list){
		List<String> resultList=new ArrayList<String>();
		for (String string : list) {
			if(predicate.test(string)) {
				resultList.add(string);
			}
		}
		return resultList;
	}
	
}

四、方法引用

4.1 概念

4.1.1冗余的Lambda场景

来看一个简单的函数式接口以应用Lambda表达式：

@FunctionalInterface
public interface Printable {
   void print(String str);  
}

在 Printable 接口当中唯一的抽象方法 print 接收一个字符串参数，目的就是为了打印显示它。那么通过Lambda来使用它的代码很简单：

public class PrintSimpleDemo {
    private static void printString(Printable data) {
       data.print("Hello, World!");  
    }
    public static void main(String[] args) {
       printString(s ‐> System.out.println(s));  
    }
}

其中 printString 方法只管调用 Printable 接口的 print 方法，而并不管 print 方法的具体实现逻辑会将字符串

打印到什么地方去。而 main 方法通过Lambda表达式指定了函数式接口 Printable 的具体操作方案为：拿到

String（类型可推导，所以可省略）数据后，在控制台中输出它。

4.1.2问题分析

这段代码的问题在于，对字符串进行控制台打印输出的操作方案，明明已经有了现成的实现，那就是 System.out对象中的 println(String) 方法。既然Lambda希望做的事情就是调用 println(String) 方法，那何必自己手动调用呢？

4.1.3 用方法引用改进代码

能否省去Lambda的语法格式（尽管它已经相当简洁）呢？只要“引用”过去就好了：

public class PrintRefDemo {
    private static void printString(Printable data) {
        data.print("Hello, World!");
    }
    public static void main(String[] args) {
        /*
        Lambda表达式写法： s -> System.out.println(s);
方法引用写法： System.out::println
第一种语义是指：拿到参数之后经Lambda之手，继而传递给 System.out.println 方法去处理。
第二种等效写法的语义是指：直接让 System.out 中的 println 方法来取代Lambda。两种写法的执行效果完全一样，而第二种方法引用的写法复用了已有方案，更加简洁。
		*/
       printString(System.out::println);  
    }
}

请注意其中的双冒号 :: 写法，这被称为“方法引用”，而双冒号是一种新的语法。

方法引用是Lambda表达式的一种简写形式。

如果Lambda表达式方法体中只是调用一个特定的已经存在的方法，则可以使用方法引用。

双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

常见形式：

对象::实例方法

类::静态方法

类::new

4.2 基本使用

Employee类：

public class Employee {
	private String name;
	private double money;
	public Employee() {
		// TODO Auto-generated constructor stub
	}
	
	public Employee(String name, double money) {
		super();
		this.name = name;
		this.money = money;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getMoney() {
		return money;
	}
	public void setMoney(double money) {
		this.money = money;
	}
	@Override
	public String toString() {
		return "Employee [name=" + name + ", money=" + money + "]";
	}

	 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Double.compare(employee.money, money) == 0 &&
                Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, money);
    }
	
}

TestEmployee类：

public class Demo4 {
	public static void main(String[] args) {
		//1 对象::实例方法
		Consumer<String> consumer=s->System.out.println(s);
		consumer.accept("hello");
		Consumer<String> consumer2=System.out::println;
		consumer.accept("world");
		
		//2类::静态方法
		Comparator<Integer> com=(o1,o2)->Integer.compare(o1, o2);
		Comparator<Integer> com2=Integer::compare;
			
		
		
		//3类::new
		Supplier<Employee> supplier=()->new Employee();
		Supplier<Employee> supplier2=Employee::new;
		
		Employee employee=supplier.get();
		System.out.println(employee.toString());
		
	}
}

五、什么是Stream【
`重点`
】

5.1 引言

5.1.1 传统集合的多步遍历代码

几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如：

 import java.util.ArrayList;
import java.util.List;
public class ForEachDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        for (String name : list) {
           System.out.println(name);  
        }
    } 
}

5.1.2 循环遍历的弊端

Java 8的Lambda让我们可以更加专注于做什么（What），而不是怎么做（How），这点此前已经结合内部类进行

了对比说明。现在，我们仔细体会一下上例代码，可以发现：

for循环的语法就是“怎么做”

for循环的循环体才是“做什么”

为什么使用循环？因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从

第一个到最后一个顺次处理的循环。前者是目的，后者是方式。

试想一下，如果希望对集合中的元素进行筛选过滤：

将集合A根据条件一过滤为子集B；

然后再根据条件二过滤为子集C。

那怎么办？在Java 8之前的做法可能为：

import java.util.ArrayList;
import java.util.List;
public class NormalFilterDemo {
   public static void main(String[] args) {  
       List<String> list = new ArrayList<>();  
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        List<String> zhangList = new ArrayList<>();
        for (String name : list) {
            if (name.startsWith("张")) {
               zhangList.add(name);  
            }
        }
        List<String> shortList = new ArrayList<>();
        for (String name : zhangList) {
            if (name.length() == 3) {
               shortList.add(name);  
            }
        }
        for (String name : shortList) {
           System.out.println(name);  
        }
    }
}

这段代码中含有三个循环，每一个作用不同：

首先筛选所有姓张的人；

然后筛选名字有三个字的人；

最后进行对结果进行打印输出。

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使用另一个循环从头开始。

那，Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢？

5.1.3 Stream的更优写法

下面来看一下借助Java 8的Stream API，什么才叫优雅：

import java.util.ArrayList;
import java.util.List;
public class StreamFilterDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.stream()
           .filter(s ‐> s.startsWith("张"))  
            .filter(s ‐> s.length() == 3)
            .forEach(System.out::println);
    }
}

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。

5.1 概念

流（Stream）与集合类似，但集合中保存的是数据，而Stream中保存对集合或数组数据的操作。

Stream
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d5BFLHqJ-1605581823806)(Pictures\002.png)]$

5.2 Stream特点

Stream 自己不会存储元素。

Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

Stream 操作是延迟执行的，会等到需要结果的时候才执行。

5.3 Stream使用步骤

创建：

新建一个流。

中间操作：

在一个或多个步骤中，将初始Stream转化到另一个Stream的中间操作。

终止操作：

使用一个终止操作来产生一个结果。该操作会强制之前的延迟操作立即执行，在此之后，该Stream就不能使用了。

5.4 创建Stream

通过Collection对象的stream()或parallelStream()方法。

通过Arrays类的stream()方法。

通过Stream接口的of()、iterate()、generate()方法。

通过IntStream、LongStream、DoubleStream接口中的of、range、rangeClosed方法。

案例演示：

public class Demo5 {
	public static void main(String[] args) {
		//(1)Collection对象中的stream()和parallelStream()方法
		ArrayList<String> arrayList=new ArrayList<>();
		arrayList.add("apple");
		arrayList.add("huawei");
		arrayList.add("xiaomi");
		Stream<String> stream = arrayList.parallelStream();
		//遍历
//		stream.forEach(s->System.out.println(s));
		stream.forEach(System.out::println);
		//(2)Arrays工具类的stream方法
		String[] arr= {"aaa","bbb","ccc"};
		Stream<String> stream2=Arrays.stream(arr);
		stream2.forEach(System.out::println);
		
		//(3)Stream接口中的of iterate 、generate 方法
		
		Stream<Integer> stream3 = Stream.of(10,20,30,40,50);
		stream3.forEach(System.out::println);
		//迭代流
		System.out.println("-----迭代流------");
		Stream<Integer> iterate = Stream.iterate(0, x->x+2);
		iterate.limit(5).forEach(System.out::println);
		System.out.println("--------生成流----------");
		//生成流
		Stream<Integer> generate = Stream.generate(()->new Random().nextInt(100));
		generate.limit(10).forEach(System.out::println);
		
		//(4)IntStream,LongStream,DoubleStream  的of  、range、rangeClosed
		IntStream stream4 = IntStream.of(100,200,300);
		stream4.forEach(System.out::println);
		IntStream range = IntStream.rangeClosed(0, 50);
		range.forEach(System.out::println);
	}
}

5.5 中间操作

常见中间操作：

filter、limit、skip、distinct、sorted

map

parallel

5.5.1 过滤：filter

可以通过 filter 方法将一个流转换成另一个子集流。方法签名：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

此前我们已经学习过 java.util.stream.Predicate 函数式接口，其中唯一的抽象方法为：

boolean test(T t);

该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法

将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。

5.5.2 映射：map

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：

R apply(T t);

这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”。

5.5.3 跳过前几个：skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

5.5.4 取用前几个：limit

limit 方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。

案例演示：

public class Demo6 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<>();
		list.add(new Employee("小王", 15000));
		list.add(new Employee("小张", 12000));
		list.add(new Employee("小李", 18000));
		list.add(new Employee("小孙", 20000));
		list.add(new Employee("小刘", 25000));
		//list.add(new Employee("小刘", 25000));
		//中间操作1 
        //filter过滤、limit 限制、skip 跳过、distinct 去掉重复、sorted排序
		//(1) filter过滤
		System.out.println("------filter-------");
		list.stream()
			.filter(e->e.getMoney()>15000)
			.forEach(System.out::println);
		//(2) limit限制
		System.out.println("----limit------");
		list.stream()
			.limit(2)
			.forEach(System.out::println);
		//(3) skip跳过
		System.out.println("-----skip------");
		list.stream()
			.skip(2)
			.forEach(System.out::println);
		System.out.println("------distinct--------");
		//(4) distinct去重复
		list.stream()
			.distinct()
			.forEach(System.out::println);
		
		System.out.println("---------sorted---------");
		//(5) sorted排序
		list.stream()
			.sorted((e1,e2)->Double.compare(e1.getMoney(), e2.getMoney()))
			.forEach(System.out::println);
				
		//中间操作2 map
		System.out.println("---------map--------");
		list.stream()
			.map(e->e.getName())
			.forEach(System.out::println);
		//中间操作3 parallel 采用多线程 效率高
		System.out.println("---------map--------");
		list.parallelStream()
			.forEach(System.out::println);
	}
}

串行流和并行流：

串行流使用单线程。

并行流使用多线程，效率更高。

public class Demo7 {
	public static void main(String[] args) {
		//串行流和并行流的区别
		ArrayList<String> list=new ArrayList<>();
		for(int i=0;i<5000000;i++) {
			list.add(UUID.randomUUID().toString());
		}
		//串行：10秒  并行：7秒
		long start=System.currentTimeMillis();
        long count=list.Stream().sorted().count();
		//long count=list.parallelStream().sorted().count();
		System.out.println(count);
		long end=System.currentTimeMillis();
		System.out.println("用时:"+(end-start));
	}
}

5.6 终止操作

常见终止操作：

forEach、min、max、count

reduce、collect

5.6.1 逐一处理：forEach

虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同。

void forEach(Consumer<? super T> action);

该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。

java.util.function.Consumer接口是一个消费型接口。

Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。

5.6.2 统计个数：count

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

long count();

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。

案例演示：

public class Demo8 {
	public static void main(String[] args) {
		ArrayList<Employee> list = new ArrayList<>();
		list.add(new Employee("小王", 15000));
		list.add(new Employee("小张", 12000));
		list.add(new Employee("小李", 18000));
		list.add(new Employee("小孙", 20000));
		list.add(new Employee("小刘", 25000));
		//1 终止操作 foreach
		list.stream()
			.filter(e->{
					System.out.println("过滤了....");
					return e.getMoney()>15000;
				})
			.forEach(System.out::println);
		//2 终止操作 min max count
		System.out.println("-----min-----");
		Optional<Employee> min = list.stream()
			.min((e1,e2)->Double.compare(e1.getMoney(), e2.getMoney()));
		System.out.println(min.get());
		System.out.println("-----max-----");
		Optional<Employee> max = list.stream()
			.max((e1,e2)->Double.compare(e1.getMoney(), e2.getMoney()));
		System.out.println(max.get());
		
		long count = list.stream().count();
		System.out.println("员工个数:"+count);
		
		//3 终止操作 reduce 规约
		//计算所有员工的工资和
		System.out.println("--------reduce---------");
		Optional<Double> sum = list.stream()
			.map(e->e.getMoney())
			.reduce((x,y)->x+y);
		System.out.println(sum.get());
		
		//4 终止方法 collect收集
		//获取所有的员工姓名，封装成一个list集合
		System.out.println("------collect------");
		List<String> names = list.stream()
			.map(e->e.getName())
			.collect(Collectors.toList());
		for (String string : names) {
			System.out.println(string);
		}
	}
}

六、新时间API

6.1 概述

本地化日期时间 API：

LocalDate

LocalTime

LocalDateTime

Instant：时间戳。

ZoneId：时区。

Date、Instant、LocalDateTime的转换。

DateTimeFormatter：格式化类。

6.2 LocalDateTime类

表示本地日期时间，没有时区信息

public class Demo2 {
	public static void main(String[] args) {
		//1创建本地时间
		LocalDateTime localDateTime=LocalDateTime.now();
		//LocalDateTime localDateTime2=LocalDateTime.of(year, month, dayOfMonth, hour, minute)
		System.out.println(localDateTime);
		System.out.println(localDateTime.getYear());
		System.out.println(localDateTime.getMonthValue());
		System.out.println(localDateTime.getDayOfMonth());
		
		//2添加两天
		LocalDateTime localDateTime2 = localDateTime.plusDays(2);
		System.out.println(localDateTime2);
		
		//3减少一个月
		LocalDateTime localDateTime3 = localDateTime.minusMonths(1);
		System.out.println(localDateTime3);
	}
}

6.3 Instant、ZoneId类

Instant表示瞬间；和前面Date类似。

ZoneId表示时区信息。

public class Demo3 {
	public static void main(String[] args) {
		//1 创建Instant：时间戳
		Instant instant=Instant.now();
		System.out.println(instant.toString());
		System.out.println(instant.toEpochMilli());
		System.out.println(System.currentTimeMillis());
		//2 添加减少时间
		
		Instant instant2 = instant.plusSeconds(10);
		
		System.out.println(Duration.between(instant, instant2).toMillis());
		
		//3ZoneId
		Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
		for (String string : availableZoneIds) {
			System.out.println(string);
		}
		
		System.out.println(ZoneId.systemDefault().toString());
		
		//1 Date --->Instant--->LocalDateTime
		System.out.println("-------------Date --->Instant---->LocalDateTime-----------");
		Date date=new Date();
		Instant instant3 = date.toInstant();
		System.out.println(instant3);
		
		LocalDateTime localDateTime = LocalDateTime.ofInstant(instant3, ZoneId.systemDefault());
		System.out.println(localDateTime);
		
		//2 LocalDateTime --->Instant--->Date
		System.out.println("-------------LocalDateTime --->Instant---->Date-----------");
	
		Instant instant4 = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
		System.out.println(instant4);
		Date from = Date.from(instant4);
		System.out.println(from);
		
	}
}

6.4 DateTimeFormatter类

DateTimeFormatter是时间格式化类。

public class Demo4 {
	public static void main(String[] args) {
		//创建DateTimeFormatter
		DateTimeFormatter dtf=DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
		//1 把时间格式化成字符串
		String format = dtf.format(LocalDateTime.now());
		System.out.println(format);
		//2 把字符串解析成时间
		LocalDateTime localDateTime = LocalDateTime.parse("2020/03/10 10:20:35", dtf);
		System.out.println(localDateTime);
	}
}

原文链接：https://blog.csdn.net/Bearrr93/article/details/109738226

一、Java8概述

二、Lambda表达式

2.1 概念

2.2 语法

2.3 基本使用

2.4 课堂案例

三、函数式接口【 重点 】

3.1 概念

3.2 常见函数式接口

四、方法引用

4.1 概念

4.1.1冗余的Lambda场景

4.1.2问题分析

4.1.3 用方法引用改进代码

4.2 基本使用

五、什么是Stream【 重点 】

5.1 引言

5.1.1 传统集合的多步遍历代码

5.1.2 循环遍历的弊端

5.1.3 Stream的更优写法

5.1 概念

5.2 Stream特点

5.3 Stream使用步骤

5.4 创建Stream

5.5 中间操作

5.5.1 过滤：filter

5.5.2 映射：map

5.5.3 跳过前几个：skip

5.5.4 取用前几个：limit

5.6 终止操作

5.6.1 逐一处理：forEach

5.6.2 统计个数：count

六、新时间API

6.1 概述

6.2 LocalDateTime类

6.3 Instant、ZoneId类

6.4 DateTimeFormatter类

你可能也喜欢

三、函数式接口【
`重点`
】

五、什么是Stream【
`重点`
】