Java集合相关

最新推荐文章于 2024-08-24 17:09:16 发布

九点六

最新推荐文章于 2024-08-24 17:09:16 发布

阅读量58

点赞数

文章标签： java 前端 servlet 开发语言 jvm

本文链接：https://blog.csdn.net/renzheng12/article/details/128628240

版权

java集合接口和常见类

「这是我参与11月更文挑战的第1天，活动详情查看：2021最后一次更文挑战」

集合就是许多数据(啥类型的都有)存储在同一个“容器”中，那个“容器”好像就叫做集合，哈哈哈。从数据库中提取出来数据，在后端存入一个集合，然后前端调用这个集合，然后一股脑的将该集合中的数据加载到页面上，让用户能看到数据。应该是这么回事。

一、Collection接口

Collection接口是List接口和Set接口的父接口，所以该接口中封装的方法，子接口可以照常使用。

以下方法都是基础的方法，详细的请查看API

java public static void main(String[] args) { /* Collection接口的常用方法：增加：add(E e) addAll(Collection<? extends E> c) 删除：clear() remove(Object o) 查看：iterator() size() 判断：contains(Object o) equals(Object o) isEmpty() */ //创建对象：接口不能创建对象，利用实现类创建对象：该创建方法为多态的一种使用方法 Collection col = new ArrayList(); //调用方法： //集合有一个特点：只能存放引用数据类型的数据，不能是基本数据类型 //基本数据类型自动装箱，对应包装类。int--->Integer col.add(18); //向集合中添加数据 //将这些数据转换成包装类，然后调用Arrays类中的asList方法转换为List集合 List list = Arrays.asList(new Integer[]{11, 15, 3, 7, 1}); col.addAll(list);//将另一个集合添加入col中 //col.clear();清空集合 System.out.println("集合中元素的数量为："+col.size()); System.out.println("集合是否为空："+col.isEmpty()); //返回值为布尔类型，true或false boolean isRemove = col.remove(15); //删除值为15的元素 System.out.println("集合中数据是否被删除："+isRemove); //返回值为布尔类型，true或false Collection col2 = new ArrayList(); col2.add(18); col2.add(12); Collection col3 = new ArrayList(); col3.add(18); col3.add(12); System.out.println(col2.equals(col3)); //调用equals方法比较两个集合中的元素是否相等，返回true或false System.out.println(col2==col3);//地址一定不相等 false System.out.println("是否包含元素："+col3.contains(117)); //contain是否包含此元素，返回true或false }

1.List接口(继承于Collection接口)(特点：不唯一，有序的)

因为List接口为有序的集合，所以在该集合中增加的方法都是一些与索引相关的方法。 增加：add(int index, E element) 删除：remove(int index) remove(Object o) 修改：set(int index, E element) 查看：get(int index) List集合的遍历：

java //方式1：普通for循环： System.out.println("---------------------"); for(int i = 0;i<list.size();i++){ System.out.println(list.get(i)); } //方式2：增强for循环： System.out.println("---------------------"); for(Object obj:list){ System.out.println(obj); } //方式3：迭代器： System.out.println("---------------------"); //Iterator为迭代器，后续会介绍 Iterator it = list.iterator(); while(it.hasNext()){ System.out.println(it.next());

(1)、ArrayList类(底层为数组存储)

因为JDK1.7跟JDK1.8版本的ArrayList是不一样的，所以我会分别列举： 1.7版本：当在调用构造器时，数组初始化的长度为10，然后当数据超出初始化时，会自动扩容为原来的1,5倍，然后再将老数组指向新数组，在返回新数组。 1.8版本：当在调用构造器时，底层数组为null，只有在调用add方法以后底层的数组才重新复制新的数组，长度为10，也是扩容1.5倍。优点：节省内存 ArrayList的线程不安全，但是效率高数组的优点：查询速度快，但是可以重复。数组的缺点：删除，增加元素效率低

(2)、Vector类(已淘汰，底层为数组存储)

该类底层也是数组，但是该类扩容2倍，线程安全，效率低。

(3)、LinkeList类(底层为双向链表存储)

请添加图片描述 LinkedList的源码： ```java public class LinkedList {//E是一个泛型，具体的类型要在实例化的时候才会最终确定 transient int size = 0;//集合中元素的数量 //Node的内部类 private static class Node { E item;//当前元素 Node next;//指向下一个元素地址 Node prev;//上一个元素地址 Node(Node prev, E element, Node next) { this.item = element; this.next = next; this.prev = prev; } } transient Node first;//链表的首节点 transient Node last;//链表的尾节点 //空构造器： public LinkedList() { } //添加元素操作： public boolean add(E e) { linkLast(e); return true; } void linkLast(E e) {//添加的元素e final Node l = last;//将链表中的last节点给l 如果是第一个元素的话 l为null //将元素封装为一个Node具体的对象： final Node newNode = new Node<>(l, e, null); //将链表的last节点指向新的创建的对象： last = newNode;

if (l == null)//如果添加的是第一个节点
        first = newNode;//将链表的first节点指向为新节点
    else//如果添加的不是第一个节点 
        l.next = newNode;//将l的下一个指向为新的节点
    size++;//集合中元素数量加1操作
    modCount++;
}
    //获取集合中元素数量
    public int size() {
    return size;
}
    //通过索引得到元素：
    public E get(int index) {
    checkElementIndex(index);//健壮性考虑
    return node(index).item;
}

Node<E> node(int index) {
    //如果index在链表的前半段，那么从前往后找
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {//如果index在链表的后半段，那么从后往前找
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

} ```

2.Set接口(继承于Collection接口)(特点：唯一，无序的)

该接口因为是无序的(而非随机，而是根据底层的算法来进行排序)，所以没有与索引相关方法。
遍历的方法：使用Iterator迭代器迭代；增强for循环遍历。

(1)、HashSet类(底层为哈希表(数组+链表)存储)

该类下还有一个实现类为：LinkedHashSet实现类。
该类的特点为：唯一，而且有序的(按照输入的顺序输出)。

该类底层是HashMap类。

(2)、TreeSet类(底层为二叉树存储)

该类的特点：唯一，有序的(是按照升序的排序进行输出)，无序(没有按照输入的方式进行输出)。
底层原理：实现内部比较器(compareTo)或者外部比较器(compare)

在这里插入图片描述

当调用TreeSet的空构造器时，底层创建了一个TreeMap。

二、Map接口

Map接口的常用方法： java import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; 增加：put(K key, V value) 删除：clear() remove(Object key) 修改：查看：entrySet() get(Object key) keySet() size() values() 判断：containsKey(Object key) containsValue(Object value) equals(Object o) isEmpty() */ //创建一个Map集合：无序，唯一 Map<String,Integer> map = new HashMap<>(); System.out.println(map.put("lili", 10101010)); map.put("nana",12345234); map.put("feifei",34563465); System.out.println(map.put("lili", 34565677)); map.put("mingming",12323); /*map.clear();清空*/ /*map.remove("feifei");移除*/ System.out.println(map.size()); System.out.println(map); System.out.println(map.containsKey("lili")); System.out.println(map.containsValue(12323)); Map<String,Integer> map2 = new HashMap<>(); System.out.println(map2.put("lili", 10101010)); map2.put("nana",12345234); map2.put("feifei",34563465); System.out.println(map2.put("lili", 34565677)); map2.put("mingming2",12323); System.out.println(map==map2); System.out.println(map.equals(map2));//equals进行了重写，比较的是集合中的值是否一致 System.out.println("判断是否为空："+map.isEmpty()); System.out.println(map.get("nana")); System.out.println("-----------------------------------"); //keySet()对集合中的key进行遍历查看： Set<String> set = map.keySet(); for(String s:set){ System.out.println(s); } System.out.println("-----------------------------------"); //values()对集合中的value进行遍历查看： Collection<Integer> values = map.values(); for(Integer i:values){ System.out.println(i); } System.out.println("-----------------------------------"); //get(Object key) keySet() Set<String> set2 = map.keySet(); for(String s:set2){ System.out.println(map.get(s)); } System.out.println("-----------------------------------"); //entrySet() Set<Map.Entry<String, Integer>> entries = map.entrySet(); for(Map.Entry<String, Integer> e:entries){ System.out.println(e.getKey()+"----"+e.getValue()); } } }

1、HashMap类(底层为哈希表(数组+链表)存储)

HashMap实现类的特点为：无序，但唯一。
该实现类按照key值进行排序总结，因底层key是按照哈希表的结构进行排序。

在这里插入图片描述所以当放入这个集合的数据对应的类时，必须重写HashCode方法(将key进行哈希运算)和equals方法(判断维不唯一)。

HashMap源码详解：

```java

public class HashMap extends AbstractMap //【1】继承的AbstractMap中，已经实现了Map接口,这个地方属于重复使用 implements Map , Cloneable, Serializable{ static final int DEFAULT INITIALCAPACITY = 16;//哈希表主数组的默认长度 //定义了一个float类型的变量，以后作为：默认的装填因子，加载因子是表示Hsah表中元素的填满的程度 //太大容易引起哈西冲突，太小容易浪费 0.75是经过大量运算后得到的最好值 static final float DEFAULT LOADFACTOR = 0.75f; transient Entry [] table;//主数组,每个元素为Entry类型 transient int size; int threshold;//数组扩容的界限值,门槛值 16*0.75=12 final float loadFactor;//用来接收装填因子的变量

//【4】查看构造器：内部相当于：this(16,0.75f);调用了当前类中的带参构造器
    public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
    //【5】本类中带参数构造器：--》作用给一些数值进行初始化的！
    public HashMap(int initialCapacity, float loadFactor) {
    //【6】给capacity赋值，capacity的值一定是 大于你传进来的initialCapacity 的 最小的 2的倍数
    int capacity = 1;
    while (capacity < initialCapacity)
        capacity <<= 1;
            //【7】给loadFactor赋值，将装填因子0.75赋值给loadFactor
    this.loadFactor = loadFactor;
            //【8】数组扩容的界限值,门槛值
    threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);

            //【9】给table数组赋值，初始化数组长度为16
    table = new Entry[capacity];

}
    //【10】调用put方法：
    public V put(K key, V value) {
            //【11】对空值的判断
    if (key == null)
        return putForNullKey(value);
            //【12】调用hash方法，获取哈希码
    int hash = hash(key);
            //【14】得到key对应在数组中的位置
    int i = indexFor(hash, table.length);
            //【16】如果你放入的元素，在主数组那个位置上没有值，e==null  那么下面这个循环不走
            //当在同一个位置上放入元素的时候
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
                    //哈希值一样  并且  equals相比一样   
                    //(k = e.key) == key  如果是一个对象就不用比较equals了
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
            //【17】走addEntry添加这个节点的方法：
    addEntry(hash, key, value, i);
    return null;
}

    //【13】hash方法返回这个key对应的哈希值，内部进行二次散列，为了尽量保证不同的key得到不同的哈希码！
    final int hash(Object k) {
    int h = 0;
    if (useAltHashing) {
        if (k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h = hashSeed;
    }
            //k.hashCode()函数调用的是key键值类型自带的哈希函数，
            //由于不同的对象其hashCode()有可能相同，所以需对hashCode()再次哈希，以降低相同率。
    h ^= k.hashCode();
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
            /*
            接下来的一串与运算和异或运算，称之为“扰动函数”，
            扰动的核心思想在于使计算出来的值在保留原有相关特性的基础上，
            增加其值的不确定性，从而降低冲突的概率。
            不同的版本实现的方式不一样，但其根本思想是一致的。
            往右移动的目的，就是为了将h的高位利用起来，减少哈西冲突
            */
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
    //【15】返回int类型数组的坐标
    static int indexFor(int h, int length) {
            //其实这个算法就是取模运算：h%length，取模效率不如位运算
    return h & (length-1);
}
    //【18】调用addEntry
    void addEntry(int hash, K key, V value, int bucketIndex) {
            //【25】size的大小  大于 16*0.75=12的时候，比如你放入的是第13个，这第13个你打算放在没有元素的位置上的时候
    if ((size >= threshold) && (null != table[bucketIndex])) {
                    //【26】主数组扩容为2倍
        resize(2 * table.length);
                    //【30】重新调整当前元素的hash码
        hash = (null != key) ? hash(key) : 0;
                    //【31】重新计算元素位置
        bucketIndex = indexFor(hash, table.length);
    }
            //【19】将hash,key,value,bucketIndex位置  封装为一个Entry对象：
    createEntry(hash, key, value, bucketIndex);
}
    //【20】
    void createEntry(int hash, K key, V value, int bucketIndex) {
            //【21】获取bucketIndex位置上的元素给e
    Entry<K,V> e = table[bucketIndex];
            //【22】然后将hash, key, value封装为一个对象，然后将下一个元素的指向为e (链表的头插法)
            //【23】将新的Entry放在table[bucketIndex]的位置上
    table[bucketIndex] = new Entry<>(hash, key, value, e);
            //【24】集合中加入一个元素 size+1
    size++;
}
//【27】
    void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
            //【28】创建长度为newCapacity的数组
    Entry[] newTable = new Entry[newCapacity];
    boolean oldAltHashing = useAltHashing;
    useAltHashing |= sun.misc.VM.isBooted() &&
            (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
    boolean rehash = oldAltHashing ^ useAltHashing;
            //【28.5】转让方法：将老数组中的东西都重新放入新数组中
    transfer(newTable, rehash);
            //【29】老数组替换为新数组
    table = newTable;
            //【29.5】重新计算
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
    //【28.6】
    void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
                            //【28.7】将哈希值，和新的数组容量传进去，重新计算key在新数组中的位置
            int i = indexFor(e.hash, newCapacity);
                            //【28.8】头插法
            e.next = newTable[i];//获取链表上元素给e.next
            newTable[i] = e;//然后将e放在i位置 
            e = next;//e再指向下一个节点继续遍历
        }
    }
}

} ``` HashMap效率高，但线程不安全。key可以存入null值，并且key的null值也遵循唯一的特点。在JDK1.2之前有个Hashtable实现类，但是它的效率低，线程安全，并且key不可以存入null值。

2、TreeMap类(底层为二叉树存储)

TreeMAp底层为二叉树，所以遵照二叉树的特点，放入集合的key的数据对应的类型内部一定要实现比较器(内部或外部比较器)。

补充泛型的相关知识

泛型就相当于标签形式：<>
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object， JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。 Collection ,List ,ArrayList 中的就是类型参数，就是泛型。示例代码： java import java.util.ArrayList; public class Test01 { //这是main方法，程序的入口 public static void main(String[] args) { //创建一个ArrayList集合，向这个集合中存入学生的成绩： //加入泛型的优点：在编译时期就会对类型进行检查，不是泛型对应的类型就不可以添加入这个集合。 ArrayList<Integer> al = new ArrayList<Integer>(); al.add(98); al.add(18); al.add(39); al.add(60); al.add(83); /*al.add("丽丽"); al.add(9.8);*/ //对集合遍历查看： /*for(Object obj:al){ System.out.println(obj); }*/ for(Integer i:al){ System.out.println(i); } } } · 泛型引用的必须都是引用数据类型，不能是基本数据类型。

·ArrayList<Integer> al = new ArrayList<Integer>();在JDK1.7之后可以写钻石运算符：ArrayList<Integer> al = new ArrayList<>();
`泛型继承关系：当父类指定了泛型，子类可以直接使用；当父类没指定泛型时，那么子类可以在创建子类对象的时候指定泛型。
·泛型类可以定义多个参数。例如：
    public class TestGeneric<A,B,C>{
    A age ; B name ; C sex ; 
    public void a(A m , B n , C x ){

        }
    }
·静态方法不能使用类的泛型;也就是有static关键词修饰的方法
·泛型如果没被指定，那么系统就会把他擦除。

泛型方法的含义：没带泛型的方法为泛型方法。 泛型方法对应的参数类型与当前所在的这个类是否为泛型类，是否为泛型无关。 · 泛型方法的定义前边要加上< T >，< T >在调用方法的时候确认。泛型方法可以是静态方法。 示例： java public static <T> void b(T t){ } 泛型的通配符>的作用：当G< A >和G< B >不存在父子关系时，加入G>就会变成他俩的父类。 List extends Person>: 就相当于： List extends Person>是List 的父类，是List

List super Person>就相当于：List super Person>是List 的父类，是List

补充二叉树的比较器compareTo方法的与原理及使用

比较器分为内部比较器compareTo()跟外部比较器compareTo()

String类实现了Comparable接口，这个接口中有一个抽象方法compareTo，String类中重写这个方法即可。内部比较器的使用逻辑代码里重写compareTo()方法。外部比较器是创建单独的类来重写compare()方法。

问题1：Iterator迭代器与ListIterator迭代器的区别

Iterator只是单纯的迭代数据。 当程序需要对集合进行迭代加修改双重操作时，就会使用ListIterator。

问题2：iterator()，Iterator，Iterable的关系

请添加图片描述

HashMap中的装填因子是0.75的原因

这时我们得考虑时间跟空间的问题

如果装填因子为1，那么就证明需要等到数组满了时候才能进行数组2倍扩容，这样可以做到最大的空间利用率，但是现实中元素不可能完全的均匀分布，那就很可能发生哈希碰撞，就会产生链表，产生链表就会使查询速度变慢。所以说当装填因子为1时，能做到最大的空间利用率，但是时间会变慢。

如果装填因子变小，变到0.5时，也就说当元素数量增加到数组容量的一半时就会进行2倍的数组扩容，这样做可以减少哈希碰撞，若不产生链表，那么查询的效率很高，但是会浪费空间。所以当装填因子为0.5时，查询时间会很快，但是空间会浪费。

所以我们会在空间和时间中取中间值0.75来平衡这个因素。

九点六

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java集合相关

java集合接口和常见类「这是我参与11月更文挑战的第1天，活动详情查看：2021最后一次更文挑战」集合就是许多数据(啥类型的都有)存储在同一个“容器”中，那个“容器”好像就叫做集合，哈哈哈。从数据库中提取出来数据，在后端存入一个集合，然后前端调用这个集合，然后一股脑的将该集合中的数据加载到页面上，让用户能看到数据。应该是这么回事。一、Collection接口Collection...
复制链接

扫一扫