S11L14 - 몇 가지 더 할 것 - 섹션 정리

html

Java 컬렉션 마스터하기: Sets, Lists, 그리고 효율적인 검색
목차

소개 ............................................................... 1
Java Sets 이해하기 .................................... 3
Set을 List로 변환하기 ................................... 6
Java에서 Lists 정렬하기 ........................................ 9
Binary Search 구현하기 .......................... 12
컬렉션에서 사용자 정의 객체 다루기 .................................................... 16
결론 ................................................................. 21


소개
Java Collections Framework은 효과적인 Java 프로그래밍의 초석으로, 데이터 그룹을 저장하고 조작하기 위한 클래스 및 인터페이스 집합을 제공합니다. 가장 일반적으로 사용되는 컬렉션 중에는 Sets와 Lists가 있으며, 각각 고유한 목적을 수행하고 독특한 기능을 제공합니다. 이러한 컬렉션을 효과적으로 활용하고, 컬렉션 간 전환하며, 정렬 및 검색과 같은 작업을 수행하는 방법을 이해하는 것은 초보자와 숙련된 개발자 모두에게 필수적입니다.
이 전자책에서는 Java Sets and Lists의 복잡한 부분을 깊이 있게 파고들어, Sets를 사용하여 중복 값을 제거하고, 순서가 필요한 작업을 위해 Sets를 Lists로 변환하며, 데이터를 효율적으로 정렬하고, 빠른 데이터 검색을 위해 binary search를 구현하는 방법을 탐구합니다. 또한, 이러한 컬렉션 내에서 사용자 정의 객체를 다루는 방법을 살펴보아 데이터 무결성과 최적의 성능을 보장합니다.


장
페이지 수


소개
1


Java Sets 이해하기
3


Set을 List로 변환하기
6


Java에서 Lists 정렬하기
9


Binary Search 구현하기
12


컬렉션에서 사용자 정의 객체 다루기
16


결론
21



Java Sets 이해하기
Set이란?
Java의 Set은 중복 요소를 허용하지 않는 컬렉션입니다. 이는 수학적 집합 추상을 모델링하며, Java Collections Framework의 일부입니다. 요소의 고유성이 우선일 때 Sets는 특히 유용합니다.
Set의 주요 특징

중복 없음: 각 요소가 고유함을 보장합니다.
순서 없음: 요소의 순서를 보장하지 않습니다 (LinkedHashSet 같은 특정 구현을 제외하고).
효율적인 연산: 해시 함수가 요소를 적절히 분산한다고 가정할 때, add, remove, contains와 같은 기본 연산에 대해 상수 시간 성능을 제공합니다.

일반적인 Set 구현

HashSet: 가장 일반적으로 사용되는 Set 구현입니다. 해시 테이블에 의해 지원되며 기본 연산에 대해 상수 시간 성능을 제공합니다.
LinkedHashSet: Set 내의 항목들에 대한 연결 리스트를 유지하여 삽입 순서를 보존합니다.
TreeSet: SortedSet 인터페이스를 구현하며, 요소를 정렬된 트리 구조로 저장합니다.

Set을 사용해야 할 때

중복 제거: 고유한 요소를 저장해야 할 때.
소속 테스트: 컬렉션에 요소가 존재하는지 효율적으로 확인할 때.
수학적 집합 연산: 합집합, 교집합, 차집합을 수행할 때.

Set 사용의 장단점


장점
단점


요소의 고유성을 보장합니다
요소의 순서를 제어할 수 없습니다


일반적으로 빠른 성능을 제공합니다
Lists에 비해 메모리 소비가 높습니다


수학적 집합 연산에 적합합니다
Lists에 비해 인터페이스가 제한적입니다



Set을 List로 변환하기
Set을 List로 변환하는 이유
Sets는 고유성을 보장하는 데 탁월하지만, Lists는 순서가 있는 컬렉션을 제공하며 중복 요소를 허용합니다. Set을 List로 변환하면 정렬이나 binary search와 같이 순서 지정이나 인덱스 접근이 필요한 작업을 수행할 때 유용할 수 있습니다.
단계별 변환

