介绍:Java 8 是一种流式编程,它支持通过使用Stream来更高效率地处理用户设定的操作。使用流API,您可以执行以下操作:
-
过滤 filter:对流中的元素进行过滤,仅保留符合给定条件的元素。
-
映射 map: 对流中的每个元素执行指定的函数,并将结果收集到另一个流中。
-
排序P sorted:根据指定的排序规则对流中的元素进行排序。
-
合并 reduce:将流中的元素合并到一个单一的结果中,使用给定的函数作为累加器,可以使用此函数对每个元素执行特定的功能。
-
聚合 collect:收集流中的元素,将它们收集到集合中,或将它们处理为Map,并返回一个结果容器。
-
计数 count:计算流中元素数量。
-
最值 min/max:返回流中的最小或最大元素。
-
匹配 anyMatch/allMatch/noneMatch:检查流中的元素是否与给定的条件匹配。
区别
Stream().map是将原有的集合中的每一项,通过映射函数转换为新的集合;而Stream().filter是对原有集合进行过滤,过滤出符合条件的结果集,剩下不满足条件的不作处理。
实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Test implements Serializable {
private Integer id;
private String name;
private String address;
// 部门id
private Integer deptId;
public Test(String name, String address) {
this.name = name;
this.address = address;
}
}
@Data
@AllArgsConstructor
@NoArgsConstructor
public class DeptMerge implements Serializable {
private Integer testId;
private Integer deptId;
}
测试
// 测试
public static void main(String[] args) {
List<Test> testList = Arrays.asList(new Test(1, "张三", "安徽", 2), new Test(2, "李四", "芜湖", 2), new Test(3, "王五", "六安", 3), new Test(4, "赵七", "南京", 4), new Test(5, "张三", "南京", 5));
// 获取当中的name集合
List<String> nameList = testList.stream().map(test -> test.getName()).collect(Collectors.toList());
// System.out.println(nameList); [张三, 李四, 王五, 赵七]
// 将testList的id转换为Long
Integer[] idToLong = testList.stream().map(Test::getId).toArray(Integer[]::new);
// System.out.println(idToLong); [1,2,3,4]
// list - > new List
List<Test> newList = testList.stream().map(p -> {
return new Test(p.getName(), p.getAddress());
}).collect(Collectors.toList());
// System.out.println(newList);
//[Test(id=null, name=张三, address=安徽, deptId=null), Test(id=null, name=李四, address=芜湖, deptId=null), Test(id=null, name=王五, address=六安, deptId=null), Test(id=null, name=赵七, address=南京, deptId=null)]
//将学生姓名放到Set中,可以实现去重功能
Set<String> collectToSet = testList.stream().map(Test::getName).collect(Collectors.toSet());
//[李四, 张三, 王五, 赵七]
// 使用Arrays.stream().map 适用于一对多关系
Integer[] toArray = testList.stream().map(Test::getId).toArray(Integer[]::new);
Arrays.stream(toArray).map(id->new DeptMerge(id,1)).collect(Collectors.toSet());
System.out.println(toArray);
}
user实体类
public class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public User() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public static void main(String[] args) {
ArrayList<User> users = new ArrayList<>();
users.add(new User("张三",20));
users.add(new User("李四",23));
users.add(new User("王五",18));
Stream<User> stream = users.stream();
Optional<User> sum = stream.reduce(new BinaryOperator<User>() {
@Override
public User apply(User user, User user2) {
User sum = new User("sum", user.getAge() + user2.getAge());
return sum;
}
});
System.out.println(sum.get());
}
public static void main(String[] args) {
ArrayList<User> users = new ArrayList<>();
users.add(new User("张三",20));
users.add(new User("李四",23));
users.add(new User("王五",18));
Stream<User> stream = users.stream();
Optional<User> min = stream.min(new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
return o1.getAge() - o2.getAge();
}
});
System.out.println(min.get());
}
}
public static void main(String[] args) {
ArrayList<User> users = new ArrayList<>();
users.add(new User("张三",20));
users.add(new User("李四",23));
users.add(new User("王五",18));
Stream<User> stream = users.stream();
boolean b = stream.allMatch(new Predicate<User>() {
@Override
public boolean test(User user) {
return "张三".equals(user.getName());
}
});
System.out.println(b);
}
}
public static void main(String[] args) {
ArrayList<User> users = new ArrayList<>();
users.add(new User("张三",20));
users.add(new User("李四",23));
users.add(new User("王五",18));
Stream<User> stream = users.stream();
stream.filter(user -> "张三".equals(user.getName()) && user.getAge()>18).forEach(s-> System.out.println(s));
}
}
public static void main(String[] args) {
ArrayList<User> users = new ArrayList<>();
users.add(new User("张三",20));
users.add(new User("李四",23));
users.add(new User("王五",18));
Stream<User> stream = users.stream();
stream.skip(2).limit(2).forEach(s-> System.out.println(s));
}
}
public static void main(String[] args) {
ArrayList<User> users = new ArrayList<>();
users.add(new User("张三",20));
users.add(new User("李四",23));
users.add(new User("王五",18));
users.add(new User("王五",28));
users.add(new User("赵六",15));
Stream<User> stream = users.stream();
stream.sorted((o1,o2)->-(o1.getAge()-o2.getAge())).filter(s->"王五".equals(s.getName())).limit(2).forEach(s-> System.out.println(s));
}
}
public static void main(String[] args) {
Instant now = Instant.now();
int sum=0;
for (int i = 0; i < 1000000; i++) {
sum+=i;
}
Instant end = Instant.now();
System.out.println("话费的时间是:"+ Duration.between(now,end).toMillis());
}
}
public static void main(String[] args) {
String username=null;
Optional.ofNullable(username).filter(new Predicate<String>() {
@Override
public boolean test(String s) {
return "张三".equals(s);
}
}).isPresent();
}
}
public static void main(String[] args) {
String username=null;
Optional<String> option = Optional.ofNullable(username);
if (option.isPresent()){
System.out.println(option.get());
}
}
}