import java.util.*;
import java.util.stream.*;
class StreamEx1 {
   public static void main(String[] args) {
	   Student[] stuArr= {
			   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)
	   };
	   
	   Stream<Student> stuStream = Stream.of(stuArr);
	   
	   stuStream.sorted(Comparator.comparing(Student::getBan)//반별 
	                .thenComparing(Comparator.naturalOrder())) // 점수별 내림 차순
	                .forEach(System.out::println); //Stream소모
	   
	   stuStream = Stream.of(stuArr);//다시 생성
	   IntStream stuScoreStream = stuStream.mapToInt(Student::getTotalScore);//기본형 스트림으로 변환하는
	   
	   IntSummaryStatistics stat = stuScoreStream.summaryStatistics();//최종연산에도 소모되지 않도록
	   System.out.println("count="+stat.getCount());
	   System.out.println("sum="+stat.getSum());
	   System.out.printf("average=%.2f%n",stat.getAverage());
	   System.out.println("min="+stat.getMin());
	   System.out.println("max="+stat.getMax());
   }	
}
class Student implements Comparable<Student>{//자료형에 정의되는 기본정렬 Comparable
	String name;
	int ban;
	int totalScore;
	Student(String name, int ban, int totalScore) {
		this.name = name;
		this.ban = ban;
		this.totalScore = totalScore;
	}
	public String toString() {
		return String.format("[%s,%d,%d]",name,ban,totalScore).toString() ;
	}
	String getName() {return name;}
	int getBan() {return ban;}
	int getTotalScore() {return totalScore;}
	
	public int compareTo(Student s) { // 기본 내림차순
		return s.totalScore -this.totalScore; //양수 바꾸기 
	}
}

flatMap() - Stream<T[]>를 Stream로 변환

Stream의 요소가 배열인 경우

import java.util.*;
import java.util.stream.*;

class StreamEx4 {
	public static void main(String[] args) {
		//1번째 배열을 요소로 하는 stream의 각 요소를 stream으로 만들기
		Stream<String[]> strArrStrm = Stream.of( //stream 요소 자체가 배열인
				new String[] {"abc","def","jkl"},
				new String[] {"ABC","GHI","JKL"}
				);
		   //Stream<Stream<String>> strStremStrem = strArr.map(Arrays::stream);
		Stream<String> strStrm = strArrStrm.flatMap(Arrays::stream);//Arrays.stream()
		
		strStrm.map(String::toLowerCase)//소문자
		       .distinct()//중복제거
		       .sorted()//정렬
		       .forEach(System.out::println); //출력하고 소모
		System.out.println();
		//2번째 문장을 요소로 하는 stream을 단어별의 stream으로 만들기
		String[] lineArr = {
				"Believe or not It is true",
				"Do or do not There is no try"
		};
		
		Stream<String> lineStream = Arrays.stream(lineArr); //stream생성
		lineStream.flatMap(line->Stream.of(line.split(" +"))) //띄어쓰기를 구분하여 stream요소 생성
		          .map(String::toLowerCase) //소문자
		          .distinct() //중복 제거
		          .sorted() //정렬
		          .forEach(System.out::println); //출력하고 소모
		System.out.println();
		
		//3번째 stream안의 stream을 stream<T>으로 만들 때
		   // map으로 stream 안의 stream을 배열로 만들 후
		   // flatMap으로 그 배열의 요소를 각각 stream으로 만들 것
		
		Stream<String> strStrm1 = Stream.of("AAA","ABC","bBb","Dd"); //String의 요소를 갖는 stream
		Stream<String> strStrm2 = Stream.of("bbb","aaa","ccc","dd");
		
		Stream<Stream<String>> strStrmStrm =Stream.of(strStrm1,strStrm2); //두개의 stream을 합치기 즉 스트림 안의 스트림
		Stream<String> strStream = strStrmStrm
				                       .map(s->s.toArray(String[]:: new)) //스트림 안의 스트림을 String 배열로 마들기
				                       .flatMap(Arrays::stream); //배열 안의 요소들 stream으로 만들기
		strStream.map(String::toLowerCase)
		         .distinct()
		         .forEach(System.out::println);
		

	}

}

2.4 Optional<T>와 OptionalInt

