java8 新特征 ---stream

}

接着:

package com.example.demo;

import com.example.demo.entity.hlvy;

import java.util.*;

import java.util.stream.Collectors;

import java.util.stream.Stream;

/**

• HlvyTest

• @author heng

**/

public class HlvyTest {

public static void main(String[] args) {

/**

• java8 新特征 stream map

• 拿到集合里实体类的某个字段

*/

List<hlvy> list = new ArrayList<hlvy>();

hlvy h = new hlvy();

hlvy h1 = new hlvy();

h.setName("yanyan");

h.setAge(18);

h1.setName("heng");

h1.setAge(18);

list.add(h);

list.add(h1);

List<String> name = list.stream().map(hlvy::getName).collect(Collectors.toList());

/*

for (String s : name) {

System.out.println(s);

}*/

/**

• java8 新特征 stream

• %2==0 就添加到集合 filter 让符合条件的通过，不符合的过滤掉

*/

List <Integer> nums = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

List<Integer> listTwo = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());

/* for (Integer integer : listTwo) {

System.out.println(integer);

}*/

/**

• java8 新特征 stream distinct 对数据进行去重

• %2==0 就添加到集合 并且不重复

*/

List <Integer> numsOne = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);

List<Integer> listThree = numsOne.stream().filter(num -> num % 2 == 0).distinct().collect(Collectors.toList());

/* for (Integer integer : listThree) {

System.out.println(integer);

}*/

/**

• java8 新特征 stream limit 限制数据出现的条数 limit 返回包含前 n 个元素的流，当集合大小小于 n 时，则返回实际长度

• 两个是 10 的数字

*/

List <Integer> numsTwo = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);

List<Integer> listFour = numsTwo.stream().filter(num -> num == 10).limit(2).collect(Collectors.toList());

/*for (Integer integer : listFour) {

System.out.println(integer);

}*/

/**

• java8 新特征 stream skip 与 limit 操作相反 跳过前 n 个元素

• 跳过前两个，从第三个开始

*/

List <Integer> numsFive = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);

List<Integer> listFive = numsFive.stream().filter(num -> num > 1).skip(2).collect(Collectors.toList());

/*for (Integer integer : listFive) {

System.out.println(integer);

}*/

/**

• java8 新特征 stream

• 计算和

*/

/**

• java8 新特征 stream map

• 拿到集合里实体类的某个字段

*/

List<hlvy> list2 = new ArrayList<hlvy>();

hlvy h2 = new hlvy();

hlvy h3 = new hlvy();

h2.setName("yanyan");

h2.setAge(18);

h3.setName("heng");

h3.setAge(18);

list2.add(h2);

list2.add(h3);

Integer ages = list2.stream().filter(list3 -> list3.getAge() > 1).mapToInt(hlvy::getAge).sum();

// System.out.println(ages);

/**

• 使用这些数值流的好处还在于可以避免 jvm 装箱操作所带来的性能消耗

• flatMap 用于合并用

*/

List<Integer> collected0 = new ArrayList<>();

collected0.add(1);

collected0.add(3);

collected0.add(5);

List<Integer> collected1 = new ArrayList<>();

collected1.add(2);

collected1.add(4);

collected1 = Stream.of(collected0, collected1)

.flatMap(num -> num.stream()).collect(Collectors.toList());

// System.out.println(collected1);// 1,3,5,2,4

/**

• java8 新特征 allMatch 用于检测是否全部都满足指定的参数行为，如果全部满足则返回 true

• 如果数组的数字全部大于 7 则返回 true 否则 false

*/

List <Integer> allMatchs = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);

boolean l

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开：qq.cn.hn/FTf 免费领取

istallMatchs = allMatchs.stream().allMatch(mas -> mas > 7);

// System.out.println(listallMatchs);

/**

• java8 新特征 anyMatch 检测是否存在一个或多个满足指定的参数行为，如果满足则返回 true

• 如果数组的数字 y 有等于 7 的返回 true

*/

List <Integer> allMatchs2 = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);

boolean listallMatchs2 = allMatchs2.stream().anyMatch(numt -> numt==7);

// System.out.println(listallMatchs2);

/**

• java8 新特征 noneMathch 检测是否不存在满足指定行为的元素

*不存在返回 true

*/

List <Integer> allMatchs3 = Arrays.asList(1,2,2,3,4,5,6,6,7,8,9,10,10);

boolean listallMatchs3 = allMatchs3.stream().noneMatch(numt -> numt==17);

// System.out.println(listallMatchs3);

/**

• java8 新特征 findFirst 返回满足条件的第一条元素

*/

List <Integer> allMatchs4 = Arrays.asList(1,2,3,4,5,6,6,7,8,9,10,10);

Optional<Integer> listallMatchs4 = allMatchs4.stream().filter(numt -> numt>1).findFirst();

if(listallMatchs4.isPresent()){//如果里面存有值

//System.out.println(listallMatchs4.get());

}

// 前面例子中的方法

int totalAge = list.stream()

.filter(hlvy -> "yanyan".equals(hlvy.getName()))

.mapToInt(hlvy::getAge).sum();

// System.out.println(totalAge);

// 归约操作

int totalAge11 = list.stream()

.filter(hlvy -> "yanyan".equals(hlvy.getName()))

.map(hlvy::getAge)

.reduce(0, (a, b) -> a + b);

// System.out.println(totalAge11);

// 进一步简化

int totalAge2 = list.stream()

.filter(hlvy -> "yanyan".equals(hlvy.getName()))

.map(hlvy::getAge)

.reduce(0, Integer::sum);

//System.out.println(totalAge2);

// 采用无初始值的重载版本，需要注意返回 Optional

Optional<Integer> totalAge22 = list.stream()

.filter(hlvy -> "yanyan".equals(hlvy.getName()))

.map(hlvy::getAge)

.reduce(Integer::sum); // 去掉初始值

// if (totalAge22.isPresent()) System.out.println(totalAge22.get());

/**

• 收集 前面利用 collect(Collectors.toList())是一个简单的收集操作，是对处理结果的封装

*来自于 java.util.stream.Collectors，我们可以称之为收集器。

*/

long count = list.stream().collect(Collectors.counting());

long count1 = list.stream().count();

//System.out.println(count+"-------"+count1);

/**

• 求年龄的最大值和最小值

*/

// 求最大年龄

Optional<hlvy> olderStudent = list.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge()));

// System.out.println(olderStudent.get().getAge());

// 进一步简化

Optional<hlvy> olderStudent2 = list.stream().collect(Collectors.maxBy(Comparator.comparing(hlvy::getAge)));

// System.out.println(olderStudent2.get().getAge());

// 求最小年龄

Optional<hlvy> olderStudent3 = list.stream().collect(Collectors.minBy(Comparator.comparing(hlvy::getAge)));

// System.out.println(olderStudent3.get().getAge());

/**

• 求年龄总和

*/

int totalAge4 = list.stream().collect(Collectors.summingInt(hlvy::getAge));