Java8 새로운 기능 - 스트림 API

스트림 처리 당신이 당신이 일련의 작업은 매우 복잡한 검색, 필터링 및 매핑 데이터와 다른 작업을 수행 할 수있을하도록 지정할 수 있습니다, 주요 추상화 Java8의 모음입니다. 수집 작업을 통해 스트림 API를 사용하여, 그것은 수행 SQL 데이터베이스 작업을 사용하는 것과 비슷합니다. 스트림 API 병렬로 작업을 수행 할 수 있습니다. 간단히, 스트림 API 처리 데이터의 효율적이고 사용하기 쉬운 방법을 제공합니다.

스트림 무엇입니까

데이터 채널 생성 된 시퀀스 요소의 동작 (등 세트 어레이)에 대한 데이터의 출처는
데이터 스트림 세트에 대해 얘기하는 응력을 계산하는

추신:

• 자신이 저장되지 않습니다 스트림 요소
• 스트림, 소스 객체를 변경하지 않는 반면에, 그들은 새로운 스트림을 들고의 결과를 반환합니다
• 스트림 작업은 그들이 단지의 구현의 결과 때까지 기다려야합니다 의미, 지연 수행한다

다음 그래프는보다 직관적 인 프로세스를 반영 할 수있다 :

• 만들 스트림
  스트림을 획득하는 데이터 소스 (배열, 모음 등),
• 중간체 조작
  체인 중간 동작, 데이터 소스의 데이터 처리
• 동작 (동작 단말) 종료
  종료 연산, 중간 연산 체인을 수행하고, 결과를

스트림 만들기

컬렉션 시리즈 컬렉션 () 또는 parallelStream 의해 제공 스트림 ()

Java8 컬렉션 인터페이스는 두 개의 스트림을 획득하는 방법을 제공하도록 확장된다 :

• 기본 스트림 스트림 () : 순차적 스트림을 반환
• 기본 스트림 parallelStream는 () : 병렬 스트림을 리턴

샘플 코드 :

List<Integer> list = new ArrayList<>();
Stream<Integer> stream1 = list.stream();
Stream<Integer> stream2 = list.parallelStream();

스트림의 배열에 의해 만들어진

스트림 Java8 배열 정적 메소드 ()는 상기 데이터 스트림을 얻을

• 공전 흐름 스트림 (T [] 배열) : 스트림을 돌려줍니다

샘플 코드 :

Integer[] integers = new Integer[10];
Stream<Integer> stream = Arrays.stream(integers);

가치 흐름에 의해 만들어진

의 (), 디스플레이를 통해 흐름 값을 만들고, 상기 스트림 클래스 정적 법에 의해 수신 된 임의 수의 매개 변수가 될 수있다

• 공공 정적 흐름 의 (T ... 값) : 스트림을 돌려줍니다

샘플 코드 :

Stream<Integer> stream = Stream.of(1, 2, 3);

무제한 스트림을 생성

무제한 스트림을 생성, 정적 방법 Stream.iterate ()와 Stream.generate ()를 사용

• 반복 : 공공 정적 흐름 반복 처리 (최종 T 씨, 마지막 UnaryOperator 에프)
• 세대 : 공공 정적 흐름 생성 (공급 에스)

샘플 코드 :

// 迭代
Stream stream1 = Stream.iterate(0, (x) ->  x + 2);
// 生成
Stream stream2 = Stream.generate(() -> Math.random());

중급 운영

복수의 중간 연산이 형태에 결합 될 수 파이프 라인 , 종료 트리거 않는 파이프 라인 동작 또는 중간 동작하는 프로세스를 수행하지 않는다 ! 에서 한 번에 정지 작업 과정, "지연 평가"라고합니다 .

선별 및 분리 된

• 필터 : 유동 요소로부터 제외 람다 결합 됨,
• 값 : 요소가 주어진 횟수를 초과하지 않도록, 스트림 잘린다
• (N) 이동 : 엘리먼트가 생략, 복귀 유동이 제 n 개의 요소를 제거 n은 유동 소자, 빈 스트림보다 작은 경우, 상기 한계에 상보 (N)
• 별개 : 선별, 원소 ()와 같음 의해 생성 된 해시 코드 스트림 () 소자 중복

샘플 코드 :

