2021-10-12 集合

最新推荐文章于 2022-06-24 16:03:07 发布

GuYue2651

最新推荐文章于 2022-06-24 16:03:07 发布

阅读量10w+

点赞数

分类专栏： Java学习文章标签：数据结构 java

本文链接：https://blog.csdn.net/hjr2651/article/details/120718052

版权

Java学习专栏收录该内容

19 篇文章 0 订阅

订阅专栏

集合

1 集合概述

一种容器，可以容纳其他类型数据。数组就是一个集合

一个载体，可以一次容纳多个对象

开发中常用

集合本身是Java对象，集合不能直接存储基本数据类型，也不能直接存储JAVA对象，存储的是引用（内存地址）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VMwsk1yC-1634004729514)(https://i.loli.net/2021/09/22/OUYnKSbjhisQwDq.png)]

不同集合，底层对应不同数据结构。往不同集合中存储数据，等于将数据放到不同的数据结构中。

常见数据结构：数组、二叉树、链表、哈希表

所有集合类合集合接口都在java.util包下

最好能将集合继承结构图背会

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hZE9IuxA-1634004729520)(https://i.loli.net/2021/09/22/K3zEH8fF7WQCy4A.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t9JSoDL5-1634004729522)(https://i.loli.net/2021/09/22/LsATnhpgXOU86CZ.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YzUaUF5F-1634004729523)(https://i.loli.net/2021/09/22/V9EwxzOSapgbnch.png)]

java 集合分两类：

以单个方式存储元素

这一类集合中超级父接口：java.uti1.Collection;

以键值对方式存储元素

这一类集合中超级父接口：java.uti1.Map;

2 Collection中的常用方法

没有使用“泛型”，collection中可以存储Object中所有的子类型

使用”泛型“，collection中只能存储某个具体的类型。

现阶段没有使用”泛型“，什么都可以存，只要是Object的子类型。

boolean add(Object e)

向集合中加元素e

package com.collection;

import com.object.demo04.Student;

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

public class ColTest01 {
    public static void main(String[] args) {
        //Collection c = new Collection();    //接口是抽象的，不能new对象
        Collection c = new ArrayList();       //多态：夫类型new子对象
        c.add(1200);        //自动装箱，实际放进去对象内存地址， Integer x = new Integer(1200);
        c.add(3.14);
        c.add(new Object());
        c.add(new Student());
        c.add(true);

        //add是向集合加元素

    }
}

int size()

获取集合中元素个数

package com.collection;

import com.object.demo04.Student;

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

public class ColTest01 {
    public static void main(String[] args) {
        //Collection c = new Collection();    //接口是抽象的，不能new对象
        Collection c = new ArrayList();       //多态：夫类型new子对象
        c.add(1200);        //自动装箱，实际放进去对象内存地址， Integer x = new Integer(1200);
        c.add(3.14);
        c.add(new Object());
        c.add(new Student());
        c.add(true);

        //add是向集合加元素

        //获取集合中元素个数
        System.out.println("集合中元素个数："+c.size());        //集合中元素个数：5

    }
}

void clear()

移除此 collection 中的所有元素

package com.collection;

import com.object.demo04.Student;

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

public class ColTest01 {
    public static void main(String[] args) {
        //Collection c = new Collection();    //接口是抽象的，不能new对象
        Collection c = new ArrayList();       //多态：夫类型new子对象
        c.add(1200);        //自动装箱，实际放进去对象内存地址， Integer x = new Integer(1200);
        c.add(3.14);
        c.add(new Object());
        c.add(new Student());
        c.add(true);

        //add是向集合加元素

        //获取集合中元素个数
        System.out.println("集合中元素个数："+c.size());        //集合中元素个数：5
        c.clear();
        System.out.println("集合中元素个数："+c.size());        //集合中元素个数：0
        c.add("hello");
        c.add("浩克");
        System.out.println("集合中元素个数："+c.size());        //集合中元素个数：2

        


    }
}

boolean contains(Object o)

如果此 collection 包含指定的元素o，则返回 true。

c.add("hello");
c.add("浩克");
System.out.println(c.contains("浩克"));   //true
System.out.println(c.contains("HELLO"));    //false

注意：Contains方法底层调用了equals方法，比较集合中是否包含字符串对象时，要比较字符串内容是否存在，存在为true，因为字符串重写了equals方法，不再是比较内存地址。contains里的参数对应的类重写equals方法则比较内容，没重写则比较内存地址。

放在集合中的元素，需要重写equals方法。

例如

package com.collection;

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

public class ColTest04 {
    //深入contains方法
    public static void main(String[] args) {
        Collection c = new ArrayList();

        String s1 = new String("abc");
        String s2 = new String("def");

        c.add(s1);
        c.add(s2);

        System.out.println("元素个数："+c.size());

        String x = new String("abc");

        System.out.println(c.contains(x));  //true contains方法调用了equals方法

    }
}

内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kRJVWIis-1634004729524)(https://i.loli.net/2021/09/23/q8jafdnZvKClhgH.png)]

测试

package com.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;

//测试contains方法
public class ColTest05 {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        User u1 = new User("张三");
        User u2 = new User("张三");

        c.add(u1);

        //System.out.println(c.contains(u2)); //false,没有重写equals前
        //System.out.println(u1.equals(u2));  //false

        System.out.println(c.contains(u2)); //T,重写equals后

    }
}

