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();


最新内容请见作者的GitHub页:http://qaseven.github.io/
相关文章
|
1月前
|
Java 程序员
Java this关键字详解(3种用法),Java程序员面试必备的知识点
Java this关键字详解(3种用法),Java程序员面试必备的知识点
|
1月前
|
Java
Java中return的两种用法
Java中return的两种用法
|
5天前
|
Java
深入理解 Java 8 函数式接口:定义、用法与示例详解
深入理解 Java 8 函数式接口:定义、用法与示例详解
7 1
|
7天前
|
Java
Java 中 MessageFormat.format 用法
Java 中 MessageFormat.format 用法
5 1
|
10天前
|
Java API 容器
Java 8 的流库:Filter、Map、FlatMap 及 Optional 的概念与用法
【6月更文挑战第9天】Java 8 引入了许多强大的新特性,其中流库(Stream API)和 Optional 类极大地简化了集合操作和空值处理。本文将深入探讨 filter、map、flatMap 以及 Optional 的概念和用法,并提供示例代码来展示其实际应用。
17 4
|
13天前
|
安全 Java 测试技术
滚雪球学Java(53):从入门到精通:SimpleDateFormat类高深用法,让你的代码更简洁!
【6月更文挑战第7天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
24 0
滚雪球学Java(53):从入门到精通:SimpleDateFormat类高深用法,让你的代码更简洁!
|
15天前
|
安全 Java 测试技术
滚雪球学Java(51):掌握Java Date类:用法、弊端与时间戳转换技巧,助你轻松处理日期时间
【6月更文挑战第5天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
22 0
滚雪球学Java(51):掌握Java Date类:用法、弊端与时间戳转换技巧,助你轻松处理日期时间
|
15天前
|
Java
Java中String的用法
Java中String的用法
|
20天前
|
Java 开发者
Java的三元表达式用法
Java的三元表达式用法
|
23天前
|
Java
Java多线程基础-7:wait() 和 notify() 用法解析
这篇内容探讨了Java中的`wait()`和`notify()`方法在多线程编程中的使用。
20 0