[转]Java8 lambda表达式及新特新

package info.liuwenjun.test;

import org.junit.Test;

import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;

/**
* Created by Vincent on 2016-04-12.
*/
public class TestJava8 {

private void print(Object obj) {
System.out.println(obj);
}

@Test
public void sort() {
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return a.compareTo(b);
}
});

Collections.sort(names, (String a, String b) -> {
return a.compareTo(b);
});

Collections.sort(names, (String a, String b) -> a.compareTo(b));

Collections.sort(names, (a, b) -> a.compareTo(b));

print(names);

new Thread(new Runnable() {
@Override
public void run() {
System.out.println("inner class");
}
}).start();

new Thread(() -> System.out.println("lambda")).start();
}

@Test
public void typeDeduction() {
Function<Integer, String> intToStr = a -> a.toString();

Function<Double, String> doubleToStr = a -> a.toString();

// doubleToStr = intToStr;

// () -> print("typeDeduction");
((Action) () -> print("typeDeduction")).action();
}

@FunctionalInterface
private interface Action {
void action();
}

@Test
public void functionalInterface() {
Function<Integer, Integer> plusOne = i -> i + 1;
print(plusOne.apply(1));

Predicate<Character> emoticon = o->'皿'<-o;
print(emoticon.test('皿'));

Consumer<Integer> printInt = i -> print(i);
printInt.accept(1);

Supplier<Long> getCurrentTime = () -> System.currentTimeMillis();
print(getCurrentTime.get());

Action sayHello = () -> print("hello");
sayHello.action();
}

@Test
public void testThis() {
Action innerClass = new Action() {
@Override
public void action() {
this.print("testThis");
}

private void print(Object obj) {
System.out.println("Inner: " + obj);
}
};
innerClass.action();

Action lambda = () -> this.print("testThis");
lambda.action();
}

@Test
public void testFinal() {
final int finalVar = 0;
int effectivelyFinalVar = 0;
// effectivelyFinalVar = 1;

new Action() {
@Override
public void action() {
print(finalVar);
print(effectivelyFinalVar);
}
}.action();
}

private List<String> stringCollection = new ArrayList<String>() {
{
add("ddd2");
add("aaa2");
add("bbb1");
add("aaa1");
add("bbb3");
add("ccc");
add("bbb2");
add("ddd1");
}
};

@Test
public void filter() {
stringCollection
.stream()
.filter(s -> s.startsWith("a"))
.forEach(s -> print(s));
}

@Test
public void sorted() {
stringCollection
.stream()
.sorted((a, b) -> b.compareTo(a))
.filter(s -> s.startsWith("a"))
.forEach(s -> print(s));
}

@Test
public void map() {
stringCollection
.stream()
.map(s -> s.toUpperCase())
.sorted(Comparator.comparing(s -> s.length()))
.forEach(s -> print(s));
}

@Test
public void flatMap() {
stringCollection
.stream()
.filter(s -> s.startsWith("a"))
.flatMap(s -> Arrays.stream(s.split("")))
.forEach(c -> print(c));
}

@Test
public void match() {
print(stringCollection.stream().anyMatch(s -> s.startsWith("a")));

print(stringCollection.stream().allMatch(s -> s.startsWith("a")));

print(stringCollection.stream().noneMatch(s -> s.startsWith("z")));
}

@Test
public void count() {
print(stringCollection.stream().filter(s -> s.startsWith("b")).count());
}

@Test
public void reduce() {
Optional<Integer> optional = stringCollection
.stream()
.map(s -> s.length())
.reduce((a, b) -> a + b);
print(optional.get());

int sum = stringCollection.get(0).length();
for (int i = 1; i < stringCollection.size(); i++) {
sum = sum + stringCollection.get(i).length();
}
print(sum);
}

@Test
public void intStream() {
IntSummaryStatistics statistics = stringCollection
.stream()
.mapToInt(s -> s.length())
.summaryStatistics();
print(statistics.getAverage());
print(statistics.getSum());
print(statistics.getMax());
print(statistics.getMin());
print(statistics.getCount());
}

@Test
public void complex() {
stringCollection
.stream()
.sorted()
.filter(s -> s.startsWith("a") && s.endsWith("1"))
.map(s -> s.length())
.filter(i -> i == 4)
.forEach(i -> print(i));
}

@Test
public void toList() {
List<Integer> len = stringCollection.stream().map(s -> s.length()).collect(Collectors.toList());
print(len);
}

@Test
public void toMap() {
Map<String, Integer> len = stringCollection.stream().collect(Collectors.toMap(s -> s, s -> s.length()));
print(len);
}

@Test
public void groupingBy() {
Map<Integer, List<String>> groups = stringCollection
.stream()
.collect(Collectors.groupingBy(s -> s.length()));
print(groups);
}

@Test
public void complexCollect() {
Map<Integer, List<String>> groups = stringCollection
.stream()
.collect(Collectors.groupingBy(s -> s.length(),
Collectors.mapping(s -> s.toUpperCase(), Collectors.toList())));
print(groups);
}

@Test
public void removeIf() {
List<String> copy = new ArrayList<>(stringCollection);

stringCollection.removeIf(s -> s.startsWith("a"));
print(stringCollection);

Iterator<String> iter = copy.iterator();
while (iter.hasNext()) {
if(iter.next().startsWith("a")) {
iter.remove();
}
}
print(copy);
}

@Test
public void iterateMap() {
Map<String, Integer> map = stringCollection.stream().collect(Collectors.toMap(s -> s, s -> s.length()));

map.forEach((key, value) -> print(key + ": " + value));

print("---------");

for(Map.Entry entry : map.entrySet()) {
print(entry.getKey() + ": " + entry.getValue());
}
}

@Test
public void mapStream() {
Map<String, Integer> map = stringCollection.stream().collect(Collectors.toMap(s -> s, s -> s.length()));

map.entrySet()
.stream()
.filter(e -> e.getValue() == 4)
.forEach(e -> print(e.getKey() + ": " + e.getValue()));
}
}