Set 초기화:

    



		
		
			
			
Java
			
			Set<String> namesSet = new HashSet<>();
namesSet.add("John");
namesSet.add("Afia");
namesSet.add("Chand");
namesSet.add("John"); // 중복, 무시됩니다
			
				
					
				
					1
2
3
4
5
				
						Set<String> namesSet = new HashSet<>();
namesSet.add("John");
namesSet.add("Afia");
namesSet.add("Chand");
namesSet.add("John"); // 중복, 무시됩니다
					
				
			
		


  
Set을 List로 변환:

    



		
		
			
			
Java
			
			List<String> namesList = new ArrayList<>();
namesList.addAll(namesSet);
			
				
					
				
					1
2
				
						List<String> namesList = new ArrayList<>();
namesList.addAll(namesSet);
					
				
			
		



    또는 생성자를 사용하여:

    



		
		
			
			
Java
			
			List<String> namesList = new ArrayList<>(namesSet);
			
				
					
				
					1
				
						List<String> namesList = new ArrayList<>(namesSet);
					
				
			
		


  
변환 검증:

    



		
		
			
			
Java
			
			System.out.println(namesList);
// 출력: [John, Afia, Chand]
			
				
					
				
					1
2
				
						System.out.println(namesList);
// 출력: [John, Afia, Chand]
					
				
			
		


  

코드 예제




		
		
			
			
Java
			
			import java.util.*;

public class SetToListExample {
    public static void main(String[] args) {
        // Initialize a Set with duplicate values
        Set<String> namesSet = new HashSet<>();
        namesSet.add("John");
        namesSet.add("Afia");
        namesSet.add("Chand");
        namesSet.add("John"); // Duplicate entry

        // Convert Set to List
        List<String> namesList = new ArrayList<>();
        namesList.addAll(namesSet);

        // Display the List
        System.out.println("List after converting from Set: " + namesList);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						import java.util.*;
 
public class SetToListExample {
    public static void main(String[] args) {
        // Initialize a Set with duplicate values
        Set<String> namesSet = new HashSet<>();
        namesSet.add("John");
        namesSet.add("Afia");
        namesSet.add("Chand");
        namesSet.add("John"); // Duplicate entry
 
        // Convert Set to List
        List<String> namesList = new ArrayList<>();
        namesList.addAll(namesSet);
 
        // Display the List
        System.out.println("List after converting from Set: " + namesList);
    }
}
					
				
			
		


출력:




		
		
			
			
Java
			
			List after converting from Set: [John, Afia, Chand]
			
				
					
				
					1
				
						List after converting from Set: [John, Afia, Chand]
					
				
			
		


핵심 요점

중복 제거: 변환 중, Set에 존재했던 중복은 자동으로 제거됩니다.
유연성: 변환 후에 Lists는 순서가 있는 작업을 위해 더 많은 유연성을 제공합니다.
성능: 변환은 일반적으로 효율적이지만, 사용 사례에 따라 적절한 데이터 구조를 선택하는 것이 중요합니다.


Java에서 Lists 정렬하기
정렬의 중요성
정렬은 데이터를 지정된 순서로 조직화하는 기본적인 작업으로, 검색 및 인덱싱과 같은 다른 작업의 효율성을 향상시킵니다. Java는 Lists를 손쉽게 정렬할 수 있는 강력한 메커니즘을 제공합니다.
문자열 List 정렬하기
Collections.sort() 메서드를 사용하면, 문자열의 List를 자연 순서 (알파벳 순서)로 정렬할 수 있습니다.




		
		
			
			
Java
			
			List<String> namesList = new ArrayList<>(Arrays.asList("John", "Afia", "Chand"));
Collections.sort(namesList);
System.out.println("Sorted List: " + namesList);
			
				
					
				
					1
2
3
				
						List<String> namesList = new ArrayList<>(Arrays.asList("John", "Afia", "Chand"));
Collections.sort(namesList);
System.out.println("Sorted List: " + namesList);
					
				
			
		


출력:




		
		
			
			
Java
			
			Sorted List: [Afia, Chand, John]
			
				
					
				
					1
				
						Sorted List: [Afia, Chand, John]
					
				
			
		


사용자 정의 객체의 List 정렬하기
사용자 정의 객체의 List를 정렬하려면, 객체들이 Comparable 인터페이스를 구현해야 하거나 Comparator가 제공되어야 합니다.
Comparable 구현하기

클래스 생성:

    



		
		
			
			
Java
			
			public class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }

