S11L14 - 还有几件事 - 本节总结

html

掌握 Java 集合：Sets、Lists 和高效搜索
目录

介绍 ............................................................... 1
理解 Java Sets .................................... 3
将 Set 转换为 List ................................... 6
在 Java 中排序 Lists ........................................ 9
实现二分搜索 .......................... 12
在集合中处理自定义对象 .................................................... 16
结论 ................................................................. 21


介绍
Java Collections Framework 是高效 Java 编程的基石，提供了一组用于存储和操作数据组的类和接口。在最常用的集合中，Sets 和 Lists 各自服务于不同的目的，并提供独特的功能。理解如何有效地利用这些集合、在它们之间转换，以及执行排序和搜索等操作，对于初学者和有经验的开发者来说都是至关重要的。
在本电子书中，我们深入探讨了 Java Sets 和 Lists 的复杂性，探索如何使用 Sets 消除重复值，将 Sets 转换为 Lists 以进行有序操作，有效地排序数据，以及实现二分搜索以快速检索数据。此外，我们还将研究如何在这些集合中处理自定义对象，确保数据的完整性和最佳性能。


章节
页码


介绍
1


理解 Java Sets
3


将 Set 转换为 List
6


在 Java 中排序 Lists
9


实现二分搜索
12


在集合中处理自定义对象
16


结论
21



理解 Java Sets
什么是 Set？
Java 中的 Set 是一种不允许重复元素的集合。它模拟了数学中的集合抽象，是 Java Collections Framework 的一部分。当元素的唯一性是优先考虑时，Sets 特别有用。
Sets 的主要特性

无重复：确保每个元素都是唯一的。
无序：不保证元素的顺序（特定实现如 LinkedHashSet 除外）。
高效操作：在基本操作如添加、移除和包含时提供常数时间性能，前提是哈希函数能适当地分散元素。

常见的 Set 实现

HashSet：最常用的 Set 实现。它由哈希表支持，并在基本操作上提供常数时间性能。
LinkedHashSet：维护集合中条目的链表，保留插入顺序。
TreeSet：实现了 SortedSet 接口，并以排序的树结构存储元素。

何时使用 Set

消除重复：当需要存储唯一元素时。
成员测试：高效地检查集合中是否存在某个元素。
数学集合操作：执行并集、交集和差集。

使用 Set 的优缺点


优点
缺点


确保元素的唯一性
无法控制元素的顺序


通常提供快速性能
相比 Lists，内存消耗较高


适合数学集合操作
相比 Lists，接口较为有限



将 Set 转换为 List
为什么将 Set 转换为 List？
虽然 Sets 在确保唯一性方面表现出色，但 Lists 提供了有序集合并允许重复元素。将 Set 转换为 List 在需要进行排序或二分搜索等需要有序或索引访问的操作时非常有用。
逐步转换

初始化一个 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) {
        // 初始化一个包含重复值的 Set
        Set<String> namesSet = new HashSet<>();
        namesSet.add("John");
        namesSet.add("Afia");
        namesSet.add("Chand");
        namesSet.add("John"); // 重复条目

        // 将 Set 转换为 List
        List<String> namesList = new ArrayList<>();
        namesList.addAll(namesSet);

        // 显示 List
        System.out.println("从 Set 转换后的 List: " + 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) {
        // 初始化一个包含重复值的 Set
        Set<String> namesSet = new HashSet<>();
        namesSet.add("John");
        namesSet.add("Afia");
        namesSet.add("Chand");
        namesSet.add("John"); // 重复条目
 
        // 将 Set 转换为 List
        List<String> namesList = new ArrayList<>();
        namesList.addAll(namesSet);
 
        // 显示 List
        System.out.println("从 Set 转换后的 List: " + namesList);
    }
}
					
				
			
		


输出:




		
		
			
			
Java
			
			从 Set 转换后的 List: [John, Afia, Chand]
			
				
					
				
					1
				
						从 Set 转换后的 List: [John, Afia, Chand]
					
				
			
		


