스트림 문제 2

스터디에서 지웅님이 발표하신 부분을 가져왔습니다.

List<String> strList = Arrays.asList("jiwoong", "", "hyungjoon", "", 
"minseung", "hyunjoon","yoochul","Tea0");

빈 문자열의 개수를 출력하세요.(filter , isEmpty)

• 답

  long count = strList.stream() .filter(x -> x.isEmpty()) .count();
          System.out.println("count = " + count);

h로 시작하는 문자열의 개수를 출력하세요(startsWith)

• 답

  long count1 = strList.stream() .filter(x -> x.startsWith("h")) .count();
          System.out.println("count1 = " + count1);

길이가 2 이상인 문자열만 따로 리스트에 저장해주세요(toList)

• 답

  List<String> filtered = strList.stream() .filter(x -> x.length()> 2) .collect(Collectors.toList());
          System.out.println("filtered = " + filtered);

백준 문제 스트림으로 풀기

최댓값문제

2562번: 최댓값

import java.io.*;

public class Main{

    public static void main(String []args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int max = Integer.MIN_VALUE;
        int index = 0;
        for(int i=1;i<=9;i++){
            int num = Integer.parseInt(br.readLine());
            if(num>max) {
                max = num;
                index = i;
            }
        }
        System.out.println(max);
        System.out.println(index);
    }
}

template

//복붙하세요
import java.io.*;
import java.util.*;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] arr = new int[9];
       for(int i=0;i<9;i++){
        arr[i] = Integer.parseInt(br.readLine());
    }
       //-----------------------------------

			//---------------------------------------
    }
}

• 답

  import java.io.*;
  import java.util.*;
  import java.util.stream.IntStream;
  
  public class Main {
      public static void main(String[] args) throws IOException {
          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
          int[] arr = new int[9];
         for(int i=0;i<9;i++){
          arr[i] = Integer.parseInt(br.readLine());
      }
         int max = Arrays.stream(arr).max().getAsInt();
         int index = IntStream.range(0,arr.length).filter(i -> arr[i]==max).findFirst().getAsInt()+1;
          System.out.println(max);
          System.out.println(index);
      }
  }

나머지 문제

3052번: 나머지

• 답

  import java.io.*;
  import java.util.*;
  
  public class Main {
      public static void main(String[] args) throws IOException {
          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
          int[] arr = new int[10];
         for(int i=0;i<10;i++){
          arr[i] = Integer.parseInt(br.readLine());
      }
          System.out.println(Arrays.stream(arr).map(i->i%42).distinct().count());
      }
  }

정렬 문제

1181번: 단어 정렬

• 답

  import java.io.*;
  import java.util.*;
  
  public class Main {
      public static void main(String[] args) throws IOException {
          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
          int n = Integer.parseInt(br.readLine());
          ArrayList<String> arr = new ArrayList<>();
          while(n-->0){
              arr.add(br.readLine());
          }
          arr.stream().distinct().sorted().sorted(((o1, o2) -> Integer.compare(o1.length(),o2.length()))).forEach(System.out::println);
      }
  }

문제1

아래와 같은 데이터가 저장된 리스트가 있다고 하자.

private static List<String> WORDS = Arrays.asList("TONY", "a", "hULK", "B", "america", "X", "nebula", "Korea");

문제 1-1

List에 저장된 단어들의 접두사가 각각 몇개씩 있는지 Map<String, Integer>으로 변환하여라. ex) ("T", 1), ("a", 2) ...

ex)

Map<String, Integer> map1 = new HashMap<>();
map1.put("Apple", 1000);
map1.put("Banana", 2000);
map1.put("Orange", 3000);

Map<String, Integer> map2 = new HashMap<>();
map2.put("Apple", 4000);
map2.put("Tomato", 5000);
map2.put("WaterMelon", 6000);

// Map1 + Map2
map2.forEach((key, value) -> map1.merge(key, value, (v1, v2) -> v1+v2));

문제 1-2

List에 저장된 단어들 중에서 단어의 길이가 2 이상인 경우에만, 모든 단어를 대문자로 변환하여 스페이스로 구분한 하나의 문자열로 합한 결과를 반환하여라. ex) ["Hello", "a", "Island", "b","mentor"] -> “HIM”