public class TestStreamApi {
    private static List<Demo> demoList = Arrays.asList(
            new Demo(1, "哈哈哈"),
            new Demo(2, "嘿嘿嘿嘿"),
            new Demo(3, "呵呵呵"),
            new Demo(4, "恩恩恩恩"),
            new Demo(5, "哼哼哼"),
            new Demo(6, "啧啧啧"),
            new Demo(5, "哼哼哼"),
            new Demo(8, "哼")
    );

    public static void main(String[] args) {
        // 中间操作不会执行任何操作
        Stream<Demo> demoStream = demoList.stream()
                .filter((x) -> x.getRemark().length() == 3)
                .limit(4)
                .skip(1)
                .distinct();

        // 终止操作一次性执行全部内容
        // 内部迭代：迭代操作由Stream API完成
        demoStream.forEach(System.out::println);
    }
}

실행 결과 :
3, 오, 오,
5 험 험
6 혀를 차다

주 : DISTINCT 해시 코드를 생성 된 기본 스트림 ()와 같음을 스크리닝 () 중복 요소는, 상기 데모 해시 코드 ()와 같음 () 메소드를 재기록 할 필요가있다.

지도 제작

• 지도 : 람다 수신 정보 또는 다른 형태를 추출하는 변환 소자, 파라미터 등의 수신 기능이 함수는 각각의 소자에인가하고, 새로운 요소로 매핑 될
• flatMap는 : 파라미터로하는 함수를 받고, 각 스트림의 값이 다른 스트림으로 대체되는, 모든 하나 개의 스트림에 연결 스트림

샘플 코드 :

public class TestStreamApi {
    private static List<Demo> demoList = Arrays.asList(
            new Demo(1, "哈哈哈"),
            new Demo(2, "嘿嘿嘿嘿")
    );

