java8新特性——StreamAPI

最新推荐文章于 2023-10-12 10:35:20 发布
最新推荐文章于 2023-10-12 10:35:20 发布
阅读量1.6k 收藏
点赞数
分类专栏： Java 文章标签： java8 新特性 StreamAPI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_ZhouR/article/details/102969371
版权

什么是Stream？

是数据渠道，用于操作数据源（集合数组等）所生成的元素序列

“集合讲的是数据，流讲的是计算”

注意：

  1. Strram自己不会存储元素。
  2. Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
  3. Stream操作时延迟执行的。这意味着他们会等到需要结果的时候才执行

Stream的三个操作步骤：

  1. 创建Stream
  2. 中间操作
  3. 终止操作（终端操作）

创建Stream

  1. 可以通过Collection系列集合提供的stream()或parallelStream()

    • stream()：串行流

    • parallelStream()：并行流

    • List<Object> list = new ArrayList<>();
Stream<Object> stream = list.stream();//得到一个流

  2. 通过Arrays中的静态方法stream()获取数组流

    • String[] emps = new String[10];
Stream<String> stream1 = Arrays.stream(emps);

  3. 通过Stream类中的静态方法 of()

    • Stream<String> stream2 = Stream.of("aa", "bb", "cc");  //可变数组

  4. 创建无限流

    1. 迭代

      • Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2);
//stream3.forEach(System.out::println);
//按照一元运算的规律  从0开始，无限+2

//添加限制操作  限制只打印10个
stream3.limit(10).forEach(System.out::println);

    2. 生成

      • Stream<Double> generate = Stream.generate(Math::random); 
//生成随机数
generate.limit(2).forEach(System.out::println);

创建实体类

public class Employee {
	private String name;
	private  Integer age;
	private  double salary;
	private Status status;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Status getStatus() {
		return status;
	}

	public void setStatus(Status status) {
		this.status = status;
	}

	public Employee(String name, Integer age, double salary, Status status) {
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.status = status;
	}

	public Employee() {

	}

	@Override
	public String toString() {
		return "Employee{" +
				"name='" + name + '\'' +
				", age=" + age +
				", salary=" + salary +
				", status=" + status +
				'}';
	}

	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		Employee employee2 = (Employee) o;
		return Double.compare(employee2.salary, salary) == 0 &&
				Objects.equals(name, employee2.name) &&
				Objects.equals(age, employee2.age) &&
				status == employee2.status;
	}

	@Override
	public int hashCode() {
		return Objects.hash(name, age, salary, status);
	}

	public enum Status{
		FREE,	//空闲
		BUSY,	//忙
		VOCATION	//休假
	}
	
	public static List<Employee> getData() {
        return Arrays.asList(
			new Employee("张三", 18, 9999.99, Status.FREE),
			new Employee("李四", 58, 5555.55, Status.VOCATION),
			new Employee("王五", 26, 3333.33, Status.VOCATION),
			new Employee("赵六", 36, 6666.66, Status.BUSY),
			new Employee("赵六", 36, 6666.66, Status.FREE),
			new Employee("田七", 12, 8888.88, Status.BUSY)
        );
    }
}

中间操作与终止操作的一些说明

  • 如果没有终止操作，那么中间操作不会执行
  • 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，
  • 否则中间操作不会执行，任何的处理
  • 而在终止操作时一次性全部处理，成为惰性求值

例子：

@Test
public void test3() {
    Stream<Employee> stream = employees.stream()//创建流 获取流
        .filter((x) -> {
            System.out.println("中间操作");
            return x.getSalary() > 6000;
        });

}

这段代码没有任何运行结果，因为没有终止操作。

中间操作

筛选与切片：

方法介绍
filte接收Lambda ，从流中排除某些元素
limit截断流，使其元素不超过给定数量。
skip(n)跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
distinct筛选，通过流所生成元素的hashCode()和equals()去重复元素
filter
  • 接收Lambda ，从流中排除某些元素
@Test
public void test2() {
    employees.stream()//创建流 获取流
        .filter((x) -> x.getSalary() > 6000)  
        //入参断言型接口 boolean TraderTest(T t);
        .forEach(System.out::println);        //终止操作
}

