## 과제_1 : 백준 문제 풀이

목표 : 백준 문제를 풀어본다.

- [네트워크 연결](https://www.acmicpc.net/problem/1922)

## 과제_2 : Java Stream을 사용해보자

1. **리스트의 모든 요소를 정수로 변환**
주어진 문자열 리스트가 있을 때, 이 리스트의 모든 요소를 정수로 변환하고 새로운 리스트로 반환하는 Java Stream을 작성해보자.

2. **짝수만 필터링**
주어진 정수 리스트가 있을 때, 이 리스트에서 짝수만 필터링하여 새로운 리스트를 만드는 Java Stream을 작성해보자.

3. **리스트의 합계 계산**
주어진 정수 리스트가 있을 때, 이 리스트의 모든 요소의 합계를 계산하는 Java Stream을 작성해보자.

4. **리스트의 최소값 찾기**
주어진 정수 리스트에서 최소값을 찾는 Java Stream을 작성해보자.

5. **문자열 리스트 정렬**
주어진 문자열 리스트를 알파벳 순서대로 정렬하는 Java Stream을 작성해보자.

6. **객체 리스트에서 특정 필드 값의 평균 계산**
"age"라는 정수 필드가 포함된 객체를 만들고, 그 객체의 리스트가 있을 때, 이 리스트에서 모든 "age" 값의 평균을 계산하는 Java Stream을 작성해보자.

---

## 과제_1 : 백준 문제 풀이 모범답안

import java.util.*;

public class Main {
    // Union-Find 자료구조를 위한 클래스
    static class UnionFind {
        private int[] parent;

        public UnionFind(int size) {
            parent = new int[size];
            for (int i = 0; i < size; i++) {
                parent[i] = i;
            }
        }

        public int find(int x) {
            if (parent[x] == x) {
                return x;
            } else {
                return parent[x] = find(parent[x]);
            }
        }

        public void union(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);
            if (rootX != rootY) {
                parent[rootY] = rootX;
            }
        }
    }

    // 간선을 표현하기 위한 클래스
    static class Edge implements Comparable<Edge> {
        int src, dest, weight;

        public Edge(int src, int dest, int weight) {
            this.src = src;
            this.dest = dest;
            this.weight = weight;
        }

        @Override
        public int compareTo(Edge o) {
            return Integer.compare(this.weight, o.weight);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();  // 컴퓨터의 수
        int M = sc.nextInt();  // 연결할 수 있는 선의 수
        List<Edge> edges = new ArrayList<>();

        for (int i = 0; i < M; i++) {
            int a = sc.nextInt() - 1;  // 1번 컴퓨터부터 시작하는 인덱스를 0번 인덱스로 맞추기
            int b = sc.nextInt() - 1;
            int c = sc.nextInt();
            edges.add(new Edge(a, b, c));
        }

        // 간선을 비용에 따라 오름차순으로 정렬
        Collections.sort(edges);

        // 크루스칼 알고리즘 실행
        UnionFind uf = new UnionFind(N);
        int totalCost = 0;
        int edgeCount = 0;

        for (Edge edge : edges) {
            if (uf.find(edge.src) != uf.find(edge.dest)) {
                uf.union(edge.src, edge.dest);
                totalCost += edge.weight;
                edgeCount++;
                if (edgeCount == N - 1) break;  // 최소 신장 트리 완성 조건
            }
        }

        System.out.println(totalCost);
        sc.close();
    }
}

## 과제_2 : Java Stream을 사용해보자 모범답안

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

public class Main {
    public static void main(String[] args) {
        // 1. 리스트의 모든 요소를 정수로 변환
        List<String> strList = Arrays.asList("1", "2", "3", "4", "5");
        List<Integer> intList = strList.stream()
                .map(Integer::parseInt)
                .collect(Collectors.toList());
        System.out.println(intList);

        // 2. 짝수만 필터링
        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> evenList = numList.stream()
                .filter(num -> num % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(evenList);

        // 3. 리스트의 합계 계산
        int sum = numList.stream()
                .mapToInt(Integer::intValue)
                .sum();
        System.out.println(sum);

        // 4. 리스트의 최소값 찾기
        int min = numList.stream()
                .min(Integer::compareTo)
                .orElse(0);
        System.out.println(min);

        // 5. 문자열 리스트 정렬
        List<String> strList2 = Arrays.asList("banana", "apple", "cherry", "date");
        List<String> sortedList = strList2.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedList);

        // 6. 객체 리스트에서 특정 필드 값의 평균 계산
        class Person {
            private int age;

            public Person(int age) {
                this.age = age;
            }

            public int getAge() {
                return age;
            }
        }

        List<Person> personList = Arrays.asList(
                new Person(20),
                new Person(30),
                new Person(40),
                new Person(50),
                new Person(60)
        );

        double avg = personList.stream()
                .mapToInt(Person::getAge)
                .average()
                .orElse(0);
        System.out.println(avg);
    }
}