• 답

  import java.io.*;
  import java.util.*;
  import java.util.stream.Collectors;
  
  public class Main {
  
      static List<String> WORDS = Arrays.asList("TONY", "a", "hULK", "B", "america", "X", "nebula", "Korea");
      public static Map quiz1() {
          Map<String, Integer> wordCountMap = new HashMap<>();
          WORDS.stream().map(w -> w.substring(0, 1)).forEach(prefix -> wordCountMap.merge(prefix, 1, (oldValue, newValue) -> (newValue += oldValue)));
          wordCountMap.keySet().forEach(k -> System.out.println(k + ": " + wordCountMap.get(k)));
          return wordCountMap;
      }
      public static String quiz2() {
          String result = WORDS.stream().filter(w -> w.length() > 1).map(String::toUpperCase).map(w -> w.substring(0, 1)).collect(Collectors.joining(" "));
          System.out.println(result);
          return result;
      }
      public static void main(String[] args) throws IOException {
      quiz1();
      quiz2();
      }
  }

문제 2

private static List<Integer> numbers1 = Arrays.asList(1, 2, 3);
private static List<Integer> numbers2 = Arrays.asList(3, 4);

문제 2.1

위와 같은 숫자 리스트가 있을 때 모든 숫자 쌍의 배열 리스트를 반환하여라. ex) numbers1 = [1,2,3], numbers2 = [3,4] -> [(1,3), (1,4), (2,3), (2,4), (3,3), (3,4)]

• ex)

  //166쪽 참고
  List<Integer> numbers1=Arrays.asList(1, 2, 3);
  List<Integer> numbers2=Arrays.asList(3, 4);
  List<int[]> pairs= numbers1.stream()
  	.flatMap(i-> numbers2.stream()
  		.map(j->newint[]{i, j}))
  			.collect(toList());

문제 2.2

위와 같은 숫자 리스트가 있을 때 모든 숫자 쌍의 곱이 가장 큰 값을 반환하여라. ex) numbers1 = [1,2,3], numbers2 = [3,4] -> 12

• 답

  import java.io.*;
  import java.util.*;
  import java.util.stream.Collectors;
  
  public class Main {
      private static List<Integer> numbers1 = Arrays.asList(1, 2, 3);
      private static List<Integer> numbers2 = Arrays.asList(3, 4);
  
      public static List<Integer[]> quiz1() {
          List<Integer[]> integers = numbers1.stream().flatMap(n -> numbers2.stream().map(m -> new Integer[]{n, m})).collect(Collectors.toList());
          String result = integers.stream().map(a -> "(" + a[0] + ", " + a[1] + ")").collect(Collectors.joining("\\n"));
          System.out.println(result);
          return integers;
      }
  
      public static Integer quiz2() {
          int maxValue = numbers1.stream().flatMap(n -> numbers2.stream().map(m -> new Integer[]{n, m})).mapToInt(a -> a[0]*a[1]).max().getAsInt();
          System.out.println(maxValue);
          return maxValue;
      }
      public static void main(String[] args) throws IOException {
          quiz1();
          quiz2();
      }
  }

문제3

아래와 같은 데이터를 갖는 거래자와 거래 내역 클래스가 있다고 하자. (생성자 및 Getter, Setter 등은 생략)

public class Trader {
    private String name;
    private String city;
}

public class Transaction {
    private Trader trader;
    private int year;
    private int value;
}

또한 데이터는 아래와 같이 초기화되어 있다.

public void init() {
    Trader kyu = new Trader("Kyu", "Seoul");
    Trader ming = new Trader("Ming", "Gyeonggi");
    Trader hyuk = new Trader("Hyuk", "Incheon");
    Trader hyuk = new Trader("Hyuk", "Seoul");
    transactions = Arrays.asList(
            new Transaction(kyu, 2019, 30000),
            new Transaction(kyu, 2020, 12000),
            new Transaction(ming, 2020, 40000),
            new Transaction(ming, 2020, 7100),
            new Transaction(hyuk, 2019, 5900),
            new Transaction(hwan, 2020, 4900)
    );
}

문제 3.1

2020년에 일어난 모든 거래 내역을 찾아 거래값을 기준으로 오름차순 정렬하라.

