目录
Lambda
1. 引用
匿名内部类：
创建Comparator接口的匿名内部类对象，在匿名内部类对象重写compare方法，进行比较匿名内部类也是一种语法的简化
list.sort(new Comparator<String>() { @Override
public int compare(String o1, String o2) { return 0;
}
});
2. lambda 表达式
指对匿名内部类语法进行进一步简化
lambda表达式又称为函数式编程
"(o1, o2) -> {return o1.compareTo(o2);}"
匿名函数可以将匿名函数代码块作为参数传递，语法更加简单
list.sort((o1, o2) -> {return o1.compareTo(o2);});
3. 要求（规则）
使用Lambda 表达式的接口中只能允许一个抽象方法要使用lambda 表达式要使用注解标签@FunctionalInterface，用来修饰的接口就是功能函数接口，其中只允许有一个抽象方法。
1. 无参的lambda表达式
无参数，无返回值
@FunctionalInterface
public interface LambdaDemo {
void test1();
}public class Test {
public static void main(String[] args){
LambdaDemo lam = ()->{System.out.println("Hello world！");};
//LambdaDemo lam = ()->System.out.println("Hello world！";
}
}2. 有参的Lambda表达式
有参数，无返回值 (int a,int b) -> { System.out.println(a+b);};
@FunctionalInterface
public interface LambdaDemo {
void test1(int a,int b);
}public class Test {
public static void main(String[] args) {
LambdaDemo lam = (a,b)->{
System.out.println(a+b);//9
};
lam.test2(6, 3);
}
}
3. 有多个参数，有返回值的Lambda表达式
(int a, int b) -> { return a + b;};
@FunctionalInterface
public interface LambdaDemo {
int test3(int a,int b);
}
public class Test {
public static void main(String[] args) {
LambdaDemo lam = (a,b)->{
return a+b;//9
};
int res = lam.test3(6, 3);
System.out.println(res);
}
}4. 应用
1. 线程的初始化
//匿名内部类方式：
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello!");
}
});
//Lambda 表达式
new Thread(()-> System.out.println("Hello"));
new Thread(()-> {System.out.println("Hello");});2. List 的遍历
import java.util.ArrayList;
import java.util.function.Consumer;
public class LambdaDemo1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("d");
list.add("a");
list.add("c");
//匿名内部类方式：
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
//Lambda 表达式
list.forEach((e)->{
System.out.println(e);
});
}
}
Stream
Stream 提供了对集合元素更加丰富的操作（中间操作和终端操作）， Stream流 操作不影响原始集合数据
为了对集合或数组进行操作，在 java8 提供了Stream 来丰富集合和数组操作
注：Stream 与 IO 流是完全不同的
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("c");
list.add("d");
list.add("ac");
list.add("b");
//将集合或数组中的元素添加到Stream对象中去
Stream<String> stream = list.stream();
List<String> list1 = stream.filter((e)->{
return e.equals("c");
})//中间操作
.collect(Collectors.toList());//终端操作
System.out.println(list1);//[c]
System.out.println(list);//[a, c, d, ac, b]
}
}
1.获取流
集合.stream()
Arrays.stream(a);
Stream.of(1,2,3,4,5,6,7);
字符流中reader.lines(); 可以将读入到程序中字符存入到Stream中
2.流操作
中间操作
返回的是Stream
- 过滤（filter）
import java.util.*;
import java.util.stream.Collectors;
public class StreamDemo {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(6);
list.add(4);
list.add(5);
list.add(6);
list.add(2);
list.add(9);
list.stream()
.filter((e)->{ return e>=5; })//中间操作，过滤
.forEach((e)-> System.out.print(e + ",")//终端操作：foreach遍历
);// 6,5,6,9,
}
}
- 自然排序（sorted()）
list.stream()
.distinct() //去重
.sorted((a,b)->{ return a- b; }) //排序
.forEach((e)-> System.out.print(e + ","));
//1,2,4,5,6,9,- 去重（distinct）
list.stream()
.distinct() //去重
.forEach((e)-> System.out.print(e + ",")//foreach遍历
);//1,2,6,4,5,9,
- 限定n个元素（limit(n)）
list.stream()
.distinct() //去重
.sorted((a,b)->{ return a- b; }) //排序
.limit(3) //限制n个元素
.forEach((e)-> System.out.print(e + ","));
//1,2,4,- 跳过 n 个元素（skip(n)）
list.stream()
.distinct() //去重
.sorted((a,b)->{ return a- b; }) //排序
.skip(4) //跳过4个元素
.forEach((e)-> System.out.print(e + ","));
//6,9- 映射（map()）
package javastream;
import java.util.Objects;
public class Car {
private int cno;
private String name;
private String color;
public Car() {
}
public Car(int cno, String name, String color) {
this.cno = cno;
this.name = name;
this.color = color;
}
public int getCno() {
return cno;
}
public void setCno(int cno) {
this.cno = cno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return cno == car.cno &&
name.equals(car.name) &&
color.equals(car.color);
}
@Override
public int hashCode() {
return Objects.hash(cno, name, color);
}
@Override
public String toString() {
return "Car{" +
"cno=" + cno +
", name='" + name + '\'' +
", color='" + color + '\'' +
'}';
}
}
import java.util.*;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
Car car1 = new Car(101,"宝马","黑色");
Car car2 = new Car(102,"大众","黑色");
Car car3 = new Car(103,"红旗","红色");
Car car6 = new Car(106,"小段","白色");
Car car4 = new Car(104,"奔驰","白色");
Car car5 = new Car(105,"黑马","黑色");
List<Car> alist = new ArrayList<>();
alist.add(car1);
alist.add(car2);
alist.add(car1);
alist.add(car5);
alist.add(car6);
alist.add(car3);
alist.add(car4);
alist.add(car1);
Map<Integer,String> carmap = alist.stream().distinct().
collect(Collectors.toMap(Car::getCno, Car::getName));
System.out.println(carmap);
//{101=宝马, 102=大众, 103=红旗, 104=奔驰, 105=黑马, 106=小段}
}
}
注：可以使用跳过和限定进行分页
list.stream()
.sorted((a,b)->{ return a- b; }) //排序
.skip(1)//跳过n个元素
.limit(3)//限制n个元素
.forEach((e)-> System.out.print(e + ","));
//2,2,4,终端操作： 获取你最终想要的数据
- 将流装入List集合 toList
- 将流装入Set集合 toSet
- foreach:遍历
- max
- min
- count 返回流中元素的个数
- reduce 所有元素求和
- anyMatch （接收一个 Predicate 函数，只要流中有一个元素满足条件 返回true，否则为false）
- allmatch（接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false）
- findFirst：返回流中的第一个元素
- collect：将流中的元素倒入一个集合，Collection 或 Map
import java.util.*;
import java.util.stream.Collectors;
public class StreamDemo {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(6);
list.add(4);
list.add(5);
list.add(6);
list.add(2);
list.add(9);
/*max
min
count：返回流中元素的个数
reduce： 所有元素求和
anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足条件
返回true，否则为false
allmatch：:接收一个 Predicate 函数，当流中每个元素都符合条件时才返
回 true，否则返回 false
findFirst：返回流中的第一个元素
collect：将流中的元素倒入一个集合，Collection 或 Map*/
int max = list.stream()
.filter((e)->{ return e>=1; }) //中间操作，过滤
.max(Integer::compare).get(); //获取最大值
System.out.println(max);//9
int min = list.stream()
.filter((e)->{ return e>=1; }) //中间操作，过滤
.min(Integer::compare).get(); //获取最小值
System.out.println(min);//1
//获取流中元素个数
long count = list.stream()
.filter((e)->{ return e>=1; }) //中间操作，过滤
.count();
System.out.println(count);//8
//所有元素求和
Optional<Integer> sum1 = list.stream().filter((e)->{ return e>=1; })
.reduce((x, y) -> x + y);
System.out.println(sum1);//Optional[35]
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
System.out.println(sum2);//Optional[35]
Integer sum3 = list.stream().reduce(0, Integer::sum);
System.out.println(sum3);//35
//anyMatch(是否存在符合条件你的元素）
boolean anyMatch = list.stream().filter((e)->{ return e>=1; })
.anyMatch (x -> x>5);
System.out.println(anyMatch);//true
//allmatch(所有元素都符合条件)
boolean allmatch = list.stream().filter((e)->{return e>=1;})
.allMatch(x-> x>5);
System.out.println(allmatch);//false
//返回流中的第一个元素
int first = list.stream().filter((e)->{return e>=1;})
.findFirst().get();
System.out.println(first);
//将流中的元素倒入一个Set集合
Set<Integer> set = list.stream().filter(e -> e>= 3)
.collect(Collectors.toSet());
System.out.println(set);//[4, 5, 6, 9]
//将流中的元素倒入一个List集合
List<Integer> alist = list.stream().filter(e -> e>=3)
.collect(Collectors.toList());
System.out.println(alist);//[6, 4, 5, 6, 9]
}
}
164
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
