java8新特性

1.lambda表达式

Lambda 允许把函数作为参数传递进方法中

// 类型声明 MathOperation addition = (int a, int b) -> a + b;

// 不用类型声明 MathOperation subtraction = (a, b) -> a - b;

// 大括号中的返回语句 MathOperation multiplication = (int a, int b) -> { return a * b; };

Lambda 表达式只能引用标记了 final 的外层局部变量,lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改

2.方法引用

构造器引用：它的语法是Class::new，或者更一般的Class< T >::new

public static Car create(final Supplier<Car> supplier) { return supplier.get(); }

final Car car = Car.create( Car::new );

静态方法引用：它的语法是Class::static_method

public static void collide(final Car car) { System.out.println("Collided " + car.toString()); }

cars.forEach( Car::collide );

特定类的任意对象的方法引用：它的语法是Class::method

public void repair() { System.out.println("Repaired " + this.toString()); }

cars.forEach( Car::repair );

特定对象的方法引用：它的语法是instance::method

public void follow(final Car another) { System.out.println("Following the " + another.toString()); }

final Car police = Car.create( Car::new );

cars.forEach( police::follow );

3.Stream

Stream（流）是一个来自数据源的元素队列并支持聚合操作

数据源流的来源。可以是集合，数组，I/O channel，产生器generator 等。

聚合操作类似SQL语句一样的操作，比如filter, map, reduce, find, match, sorted等。

forEach limit sorted

Random random = new Random();

random.ints().limit(10).sorted().forEach(System.out::println);

map

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

// 获取对应的平方数

List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

filter

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

// 获取空字符串的数量

long count = strings.stream().filter(string -> string.isEmpty()).count();

Collectors

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

System.out.println("筛选列表: " + filtered);

String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));

System.out.println("合并字符串: " + mergedString);

(1)Stream创建

1) 通过参数序列创建Stream

// 利用可变参数直接构造Stream，相比Arrays.stream()更简单

// 下面语句创建的流内容：10,20,30,40,50

final IntStream stream = IntStream.of(10, 20, 30, 40, 50);

// 下面语句创建的流内容：red,blue,green

final Stream<String> colorStream = Stream.of("red", "blue", "green");

2) 通过数组创建Stream

相比Stream.of()，不用区分基础数据类型，但参数只能是数组，不支持参数序列创建

final Integer[] numbers = {10, 20, 30, 40, 50, 60};

final Stream<Integer> numberStream = Arrays.stream(numbers);

final int[] intNumbers = {10, 20, 30, 40, 50, 60};

final IntStream result = Arrays.stream(intNumbers);

3) 通过集合创建Stream

final Collection<Integer> collection = Lists.newArrayList(10, 20, 30, 40, 50, 60);

final Stream<Integer> numberStream = collection.stream();

4) 通过集合创建并行Stream

final Collection<Integer> numbers = Lists.newArrayList(10, 20, 30, 40, 50, 60);

// 直接创建并行流

Stream<Integer> numberStream = numbers.parallelStream();

// 将串行流转换为并行流

numberStream = numbers.stream().parallel();

5) 通过IO方式创建Stream

// 读取文件的内容，生成stream流

final Stream<String> stream = Files.lines(Paths.get("data.txt"), Charsets.UTF_8);

// 获取目录下的文件列表信息

final Stream<Path> listFile = Files.list(Paths.get("/"));

6) 通过生成器创建Stream

SecureRandom random = SecureRandom.getInstanceStrong();

// 直接传入instance::method

// 下面语句创建的result包含10个随机数

Stream<Integer> result = Stream.generate(random::nextInt).limit(10);

// 直接传入lambda表达式

// 下面语句创建的result包含10个元素，每个值由根据当前时间 % 100计算得来

// 以某次执行为例，result包含36,3,40,71,46,43,68,97,38,92

result = Stream.generate(() -> (int) (System.nanoTime() % 100)).limit(10);

7) 通过iterate创建Stream

// 以0为种子，f(n) = n + 3, f(f(n)) ...

// 下面语句创建的Stream内容：0 3 6 9 12 15 18 21 24 27

Stream.iterate(0, n -> n + 3).limit(10).forEach(Stubs::doWhatever);

8) 通过区间创建整数序列Stream

// 通过range、rangeClosed生成序列，该序列为数学中的区间序列。

// 生成[-100, 100)区间的元素序列，不包括end元素100

final IntStream range = IntStream.range(-100, 100);

// 由于start > end，不符合区间定义，返回空区间，Stream中元素长度为0

final IntStream emptyRange = IntStream.range(100, -100);

// 生成[-100,100]区间的元素序列，包含end元素100

final IntStream rangeClosed = IntStream.rangeClosed(-100, 100);

// LongStream range生成

// 生成[-100, 100)区间的元素序列，不包括end元素100

final LongStream longRange = LongStream.range(-100L, 100L);

// 生成[-100,100]区间的元素序列，包含end元素100

final LongStream longRangeClosed = LongStream.rangeClosed(-100L, 100L);

(1)Stream基础操作

1) 计算Stream大小

// 计算Stream中元素的格式，count为特殊的reduce操作，对于sum(), max(), min(), average()，count()等操作不建议直接使用reduce()

// 等同于stream.mapToLong(e -> 1L).sum();

long count = Stream.of().count(); // count = 0

count = Stream.of(10).count(); // count = 1

count = Stream.of(10, 20, 30, 40, 50).count(); // count = 5

1) Stream转换为字符串