template

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class Main {

    public class Trader {
        private String name;
        private String city;

        public Trader(String n, String c) {
            name = n;
            city = c;
        }

        public String getName() {
            return name;
        }

        public String getCity() {
            return city;
        }

        public void setCity(String newCity) {
            city = newCity;
        }

        @Override
        public int hashCode() {
            int hash = 17;
            hash = hash * 31 + (name == null ? 0 : name.hashCode());
            hash = hash * 31 + (city == null ? 0 : city.hashCode());
            return hash;
        }

        @Override
        public boolean equals(Object other) {
            if (other == this) {
                return true;
            }
            if (!(other instanceof Trader)) {
                return false;
            }
            Trader o = (Trader) other;
            boolean eq = Objects.equals(name, o.getName());
            eq = eq && Objects.equals(city, o.getCity());
            return eq;
        }

        @Override
        public String toString() {
            return String.format("Trader:%s in %s", name, city);
        }
    }

    public class Transaction {
        private Trader trader;
        private int year;
        private int value;

        public Transaction(Trader trader, int year, int value) {
            this.trader = trader;
            this.year = year;
            this.value = value;
        }

        public Trader getTrader() {
            return trader;
        }

        public int getYear() {
            return year;
        }

        public int getValue() {
            return value;
        }

        @Override
        public int hashCode() {
            int hash = 17;
            hash = hash * 31 + (trader == null ? 0 : trader.hashCode());
            hash = hash * 31 + year;
            hash = hash * 31 + value;
            return hash;
        }

        @Override
        public boolean equals(Object other) {
            if (other == this) {
                return true;
            }
            if (!(other instanceof Transaction)) {
                return false;
            }
            Transaction o = (Transaction) other;
            boolean eq = Objects.equals(trader, o.getTrader());
            eq = eq && year == o.getYear();
            eq = eq && value == o.getValue();
            return eq;
        }

        @SuppressWarnings("boxing")
        @Override
        public String toString() {
            return String.format("{%s, year: %d, value: %d}", trader, year, value);
        }
    }

    private List<Transaction> transactions;

   private void init() {
        Trader Jun = new Trader("Jun", "Seoul");
        Trader ming = new Trader("Ming", "Gyeonggi");
        Trader Yoo = new Trader("Yoo", "UK");
        Trader Jiwoong = new Trader("Jiwoong", "Jeju");

        transactions = Arrays.asList(
                new Transaction(Jun, 2019, 30000),
                new Transaction(Jun, 2020, 12000),
                new Transaction(ming, 2020, 40000),
                new Transaction(ming, 2020, 7100),
                new Transaction(Yoo, 2019, 5900),
                new Transaction(Jiwoong, 2020, 4900)
        );
    }
    public List<Transaction> quiz1() {
        List<Transaction> transactionList = transactions.stream()
                .filter(t -> t.getYear() == 2020)
                .sorted(Comparator.comparing(Transaction::getValue))
                .collect(Collectors.toList());

        transactionList.forEach(System.out::println);
        return transactionList;
    }

//    public List<String> quiz2() {}

//    public List<Trader> quiz3() {}

//    public String quiz4() {}

//    public boolean quiz5() {}

//    public List<Integer> quiz6() {}

//    public Integer[] quiz7() {}
    public static void main(String[] args) throws IOException {
        Main t = new Main();
        t.init();
        t.quiz1();
//        t.quiz2();
//        t.quiz3();
//        t.quiz4();
//        t.quiz5();
//        t.quiz6();
//        t.quiz7();

    }
}

문제 3.2

거래 내역이 있는 거래자가 근무하는 모든 도시를 중복 없이 나열하라.

문제 3.3

서울에서 근무하는 모든 거래자를 찾아서 이름순서대로 정렬하라.

문제 3.4

모든 거래자의 이름을 순서대로 정렬하라.

문제 3.5

부산에 거래자가 있는지를 확인하라.

문제 3.6

서울에 거주하는 거래자의 모든 거래 내역을 구하라.

문제 3.7

모든 거래 내역중에서 최댓값과 최솟값을 구하라. 단, 최댓값은 reduce를 이용하고 최솟값은 stream의 min()을 이용하라.

