Java中的数组和集合

ゞ浴缸里的玫瑰 2024-03-16 18:34 83阅读 0赞

#### 文章目录 ####

*  数组
 *   *  一维数组
     *   *  使用示例
         *  注意事项
     *  多维数组
     *   *  使用示例
         *  注意事项
 *  集合
 *   *  List
     *   *  ArrayList
         *  LinkedList
     *  Set
     *   *  HashSet
         *  TreeSet
     *  Map
     *   *  HashMap
         *  TreeMap
 *  总结

## 数组 ##

> Java 中的数组是一种容器，可以用来存储一组相同类型的元素。数组可以是一维的，也可以是多维的。

### 一维数组 ###

#### 使用示例 ####

> 一维数组是指只有一行的数组。在Java中，定义方式如下：

int[] array = new int[5];

这创建了一个名为 array 的整型数组，该数组有 5 个元素。可以使用下标访问数组中的元素，例如：array\[0\] 表示第一个元素，array\[1\] 表示第二个元素，以此类推。数组下标从 0 开始，因此最后一个元素的下标是 array.length - 1。

> 对于一维数组，可以使用循环语句轻松遍历所有元素。例如，以下代码打印了上述数组中的所有元素：

for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }

#### 注意事项 ####

*  数组的长度是不可变的，所以在定义数组时必须指定数组长度。
 *  数组下标从 0 开始，最大下标为数组长度减一。
 *  访问数组时要确保下标不越界，否则会导致数组越界异常。

### 多维数组 ###

#### 使用示例 ####

> 多维数组是指包含多行和多列的数组。在Java中，我们可以使用以下方式定义一个二维数组：

int[][] array = new int[3][4];

这将创建一个名为 array 的二维整型数组，该数组有 3 行 4 列。可以使用两个下标来访问二维数组中的元素，例如：array\[0\]\[0\] 表示第一行第一列的元素，array\[1\]\[2\] 表示第二行第三列的元素，以此类推。

> 对于多维数组，通常需要使用嵌套循环来访问所有元素。例如，以下代码打印了上述二维数组中的所有元素：

for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }
    }

#### 注意事项 ####

*  定义二维数组时，需要指定行数和列数。
 *  可以将二维数组看作是一个矩阵，其中第一个下标表示行数，第二个下标表示列数。
 *  访问数组元素时要确保下标不越界，否则会导致数组越界异常。

> 总之，在Java中使用数组和集合时，要注意正确的使用方式以及各自的特点和限制，尽量避免出现不必要的性能和安全问题。

## 集合 ##

> Java 中的集合是一组对象的容器，可以用来存储和操作各种类型的数据。Java 提供了许多集合实现，包括 List、Set、Queue 和 Map 等。下面我们将重点介绍 List、Set 和 Map。

### List ###

**List是一个有序可重复的集合，可以根据元素的位置（下标）来进行操作。常用的实现类包括：**

>  *  ArrayList：基于数组实现，支持快速随机访问，但插入和删除操作比较慢。
>  *  LinkedList：基于链表实现，支持快速插入和删除，但访问元素比较慢。
>  *  Vector：线程安全的动态数组，性能较差，已经被ArrayList替代。
>  *  List 是一种有序的容器，它可以包含重复元素。在 Java 中，最常见的 List 实现是 ArrayList 和 LinkedList。

#### ArrayList ####

> ArrayList 是基于数组实现的动态数组，它可以自动扩展容量来容纳新元素。以下是如何使用 ArrayList 的示例代码：

ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    int size = list.size();
    int element = list.get(0);
    list.remove(1);
    list.clear();

> 在上面的示例中，我们首先创建了一个整型 ArrayList，然后添加了三个元素。可以通过 size() 方法获取 ArrayList 的大小，通过 get(index) 方法获取特定索引处的元素，通过 remove(index) 方法删除特定索引处的元素，通过 clear() 方法清空列表。

**ArrayList是一个基于动态数组实现的List，使用数组来保存元素，具有以下特点：**

>  *  支持随机访问，时间复杂度为O(1)
>  *  插入和删除操作的效率较低，时间复杂度为O(n)
>  *  不支持线程同步，因此不是线程安全的
>  *  ArrayList适用于需要随机访问元素，但是插入和删除操作相对较少的场景。

#### LinkedList ####

> LinkedList 是基于链表实现的集合，它可以在任意位置进行插入和删除操作。以下是如何使用 LinkedList 的示例代码：

LinkedList<Integer> list = new LinkedList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    int size = list.size();
    int element = list.get(0);
    list.addFirst(0);
    list.addLast(4);
    list.remove(1);
    list.clear();

> 在上面的示例中，我们首先创建了一个整型 LinkedList，然后添加了三个元素。可以通过 size() 方法获取 LinkedList 的大小，通过 get(index) 方法获取特定索引处的元素，通过 addFirst(element) 和 addLast(element) 方法在列表头部或尾部添加元素，通过 remove(index) 方法删除特定索引处的元素，通过 clear() 方法清空列表。

**LinkedList是一个双向链表实现的List，每个节点都存储下一个节点和上一个节点的引用，具有以下特点：**

