Java8——Stream流

時間  2020-08-09
標籤 java8 java stream 欄目 Java 简体版
原文   原文鏈接

Stream是數據渠道，用於操做集合、數組等生成的元素序列。java

Stream操做的三個步驟：數組

  • 建立Streamapp

  • 中間操做dom

  • 終止操做

1、獲取stream的四種方式

  1. 經過collection系列集合的stream()或parallelStream()獲取。
@Test
void test11(){
    List<String> list = new ArrayList<>();
    Stream<String> stringStream = list.stream();
}
  1. 經過Arrays中的靜態方法stream()獲取數組流。
@Test
void test11(){
    Person[] person = new Person[10];
    Arrays.stream(person);
}
  1. 經過Stream中的靜態方法of()。
@Test
void test11(){
    Stream<String> stream = Stream.of("a", "b", "c");
}
  1. 建立無限流
/**
 * 迭代
 */
@Test
void test11(){
    Stream<Integer> integerStream = Stream.iterate(0, x -> x + 2);
}
/**
 * 生成
 */
@Test
void test11(){
    Stream.generate(() -> Math.random());
}

2、中間操做

中間操做不會執行任何操做，只有終止操做纔會一次性輸出所有值，即「惰性求值」。ide

2.1 篩選與切片

  • filter——接收lamdba，從流中排除某些元素
@Test
void test12(){
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    // 中間操做
    Stream<Person> personStream = personList.stream()
        .filter(e -> e.getAge() > 18);
    // 終止操做
    personStream.forEach(System.out::println);
}
  • limit——截斷流，使其元素不超過給定數量
@Test
void test12(){

    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    personList.stream()
        .limit(1)
        .forEach(System.out::println);
}
  • skip(n)——跳過元素，返回一個扔掉前n個元素的流，若不足n個，則返回一個空流。與limit(n)互補。
@Test
void test12(){

    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    personList.stream()
        .skip(1)
        .forEach(System.out::println);
}
  • distinct——篩選，經過生成元素的hashCode()和equals()，去除重複元素。
@Test
void test12(){

    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20),
        new Person("Java旅途",20)
    );
    personList.stream()
        .distinct()
        .forEach(System.out::println);
}

注意：使用distinct的時候須要重寫實體的hashCode()和equals()方法。函數

2.2 映射

  • map——接收lamdba，將元素轉換成其餘形式或提取信息。接收一個函數做爲參數，該函數會被應用到每一個元素上，並將其映射成一個新的元素。
/**
 * 獲取personList的全部name
 */
@Test
void test13(){
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20),
        new Person("Java旅途",20)
    );
    personList.stream()
        .map(Person::getName)
        .forEach(System.out::println);
}
  • flatMap——接收一個函數做爲參數，將流中的每一個值都換成另外一個流，而後把全部流生成一個流。
// 將字符串轉換爲字符，並將字符放進list返回
static Stream<Character> filterCharcter(String string){

    List<Character> list = new ArrayList<>();
    for (Character ch : string.toCharArray()){
        list.add(ch);
    }
    return list.stream();
}
@Test
void test13(){
    List<String> list = Arrays.asList("aaa","bbb","ccc");

    list.stream()
        .flatMap(LamdbaApplicationTests::filterCharcter)
        .forEach(System.out::println);
}

2.3 排序

  • sorted()——天然排序（comparable）
  • sorted(comparator com)——定製排序（comparator ）
/**
* 定製排序，e1和e2按age排序，age同樣按name排
*/
@Test
void test14(){
    List<Person> personList = Arrays.asList(
            new Person("Java旅途",18),
            new Person("Java旅途",20)
    );
    personList.stream()
        .sorted((e1,e2) -> {
            if(e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else{
                return e1.getAge()+"".compareTo(e2.getAge()+"");
            }
        }).forEach(System.out::println);
}

3、終止操做

3.1 查找與匹配

完善一下Person類this

@Data
public class Person implements Serializable {
    private static final long serialVersionUID = -7008474395345458049L;

    private String name;
    private int age;
    private Status status;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person(String name, int age, Status status) {
        this.name = name;
        this.age = age;
        this.status = status;
    }
    public enum Status {
        FRER,
        BUSY;
    }
}
  • allMatch——檢查是否匹配全部元素
/**
* 是否全部元素都是Fire狀態，是返回true
*/
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .allMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
  • anyMatch——檢查是否至少匹配一個元素
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .anyMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
  • noneMatch——檢查是否全部元素都不匹配
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .noneMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
  • findFirst——返回第一個元素
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    Optional b = personList1.stream()
        .findFirst();
    System.out.println(b.get());
}
  • findAny——返回當前流中的任意元素
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    Optional b = personList1.stream()
        .findAny();
    System.out.println(b.get());
}
  • count——返回流中元素的總數
  • max——返回流中最大值
  • min——返回流中最小值

3.2 規約

  • reduce(T identity, BinaryOperator)/reduce(BinaryOperator)——能夠將流中元素反覆結合起來，獲得一個值。
/**
  * reduce 第一個參數是起始值
  */
@Test
void test16(){
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    Integer sum = list.stream()
                      .reduce(0,(x,y) -> x+y);
    System.out.println(sum);

    Optional<Integer> reduce = list.stream()
                                   .reduce((x, y) -> x + y);
    System.out.println(reduce.get());
}

3.3 收集

  • collect——將流轉化爲其餘形式。接收一個Collector接口的實現。用於給Stream中元素作彙總的方法。
/**
* 取出名字放在一個list中
*/
@Test
void test16(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    List<String> collect = personList1.stream()
        .map(Person::getName)
        .collect(Collectors.toList());
    collect.forEach(System.out::println);
}

Optional經常使用方法

Optional類是一個容器類，表明一個值存在或不存在，原來用null表示一個值不存在，如今Optional能夠更好的表達這個概念。而且能夠避免空指針異常。指針

  1. Optional.of(T t) ——建立一個Optional實例code

  2. Optional.empty()——建立一個空的optional實例
  3. Optional.ofNullable(T t)——若t不爲null，建立optional實例，不然建立空實例
  4. isPresent()——判斷是否包含值
  5. orElse(T t)——若是調用對象包含值，返回該值，不然返回 t
  6. orElseGet(Supplier s)——若是調用對象包含值，返回該值，不然返回 s 獲取的值
  7. map(Function f)——若是有值對其處理，並返回處理後的Optional，不然返回Optional.empty()
  8. flatMap(Function mapper)——與map相似，要求返回值必須是Optional
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程