• 답

  import java.io.*;
  import java.util.*;
  import java.util.stream.Collectors;
  
  public class Main {
  
      public class Trader {
          private String name;
          private String city;
  
          public Trader(String n, String c) {
              name = n;
              city = c;
          }
  
          public String getName() {
              return name;
          }
  
          public String getCity() {
              return city;
          }
  
          public void setCity(String newCity) {
              city = newCity;
          }
  
          @Override
          public int hashCode() {
              int hash = 17;
              hash = hash * 31 + (name == null ? 0 : name.hashCode());
              hash = hash * 31 + (city == null ? 0 : city.hashCode());
              return hash;
          }
  
          @Override
          public boolean equals(Object other) {
              if (other == this) {
                  return true;
              }
              if (!(other instanceof Trader)) {
                  return false;
              }
              Trader o = (Trader) other;
              boolean eq = Objects.equals(name, o.getName());
              eq = eq && Objects.equals(city, o.getCity());
              return eq;
          }
  
          @Override
          public String toString() {
              return String.format("Trader:%s in %s", name, city);
          }
      }
  
      public class Transaction {
          private Trader trader;
          private int year;
          private int value;
  
          public Transaction(Trader trader, int year, int value) {
              this.trader = trader;
              this.year = year;
              this.value = value;
          }
  
          public Trader getTrader() {
              return trader;
          }
  
          public int getYear() {
              return year;
          }
  
          public int getValue() {
              return value;
          }
  
          @Override
          public int hashCode() {
              int hash = 17;
              hash = hash * 31 + (trader == null ? 0 : trader.hashCode());
              hash = hash * 31 + year;
              hash = hash * 31 + value;
              return hash;
          }
  
          @Override
          public boolean equals(Object other) {
              if (other == this) {
                  return true;
              }
              if (!(other instanceof Transaction)) {
                  return false;
              }
              Transaction o = (Transaction) other;
              boolean eq = Objects.equals(trader, o.getTrader());
              eq = eq && year == o.getYear();
              eq = eq && value == o.getValue();
              return eq;
          }
  
          @SuppressWarnings("boxing")
          @Override
          public String toString() {
              return String.format("{%s, year: %d, value: %d}", trader, year, value);
          }
      }
  
      private List<Transaction> transactions;
  
      private void init() {
          Trader Jun = new Trader("Jun", "Seoul");
          Trader ming = new Trader("Ming", "Gyeonggi");
          Trader Yoo = new Trader("Yoo", "UK");
          Trader Jiwoong = new Trader("Jiwoong", "Jeju");
  
          transactions = Arrays.asList(
                  new Transaction(Jun, 2019, 30000),
                  new Transaction(Jun, 2020, 12000),
                  new Transaction(ming, 2020, 40000),
                  new Transaction(ming, 2020, 7100),
                  new Transaction(Yoo, 2019, 5900),
                  new Transaction(Jiwoong, 2020, 4900)
          );
      }
      public List<Transaction> quiz1() {
          List<Transaction> transactionList = transactions.stream()
                  .filter(t -> t.getYear() == 2020)
                  .sorted(Comparator.comparing(Transaction::getValue))
                  .collect(Collectors.toList());
  
          transactionList.forEach(System.out::println);
          return transactionList;
      }
  
      public List<String> quiz2() {
          List<String> cities = transactions.stream()
                  .map(t -> t.getTrader().getCity()).distinct().collect(Collectors.toList());
  
          cities.forEach(System.out::println);
          return cities;
      }
  
      public List<Trader> quiz3() {
          List<Trader> traders = transactions.stream()
                  .map(Transaction::getTrader)
                  .distinct()
                  .filter(t -> t.getCity().equals("Seoul"))
                  .sorted(Comparator.comparing(Trader::getName))
                  .collect(Collectors.toList());
  
          traders.forEach(System.out::println);
          return traders;
      }
  
      public String quiz4() {
          String names = transactions.stream()
                  .map(t -> t.getTrader().getName())
                  .distinct()
                  .sorted()
                  .collect(Collectors.joining(","));
  
          System.out.println(names);
          return names;
      }
  
      public boolean quiz5() {
          boolean isExist = transactions.stream()
                  .map(t -> t.getTrader().getCity())
                  .anyMatch(c -> c.equals("Busan"));
          System.out.println(isExist);
          return isExist;
      }
  
      public List<Integer> quiz6() {
          List<Integer> valueList = transactions.stream()
                  .filter(t -> t.getTrader().getCity().equals("Seoul"))
                  .map(t -> t.getValue())
                  .collect(Collectors.toList());
          valueList.forEach(System.out::println);
          return valueList;
      }
  
      public Integer[] quiz7() {
          Integer[] arr = new Integer[2];
          arr[0] = transactions.stream()
                  .map(Transaction::getValue)
                  .reduce(Integer::max)
                  .orElse(-1);
  
          arr[1] = transactions.stream()
                  .min(Comparator.comparingInt(Transaction::getValue))
                  .orElseThrow(RuntimeException::new).getValue();
  
          Arrays.stream(arr).forEach(System.out::println);
          return arr;
      }
      public static void main(String[] args) throws IOException {
          Main t = new Main();
          t.init();
  //        t.quiz1();
  //        t.quiz2();
  //        t.quiz3();
  //        t.quiz4();
          t.quiz5();
  //        t.quiz6();
  //        t.quiz7();
  
      }
  }