import java.util.*;
public class OptionalEx1 {
	public static void main(String[] args) {
		//Optional 객체 생성
		Optional <String> optStr = Optional.of("1234");
		Optional<Integer> optInt = optStr.map(String::length); //s->s.length()
		//get()함수를 통해서 저장된 값 가져오기
		System.out.println("optStr="+optStr.get());
		System.out.println("optInt="+optInt.get());
		 
        //null이 발생하여 예외가 발생하는 경우 get() ->orElse()
		int result1 = Optional.of("1234")
                              .filter(x->x.length()>0)
                              .map(Integer::parseInt).get();
	    int result2 = Optional.of("")
	    		              .filter(x->x.length()>0)
	    		              .map(Integer::parseInt).orElse(-1);
	    
	    System.out.println("result1 ="+result1);
	    System.out.println("result2 ="+result2);
	    

	    //ifPresent() null이면 아무일도 안함, 값이 있다면 람다식
	    Optional.of("456").map(Integer::parseInt)
	                      .ifPresent(x->System.out.printf("result3=%d%n",x));
	    
	       //0과 빈객체의 차이
	    OptionalInt optInt1 = OptionalInt.of(0);//0저장
	    OptionalInt optInt2 = OptionalInt.empty();//null
	    
	    //isPresent() null이면 false, 값이 있다면 true
	    System.out.println(optInt1.isPresent());
	    System.out.println(optInt2.isPresent());
	    
	    //기본형Optional의 get메서드의 형태
	    System.out.println(optInt1.getAsInt());
	    System.out.println("optInt1="+optInt1);
	    System.out.println("optInt2="+optInt2);
	    System.out.println("optInt1.equals(optInt2)?"+optInt1.equals(optInt2));
	    
	    //참보 뱐수의 값이 null일 가능성이 있는 경우 Optional의 겍체 생성은
	    //of() 대신에 ofNullable()을 사용
	    Optional<String> opt = Optional.ofNullable(null);
	    Optional<String> opt2 = Optional.empty();
	    System.out.println("opt ="+opt);
	    System.out.println("opt2 ="+opt2);
	    System.out.println("opt.equals(opt2)?"+opt.equals(opt2));
	     
	    //optStrToInt 메서드 정의
	    int result3 = optStrToInt(Optional.of("123"),0);
	    int result4 = optStrToInt(Optional.of(""),0);
	    
	    System.out.println("result3="+result3);
	    System.out.println("result4="+result4);
	}
	static int optStrToInt(Optional<String> optStr , int defaultValue) {
		try {
			return optStr.map(Integer:: parseInt).get();
		}catch(Exception e) {
			return defaultValue;
		}
	}

}

2.5 스트림의 최종 연산

forEach()

<->peek() : 스트림 소모하지 않고 결과를 만들어낸다.

void forEach(Consumer<? super  T> action)

조건검사 - allMatch(), anyMatch, noneMatch(), findFirst(), findAny()

통계 - count(), sum(), average(), max(), min()

import java.util.*;
import java.util.stream.*;
class StreamEx5 {
	public static void main(String[] args) {
		String[] strArr = {
				"Inheritance","Java" ,"Lambda","stream","OptionalDouble","IntStream","count","sum"
		};
		//스트림 생성
		Stream.of(strArr).forEach(System.out::println);
		
		//조건 noneMatch : 조건을 만족하는 요소가 하나도 없는가?
		boolean noEmptyStr = Stream.of(strArr).noneMatch(s->s.length()==0);
        //조건 findFirst() 첫번째 요소 주로 filter()와 같이 사용됨
		  //s로 시작하는 첫번째 요소 반환
		Optional<String> sWord = Stream.of(strArr)
        		                        .filter(s->s.charAt(0)=='s').findFirst();
		
		System.out.println("noEmptyStr="+noEmptyStr);
		System.out.println("sWord="+sWord.get());
		
		//mapToInt를 이용하여 Stream<String[]>->IntString
		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);//count()
		int sum = intStream2.reduce(0,(a,b)->a+b);//sum()
		//람다식을 메서드 차조로
		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());
	}

}

2.6 collect()

import java.util.*;
import java.util.stream.*;
import static java.util.stream.Collectors.*;//static 메서드 호출시 'Collectors.' 생략
class StreamEx1 {
   public static void main(String[] args) {
	   Student[] stuArr= {
			   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)
	   };
	  //stream->컬렉션과 배열로 변환 
	   List<String> names = Stream.of(stuArr).map(Student::getName)
			                             .collect(Collectors.toList());
	   System.out.println(names);
	   //스트림->배열로
	   Student[] stuArr2= Stream.of(stuArr).toArray(Student[]::new);
	   for(Student s : stuArr2)
		   System.out.println(s);
	   