    @Override
    public String toString() {
        return this.name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						public class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
 
    @Override
    public String toString() {
        return this.name;
    }
}
					
				
			
		


  
List 정렬하기:

    



		
		
			
			
Java
			
			List<Name> nameList = new ArrayList<>();
nameList.add(new Name("John"));
nameList.add(new Name("Afia"));
nameList.add(new Name("Chand"));

Collections.sort(nameList);
System.out.println("Sorted Name List: " + nameList);
			
				
					
				
					1
2
3
4
5
6
7
				
						List<Name> nameList = new ArrayList<>();
nameList.add(new Name("John"));
nameList.add(new Name("Afia"));
nameList.add(new Name("Chand"));
 
Collections.sort(nameList);
System.out.println("Sorted Name List: " + nameList);
					
				
			
		


  

출력:




		
		
			
			
Java
			
			Sorted Name List: [Afia, Chand, John]
			
				
					
				
					1
				
						Sorted Name List: [Afia, Chand, John]
					
				
			
		


코드 예제




		
		
			
			
Java
			
			import java.util.*;

class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // Implement compareTo for natural ordering
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }

    @Override
    public String toString() {
        return this.name;
    }
}

public class SortingExample {
    public static void main(String[] args) {
        // Create a list of Name objects
        List<Name> nameList = new ArrayList<>();
        nameList.add(new Name("John"));
        nameList.add(new Name("Afia"));
        nameList.add(new Name("Chand"));

        // Sort the list
        Collections.sort(nameList);

        // Display the sorted list
        System.out.println("Sorted Name List: " + nameList);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
				
						import java.util.*;
 
class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    // Implement compareTo for natural ordering
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
 
    @Override
    public String toString() {
        return this.name;
    }
}
 
public class SortingExample {
    public static void main(String[] args) {
        // Create a list of Name objects
        List<Name> nameList = new ArrayList<>();
        nameList.add(new Name("John"));
        nameList.add(new Name("Afia"));
        nameList.add(new Name("Chand"));
 
        // Sort the list
        Collections.sort(nameList);
 
        // Display the sorted list
        System.out.println("Sorted Name List: " + nameList);
    }
}
					
				
			
		


출력:




		
		
			
			
Java
			
			Sorted Name List: [Afia, Chand, John]
			
				
					
				
					1
				
						Sorted Name List: [Afia, Chand, John]
					
				
			
		


핵심 요점

자연 순서: Comparable을 구현하면 객체를 자연 속성에 기반하여 정렬할 수 있습니다.
사용자 정의 정렬: 객체의 클래스를 수정하지 않고 유연한 정렬 기준을 위해 Comparator를 사용합니다.
효율성: Collections.sort()는 성능을 최적화하여 대규모 데이터셋에 적합합니다.


Binary Search 구현하기
Binary Search란?
Binary search는 정렬된 항목 목록에서 항목을 찾기 위한 효율적인 알고리즘입니다. 검색 간격을 반복적으로 절반으로 나누어 시간 복잡도를 O(log n)으로 줄여 대규모 데이터셋에서 선형 검색보다 훨씬 빠릅니다.
Binary Search의 전제 조건

정렬된 List: binary search를 수행하기 전에 리스트가 오름차순 또는 내림차순으로 정렬되어 있어야 합니다.
랜덤 접근: 리스트는 요소에 대한 빠른 랜덤 접근을 지원해야 합니다 (예: ArrayList).

Java에서 Binary Search 수행하기
Java는 List에서 binary search를 수행하기 위해 Collections.binarySearch() 메서드를 제공합니다.




		
		
			
			
Java
			