结果：
Employee{name='张三', age=18, salary=9999.99, status=FREE}
Employee{name='赵六', age=36, salary=6666.66, status=BUSY}
Employee{name='赵六', age=36, salary=6666.66, status=FREE}
Employee{name='田七', age=12, salary=8888.88, status=BUSY}
limit
/**
	 * limit —— 截断流，使其元素不超过给定数量。
	 */
@Test
public void test5() {

    employees.stream()
        .filter((x) ->
                {
                    System.out.println("短路");
                    return x.getSalary() > 6000;
                }
               )
        .limit(2)  //筛选完后只打印两个
        .forEach(System.out::println);

    //这里找到符合条件的两个就停止，后续的操作就没有了，
    //说明所有的中间操作都是同步进行的，增加了效率

}

结果：
短路
Employee{name='张三', age=18, salary=9999.99, status=FREE}
短路
短路
短路
Employee{name='赵六', age=36, salary=6666.66, status=BUSY}
skip(n)
/**
	 * skip(n) —— 跳过元素，返回一个扔掉了前n个元素的流。
	 * 若流中元素不足n个，则返回一个空流。与limit(n)互补
	 */
@Test
public void test6() {
    employees.stream()
        .filter((x) ->
                {
                    System.out.println("skip");
                    return x.getSalary() > 6000;
                }
               )
        .skip(2)
        .forEach(System.out::println);
}

结果：
skip
skip
skip
skip
skip
Employee{name='赵六', age=36, salary=6666.66, status=FREE}
skip
Employee{name='田七', age=12, salary=8888.88, status=BUSY}
distinct
/**
	 * distinct —— 筛选，通过流所生成元素的hashCode()和equals()去重复元素
	 *
	 * 需要重写hashCode和equals
	 */
@Test
public void test7() {
    employees.stream()
        .distinct()
        .forEach(System.out::println);
}

结果：
Employee{name='张三', age=18, salary=9999.99, status=FREE}
Employee{name='李四', age=58, salary=5555.55, status=VOCATION}
Employee{name='王五', age=26, salary=3333.33, status=VOCATION}
Employee{name='赵六', age=36, salary=6666.66, status=BUSY}
Employee{name='赵六', age=36, salary=6666.66, status=FREE}
Employee{name='田七', age=12, salary=8888.88, status=BUSY}

映射

方法介绍
map接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连成一个流
map
/**
	 * map——接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，
	 * 		该函数会被应用到每个元素上，并将其映射成一个新的元素。
	 */
	@Test
	public void test8(){
		List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
		list.stream()
				.map((x) -> x.toUpperCase()) //把集合所有内容转大写
				.forEach(System.out::println);
		//AAA
		//BBB
		//CCC
		//DDD

		System.out.println("---------------------");

		employees.stream()
				.map((x) -> x.getName())
				.forEach(System.out::println);
		//张三
		//李四
		//王五
		//赵六
		//赵六
		//田七

	}
flatMap

先声明一个方法

//穿进去一个字符串，把一个字符串中所有的字符一个一个提取出来
	 static Stream<Character> filterCharacter(String str){
		List<Character> list = new ArrayList<>();

		for (Character character : str.toCharArray()) {
			list.add(character);
		}

		return list.stream();
	}

使用flapmap

/**
	 * flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连成一个流
	 */
@Test
public void test9(){
    System.out.println("\n\n---------普通字符串---------");
    //普通字符串
    String str = "helloworld";
    filterCharacter(str).forEach(System.out::print);
    //helloworld

    System.out.println("\n\n---------集合---------");
    //集合
    List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
    Stream<Stream<Character>> stream = list.stream()
        .map(demo1::filterCharacter);  //{{a,a,a},{b,b,b},{c,c,c},...}
    //得到的是流的集合，集合里还是个流，然后二层遍历
    stream.forEach(
        (x) -> x.forEach(System.out::print)
    );
    //结果：aaabbbcccddd


    System.out.println("\n\n---------flatMap---------");
    //扁平化，平铺的意思
    Stream<Character> stream1 = list.stream()//{a,a,a,b,b,b,c,c,c,...}
        .flatMap((x) -> filterCharacter(x));
    stream1.forEach(System.out::print);
    //结果：aaabbbcccddd


}