	   // 스트림->Map<String,Student>로 변환. 학생이름이 key
	   Map<String,Student> stuMap = Stream.of(stuArr)
			                           .collect(Collectors.toMap(s->s.getName(),p->p));
	   
	   for(String name : stuMap.keySet())
		   System.out.println(name+"-"+stuMap.get(name));
	   
	   long count = Stream.of(stuArr).collect(counting());
	   long  totalScore = Stream.of(stuArr)
			                  .collect(summingInt(Student::getTotalScore));
	  
	   System.out.println("count="+count);
	   System.out.println("totalScore="+totalScore);
	   
	   //map()->reduce()
	   totalScore =Stream.of(stuArr)
			         .collect(reducing(0,Student::getTotalScore, Integer::sum));
	   
	   System.out.println("totalScore="+totalScore);
	   
	   Optional<Student> topStudent = Stream.of(stuArr)
			                              .collect(maxBy(Comparator.comparingInt(Student::getTotalScore)));
	   System.out.println("topStudent="+topStudent.get());
	   
	   IntSummaryStatistics stat = Stream.of(stuArr)
			                       .collect(summarizingInt(Student::getTotalScore));
	   System.out.println(stat);
	  
	   String stuNames = Stream.of(stuArr).map(Student::getName)
			                .collect(joining(",","{","}"));
	   System.out.println(stuNames);
   }	
}
class Student implements Comparable<Student>{//자료형에 정의되는 기본정렬 Comparable
	String name;
	int ban;
	int totalScore;
	Student(String name, int ban, int totalScore) {
		this.name = name;
		this.ban = ban;
		this.totalScore = totalScore;
	}
	public String toString() {
		return String.format("[%s,%d,%d]",name,ban,totalScore).toString() ;
	}
	String getName() {return name;}
	int getBan() {return ban;}
	int getTotalScore() {return totalScore;}
	
	public int compareTo(Student s) { // 기본 내림차순
		return s.totalScore -this.totalScore; //양수 바꾸기 
	}
}

그룹화와 분할

partitiongBy()에 의한 분류

import java.util.*;
import java.util.function.*;
import java.util.stream.*;
import static java.util.stream.Collectors.*;
import static java.util.Comparator.*;

class Student2 {
  String name;
  boolean isMale;
  int hak;
  int ban;
  int score;
  
  Student2(String name, boolean isMale, int hak, int ban, int score){
	  this.name = name;
	  this.isMale = isMale;
	  this.hak = hak;
	  this.ban = ban ;
	  this.score = score;
  }
  String getName() {return name;}
  boolean isMale() {return isMale;}
  int getHak() {return hak;}
  int getBan() {return ban;}
  int getScore() {return score;}
  
  public String toString() {
	  return String.format("[ %s ,%s,%d학년 %d반,%3d점]",
			  name,isMale? "남":"여",hak,ban,score);
  }
  enum Level {HIGH, MID, LOW}
}

