JAVA ( 스트림 )

 

• 스트림 ??

 

--다양한 데이터 소스를 표준화된 방법으로 다루기 위한 것.

 

***스트림만들기  ->  중간연산 (여러번 가능)  -> 최종연산 (1번)

 

중간연산 : 연산결과가 스트림인 연산. 반복적 사용가능.

최종연산 : 연산결과가 스트림이 아닌 연산. 단 한번만 적용가능. (스트림요소 소모)

 

ex )))

stream. distinct(). limit(5) . sorted() . forEach (System.out :: println)

                중      간        연      산              최종연산

 

--스트림은 데이터 소스로부터 데이터를 읽기만 할뿐, 변경하지않는다. 

--스트림은 Iterator 처럼 일회용이다. 

--최종연산 전까지 중간연산이 수행되지 않는다. --지연된 연산.

 

--스트림은 작업을 내부 반복으로 처리한다. 

--스트림의 작업을 병렬로 처리 --병렬스트림  (parallel() ) 을 지원.    : 멀티쓰레드   

 

     

• 스트림 만들기

--Collection 인터페이스의 stream() 으로 컬렉션을 스트림으로 변환.

     ( List, Set )

public class Example6 {
	public static void main(String[] args) {
		
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		Stream<Integer> intStream = list.stream();   //  list를 Stream으로 변환
		intStream.forEach(System.out :: print);      //  forEach() 최종연산
		
		// Stream 은 1회용. 최종연산을 수행하면 Stream이 닫힌다.
		intStream = list.stream();                //list로부터 Stream 생성해야
		intStream.forEach(System.out :: print);   //다시 최종연산을 할수있다. 
	}
}

 

 

 

• 스트림 만들기 ( 배열 )

기본형스트림 = int [] intArr = {1,2,3,4,5}

                          IntStream intStream = Arrays.stream (intArr)

객체 스트림   =  Integer[] intArr = {1,2,3,4,5}

                         Stream<Integer> intStream = Arrays.stream (intArr)

public class Example6 {
	public static void main(String[] args) {
		
		//Stream<String> strStream = Stream.of(new String[] {"a","b","c"});
		String[] strArr = {"a","b","c"};
		Stream<String> strStream = Arrays.stream(strArr);	 //위에랑 같은문장
		strStream.forEach(System.out :: println);
		
		int[] intArr = {1,2,3,4,5};
		IntStream intStream = Arrays.stream(intArr);
		intStream.forEach(System.out :: print);
//		System.out.println("sum="+intStream.sum());       // 기본형배열 스트림은
//		System.out.println("avg="+intStream.average());   // sum, average 등등
		                                                  // 가능하다. 
//		Integer[] intArr = {1,2,3,4,5};
//		Stream<Integer> intStream = Arrays.stream(intArr);  //객체스트림은
//		intStream.forEach(System.out :: print);           // sum, average 등
//		System.out.println("count=" +intStream.count());  //  지원하지않는다.	                                               
	}
}

 

 

• 스트림 만들기 ( 임의의 수 (난수 ) )

public class Example6 {
	public static void main(String[] args) {
		
//		IntStream intStream = new Random().ints();   //무한스트림.
//		IntStream intStream = new Random().ints(5);   // 5개만 뽑아라.
		IntStream intStream = new Random().ints(10,5,10); // 10개뽑아라. 5부터 9까지
		intStream
//		.limit(10)    //  10개만 자르기
		.forEach(System.out :: println);
		
		
		//  iterator(T seed, UnaryOperator f)   단항 연산자
		Stream<Integer> intStream2 = Stream.iterate(1, n -> n + 2); // 홀수 스트림
		intStream2.limit(10).forEach(System.out :: println);     // 홀수 10개만출력
		
		
		//  generate(Supplier s) : 주기만하는것, 입력X , 출력 O
		Stream<Integer> intStream3  = Stream.generate(()->1);   // 1 계속호출
		intStream3.limit(10).forEach(System.out :: println);    // 1 10개만 출력
			
	}
}

 

 

• 스트림의 중간연산

--distinct()    중복을 제거

--filter(조건식)   조건에 안맞는 요소 제외

--limit()        스트림이 일부를 잘라낸다

--skip()        스트림의 일부를 건너뛴다

--peek()       스트림의 요소에 작업수행

--sorted()     스트림 요소 정렬

 

• 스트림의 최종연산

--forEach , forEachOrdered     각 요소 지정된 작업 수행

--count()       요소 개수 반환

--max, mix     최대값/최소값 반환

--findAny()     병렬 ,  filter랑 같이 쓰이며, 아무거나 하나 반환

--findFirst()    직렬,   filter랑 같이 쓰이며,첫번째요소 반환

--allMatch(조건식)       조건식에 모두 만족하는지 . true/false

--anyMatch(조건식)     조건식에 하나라도 만족하는지 

--noneMatch(조건식)   조건식에 모두 만족하지 않은지 

--reduce      스트림의 요소를 하나씩 줄여가면서(리듀싱)  계산한다.

--collect       스트림의 요소를 수집.

 

 

 

 

    EX )))) 스트림 중간연산 예제.  ( 정렬 )

 

import java.util.Comparator;
import java.util.stream.Stream;

class Student implements Comparable<Student>{
	String name;
	int ban;
	int totalScore;
	