class User{
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        return name.equals(user.name);
    }

    @Override
    public int hashCode() {
        return name.hashCode();
    }
}

boolean remove(Object o)

从此 collection 中移除指定元素的单个实例o。

package com.collection;

import com.object.demo04.Student;

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

public class ColTest01 {
    public static void main(String[] args) {
        //Collection c = new Collection();    //接口是抽象的，不能new对象
        Collection c = new ArrayList();       //多态：夫类型new子对象

        c.add("hello");
        c.add("浩克");
        System.out.println(c.contains("浩克"));   //true
        System.out.println(c.contains("HELLO"));    //false

        System.out.println(c.size());       //2
        c.remove("浩克");
        System.out.println(c.size());       //1


    }
}

注意：remove方法，调用了equals方法，如果重写了equals方法，则按对象内容删除

package com.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;

//测试contains方法
public class ColTest05 {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        User u1 = new User("张三");
        User u2 = new User("张三");

        c.add(u1);

        //System.out.println(c.contains(u2)); //false,没有重写equals前
        //System.out.println(u1.equals(u2));  //false

        System.out.println(c.contains(u2)); //T,重写equals后

        c.remove(u2);
        System.out.println(c.size());   //0

    }
}

class User{
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        return name.equals(user.name);
    }

    @Override
    public int hashCode() {
        return name.hashCode();
    }
}

boolean isEmpty()

如果此 collection 不包含元素，则返回 true。判断集合是否为空

package com.collection;

import com.object.demo04.Student;

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

public class ColTest01 {
    public static void main(String[] args) {
        //Collection c = new Collection();    //接口是抽象的，不能new对象
        Collection c = new ArrayList();       //多态：夫类型new子对象

        c.add("hello");
        c.add("浩克");
        System.out.println(c.contains("浩克"));   //true
        System.out.println(c.contains("HELLO"));    //false

        System.out.println(c.size());       //2
        c.remove("浩克");

        System.out.println(c.size());       //1

        c.clear();
        System.out.println(c.isEmpty());    //true


    }
}

Object[ ] toArray( ) （使用不多）

返回包含此 collection 中所有元素的数组。将集合转换成数组

package com.collection;

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

public class ColTest01 {
    public static void main(String[] args) {
        //Collection c = new Collection();    //接口是抽象的，不能new对象
        Collection c = new ArrayList();       //多态：夫类型new子对象

        c.add("abc");
        c.add("def");
        c.add("xyz");

        Object[] objs = c.toArray();
        for (int i = 0; i < objs.length; i++) {
            System.out.print(objs[i]+" ");      //abc def xyz 
        }



    }
}

3 集合遍历/迭代

迭代器对象 Iterator负责遍历/迭代集合中对象，其的主要方法

boolean hasNext()
如果仍有元素可以迭代，则返回 true。
Object next()
返回迭代的下一个元素。
void remove()
从迭代器指向的 collection 中移除迭代器返回的最后一个元素。

初始状态	迭代一次	继续迭代
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BD0TKGJ2-1634004729525)(https://i.loli.net/2021/09/22/BYfkcn37Cs9qR5G.png)]	[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Obbjoxj-1634004729525)(https://i.loli.net/2021/09/22/FHRhkIDC5Eg69JA.png)]	[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AkWpVhht-1634004729526)(https://i.loli.net/2021/09/22/zl2UYcqWd56mivV.png)]

注意

集合状态只要发生改变，就要重写获取迭代器。

如在集合中添加删除元素后，迭代器必须重写获取

若没重写获取，会出现异常ConCurrentModificationException

package com.collection;

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

//所有Collection中通用，Map不能使用。
public class ColTest02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        c.add("abc");
        c.add("def");
        c.add(100);
        c.add(new Object());

        //遍历
        //1. 获取集合对象的迭代器对象
        Iterator it = c.iterator();
        //2.用迭代器对象迭代/遍历集合
        while (it.hasNext()){
            //不管当初存进去什么，取出来统一都是object
            Object obj = it.next();
            System.out.println(obj);
        }


    }
}

ArrayList集合：有序可重复

HashSet集合：无序不可重复

package com.collection;

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

public class ColTest03 {
    public static void main(String[] args) {
        Collection c1 = new ArrayList();

        //ArrayList集合有序可重复
        c1.add(1);
        c1.add(2);
        c1.add(3);
        c1.add(4);
        c1.add(1);

        Iterator it1 = c1.iterator();
        while (it1.hasNext()){
            //这里取出的还是Integer类型，输出的时候调用了toString方法
            System.out.print(it1.next()+" ");    //1 2 3 4 1
        }


        //HashSet集合：无序不可重复
        Collection c2 = new HashSet();
        c2.add(100);
        c2.add(300);
        c2.add(200);
        c2.add(100);
        System.out.println();
        Iterator it2 = c2.iterator();
        while (it2.hasNext()){
            System.out.print(it2.next()+" ");       //100 200 300 
        }

    }
}