关键要点

消除重复：在转换过程中，如果 Set 中存在重复项，它们将被自动移除。
灵活性：List 在转换后为有序操作提供了更多的灵活性。
性能：转换通常是高效的，但根据使用场景选择合适的数据结构非常重要。


在 Java 中排序 Lists
排序的重要性
排序是一项基本操作，它按指定顺序组织数据，提升了其他操作如搜索和索引的效率。Java 提供了强大的机制来轻松排序 Lists。
排序字符串列表
使用 Collections.sort() 方法，你可以按 自然（字母）顺序 对字符串列表进行排序。




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


输出:




		
		
			
			
Java
			
			排序后的 List: [Afia, Chand, John]
			
				
					
				
					1
				
						排序后的 List: [Afia, Chand, John]
					
				
			
		


排序自定义对象的列表
要对自定义对象的 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;
    }
}
					
				
			
		


  
排序列表:

    



		
		
			
			
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("排序后的 Name 列表: " + 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("排序后的 Name 列表: " + nameList);
					
				
			
		


  

输出:




		
		
			
			
Java
			
			排序后的 Name 列表: [Afia, Chand, John]
			
				
					
				
					1
				
						排序后的 Name 列表: [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;
    }

    // 实现 compareTo 以实现自然排序
    @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) {
        // 创建 Name 对象的列表
        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("排序后的 Name 列表: " + 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;
    }
 
    // 实现 compareTo 以实现自然排序
    @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) {
        // 创建 Name 对象的列表
        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("排序后的 Name 列表: " + nameList);
    }
}
					
				
			
		


输出:




		
		
			
			
Java
			
			排序后的 Name 列表: [Afia, Chand, John]
			
				
					
				
					1
				
						排序后的 Name 列表: [Afia, Chand, John]
					
				
			
		


关键要点

自然排序：实现 Comparable 允许基于自然属性对对象进行排序。
自定义排序：使用 Comparator 可以在不修改对象类的情况下进行灵活的排序标准。
效率：Collections.sort() 针对性能进行了优化，适用于大型数据集。


实现二分搜索
什么是二分搜索？
二分搜索是一种高效的算法，用于在已排序的项目列表中查找某个项目。它通过反复将搜索区间分为两半，将时间复杂度降低到O(log n)，对于大型数据集来说，这比线性搜索快得多。
二分搜索的先决条件

已排序的列表：在执行二分搜索之前，列表必须按升序或降序排序。
随机访问：列表应支持快速的随机访问元素（例如 ArrayList）。

在 Java 中执行二分搜索
Java 提供了 Collections.binarySearch() 方法来对 List 执行二分搜索。




		
		
			
			
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); // 确保列表已排序

        // 搜索存在的元素
        int index = Collections.binarySearch(namesList, "John");
        System.out.println("John 的索引: " + index); // 输出: 2

        // 搜索不存在的元素
        int negativeIndex = Collections.binarySearch(namesList, "john"); // 区分大小写
        System.out.println("john 的索引: " + negativeIndex); // 输出: -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); // 确保列表已排序
 
        // 搜索存在的元素
        int index = Collections.binarySearch(namesList, "John");
        System.out.println("John 的索引: " + index); // 输出: 2
 
        // 搜索不存在的元素
        int negativeIndex = Collections.binarySearch(namesList, "john"); // 区分大小写
        System.out.println("john 的索引: " + negativeIndex); // 输出: -4
    }
}
					
				
			
		


输出:




		
		
			
			
Java
			
			John 的索引: 2
john 的索引: -4
			
				
					
				
					1
