JAVA之集合—-Collection

数组有很多的缺点，比如

  • 一旦初始化以后，其长度就不可修改。
  • 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
  • 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
  • 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

所以我们使用集合来实现

集合分为Collection和Map两种体系

  • Collection：主要由List、Set、Queue接口组成，List代表有序、重复的集合；其中Set代表无序、不可重复的集合；Java 5 又增加了Queue体系集合，代表一种队列集合实现。
  • Map：则代表具有映射关系的键值对集合。

image-20240403191843617

Collections方法

所有的Collections下的实现类都能使用此方法

  • 增减

boolean add(Elemtype e)：添加一个元素，成功了就会返回true，反之是false

boolean remove(Eletmtype e)：移除集合中的元素

  • 查询

boolean contains(Elemtype e)：检查集合中指定的元素

int max(coll)：根据元素的自然顺序，返回给定集合中的最大元素

int min(coll)：根据元素的自然顺序，返回给定集合中的最小元素

int frequency(coll，int i)：返回指定集合中指定元素的出现次数

List（有序列表）

List集合的特点就是存取有序，可以存储重复的元素，可以用下标进行元素的操作

有些Collections方法是只有List能用的

  • 反转

    void reverse (coll)：反转 List 中元素的顺序

  • 排序

    void sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序

  • 交换

    void swap(coll,int i,int j)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

List特有方法

  • 查询

    Elemtype get(int index)：获取此集合中指定索引位置的元素，E 为集合中元素的数据类型
    int index(Elemtype e)：返回此集合中第一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1
    int lastIndexOf(Elemtype e)：返回此集合中最后一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1

  • 修改

    Elemtype set(int index, element)：将此集合中指定索引位置的元素修改为 element 参数指定的对象。此方法返回此集合中指定索引位置的原元素

    List<E> subList(int fromlndex, int tolndex)：返回一个新的集合，新集合中包含 fromlndex 和 tolndex 索引之间的所有元素。左开右闭

List与数组之间的转化

数组 ———> List

  • 使用Arrays.asList()方法

    1
    2
    String[] array = {"Apple", "Banana", "Cherry"};
    List<String> list = Arrays.asList(array);

    这是将数组转换为列表的最直接方法。但需要注意的是，通过Arrays.asList()方法转换得到的列表是固定大小的，即不能添加或删除元素

    而且只能适用于包装类(Integer)，无法用于基本数据类型(int)

  • 使用Stream API

    1
    2
    int[] array = {1, 2, 3, 4, 5};
    List<Integer> list = Arrays.stream(array).boxed().collect(Collectors.toList());

    这适用于基本类型数组，如int[]，因为Arrays.asList()无法直接处理基本类型数组

List ———>数组

  • 使用List.toArray()

    这是将列表转换为数组的标准方法。只能把列表转换为包装类

    1
    2
    List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));
    String[] array = list.toArray(new String[0]);

  • 使用Stream API

    1
    2
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    int[] array = list.stream().mapToInt(Integer::intValue).toArray();

ArrayList（动态数组）

ArrayList 是一个动态数组结构，支持随机存取，尾部插入删除方便，内部插入删除效率低（因为要移动数组元素）；如果内部数组容量不足则自动扩容，因此当数组很大时，效率较低。

ArrayList继承了List和Collection的所有方法

LinkedList（双向链表）

LinkedList 是一个双向链表结构，在任意位置插入删除都很方便，但是不支持随机取值，每次都只能从一端开始遍历，直到找到查询的对象，然后返回；不过，它不像 ArrayList 那样需要进行内存拷贝，因此相对来说效率较高，但是因为存在额外的前驱和后继节点指针，因此占用的内存比 ArrayList 多一些。

LinkedList除了继承了List和Collection的所有方法，根据其链表的特性，还特有几种方法

