Java 学习笔记（十四）集合

集合

在开发的时候，如果需要存储多个数据，可以使用数组，不过数据是固定长度的，如果需要存储可变长度的多个数据，可以使用集合。集合提供存储空间可变的存储类型，存储的容量可以实时改变

集合分类

• Collection 单列集合（接口）
  • List （接口）存储的值可以重复
    • ArrayList（实现类）
    • LinkedList（实现类）
  • Set（接口）存储的值不可重复
    • HashSet（实现类）
    • TreeSet（实现类）
• Map 双列集合（接口）
  • HashMap（实现类）
  • TreeMap（实现类）

Collection

Collection 是单列集合的顶层接口，它表示一组对象，这些对象也称为 Collection 的元素

JDK 不提供接口的任何实现，但是提供更具体的子接口，比如 List Set 实现接口

Collection 集合的常用方法

方法名	说明
boolean add(E e)	添加元素
int size()	返回集合中元素的个数
boolean isEmpty()	判断集合是否为空
boolean contains(Object o)	判断集合中是否存在指定元素
void clear()	清空集合
boolean remove(Object o)	删除指定元素

Iterator 迭代器

迭代器是集合专用的遍历方式，通过集合对象的 iterator 方法获取

迭代器的常用方法

方法名	说明
next()	返回下一个元素
boolean hasNext()	判断是否可迭代

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

/**
 * 迭代器
 */
public class IteratorDemo {
    public static void main(String[] args) {
        // 以多态的形式创建一个 Collection 对象
        Collection list = new ArrayList<>();

        // 给集合添加元素
        list.add("i");
        list.add("t");
        list.add("e");
        list.add("r");

        // 创建一个迭代器
        Iterator iter = list.iterator();

        // 判断是否可迭代，如果可迭代
        while (iter.hasNext()){
            // 输出下一个元素
            System.out.println(iter.next());
        }
    }
}

list

list 集合是可重复的，可以通过索引值访问集合中的元素

list 集合的常用方法

方法名	说明
void add(int index, E e)	添加元素
E get(int index)	获取元素
E set(index, E e)	设置元素
E remove(int index)	删除元素

ListIterator

ListIterator 是 list 集合的专属迭代器，通过集合的 ListIterator() 方法获取迭代器对象

ListIterator 在迭代期间可以修改集合，而且执行获取双向的迭代操作

ListIterator 中的常用方法

方法名	说明
void add(E e)	添加元素
E next()	返回迭代器中的下一个元素
boolean hasNext()	判断迭代器中是否有下一个元素
E pervious()	返回迭代器中的上一个元素
boolean hasPervious()	判断迭代器中是否有上一个元素

ListIterator 常用的应用示例

import java.util.ArrayList;
import java.util.ListIterator;

/**
 * ListIterator
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建一个 list
        ArrayList list = new ArrayList<>();
        // 添加元素
        list.add("h");
        list.add("e");
        list.add("l");
        list.add("o");
        // 创建一个 ListIterator
        ListIterator listIter = list.listIterator();

        // 判断迭代器中是否有下一个元素，如果有
        while (listIter.hasNext()){
            // 把迭代器中的下一个元素赋值给变量 s
            String s = listIter.next();
            // 判断如果下一个元素是 l
            if ("l".equals(s)){
                // 通过迭代器向集合中添加一个元素 l
                listIter.add("l");
            }
            // 输入迭代器中的下一个元素
            System.out.println(s);
        }
        System.out.println("~~~");
        // 判断迭代器中是否有上一个元素，如果有
        while (listIter.hasPrevious()){
            // 输出迭代器中的上一个元素
            System.out.println(listIter.previous());
        }
    }
}

数据结构

数据结构是计算机存储，组织数据的一种方式

栈

栈模型只有一个开口，数据==先进后出==

栈底元素：最先进入栈模型的元素

栈顶元素：最后进入栈模型的元素

进栈、压栈：数据进入栈模型的过程

出栈、弹栈：数据离开栈模型的过程

/**
 * 栈
 */
public class Demo01 {
    public static void main(String[] args) {
        say(3);
    }

