一篇文章带你入门Java集合

Java集合是Java编程中常用的数据结构，包含了List、Set、Map等常用的集合类型。本文将从以下几个方面介绍Java集合：

1. Java集合的类型和概念
2. Java集合的基础用法
3. Java集合的注意事项

1. Java集合的类型和概念

集合类型

Java集合主要有以下三种类型：

1. List（列表）：有序，可以重复，例如ArrayList、LinkedList等。
2. Set（集合）：无序，不能重复，例如HashSet、TreeSet等。
3. Map（映射表）：Key-Value键值对，可以根据Key查找Value，例如HashMap、TreeMap等。

集合概念

Java集合中常用的概念有以下几个：

1. 元素（Element）：集合中存储的数据项。
2. 长度（Size）：集合中元素的数量。
3. 迭代器（Iterator）：用于遍历集合中的元素。
4. 泛型（Generic）：Java 5.0 引入的类型安全机制，用于指定集合中可以存储的元素类型。
5. 装箱（Boxing）：将基本类型数据转换为对应的封装类类型。

2. Java集合的基础用法

List

List是有序的集合，可以重复。常用的List有ArrayList和LinkedList。

ArrayList

ArrayList是基于数组实现的List，具有如下特点：

1. 读取数据快，增删数据慢。
2. 可以设置容量（initialCapacity），可以防止扩容导致性能下降。

以下是ArrayList的基本用法：

List<String> arrayList = new ArrayList<>();
arrayList.add("apple");
arrayList.add("banana");
arrayList.add("orange");
System.out.println(arrayList.get(1)); // 输出：banana

LinkedList

LinkedList是基于链表实现的List，具有如下特点：

1. 读取数据慢，增删数据快。
2. 不需要设置容量，可以动态扩展。

以下是LinkedList的基本用法：

List<String> linkedList = new LinkedList<>();
linkedList.add("apple");
linkedList.add("banana");
linkedList.add("orange");
System.out.println(linkedList.get(2)); // 输出：orange

Set

Set是无序的集合，不允许重复。常用的Set有HashSet和TreeSet。

HashSet

HashSet是基于HashMap实现的Set，具有如下特点：

1. 数据存储无序。
2. 不允许重复，添加重复元素时会被忽略。
3. 可以添加null元素。

以下是HashSet的基本用法：

Set<String> hashSet = new HashSet<>();
hashSet.add("apple");
hashSet.add("banana");
hashSet.add("orange");
hashSet.add("banana"); // 添加重复元素会被忽略
System.out.println(hashSet.size()); // 输出：3

TreeSet

TreeSet是基于红黑树实现的Set，具有如下特点：

1. 数据存储有序。
2. 不允许重复，添加重复元素时会被忽略。
3. 不允许添加null元素。

以下是TreeSet的基本用法：

Set<String> treeSet = new TreeSet<>();
treeSet.add("apple");
treeSet.add("banana");
treeSet.add("orange");
treeSet.add("banana"); // 添加重复元素会被忽略
System.out.println(treeSet.size()); // 输出：3

Map

Map是Key-Value键值对的映射表，可以根据Key查找Value。常用的Map有HashMap和TreeMap。

HashMap

HashMap是基于散列表实现的Map，具有如下特点：

1. 数据存储无序。
2. Key不允许重复，添加重复Key时会覆盖原有的Value。
3. 可以添加null Key和null Value。

以下是HashMap的基本用法：

Map<String, String> hashMap = new HashMap<>();
hashMap.put("apple", "red");
hashMap.put("banana", "yellow");
hashMap.put("orange", "orange");
hashMap.put("banana", "green"); // 添加重复Key时会覆盖原有的Value
System.out.println(hashMap.get("banana")); // 输出：green

TreeMap

TreeMap是基于红黑树实现的Map，具有如下特点：

1. 数据存储有序。
2. Key不允许重复，添加重复Key时会覆盖原有的Value。
3. 不允许添加null Key和null Value。

以下是TreeMap的基本用法：

Map<String, String> treeMap = new TreeMap<>();
treeMap.put("apple", "red");
treeMap.put("banana", "yellow");
treeMap.put("orange", "orange");
treeMap.put("banana", "green"); // 添加重复Key时会覆盖原有的Value
System.out.println(treeMap.get("banana")); // 输出：green

3. Java集合的注意事项

集合遍历

Java集合可以使用for-each循环或迭代器进行遍历。

使用for-each循环遍历

List<String> arrayList = new ArrayList<>();
arrayList.add("apple");
arrayList.add("banana");
arrayList.add("orange");

for (String element : arrayList) {
    System.out.println(element);
}

使用迭代器遍历

List<String> arrayList = new ArrayList<>();
arrayList.add("apple");
arrayList.add("banana");
arrayList.add("orange");

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

集合排序

Java集合可以使用Collections.sort()方法进行排序，也可以使用TreeSet等自带排序功能的集合。

使用Collections.sort()方法排序

List<Integer> arrayList = new ArrayList<>();
arrayList.add(2);
arrayList.add(3);
arrayList.add(1);

Collections.sort(arrayList); // 默认升序排序

for (Integer element : arrayList) {
    System.out.println(element);
}

使用TreeSet自带排序功能排序

Set<Integer> treeSet = new TreeSet<>();
treeSet.add(2);
treeSet.add(3);
treeSet.add(1);

for (Integer element : treeSet) {
    System.out.println(element);
}

示例说明：

示例1：使用ArrayList存储用户信息

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class UserList {
    private List<User> userList = new ArrayList<>();

    public void addUser(User user) {
        userList.add(user);
    }

    public void removeUser(User user) {
        userList.remove(user);
    }

    public List<User> getUserList() {
        return userList;
    }
}

public class Main {
    public static void main(String[] args) {
        UserList userList = new UserList();
        userList.addUser(new User("Alice", 25));
        userList.addUser(new User("Bob", 30));
        userList.addUser(new User("Charlie", 35));

        List<User> list = userList.getUserList();
        for (User user : list) {
            System.out.println(user.getName() + ", " + user.getAge());
        }
    }
}

上述代码演示了如何使用ArrayList存储用户信息，并使用for-each循环遍历集合。

示例2：使用HashSet实现排重功能

public class Main {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("orange");
        set.add("banana");

        for (String element : set) {
            System.out.println(element);
        }
    }
}

上述代码演示了如何使用HashSet去除重复元素。由于HashSet不允许存储重复元素，因此最终输出结果只有三个元素。