스트림

요소 매칭

public class StreamPractice {
	public static void mian(String[] args) {
    
    	// 요소 매칭 -> allMatch(람), anyMatch(람), noneMatch(람)
        // 람다식 -> Predicate
        
        String[][] strArr = new String[][] {
        		{"AA", "BBBB"}, {"CCCCCCC", "DD"},
                { "E", "FFFFFFFF"}, { "GGG", "HHHHH"}
        }
        
        Stream<String[]> outerStream = Arrays.stream(strArr);
        
        boolean match = outerStream
        		.flatMap(innerArr -> Arrays.stream(innerArr))
                .allMatch(el -> el.length() > 3);
                
        System.out.println(match)
    }
}

• allMatch() : 모든 요소가 충족하는지
• anyMatch() : 요소 하나라도 충족하는지
• noneMatch() : 모든 요소가 불충족하는지

요소 집계

public class StreamPractice {
	public static void mian(String[] args) {
    
    	// 요소 집계
        // - 객체 요소를 다루는 스트림을 집계 -> Stream<XXXX>
        //    - count(), max(), min() 정도는 사용가능 (사용방법은 다름)
        // - 기본형 요소를 다루는 스트림을 집계 -> IntStream, DoubleStream, LongStream
        //    - 기본형 스트림에서 쓸 수 있는 집계 메서드가 있다.
        //    - count(), max(), min() + sum(), average()
        
        String[][] strArr = new String[][] {
        		{"AA", "BBBB"}, {"CCCCCCC", "DD"},
                { "E", "FFFFFFFF"}, { "GGG", "HHHHH"}
        }
        
        long count = Arrays.stream(strArr)
        		.flatmap(innerArr -> Arrays.stream(innerArr))
                .count();
        System.out.println(count);
        
        String max = Arrays.stream(strArr)
        		.flatmap(innerArr -> Arrays.stream(innerArr))
                .max((a, b) -> a.length() - b.length())
                .get();
        
        // 필요한 값은 String 타입이지만 .max()는 Optional을 리턴함 -> get 필요 
        // Optional -> Stream<XXXX> -> .get()
        // OptionalInt -> IntStream -> .getAsInt()
        
        String min = Arrays.stream(strArr)
        		.flatmap(innerArr -> Arrays.stream(innerArr))
                .min((a, b) -> a.length() - b.length())
                .get();
    }
}

• 객체 스트림은 박싱, 언박싱이 필요 -> 리소스를 좀더 사용함

• Optional : 만약 값이 0으로 나올 경우 값이 도출된 0인지 값이 없어서 0인지 혼재되어있음

• 인텔리제이에서는 각 스트림 연산별 리턴 타입을 오른쪽에 회색으로 표시해준다

public class StreamPractice {
	public static void mian(String[] args) {
    
    	// 요소 집계
        // - 객체 요소를 다루는 스트림을 집계 -> Stream<XXXX>
        //    - count(), max(), min() 정도는 사용가능 (사용방법은 다름)
        // - 기본형 요소를 다루는 스트림을 집계 -> IntStream, DoubleStream, LongStream
        //    - 기본형 스트림에서 쓸 수 있는 집계 메서드가 있다.
        //    - count(), max(), min() + sum(), average()
        
        String[][] strArr = new String[][] {
        		{"AA", "BBBB"}, {"CCCCCCC", "DD"},
                { "E", "FFFFFFFF"}, { "GGG", "HHHHH"}
        }
        
        long count = Arrays.stream(strArr)
        		.flatmap(innerArr -> Arrays.stream(innerArr))
                .mapToInt(str -> str.length())
                .count();
        System.out.println(count);
        
        int max = Arrays.stream(strArr)
        		.flatmap(innerArr -> Arrays.stream(innerArr))
                .mapToInt(str -> str.length())
                .max()
                .getAsInt();
        System.out.println(max);
                
        double average = Arrays.stream(strArr)
        		.flatmap(innerArr -> Arrays.stream(innerArr))
                .mapToInt(str -> str.length())
                .average()
                .getAsDouble(); 
        System.out.println(avarage);        
    }
}

• 길이만을 가진 Int형으로 바꼈으므로 int max 사용

• 기본형 스트림은 비교기준이 명확하므로 빈괄호 사용

리듀싱

public class StreamPractice {
	public static void mian(String[] args) {
    
    	// 리듀싱 : 스트림의 요소를 줄여나가면서 누적 연산을 수행한 다음 최종결과를 리턴함
        
        int[] arr = new int[] { 9, 5, 2, 3, 1, 6, 8, 7, 8, 2, 3, 1, 4, 6}
        
        int result = Arrays.stream(arr)
        		.reduce(1, (a, b) -> a > b ? a : b);
        
   		int sumResult = Arrays.stream(arr)
        		.reduce(0, (a, b) -> a + b);   
    }
}

• reduce(초기값, 람다식)

요소 수집

public class StreamPractice {
	public static void mian(String[] args) {
    
    	// collect() -> 요소 수집
        //  -> 연산 결과를 컬렉션 또는 배열로 추출하거나, 그룹핑하는것
       
       Student[] students = new Student[] {};
       
       // 씻는 횟수만 추출해서 List로 저장
       List<Integer> wash = Arrays.stream(students)
       			.map(student -> student.getWash())
                .collect(Collectors.toList());
       System.out.println(wash);
       
       // 이름을 추출해서 Set으로 저장
       Set<String> names = Arrays.stream(students)
       			.map(student -> student.getName())
                .collet(Collectors.toSet());
       System.out.println(names);
       
       // Map<이름, 씻는 횟수> 생성
       Map<String, Integer> map = Arrays.stream(students)
       			.collect(Collectors.toMap(
                		student -> student.getName(), student-> student.getWash()
                ));
       System.out.println(map);                
    }
}

enum Gender {
	MALE,
    FEMALE
}

class Student {
	private name
    private Gender
    private wash
}

그룹핑, 분할

public class StreamPractice {
	public static void mian(String[] args) {
    
       
       Student[] students = new Student[] {};
       
       // groupingBy(람다식)
       // 결과 : Map<Integer, List<Student>>
       
       Map<Integer, List<Student>> groupByWash = Arrays.stream(students)
       			.collect(Collectors.groupingBy(student-> students.getWash()));
                
       List<Student> list = groupByWash.get(3);
       list.stream().forEach(student -> System.out.println(student.getName()));
       
       
       // 분할 : 이다 아니다(predicate)를 기준으로 판단
       
       Map<Boolean, List<Student>> partitionedByGender = Arrays.stream(students)
       			.collect(Collectors.partitioningBy(
                		student -> student.getGender() == Gender.FEMALE
                ));
       
       System.out.println(partitionedByGender);
       
       List<Student> femaleList = partitionedByGender.get(true)
       femaleList.stream().forEach(student -> System.out.println(student.getName()));
     }
}

enum Gender {
	MALE,
    FEMALE
}

class Student {
	private name
    private Gender
    private wash
}

• 그냥 출력해버리면 리스트의 주소값이 Value로 리턴된다
• 리스트로 수집해서 출력하는 과정이 필요하다