map和flatmap的区别：

  • map是把多个流放入一个流 形成{ { }, { }, { } }的形式
  • flapmap是把每个流中的元素，作为单独的元素加入到新的流中
  • 相当于集合add() 和 addAll()方法
测试集合add() 和 addAll()方法
/**
	 * function:测试集合add() 和  addAll()方法
	 */
	@Test
	public void test10(){

		List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");

		List list2 = new ArrayList<>();

		list2.add(111);
		list2.add(222);
		list2.add(list);
		System.out.println(list2);
		//结果：[111, 222, [aaa, bbb, ccc, ddd]]


		List list3 = new ArrayList<>();

		list3.add(111);
		list3.add(222);
		list3.addAll(list);
		System.out.println(list3);
		//结果：[111, 222, aaa, bbb, ccc, ddd]
	}

结论：

  • add是整个集合传进来
  • addAll()是将集合中的元素拆分，作为单独的元素传进来
  • 所以map相当于把流加到当前的流中
  • flatMap相当于把流中的元素，加到新流中

排序

方法介绍
sorted()自然排序
sorted(Comparator com)定制排序
sorted()
/**
	 	排序
	 	sorted() 自然排序
	 	sorted(Comparator com) 定制排序
	 */
@Test
public void test11(){
    List<String> list = Arrays.asList("eee","ccc","bbb","aaa","ddd");
    list.stream()
        .sorted()
        .forEach(System.out::println);
    //结果：
    //aaa
    //bbb
    //ccc
    //ddd
    //eee

}
sorted(Comparator com)
/**
	 * sorted(Comparator com) 定制排序
	 */
	@Test
	public void test111(){
		List<String> list = Arrays.asList("eee","ccc","bbb","aaa","ddd");
		list.stream()
				.sorted((x,y) -> -x.compareTo(y))
				.forEach(System.out::println);
		//结果：
		//eee
		//ddd
		//ccc
		//bbb
		//aaa

		//定制排序：按照年龄排序，年龄一样按照姓名排
		employees.stream()
				.sorted((x,y) -> {
					if(x.getAge().equals(y.getAge())){
						return x.getName().compareTo(y.getName());
					}	else {
						return x.getAge().compareTo(y.getAge());
					}

				}).forEach(System.out::println);
	}
结果：
Employee{name='田七', age=12, salary=8888.88, status=BUSY}
Employee{name='张三', age=18, salary=9999.99, status=FREE}
Employee{name='王五', age=26, salary=3333.33, status=VOCATION}
Employee{name='赵六', age=36, salary=6666.66, status=BUSY}
Employee{name='赵六', age=36, salary=6666.66, status=FREE}
Employee{name='李四', age=58, salary=5555.55, status=VOCATION}

终止操作

查找与匹配