class StreamEx7 {
	public static void main(String[] args) {
		Student2[] stuArr = {
				new Student2("나자바",true,1,1,300),
				new Student2("김자바",false,1,1,250),
				new Student2("김자바",true,1,1,200),
				new Student2("이지미",false,1,2,150),
				new Student2("남자바",true,1,2,100),
				new Student2("안지미",false,1,2,50),
				new Student2("황지미",false,1,3,100),
				new Student2("강지미",false,1,3,150),
				new Student2("이자바",true,1,3,200),
				
				new Student2("나자바",true,2,1,300),
				new Student2("김지미",false,2,1,250),
				new Student2("김자바",true,2,1,250),
				new Student2("이지미",false,2,2,150),
				new Student2("남자바",true,2,2,100),
				new Student2("안지미",false,2,2,100),
				new Student2("황지미",false,2,3,100),
				new Student2("강지미",false,2,3,150),
				new Student2("이자바",true,2,3,100)
		};
		
		System.out.printf("1. 단순분할(성별로 분할)%n");
		Map<Boolean, List<Student2>> stuBySex = Stream.of(stuArr)
				.collect(partitioningBy(Student2::isMale));
		
		System.out.println("map<성별, List<Student>="+stuBySex);
		
		List<Student2> maleStudent = stuBySex.get(true);
		List<Student2> femaleStudent = stuBySex.get(false);
		
		for(Student2 s : maleStudent) System.out.println(s);
		for(Student2 s: femaleStudent) System.out.println(s);
		
		System.out.printf("%n2. 단순분할 + 통계(성별 학생수)%n");
		Map<Boolean,Long> stuNumBySex = Stream.of(stuArr)
				.collect(partitioningBy(Student2::isMale,counting()));

		System.out.println("남학생 수 : "+stuNumBySex.get(true));
		System.out.println("여학생 수 : "+stuNumBySex.get(true));
        
	
		System.out.printf("%n3. 단순불할 + 통계 (성별 1등)%n");
		Map<Boolean,Optional<Student2>> topScoreBySex = Stream.of(stuArr)
				.collect(partitioningBy(Student2::isMale,maxBy(comparingInt(Student2::getScore))
						));
		System.out.println("남학생 1등 :"+topScoreBySex.get(true));
		System.out.println("여학생 1등 :"+topScoreBySex.get(false));
		
		Map<Boolean, Student2> topScoreBySex2 = Stream.of(stuArr)
				.collect(partitioningBy(Student2::isMale,
						collectingAndThen(
								maxBy(comparingInt(Student2::getScore)), Optional ::get
								)
						));
		System.out.println("남학생 1등 :"+ topScoreBySex2.get(true));
		System.out.println("남학생 1등 :"+ topScoreBySex2.get(false));
		
		System.out.printf("%n4. 다중분할(성별 불합격자, 100점 이하)%n");
		
		Map<Boolean, Map<Boolean, List<Student2>>> failedStuBySex = 
				Stream.of(stuArr).collect(partitioningBy(Student2::isMale,partitioningBy(s->s.getScore()<=100))
						);
		List<Student2> failedMaleStu = failedStuBySex.get(true).get(true);
		List<Student2> failedFemaleStu = failedStuBySex. get(false).get(true);
		
		for(Student2 s : failedMaleStu) System.out.println(s);
		for(Student2 s : failedFemaleStu) System.out.println(s);
	}
}

groupingBy()에 의한 분류

import java.util.*;
import java.util.function.*;
import java.util.stream.*;
import static java.util.stream.Collectors.*;
import static java.util.Comparator.*;

class Student2 {
  String name;
  boolean isMale;
  int hak;
  int ban;
  int score;
  
  Student2(String name, boolean isMale, int hak, int ban, int score){
	  this.name = name;
	  this.isMale = isMale;
	  this.hak = hak;
	  this.ban = ban ;
	  this.score = score;
  }
  String getName() {return name;}
  boolean isMale() {return isMale;}
  int getHak() {return hak;}
  int getBan() {return ban;}
  int getScore() {return score;}
  
  public String toString() {
	  return String.format("[ %s ,%s,%d학년 %d반,%3d점]",
			  name,isMale? "남":"여",hak,ban,score);
  }
  enum Level {HIGH, MID, LOW}
}