集合迭代过程，不能使用集合对象的remove方法，删除元素

可以使用迭代器对象的remove方法删除

迭代器类似一个**“快照”**

package com.collection;

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

//remove
public class ColTest06 {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        c.add(1);
        c.add(2);
        c.add(3);
        c.add(4);

        Iterator it = c.iterator();
        while (it.hasNext()){
            Object o = it.next();
//          c.remove(o);          //ConcurrentModificationException
            it.remove();    //删除的是迭代器指向的当前元素    
            System.out.println(o);
        }
        System.out.println(c.size());   //0
    }
}

4 List接口的常用方法

List存储元素特点：有序可重复

有序：有下标，从0开始，以一递增

List是Collection的子接口，除了Collection的方法，还有自己的特有子方法

boolean add(Object e)

将指定的元素添加到此列表的尾部。

void add(int index, Object element)

将指定的元素插入此列表中的指定位置。效率较低

package com.collection;

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

public class ListTest01 {
    public static void main(String[] args) {
        List myList = new ArrayList();
        //向末尾加元素
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");

        //指定位置加元素，1为下标，，效率较低
        myList.add(1,"KING");

        Iterator it = myList.iterator();

        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }

    }
}

Object get(int index)

返回此列表中指定位置上的元素。

package com.collection;

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

public class ListTest01 {
    public static void main(String[] args) {
        List myList = new ArrayList();
        //向末尾加元素
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");

        //指定位置加元素，1为下标，，效率较低
        myList.add(1,"KING");

        Iterator it = myList.iterator();

        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }

        //根据下下标获取元素
        Object firstobj = myList.get(0);
        System.out.println(firstobj);       //A
        System.out.println("==========================");


        //循环输出，因为有下标
        for (int i = 0; i < myList.size(); i++) {
            System.out.println(myList.get(i));
        }

    }
}

int indexOf(Object o)

返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

int lastIndexOf(Object o)

返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。

Object remove(int index)

移除此列表中指定位置上的元素。

Object set(int index, E element)

用指定的元素替代此列表中指定位置上的元素。

package com.collection;

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

public class ListTest01 {
    public static void main(String[] args) {
        List myList = new ArrayList();
        //向末尾加元素
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("C");
        myList.add("D");

        //指定位置加元素，1为下标，，效率较低
        myList.add(1,"KING");

        Iterator it = myList.iterator();

        //获取元素第一次出现处的下标
        System.out.println(myList.indexOf("KING"));     //1

        //获取元素最后出现处的下标
        System.out.println(myList.lastIndexOf("C"));    //4

        //删除指定下标位置元素
        myList.remove(0);
        System.out.println(myList.size());  //5

        System.out.println("==================");
        //修改指定位置元素
        myList.set(2,"soft");
        for (int i = 0; i < myList.size(); i++) {
            System.out.println(myList.get(i));
        }

    }
}

5 ArrayList

ArrayList集合，初始化容量为10
底层先创建了一个长度为0的数组，当添加第一个元素时，初始化容量为10
底层是Object类型数组
可以通过有参和无参构造
ArrayList集合的扩容：增长到原容量的1.5倍，底层是数组，所以要尽可能少扩容，要预估合理容量
ArrayList不是线程安全的

面试题

这么多集合中，你用的最多的是哪个？

ArrayList集合，因为往数组末尾添加元素，效率不受影响，我们查找元素用的比较多。

package com.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

public class ArrayListTest01 {
    public static void main(String[] args) {
        List list1 = new ArrayList(20);
        System.out.println(list1.size());   //0     size是获取集合元素个数，不是获取集合容量

        List list2 = new ArrayList();       //默认初始化10
        System.out.println(list2.size());   //0

        Collection c = new HashSet();
        c.add(100);
        c.add(200);
        List list3 = new ArrayList(c);  //将Hashset集合转换为list集合
        for (int i = 0; i < list3.size(); i++) {
            System.out.println(list3.get(i));
        }
    }
}

6 链表数据结构

单向链表数据结构

链表数据结构，基本的单元是节点node。

单向链表任何节点都有两个属性：1）存储的数据，2）下一节点的内存地址