方法介绍
allMatch(Predicate p)检查是否匹配所有元素
anyMatch(Predicate p)检查是否至少匹配一个元素
noneMatch(Predicate p)检查是否没有匹配所有元素
findFirst()返回第一个元素
findAny()返回当前流中的任意元素
count()返回流中元素的总个数
max()返回流中最大值
min()返回流中最小值
allMatch(Predicate p)
anyMatch(Predicate p)
noneMatch(Predicate p)
findFirst()
findAny()
/**
    allMatch(Predicate p)

    anyMatch(Predicate p)

    noneMatch(Predicate p)

    findFirst()

    findAny()	
*/
@Test
public void test12(){

    //判断是否所有员工都是BUSY状态
    boolean b = employees.stream()
        .allMatch((x) -> x.getStatus().equals(Employee.Status.BUSY));
    System.out.println("b = " + b);	//b = false

    //判断是否至少有一位员工是BUSY状态
    boolean b1 = employees.stream()
        .anyMatch((x) -> x.getStatus().equals(Employee.Status.BUSY));
    System.out.println("b1 = " + b1);//b1 = true

    //判断是否没有休假的员工
    boolean b2 = employees.stream()
        .noneMatch((x) -> x.getStatus().equals(Employee.Status.VOCATION));
    System.out.println("b2 = " + b2);//b2 = false

    //返回工资最低的员工 findFirst()
    Optional<Employee> first = employees.stream()
        .sorted((x,y) -> Double.compare(x.getSalary(),y.getSalary()))
        .findFirst();
    System.out.println("first = " + first.get());
    //first = Employee{name='王五', age=26, salary=3333.33, status=VOCATION}

    //任意找一个空闲状态的员工（串行流，挨个儿找）
    Optional<Employee> any = employees.stream()
        .filter((x) -> x.getStatus().equals(Employee.Status.FREE))
        .findAny();
    System.out.println("any = " + any.get());
    //any = Employee{name='赵六', age=36, salary=6666.66, status=FREE}


    //任意找一个空闲状态的员工（并行流，多个线程一起找，谁先找到算谁）
    Optional<Employee> any2 = employees.parallelStream()
        .filter((x) -> x.getStatus().equals(Employee.Status.FREE))
        .findAny();
    System.out.println("any2 = " + any2.get());
    //any = Employee{name='赵六', age=36, salary=6666.66, status=FREE}

}
count()
max()
min()
/**
	 * 	count()				返回流中元素的总个数
	 * 	max()				返回流中最大值
	 * 	min()				返回流中最小值
	 */
@Test
public void test13(){
    long count = employees.stream()
        .count();
    System.out.println("count = " + count); //count = 6

    //获取工资最高的
    Optional<Employee> max = employees.stream()
        .max((x, y) -> Double.compare(x.getSalary(), y.getSalary()));
    System.out.println("max = " + max.get().getSalary());  //max = 9999.99

    //获取工资最低的
    Optional<Double> min = employees.stream()
        .map(Employee::getSalary)
        .min(Double::compareTo);
    System.out.println("min = " + min.get());  //min = 3333.33


}

归约

  • 可以将流中元素反复结合起来，得到一个值
方法介绍
reduce(T identity, BinaryOperator)返回T identity 起始值 BinaryOperator二元运算
reduce(BinaryOperator)返回Optional
reduce(T identity, BinaryOperator)
reduce(BinaryOperator)
/**
	 * function:
	 */
@Test
public void test14(){
    List<Integer> list = Arrays.asList(1,2,3,4,5);

    Integer sum = list.stream()
        .reduce(0, (x, y) -> x + y);
    System.out.println("sum = " + sum);  //sum = 15


    Integer sum2 = list.stream()
        .reduce(10, (x, y) -> x + y);
    System.out.println("sum2 = " + sum2);  //sum2 = 25


    //首先将起始值作为x，然后从流中取出一个元素给y，
    //然后把运算的结果给x，再从集合中取值运算，直到最后


    System.out.println("----------工资的总和-------------");
    Optional<Double> sumSalary = employees.stream()
        .map((x) -> x.getSalary())
        .reduce((x, y) -> x + y);
    System.out.println("sumSalary= " + sumSalary.get()); 
    //sumSalary = 41111.07

}

这里想一下，为什么上面的返回值是原始值，而工资的返回值是Optional

上面的有初始值，一定不会为空，，而下面的工资没有初始值，可能为空

Optional的原理就是，只要返回的对象有可能为空，那么就封装到Optional中去

备注：map和reduce的连接称为map-reduce模式，因Google用它类进行网络搜索而出名

收集

collect(Collector c)——将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

Collector接口中方法的实现决定了如何对流执行收集操作（如搜集到List，Set，Map）

但是Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，

Collectors.toList()
/**
	 * function:把当前公司员工的名字提取出来，并放到一个集合中
	 */
