스트림 流 API

Java8에서 가장 중요한 변화의 두 가지가 있습니다. 첫 번째는 람다 식이고 다른 하나는 스트림 API입니다.

스트림 API (java.util.stream) 자바에 소개 된 실제 함수형 프로그래밍 스타일. 스트림 API 자바 프로그래머가 매우 효율적으로, 깨끗하고, 간단한 코드를 작성하는 프로그래머의 생산성을 향상시킬 수 있기 때문에, 자바 클래스 라이브러리에 대한 지금까지 최고의 보완하는 것입니다.

스트림 처리 Java8 수집 추상화의 핵심입니다, 당신은 당신이 일련의 작업은 매우 복잡한 검색을 수행 필터링 및 매핑 데이터 및 기타 작업을 할 수있을 것인지 지정할 수 있습니다. 사용 스트림 API는 SQL 데이터베이스 쿼리 실행을 사용하여 유사한 데이터 수집을 조작합니다. 스트림 API 병렬로 작업을 수행 할 수 있습니다. 간단하게는, 스트림 API는 데이터를 처리하는 효율적이고 사용하기 쉬운 방법을 제공합니다.

스트림은 데이터 채널을 생성하는 데이터 소스 (집합 배열 등)의 동작을위한 구성 요소의 시퀀스이다. "데이터를 저장하는 책임을 데이터 수집에 대해 얘기 스트림 흐름 계산 말하고 약, 데이터 처리를 담당!"

참고 :

그는 요소를 저장하지 않습니다 ①Stream.

②Stream 소스 오브젝트를 변경하지 않습니다. 때마다 새로운 처리를 반환 스트림 결과를 보유하고 있습니다.

③Stream 작업 실행을 지연된다. 이 결과가 수행해야 할 때까지 기다릴 필요가 의미합니다.

④ 각 스트림 객체는 한 번만 사용할 수 있습니다

스트림 작업을 세 단계 :

1- 스트림 생성 : 데이터 소스에 의해 (예 :로 수집, 배열) 스트림을 취득

2- 중간 조작 중간체 운전 조작 체인이고, n 배의 데이터를 데이터 소스 프로세스 있지만 동작의 종료 전에 실제로 실행하지 않는다.

3- 종료 동작 : 종료 작업이 수행되면, 동작은 최종 결과를 생성하기 위해, 중간 사슬을 실행하고 스트림을 종료한다.

 

스트림 만들기

스트림 방법을 만들기 : 1. 컬렉션을

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

• 공공 기본 스트림 <E> 스트림 () : 순차적 스트림을 반환

• 공공 기본 스트림 <E> parallelStream은 () : 병렬 스트림을 반환

스트림 방식으로 만들기 2 : 배열을

정적 메소드 어레이 Java8 ()는 스트림의 배열 일 수있다 가져 트림 :

• 공용 static <T> 스트림 <T> 스트림 (T [] 배열) 반환 스트림

기본적인 유형에 대응하는 배열을 처리 할 수있는 과부하 :

• 공용 static IntStream 스트림 (INT [] 배열) : 리턴 정수 데이터 스트림

• 공용 정적 LongStream 스트림 (긴 [] 배열) : 긴 데이터 스트림을 리턴

• 공용 정적 DoubleStream 스트림 (더블 [] 배열)을 리턴 부동 소수점 데이터 스트림

스트림 세 가지 방법을 만들기 3. 스트림의의를 통해 ()

스트림 클래스의 정적 메소드를 호출 할 수있다 (), 스트림의 값을 표시하여 만들었다. 이 매개 변수의 수를받을 수 있습니다.

• 공공 정적 <T> 스트림 <T> (T ... 값)의 : 반환 순차적 스트림

Stream에 네 가지 방법을 만들기 4 : 무제한 스트림을 생성

당신은 정적 방법 Stream.iterate ()와 Stream.generate ()를 사용 무한 스트림을 만들 수 있습니다.

• 공용 static <T> 스트림 <T> 반복 처리 (최종 T 씨 최종 UnaryOperator <T> F) : 반환 무한 스트림

• 공공 정적 <T> 스트림 <T> 생성 (공급 <T>의) : 반환 무한 스트림

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.junit.Test;