문제 4

private static final String[] strArr = {"aaa", "bb", "c", "dddd"};

문제 4.1

문자열 배열 String[] strArr = {"aaa","bb","c","dddd"}의 모든 문자열의 길이를 더한 결과를 출력하여라.

문제 4.2

문자열 배열 String[] strArr = {"aaa","bb","c","dddd"}의 문자열 중에서 가장 긴 것의 길이를 출력하시오.

문제 4.3

임의의 로또번호(1~45)를 정렬해서 출력하시오. (newRandom().ints(1, 46)

문제 4.4

두 개의 주사위를 굴려서 나온 눈의 합이 6인 경우를 모두 출력하시오.

• 답

  importjava.io.*;
  importjava.util.*;
  importjava.util.stream.Collectors;
  importjava.util.stream.IntStream;
  importjava.util.stream.Stream;
  
  public classMain{
  private static finalString[] strArr = {"aaa", "bb", "c", "dddd"};
  
  public intquiz1() {
  intsum =Arrays.stream(strArr)
                  .mapToInt(String::length)
                  .sum();
  System.out.println(sum);
  returnsum;
      }
  
  public intquiz2() {
  intlength =Arrays.stream(strArr)
                  .mapToInt(String::length)
                  .max()
                  .getAsInt();
  System.out.println(length);
  returnlength;
      }
  
  publicList<Integer> quiz3() {
  List<Integer> integers =newRandom().ints(1, 46)
                  .distinct()
                  .limit(6)
                  .boxed()
                  .collect(Collectors.toList());
  
          integers.forEach(System.out::println);
  returnintegers;
      }
  
  publicList<Integer[]> quiz4() {
  Stream<Integer> dies =IntStream.rangeClosed(1, 6).boxed();
  List<Integer[]> list = dies.flatMap(i->IntStream.rangeClosed(1, 6).boxed().map(j->newInteger[]{i,j}))
                  .filter(arr->arr[0] +arr[1] == 6).collect(Collectors.toList());
  
          list.forEach(a->System.out.printf("[%d, %d]\\n",a[0],a[1]));
  
  returnlist;
  
      }
  
  public static voidmain(String[]args)throwsIOException{
  Maint =newMain();
          t.quiz1();
  //        t.quiz2();
  //        t.quiz3();
  //        t.quiz4();
  
  }
  }

문제 5

아래와 같은 학생 클래스가 있다고 하자. (생성자 및 Getter 등은 생략)

`public class Student {

    private String name;
    private boolean isMale; // 성별
    private int hak; // 학년
    private int ban; // 반
    private int score;

    public String toString() {
        return String.format("[%s, %s, %d학년 %d반, %3d점 ]", name, isMale ? "남" : "여", hak, ban, score);
    }

    // groupingBy()에서 사용 성적을 상,중,하 세 단계로 분류
    enum Level {
        HIGH, MID, LOW
    }

}`

또한 데이터는 Student[] stuArr에 저장되어 있다.

template

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.summingInt;

public class Main {

    public static class Student {

        private String name;
        private boolean isMale; // 성별
        private int hak; // 학년
        private int ban; // 반
        private int score;

        public Student(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);
        }

        // groupingBy()에서 사용 성적을 상,중,하 세 단계로 분류
        enum Level {
            HIGH, MID, LOW
        }

    }

    private Student[] stuArr;

    private void init() {
        stuArr = new Student[]{
                new Student("나자바", true, 1, 1, 300),
                new Student("김지미", false, 1, 1, 250),
                new Student("김자바", true, 1, 1, 200),
                new Student("이지미", false, 1, 2, 150),
                new Student("남자바", true, 1, 2, 100),
                new Student("안지미", false, 1, 2, 50),
                new Student("황지미", false, 1, 3, 100),
                new Student("강지미", false, 1, 3, 150),
                new Student("이자바", true, 1, 3, 200),
                new Student("나자바", true, 2, 1, 300),
                new Student("김지미", false, 2, 1, 250),
                new Student("김자바", true, 2, 1, 200),
                new Student("이지미", false, 2, 2, 150),
                new Student("남자바", true, 2, 2, 100),
                new Student("안지미", false, 2, 2, 50),
                new Student("황지미", false, 2, 3, 100),
                new Student("강지미", false, 2, 3, 150),
                new Student("이자바", true, 2, 3, 200)
        };
    }

    public void quiz1() {

    }

    public Map<Integer, Map<Integer, Integer>> quiz2() {
      
    }

  
    public static void main(String[] args) throws IOException {
        Main t = new Main();
        t.init();
        t.quiz1();
//        t.quiz2();

    }
}