@Test
public void test15(){

    //收集到list集合中
    List<String> list = employees.stream()
        .map(Employee::getName)
        .collect(Collectors.toList());
    System.out.println("list = " + list);
    //list = [张三, 李四, 王五, 赵六, 赵六, 田七]



    //收集到set集合中，可去重
    Set<String> set = employees.stream()
        .map(Employee::getName)
        .collect(Collectors.toSet());
    System.out.println("set = " + set);
    //set = [李四, 张三, 王五, 赵六, 田七]


    //可以在Collectors.toCollection()中指定任意集合
    HashSet<String> hashSet = employees.stream()
        .map(Employee::getName)
        .collect(Collectors.toCollection(HashSet::new));
    System.out.println("hashSet = " + hashSet);

}
操作数字
/**
	 * function:操作数字
	 */
@Test
public void test16(){

    //总数
    Long size = employees.stream()
        .collect(Collectors.counting());
    System.out.println("集合总数 = " + size);

    //平均值
    Double avg = employees.stream()
        .collect(Collectors.averagingDouble((x) -> x.getSalary()));
    System.out.println("工资平均值"+avg);

    //计算总和
    Double total = employees.stream()
        .collect(Collectors.summingDouble((x) -> x.getSalary()));
    System.out.println("工资总数： = " + total);


    //最大值  方法一、
    Optional<Employee> max = employees.stream()
        .collect(Collectors.maxBy((x, y) -> Double.compare(x.getSalary(), y.getSalary())));
    System.out.println("max = " + max.get());
    //max = Employee{name='张三', age=18, salary=9999.99, status=FREE}

    //最大值  方法二、
    Optional<Employee> max1 = employees.stream()
        .max((x, y) -> Double.compare(x.getSalary(), y.getSalary()));
    System.out.println("max1 = " + max1.get());
    //max = Employee{name='张三', age=18, salary=9999.99, status=FREE}


    //最小值
    Optional<Double> min = employees.stream()
        .map((x) -> x.getSalary())
        .collect(Collectors.minBy(Double::compare));
    System.out.println("min = " + min.get());
    //min = 3333.33


}
Collectors.groupingBy()
/**
	 * function: 分组
	 */
	@Test
	public void test17(){
		//按照状态分组  返回map，key-状态  value-状态下的内容
		//map没有foreach方法
		Map<Employee.Status, List<Employee>> map = employees.stream()
				.collect(Collectors.groupingBy((x) -> x.getStatus()));
		System.out.println("map = " + map);
	}

结果：
map = {
	 BUSY=[Employee{name='赵六', age=36, salary=6666.66, status=BUSY}, Employee{name='田七', age=12, salary=8888.88, status=BUSY}],
	 VOCATION=[Employee{name='李四', age=58, salary=5555.55, status=VOCATION}, Employee{name='王五', age=26, salary=3333.33, status=VOCATION}],
	 FREE=[Employee{name='张三', age=18, salary=9999.99, status=FREE}, Employee{name='赵六', age=36, salary=6666.66, status=FREE}]
	}
多级分组
/**
	 * function:多级分组
	 * 可以在Collectors.groupingBy后再跟一个Collectors.groupingBy
	 * 先按照状态分，分完之后按照年龄分
	 */
@Test
public void test18(){
Map<Employee.Status, Map<String, List<Employee>>> map = employees.stream()
        .collect(Collectors.groupingBy(Employee::getStatus,
           Collectors.groupingBy((e) -> {
                  if (e.getAge() <= 35) {
                         return "青年";
                   } else if (e.getAge() > 35 && e.getAge() <= 50) {
                          return "中年";
                   } else {
                          return "老年";
                    }
              })
));
    System.out.println("map = " + map);

/*
结果：
map = {
BUSY={
	青年=[Employee{name='田七', age=12, salary=8888.88, status=BUSY}],
	中年=[Employee{name='赵六', age=36, salary=6666.66, status=BUSY}]
     },
VOCATION={
	青年=[Employee{name='王五', age=26, salary=3333.33, status=VOCATION}],
	老年=[Employee{name='李四', age=58, salary=5555.55, status=VOCATION}]
		},
FREE={
	青年=[Employee{name='张三', age=18, salary=9999.99, status=FREE}],
	中年=[Employee{name='赵六', age=36, salary=6666.66, status=FREE}]
	 }
}

*/

}
分片，分区
/**
	 * function: 分片，分区
	 *
	 * 符合条件的一个区，不满足条件的一个区
	 */