单向链表数据结构图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1uOd6orp-1634004729527)(https://i.loli.net/2021/09/27/vbfXWTGxUM3Ddug.png)]

添加节点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u1em9cCG-1634004729527)(https://i.loli.net/2021/09/27/aljPAp1icUhqXzK.png)]

删除节点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0MILltR3-1634004729528)(https://i.loli.net/2021/09/27/VNuTde4OnqPp3J6.png)]

链表优缺点

优点：随机增删元素效率较高（因为链表元素在空间存储上内存地址不连续，增删元素不涉及大量元素位移）。如果随机增删业务较多，建议使用LinkedList。

缺点：查询效率低，每次查找某个元素都需要从头节点开始往下遍历（不能通过数学表达式计算被查找元素内存地址）

Array List底层是数组，具有数组的优点，把检索发挥到极致

LinkedList将随机增删发挥到极致。

总体而言，ArrayList用的比LinkedList多

链表示例

package com.slink;

public class Link {
    //头节点
    Node header = null;
    private int size = 0;

    public int getSize() {
        return size;
    }

    //向链表种添加元素
    public void add(Object data){
        //创建一个新的节点对象
        //让之前链表的末节点next指向新节点对象
        if(header == null){
            header = new Node(data, null);
        }
        else {
            Node currentLastNode = findLast(header);
            currentLastNode.next = new Node(data,null);
        }
        size++;
    }

    //找末尾节点
    private Node findLast(Node node){
        if(node.next == null){
            return node;
        }
        return findLast(node.next); //递归
    }

    //删除链表某个元素
    public void remove(Object obj){

    }

    //修改
    public void modify(Object obj){

    }

    //查
    public int find(Object obj){
        return 1;
    }


}

/*
package com.slink;

public class Node {
    Object element;     //属性
    Node next;          //下一个节点内存地址

    public Node() {
    }

    public Node(Object element, Node next) {
        this.element = element;
        this.next = next;
    }
}
 */

/*
package com.slink;

public class LinkTest01 {
    public static void main(String[] args) {
        Link link = new Link();
        link.add(100);
        link.add(200);
        link.add("abc");
        System.out.println(link.getSize());
    }
}
 */

双向链表数据结构

基本单元还是node。

上一个节点内存地址+数据+下一个节点内存地址

双向链表数据结构图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2AG47D7m-1634004729528)(https://i.loli.net/2021/09/27/ek7UrDCY41nxbLS.png)]

双向链表添加元素

package com.collection.slink;

import java.util.LinkedList;

public class LinkedListTest01 {
    public static void main(String[] args) {
        LinkedList ll = new LinkedList();
        ll.add("a");
        ll.add("b");
        ll.add("c");
        ll.add("d");
        //LinkedList这个有下标
        for (int i = 0; i < ll.size(); i++) {
            Object o = ll.get(i);
            System.out.println(o);
        }
    }
}

双向链表添加元素内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DMH5Svf2-1634004729529)(https://i.loli.net/2021/09/27/4fP3ATgDdBJmtlZ.png)]

不管是LinkedList还是ArrayList，以后写代码时不需要关心具体是哪个集合。

因为我们都是面向对象编程，调用的方法都是接口中的方法。

package com.collection.slink;

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

public class LinkedListTest02 {
    public static void main(String[] args) {
        //List list = new ArrayList();  作用一样
        List list = new LinkedList();

        list.add(100);
        list.add(200);
        list.add(300);

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

7 Vector

底层也是一个数组

初始化容量10

扩容后是原容量2倍（ArrayList扩容后是原容量1.5倍）

vector中所有方法都是线程同步的，效率较低

package com.collection;

import java.util.*;

public class VectorTest {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add(1);
        vector.add(2);
        vector.add(3);
        vector.add(4);
        vector.add(5);
        vector.add(6);
        vector.add(7);
        vector.add(8);
        vector.add(9);
        vector.add(10);
        vector.add(11);

        Iterator it = vector.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        //将线程不安全转换为线程安全的
        List mylist = new ArrayList();
        Collections.synchronizedCollection(mylist);     //将线程不安全转换为线程安全的

        mylist.add("111");
        mylist.add("222");
        mylist.add("333");

    }
}

集合中将线程不安全转换为线程安全的方法：

使用collections工具类的synchronizedList方法。传入要转换的对象。

8 泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型是在编译阶段，是给编译器看的，运行阶段没用

优点

集合中元素统一了；
集合中取出的元素是指定类型，无需大量的“向下转型”。

缺点

导致集合中存储的元素缺乏多样性

大多数业务中，集合中元素类型是统一的。

举例

未使用泛型

package com.collection;

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

public class GenericTest01 {
    public static void main(String[] args) {
        //不使用泛型
        List myList = new ArrayList();
        //准备对象
        Cat c = new Cat();
        Bird b = new Bird();

        //将对象添加在集合中
        myList.add(c);
        myList.add(b);

        //遍历集合，取出每个Animal，执行move方法
        Iterator it = myList.iterator();
        while (it.hasNext()){
            //注意：通过迭代器取出的是Object，不能写Animal a = it.next();
            Object o = it.next();
            //o中没有move方法，需向下转型
            if(o instanceof Animal){
                Animal a = (Animal) o;
                a.move();
            }

        }
    }
}

class Animal{
    public void move(){
        System.out.println("动物在移动");
    }
}
class Cat extends Animal{
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
class Bird extends Animal{
    public void fly(){
        System.out.println("鸟儿在飞翔");
    }

}

使用泛型

package com.collection;

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

public class GenericTest01 {
    public static void main(String[] args) {
       
        //使用泛型
        //List<Animal>表示使用泛型，集合中只能存储Animal类型数据
        List<Animal> myList = new ArrayList<Animal>();
        Cat c = new Cat();
        Bird b = new Bird();
        myList.add(c);
        myList.add(b);
        //迭代器迭代的是Animal类型
        Iterator<Animal> it = myList.iterator();
        //无需强制转换
        while (it.hasNext()){
            Animal a = it.next();
            a.move();
            //调用子类特有方法还是得抓换。
            if(a instanceof Cat){
                ((Cat) a).catchMouse();
            }
        }
    }
}

class Animal{
    public void move(){
        System.out.println("动物在移动");
    }
}
class Cat extends Animal{
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
class Bird extends Animal{
    public void fly(){
        System.out.println("鸟儿在飞翔");
    }

}

自动类型推断

JDK 8 之后推出了自动类型推断机制。ArrayList<>里的类型会自动推断。又称钻石表达式。

package com.collection;

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

public class GenericTest02 {
    public static void main(String[] args) {
        List<Animal> myList = new ArrayList<>();

        myList.add(new Animal());
        myList.add(new Bird());
        myList.add(new Cat());

        Iterator<Animal> it = myList.iterator();
        while (it.hasNext()){
            Animal a = it.next();
            a.move();
        }

        List<String> myStr = new ArrayList<>();

        myStr.add("http://hexo.guyuer.xyz");
        myStr.add("http://blog.guyuer.xyz");
        myStr.add("http://www.guyuer.xyz");

        Iterator<String> its = myStr.iterator();
        while (its.hasNext()){
            String s = its.next().substring(7);
            System.out.println(s);
        }
    }
}

自定义泛型

package com.collection;

public class GenericTest03 <xyz> {  //xyz只是一个标识符，随便写的，一般写E或者T，不适用泛型默认是Object类型
    public void doSome(xyz o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        GenericTest03<String> gt = new GenericTest03<>();
        gt.doSome("abc");
        //=================================
        GenericTest03<Integer> gt2 = new GenericTest03<>();
        gt2.doSome(124);

        MyIterator<String> mi = new MyIterator<>();
        String s1 = mi.get();

        MyIterator<Animal> mi2 = new MyIterator<>();
        Animal a = mi2.get();
    }

}

class MyIterator<T>{
    public T get(){
        return null;
    }
}

增强for循环，for-each

for(元素类型 变量名 ： 数组或集合){
    sout(变量名);
}

数组中使用foreach

package com.collection;

public class ForEachTest01 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("========================");
        //增强for-each
        for (int data : arr) {      //data就是数组的元素，缺点是没有下标
            System.out.println(data);
        }
    }
}

集合中使用foreach

数组集合的三种输出方式

package com.collection;

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

public class ForEachTest02 {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();

        strList.add("hello");
        strList.add("world");

        //迭代器遍历
        Iterator it1 = strList.iterator();
        while (it1.hasNext()){
            System.out.println(it1.next());
        }
        System.out.println("=============================");
        //下标遍历
        for (int i = 0; i < strList.size(); i++) {
            System.out.println(strList.get(i));
        }
        System.out.println("=============================");

        //使用foreach
        for(String s : strList){
            System.out.println(s);
        }
    }
}

9 Set

HashSet

HashSet集合特点：
无序不可重复

package com.collection;

import java.util.HashSet;
import java.util.Set;

//HashSet集合特点：
//无序不可重复
public class HashSetTest01 {
    public static void main(String[] args) {
        Set<String> s = new HashSet<>();

        s.add("h1");
        s.add("h3");
        s.add("h4");
        s.add("h2");
        s.add("h1");

        for (String st : s){
            System.out.println(st);
        }

        /*
        h1
        h2
        h3
        h4
         */
    }
}

TreeSet

无序不可重复

但存储元素可以自动按照从小到大顺序排序

称为可排序集合

package com.collection;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetTest01 {
    public static void main(String[] args) {
        Set<String> strs = new TreeSet<>();

        strs.add("1");
        strs.add("4");
        strs.add("3");
        strs.add("2");

        for(String s : strs){
            System.out.println(s);
        }
        /*
        1
        2
        3
        4
        */

    }
}

10 Map接口

Map和Collection没有继承关系

Map以key和value的方式存储数据，键值对，key和value都是引用数据类型，存储的都是对象的内存地址。

key起主导地位，value是key的附属品

常用方法

返回值	方法名	作用
void	clear()	从此映射中移除所有映射关系（可选操作）。
boolean	containsKey(Object key)	如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true。
V	get(Object key)	返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
boolean	isEmpty()	如果此映射未包含键-值映射关系，则返回 true。
Set	keySet()	返回此映射中包含的键的 Set 视图。
V	put(K key, V value)	将指定的值与此映射中的指定键关联（可选操作）。添加
V	remove(Object key)	如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int	size()	返回此映射中的键-值映射关系数。获取键值对个数
Collection	values()	获取map中的所有value，返回一个collection
Set<Map.Entry<K,V>>	entrySet()	将Map集合转换为set集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ymIxgDG-1634004729530)(https://i.loli.net/2021/10/04/P9BDdhCaqo6VEpy.png)]

Map集合的常用方法举例

package com.collection;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class MapTest01 {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();

        //添加键值对
        map.put(1,"zhangsan");  //1在这里进行了自动装箱。
        map.put(2,"lisi");
        map.put(3,"wangwu");

        //通过keyh获取value
        String value = map.get(2);
        System.out.println(value);

        //获取键值对数量
        System.out.println("键值对数量："+map.size());

        //通过key删除key-value
        map.remove(2);

        System.out.println("键值对数量："+map.size());

        //判断是否包含某个key和value，底层调用的是equals进行比对，所以自定义类型需要重写equals方法
        System.out.println(map.containsKey(3));
        System.out.println(map.containsValue("lisi"));

        //获取所有value
        Collection<String> values = map.values();
        for(String s : values){
            System.out.println(s);
        }

        //清空
        map.clear();
        System.out.println("键值对数量："+map.size());

        //判断是否为空
        System.out.println(map.isEmpty());

    }

}