1
2
3
4
5
6
void addFirst(E e); //将指定元素添加到此集合的开头
void addLast(E e); //将指定元素添加到此集合的末尾
Elemtype getFirst();    //返回此集合的第一个元素
Elemtype getLast();	 //返回此集合的最后一个元素
Elemtype removeFirst(); //删除此集合中的第一个元素
Elemtype removeLast();  //删除此集合中的最后一个元素

Queue（队列）

Queue是一个队列集合，队列通常是指“先进先出”（FIFO）的容器。新元素插入（offer）到队列的尾部，访问元素（poll）操作会返回队列头部的元素。通常，队列不允许随机访问队列中的元素

ArrayDeque （双端队列）

ArrayQueue是一个基于数组实现的双端队列，可以想象，在队列中存在两个指针，一个指向头部，一个指向尾部，因此它具有“FIFO队列”及“栈”的方法特性。

既可以先进先出，也可以先进后出

常用方法 

1
2
3
4
5
6
7
8
9
10
11
//队列常用方法：
boolean isEmpty();//队列空返回真，否则返回假
void  peek();//获取队头元素，但不出栈
boolean offer(E e);//入队
Elemtype poll();//出队，获取并移除队头元素，若为空则返回Null

//栈常用方法：
boolean isEmpty();//栈空返回真，否则返回假
void  peek();//获取栈顶元素，但不出栈
void push(E e);//入栈
Elemtype pop(E e);//出栈,获取并移除栈顶元素，若为空则返回Null

PriorityQueue（优先队列）

PriorityQueue也是一个队列的实现类，此实现类中存储的元素排列并不是按照元素添加的顺序进行排列，而是内部会按元素的大小顺序进行排列，是一种能够自动排序的队列。

LinkedList（双向链表）

双向链表同样也实现了Queue类

Set(集)

Set集合的特点：元素不重复，存取无序，无下标；

Set 集合的实现，基本都是基于 Map 中的键做文章，使用 Map 中键不能重复、无序的特性；所以，我们只需要重点关注 Map 的实现即可！

Set和数组之间的转化

  • Set———>数组

采用toArray(new Integer[] {})方法直接转为Integer数组，然后再转为整型数组；

1
2
3
4
5
6
7
8
9
10
11
12
private static int[] SetToInt(Set<Integer> allSet) {
        // 先将set集合转为Integer型数组
        Set<Integer> allSet = new TreeSet<Integer>();
        Integer[] temp = allSet.toArray(new Integer[] {});//关键语句
 
        // 再将Integer型数组转为int型数组
        int[] intArray = new int[temp.length];
        for (int i = 0; i < temp.length; i++) {
            intArray[i] = temp[i].intValue();
        }
        return intArray;
    }

  • 数组 ———>Set

    使用Stream API

    1
    2
    int[] intArray = {1, 2, 3};
    Set<Integer> set = Arrays.stream(intArray).boxed().collect(Collectors.toSet());

HashSet（哈希集）

HashSet底层是基于 HashMap 的k实现的，元素不可重复，特性同 HashMap。

LinkedHashSet（链表哈希集）

LinkedHashSet底层也是基于 LinkedHashMap 的k实现的，一样元素不可重复，特性同 LinkedHashMap。

TreeSet（树集）

同样的，TreeSet 也是基于 TreeMap 的k实现的，同样元素不可重复，特性同 TreeMap；

独特方法

因为TreeMap实现了具有一些独特方法，所以TreeSet同样也有

1
2
3
4
5
6
7
8
9
10
11
12
Elemtype ceiling(E e);
//返回在这一组大于或等于e的最小元素，如果没有这样的元素则返回null。
Elemtype higher(E e);
//返回Set中大于e的最小元素
Elemtype floor(E e);
//返回在这一组中小于或等于e的最大元素,如果没有这样的元素则返回null
Elemtype lower(E e);
// 返回Set中小于e的最大元素
Elemtype first();
//返回第一个 （最小） 元素
Elemtype last();
//返回最后一个(最高)元素