			import java.util.*;

public class BinarySearchExample {
    public static void main(String[] args) {
        List<String> namesList = new ArrayList<>(Arrays.asList("Afia", "Chand", "John"));
        Collections.sort(namesList); // Ensure the list is sorted

        // Search for an existing element
        int index = Collections.binarySearch(namesList, "John");
        System.out.println("Index of John: " + index); // Output: 2

        // Search for a non-existing element
        int negativeIndex = Collections.binarySearch(namesList, "john"); // Case-sensitive
        System.out.println("Index of john: " + negativeIndex); // Output: -4
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						import java.util.*;
 
public class BinarySearchExample {
    public static void main(String[] args) {
        List<String> namesList = new ArrayList<>(Arrays.asList("Afia", "Chand", "John"));
        Collections.sort(namesList); // Ensure the list is sorted
 
        // Search for an existing element
        int index = Collections.binarySearch(namesList, "John");
        System.out.println("Index of John: " + index); // Output: 2
 
        // Search for a non-existing element
        int negativeIndex = Collections.binarySearch(namesList, "john"); // Case-sensitive
        System.out.println("Index of john: " + negativeIndex); // Output: -4
    }
}
					
				
			
		


출력:




		
		
			
			
Java
			
			Index of John: 2
Index of john: -4
			
				
					
				
					1
2
				
						Index of John: 2
Index of john: -4
					
				
			
		


출력 이해하기

양수 인덱스: 리스트 내에서 요소의 위치를 나타냅니다.
음수 인덱스: 요소가 존재하지 않음을 나타냅니다. -4는 "john"이 삽입된다면 인덱스 3 위치에 삽입될 것임을 의미합니다 (-(-4) - 1 = 3).

사용자 정의 객체를 포함한 코드 예제




		
		
			
			
Java
			
			import java.util.*;

class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }

    @Override
    public String toString() {
        return this.name;
    }
}

public class BinarySearchCustomObject {
    public static void main(String[] args) {
        List<Name> nameList = new ArrayList<>();
        nameList.add(new Name("Afia"));
        nameList.add(new Name("Chand"));
        nameList.add(new Name("John"));

        // Ensure the list is sorted
        Collections.sort(nameList);

        // Search for an existing object
        Name searchName = new Name("John");
        int index = Collections.binarySearch(nameList, searchName);
        System.out.println("Index of John: " + index); // Output: 2

        // Search for a non-existing object
        Name nonExistingName = new Name("john"); // Case-sensitive
        int negativeIndex = Collections.binarySearch(nameList, nonExistingName);
        System.out.println("Index of john: " + negativeIndex); // Output: -4
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
				
						import java.util.*;
 
class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
 
    @Override
    public String toString() {
        return this.name;
    }
}
 
public class BinarySearchCustomObject {
    public static void main(String[] args) {
        List<Name> nameList = new ArrayList<>();
        nameList.add(new Name("Afia"));
        nameList.add(new Name("Chand"));
        nameList.add(new Name("John"));
 
        // Ensure the list is sorted
        Collections.sort(nameList);
 
        // Search for an existing object
        Name searchName = new Name("John");
        int index = Collections.binarySearch(nameList, searchName);
        System.out.println("Index of John: " + index); // Output: 2
 
        // Search for a non-existing object
        Name nonExistingName = new Name("john"); // Case-sensitive
        int negativeIndex = Collections.binarySearch(nameList, nonExistingName);
        System.out.println("Index of john: " + negativeIndex); // Output: -4
    }
}
					
				
			
		


출력:




		
		
			
			
Java
			