Map集合的遍历

获取所有key，通过遍历key来获取value。所有的key是一个set集合。可以通过迭代器/for-each
调用entrySet方法，将把Map集合全部转换为set集合。Set集合中元素类型为Map.Entry。
方法2效率更高，因为获取key和value都是从node对象中获取的属性值，适合大数据量

方法一

package com.collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest02 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"maliu");
        map.put(5,"zhouqi");
        //获取所有key
        Set<Integer> keys = map.keySet();
        //遍历key，迭代器orforeach
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()){
            Integer key = it.next();
            String value = map.get(key);
            System.out.println(key + "=" + value);
        }

        System.out.println("=====================================");
        for (Integer key : keys){
            System.out.println(key + "=" + map.get(key));
        }
        
    }
}

方法二

package com.collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest02 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"maliu");
        map.put(5,"zhouqi");

        Set<Map.Entry<Integer,String>> set = map.entrySet();
        //遍历set每次取出一个Node
        Iterator<Map.Entry<Integer,String>> it = set.iterator();
        while (it.hasNext()){
            Map.Entry<Integer,String> node = it.next();
            Integer key = node.getKey();
            String value = node.getValue();
            System.out.println(key+ "=" +value);
        }
        System.out.println("==========================");
        //for-each
        for (Map.Entry<Integer,String> node : set){
            System.out.println(node.getKey()+"="+node.getValue());
        }

    }
}

