三大常用集合

Hu_go__

已于 2024-07-02 17:51:51 修改

阅读量1.1k

点赞数 21

文章标签： java

于 2024-07-02 17:51:00 首次发布

本文链接：https://blog.csdn.net/2301_79562326/article/details/140132866

版权

1.Set集合

在Java中，Set是一种集合类型，它是一种不允许包含重复元素的集合，每个元素在Set中是唯一的。Set接口的常用实现类有HashSet、TreeSet和LinkedHashSet。以下是关于Set集合的一些重要特点和用法：

特点：

不允许重复元素：Set中每个元素都是唯一的，如果尝试向Set中添加重复元素，则添加操作不会成功。
无序性：Set并不维护元素的添加顺序，元素的存储顺序由具体的Set实现类决定。HashSet是根据哈希算法来存储元素，没有特定的顺序；TreeSet基于元素的自然顺序或者Comparator来进行排序；LinkedHashSet保留了元素添加的顺序。
允许空元素：Set集合允许存储一个空元素（null）。

常用方法：

添加元素：使用add方法向Set中添加元素。
删除元素：使用remove方法移除Set中的元素。
判断元素是否存在：使用contains方法判断Set中是否包含某个元素。
获取Set的大小：使用size方法获取Set中元素的个数。
遍历Set：Set集合可以使用迭代器（Iterator）或者增强for循环进行遍历。

示例：

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        
        // 添加元素
        set.add("apple");
        set.add("orange");
        set.add("banana");
        set.add("apple"); // 添加重复元素，不会成功
        
        // 删除元素
        set.remove("orange");
        
        // 判断元素是否存在
        if(set.contains("banana")) {
            System.out.println("Set contains 'banana'");
        }
        
        // 遍历Set
        for(String element : set) {
            System.out.println(element);
        }
        
        // 获取Set的大小
        System.out.println("Size of Set: " + set.size());
    }
}

在实际应用中，Set集合常用于去重、判断元素是否存在以及集合运算等场景。通过Set集合提供的特性和方法，可以方便地实现对元素的管理和操作。

Set 是 Java 集合框架中的一个接口，表示不包含重复元素的集合。Set 接口的实现类通常用于存储不重复的元素，并且不保证元素的顺序。常见的 Set 实现类包括 HashSet、TreeSet 和 LinkedHashSet。

1. 创建 Set 对象：

可以使用以下方法创建 Set 对象：

Set<String> hashSet = new HashSet<>();  // 使用 HashSet 创建 Set
Set<String> treeSet = new TreeSet<>();  // 使用 TreeSet 创建 Set
Set<String> linkedHashSet = new LinkedHashSet<>();  // 使用 LinkedHashSet 创建 Set

2. 常用方法：

add(E e)：向集合中添加元素，如果元素已存在，则不添加。
remove(Object o)：从集合中移除指定元素。
contains(Object o)：判断集合中是否包含指定元素。
size()：返回集合中元素的个数。
isEmpty()：判断集合是否为空。
clear()：清空集合中的所有元素。
iterator()：返回用于迭代集合的迭代器。

3. 示例代码：

以下是一个示例代码，演示了如何使用 HashSet 和 TreeSet：

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {
    public static void main(String[] args) {
        // 使用 HashSet 创建 Set
        Set<String> hashSet = new HashSet<>();
        hashSet.add("apple");
        hashSet.add("banana");
        hashSet.add("orange");
        hashSet.add("banana");  // 不会重复添加

        System.out.println("HashSet elements: " + hashSet);

        // 使用 TreeSet 创建 Set
        Set<String> treeSet = new TreeSet<>();
        treeSet.add("pineapple");
        treeSet.add("banana");
        treeSet.add("orange");
        treeSet.add("banana");  // 不会重复添加

        System.out.println("TreeSet elements: " + treeSet);
    }
}

在上面的示例中，首先创建了一个 HashSet 和一个 TreeSet，然后向集合中添加元素。由于集合不允许重复元素，因此向 HashSet 和 TreeSet 中添加重复元素时，只会添加一次。最后打印输出了集合中的元素。通过使用 Set 接口的实现类，可以方便地管理不重复的元素集合。

2.Map集合

在Java中，Map接口表示一种将键值对映射关系存储起来的集合。Map集合中的每个元素都包含一个键和对应的值，键和值之间是一种一对一的映射关系，其中键是唯一的，值可以重复。

Map集合广泛用于保存和处理数据，在实际开发中应用非常广泛。Java中常用的Map接口的实现类有：

HashMap：基于哈希表实现，可以快速查找键值对，适合存储大量数据。
LinkedHashMap：在HashMap的基础上增加了按照插入顺序或访问顺序排序键值对。
TreeMap：基于红黑树实现，键值对按照自然顺序或自定义比较器排序。
ConcurrentHashMap：线程安全的HashMap实现，在多线程环境下性能更好。

Map集合常用的方法有：

put(key, value)：向Map中添加键值对。
get(key)：根据键获取对应的值。
containsKey(key)：判断Map中是否包含指定的键。
containsValue(value)：判断Map中是否包含指定的值。
remove(key)：移除指定键对应的键值对。
size()：返回Map中键值对的数量。

Map集合是常用的数据结构之一，能够快速进行键值对的查找、删除以及更新操作。在开发过程中，Map集合被广泛应用于保存配置信息、缓存数据、处理请求参数等场景。

Map集合是Java中用于存储键值对映射关系的数据结构，下面是一些Map集合的基本用法：