public class Test07StreamCreate {
	@Test
	public void test06(){
		/*
		 * Stream<T> iterate(T seed, UnaryOperator<T> f)  
		 * UnaryOperator接口，SAM接口，抽象方法：
		 * 
		 * UnaryOperator<T> extends Function<T,T>
		 * 		T apply(T t)
		 */
		Stream<Integer> stream = Stream.iterate(1, num -> num+=2);
//		stream = stream.limit(10);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test05(){
		Stream<Double> stream = Stream.generate(Math::random);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test04(){
		Stream<Integer> stream = Stream.of(1,2,3,4,5);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test03(){
		String[] arr = {"hello","world"};
		Stream<String> stream = Arrays.stream(arr);
	}
	
	@Test
	public void test02(){
		int[] arr = {1,2,3,4,5};
		IntStream stream = Arrays.stream(arr);
	}
	
	@Test
	public void test01(){
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		
		//JDK1.8中，Collection系列集合增加了方法
		Stream<Integer> stream = list.stream();
	}
}

 

중급 운영

중간 동작의 복수의 파이프 라인을 형성하기 위해 결합 될 수있다, 달리 조작이 모든 과정을 수행하지 않고 종료 트리거하지 않으면 파이프 라인 동작! 한 번에 및 전화 종료 처리 작업, "게으른 평가."

방법	그리 술
필터 (술어 P)	람다 수신 한 스트림에서 특정 요소를 제외
뚜렷한()	스크리닝의 요소에 의해 생성 된 흐름을 동일 () 소자 중복
제한 (긴이 maxSize)	흐름 요소를 주어진 수보다 그래서 더 이상, 차단하지
(길이, N) 이동	소자를 스킵하는 역류는 제 N 요소 던져. 유동 요소 n 개의 빈 스트림 미만인 경우. 상보 및 한도 (N)
PEEK (소비자 행동)	람다를 수신 한 각 데이터는 대류 작동 부재 람다 수행
정렬 ()	새로운 스트림을 생성하고, 상기 자연 순서 정렬
분류 (비교기 COM)	비교기는 순서를 정렬하며, 새로운 흐름을 생성
맵핑 (함수 f)	매개 변수로서 수신 기능이 함수는 각각의 소자에인가하고, 새로운 요소로 매핑한다.
mapToDouble (ToDoubleFunction의 F)	매개 변수로서 수신 기능이 함수는 새 DoubleStream을 생성하기 위해서 각각의 소자에인가된다.
mapToInt (ToIntFunction의 F)	매개 변수로서 수신 기능이 함수는 새 IntStream을 생성하기 위해서 각각의 소자에인가된다.
mapToLong (ToLongFunction의 F)	매개 변수로서 수신 기능이 함수는 새 LongStream을 생성하기 위해서 각각의 소자에인가된다.
flatMap (함수 f)	매개 변수로하는 함수를 수신 한 각 스트림의 값이 다른 스트림으로 대체되는, 모든 스트림에 접속 한 플로우

 

mport java.util.Arrays;
import java.util.stream.Stream;

import org.junit.Test;

public class Test08StreamMiddle {
	
	@Test
	public void test12(){
		String[] arr = {"hello","world","java"};
		Arrays.stream(arr)
			.flatMap(t -> Stream.of(t.split("|")))//Function<T,R>接口抽象方法 R apply(T t)  现在的R是一个Stream
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test11(){
		String[] arr = {"hello","world","java"};
		
		Arrays.stream(arr)
			.map(t->t.toUpperCase())
			.forEach(System.out::println);
	}
	
	@Test
	public void test10(){
		Stream.of(1,2,3,4,5)
			.map(t -> t+=1)//Function<T,R>接口抽象方法 R apply(T t)
			.forEach(System.out::println);
	}
	
	@Test
	public void test09(){
		//希望能够找出前三个最大值，前三名最大的，不重复
		Stream.of(11,2,39,4,54,6,2,22,3,3,4,54,54)
			.distinct()
			.sorted((t1,t2) -> -Integer.compare(t1, t2))//Comparator接口  int compare(T t1, T t2)
			.limit(3)
			.forEach(System.out::println);
	}
	
	@Test
	public void test08(){
		long count = Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.distinct()
			.peek(System.out::println)  //Consumer接口的抽象方法  void accept(T t)
			.count();
		System.out.println("count="+count);
	}
	
	
	@Test
	public void test07(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.skip(5)
			.distinct()
			.filter(t -> t%3==0)
			.forEach(System.out::println);
	}

	@Test
	public void test06(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.skip(5)
			.forEach(System.out::println);
	}
	
	@Test
	public void test05(){
		Stream.of(1,2,2,3,3,4,4,5,2,3,4,5,6,7)
			.distinct()  //(1,2,3,4,5,6,7)
			.filter(t -> t%2!=0) //(1,3,5,7)
			.limit(3)
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test04(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.limit(3)
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test03(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.distinct()
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test02(){
		Stream.of(1,2,3,4,5,6)
			.filter(t -> t%2==0)
			.forEach(System.out::println);
	}
	
	@Test
	public void test01(){
		//1、创建Stream
		Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
		
		//2、加工处理
		//过滤：filter(Predicate p)
		//把里面的偶数拿出来
		/*
		 * filter(Predicate p)
		 * Predicate是函数式接口，抽象方法：boolean test(T t)
		 */
		stream = stream.filter(t -> t%2==0);
		
		//3、终结操作：例如：遍历
		stream.forEach(System.out::println);
	}
}

작업의 끝

단말기는 파이프 플로우로부터의 결과를 생성한다. 목록, 정수, 또는 무효 : 결과는 값 예를 들어, 스트림하지 않습니다 수 있습니다. 작업 흐름의 종료 후, 다시 사용할 수 없습니다.

방법	기술
부울 allMatch (술어 P)	모든 요소가 일치하는지 확인
부울 anyMatch ( 술어 P )	성냥을 적어도 하나 개의 요소를 확인
부울 noneMatch (술어 P)	모든 요소에 대한 일치가없는 경우 확인
옵션 <T> 로 findFirst ()	첫 번째 요소를 반환
옵션 <T> findAny ()	전류의 흐름에 모든 요소를 ​​돌려줍니다
긴 수 ()	스트림의 전체 요소 수를 반환
선택적 <T> 맥스 (비교기 c)	최대 흐름을 돌려줍니다
선택적 <T> 분 (비교기 c)	최소 흐름을 돌려줍니다
무효 대해 forEach (소비자 C)	되풀이
T가 감소 (T의 아이덴, BinaryOperator의 b)	스트림은 요소를 결합하는 값을 얻기 위해 반복 될 수있다. 반환 T
U가 감소 (BinaryOperator 나)	스트림은 요소를 결합하는 값을 얻기 위해 반복 될 수있다. 돌아 가기 옵션 <T>
R 부담 (콜렉터 c)	스트림은 다른 형태로 변환됩니다. 인터페이스를 수신 수집기에 대한 요소 스트림 요약을 만들 수있는 프로세스를 구현하기

콜렉터는 인터페이스 방법은 대류 (예 : 목록, 설정,지도를 수집로) 수집 방법 수행 할 작업을 결정 구현합니다. 또한, 수집기, 유틸리티 클래스는 쉽게 공통 콜렉터 인스턴스를 만들 수 있습니다, 많은 정적 인 방법을 제공합니다.

public class Test09StreamEnding {
	
	@Test
	public void test14(){
		List<Integer> list = Stream.of(1,2,4,5,7,8)
				.filter(t -> t%2==0)
				.collect(Collectors.toList());
		
		System.out.println(list);
	}
	
	
	@Test
	public void test13(){
		Optional<Integer> max = Stream.of(1,2,4,5,7,8)
			 .reduce((t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口   T apply(T t1, T t2)
		System.out.println(max);
	}
	
	@Test
	public void test12(){
		Integer reduce = Stream.of(1,2,4,5,7,8)
			 .reduce(0, (t1,t2) -> t1+t2);//BinaryOperator接口   T apply(T t1, T t2)
		System.out.println(reduce);
	}
	
	@Test
	public void test11(){
		Optional<Integer> max = Stream.of(1,2,4,5,7,8)
				.max((t1,t2) -> Integer.compare(t1, t2));
		System.out.println(max);
	}
	
	@Test
	public void test10(){
		Optional<Integer> opt = Stream.of(1,2,4,5,7,8)
				.filter(t -> t%3==0)
				.findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test09(){
		Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9)
				.filter(t -> t%3==0)
				.findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test08(){
		Optional<Integer> opt = Stream.of(1,3,5,7,9).findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test04(){
		boolean result = Stream.of(1,3,5,7,9)
			.anyMatch(t -> t%2==0);
		System.out.println(result);
	}
	
	
	@Test
	public void test03(){
		boolean result = Stream.of(1,3,5,7,9)
			.allMatch(t -> t%2!=0);
		System.out.println(result);
	}
	
	@Test
	public void test02(){
		long count = Stream.of(1,2,3,4,5)
				.count();
		System.out.println("count = " + count);
	}
	
	@Test
	public void test01(){
		Stream.of(1,2,3,4,5)
				.forEach(System.out::println);
	}
}