class StreamEx7 {
	public static void main(String[] args) {
		Student2[] stuArr = {
				new Student2("나자바",true,1,1,300),
				new Student2("김자바",false,1,1,250),
				new Student2("김자바",true,1,1,200),
				new Student2("이지미",false,1,2,150),
				new Student2("남자바",true,1,2,100),
				new Student2("안지미",false,1,2,50),
				new Student2("황지미",false,1,3,100),
				new Student2("강지미",false,1,3,150),
				new Student2("이자바",true,1,3,200),
				
				new Student2("나자바",true,2,1,300),
				new Student2("김지미",false,2,1,250),
				new Student2("김자바",true,2,1,250),
				new Student2("이지미",false,2,2,150),
				new Student2("남자바",true,2,2,100),
				new Student2("안지미",false,2,2,100),
				new Student2("황지미",false,2,3,100),
				new Student2("강지미",false,2,3,150),
				new Student2("이자바",true,2,3,100)
		};
		
		System.out.printf("1. 단순그룹화(반별로 그룹화)%n");
		Map<Integer, List<Student2>> stuByBan = Stream.of(stuArr)
				.collect(groupingBy(Student2::getBan));
		
		for(List<Student2> ban : stuByBan.values()) {
			for (Student2 s : ban) {
				System.out.println(s);
			}System.out.println();
		}
		
		System.out.printf("%n2. 단순그룹화(성적별로 그룹화)%n");
		Map<Student2.Level,List<Student2>> stuByLevel = Stream.of(stuArr)
				.collect(groupingBy(s->{
					if(s.getScore() >= 200) return Student2.Level.HIGH;
					else if(s.getScore() >=100) return Student2.Level.MID;
					else                        return Student2.Level.LOW;				} 
				));
		
		TreeSet<Student2.Level> keySet = new TreeSet<>(stuByLevel.keySet());
		
		for(Student2.Level key : keySet) {
			System.out.println("["+key+"]");
			
			for(Student2 s: stuByLevel.get(key)) {
				System.out.println(s);
			System.out.println();
			}
		}
		
		System.out.printf("%n3. 단순그룹화 + 통계(성적별-> 학생수)%n");
		Map<Student2.Level, Long> stuCntByLevel = Stream.of(stuArr)
				.collect(groupingBy(s->{
					if(s.getScore() >= 200) return Student2.Level.HIGH;
					else if(s.getScore() >=100) return Student2.Level.MID;
					else                        return Student2.Level.LOW;},counting())
			);
		
		for(Student2.Level key : stuCntByLevel.keySet()) 
		   System.out.printf("[%s] - %d명, ",key, stuCntByLevel.get(key));
		System.out.println();
		
		
		System.out.printf("%n4. 다중그룹화(학년별, 반별)");
		//1-2-Student List
		Map<Integer,Map<Integer, List<Student2>>> stuByHakAndBan = 
				Stream.of(stuArr)
				.collect(groupingBy(Student2::getHak,
						groupingBy(Student2::getBan)
						));
		for(Map<Integer,List<Student2>> hak : stuByHakAndBan.values() ) {
			for(List<Student2> ban : hak.values()) {
				System.out.println();
				for(Student2 s : ban)
					System.out.println(s);
			}
		}
		System.out.printf("%n5. 다중그룹화 + 통계 (학년별, 반별 1등) %n");
		// 학년 별로 아래 Map으로 존재 
		//1-2-Student 1등인 사람 하나
		//하나로 연결되는 경우에는 collecitongAndThen (어떤 최종 연산자),Optional::get
		Map<Integer,Map<Integer,Student2>> topStuByHakAndBan = 
		   Stream.of(stuArr)
		   .collect(groupingBy(Student2::getHak,
				    groupingBy(Student2::getBan,
				    		collectingAndThen(
				    				maxBy(comparingInt(Student2::getScore))
				    				, Optional::get
				    				)
				    		)
				    ));
	    for(Map<Integer, Student2> ban : topStuByHakAndBan.values()) {
	    	for(Student2 s : ban.values())
	    		System.out.println(s);
	    }
	    
	    System.out.printf("%n6. 다중그룹화 + 통계(학년별, 반별 성적그룹)%n");
	    Map<String, Set<Student2.Level>> stuByScoreGroup = Stream.of(stuArr)
	    		.collect(groupingBy(s->s.getHak()+"-"+s.getBan(),
	    				mapping(s->{
	    					if(s.getScore()>=200) return Student2.Level.HIGH;
	    					else if(s.getScore() >=100) return Student2.Level.MID;
	    					else                        return Student2.Level.LOW;
	    				},toSet())
	    				));
	    
	    Set<String> keySet2 = stuByScoreGroup.keySet();
	    
	    for(String key : keySet2) {
	    	System.out.println("["+key+"]"+stuByScoreGroup.get(key));
	    }
	}
}

2.7 Collector구현하기

위에서는 Collectors 클래스에서 제공하는 컬렉터를 사용하는 방법에 대해서 배웠다.
✔️ 이번에는 Collector 인터페이스를 구현하여 컬렉터를 직접 작성해보자.

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

class CollectorEx1 {
 public static void main(String[] args) {
	 String[] strArr = {"aaa","bbb","ccc"};
	 Stream<String> strStream = Stream.of(strArr);
	 
	 String result = strStream.collect(new ConcatCollector());
	 
	 System.out.println(Arrays.toString(strArr));
	 System.out.println("result="+result);
 } 
}
// 문자열을 하나로 결합해서 String으로 반환하는 
class ConcatCollector implements Collector<String, StringBuilder, String> {
	@Override
	public Supplier<StringBuilder> supplier() {
		return () -> new StringBuilder();
	}	
	@Override
	public BiConsumer<StringBuilder, String> accumulator(){
	    return (sb,s)->sb.append(s);
	}
	
	@Override
	public Function<StringBuilder, String> finisher() {
		return sb->sb.toString();
	}
	
    @Override
    public BinaryOperator<StringBuilder> combiner() {
    	return (sb,sb2)->sb.append(sb2);
    }
    @Override
    public Set<Characteristics> characteristics() {
    	return Collections.emptySet();
    }
}