java8中Stream如何使用

java8中Stream如何使用，針對這個問題，這篇文章詳細介紹了相對應的分析和解答，希望可以幫助更多想解決這個問題的小伙伴找到更簡單易行的方法。

1.使用Stream

java8使用stream可以方便對數據集進行各種處理，顯得程序不是那么冗余,Stream使用一般都包含這三個步驟。

1. 定義一個數據源

2. 定義中間操作形成流水線

3. 定義終端操作，執行流水線，生成計算結果

1.1 構建流

Stream.of("tony","9527","952")
                .forEach(System.out::println);

 int[] nums = {1, 2, 3, 4, 100, 6};
 Arrays.stream(nums).sorted().forEach(System.out::println);

 Files.lines(Paths.get("/Users/1120291/Desktop/test.txt"))
 .forEach(System.out::println);

1.2 中間操作

1.2.1 filter

該操作接受一個返回boolean的函數，當返回false的元素將會被排除掉

class Person{
    private String name;
    private Integer age;

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

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

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

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }
}

public static List<Person> getPersonList(){
    List<Person> personList=new ArrayList<>();
    for(int i=0;i<10;i++){
        Person p=new Person();
        p.setName("test"+i);
        p.setAge(new Random().nextInt(50));
        personList.add(p);
    }
    return personList;
}

// filter過濾數據
List<Person> personList1 = getPersonList().stream().filter(person -> person.getAge() > 25)
        .collect(Collectors.toList());
personList1.stream().forEach(person -> {
    System.out.println(person);
});

1.2.2 distinct

去重操作

List<Integer> data = Stream.of(1, 7, 3, 8, 2, 4, 9, 7, 9)
        .distinct()
        .collect(Collectors.toList());

1.2.3 limit

該方法限制流只返回指定個數的元素,類似于sql中的limit

List<Integer> data = Stream.of(1, 7, 3, 8, 2, 4, 9, 7, 9)
        .limit(2)
        .collect(Collectors.toList());

1.2.4 skip

扔掉前指定個數的元素，配合limit使用可以達到翻頁的效果

List<Integer> data = Stream.of(1, 7, 3, 8, 2, 4, 9, 7, 9)
        .skip(3)
        .limit(2)
        .collect(Collectors.toList());

1.2.5 map

流中的每個元素都會應用到這個函數上，返回的結果將形成新類型的流繼續后續操作，類似于scala的map

getPersonList().stream()
        .filter(customer -> customer.getAge() > 20)
        .map(person -> {
            return  person.getName();
        })
        .forEach(System.out::println);

在調用map之前流的類型是Stream<Person>，執行完map之后的類型是Stream<String>

1.2.6 flatMap

flatMap類似于map,只不過是一對多，進來一條返回多條。

getPersonList().stream().flatMap(person -> {
   return Stream.of(person.getName().split(","));
}).forEach(System.out::println);

//注意flatMap的返回類型要是Stream的
flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

1.2.7 sorted

對所有的元素進行排序

List<Integer> numbers = Arrays.asList(1, 7, 3, 8, 2, 4, 9);
numbers.stream().sorted(Integer::compareTo).forEach(System.out::println);

1.3 終端操作

終端操作會執行所有的中間操作生成執行的結果，執行的結果不在是一個流。

1.3.1 anyMatch

如果流中有一個元素滿足條件將返回true

if (getPersonList().stream().anyMatch(person -> "test3".equals(person.getName()))) {
    System.out.println("test3");
}

1.3.2 allMatch

確保流中所有的元素都能滿足

if (allCustomers.stream().allMatch(customer -> customer.getAge() > 20)) {
    System.out.println("所有用戶年齡都大于20");
}

1.3.3 noneMatch

與allMatch操作相反，確保流中所有的元素都不滿足

if (getPersonList().stream().noneMatch(person -> person.getAge()>50)) {
       System.out.println("test3");
}

1.3.4 findAny

返回流中的任意一個元素，比如返回大于20歲的任意一個人

Optional<Person> optional = getPersonList().stream()
        .filter(person -> person.getAge() > 20)
        .findAny();
System.out.println(optional.get());

1.3.5 findFirst

返回流中的第一個元素

Optional<Person> optional = getPersonList().stream()
        .filter(person -> person.getAge() > 20)
        .findFirst();
System.out.println(optional.get());

1.3.6 reduce

接受兩個參數：一個初始值，一個BinaryOperator accumulator將兩個元素合并成一個新的值 比如我們對一個數字list累加

List<Integer> numbers = Arrays.asList(1, 7, 3, 8, 2, 4, 9);
Integer sum = numbers.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum);

找出流中的最大值、最小值 min、max

numbers.stream().reduce(Integer::max)
numbers.stream().reduce(Integer::min)

1.3.7 count

統計流中元素的個數

numbers.stream().count()

1.4 數據收集器collect

在Java8中已經預定義了很多收集器，我們可以直接使用，所有的收集器都定義在了Collectors中，基本上可以把這些方法分為三類：

• 將元素歸約和匯總成一個值

• 分組

• 分區

1.4.1 歸約和匯總

1.找出年齡最小和最大的人

List<Person> personList = getPersonList();
// 找出年齡最大和最小的客戶
Optional<Person> min = personList.stream().collect(Collectors.minBy(Comparator.comparing(Person::getAge)));
System.out.println(min);
Optional<Person> max = personList.stream().collect(Collectors.maxBy(Comparator.comparing(Person::getAge)));
System.out.println(max);

2.求平均年齡

List<Person> personList = getPersonList();
Double min = personList.stream().collect(Collectors.averagingInt(Person::getAge));
System.out.println(min);

3.進行字符串的拼接

List<Person> personList = getPersonList();
// 找出年齡最大和最小的客戶
String collect = personList.stream().map(Person::getName).collect(Collectors.joining(","));
System.out.println(collect);

1.4.2 分組

1.根據用戶的年齡進行分組

List<Person> personList = getPersonList();
Map<Integer, List<Person>> groupByAge = personList.stream().collect(Collectors.groupingBy(Person::getAge));

2.Map的key就是分組的值年齡，List<Person>就是相同年齡的用戶

List<Person> personList = getPersonList();
// 兩層分組 先安裝年齡分組,在按照名稱分組
Map<String, Map<Integer, List<Person>>> groups = personList.stream()
        .collect(Collectors.groupingBy(Person::getName, Collectors.groupingBy(Person::getAge)));

在相對于普通的分組，這里多傳了第二個參數又是一個groupingBy;理論上我們可以通過這個方式擴展到n層分組

3.分組后統計個數

List<Person> personList = getPersonList();
        Map<Integer, Long> groupByCounting = personList.stream()
                .collect(Collectors.groupingBy(Person::getAge, Collectors.counting()));

4.以用戶所在地區分組后找出年齡最大的用戶

List<Person> personList = getPersonList();
Map<String, Optional<Person>> optionalMap = personList.stream()
        .collect(Collectors.groupingBy(Person::getName, Collectors.maxBy(Comparator.comparing(Person::getAge))));

關于java8中Stream如何使用問題的解答就分享到這里了，希望以上內容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關注億速云行業資訊頻道了解更多相關知識。