Java基础集合框架学习(下)
文章目录
-
- Dog必须改写equals方法
- LinkedList独有方法
- Set入门
- Set去重现象
- TreeSet算法依赖于一个比较接口
- HashMap案例
- map常用方法
- 泛型入门
- 使用泛型
- 迭代器Iterator
- Collections集合框架工具类
Dog必须改写equals方法
在Java中，当你希望对自定义类的对象进行相等性比较时，需要重写equals()方法。默认情况下，Java中的equals()方法是比较对象的引用是否相等，而不是对象的内容。通过重写equals()方法，你可以定义自己的相等性比较逻辑。
在前面的示例中，我们可以为Dog类重写equals()方法，以便在比较两个Dog对象时根据名称属性进行比较。以下是重写equals()方法的示例：
class Dog {
private String name;
public Dog(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Dog dog = (Dog) o;
return name != null ? name.equals(dog.name) : dog.name == null;
}
@Override
public int hashCode() {
return name != null ? name.hashCode() : 0;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
'}';
}
}
public class ArrayListDogExample {
public static void main(String[] args) {
// 创建一个存放Dog对象的ArrayList
List<Dog> dogs = new ArrayList<>();
// 添加四条狗
dogs.add(new Dog("Buddy"));
dogs.add(new Dog("Max"));
dogs.add(new Dog("Charlie"));
dogs.add(new Dog("Lucy"));
// 比较狗对象
Dog targetDog = new Dog("Max");
boolean containsMax = dogs.contains(targetDog);
System.out.println("是否包含Max：" + containsMax);
}
}
如上例，我们重写了equals()方法，使得两个Dog对象在名称相等时被视为相等。这使得我们可以使用contains()方法来检查dogs列表是否包含一个特定的Dog对象，而不仅仅是比较引用。
LinkedList独有方法
LinkedList是Java集合框架中的一种实现，它除了继承自List接口和Queue接口的方法外，还有一些独有的方法。以下是一些LinkedList独有的方法：
-
addFirst(E e) / offerFirst(E e)：将指定元素添加到链表的开头。
-
addLast(E e) / offerLast(E e)：将指定元素添加到链表的末尾。
-
getFirst()：返回链表的第一个元素，但不会删除它。如果链表为空，会抛出NoSuchElementException异常。
-
getLast()：返回链表的最后一个元素，但不会删除它。如果链表为空，会抛出NoSuchElementException异常。
-
removeFirst() / pollFirst()：移除并返回链表的第一个元素。如果链表为空，
pollFirst()会返回null。 -
removeLast() / pollLast()：移除并返回链表的最后一个元素。如果链表为空，
pollLast()会返回null。 -
get(int index)：返回链表中指定位置的元素。
-
remove(int index)：移除并返回链表中指定位置的元素。
-
add(int index, E element)：在指定位置插入指定元素。
-
indexOf(Object o)：返回指定元素在链表中首次出现的索引，如果不存在则返回-1。
-
lastIndexOf(Object o)：返回指定元素在链表中最后出现的索引，如果不存在则返回-1。
-
listIterator(int index)：返回一个ListIterator，从链表中的指定位置开始迭代。
-
offer(E e)：将指定元素添加到链表末尾，等效于
addLast(E e)。 -
peek()：返回链表的第一个元素，但不会删除它。如果链表为空，返回null。
-
pop()：从链表的开头弹出一个元素，等效于
removeFirst()。 -
push(E e)：将元素推入链表的开头，等效于
addFirst(E e)。
这些方法使得LinkedList在某些场景下非常有用，特别是需要频繁在链表的开头或末尾进行插入、删除和访问操作时。要注意的是，LinkedList的底层实现是一个双向链表，因此这些操作在链表中的效率通常比较高。
Set入门
Set是Java集合框架中的一种接口，它表示一个不包含重复元素的集合。Set不保证元素的顺序，即集合中的元素不按特定的顺序排列。在Set中，每个元素都是唯一的。Java中常见的Set实现类包括HashSet、LinkedHashSet和TreeSet。
以下是使用Set的入门示例：
import java.util.HashSet;
import java.util.Set;
public class SetExample {
public static void main(String[] args) {
// 创建一个HashSet来存储整数
Set<Integer> numbers = new HashSet<>();
// 添加元素到Set
numbers.add(10);
numbers.add(20);
numbers.add(30);
numbers.add(40);
numbers.add(50);
// 尝试添加重复元素
boolean added = numbers.add(30);
System.out.println("添加重复元素是否成功：" + added);
// 打印Set中的元素
System.out.println("Set中的元素：" + numbers);
// 遍历Set中的元素
System.out.println("遍历Set中的元素：");
for (Integer num : numbers) {
System.out.println(num);
}
// 移除元素
numbers.remove(30);
// 检查元素是否存在
boolean contains = numbers.contains(20);
System.out.println("是否包含元素 20：" + contains);
// 清空Set
numbers.clear();
// 检查Set是否为空
boolean isEmpty = numbers.isEmpty();
System.out.println("Set是否为空：" + isEmpty);
}
}
例中，我们使用了HashSet作为Set的实现类，但你也可以尝试使用其他的Set实现类。我们首先创建一个HashSet来存储整数，并演示了添加、重复添加、遍历、移除、检查元素是否存在以及清空Set的操作。
注意，Set不会包含重复的元素，因此尝试将重复元素添加到Set中时，add()方法会返回false。另外，Set的元素顺序是不确定的，因此遍历Set时元素的顺序可能与添加时不同。
Set去重现象
Set的一个主要特性是它不允许包含重复的元素，这就导致了Set自动去重的现象。
当你将重复的元素添加到Set中时，只会保留一个副本，其他重复的副本会被自动移除，从而确保Set中的元素始终是唯一的。
以下是一个示例来展示Set的去重现象：
import java.util.HashSet;
import java.util.Set;
public class SetDeduplicationExample {
public static void main(String[] args) {
Set<String> uniqueNames = new HashSet<>();
// 添加元素到Set
uniqueNames.add("Alice");
uniqueNames.add("Bob");
uniqueNames.add("Charlie");
uniqueNames.add("Alice"); // 添加重复元素
// 打印Set中的元素
System.out.println("Set中的元素：" + uniqueNames);
// 添加重复元素后，Set中只保留一个副本
System.out.println("Set的大小：" + uniqueNames.size());
}
}
在上述示例中，我们使用了HashSet来存储字符串，并添加了几个元素，包括一个重复元素"Alice"。当我们打印Set中的元素时，你会注意到重复的元素只保留了一个副本，而且Set的大小也是3而不是4，这是因为Set自动去重。
Set的去重特性使其在需要存储唯一元素的场景中非常有用，例如去重字符串列表、存储唯一的标识符等。
TreeSet算法依赖于一个比较接口
TreeSet在对元素进行排序和比较时依赖于一个比较接口，通常是Comparable接口或者通过传入一个Comparator对象来实现。
- 使用Comparable接口（自然排序）：如果你希望TreeSet按照元素的自然顺序进行排序，那么被存储在TreeSet中的元素类必须实现
Comparable接口，并重写compareTo()方法。这个方法决定了元素在集合中的顺序。
import java.util.TreeSet;
public class TreeSetExample {
public static void main(String[] args) {
TreeSet<Integer> numbers = new TreeSet<>();
numbers.add(5);
numbers.add(2);
numbers.add(8);
numbers.add(1);
System.out.println("TreeSet中的元素：" + numbers);
}
}
在这个示例中，整数类型实现了Comparable接口，默认按照自然顺序进行排序。
- 使用Comparator接口（定制排序）：如果你希望TreeSet按照自定义的排序规则进行排序，你可以提供一个实现了
Comparator接口的对象，然后将这个对象传递给TreeSet的构造方法。
import java.util.TreeSet;
import java.util.Comparator;
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
public class TreeSetComparatorExample {
public static void main(String[] args) {
TreeSet<Person> people = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
});
people.add(new Person("Alice"));
people.add(new Person("Charlie"));
people.add(new Person("Bob"));
System.out.println("TreeSet中的人员：" + people);
}
}
在这个示例中，我们创建了一个存储Person对象的TreeSet，通过匿名内部类实现了Comparator接口，以按照人名的字母顺序进行排序。
TreeSet可以根据自然顺序（通过Comparable接口）或者自定义排序规则（通过Comparator接口）来对元素进行排序，因此它在需要有序集合的场景中非常有用。
HashMap案例
演示了如何创建一个HashMap，添加键值对，访问和修改值，以及遍历键值对的基本操作：
import java.util.HashMap;
import java.util.Map;
public class HashMapExample {
public static void main(String[] args) {
// 创建一个HashMap来存储学生的成绩
Map<String, Integer> scores = new HashMap<>();
// 添加键值对
scores.put("Alice", 95);
scores.put("Bob", 80);
scores.put("Charlie", 75);
scores.put("David", 88);
scores.put("Eve", 92);
// 访问和修改值
int charlieScore = scores.get("Charlie");
System.out.println("Charlie的成绩：" + charlieScore);
scores.put("Charlie", 85);
System.out.println("修改后的Charlie的成绩：" + scores.get("Charlie"));
// 遍历键值对
System.out.println("所有学生的成绩：");
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 检查键是否存在
boolean containsBob = scores.containsKey("Bob");
System.out.println("是否包含Bob：" + containsBob);
// 删除键值对
scores.remove("David");
System.out.println("删除David后的学生成绩：" + scores);
}
}
在这个案例中，我们创建了一个HashMap来存储学生的成绩，其中键是学生的姓名（String），值是学生的分数（Integer）。
我们展示了如何添加键值对、访问和修改值、遍历键值对、检查键是否存在以及删除键值对等操作。
HashMap是一种常用的键值对存储数据结构，它提供了高效的查找和插入操作。
注意，HashMap的键是唯一的，因此如果添加具有相同键的键值对，新值会覆盖旧值。
map常用方法
下面是一些常用的Map接口的方法，包括常见的操作和功能：
-
put(K key, V value)：将键值对添加到Map中，如果键已经存在，则会替换对应的值。
-
get(Object key)：根据键获取对应的值，如果键不存在，则返回null。
-
remove(Object key)：根据键移除对应的键值对。
-
containsKey(Object key)：检查Map中是否包含指定的键。
-
containsValue(Object value)：检查Map中是否包含指定的值。
-
size()：返回Map中键值对的数量。
-
isEmpty()：检查Map是否为空。
-
clear()：清空Map，移除所有键值对。
-
keySet()：返回包含所有键的Set集合。
-
values()：返回包含所有值的Collection集合。
-
entrySet()：返回包含所有键值对的Set集合（Map.Entry类型）。
-
putAll(Map m)：将另一个Map中的所有键值对添加到当前Map中。
-
getOrDefault(Object key, V defaultValue)：根据键获取对应的值，如果键不存在，则返回默认值。
-
compute(K key, BiFunction remappingFunction)：根据键对值进行计算，用于更新或创建键值对。
-
forEach(BiConsumer action)：对Map中的每个键值对执行指定的操作。
-
replace(K key, V value)：替换指定键的值，如果键不存在则不做任何操作。
-
replace(K key, V oldValue, V newValue)：替换指定键的旧值为新值，只有在键对应的值为旧值时才替换。
-
replaceAll(BiFunction function)：对Map中的每个键值对应用指定的操作。
泛型入门
泛型（Generics）是Java中一种强大的特性，它允许你在类、接口、方法的定义中使用类型参数，从而可以在编译时指定具体的数据类型，提高代码的重用性和类型安全性。泛型在集合框架和通用算法中广泛使用。
以下是关于泛型的一些入门示例和概念：
1. 泛型类（Generic Class）：
public class Box<T> {
private T value;
public Box(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
public class GenericsExample {
public static void main(String[] args) {
Box<Integer> intBox = new Box<>(42);
int intValue = intBox.getValue();
System.out.println("Value: " + intValue);
Box<String> stringBox = new Box<>("Hello, Generics!");
String stringValue = stringBox.getValue();
System.out.println("Value: " + stringValue);
}
}
例中，我们定义了一个泛型类Box，它可以存储任意类型的值。在创建Box对象时，通过指定类型参数来指定具体的数据类型。这使得我们可以在不同的上下文中重用Box类，同时在编译时进行类型检查。
2. 泛型方法（Generic Method）：
public class GenericsExample {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"one", "two", "three", "four", "five"};
printArray(intArray);
printArray(stringArray);
}
}
例中，我们定义了一个泛型方法printArray，它可以接受不同类型的数组作为参数，并打印数组中的元素。
通过使用
泛型的优势在于它提供了类型安全性和代码重用性，可以将数据类型相关的问题在编译时而不是运行时捕获，从而减少错误和调试难度。通过泛型，你可以编写更通用和灵活的代码。
使用泛型
使用泛型可以让你在类、接口、方法中定义一种通用的数据类型，这样可以在编写代码时更具灵活性和重用性。以下是使用泛型的一些示例和概念：
1. 泛型类（Generic Class）：
public class Box<T> {
private T value;
public Box(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
public class GenericsExample {
public static void main(String[] args) {
Box<Integer> intBox = new Box<>(42);
int intValue = intBox.getValue();
System.out.println("Value: " + intValue);
Box<String> stringBox = new Box<>("Hello, Generics!");
String stringValue = stringBox.getValue();
System.out.println("Value: " + stringValue);
}
}
例中，我们定义了一个泛型类Box，可以用来存储不同类型的值。我们在创建Box对象时，通过指定类型参数来指定具体的数据类型。
2. 泛型方法（Generic Method）：
public class GenericsExample {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"one", "two", "three", "four", "five"};
printArray(intArray);
printArray(stringArray);
}
}
定义一个泛型方法printArray，它可以接受不同类型的数组作为参数，并打印数组中的元素。通过使用
使用泛型可以提高代码的重用性，减少类型相关的错误，并增加代码的可读性。它在集合框架、算法和许多其他场景中广泛使用，帮助你更灵活地处理不同类型的数据。
迭代器Iterator
迭代器（Iterator）是一种用于遍历集合（如List、Set、Map等）中元素的对象。
它提供了一种统一的方式来访问集合中的元素，而无需关心集合的底层实现。
以下是使用迭代器进行集合遍历的示例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
names.add("David");
// 获取集合的迭代器
Iterator<String> iterator = names.iterator();
// 使用迭代器遍历集合
while (iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}
}
}
我们首先创建了一个ArrayList来存储字符串，然后通过iterator()方法获取了集合的迭代器。接着，使用while循环和hasNext()方法检查是否还有下一个元素，如果有就使用next()方法获取并打印元素。这样，我们可以逐个遍历集合中的元素。
迭代器提供了一种遍历集合的通用方式，不依赖于集合的具体实现，因此你可以在不同类型的集合上使用相同的遍历逻辑。它也支持在遍历过程中对集合进行增删操作，但要注意避免在迭代过程中修改集合结构，以免引发并发修改异常（ConcurrentModificationException）。
Collections集合框架工具类
Java提供了java.util.Collections类作为集合框架的工具类，它包含了一系列静态方法，用于操作和处理集合对象。Collections类提供了许多便捷的方法来对集合进行排序、查找、替换、同步等操作。以下是一些常用的Collections类方法示例：
1. 排序集合：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsSortExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(2);
numbers.add(8);
numbers.add(1);
System.out.println("排序前：" + numbers);
Collections.sort(numbers);
System.out.println("排序后：" + numbers);
}
}
2. 查找最大/最小值：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsMinMaxExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(2);
numbers.add(8);
numbers.add(1);
int min = Collections.min(numbers);
int max = Collections.max(numbers);
System.out.println("最小值：" + min);
System.out.println("最大值：" + max);
}
}
3. 集合反转：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsReverseExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
System.out.println("反转前：" + names);
Collections.reverse(names);
System.out.println("反转后：" + names);
}
}
4. 随机洗牌：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsShuffleExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
System.out.println("洗牌前：" + numbers);
Collections.shuffle(numbers);
System.out.println("洗牌后：" + numbers);
}
}
这些示例演示了Collections类的一些常见用法，它可以帮助我们更方便地操作和处理集合对象。注意，Collections类中的方法大多数都是静态方法，因此不需要实例化该类即可调用这些方法。