			Index of John: 2
Index of john: -4
			
				
					
				
					1
2
				
						Index of John: 2
Index of john: -4
					
				
			
		


핵심 요점

효율성: Binary search는 대규모, 정렬된 리스트에서 검색 시간을 크게 줄여줍니다.
대소문자 구분: 검색은 대소문자를 구분합니다. 검색 시 일관된 대소문자 사용을 보장하세요.
사용자 정의 객체: Lists의 사용자 정의 객체에 대해 binary search를 수행하려면 Comparable을 구현하세요.


컬렉션에서 사용자 정의 객체 다루기
equals와 hashCode를 오버라이드하는 것의 중요성
Set이나 Map의 키로 사용자 정의 객체를 사용할 때, equals와 hashCode 메서드를 오버라이드하는 것이 중요합니다. 이러한 메서드는 컬렉션이 중복 요소를 정확하게 식별하고 객체의 고유성을 관리할 수 있도록 보장합니다.
equals와 hashCode 구현하기




		
		
			
			
Java
			
			public class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // Overriding toString for meaningful output
    @Override
    public String toString() {
        return this.name;
    }

    // Overriding equals to compare Name objects based on the 'name' field
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Name name1 = (Name) o;

        return name != null ? name.equals(name1.name) : name1.name == null;
    }

    // Overriding hashCode to align with equals
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    // Implementing Comparable for sorting
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
				
						public class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    // Overriding toString for meaningful output
    @Override
    public String toString() {
        return this.name;
    }
 
    // Overriding equals to compare Name objects based on the 'name' field
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
 
        Name name1 = (Name) o;
 
        return name != null ? name.equals(name1.name) : name1.name == null;
    }
 
    // Overriding hashCode to align with equals
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }
 
    // Implementing Comparable for sorting
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}
					
				
			
		


Set에서 사용자 정의 객체 사용하기




		
		
			
			
Java
			
			import java.util.*;

public class CustomObjectSet {
    public static void main(String[] args) {
        Set<Name> namesSet = new HashSet<>();
        namesSet.add(new Name("John"));
        namesSet.add(new Name("Afia"));
        namesSet.add(new Name("Chand"));
        namesSet.add(new Name("John")); // 중복, 무시됩니다

        System.out.println("Set Contents: " + namesSet);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						import java.util.*;
 
public class CustomObjectSet {
    public static void main(String[] args) {
        Set<Name> namesSet = new HashSet<>();
        namesSet.add(new Name("John"));
        namesSet.add(new Name("Afia"));
        namesSet.add(new Name("Chand"));
        namesSet.add(new Name("John")); // 중복, 무시됩니다
 
        System.out.println("Set Contents: " + namesSet);
    }
}
					
				
			
		


출력:




		
		
			
			
Java
			
			Set Contents: [Afia, Chand, John]
			
				
					
				
					1
				
						Set Contents: [Afia, Chand, John]
					
				
			
		


Comparable 인터페이스 구현하기
Comparable 인터페이스를 구현하면 사용자 정의 객체가 자연 순서를 가지게 되어, 정렬 및 binary search와 같은 작업을 수행할 수 있습니다.




		
		
			
			
Java
			
			@Override
public int compareTo(Name o) {
    return this.name.compareTo(o.getName());
}
			
				
					
				
					1
2
3
4
				
						@Override
public int compareTo(Name o) {
    return this.name.compareTo(o.getName());
}
					
				
			
		


실수 및 방지 방법

hashCode를 오버라이드하는 것을 잊는 경우:

문제: 해시 기반 컬렉션에서 예기치 않은 동작을 초래합니다.
해결책: equals를 오버라이드할 때는 항상 hashCode도 오버라이드하세요.


equals와 hashCode가 일관되지 않은 경우:

문제: 컬렉션이 예측할 수 없게 동작합니다.
해결책: 두 객체가 equals()에 따라 같다면, 동일한 hashCode()를 가져야 합니다.


잘못된 compareTo 구현:

문제: 잘못된 정렬 또는 검색 동작을 초래합니다.
해결책: compareTo가 객체의 자연 순서를 반영하는지 확인하세요.



주석이 포함된 코드 예제




		
		
			
			
Java
			
			import java.util.*;

class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // Overriding toString for meaningful output
    @Override
    public String toString() {
        return this.name;
    }

    // Overriding equals to compare Name objects based on the 'name' field
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Name name1 = (Name) o;

        return name != null ? name.equals(name1.name) : name1.name == null;
    }

