【前端java进阶】集合（01）

引言

对前端来说，集合是一个新概念，理解起来会比较模糊。简单来说，它提供了更加丰富的数据储存形式。

回想一下前端的数组数据储存：

let relax = [
    {time:"9:00",do:"sleep"},
    {time:"12:00",do:"eat"}
]

我们想添加数据也非常容易

relax.push({time:"14:00",do:"game"})

我们的数组每一项甚至可以是各种奇怪的类型

let demo = [
     "1",
      2,
     {name:"shixiaoshi",age:18},
     [1,2,3],
     [{name:"mingren"},1,2]
     ....
]

但是，在Java中，我们的数组不能这么随意。java中，数组的长度一开始都是限定好的，不能动态改变长度

// 创建一个包含5个int类型元素的数组
int[] numbers = new int[5];

而且类似于下面前端代码的数据结构，他也是不能储存的。

let relax = [
    {time:"9:00",do:"sleep"},
    {time:"12:00",do:"eat"}
]

集合的出现就是用来储存各种花里胡哨的数据结构的！当然，这只是他最基本的功能！

语法简介

Java的集合提供了一组接口 和类（框架），用于存储和操作一组对象。这个框架的主要目的是为了方便地处理一组数据，如数据的存储、检索、删除、排序等操作。

java的集合框架可以简单分为两大类：

• 单一数据处理的Collection接口
• 键值对数据处理的Map接口

单一数据值单独一个对象或值，如整数、字符或一个自定义对象。键值对数据如前端中的{name:"shixiaoshi"}这种数据结构。

每种接口都有自己擅长的数据操作"领域"，我们将在下面的章节详细讨论这些子接口中的类方法作用及使用场景。

Collection接口

Collection接口是Java集合框架中的基本接口，它代表一组对象，提供了基本的集合操作。

它主要包含如下三个子接口

• List接口：继承自Collection接口，代表一组有序的元素，支持通过索引访问和修改元素。List接口的常用实现类包括ArrayList、LinkedList等。
• Set接口：继承自Collection接口，代表一组无重复元素的集合，不支持通过索引访问和修改元素。Set接口的常用实现类包括HashSet等。
• Queue接口：继承自Collection接口，代表一组元素的有序集合，支持在队列的头部和尾部插入和删除元素。Queue接口的常用实现类包括LinkedList、PriorityQueue等。

Queue接口用的比较少，本文不做详细介绍。

List接口

ArrayList

ArrayList是Java中的一个类，实现了List接口，可以用来存储一组对象。基础语法如下：

import java.util.ArrayList;

public class List {
    public static void main(String[] args) {
        // 创建一个空的ArrayList  
        ArrayList list = new ArrayList();  
          
        // 增：添加元素到ArrayList中  
        list.add("shixiaoshi");
        list.add("Duoramen");
        System.out.println(list);   // [shixiaoshi, Duoramen]

        // 删：删除元素  
        list.remove(0); // 删除第一个元素  
        System.out.println(list);  // [Duoramen]

        // 改：修改元素
        list.set(0,"shixiaoshi");
        System.out.println(list);  // [shixiaoshi]
        
        // 查：获取元素  
        Object ele = list.get(0);
        System.out.println(ele);   // shixiaoshi  
          
        // 检查ArrayList是否包含某个元素  
        boolean contains = list.contains("pig");
        System.out.println(contains);  // false  
          
        // 获取ArrayList的大小 (同前端数组中的length属性) 
        int size = list.size(); // 返回ArrayList的大小
        System.out.println(size); // 1
   }
}

注，上述代码获取元素方法中的ele类型是Object，如果写String会报错

这是因为，ArrayList是一个泛型类，这意味着它只能存储特定类型 的数据。在这种情况下，你创建了一个ArrayList对象，但没有指定它应该存储哪种类型的对象。在这种情况下，编译器会默认你正在创建一个Object类型的ArrayList，因此ele的类型只能是Object

LinkedList

ArrayList和LinkedList都是Java中的List接口的实现类，它们提供了许多相同的方法来操作列表中的元素。他们相同的方法有

1. 添加元素

• • add(E e)：在列表的末尾添加指定的元素。
  • add(int index, E element)：在指定的位置插入指定的元素。

2. 删除元素

• • remove(Object o)：从列表中删除第一个（索引最小的）等于指定参数的元素。
  • remove(int index)：移除指定位置的元素。

3. 查询元素

• • get(int index)：返回指定位置的元素。
  • indexOf(Object o)：返回首次出现指定元素的索引，如果不存在则返回-1。
  • lastIndexOf(Object o)：返回最后一次出现指定元素的索引，如果不存在则返回-1。

4. 迭代元素

• • iterator()：返回一个迭代器，用于遍历列表。
  • listIterator()：返回一个ListIterator，用于遍历列表。

5. 修改元素

• • set(int index, E element)：用指定元素替换指定位置的元素。