2
				
						John 的索引: 2
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"));

        // 确保列表已排序
        Collections.sort(nameList);

        // 搜索存在的对象
        Name searchName = new Name("John");
        int index = Collections.binarySearch(nameList, searchName);
        System.out.println("John 的索引: " + index); // 输出: 2

        // 搜索不存在的对象
        Name nonExistingName = new Name("john"); // 区分大小写
        int negativeIndex = Collections.binarySearch(nameList, nonExistingName);
        System.out.println("john 的索引: " + negativeIndex); // 输出: -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"));
 
        // 确保列表已排序
        Collections.sort(nameList);
 
        // 搜索存在的对象
        Name searchName = new Name("John");
        int index = Collections.binarySearch(nameList, searchName);
        System.out.println("John 的索引: " + index); // 输出: 2
 
        // 搜索不存在的对象
        Name nonExistingName = new Name("john"); // 区分大小写
        int negativeIndex = Collections.binarySearch(nameList, nonExistingName);
        System.out.println("john 的索引: " + negativeIndex); // 输出: -4
    }
}
					
				
			
		


输出:




		
		
			
			
Java
			
			John 的索引: 2
john 的索引: -4
			
				
					
				
					1
2
				
						John 的索引: 2
john 的索引: -4
					
				
			
		


关键要点

效率：对于大型、已排序的列表，二分搜索显著减少了搜索时间。
区分大小写：搜索是区分大小写的。搜索时确保大小写一致。
自定义对象：实现 Comparable 以对自定义对象的 List 执行二分搜索。


在集合中处理自定义对象
重写 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;
    }

    // 重写 toString 以获得有意义的输出
    @Override
    public String toString() {
        return this.name;
    }

    // 重写 equals 方法，根据 'name' 字段比较 Name 对象
    @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;
    }

    // 重写 hashCode 方法以与 equals 保持一致
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    // 实现 Comparable 以进行排序
    @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;
    }
 
    // 重写 toString 以获得有意义的输出
    @Override
    public String toString() {
        return this.name;
    }
 
    // 重写 equals 方法，根据 'name' 字段比较 Name 对象
    @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;
    }
 
    // 重写 hashCode 方法以与 equals 保持一致
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }
 
    // 实现 Comparable 以进行排序
    @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 内容: " + 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 内容: " + namesSet);
    }
}
					
				
			
		


输出:




		
		
			
			
Java
			
			Set 内容: [Afia, Chand, John]
			
				
					
				
					1
				
						Set 内容: [Afia, Chand, John]
					
				
			
		


实现 Comparable 接口
实现 Comparable 接口允许自定义对象具有自然的排序顺序，这对于排序和二分搜索等操作至关重要。




		
		
			
			
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;
    }

    // 重写 toString 以获得有意义的输出
    @Override
    public String toString() {
        return this.name;
    }

    // 重写 equals 方法，根据 'name' 字段比较 Name 对象
    @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;
    }

    // 重写 hashCode 方法以与 equals 保持一致
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    // 实现 Comparable 以根据 'name' 进行自然排序
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}

public class CustomObjectCollection {
    public static void main(String[] args) {
        // 创建 Name 对象的 Set
        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")); // 重复，由于重写了 equals 和 hashCode，将被忽略

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

        // 将 Set 转换为 List 以进行有序操作
        List<Name> namesList = new ArrayList<>(namesSet);
        Collections.sort(namesList); // 排序列表

        System.out.println("排序后的 List: " + namesList);

        // 执行二分搜索
        Name searchName = new Name("John");
        int index = Collections.binarySearch(namesList, searchName);
        System.out.println("John 的索引: " + index);

        // 搜索不存在的名字
        Name nonExisting = new Name("john"); // 区分大小写搜索
        int negativeIndex = Collections.binarySearch(namesList, nonExisting);
        System.out.println("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;
    }
 
    // 重写 toString 以获得有意义的输出
    @Override
    public String toString() {
        return this.name;
    }
 
    // 重写 equals 方法，根据 'name' 字段比较 Name 对象
    @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;
    }
 
    // 重写 hashCode 方法以与 equals 保持一致
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }
 
    // 实现 Comparable 以根据 'name' 进行自然排序
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}
 