    public static void main(String[] args) {
        demoList.stream()
                .map(Demo::getRemark)
                .flatMap(TestStreamApi :: filterCharacter)
                .forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter(String str) {
        List<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
}

그 결과,
하
, 하,
하
헤이
헤이
헤이
헤이

순서

• () 분류 : 자연 순서
• 분류 (비교기 C) : 사용자 정의 정렬

샘플 코드 :

public class TestStreamApi {
    private static List<Demo> demoList = Arrays.asList(
            new Demo(5, "哈哈哈"),
            new Demo(2, "嘿嘿嘿嘿"),
            new Demo(3, "呵呵呵"),
            new Demo(2, "哼哼哼"),
            new Demo(5, "啧啧啧")
    );

    public static void main(String[] args) {
        List<String> list = Arrays.asList("aaa", "bbb", "ccc");
        list.stream()
                .sorted()
                .forEach(System.out::println);
        System.out.println("----------");
        demoList.stream()
                .sorted((x, y) -> {
                    if (x.getNum().equals(y.getNum())) {
                        return x.getRemark().compareTo(y.getRemark());
                    } else {
                        return x.getNum().compareTo(y.getNum());
                    }
                })
                .forEach(System.out::println);
    }
}

실행 결과 :
AAA
BBB의
CCC
----------
2 험 험
2 헤이 헤이
, 오, 오 3
5 헥타르
5 혀의 혀

작업 종료

일치 찾기

• allMatch : 모든 요소가 일치하는지 확인
• anyMatch : 모든 요소가 일치하는지 확인
• noneMatch : 모든 요소에 대한 일치가없는 경우 확인
• 로 findFirst : 첫 번째 요소를 반환
• findAny는 : 어떤 요소에 전류 흐름을 반환
• 수 : 흐름의 요소의 수를 돌려줍니다
• 최대 : 역류의 최대치
• 분 : 최소 흐름을 반환

샘플 코드 :

public class TestStreamApi2 {
        private static List<Demo> demoList = Arrays.asList(
            new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
            new Demo("李四", 38, 3333.33, Demo.Status.FREE),
            new Demo("王五", 28, 5555.55, Demo.Status.FREE),
            new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
            new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)

    );

    public static void main(String[] args) {
        // 是不是所有的对象都处于BUSY状态
        System.out.println(demoList.stream()
                .allMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
        // 是否有对象处于BUSY状态
        System.out.println(demoList.stream()
                .anyMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
        // 是否没有对象处于BUSY状态
        System.out.println(demoList.stream()
                .noneMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
        // 获取工资最高的
        Optional<Demo> optionalDemo1 = demoList.stream()
                .sorted((x, y) -> -Double.compare(x.getSalary(), y.getSalary()))
                .findFirst();
        System.out.println(optionalDemo1.get());
        // 获取随机一个空闲的
        Optional<Demo> optionalDemo2 = demoList.stream()
                .filter((e) -> e.getStatus().equals(Demo.Status.FREE))
                .findAny();
        System.out.println(optionalDemo2.get());
        // 总数
        System.out.println(demoList.stream().count());
        // 工资最高的
        Optional<Demo> optionalDemo3 = demoList.stream()
                .max((x, y) -> Double.compare(x.getSalary(), y.getSalary()));
        System.out.println(optionalDemo3.get());
        // 最小的工资
        Optional<Double> optionalDemo4 = demoList.stream()
                .map(Demo::getSalary)
                .max(Double::compare);
        System.out.println(optionalDemo4.get());
    }
}

class Demo{
    // 姓名
    String name;
    // 年龄
    Integer age;
    // 工资
    Double salary;
    // 状态
    Status status;

    public Demo() {}

    public Demo(String name, Integer age, Double salary, Status status) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Demo demo = (Demo) o;
        return name.equals(demo.name) &&
                age.equals(demo.age) &&
                salary.equals(demo.salary) &&
                status == demo.status;
    }

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

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

    public enum Status{
        FREE,
        BUSY,
        VOCATION
    }
}

실행 결과 :
false로
true로
false로
데모 {이름 = '킹 두창', 나이 = 58, 급여 = 8888.88, 상태 = 직업}
데모 {이름 = '홍길동', 나이는 38, 급여 = 3333.33, 상태 = 자유로운이다 =}
. (5)
데모 {이름 = '킹 두창', 나이 = 58, 급여 = 8888.88, 직업} 상태 =
8888.88

축소

• (BinaryOperator를) / (BinaryOperator을 식별 T) 감소 감소 : 스트림이 반복 될 수 요소 값을 제공하는 결합

샘플 코드 :

public class TestStreamApi3 {
    private static List<Demo> demoList = Arrays.asList(
            new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
            new Demo("李四", 38, 3333.33, Demo.Status.FREE),
            new Demo("王五", 28, 5555.55, Demo.Status.FREE),
            new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
            new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)
    );

    public static void main(String[] args) {
        Optional<Double> optional = demoList.stream()
                .map(Demo::getSalary)
                .reduce(Double::sum);
        System.out.println(optional.get());
    }
}

결과 :
32222.190000000002

수집

• 수집 : 스트림이 다른 형태로 변환됩니다. 인터페이스를 수신 컬렉션에 대한 요소 스트림 요약을 만들 수있는 프로세스를 구현하기

구현 방법 수집가 인터페이스는 대류 컬렉션 (예 : 수집 목록으로, 설정,지도) 할 방법을 결정합니다.

• toList : 목록을 수집하는 흐름 요소
• toSet : 유동 요소 수집 집합
• toCollection가 : 컬렉션을 만들 수있는 컬렉션의 요소의 흐름
• 계산 : 스트림의 요소 수를 계산
• 정수 대류 요소 속성 합산 : summingInt를
• averagingInt : 평균치 산출 스트림 속성 소자 정수
• summarizingInt : 정수 속성 통계 수집 스트림
• jioning : 각 문자열의 연결 흐름
• maxBy : 최대 값이 선택되어 비교기
• minBy : 최소값 선택되어 비교기
• 환원 : 초기 값으로 한 어큐뮬레이터에서 시작하고 BinaryOperator를 사용하여 기본 스트림은 각각 하나의 값 법령 바인딩
• collectingAndThen는 : 전달 함수의 결과를 또 다른 누산기 랩
• groupingBy : 속성 대류 패킷 특성 값이 K이고, 결과는 V이며
• partitioningBy은 : 파티션 참, 거짓을 기반으로

샘플 코드 :

public class TestStreamApi4 {
    private static List<Demo> demoList = Arrays.asList(
            new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
            new Demo("李四", 38, 3333.33, Demo.Status.FREE),
            new Demo("王五", 28, 5555.55, Demo.Status.FREE),
            new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
            new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)
    );

    public static void main(String[] args) {
        HashSet<String> set = demoList.stream()
                .map(Demo::getName)
                .collect(Collectors.toCollection(HashSet::new));
        set.forEach(System.out::println);
        // 总数
        System.out.println(demoList.stream()
                .collect(Collectors.counting()));

        // 工资平均值
        System.out.println(demoList.stream()
                .collect(Collectors.averagingDouble(Demo::getSalary)));
    }
}

결과 :
홍길동
홍길동
왕, 두창
왕 우
자오 여섯
5
6444.438