6. 其他操作

• • isEmpty()：判断列表是否为空。
  • size()：返回列表中的元素数。
  • contains(Object o)：判断列表中是否包含指定元素。

专属LinkedList的方法有

import java.util.LinkedList;

public class List {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("xiao");

        // 在列表头部添加元素。
        list.addFirst("shi");
        System.out.println(list);  // [shi, xiao]

        // 在列表尾部添加元素
        list.addLast("shi");
        System.out.println(list); // [shi, xiao, shi]

        // 移除并返回列表头部的元素
        Object first =  list.removeFirst();
        System.out.println(first); // shi
        System.out.println(list);  // [xiao, shi]

        // 移除并返回列表尾部的元素
        Object end = list.removeLast();
        System.out.println(end);  // shi
        System.out.println(list); // [xiao]
    }
}

import java.util.LinkedList;

public class List {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("shi");
        list.add("xiao");
        list.add("shi");

        //  getFirst()：返回并列表头部的元素。
        Object first =  list.getFirst();
        System.out.println(first);   // shi
        System.out.println(list);    ////[shi, xiao, shi]

        //   getLast()：返回列表尾部的元素。
        Object end = list.getLast();
        System.out.println(end);  // shi
        System.out.println(list); //[shi, xiao, shi]
    }
}

Set接口

HashSet

HashSet是Java集合框架的一部分，它实现了Set接口。HashSet的主要特点是不保证元素的顺序，并且它不允许出现重复元素。它的基础方法和List接口是一样的。

import java.util.HashSet;

public class Set_HashSet {
    public static void main(String[] args) {
        HashSet setList = new HashSet();
        setList.add("shi");
        setList.add("xiao");
        setList.add("shi");
        System.out.println(setList);   // [shi, xiao]
    }
}

上述代码展示了重复的数值会被删除。

Map接口

Map是Java集合框架的一部分，它是一个接口，定义了操作键/值对的方法。Map接口的两个主要实现HashMap和TreeMap。

我们简单探讨一下HashMap的使用

import java.util.HashMap;
import java.util.Set;

public class Map_HashMap {
    public static void main(String[] args) {
        // 创建一个新的HashMap
        HashMap map = new HashMap();

        // put方法：添加键值对
        map.put("name","shixiaoshi");
        map.put("age","18");
        map.put("sex","男");

        System.out.println(map);  // {sex=男, name=shixiaoshi, age=18}

        // get方法：获取键对应的值
        Object name = map.get("name");
        System.out.println(name);  // shixiaoshi

        // remove方法：删除键值对
        map.remove("sex");
        System.out.println(map);  // {name=shixiaoshi, age=18}

        // containsKey方法：检查Map中是否包含指定的key
        boolean containsName = map.containsKey("name");
        System.out.println(containsName);  // true

        // containsValue方法：检查Map中是否包含指定的value
        boolean containsValue = map.containsValue("18");
        System.out.println(containsValue);         // true

        // isEmpty方法：检查Map是否为空
        boolean isEmpty = map.isEmpty();
        System.out.println(isEmpty);   // false

        // size方法：返回Map中的键值对的数量
        int size = map.size();
        System.out.println(size);  // 2

        // keySet方法：返回Map中所有的key的集合视图
        Set keys = map.keySet();
        System.out.println(keys);  //[name, age]
    }
}

迭代器

在计算机科学中，迭代器（Iterator）是一个对象，它能够遍历并选择序列中的对象。迭代器通常用于列表、数组或其他类型的数据集合的数据访问。

迭代器通常具有以下方法：

1. hasNext()：检查是否还有下一个元素。如果有，则返回true；否则返回false。
2. next()：返回当前元素并将指针移动到下一个元素。

使用迭代器可以遍历集合中的所有元素，我们ArrayList类的Iterable接口为例

import java.util.ArrayList;
import java.util.Iterator;

public class Iterator_case {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("1");
        list.add("2");
        list.add("3");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object num = iterator.next();
            System.out.println(num);  // 1 2 3
        }
    }
}

工具类

在Java中，对于数组和集合的处理，有一些常用的工具类，它们提供了各种功能和操作，帮助开发者更高效地处理数据。

Arrays

Arrays是Java中的一个工具类，它提供了许多用于操作数组的方法：

• asList(): 将数组转换为List集合。
• sort(): 对数组进行排序。
• toString(): 返回数组的字符串表示形式。
• equals(): 比较两个数组是否相等。
• indexOf(): 返回指定元素在数组中的索引。

import java.util.Arrays;

public class Array_utils {
    public static void main(String[] args) {
        // asList()方法演示
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        System.out.println(list);                    // [1, 2, 3, 4, 5]
        
        // toString()方法演示
        int[] is = {1,2,4,5};
        System.out.println(Arrays.toString(is));    // [1, 2, 4, 5]
        System.out.println(is);                     // [I@1b6d3586
    }
}