    // Overriding hashCode to align with equals
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    // Implementing Comparable for natural ordering based on 'name'
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}

public class CustomObjectCollection {
    public static void main(String[] args) {
        // Creating a Set of Name objects
        Set<Name> namesSet = new HashSet<>();
        namesSet.add(new Name("John"));
        namesSet.add(new Name("Afia"));
        namesSet.add(new Name("Chand"));
        namesSet.add(new Name("John")); // 중복, 무시됩니다 <em>equals</em>와 <em>hashCode</em>를 오버라이드했기 때문입니다.

        System.out.println("Set Contents: " + namesSet);

        // Converting Set to List for ordered operations
        List<Name> namesList = new ArrayList<>(namesSet);
        Collections.sort(namesList); // 리스트 정렬

        System.out.println("Sorted List: " + namesList);

        // Performing binary search
        Name searchName = new Name("John");
        int index = Collections.binarySearch(namesList, searchName);
        System.out.println("Index of John: " + index);

        // Searching for a non-existing name
        Name nonExisting = new Name("john"); // 대소문자 구분 검색
        int negativeIndex = Collections.binarySearch(namesList, nonExisting);
        System.out.println("Index of john: " + negativeIndex);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
				
						import java.util.*;
 
class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    // Overriding toString for meaningful output
    @Override
    public String toString() {
        return this.name;
    }
 
    // Overriding equals to compare Name objects based on the 'name' field
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
 
        Name name1 = (Name) o;
 
        return name != null ? name.equals(name1.name) : name1.name == null;
    }
 
    // Overriding hashCode to align with equals
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }
 
    // Implementing Comparable for natural ordering based on 'name'
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}
 
public class CustomObjectCollection {
    public static void main(String[] args) {
        // Creating a Set of Name objects
        Set<Name> namesSet = new HashSet<>();
        namesSet.add(new Name("John"));
        namesSet.add(new Name("Afia"));
        namesSet.add(new Name("Chand"));
        namesSet.add(new Name("John")); // 중복, 무시됩니다 <em>equals</em>와 <em>hashCode</em>를 오버라이드했기 때문입니다.
 
        System.out.println("Set Contents: " + namesSet);
 
        // Converting Set to List for ordered operations
        List<Name> namesList = new ArrayList<>(namesSet);
        Collections.sort(namesList); // 리스트 정렬
 
        System.out.println("Sorted List: " + namesList);
 
        // Performing binary search
        Name searchName = new Name("John");
        int index = Collections.binarySearch(namesList, searchName);
        System.out.println("Index of John: " + index);
 
        // Searching for a non-existing name
        Name nonExisting = new Name("john"); // 대소문자 구분 검색
        int negativeIndex = Collections.binarySearch(namesList, nonExisting);
        System.out.println("Index of john: " + negativeIndex);
    }
}
					
				
			
		


출력:




		
		
			
			
Java
			
			Set Contents: [Afia, Chand, John]
Sorted List: [Afia, Chand, John]
Index of John: 2
Index of john: -4
			
				
					
				
					1
2
3
4
				
						Set Contents: [Afia, Chand, John]
Sorted List: [Afia, Chand, John]
Index of John: 2
Index of john: -4
					
				
			
		


핵심 요점