문제 6.1

stuArr에서 불합격(150점 미만)한 학생의 수를 남자와 여자로 구별하여라. (Boolean, List)

문제 6.2

각 반별 총점을 학년 별로 나누어 구하여라 (Map<Integer, Map<Integer, Integer>>)

• 답

  import java.io.*;
  import java.util.*;
  import java.util.stream.Collectors;
  import java.util.stream.IntStream;
  import java.util.stream.Stream;
  
  import static java.util.stream.Collectors.*;
  
  public class Main {
  
      public static class Student {
  
          private String name;
          private boolean isMale; // 성별
          private int hak; // 학년
          private int ban; // 반
          private int score;
  
          public Student(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);
          }
  
          // groupingBy()에서 사용 성적을 상,중,하 세 단계로 분류
          enum Level {
              HIGH, MID, LOW
          }
  
      }
  
      private Student[] stuArr;
  
      private void init() {
          stuArr = new Student[]{
                  new Student("나자바", true, 1, 1, 300),
                  new Student("김지미", false, 1, 1, 250),
                  new Student("김자바", true, 1, 1, 200),
                  new Student("이지미", false, 1, 2, 150),
                  new Student("남자바", true, 1, 2, 100),
                  new Student("안지미", false, 1, 2, 50),
                  new Student("황지미", false, 1, 3, 100),
                  new Student("강지미", false, 1, 3, 150),
                  new Student("이자바", true, 1, 3, 200),
                  new Student("나자바", true, 2, 1, 300),
                  new Student("김지미", false, 2, 1, 250),
                  new Student("김자바", true, 2, 1, 200),
                  new Student("이지미", false, 2, 2, 150),
                  new Student("남자바", true, 2, 2, 100),
                  new Student("안지미", false, 2, 2, 50),
                  new Student("황지미", false, 2, 3, 100),
                  new Student("강지미", false, 2, 3, 150),
                  new Student("이자바", true, 2, 3, 200)
          };
      }
  
      public void quiz1() {
          Map<Boolean, List<Student>> map = new HashMap<Boolean, List<Student>>();
  
  //        Stream.of(stuArr)
  //                .filter(s->s.getScore() < 150)
  //                .forEach(s-> map.merge(s.isMale(),new ArrayList<Student>(), (oldValue,newValue) -> {
  //                    oldValue.add(s);
  //                    return oldValue;
  //                }));
  //        map.keySet().forEach(k-> map.get(k).forEach(System.out::println));
          Map<Boolean, Map<Boolean, Long>> failedStuBySex = Stream.of(stuArr)
  
                  .collect(
  
                          partitioningBy(
  
                                  Student::isMale,
  
                                  partitioningBy(s -> s.getScore() < 150, counting())
  
                          )
  
                  );
  
          long failedMaleStuNum = failedStuBySex.get(true).get(true);
  
          long failedFemaleStuNum = failedStuBySex.get(false).get(true);
  
          System.out.println("불합격[남자]:" + failedMaleStuNum + "명");
  
          System.out.println("불합격[여자]:" + failedFemaleStuNum + "명");
      }
  
      public Map<Integer, Map<Integer, Integer>> quiz2() {
          Map<Integer, Map<Integer, Integer>> map;
          map = Stream.of(stuArr)
                  .collect(groupingBy(Student::getHak, groupingBy(Student::getBan, summingInt(Student::getScore))));
  
          System.out.println(map);
          return map;
      }
  
      public static void main(String[] args) throws IOException {
          Main t = new Main();
          t.init();
          t.quiz1();
          t.quiz2();
  
      }
  }