11 哈希表数据结构

HashMap集合

HashMap集合底层是哈希表/散列表的数据结构。
哈希表是一个数组和单向链表的结合体。

数组：查询效率高，随机增删效率低；

单向链表：查询效率低，随机增删效率高。

哈希表将两种数据结构融合在一起，充分发挥他们各自的优点。
HashMap集合底层的源代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QlhKin2z-1634004729530)(https://i.loli.net/2021/10/05/iJKUjyGnHYdIqrE.png)]
最主要掌握：

map.put(k,v);

v= map.get(k);
HashMap集合的key部分特点：

无序不可重复。

为什么无序：因为不一定挂到哪个单项链表上。

不可重复是怎么保证的？equals方法保证HashMap的key不可重复。若Key重复value会覆盖。

放到HashMap集合的key部分的元素其实就是放到HashSet集合中了。所以HashSet集合中的元素也需要同时重写hashCode()和equals()方法。
HashMap哈希表使用不当，无法发挥性能。

假设所有hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了纯单向链表。这周中情况成为：散列分布不均匀。

假设所有hashCode()方法返回值都设定为不一样的值，那么会导致底层哈希表变成了一维数组，没有链表的概念了，也是散列分布不均匀。

散列分布均匀需要重写hashCode()时有一定技巧。
重点：放在HashMap集合key部分的元素，以及放在HashSet集合中的元素，需要同时重写hahCode()和equals()方法。哈希值相同的放到同一个数组下标下，哈希值不同的一般放到不同数组下标下，除非哈希碰撞，可能不同哈希值放到同一数组下标位置。
HashMap集合的默认初始化容量是16，默认加载因子是0.75。默认加载因子0.75表示HashMap底层数组容量达到75%的时候，数组开始扩容。扩容后容量是原容量2倍。

重点：HashMap集合初始化容量必须是2的倍数。这也是官方推荐的。

这是要达到散列分布均匀，为了提高HashMap集合的存取效率所必须的。

哈希表数据结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-trQqqRSc-1634004729531)(https://i.loli.net/2021/10/05/FZa7GuM3g2AKfwR.png)]

package com.collection;

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

public class HashMapTest01 {
    public static void main(String[] args) {
        //测试HashMap集合key部分的元素特点
        //Integer是key，他的hashCode()和equals()都重写了
        Map<Integer,String > map = new HashMap<>();
        map.put(1111,"zhangsan");
        map.put(6666,"lisi");
        map.put(7777,"wangwu");
        map.put(2222,"zhaoliu");
        map.put(2222,"king");       //key重复的时候，value会覆盖

        System.out.println(map.size());     //4

        //遍历map集合
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        for(Map.Entry<Integer,String> entry : set){
            //验证结果：HashMap集合key部分元素：无需不可重复
            System.out.println(entry.getKey()+"="+entry.getValue());
        }

    }

}

重写HashCode()方法

向Map集合中存，以及从Map集合中取，都是先调用key的 hashCode()方法，然后再调用 equals()方法!

equals()方法有可能调用，也有可能不调用。

拿put(k,V)举例，什么时候 equals不会调用？

k.hashCode()方法返回哈希值。

哈希值经过哈希算法转换成数组下标。

数组下标位置上如果是null， equals不需要执行。
拿get(k)举例，什么时候 equals()不会调用?

k.hashCode()方法返回哈希值。

哈希值经过哈希算法转换成数组下标。

数组下标位置上如果是null，equals不需要执行。

如果一个类的equals()方法重写了，那么hashCode()方法必须重写。

并且equals方法返回true，hashCode方法返回必须是一样。

equals返回true，表示两个方法相同，在同一个链表上比较，那么对于同一个单向链表上的节点来说，他们的哈希值都是相同的，所以hashCode()方法的返回值应该是相同的。
hashCode()和equals()使用IDEA工具同时生成

package com.collection.hashmap;

import java.util.HashSet;
import java.util.Set;

public class HashMapTest02 {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsan");
        Student s2 = new Student("zhangsan");
        System.out.println(s1.equals(s2));

        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        
        Set<Student> studentSet = new HashSet<>();
        studentSet.add(s1);
        studentSet.add(s2);
        System.out.println(studentSet.size());  //没重写hashCode按说应该是1，现在是2
    }
}