데이터 무결성: equals와 hashCode를 오버라이드하면 컬렉션이 객체를 올바르게 처리할 수 있습니다.
자연 순서: Comparable을 구현하면 정렬 및 검색 작업을 용이하게 합니다.
일반적인 실수 피하기: 이러한 메서드를 올바르게 구현하면 미묘한 버그를 방지하고 컬렉션에서 예측 가능한 동작을 보장합니다.


결론
Java Collections, 특히 Sets와 Lists를 마스터하는 것은 효율적이고 견고한 Java 애플리케이션을 구축하는 데 기본적입니다. Sets를 사용하여 중복을 제거하고, Sets과 Lists 간 전환하며, 데이터를 효과적으로 정렬하고, binary search와 같은 효율적인 검색 알고리즘을 구현함으로써 개발자는 성능과 유지보수성을 모두 최적화할 수 있습니다.
더욱이, 컬렉션에서 사용자 정의 객체를 다루는 것은 equals, hashCode를 오버라이드하고 Comparable 인터페이스를 구현하는 명확한 이해를 필요로 하며, 이는 데이터 무결성을 보장하고 원활한 작업을 가능하게 합니다. 이러한 관행은 Java 애플리케이션의 기능을 향상시킬 뿐만 아니라 더 깔끔하고 읽기 쉬운 코드를 작성하는 데 기여합니다.
핵심 요점

Sets vs. Lists: 고유한 요소를 위해 Sets를 사용하고, 순서가 있는 인덱스 컬렉션을 위해 Lists를 사용하세요.
전환: Sets과 Lists 간의 전환을 통해 두 가지의 강점을 쉽게 활용할 수 있습니다.
정렬 및 검색: 효율적인 데이터 조작을 위해 Collections.sort()와 Collections.binarySearch()를 활용하세요.
사용자 정의 객체: 컬렉션과 원활하게 작업하기 위해 equals, hashCode를 올바르게 오버라이드하고 Comparable을 구현하세요.

이러한 개념을 수용하면 데이터를 보다 효과적으로 다룰 수 있어 고품질의 Java 애플리케이션을 개발하는 데 도움이 될 것입니다.
Keywords: Java Collections, Set, List, binary search, Collections.sort, Comparable interface, equals and hashCode, Java 프로그래밍, 데이터 구조, ArrayList, HashSet, 정렬 알고리즘, 검색 알고리즘, Java의 사용자 정의 객체, 데이터 무결성, Java 튜토리얼, 효율적인 Java 코딩

참고: 이 기사는 AI가 생성했습니다.
S11L14 – 몇 가지 더 할 것 – 섹션 정리

Java 컬렉션 마스터하기: Sets, Lists, 그리고 효율적인 검색

목차

소개

Java Sets 이해하기

Set이란?

Set의 주요 특징

일반적인 Set 구현

Set을 사용해야 할 때

Set 사용의 장단점

Set을 List로 변환하기

Set을 List로 변환하는 이유

단계별 변환

코드 예제

핵심 요점

Java에서 Lists 정렬하기

정렬의 중요성

문자열 List 정렬하기

사용자 정의 객체의 List 정렬하기

Comparable 구현하기

코드 예제

핵심 요점

Binary Search 구현하기

Binary Search란?

Binary Search의 전제 조건

Java에서 Binary Search 수행하기

출력 이해하기

사용자 정의 객체를 포함한 코드 예제

핵심 요점

컬렉션에서 사용자 정의 객체 다루기

`equals`와 `hashCode`를 오버라이드하는 것의 중요성

`equals`와 `hashCode` 구현하기

Set에서 사용자 정의 객체 사용하기

Comparable 인터페이스 구현하기

실수 및 방지 방법

주석이 포함된 코드 예제

핵심 요점

결론

핵심 요점

장점	단점
요소의 고유성을 보장합니다	요소의 순서를 제어할 수 없습니다
일반적으로 빠른 성능을 제공합니다	Lists에 비해 메모리 소비가 높습니다
수학적 집합 연산에 적합합니다	Lists에 비해 인터페이스가 제한적입니다