>  *  支持快速的插入和删除操作，时间复杂度为O(1)
>  *  访问元素速度较慢，时间复杂度为O(n)
>  *  不支持线程同步，因此不是线程安全的
>  *  LinkedList适用于需要频繁插入和删除元素的场景。

### Set ###

**Set是一个无序不可重复的集合，常用的实现类包括：**

>  *  HashSet：基于哈希表实现，插入和删除元素速度很快，但是不能保证顺序。
>  *  TreeSet：基于红黑树实现，有序的Set，但是性能相对较差。
>  *  LinkedHashSet：基于哈希表和链表实现，在HashSet的基础上记录了元素插入的顺序。

#### HashSet ####

> HashSet 是基于哈希表实现的集合，它不保证元素的顺序，并且可以很快地查找元素。以下是如何使用 HashSet 的示例代码：

HashSet<Integer> set = new HashSet<Integer>();
    set.add(1);
    set.add(2);
    set.add(3);
    int size = set.size();
    boolean contains = set.contains(1);
    set.remove(2);
    set.clear();

> 在上面的示例中，我们首先创建了一个整型 HashSet，然后添加了三个元素。可以通过 size() 方法获取 HashSet 的大小，通过 contains(element) 方法检查 HashSet 是否包含特定元素，通过 remove(element) 方法删除特定元素，通过 clear() 方法清空集合。

**HashSet是一个基于哈希表实现的Set，使用哈希表来保存元素，具有以下特点：**

>  *  插入、删除、查询等操作的效率都非常高，时间复杂度为O(1)
>  *  元素的顺序不确定
>  *  不支持线程同步，因此不是线程安全的  
>     HashSet适用于判断元素是否存在，或者需要快速添加、删除元素的场景。

#### TreeSet ####

> TreeSet 是基于红黑树实现的集合，它保证元素按照自然顺序或者给定的比较器进行排序。以下是如何使用 TreeSet 的示例代码：

TreeSet<Integer> set = new TreeSet<Integer>();
    set.add(3);
    set.add(1);
    set.add(2);
    int size = set.size();
    set.remove(2);
    set.clear();

> 在上面的示例中，我们首先创建了一个整型 TreeSet，然后添加了三个元素。可以通过 size() 方法获取 TreeSet 的大小，通过 remove(element) 方法删除特定元素，通过 clear() 方法清空集合。

### Map ###

**Map是一种键值对存储结构，每个键只能对应一个值。常用的实现类包括：**

>  *  HashMap：基于哈希表实现，插入和删除元素速度很快，但是不能保证顺序。
>  *  TreeMap：基于红黑树实现，有序的Map，但是性能相对较差。
>  *  LinkedHashMap：基于哈希表和链表实现，在HashMap的基础上记录了元素插入的顺序。

#### HashMap ####

> HashMap 是基于哈希表实现的 Map，它不保证键值对的顺序。以下是如何使用 HashMap 的示例代码：

TreeSet<Integer> set = new TreeSet<Integer>();
    set.add(3);
    set.add(1);
    set.add(2);
    int size = set.size();
    set.remove(2);
    set.clear();

> 在上面的示例中，我们首先创建了一个键为字符串、值为整型的 HashMap，然后添加了三个键值对。可以通过 size() 方法获取 HashMap 的大小，通过 containsKey(key) 方法检查 HashMap 是否包含特定键，通过 get(key) 方法获取特定键对应的值，通过 remove(key) 方法删除特定键值对，通过 clear() 方法清空 Map。

#### TreeMap ####

> TreeMap 是基于红黑树实现的 Map，它保证键值对按照键的自然顺序或者给定的比较器进行排序。以下是如何使用 TreeMap 的示例代码：

TreeMap<String, Integer> map = new TreeMap<String, Integer>();
    map.put("c", 3);
    map.put("a", 1);
    map.put("b", 2);
    int size = map.size();
    int value = map.get("b");
    map.remove("c");
    map.clear();

> 在上面的示例中，我们首先创建了一个键为字符串、值为整型的 TreeMap，然后添加了三个键值对。可以通过 size() 方法获取 TreeMap 的大小，通过 get(key) 方法获取特定键对应的值，通过 remove(key) 方法删除特定键值对，通过 clear() 方法清空 Map。

**TreeMap是一个基于红黑树实现的Map，使用红黑树来保存元素，具有以下特点：**

>  *  插入、删除、查询等操作的效率都较高，时间复杂度为O(log n)
>  *  元素按照键值升序排序
>  *  不支持线程同步，因此不是线程安全的
>  *  TreeMap适用于需要按照键值排序，或者需要快速添加、删除元素的场景。

***除了以上常用的集合实现，Java还提供了一些其他的集合类，例如Stack、Queue等。在使用集合时，需要根据具体的情况选择合适的实现类，并注意其特性和使用方法。***

## 总结 ##

> Java 中提供了丰富的数组和集合类型，可以用来存储和操作各种类型的数据。了解这些类型的区别和使用场景，可以帮助我们更加高效地编写Java程序。在使用数组和集合时，我们还应该注意内存占用和性能等方面的问题，避免出现不必要的性能瓶颈。