/*
 package com.collection.hashmap;

import java.util.Objects;

public class Student {
    String name;

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

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }
    
}

*/

package com.collection.hashmap;

import java.util.HashSet;
import java.util.Set;

public class HashMapTest02 {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsan");
        Student s2 = new Student("zhangsan");
        System.out.println(s1.equals(s2));

        System.out.println(s1.hashCode());      //-1432604556
        System.out.println(s2.hashCode());      //-1432604556
        
        Set<Student> studentSet = new HashSet<>();
        studentSet.add(s1);
        studentSet.add(s2);
        System.out.println(studentSet.size());  //重写了，现在是1
    }
}

/*
package com.collection.hashmap;

import java.util.Objects;

public class Student {
    String name;

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

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        return name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return name.hashCode();
    }
}

 */

在JDK8之后，如果哈希表单向链表中元素超过8个，单向链表这种数据结构会变成红黑树数据结构。当红黑树上的节点数量小于6时，会重新把红黑树变成单向链表数据结构。是为了提高效率。

测试：HashMap的key部分允许null嘛？

允许，但null值只能有一个。HashMap集合的key和value都是可以为null的。

package com.collection.hashmap;

import java.util.HashMap;
import java.util.Map;

public class HashMapTest03 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put(null,null);
        System.out.println(map.size());     //1

        map.put(null,100);
        System.out.println(map.size());     //1
        System.out.println(map.get(null));  //100
    }
}

测试：Hashtable的key部分允许null嘛？

Hashtable的key和value都不能为空。

Hashtable方法都带有synchronized:线程安全的。线程安全有其它的方案，这个Hashtable对线程的处理导致效率较低，使用较少了。

Hashtable 和HashMap一样，底层都是哈希表数据结构。

Hashtable的初始化容量是11，默认加载因子是：0.75

Hashtable的扩容是：原容量*2+1

Properties属性类的相关方法

Properties是一个Map集合，继承Hashtable，Properties的key和value都是string类型。

Properties被称为属性类对象。

Properties是线程安全的。

掌握Properties的两个方法，一个存，一个取。

12 TreeSet和TreeMap

TreeSet集合底层实际上是一个TreeMap
TreeMap集合底层是一个二叉树。
放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。
TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序。称为：可排序集合。
按照字典顺序，升序
对于自定义类型，TreeSet不能自动排序。因为没有指定对象间的排序规则（自定义类没有实现java.lang.Comparable接口）

TreeSet和TreeMap演示

package com.collection;

import java.util.TreeSet;

public class TreeSetTest02 {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>();
        ts.add("zhanghuan");
        ts.add("lilang");
        ts.add("yangfang");
        ts.add("renkuo");

        //遍历
        for(String s : ts){
            System.out.print(s+" ");    //lilang renkuo yangfang zhanghuan
        }

        TreeSet<Integer> ts2 = new TreeSet<>();
        ts2.add(100);
        ts2.add(200);
        ts2.add(900);
        ts2.add(500);
        ts2.add(100);

        System.out.println();
        for(Integer ele : ts2){
            System.out.print(ele+" ");      //100 200 500 900
        }

    }
}

自定义类型实现Comparable接口

package com.collection;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetTest03 {
    public static void main(String[] args) {
        Customer c1 = new Customer(32);
        Customer c2 = new Customer(20);
        Customer c3 = new Customer(30);
        Customer c4 = new Customer(25);

        TreeSet<Customer> customers = new TreeSet<>();
        customers.add(c1);
        customers.add(c2);
        customers.add(c3);
        customers.add(c4);

        for(Customer c : customers){
            System.out.println(c);
        }
    }
}
class Customer implements Comparable<Customer>{
    int age;

    public Customer(int age) {
        this.age = age;
    }

    public Customer() {
    }

    //需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较！
    //k.compareTo(t.key)
    //拿着参数和集合中的每一个k进行比较，返回值可能是>0<0=0
    //比较规则最终还是由程序员指定的：例如按照年龄升序。或者按照年龄降序。

    @Override
    public int compareTo(Customer o) {

        return this.age-o.age;
    }

    @Override
    public String toString() {
        return "Customer[" +
                "age=" + age +
                ']';
    }
}