public class CustomObjectCollection {
    public static void main(String[] args) {
        // 创建 Name 对象的 Set
        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")); // 重复，由于重写了 equals 和 hashCode，将被忽略
 
        System.out.println("Set 内容: " + namesSet);
 
        // 将 Set 转换为 List 以进行有序操作
        List<Name> namesList = new ArrayList<>(namesSet);
        Collections.sort(namesList); // 排序列表
 
        System.out.println("排序后的 List: " + namesList);
 
        // 执行二分搜索
        Name searchName = new Name("John");
        int index = Collections.binarySearch(namesList, searchName);
        System.out.println("John 的索引: " + index);
 
        // 搜索不存在的名字
        Name nonExisting = new Name("john"); // 区分大小写搜索
        int negativeIndex = Collections.binarySearch(namesList, nonExisting);
        System.out.println("john 的索引: " + negativeIndex);
    }
}
					
				
			
		


输出:




		
		
			
			
Java
			
			Set 内容: [Afia, Chand, John]
排序后的 List: [Afia, Chand, John]
John 的索引: 2
john 的索引: -4
			
				
					
				
					1
2
3
4
				
						Set 内容: [Afia, Chand, John]
排序后的 List: [Afia, Chand, John]
John 的索引: 2
john 的索引: -4
					
				
			
		


关键要点

数据完整性：重写 equals 和 hashCode 确保集合正确处理对象。
自然排序：实现 Comparable 促进排序和搜索操作。
避免常见错误：正确实现这些方法可以防止微妙的错误，确保集合行为可预测。


结论
掌握 Java Collections，特别是 Sets 和 Lists，对于构建高效和稳健的 Java 应用程序至关重要。通过理解如何使用 Sets 消除重复、在 Sets 和 Lists 之间转换、有效地排序数据，以及实现高效的搜索算法如二分搜索，开发者可以优化代码的性能和可维护性。
此外，在集合中处理自定义对象需要清晰地理解如何重写 equals、hashCode，以及实现 Comparable 接口，以确保数据的完整性并促进无缝的操作。这些实践不仅增强了 Java 应用程序的功能，还贡献于更简洁和更具可读性的代码。
关键要点

Sets vs. Lists：使用 Sets 来存储唯一元素，使用 Lists 来存储有序的、带索引的集合。
转换：轻松在 Sets 和 Lists 之间转换，以利用两者的优势。
排序和搜索：利用 Collections.sort() 和 Collections.binarySearch() 进行高效的数据操作。
自定义对象：正确重写 equals、hashCode，并实现 Comparable，以与集合无缝配合。

掌握这些概念将使你能够更有效地处理数据，从而开发出高质量的 Java 应用程序。
关键词: Java Collections, Set, List, binary search, Collections.sort, Comparable interface, equals and hashCode, Java programming, data structures, ArrayList, HashSet, sorting algorithms, searching algorithms, custom objects in Java, data integrity, Java tutorials, efficient coding in Java

注意：本文是由 AI 生成的。
S11L14 – 还有几件事 – 本节总结

掌握 Java 集合：Sets、Lists 和高效搜索

目录

介绍

理解 Java Sets

什么是 Set？

Sets 的主要特性

常见的 Set 实现

何时使用 Set

使用 Set 的优缺点

将 Set 转换为 List

为什么将 Set 转换为 List？

逐步转换

代码示例

关键要点

在 Java 中排序 Lists

排序的重要性

排序字符串列表

排序自定义对象的列表

实现 Comparable

代码示例

关键要点

实现二分搜索

什么是二分搜索？

二分搜索的先决条件

在 Java 中执行二分搜索

理解输出

带有自定义对象的代码示例

关键要点

在集合中处理自定义对象

重写 `equals` 和 `hashCode` 的重要性

实现 `equals` 和 `hashCode`

在 Set 中使用自定义对象

实现 Comparable 接口

常见错误及避免方法

带注释的代码示例

关键要点

结论

关键要点

优点	缺点
确保元素的唯一性	无法控制元素的顺序
通常提供快速性能	相比 Lists，内存消耗较高
适合数学集合操作	相比 Lists，接口较为有限