    private static void say (int num) {
        System.out.println(num);
        if (num > 1) {
            say(num - 1);
        }
        System.out.println(num);
    }
}

队列

队列模型，两端都有开口，数据==先进先出==

入队列：数据进入队列模型的过程

出队列：数据离开队列模型的过程

数组

数组查询、修改快，增加、删除慢

查询和修改数据通过索引定位，对于任意位置的数据耗时相同，查询效率高

增加数据，需要将插入位置之后的所有数据依次后移，效率低

删除数据，需要将删除位置之后的所有数据一次前移，效率低

链表

链表增加、删除快，查询、修改慢

节点：一个数据单元

指针域：用来存储节点地址的存储空间

数据域：用来存储实际数据的存储空间

List 集合实现类的特点

• ArrayList 底层数据结构是数组，查询、修改快，添加、删除慢
• LinkedList 底层数据结构是链表，添加、删除快，查询、修改慢

ArrayList

ArralList 类的常用方法

方法名	说明
public ArrayList()	无参构造方法，用于创建一个空集合
public boolean add(E e)	添加元素到集合的末尾
public void add(int index, E element)	添加元素到集合的指定位置
public E get(int index)	返回指定索引位置的元素
public int size()	返回集合的元素个数
public E set(int index, E element)	修改指定元素，返回修改的元素
publec boolean remmove(Object o)	删除指定元素，返回是否删除成功
public E remove(int index)	删除指定元素，返回被删除的元素

应用示例

import java.util.ArrayList;

/**
 * Arraylist 的基本使用
 */
public class Demo01 {
    public static void main(String[] args) {
        // 调用无参构造方法，创建一个空集合
        ArrayList list = new ArrayList<>();

        // 添加元素到集合末尾
        list.add("hello");
        list.add("list");

        // 打印集合，输出结果：[hello, list]
        System.out.println(list);

        // 遍历集合中的元素，使用 size() 和 get()
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 遍历集合中的元素，使用 foreach
        for (String str:list) {
            System.out.println(str);
        }

        // 添加元素到集合的指定位置
        list.add(1, "world");
        // 输出结果：[hello, world, list]
        System.out.println(list);

        // set(int index, E element) 修改集合中的元素
        String se = list.set(2, "ArrayList");
        // 输出结果：list
        System.out.println(se);
        // 输出结果：[hello, world, ArrayList]
        System.out.println(list);

        // remove(Object o) 删除指定元素，返回是否删除成功
        boolean re = list.remove("ArrayList");
        // 输出结果：true
        System.out.println(re);
        // 输出结果：[hello, world]
        System.out.println(list);

        // remove(int index) 删除指定元素，返回删除的元素
        String re1 = list.remove(1);
        // 输出结果：world
        System.out.println(re1);
        // 输出结果：[hello]
        System.out.println(list);
    }
}

使用 ArrayList 存储对象

/**
 * 定义一个学生类
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/**
 * 使用集合存储学生对象
 */

import java.util.ArrayList;
import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        ArrayList stuList = new ArrayList<>();

        String name;
        int age;

        for (int i = 0; i < 3; i++) {
            System.out.println("请输入学生姓名");
            name = new Scanner(System.in).next();
            System.out.println("请输入学生年龄");
            age = new Scanner(System.in).nextInt();
            stuList.add(new Student(name, age));
        }

        System.out.println(stuList);
    }
}

LinkedList

LinkedList 类的常用方法

方法名	说明
public void addFirst(E e)	在列表的第一个位置添加元素
public void addLast(E e)	在列表的最后一个位置添加元素
public E getFirst()	获取列表的第一个元素
public E getLast()	获取列表的最后一个元素
public E removeFirst()	删除列表的第一个元素，返回删除的元素
public E removeLast()	删除列表的最后一个元素，返回删除的元素

应用示例

import java.util.LinkedList;

