前些日子小熙简单了解了下jdk8的新特性，觉得其中的lambda和stream比较有意思，所以分享下。
1.lambda表达式
举几个小例子
（1）. 简单的遍历循环与操作
lambda表达式也是方法的简写，只不过强调了入参而无出参，是封闭式的
前端的箭头函数也是方法的简写，同理但箭头是两个杠的
ArrayList<Integer> integers = new ArrayList<>();
ArrayList<Integer> newIntegers = new ArrayList<>();
Collections.addAll(integers, 1, 2, 3, 4, 5);
// foreach遍历和lambda打印（简单遍历数字）
// integers.forEach(integer -> System.out.println(integer));
// 调用Scala中的方法，序列化打印（结合Scala语言简写）
integers.forEach(System.out::println);
// foreach遍历和lambda（遍历中加些操作）
integers.forEach(integer -> newIntegers.add(integer + 1));
System.out.println("newIntegers:" + newIntegers);
（2）. 应用于比较器
简单应用
String[] players = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka", "David Ferrer",
"Roger Federer", "Andy Murray",
"Tomas Berdych", "Juan Martin Del Potro",
"Richard Gasquet", "John Isner"};
// 通过lambda表达式构建比较器，还是比较方便的
Comparator<String> sortByLastLetter =
(String s1, String s2) ->
(s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
// 通过数组工具类调用排序方法，传入比较器规则
Arrays.sort(players, sortByLastLetter);
System.out.println("sortByLastLetter："+Arrays.toString(players));
// 打印该索引位置的字符
System.out.println(players[0].charAt(0));
// 打印该字符位置的索引，字符区分大小写
System.out.println(players[0].indexOf('S'));
System.out.println(players[0].indexOf('s'));
具体多种方式应用
String[] players = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka", "David Ferrer",
"Roger Federer", "Andy Murray",
"Tomas Berdych", "Juan Martin Del Potro",
"Richard Gasquet", "John Isner"};
// 1.1 使用匿名内部类根据 name 排序 players
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return (s1.compareTo(s2));
}
});
// 1.2 使用 Lambda expression 排序 players
Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));
Arrays.sort(players, sortByName);
// 1.3 也可以采用如下形式:
Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));
// 其他的排序如下所示。 和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :
// 1.1 使用匿名内部类根据 surname 排序 players
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" "))));
}
});
// 1.2 使用 Lambda expression 排序,根据 surname
Comparator<String> sortBySurname = (String s1, String s2) ->
(s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" "))));
Arrays.sort(players, sortBySurname);
// 1.3 或者这样,怀疑原作者是不是想错了,括号好多...
Arrays.sort(players, (String s1, String s2) ->
(s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" "))))
);
// 2.1 使用匿名内部类根据 name lenght 排序 players
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return (s1.length() - s2.length());
}
});
// 2.2 使用 Lambda expression 排序,根据 name lenght
Comparator<String> sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length());
Arrays.sort(players, sortByNameLenght);
// 2.3 or this
Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length()));
// 3.1 使用匿名内部类排序 players, 根据最后一个字母
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
}
});
// 3.2 使用 Lambda expression 排序,根据最后一个字母
Comparator<String> sortByLastLetter =
(String s1, String s2) ->
(s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
Arrays.sort(players, sortByLastLetter);
// 3.3 or this，推荐
Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));
}
（3）. 线程应用
/**
* 经过测试调用run方法比直接start要快
*/
@Test
public void thread(){
// 1.1使用匿名内部类
new java.lang.Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello world1 !");
}
}).start();
// 1.2使用 lambda expression
new java.lang.Thread(() -> System.out.println("lambda替代匿名内部类")).start();
java.lang.Thread thread = new java.lang.Thread(() -> System.out.println("Hello world2 !"));
thread.run();
// 2.1使用匿名内部类
Runnable race1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello world3 !");
}
};
// 2.2使用 lambda expression
Runnable race2 = () -> System.out.println("Hello world4 !");
Runnable runnable = () -> System.out.println("新线程");
// 直接调用 run 方法(没开新线程哦!)
race1.run();
race2.run();
runnable.run();
// 可重入锁
ReentrantLock reentrantLock = new ReentrantLock();
reentrantLock.lock();
reentrantLock.unlock();
}
2. stream简单使用
Random random = new Random();
// ints()将整数转为整数流，limit(10)用于获取指定数量的流（这里指定的是10），forEach遍历循环，System.out::println单个输出结果
random.ints().limit(10).forEach(System.out::println);
random.ints().limit(10).sorted().forEach(System.out::println);
// asDoubleStream是转为小数流
System.out.println("小数流："+random.ints().asDoubleStream());
List<Integer> integers = new ArrayList<>();
Collections.addAll(integers,1,2,3,4,5);
System.out.println("integers："+integers.stream());
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
// 先把集合变成流对象，用map进行遍历（lambda处理操作），接着对结果进行去重（调用去重方法），最后使用集合工具添加
// Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
// List<Integer> squaresLists = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
// parallelStream是多管比Stream的单管更快
List<Integer> squaresLists = numbers.parallelStream().map( i -> i*i).distinct().collect(Collectors.toList());
// 遍历循环结果
squaresLists.forEach(System.out::println);
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量，首先将集合类转为流对象，接着调用过滤方法，使用lambda表达式实现过滤操作，最后调用count方法记过滤总数。
long count = strings.stream().filter(string -> string.isEmpty()).count();
long count1 = numbers.stream().filter(number -> number > 5).count();
System.out.println("数组集合中大于5的个数："+count1);
// 最后的collect方法可以调用Collectors.toList()方法将过滤的结果加到新集合中
List<Integer> collect = numbers.stream().filter(number -> number > 5).collect(Collectors.toList());
System.out.println("数组集合中大于5的数为："+collect);
嗯，小熙分享的以上入门是可以的。如果想要深入学习可自寻查找资料。