	Student(String name, int ban,int totalScore){
		this.name = name;
		this.ban = ban;
		this.totalScore = totalScore;
	}
	@Override
	public String toString() {
		return name+", "+ban+", "+totalScore;
	}
	public String getName() {
		return name;
	}
	public int getBan() {
		return ban;
	}
	public int getTotalScore() {
		return totalScore;
	}
	@Override                                
	public int compareTo(Student s) {         //총점 내림차순을 기본정렬로.
		return s.totalScore - this.totalScore ;
	}
}
public class Example6 {
	public static void main(String[] args) {
			
		Stream<Student> studentStream = Stream.of(
				new Student("김철수", 3 , 300),
				new Student("이철수", 1 , 200),
				new Student("박철수", 2 , 100),
				new Student("최철수", 2 , 150),
				new Student("노철수", 1 , 200),
				new Student("조철수", 3 , 290),
				new Student("전철수", 3 , 180)
				);
		studentStream.sorted(Comparator.comparing(Student::getBan) // 1.반별로 정렬
				.thenComparing(Comparator.naturalOrder()))    //   2.기본정렬
				.forEach(System.out::println);		
	}
}

 

 

 

    EX )))) 스트림 중간연산 예제.  ( map ) : Stream 타입변환

 

import java.io.File;
import java.util.stream.Stream;

public class Example6 {
	public static void main(String[] args) {
	
		File[] fileArr= { new File("Ex1.java"),
				new File("Ex1.bak"),
				new File("Ex2.java"),
				new File("Ex1"),
				new File("Ex1.txt")
		};
		Stream<File> fileStream = Stream.of(fileArr);
		
		Stream<String> filenameStream = fileStream.map(File::getName);
		// map() 으로 Stream<File> 을 Stream<String> 으로 변환.
		filenameStream.forEach(System.out::println);   // 파일이름 출력
		
		fileStream = Stream.of(fileArr);     //스트림 다시 생성
		
		fileStream.map(File::getName)     // <File> --> <String>
			.filter( s -> s.indexOf('.') != -1 )    // 확장자가 없는것은 제외
			.map( s -> s.substring(s.indexOf('.') +1 ))  //확장자만 추출
			.map( String :: toUpperCase )            // 모두 대문자변환
			.distinct()                           //중복제거
			.forEach( System.out :: println);
	}
}

 

 

    EX )))) 스트림 중간연산 예제. flatMap()  : 스트림의 스트림을 스트림으로 변환.

 

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

public class Example6 {
	public static void main(String[] args) {
	
		Stream<String[]> strArrStrm = Stream.of(
				new String[] {"abc","def","jkl"},
				new String[] {"ABC","GHI","JKL"}
				);
		
//		Stream<Stream<String>> strStrmStrm = strArrStrm.map(Arrays::stream);
		Stream<String> strStrm = strArrStrm.flatMap(Arrays :: stream);   
		                                                 // String배열이 합쳐짐
		strStrm.map(String :: toLowerCase)   //스트림과 요소들 모두 소문자로 변경
			.distinct()         //중복제거
			.sorted()          //정렬 
			.forEach(System.out :: println);
		System.out.println();
		
		String[] lineArr = {
				"Believe or not It is ture",
				"Do or do not There is no try",     //한문장한문장 Stream으로 다루기
		};
		Stream<String> lineStream = Arrays.stream(lineArr);
		lineStream.flatMap( line -> Stream.of(line.split(" +")))  //정규식. 하나이상의 공백
			.map(String :: toLowerCase)   //소문자로
			.distinct()         //중복제거
			.sorted()           //정렬
			.forEach(System.out :: println);			
	}
}

 

 

 

 

 

    EX )))) 스트림 최종연산 예제.

 

import java.util.Optional;
import java.util.OptionalInt;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Example6 {
	public static void main(String[] args) {
	
		String[] strArr= {
				"Inheritance","Java","Lambda","stream",
				"OptionalDouble","IntStream","count","sum"
		};
	//	Stream.of(strArr).forEach(System.out :: println);
		Stream.of(strArr)
		.parallel()                      // 병렬로 처리하는데 ( 순서 섞임 )
		.forEachOrdered(System.out :: println);  // 순서는 그대로 유지
		
		boolean noEmptyStr = Stream.of(strArr).noneMatch( s -> s.length()==0);    
		                                     // 문자열 길이가 0인게 하나도 없냐?  true
		Optional<String> sWord = Stream.of(strArr)
						.filter( s -> s.charAt(0)=='s').findFirst();
		                                  // s 로 시작하는것중 처음꺼 찾기.
		
		System.out.println("noEmptyStr=" + noEmptyStr);
		System.out.println("sWord=" + sWord.get());
		
		// Stream<String[]> 을 IntStream(기본형) 으로 변환
		IntStream intStream1 = Stream.of(strArr).mapToInt(String :: length);
		IntStream intStream2 = Stream.of(strArr).mapToInt(String :: length);
		IntStream intStream3 = Stream.of(strArr).mapToInt(String :: length);
		IntStream intStream4 = Stream.of(strArr).mapToInt(String :: length);
		
		int count = intStream1.reduce( 0, (a,b) -> a + 1 );  //단어의 갯수
		int sum = intStream2.reduce( 0, (a,b) -> a + b );    //단어의 길이
		
		OptionalInt max = intStream3.reduce( Integer :: max );
		OptionalInt min = intStream4.reduce( Integer :: min );
		System.out.println("count=" + count);
		System.out.println("sum=" + sum);
		System.out.println("max=" + max.getAsInt());   //가장 긴 문자열
		System.out.println("min=" + min.getAsInt());   //가장짧은 문자열
	}
}