Operación de agregación lambda

	public static void main(String[] args) {
		Random random = new Random();
		List<Hero> heros = new ArrayList<Hero>();
		for (int i = 0; i < 10; i++) {
			heros.add(new Hero("hero" + i, random.nextInt(1000), random.nextInt(1000)));
		}
		
		System.out.println("初始化后的集合：");
		System.out.println(heros);
		System.out.println("查询条件：hp>100 && damage< 50");
		System.out.println("通过传统操作方式找出数据");
		
		for (Hero hero : heros) {
			if (hero.getFloHp() > 100 && hero.getIntDamage() < 50) {
				System.out.println(hero.getVcName());
			}
		}
		
		
		/**
		 * Stream是一系列的元素
		 * 管道是指一系列的聚合操作
		 * 
		 * 管道分3个部分
		 * 		管道源：在这个例子中，源是一个list
		 * 		中间操作：每个中间操作，又会返回一个Stream。
		 * 				比如filter()又返回一个Stream，中间操作是“懒”操作，并不会真正的遍历
		 * 		结束操作：当这个操作执行后，流就被使用“光”了，无法再被操作，所以这是流的最后一个操作
		 * 					结束不会返回Stream，但是会返回int、String、Collection或者像forEach什么都不返回
		 * 					结束操作才进行真正的遍历行为，在遍历的时候才会进行中间操作的相关判断。
		 */
		System.out.println("通过聚合操作方式找出满足条件的数据");
		heros
			.stream()
			.filter(hero-> hero.getFloHp()>100 && hero.getIntDamage()<50)
			.forEach(hero-> System.out.println(hero.getVcName()));
		
	}

Fuente de la tubería

		Random random = new Random();
		List<Hero> heros = new ArrayList<Hero>();
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero" + i, random.nextInt(1000), random.nextInt(1000)));
		}

		// 管道源是集合
		heros.stream().forEach(h -> System.out.println(h.getVcName()));

		// 管道源是数组
		Hero[] hs = heros.toArray(new Hero[heros.size()]);
		Arrays.stream(hs).forEach(h -> System.out.println(h.getVcName()));

Operación intermedia

		Random random = new Random();
		List<Hero> heros = new ArrayList<Hero>();
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero" + i, random.nextInt(1000), random.nextInt(1000)));
		}
		
		
		/**
		 * 每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
			中间操作比较多，主要分两类
			对元素进行筛选 和 转换为其他形式的流
			对元素进行筛选：
			filter 匹配
			distinct 去除重复(根据equals判断)
			sorted 自然排序
			sorted(Comparator<T>) 指定排序
			limit 保留
			skip 忽略
			转换为其他形式的流
			mapToDouble 转换为double的流
			map 转换为任意类型的流
		 */
		
		//制造一个重复数据
		heros.add(heros.get(0));
		System.out.println("初始化集合后的数据----------------------");
		System.out.println(heros);
		
		System.out.println("满足条件 hp>100&&damage<50的数据");
		heros
			.stream()
			.filter(h-> h.getFloHp()>100 && h.getIntDamage()<50)
			.forEach(h-> System.out.println(h));
		
		System.out.println("去除重复的数据");
		heros
			.stream()
			.distinct()
			.forEach(h-> System.out.println(h));
		
		System.out.println("按照血量排序");
		heros
			.stream()
			.sorted((h1, h2)-> h1.getFloHp() >= h2.getFloHp() ? 1 : -1)
			.forEach(h -> System.out.println(h));
		
		System.out.println("保留3个");
		heros
			.stream()
			.limit(3)
			.forEach(h -> System.out.println(h));
		
		System.out.println("忽略前3个");
		heros
			.stream()
			.skip(3)
			.forEach(h -> System.out.println(h));
		
		System.out.println("转换为double的stream");
		heros
			.stream()
			.mapToDouble(Hero::getFloHp)
			.forEach(h -> System.out.println(h));
		
		System.out.println("转换为任意类型的Stream");
		heros
			.stream()
			.map((h)-> h.getVcName() + " - " + h.getFloHp() + " - " + h.getIntDamage())
			.forEach(h -> System.out.println(h));
		

Fin de la operación

	当进行结束操作后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。 结束操作不会返回Stream，但是会返回int、float、String、 Collection或者像forEach，什么都不返回,。
结束操作才真正进行遍历行为，前面的中间操作也在这个时候，才真正的执行。
常见结束操作如下：
forEach() 遍历每个元素
toArray() 转换为数组
min(Comparator<T>) 取最小的元素
max(Comparator<T>) 取最大的元素
count() 总数
findFirst() 第一个元素

Random random = new Random();
		List<Hero> heros = new ArrayList<Hero>();
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero" + i, random.nextInt(1000), random.nextInt(1000)));
		}
		
		System.out.println("遍历集合中的每个数据");
		heros
			.stream()
			.forEach(h->System.out.println(h));
		
		System.out.println("返回一个数组");
		Object[] hs = heros
			.stream()
			.toArray();
		System.out.println(Arrays.toString(hs));
		
		System.out.println("返回伤害最低的那个英雄");
		Hero minDamageHero = heros
							.stream()
							.min((h1, h2) -> h1.getIntDamage() - h2.getIntDamage())
							.get();
		System.out.println(minDamageHero);
		
		System.out.println("返回伤害最高的那个英雄");
		Hero maxDamageHero = heros
								.stream()
								.max((h1, h2) -> h1.getIntDamage() - h2.getIntDamage())
								.get();
		System.out.println(maxDamageHero);
		
		System.out.println("流中的数据的总数");
		long count = heros
						.stream()
						.count();
		System.out.println("总数：" + count);
		
		System.out.println("第一个英雄");
		Hero firstHero = heros
							.stream()
							.findFirst()
							.get();
		System.out.println(firstHero);