/**
 * LinkedList
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建一个 LinkedList 对象
        LinkedList linkedList = new LinkedList<>();

        // 添加元素
        linkedList.add("e");
        linkedList.add("l");
        linkedList.add("l");

        // 添加元素到第一个位置
        linkedList.addFirst("h");
        // 添加元素到最后一个位置
        linkedList.addLast("o");

        // 输出结果：[h, e, l, l, o]
        System.out.println(linkedList);

        // 获取第一个元素，输出结果：h
        System.out.println(linkedList.getFirst());
        // 获取最后一个元素，输出结果：o
        System.out.println(linkedList.getLast());

        // 删除第一个元素，输出结果：h
        System.out.println(linkedList.removeFirst());
        // 输出结果：[e, l, l, o]
        System.out.println(linkedList);
        // 删除最后一个元素，输出结果：o
        System.out.println(linkedList.removeLast());
        // 输出结果：[e, l, l]
        System.out.println(linkedList);
        
    }
}

Set

Set 是一个接口，需要通过实现类来对其进行操作

Set 集合的特点：

• 不包含重复的元素
• 没有带索引的方法，不能通过普通的 for 循环利用索引的方式进行遍历

哈希值

哈希值是 JVM 根据对象的地址或者字符串或者数值计算出来的一个 int 类型的数值

Object 类中有一个可以获取对象哈希值的方法：public int hashCode()

哈希值的特点：

• 同一个对象的哈希值是相同的
• 一般情况下，不同的对象，哈希值是不同的，但是有特殊情况

哈希表

哈希表是通过数组 + 链表的形式实现的

任何数%16之后的结果都小于15，然后再取绝对值，得到0～15范围的数值

哈希表的底层是一个拥有16个存储空间的数组，对元素取哈希值，再%16，再取绝对值，再根据得到的值，存储到数组对应的位置，比如有一个元素，经过取哈希值，%16，取绝对值之后得到的值是0，那就把它存储在数据的第一个位置。相同位置的元素以链表的形式连接起来。

image

HashSet

HashSet 集合的底层数据结构是哈希表

HashSet 集合的特点

• 不包含重复的元素
• 存、取的顺序不一致
• 没有带索引参数的方法，不能使用索引进行遍历

import java.util.HashSet;
import java.util.Iterator;

/**
 * HashSet
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建 HashSet 对象
        HashSet hashSet = new HashSet<>();

        // 添加元素
        hashSet.add("h");
        hashSet.add("e");
        hashSet.add("l");
        hashSet.add("l");
        hashSet.add("o");

        // 输出结果：[e, h, l, o]
        System.out.println(hashSet);

        // 遍历，使用 foreach
        for (String str : hashSet) {
            System.out.println(str);
        }

        // 遍历，使用迭代器
        // 创建迭代器对象
        Iterator iter = hashSet.iterator();
        // 如果迭代器中有下一个元素
        while (iter.hasNext()) {
            // 输出迭代器中的下一个元素
            System.out.println(iter.next());
        }
    }
}

LinkedHashSet

LinkedHashSet 集合底层数据结构是哈希表 + 链表

LinkedHashSet 集合的特点：

• 存、取的顺序一致
• 没有重复的元素

import java.util.LinkedHashSet;

/**
 * LinkedHashSet
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建 LinkedHahSet 对象
        LinkedHashSet lhSet = new LinkedHashSet<>();

        // 添加元素
        lhSet.add("h");
        lhSet.add("e");
        lhSet.add("l");
        lhSet.add("l");
        lhSet.add("o");

        // 输出结果：[h, e, l, o]
        System.out.println(lhSet);
    }
}

TreeSet

TreeSet 集合可以按照一定的排序规则对元素进行排序

TreeSet 集合的特点：

• 没有重复的元素
• 没有索引

自然排序示例

import java.util.TreeSet;

/**
 * TreeSet
 * 自然排序
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建一个 TreeSet 对象
        TreeSet tSet = new TreeSet<>();

        // 添加元素
        tSet.add(2);
        tSet.add(4);
        tSet.add(3);
        tSet.add(1);

        // 输出结果：[1, 2, 3, 4]
        System.out.println(tSet);
    }
}

使用接口对对象进行排序示例

/**
 * 定义一个类，实现 Comparable 接口
 */
public class Stdent implements Comparable {
    private String name;
    private int age;

