将list集合去空
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//.filter（o -> !o.isEmpty）过滤对象是空的，collect收集（Collectors.toList）将结果转化为List
List<String> collect = strings.stream().filter(o -> !o.isEmpty()).collect(Collectors.toList());
'forEach' 来迭代流中的每个数据
//生成随机数
Random random = new Random();
//.ints().limit(10)生成10个随机数.forEach遍历输出
random.ints().limit(10).forEach(System.out::println);
distinct不同的（去重）
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
//以map的形式映射对象，distinct()去重，collect收集(Coolectors.toList)收集转换成List集合
List<Integer> collect = numbers.stream().map(o -> o*2).distinct().collect(Collectors.toList);
计算是空的集合的个数
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//过滤是空的集合个数
Long count = strings.stream().filter(0 -> o.isEntry()).count();
对随机数进行过滤
Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);
使用lambda表达式
//传统用法
String[] atp = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka",
"David Ferrer","Roger Federer",
"Andy Murray","Tomas Berdych",
"Juan Martin Del Potro"};
List<String> players = Arrays.asList(atp);
for (String player : players) {
System.out.println("player:"+player);
}
//lambda 表达试以及函数操作（function operation）
players.forEach((player -> System.out.println(player)));
// 在java8中使用双冒号操作符(double colon operator)
players.forEach(System.out::println);
lambda表达式的简单例子:
// 1. 不需要参数,返回值为 5
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)
匿名内部类
// 使用匿名内部类
btn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
System.out.println("Hello World!");
}
});
// 或者使用 lambda expression
btn.setOnAction(event -> System.out.println("Hello World!"));
lambdas 来实现 Runnable接口 的示例:
// 1.1使用匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello world !");
}
}).start();
// 1.2使用 lambda expression
new Thread(() -> System.out.println("Hello world !")).start();
// 2.1使用匿名内部类
Runnable race1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello world !");
}
};
// 2.2使用 lambda expression
Runnable race2 = () -> System.out.println("Hello world !");
// 直接调用 run 方法(没开新线程哦!)
race1.run();
race2.run();
使用匿名内部类根据name排序players
String[] players = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka", "David Ferrer",
"Roger Federer", "Andy Murray",
"Tomas Berdych", "Juan Martin Del Potro",
"Richard Gasquet", "John Isner"};
//使用匿名内部类根据name排序players Comparators 比较器
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
//使用lambdas表达式可以通过以下方法实现
//使用lambda expression 排序players
Comparator<String> sortByName = ((String o1, String o2) -> (o1.compareTo(o2)));
Arrays.sort(players,sortByName);
//也可以采用一下形式
Arrays.sort(players,((String s1,String s2) -> (s1.compareTo(s2))));
//使用匿名内部类根据surname 排序 players
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.substring(o1.indexOf(" ")).compareTo(o2.substring(o1.indexOf(" ")));
}
});
//使用lambda 表达式排序，根据surname
Arrays.sort(players,(String s1,String s2) -> (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" ")))));
//使用匿名内部类根据 name lenght 排序 players
Arrays.sort(players, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return (o1.length() - o2.length());
}
});
// 使用 lambda expression 排序,根据 name lenght
Arrays.sort(players,(String s1,String s2) -> (s1.length() -s2.length()));
//根据最后一个字母排序
Arrays.sort(players,(String s1, String s2) -> (s1.charAt(s1.length()-1)) - s2.charAt(s2.length()-1));
}