@Test
public void test19(){
    Map<Boolean, List<Double>> map = employees.stream()
        .map(Employee::getSalary)
        .collect(Collectors.partitioningBy((x) -> x > 6000));
    System.out.println(map);
    
//结果：
//{
//   false=[5555.55, 3333.33],
//   true=[9999.99, 6666.66, 6666.66, 8888.88]
// }


}
Collectors.summarizingDouble
/**
	 * function: 计算数字总和平均值最大最小
	 */
@Test
public void test20(){
    DoubleSummaryStatistics dss = employees.stream()
        .collect(Collectors.summarizingDouble(Employee::getSalary));

    double sum = dss.getSum();
    System.out.println("sum = " + sum); //sum = 41111.07

    double max = dss.getMax();
    System.out.println("max = " + max); //max = 9999.99
}
joining()
/**
	 * function:连接 joining
	 */
@Test
public void test21(){
    //连接字符串
    String collect = employees.stream()
        .map(Employee::getName)
        .collect(Collectors.joining());
    System.out.println("collect = " + collect); 
    //collect = 张三李四王五赵六赵六田七


    //还可以加逗号，去除前后的逗号
    String collect1 = employees.stream()
        .map(Employee::getName)
        .collect(Collectors.joining(","));
    System.out.println("collect1 = " + collect1); 
    //collect1 = 张三,李四,王五,赵六,赵六,田七


    //如果要首尾添加
    String collect2 = employees.stream()
        .map(Employee::getName)
        .collect(Collectors.joining(",", "*****", "###"));
    System.out.println("collect2 = " + collect2);  
    //collect2 = *****张三,李四,王五,赵六,赵六,田七###

}
Mr_ZhouR
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java8stream源码-java8-features:java8-功能
06-04
java8流源码java8-功能 一些重要的 Java 8 特性是 Java 流 API Iterable 接口中的 forEach() 方法 接口中的默认和静态方法 函数式接口和 Lambda 表达式 Java时间API 集合 API 改进 并发 API 改进 选修课 Java 中的 ...
Java8使用stream处理集合
ZHAIKE的博客
07-26 3786
stream类处理集合1. 将集合类型进行一个转换（map）2. 过滤集合中符合条件的元素，并返回一个新集合（filter）3. 循环集合进行操作（forEach） 简单的使用方法，是将list转为流进行处理 1. 将集合类型进行一个转换（map） // 1.将对象包装为返回类 List<User> dataList = UserMapper.selectList(null); List<UserVO> voList = dataList.stream().map(data -&gt
JAVA的Stream流操作 简单总结
l10711097061的博客
10-14 4103
JAVA的Stream流操作 简单总结
java8 List的Stream流操作 (常用篇 一)
DJyzh的博客
06-08 3581
java8 List的Stream流操作 (常用篇 一) 1、Stream流 遍历(forEach) 2、Stream流 过滤(filter) 3、Stream流 排序(sortAndReversed) 4、Stream流 去重(distinct) 5、Stream流 分组(Collectors.groupingBy) 6、Stream流 toMap()获取、转化map 关键字groupingBy、distinct、count、anyMatch、noneMatch、allMatch、thenCompar
别再使用循环的方式筛选元素了！开发常用的Stream流+Lambda表达式过滤元素了解过吗？10000字超详细解析
最新发布
m0_70325779的博客
10-12 1125
如下所示，参数可以为 字符串，整型，浮点型，这些零散不统一的数据，但是，这种方式几乎在开发中根本不会用，我们不会吧数据类型不一致的数据放在一起，所以自己敲代码的时候玩玩就可以了，这种 获取 stream 流的方式了解即可，concat 合并两个流的方法，我调用此方法的时候，建议两个要合并的流存放相同类型的数据，如果存放的不相同，那么合并后的流存放的类型就两个流数据类型的父类，可能会导致原来自己独有的方法无法被调用，这一点要注意。
Stream集合详细操作（jdk1.8新特性）
qq_53464269的博客
03-05 2812
Stream集合
java8新特性之Stream
yangzhanghui的专栏
07-06 4712
Java8中的Stream是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作(bulk data operation)。Stream不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的Iterator。原始版本的Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的Stream，用户只要给出需要对其包含的元素执行什么操作，比如，“过滤掉长度大于 10 的字符串”、..
stream流从数组或集合中找到符合条件的就返回该对象
qq_50523945的博客
07-20 1316
不并行使用流时，两者效果一致。当并行使用时，如果只是想找到了就成立就使用findAny，否则采用findFirst.
java8(stream)从数组或集合中找到符合条件的就返回该对象
wflsyf的博客
01-09 1万+
测试代码 public static void main(String[] args) { List<Integer> list =new ArrayList<>(); for (int i=0;i<10000;i++){ list.add(i); } Integer integer = list.stream() .filter(integer1 -> {
Stream流方式处理List示例
qq_42570967的博客
12-04 2653
Stream流方式处理List
java8 .stream().filter()
Garry
10-31 4214
1.输出符合表达式的每一个对象 employees.stream().filter(p -> p.getAge() > 21).forEach(System.out::println); //输出每一个对象 2.返回一个符合表达式的集合 Stream<Person> personStream = collection.stream().filter(new Predica...
JDK_API_1_6
03-01
Externalizable Externalizable 实例类的唯一特性是可以被写入序列化流中，该类负责保存和恢复实例内容。 FileFilter 用于抽象路径名的过滤器。 FilenameFilter 实现此接口的类实例可用于过滤器文件名。 ...
写给大忙人看的JAVA SE 8
03-08
第9章你可能错过的Java 7特性 188 9.1 异常处理改进 190 9.1.1 try-with-resources语句 190 9.1.2 忽略异常 191 9.1.3 捕获多个异常 192 9.1.4 更简单地处理反射方法的异常 193 9.2 使用文件 193 9.2.1 Path 194 ...
写给忙人看的java SE8
01-08
第一章 lambda表达式 第二章 streamAPI 第三章 使用lambda编程 第四章 javaFX 第五章 新的时日期和时间API 第六章 并发曾强 第七章 javaScript引擎——Nashron 第八章 杂项改进 第九章 java7特性
JAVA入门1.2.3：一个老鸟的JAVA学习心得 PART1（共3个）
05-07
3.4 小结：基本数据类型—— Java中一切数据和运算的基础 63 3.5 习题 65 第4章 Java中的程序执行流程 67 教学视频：1小时57分钟 4.1 顺序执行 67 4.2 使用if-else让程序懂得判断 68 4.2.1 if语句 68 4.2.2 ...
Java 8中新特性Stream的详细理解和使用
m0_56245143的博客
04-18 982
Stream是对集合Collection对象功能的增强，Stream可以对集合对象进行便利高效的聚合操作和大批量的数据操作，集合类存有的元素都是划分内存空间存储的，数据量很大的集合类会占用大量的内存。获取一个数据源source => 数据转换 => 执行操作获取需要的结果，每次转换后原来的Stream对象不变，返回一个新的Stream对象，这样可以使得对Stream的操作链式排列，形成一个管道。集合的大小是有界的，但数据流Stream可以是无界的，短路操作等可以允许无限流计算在有限的时间内完成。
JDK8 常用的Stream流操作 方法
肥宅友的博客
06-18 1972
Stream流操作、Stream流map方法、Stream流排序、Stream流map和peek的区别、Stream流过滤filter、Stream创建集合、Stream和迭代器遍历集合。
stream流的常用方法
cyx2302743125的博客
11-18 2038
stream的常用用法
Java8 使用 stream().filter()过滤List对象（查找符合条件的对象集合）
热门推荐
m0_67402125的博客
09-11 1万+
深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
stream流倒序排序_Java8新特性——强大的Stream
05-24
Java 8 中的 Stream API 提供了很多方便的方法来处理集合数据，其中一个非常有用的功能就是对集合元素进行排序。要对 Stream 流进行倒序排序，可以使用 `sorted()` 方法，该方法接受一个 Comparator 参数，用于指定...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值