Java集合

-----小破站韩顺平老师学习笔记

鉴于数组的局限性（不易扩容，保存的都是同一类型，等等），集合，横空出世。

1. 集合主要两类（单列集合和双列集合）

2. Collection接口的两个 重要的字接口 List、Set。他们的实现子类都是单列集合。

3. Map接口的实现子类是双列集合，存放（K-V）

单列集合体系图：

双列集合体系图：

Collection常用方法

包括增删改等等

public class CollectionMethod {
    public static void main(String[] args) {
        // Collection常用方法，以ArrayList为例
        List list = new ArrayList();

        // add: 添加单个元素
        list.add("wxl");
        list.add(145);
        list.add(true);
        System.out.println(list);

        // remove 删除
        // list.remove("wxl");//指定删除某个元素
        list.remove(1);//删除下标为1 的元素
        System.out.println(list);

        // contains: 查
        System.out.println(list.contains("wxl")); // 返回布尔变量
        // size:元素个数
        System.out.println(list.size());
        // isEmpty: 判断是否为空
        System.out.println(list.isEmpty());
        // clear : 清空
//        list.clear();
//        System.out.println(list);
        // addAll: 添加多个元素
        List list1 = new ArrayList();
        list1.add("三国演义");
        list1.add("西游记");
        list.addAll(list1);
        System.out.println(list);
        // contains: 查找多个元素是否存在
        System.out.println(list.containsAll(list1));
        // removeAll : 删除多个元素
        System.out.println(list.removeAll(list1)); // true
        System.out.println(list);
    }
}

iterator迭代器

迭代器介绍：

迭代器用法及细节：

public class Iterator_ {
    public static void main(String[] args) {
        // 迭代器
        Collection col = new ArrayList();
        col.add(new Book("三国演义", "罗贯中", 9.9));
        col.add(new Book("西游记", "吴承恩", 9.9));
        col.add(new Book("龙族", "江南小儿", 9.9));

        // 现在希望遍历 集合， 需要先得到col对应的迭代器
        Iterator iterator = col.iterator();
        // 使用while循环遍历
//        while(iterator.hasNext()){ //判断是否还有数据
//            Object obj = iterator.next();//返回下一个元素，类型是Object
//            System.out.println(obj);
//        }

        // 可以使用快捷键itit生成迭代器
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }

        // 当退出遍历循环后，这时迭代器指向最后一个元素
        // 若需要再次遍历，需要重置迭代器
        iterator = col.iterator();
        System.out.println("=======第二次遍历=========");
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }

    }
}

class Book{
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

增强for

public class CollectionFor {
    public static void main(String[] args) {
        //增强for
        Collection col = new ArrayList();
        col.add(new Book("三国演义", "罗贯中", 9.9));
        col.add(new Book("西游记", "吴承恩", 9.9));
        col.add(new Book("龙族", "江南小儿", 9.9));

        // 使用增强for遍历集合，其实底层仍然是迭代器，可以说是迭代器遍历的简化版
        // 快捷键 I或者iter
        for (Object object : col) {
            System.out.println(object);
        }

        // 增强for也可以遍历数组
        int[] num = {1,2,3,4,5};
        for (int i : num) {
            System.out.println(i);
        }
    }
}

List

list的特点：

        List list = new ArrayList();
        // 1. List集合类中元素有序（即添加顺序和取出顺序相同），且可重复
        list.add("Jack");
        list.add("Tom");
        list.add("Levi");
        list.add("Penguin");
        list.add("Tom");
        System.out.println(list);
        // 2.List集合中的每个元素都有其对应的顺序索引，即支持索引
        System.out.println(list.get(2));

list的常用方法：

ArrayList

1. ArrayList可以加入（多个）null，

2. ArrayList是由数组实现存储的

3. ArrayList基本等同于Vector，除了ArrayList是线程不安全的（效率高）。

4. ArrayList底层机制结论：

Vector

LinkList

1. LinkList底层维护了一个双向链表

2. LinkList中维护了两个属性first和last，分别指向首节点和尾节点

3. 每个节点又维护了prev、next、item三个属性，next指向后一个节点，prev指向前一个

4. crud：

LinkedList linkedList = new LinkedList();
        // 添加结点
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println(linkedList);

        // 删除结点
        // linkedList.remove(); // 默认删除第一个
        linkedList.remove(1);
        System.out.println(linkedList);

        // 修改
        linkedList.set(1, 999);
        System.out.println(linkedList);

        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

★若增删操作较多，选择LinkedList； 若改查操作较多，选择ArrayList。

Set

// Set接口的实现类的对象（Set接口对象），不能存放重复元素，可以有一个null
// Set接口对象存放的顺序是无序的，
// 取出的顺序虽不是添加的顺序，但固定

// 遍历，可以使用迭代器、增强for，
// Set接口对象，不能通过索引来获取

HashSet

HashSet实现了Set接口

HashSet底层机制（结构上类似于数据结构中的散列表）

1. 添加元素时，会先获得元素的哈希值（hashCode方法）

2. 对哈希值进行运算，得出一个索引值

3. 在该索引值所在的位置上进行遍历，并进行equals判断，若相等，则退出，不添加；若不相等，则以链表的形式添加。

HashSet扩容机制

LinkedHashSet

LinkedHashSet中维护了一个hash表和双向链表，（LinkedHashSet有head和tail）。

因为双向链表的存在，我们可以确保其遍历顺序和插入顺序一致。

TreeSet

当有排序的需求时，可以使用TreeSet

        // 当使用无参构造器时，按照自然顺序排序
        //java.util.TreeSet treeSet = new java.util.TreeSet();

        java.util.TreeSet treeSet = new java.util.TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // 进行字符串比较，当然，也可以进行字符串的长度比较
                // 比较过程中，若遇到相同的，就不加入了
                return ((String) o2).compareTo((String) o1);
            }
        });
        treeSet.add("Jack");
        treeSet.add("Tom");
        treeSet.add("Xl");
        treeSet.add("a");

        System.out.println(treeSet);

Map

1. Map用于保存具有映射关系的数据：Key-Value

2. Map中的key和value可以是任意引用类型的数据，会封装到HashMap$Node对象中。

3. Map中的key不可以重复，Value可以重复

4. key、value都可以为null，但key只能有一个null，value可以有多个

5. key和value存在单项一对一关系，总能通过key找到对应的value

HashMap

扩容机制同HashSet

HashTab

1. 存放键值对

2. 键和值不能为null

3. 线程安全，HashMap线程不安全

TreeMap

public class TreeMap {
    public static void main(String[] args) {
        // 当使用默认无参构造器时，会默认按照自然顺序排序

        // java.util.TreeMap treeMap = new java.util.TreeMap();
        java.util.TreeMap treeMap = new java.util.TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // 按照字符串长度排序，若遇到字符串长度相同时，则覆盖
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        treeMap.put("JoJo", "乔纳森");
        treeMap.put("Tom", "汤姆");
        treeMap.put("Smith", "史密斯");
        treeMap.put("Dio", "迪奥");
        treeMap.put("1" , "奥特曼");
        treeMap.put("1" , "怪兽"); // 在排序过程中，发现与存在的“1”相同，则key不变，value改变

        System.out.println(treeMap);
    }
}

开发中使用场景