    public Stdent() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Stdent stu) {
        // 比较年龄
        int re = this.getAge() - stu.getAge();
        // 如果年龄相等，返回比较姓名的结果，如果年龄不相等，直接返回比较年龄的结果
        return re == 0 ? this.getName().compareTo(stu.getName()) : re;
    }
}

import java.util.TreeSet;

/**
 * TreeSet
 * 使用接口对对象排序
 */
public class Demo02 {
    public static void main(String[] args) {
        // 创建 TreeSet 对象
        TreeSet tSet = new TreeSet<>();

        // 添加元素
        tSet.add(new Stdent("小明", 19));
        tSet.add(new Stdent("小红", 18));
        tSet.add(new Stdent("张三", 20));

        // 输出结果：[Student{name='小红', age=18}, Student{name='小明', age=19}, Student{name='张三', age=20}]
        System.out.println(tSet);

    }
}

泛型

泛型是提供编译时类型安全的检测机制。该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说操作的数据类型可以被指定为一个参数

泛型可以应用在类、方法和接口中，分别称之为泛型类，泛型方法和泛型接口

泛型的定义格式

• <引用数据类型> 指定一种数据类型
• <类型1, 类型2,...> 指定多种数据类型，多种类型之间用逗号分隔

使用泛型的好处

• 把运行时期的问题提前到了编译时期，可以更早的发现问题
• 避免强制类型转换的问题

泛型类

泛型类的定义格式

修饰符 class 类名<数据类型>{}

比如:

public class Generic{}

泛型类示例

/**
 * 定义一个泛型类
 */
public class GenericClass {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

/**
 * 泛型类
 */
public class GenericClassDemo {
    public static void main(String[] args) {
        // 使用泛型类传递 String 
        Generic strG = new Generic<>();
        strG.setT("hello");
        System.out.println(strG.getT());

        // 使用泛型类传递 int
        Generic intG = new Generic<>();
        intG.setT(123);
        System.out.println(intG.getT());

        // 使用泛型类传递 Student
        Generic stuG = new Generic<>();
        stuG.setT(new Student("小明", 18));
        System.out.println(stuG.getT());
    }
}

泛型方法

泛型方法的定义格式

​ 修饰符 <数据类型> 返回值类型 方法名(数据类型 变量名) {}

比如

​ public void show(T t){}

泛型方法示例

/**
 * 定义一个泛型方法
 */
public class GenericMethod {
    public  void show(T t) {
        System.out.println(t);
    }
}

public class GenericMethodDemo {
    public static void main(String[] args) {
        GenericMethod genericMethod = new GenericMethod();
        genericMethod.show("String");
        genericMethod.show(123);
        genericMethod.show(3.14);
    }
}

泛型接口

泛型接口的定义格式

​ 修饰符 interface 接口名<数据类型>{}

比如：

​ public interface GenericInterface{}

泛型接口示例

/**
 * 定义一个泛型接口
 */
public interface GenericInterface {
    void show(T t);
}

/**
 * 泛型接口的实现类
 */
public class GenericInterfaceClass implements GenericInterface {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

public class GenericInterfaceDemo {
    public static void main(String[] args) {
        GenericInterfaceClass strInter = new GenericInterfaceClass<>();
        strInter.show("String");

        GenericInterfaceClass intInter = new GenericInterfaceClass<>();
        intInter.show(123);

        GenericInterface douInter = new GenericInterface() {
            @Override
            public void show(Double dou) {
                System.out.println(dou);
            }
        };
        douInter.show(3.14);
    }
}

泛型通配符

泛型通配符

​ 比如 List 表示未知类型的 List ，它的元素可以匹配任何数据类型

泛型通配符的上限

​ 比如 List 表示类型可以是 Number 或者其子类

泛型通配符的下限

​ 比如 Lits 表示类型可以是 Number 或者器父类

通配符示例

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

/**
 * 泛型通配符
 */
public class GenericTpf {
    public static void main(String[] args) {
        // 泛型通配符的上限
        List list1 = new ArrayList();
        List list2 = new ArrayList();
        // Object 超过了 Number 的上限，所以会报错
        // List list3 = new ArrayList