双重排序

package com.collection;

import java.util.TreeSet;

public class TreeSetTest05 {
    public static void main(String[] args) {
        TreeSet<Vip> vips = new TreeSet<>();
        vips.add(new Vip(20,"zhanghuan"));
        vips.add(new Vip(20,"lilang"));
        vips.add(new Vip(18,"yangfang"));
        vips.add(new Vip(17,"renkuo"));
        for(Vip v : vips){
            System.out.println(v);
        }
    }
}
class Vip implements Comparable<Vip>{
    int age;
    String name;

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

    public Vip() {
    }

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

    //先比较年龄，再比较姓名
    @Override
    public int compareTo(Vip v) {
        if(this.age == v.age){
            return this.name.compareTo(v.name);
        } else {
            return this.age - v.age;
        }
    }
}

13 自平衡二叉树

数据结构

TreeSet/TreeMap是自平衡二叉树。遵循左小右大原则存放。
遍历二叉树的时候有三种方式：

前序遍历：根左右

中序遍历：左根右

后序遍历：左右根

注意：

前中后说的是“根”的位置。根在前面是前序；根在中间，是中序；根在后面是后序。
TreeSet集合/TreeMap集合采用的是：中序遍历方式。

Iterator迭代器采用的是中序遍历方式。

左根右。
例如：100 200 50 60 80 120 140 130 180 666 40 55的自平衡二叉树结构

二叉树图形生成页面
采用中序遍历取出

40 50 55 60 80 100 120 130 140 180 200 666

TreeSet集合中元素可排序的第二种方式：使用比较器的方式。

最终的结论：

放到TreeSet或者TreeMap集合key部分的元素要想做到排序，包括两种方式：

第一种：放在集合中的元素实现java.Lang.Comparable接口。

第二种：在构造Treeset或者TreeMap集合的时候给它传一个比较器对象。

Comparable 和Comparator怎么选择呢？

当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。

如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。

Comparator接口的设计符合OCP原则。

package com.collection;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetTest06 {
    public static void main(String[] args) {
        //给构造方法传递比较器
        //TreeSet<WuGui> wuguis = new TreeSet<>(new WuGuiComparable());
        //使用匿名内部类
        TreeSet<WuGui> wuguis = new TreeSet<>(new Comparator<WuGui>() {
            @Override
            public int compare(WuGui o1, WuGui o2) {
                return o1.age - o2.age;
            }
        });
        wuguis.add(new WuGui(1000));
        wuguis.add(new WuGui(800));
        wuguis.add(new WuGui(810));

        for(WuGui wugui : wuguis){
            System.out.println(wugui);
        }

    }
}
class WuGui{
    int age;

    public WuGui(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "乌龟[" +
                "age=" + age +
                ']';
    }
}
//单独在这里编写一个比较器
//比较器实现java.util.Comparator接口。Comparable是java.lang包下的。Comparator是java.util包下的。
/*
class WuGuiComparable implements Comparator<WuGui>{

    @Override
    public int compare(WuGui o1, WuGui o2) {
        return o1.age - o2.age;
    }
}*/

14 集合工具类

java.util.Collection 集合接口
java.util.Collections集合工具类，方便集合的操作。

package com.collection;

import java.util.*;

public class CollectionsTest {
    public static void main(String[] args) {
        //ArrayList线程不安全
        List<String> list = new ArrayList<>();
        //转变为线程安全的
        Collections.synchronizedList(list);
        //排序
        list.add("abe");
        list.add("afd");
        list.add("abc");
        Collections.sort(list);
        for(String s : list){
            System.out.println(s);
        }
        //对于自定义类型需要实现Comparable接口才能使用sort();
        List<WuGui2> wuguis = new ArrayList<>();
        wuguis.add(new WuGui2(1000));
        wuguis.add(new WuGui2(8000));
        wuguis.add(new WuGui2(5000));

        Collections.sort(wuguis);
        for(WuGui2 wugui : wuguis){
            System.out.println(wugui);
        }

        //对set集合怎么排序
        Set<String> set = new HashSet<>();
        set.add("king");
        set.add("king2");
        set.add("kingsoft");
        set.add("king1");
        List<String> list1 = new ArrayList<>(set);
        Collections.sort(list1);      //sort只能排list，需要将set转换为list
        for(String s : list1){
            System.out.println(s);
        }


    }
}
class WuGui2 implements Comparable<WuGui2>{
    int age;

    public WuGui2(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(WuGui2 o) {
        return this.age - o.age;
    }

    @Override
    public String toString() {
        return "WuGui2[" +
                "age=" + age +
                ']';
    }
}

GuYue2651

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-10-12 集合

集合1 集合概述一种容器，可以容纳其他类型数据。数组就是一个集合一个载体，可以一次容纳多个对象开发中常用集合本身是Java对象，集合不能直接存储基本数据类型，也不能直接存储JAVA对象，存储的是引用（内存地址）。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VMwsk1yC-1634004729514)(https://i.loli.net/2021/09/22/OUYnKSbjhisQwDq.png)]不同集合，底层对应不同数据结构。往不同集合中存储
复制链接

扫一扫