Java 8的一些常见用法

lambda表达式

语法

最常用的：

Runnable runnable = () -> System.out.println("Hello!");
Thread t = new Thread(runnable);
t.start();
t.join();

你还可以这么写：

Thread t = new Thread(() -> System.out.println("Hello!"));
t.start();
t.join();

带有参数的呢？

Comparator<String> stringComparator = (s1, s2) -> s1.compareTo(s2);

扩展成一个完整的表达式：

Comparator<String> stringComparator = (String s1, String s2) -> {
System.out.println("Comparing...");
return s1.compareTo(s2);
};

函数式接口

Lambda表达式使得你可以更紧凑地表达出单方法类。单一方法类也被称作函数式接口，它可以通过 @FunctionalInterface来进行注解：

@FunctionalInterface
public interface MyFunctionalInterface<T> {
boolean test(T t);
}

// Usage
MyFunctionalInterface<String> l = s -> s.startsWith("A");

方法引用

方法引用就是更紧凑，易懂的Lambda表达式，它适用于那些已经有名字的方法。来看一个简单的例子：

public class Sample {

public static void main(String[] args) {
Runnable runnable = Sample::run;
}

private static void run() {
System.out.println("Hello!");
}
}

还有一个：

public static void main(String[] args) {
Sample sample = new Sample();
Comparator<String> stringLengthComparator = sample::compareLength;
}

private int compareLength(String s1, String s2) {
return s1.length() - s2.length();
}

Stream API基础

stream是一个元素序列，它支持串行及并行的操作。

遍历列表

List<String> list = Arrays.asList("one", "two", "three", "four", "five", "six");

list.stream()
.forEach(s -> System.out.println(s));

过滤

Predicate<String> lowerThanOrEqualToFour = s -> s.length() <= 4;
Predicate<String> greaterThanOrEqualToThree = s -> s.length() >= 3;

list.stream()
.filter(lowerThanOrEqualToFour.and(greaterThanOrEqualToThree))
.forEach(s -> System.out.println(s));

排序

Predicate<String> lowerThanOrEqualToFour = s -> s.length() <= 4;
Predicate<String> greaterThanOrEqualToThree = s -> s.length() >= 3;
Comparator<String> byLastLetter = (s1, s2) -> s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1);
Comparator<String> byLength = (s1, s2) -> s1.length() - s2.length();

list.stream()
.filter(lowerThanOrEqualToFour.and(greaterThanOrEqualToThree))
.sorted(byLastLetter.thenComparing(byLength))
.forEach(s -> System.out.println(s));

大小限制

Predicate<String> lowerThanOrEqualToFour = s -> s.length() <= 4;
Predicate<String> greaterThanOrEqualToThree = s -> s.length() >= 3;
Comparator<String> byLastLetter = (s1, s2) -> s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1);
Comparator<String> byLength = (s1, s2) -> s1.length() - s2.length();

list.stream()
.filter(lowerThanOrEqualToFour.and(greaterThanOrEqualToThree))
.sorted(byLastLetter.thenComparing(byLength))
.limit(4)
.forEach(s -> System.out.println(s));

集合转化成列表

Predicate<String> lowerThanOrEqualToFour = s -> s.length() <= 4;
Predicate<String> greaterThanOrEqualToThree = s -> s.length() >= 3;
Comparator<String> byLastLetter = (s1, s2) -> s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1);
Comparator<String> byLength = (s1, s2) -> s1.length() - s2.length();

List<String> result = list.stream()
.filter(lowerThanOrEqualToFour.and(greaterThanOrEqualToThree))
.sorted(byLastLetter.thenComparing(byLength))
.limit(4)
.collect(Collectors.toList());

并行处理

用它来遍历文件列表则再常见不过了：

public static void main(String[] args) {
File[] files = new File("c:/windows").listFiles();
Stream.of(files)
.parallel()
.forEach(Sample::process);
}

private static void process(File file) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}

System.out.println("Processing -> " + file);
}

注意上面给出这个示例的同时，也暴露了并行处理的一些缺点。

Stream API进阶

映射

遍历文件后返回一个FileSize 对象：

class FileSize {

private final File file;
private final Long size;

FileSize(File file, Long size) {
this.file = file;
this.size = size;
}

File getFile() {
return file;
}

Long getSize() {
return size;
}

String getName() {
return getFile().getName();
}

String getFirstLetter() {
return getName().substring(0, 1);
}

@Override
public String toString() {
return Objects.toStringHelper(this)
.add("file", file)
.add("size", size)
.toString();
}
}

最终进行映射的代码：

File[] files = new File("c:/windows").listFiles();
List<FileSize> result = Stream.of(files)
.map(FileSize::new)
.collect(Collectors.toList());

分组：

按文件名的第一个字母将FileSize对象分组

Map<String, List<FileSize>> result = Stream.of(files)
.map(FileSize::new)
.collect(Collectors.groupingBy(FileSize::getFirstLetter));

Reduce

找出文件夹下的最大最小文件：

Optional<FileSize> filesize = Stream.of(files)
.map(FileSize::new)
.reduce((fs1, fs2) -> fs1.getSize() > fs2.getSize() ? fs1 : fs2);

如果你不需要FileSize对象，只需要一个数值的话：

OptionalLong max = Stream.of(files)
.map(FileSize::new)
.mapToLong(fs -> fs.getSize())
.max();

原创文章转载请注明出处：Java 8的一些常见用法