java8笔记二

package com.arithmetic;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static org.junit.Assert.assertEquals;

/**
* @author nidayu
* @Description:
* @date 2015/10/15
*/
public class Java8 {
public static void main(String[] args){
List<String> collected = Stream.of("a", "b", "c").collect(Collectors.toList());
//断言
assertEquals(Arrays.asList("a", "b", "c"), collected);

List<String> collected2 = Stream.of("a", "b", "hello")
.map(string -> string.substring(0, 1).toUpperCase() + string.substring(1, string.length()))
.collect(Collectors.toList());
assertEquals(Arrays.asList("A", "B", "Hello"), collected2);

List<String> beginWithNumbers = Stream.of("a", "1abc", "abc1")
.filter(value -> Character.isDigit(value.charAt(0)))
.collect(Collectors.toList());
assertEquals(Arrays.asList("1abc"), beginWithNumbers);

List<Integer> together = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4))
.flatMap(numbers -> numbers.stream())
.collect(Collectors.toList());
assertEquals(Arrays.asList(1, 2, 3, 4), together);

//按照类的属性，求出最小的一个类！
List<Track> tracks = Arrays.asList(
new Track("ni", 17),
new Track("da", 20),
new Track("yu", 25),
new Track("zhangyu", 22),
new Track("da", 22)
);
Track minLengthTrack = tracks.stream()
.min(Comparator.comparing(track -> track.getLength()))
.get();
System.out.println(minLengthTrack.getLength() +" "+ minLengthTrack.getNeme());
assertEquals(tracks.get(0), minLengthTrack);

//排序输出
tracks.stream()
.sorted(Comparator.comparing(track -> track.getLength()))
.forEach(track1 -> System.out.println(track1.getNeme()));

//对象转换
IntSummaryStatistics intSummaryStatistics = tracks.stream()
.mapToInt(track -> track.getLength()) //转换成IntStream对象
.summaryStatistics();
System.out.println(String.format("min: %d \nmax: %d \nave: %f \nsum: %d",
intSummaryStatistics.getMin(),
intSummaryStatistics.getMax(),
intSummaryStatistics.getAverage(),
intSummaryStatistics.getSum()));

//求和
BinaryOperator<Integer> accumulator = (x, y) -> x + y;
int count = Stream.of(1, 2, 3)
.reduce(0, accumulator);
assertEquals(6, count);

//测试方法
Java8 java8 = new Java8();
//根据人名分组
Map<String, List<Track>> map = java8.groupByTrackName(tracks.stream());
for (Map.Entry<String, List<Track>> entry: map.entrySet()){
System.out.println(entry.getKey() +" "+ entry.getValue().size());
}
//测试方法
java8.test(() -> "test info ...");
}

public void test(Supplier<String> message){
if (true){
System.out.println(message.get());
}
}

public Map<String, List<Track>> groupByTrackName(Stream<Track> trackStream){
return trackStream.collect(Collectors.groupingBy(track -> track.getNeme()));
}
}

class Track{
String neme;
int length;

public Track(String neme, int length) {
this.neme = neme;
this.length = length;
}

public String getNeme() {
return neme;
}

public void setNeme(String neme) {
this.neme = neme;
}

public int getLength() {
return length;
}

public void setLength(int length) {
this.length = length;
}
}