创建Map对象

可以使用HashMap、LinkedHashMap、TreeMap等Map的实现类来创建Map对象：

Map<String, Integer> map = new HashMap<>();

添加键值对

使用put(key, value)方法向Map中添加键值对：

map.put("apple", 10);
map.put("banana", 5);
map.put("orange", 8);

获取值

使用get(key)方法根据键获取对应的值：

int appleCount = map.get("apple");

判断键是否存在

使用containsKey(key)方法判断Map中是否包含指定的键：

if (map.containsKey("banana")) {
    System.out.println("Map contains key 'banana'");
}

迭代Map

可以使用keySet()、entrySet()、values()等方法对Map进行迭代，获取键集、键值对集或值集：

// 遍历所有键
for (String key : map.keySet()) {
    int value = map.get(key);
    System.out.println(key + ": " + value);
}

// 遍历所有键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    int value = entry.getValue();
    System.out.println(key + ": " + value);
}

// 遍历所有值
for (int value : map.values()) {
    System.out.println(value);
}

删除键值对

使用remove(key)方法移除指定键对应的键值对：

map.remove("orange");

Map集合是一种非常有用的数据结构，能够方便地存储和操作键值对数据。在实际开发中，Map经常被用于保存配置信息、统计数据、缓存数据等场景。熟练掌握Map集合的用法有助于提高代码编写效率和数据处理能力。

3.List集合

List 是 Java 集合框架中的一个接口，表示有序的集合，可以包含重复元素。List 接口的常见实现类包括 ArrayList、LinkedList 和 Vector。

1. 创建 List 对象：

可以使用以下方法创建 List 对象：

List<String> arrayList = new ArrayList<>();  // 使用 ArrayList 创建 List
List<String> linkedList = new LinkedList<>();  // 使用 LinkedList 创建 List
List<String> vector = new Vector<>();  // 使用 Vector 创建 List

2. 常用方法：

add(E e)：向列表尾部添加元素。
add(int index, E element)：在指定位置插入元素。
get(int index)：获取指定位置的元素。
remove(int index)：移除指定位置的元素。
remove(Object o)：移除指定元素。
contains(Object o)：判断列表中是否包含指定元素。
size()：返回列表的大小。
isEmpty()：判断列表是否为空。
clear()：清空列表中所有元素。
set(int index, E element)：替换指定位置的元素。

3. 示例代码：

以下是一个示例代码，演示了如何使用 ArrayList 和 LinkedList：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // 使用 ArrayList 创建 List
        List<String> arrayList = new ArrayList<>();
        arrayList.add("apple");
        arrayList.add("banana");
        arrayList.add("orange");

        // 在指定位置插入元素
        arrayList.add(1, "pineapple");

        System.out.println("ArrayList elements: " + arrayList);

        // 使用 LinkedList 创建 List
        List<String> linkedList = new LinkedList<>();
        linkedList.add("car");
        linkedList.add("bus");
        linkedList.add("bike");

        // 移除指定位置的元素
        linkedList.remove(1);

        System.out.println("LinkedList elements: " + linkedList);
    }
}

在上面的示例中，首先创建了一个 ArrayList 和一个 LinkedList，然后向列表中添加元素并插入元素。随后删除了一个元素，并打印输出了列表的元素。通过使用 List 接口的实现类，可以操作有序、可以重复的元素集合。

List 是 Java 集合框架中的一个接口，表示有序的集合，可以包含重复元素。List 接口的实现类包括 ArrayList、LinkedList 和 Vector。下面介绍 List 集合的常见用法：

1. 创建 List 对象：

可以使用以下方法创建 List 对象：

List<String> list = new ArrayList<>();  // 使用 ArrayList 创建 List
List<Integer> list = new LinkedList<>();  // 使用 LinkedList 创建 List
List<Double> list = new Vector<>();  // 使用 Vector 创建 List

2. 添加元素：

可以使用 add(E e) 方法向 List 中添加元素，可以在列表的末尾添加元素。

list.add("apple");
list.add("banana");
list.add("orange");

3. 获取元素：

可以使用 get(int index) 方法获取指定位置的元素。

String fruit = list.get(1);  // 获取第二个元素(索引从0开始)

4. 删除元素：

可以使用 remove(int index) 方法删除指定位置的元素，或者使用 remove(Object o) 方法删除指定元素。

list.remove(1);  // 删除第二个元素
list.remove("apple");  // 删除元素值为 "apple" 的元素

5. 遍历元素：

可以使用 for 循环或者迭代器遍历列表中的元素。

for(String fruit : list) {
    System.out.println(fruit);
}

Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
    String fruit = iterator.next();
    System.out.println(fruit);
}

6. 其他常用方法：

size()：返回列表的大小。
isEmpty()：判断列表是否为空。
clear()：清空列表中的所有元素。
indexOf(Object o)：返回元素在列表中第一次出现的索引。
contains(Object o)：判断列表中是否包含指定元素。
set(int index, E element)：替换指定位置的元素。

示例代码：

以下是一个示例代码，演示了 List 集合的基本用法：

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("orange");

        for (String fruit : list) {
            System.out.println(fruit);
        }

        list.remove(1);  // 删除第二个元素

        System.out.println("Size of list: " + list.size());
        System.out.println("Is list empty? " + list.isEmpty());
    }
}

通过使用 List 集合，可以方便地存储有序、可以重复的元素集合，并进行常见的操作，如添加、获取、删除、遍历等。