JAVA基础——集合【源码剖析】

已于 2022-03-04 17:11:50 修改
阅读量3.2k 收藏 10
点赞数 7
分类专栏： java 文章标签： java 开发语言 后端
于 2022-03-04 09:56:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48838340/article/details/122897684
版权

目录

Collection体系集合

ArrayList底层结构和源码分析

Vector底层结构和源码分析

LinkedList底层结构和源码分析

HashSet底层结构和源码分析

LinkedHashSet底层结构和源码分析

TreeSet基本介绍

Map接口和常用方法​

Map六大遍历方式

HashMap底层机制及源码分析

TreeMap的基本介绍

Hashtable基本介绍

Properties基本介绍

集合选型规则

集合:对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。

数组和集合的区别:

①数组长度固定，集合长度不固定
②数组可以存储基本类型和引用类型，集合只能存储引用类型

Collection体系集合

Set接口特点:无序(添加的顺序和取出的顺序不一致，取出的顺序的顺序虽然不是添加的顺序,但是它是固定的)、无下标、元素不能重复

List接口特点:有序、有下标，元素可重复

1) void add(int index, Object ele):在index位置插入ele元素
2) boolean addAll(int index, Collection eles):从index位置开始将
eles中的所有元素添加进来
3) Object get(int index):获取指定index位置的元素
4) int indexOf(Object obj):返回obj在集合中首次出现的位置
5) int lastlndexOf(Object obj):返回obj在当前集合中未次出现的位置
6) Object remove(int index):移除指定index位置的元素，并返回此元素
7) Object set(int index, Object ele):设置指定index位置的元素为ele ,
相当于是替换.
8) List subList(int fromlndex, int tolndex);返回从fromIndex到
tolndex位置的子集合

ArrayList常用方法:

1) add:添加单个元素 
2) remove:删除指定元素
3) contains:查找元素是否存在
4) size:获取元素个数
5) isEmpty:判断是否为空
6) clear:清空
7) addAll:添加多个元素
8) containsAll:查找多个元素是否都存在
9) removeAll:删除多个元素

迭代器遍历:Iterator对象称为迭代器，主要用于遍历Collection集合的元素

迭代器执行原理:

 注意:在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。

增强for循环:就是简化版的iterator(for循环底层仍然是迭代器)

基本语法:for（元素类型 元素名：集合名或数组名）

ArrayList底层结构和源码分析

ArrayList(线程不安全，没有Synchronized,执行效率高，多线程不使用)基本等同于Vector

结论

1)ArrayList中维护了一个Object类型的数组elementData. 
transient Object[] elementData;//transient表示瞬间,短暂的,表示该属性不会被序列号
2)当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1
次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。
 

@SuppressWarnings({"all"})
public class ArrayListSource {
    public static void main(String[] args) {
        //使用无参构造器创建ArrayList对象
         ArrayList list=new ArrayList();
        //使用for循环给list集合添加1-10数据
        for(int i=1;i<10;i++){
            list.add(i);
        }
        //使用for循环给list集合添加11-15数据
        for(int i=11;i<15;i++){
            list.add(i);
        }
        list.add(100);
        list.add(200);
        list.add(null);
    }
}

 Debug源码分析:

 

 

 

 

 3)如果使用的是指定大小的构造器，则初始elementData容量为指定大小,如果需要扩容,
则直接扩容elementData为1.5倍。

如果是有参数的构造器,扩容机制
(1)第一次扩容，就按照elementData的1.5倍扩容.(2)整个执行的流程还是和前面讲的一样.

 Vector底层结构和源码分析

①vector底层是一个对象数组,protected Object[] elementData;

②Vector是线程同步，即线程安全。Vector类的操作方法有synchronized

public synchronized E get(int index){
        if (index >= elementCount)
        throw new ArraylndexOutOfBoundsException(index);
        return elementData(index);
}

vector和ArrayList的比较

 

 

 

 LinkedList底层结构和源码分析

1)LinkedList底层实现了双向链表和双端队列特点

2)可以添加任意元素(元素可以重复)，包括null

3)线程不安全,没有实现同步

LinkedList底层操作机制
1) LinkedList底层维护了一个双向链表.
2)LinkedList中维护了两个属性first和last分别指向首节点和尾节点3)每个节点(Node对象），里面又维护了prev、next、item三个属性，
其中通过
prev指向前一个，通过next指向后一个节点。最终实现双向链表.
4)所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。

 linkedlist的属性

增加

 

 删除

 

 

 ArrayList和LinkedList比较（两个线程都不安全，尽量在单线程的时候使用）

HashSet底层结构和源码分析

结论:

1. HashSet底层是HashMap
2.添加一个元素时，先得到hash值-会转成->索引值
3.找到存储数据表table,看这个索引位置是否已经存放的有元素
4.如果没有，直接加入
5.如果有，调用equals比较，如果相同，就放弃添加,如果不相同，则添加到最后
6.在Java8中,如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN TREEIFY CAPACITY(默认64).就会进行树化(红黑树)

1.执行HashSet()

 2.执行add

 3.执行put

 4.执行hash(key)，尽量让不同的key得到不同的hash值

 5.执行putVal()

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //定义了辅助变量
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //table就是hashmap的数组，类型是Node[]
        //if 语句表示如果当前table 是null，或者大小=0
        //就是第一次扩容,到16个空间。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //根据key，得到hash去计算该key应该存放到table表的哪个索引位置
        //并把这个位置的对象，赋给p
        //判断p 是否为null
        //如果p 为null，表示还没有存放元素，就创建一个Node (key="java" , value=PRESENT)
        //就放在该位置 tab[i] = newNode(hash,key,value,null)
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
        //一个开发技巧提示:在需要局部变量(辅助变量)时候，再创建

            Node<K,V> e; K k;
        //并且满足下面两个条件之一:
        //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
        //(1)准备加入的key和 p指向的Node 结点的key 是同一个对象
        //(2)p指向的Node 结点的key的equals()和准备加入的kev比较后相同
        //就不能加入
            if (p.hash == hash &&

                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //再判断p是不是一颗红黑树
            //如果是一颗红黑树，就调用putTreeVal，来进行添加

            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //如果table对应索引位置,已经是一个链表，就使用for循环比较
                //(1)依次和该链表的每一个元素比较后，都不相同,则加入到该链表的最后
                //注意在把元素添加到链表后，立即判断该链表是否已经达到8个结点
                //，就调用treeifyBin()对当前这个链表进行树化(转成红黑树)
                //注意，在转成红黑树，进行判断，判断条件
                //    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                //    resize();
                //如果上面条件成立，先table扩容。
                //只有上面条件不成立时，才进行转成红黑树

                //(2)依次和该链表的每一个元素比较过程中，如果有相同情况,就直接break

                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //size 就是我们每加入一个结点Node(k, v, h , next), size++
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

LinkedHashSet底层结构和源码分析

1)LinkedHashSet是 HashSet的子类
2)LinkedHashSet底层是一个 LinkedHashMap(HashMap的子类),底层维护了一个数组+双向链表
3)LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。(加入顺序和取出元素/数据的顺序一样)
4) LinkedHashSet 不允许添重复无素

//添加第一次时，直接将 数组table 扩容到16，存放的结点类型是LinkedHashMap$Entry
//数组是 HashMap$Node[]存放的元素/数据是LinkedHashMapsEntry类型
//继承关系是内部类完成
static class EntryKK,v> extends HashMap.Node<K,V> {
        Entry<K, V> before,after;
        Entry(int hash,K key, v value,Node<K,V> next) {
        super(hash,key, value, next);
    }
}

TreeSet基本介绍

public class TreeSet_ {
    public static void main(String[] args) {
//        TreeSet treeSet=new TreeSet();
        //1。当我们使用无参构造器，创建TreeSet时，仍然是无序的
        //2．老师希望添加的元素，按照字符串大小来排序
        //3．使用TreeSet提供的一个构造器，可以传入一个比较器(匿名内部类)
        // 并指定排序规则

        TreeSet treeSet=new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //下面调用String的 compareTo方法进行字符串大小比较
                return ((String) o1).compareTo((String) o2);

            }
        });
        //添加数据
        treeSet.add("Jack");
        treeSet.add("Tom");
        treeSet.add("sp");
        treeSet.add("a");
        System.out.println("treeSet"+treeSet);
    }
}

Map接口和常用方法

public class Map_ {
    public static void main(String[] args) {
//1.Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value(双列元素)
//2.Hap 中的 key和 value 可以是任何引用类型的数据，会封装到HashMap$Node 对象中
//3. Map中的key 不允许重复，原因和HashSet一样，前面分析过源码。
//4.Map中的value可以重复
//5.Map 的key可以为 null,value也可以为null,注意key为null，只能有一个,value 为null，可以多个
//6.常用String类作为Map的key
//7.key和 value之间存在单向一对一关系，即通过指定的key 总能找到对应的value
//8.k-v最后是 HashMap$Node node = newNode(hash, key,value,null)
//9.k-v为了方便程序员的遍历，还会创建EntrySet集合，该集合存放的元素的类型 Entry，而一个Entry//对象就有k ,v；
// EntrySet<Entry<K ,V>>即: transient Set<Map.Entry<K,V>> entrySet;
//10. entrySet中，定义的类型是 Map. Entry ，但是实际上存放的还是 HashHap$Node
//这是因为 static class Node<K, V> implements Map. Entry<K,V>
//11.当把 HashHap$Node对象存放到entrySet就方便我们的遍历，因为 Hap. Entry提供了重要方法
//12与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的. (jdk8的hashMap底层数组+链表+红黑树)
//13 HashMap没有实现同步，因此是线程不安全的,方法没有做同步互斥的操作,没有
synchronized

        Map map = new HashMap();
        map.put( "no1","韩顺平");//k-v
        map.put( "no2","张无忌");//k-v
        map.put("'no1","张三丰");//当有相同的k，就等价于替换。
        map.put( "no3","张三丰");//k-v
        map.put(null,null);//k-v
        map.put(null,"abc");
        map.put("no4",null);
        map.put("no5",null);
        map.put(1,"赵敏");
        map.put(new Object(),"金毛狮王");
        //通过get方法，传入 key，会返回对应的value
        Set set = map.entrySet();
        System.out.println(set.getClass());// HashMap$EntrySet
        for (Object entry:set){
            System.out.println(entry.getClass());//HashHap$Node
        }
        // put:添加
        //remove:根据键删除映射关系map.remove(null);
        System.out.println( "map=" + map);
        //get:根据键获取值
        Object val = map.get("鹿啥");
        System.out.println( "val=" + val);
        //size:获取元素个数
        System.out.println("k-v=" + map.size());
        //isEmpty:判断个数是否为0
        System.out.println(map.isEmpty());//F
        // clear:清除k-v
        map.clear();
        System.out.println("map="+map);
        //containsKey:查找键是否存在
        System.out.println(map.containsKey("hsp"));//T

        System.out.println(map.get("no2"));//张无忌
    }
}

Map六大遍历方式

public class MapFor {
    public static void main(String[] args) {
        Map map=new HashMap();
        map.put("邓超","孙俪");
        map.put("王宝强","马蓉");
        map.put("宋喆","马蓉");
        map.put("刘令博",null);
        map.put(null,"刘亦菲");
        map. put("鹿晗","关晓彤");
        //第一组:先取出所有的Key ，通过Key取出对应的Value
        Set keyset = map.keySet();
        //(1）增强for
        System.out.println("-----第一种方式-------");
        for (Object key : keyset){
            System.out.println(key + "-" +map.get(key));
        }
        //(2）迭代器
        System.out.println("----第二种方式-------十");
                Iterator iterator = keyset.iterator();
        while (iterator.hasNext()){
            Object key = iterator. next();
            System.out.println(key + "-" +map.get(key));
        }
        //第二组:把所有的values取出
        Collection values = map.values();
        //这里可以使用所有的Collections使用的遍历方法
        // (1）增强for
        System.out.println("---取出所有的value   增强for---);" );
        for (Object value : values) {
                System.out.println(value);
    }
        //(2)迭代器
        System.out.println("---取出所有的value   迭代器---);" );
        Iterator iterator2=values.iterator();
        while (iterator2.hasNext()){
            Object value=iterator2.next();
            System.out.println(value);
        }

        //第三组:通过EntrySet来获取k-v
        Set entrySet = map.entrySet();// EntrySet<Map. Entry<K,V>>
        // (1)增强for
        System.out.println("---使用EntrySet的for增强(第3种)");
        for (Object entry : entrySet) {
        //将entry 转成 Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
        //(2)迭代器
        System.out.println("---使用EntrySet的迭代器(第4种)");
        Iterator iterator3 = entrySet.iterator();
        while (iterator3.hasNext()){
            Object entry = iterator3.next();
            //System.out.println(next.getClass());//HashMap$Node -实现-> Hap . Entry (getKey , getValue)
            //向下转型Map. Entry
            Map.Entry m = (Map.Entry)entry;
            System.out.println(m.getKey() + "_" + m.getValue());
        }
    }
}

HashMap底层机制及源码分析

1) HashMap底层维护了Node类型的数组table，默认为null2)当创建对象时，将加载因(loadfactor)初始化为0.75.
3)当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素如果没有元素直接添加。如果该索引处有元素,继续判断该元素的key和准备加入的key是否相等,如果相等，则直接替换val;如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
4)第1次添加，则需要扩容table容量为16，临界值(threshold)为12(16*0.75)
5)以后再扩容，则需要扩容table容量为原来的2倍(32)，临界值为原来的2倍,即24.依次类推6)在Java8中,如果一条链表的元素个数超过 TREEIFY_THRESHOLD(默认是8)，并且table的大小>= MIN_TREEIFY_ CAPACITY(默认64),就会进行树化(红黑树)

 

public class HashMapSource1 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put( "java",10);//ok
        map.put("php",10);//ok
        map.put( "java",20);//替换value
        System.out.println( "map=" + map);

    }
}

1。执行构造器new HashMap(
初始化加载因子loadfactor = 0.75
HashMap$Node[] table = null
2。执行put调用hash方法，计算 key的 hash值(h = key. hashCode()) A (h >>> 16)
public V put(K key, V value) {//K = "java" value = 10
return putVal(hash(key), key , value,false,true);
}
   
//3.执行putVal
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i; //定义了辅助变量
        //if 语句表示如果当前table 是null，或者length=0，就扩容到16个空间。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //取出hash值对应的table的索引位置的Node，如果为null，就直接把加入的k-v1，
        //创建成一个 Node，加入该位置即可

        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;//辅助变量
        //如果table的索引位置的key的hash相同和新的key的hash值相同，
        //并满足(table现有的结点的key和准备添加的key是同一个对象ll equals返回真)
        //就认为不能加入新的k-v
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)如果当前的table的已有的Node是红黑树，就按照红黑树处理

                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //如果找到的结点,后面是链表,就循环比较
                for (int binCount = 0; ; ++binCount) {//死循环
                    if ((e = p.next) == null) {//如果整个链表，没有和他相同，就加到该链表的最后

                        p.next = newNode(hash, key, value, null);
        //加入后，判断当前链表的个数,是否已经到8个，到8个，后
        //就调用treeifyBin方法进行红黑树的转换

                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&//如果在循环比较过程中,发现有相同，就break,就只是替换value

                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;//替换，key对应value
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;//每增加一个Node就size++
        if (++size > threshold)//如size大于临界值就扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }
        //5.关于树化(转成红黑树)
        //如果table为null ,或者大小还没有到 64，暂时不树化，而是进行扩容。
        //否则才会真正的树化->剪枝
        final void treeifyBin(Node<K,V>[] tab, int hash){
            int n, index; Node<K, V> e;
            if (tab == null ll (n = tab.length)< MIN_TREEIFY_CAPACITY)
            resize();
        }

TreeMap的基本介绍

public class TreeMap_ {
    public static void main(String[] args) {
        //使用默认的构造器，创建TreeMap，是无序的(也没有排序)
        /*
        要求:按照传入的k(String)的大小进行排序
        */
        //TreeMap treeMap=new TreeMap();
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //按照传入的k(String)的大小进行排序
                //按照K(String)的长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o1).length()-((String) o2).length();
            }
        });
        treeMap.put("Jack", "杰克");
        treeMap.put("tom","汤姆");
        treeMap.put("kristina","克瑞斯提诺");
        treeMap.put("smith","斯密斯");

        System.out.println("treeMap="+treeMap);
        /*1．构造器。把传入的实现了Comparator接口的匿名内部类(对象)，传给给TreeMap的comparatcor
          public TreeMap(Comparator<? super K> comparator）{
            this.comparator = comparator;
          2.调用put方法
          2.1第一次添加，把k-v封装到Entry对象，放入root
          Entry<K,V> t=root;
          Entry<K , V> t = root;
          if (t == null) {
            compare(key,key); // type (and possibly null) check
            root = new Entry<>(key, value,null);
            size = 1;
            modCount++;
            return null;
        }
        2.2以后添加
        2.2以后添加
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
        do {//遍历所有的key，给当前key找到适当的位置
        parent = t;
        cmp = cpr.compare(key,t.key);//动态绑定到我们的匿名内部类compare
        if (cmp < 0)
         t = t.left;
         else if (cmp > 0)
        t = t.right;
        else    //如果遍历过程中，发现准备添加key和当前已有的key相等，就不添加
        return t.setValue(value);
        }while (t != null);
      }
        */
        }
}

Hashtable基本介绍

1)存放的元素是键值对:即K-V
2) hashtable的键和值都不能为null，否则会抛出NullPointerException3) hashTable使用方法基本上和HashMap一样
4) hashTable是线程安全的(synchronized), hashMap是线程不安全的
 

public class HashtableSource {
    public static void main(String[] args) {
        Hashtable table = new Hashtable();//ok
        table.put("john",100); //ok
        table.put(null,100);//异常        NullPointerException
        table.put("john", null);//异常
        table.put("lucy",100); //ok
        table.put("Lic",100); //ok
        table.put("lic",88);//替换
        System.out.println(table);

        //Hashtable的底层
        //1.底层有数组 Hashtable$Entry[]初始化大小为11
        //2.临界值 threshold 8 = 11 * 0.75
        //3.扩容:按照自已的扩容机制来进行即可。
        //4.执行方法 addEntry(hash,key,value，index);添加K-V封装到Entry
        //5.当if (count >= threshold)满足时，就进行扩容
        //按照int newCapacity = (oldCapacity <<1) +1;的大小扩容.
    }
}

 Hashtable与HashMap对比

 Properties基本介绍

1.Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形
式来保存数据。
2.他的使用特点和Hashtable类似
3. Properties还可以用于从 xo.properties文件中，加载数据到Properties类对象,
并进行读取和修改
 

public class Properties_ {
    public static void main(String[] args) {
        //1.Properties 继承Hashtable
        //2。可以通过k-v存放数据，当然key和 value不能为null
        // 增加
        Properties properties = new Properties();
        //properties.put(null,"abc ");//抛出空指针异常
        //properties.put("abc", null);//抛出空指针异常
        properties.put( "john",100);//k-v
        properties.put("Lucy",100);
        properties.put("lic",100);
        properties.put("lic",88);//如果有相同的key , value被替换
        System.out.println("properties=" +properties);
        //通过k获取对应值
        System.out.println(properties.get("lic "));//88
        //删除
        properties.remove("lic");
        System.out.println("properties=" + properties);
        //修改
        properties.put( "john","约翰");
        System.out. println("properties=" + properties);
    }
}

集合选型规则

 总结-开发中如何选择集合实现类(记住)

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下:
1)先判断存储的类型(一组对象【单列】或一组键值对【双列】)
2)一组对象[单列]:Collection接口
允许重复:List
增删多:LinkedList【底层维护了一个双向链表】
改查多: ArrayList 【底层维护Object类型的可变数组】
不允许重复: Set
无序: HashSet 【底层是HashMap，维护了一个哈希表即(数组+链表+红黑树)】
排序:TreeSet
插入和取出顺序一致:LinkedHashSet，维护数组+双向链表
3)一组键值对[双列]: Map
键无序: HashMap [底层是:哈希表 jdk7:数组+链表，jdk8:数组+链表+红黑树]
键排序:TreeMap
键插入和取出顺序一致:LinkedHashMap
读取文件: Properties


 

龍弟-idea
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
JAVA基础——集合
qq_45821255的博客
03-12 463
文章目录前言一、集合概要及框架体系1、集合的理解2、数组的缺点3、集合的好处4、集合的框架体系二、Collection集合（单列集合）Collection集合特点Collection集合遍历元素方式1、迭代器的遍历方式2、增强for循环的遍历方式1、ListⅠ. ArrayList底层结构和源码分析Ⅱ Vector 底层结构和源码分析Vector子类——Stack(栈)Ⅲ LinkedList底层结构和源码分析Ⅳ. ArrayList 和 LinkedList 比较2.Set2.读入数据三、Map集合（双
JAVA基础知识——集合类
等待着雨水,茁壮成长--李建敏
02-13 393
先放一个图：四个比较：List接口和Set接口相同：都继承了Collection 不同：1、List是有序，允许有相同元素的Collection；Set不允许有相同的元素，即e1.equals(e2)=false； 2、List 还提供了一个listIterator（）方法，返回一个ListIterator接口多了一些增删遍历之类的方法 3、实现List接口的常用类LinkedList、Arr
应用开发--集合01、list和set概述
tyf2007635的博客
11-12 225
集合概述 Java 集合可分为 Collection 和 Map 两种体系 Collection接口： 单列数据， 定义了存取一组对象的方法的集合 List： 元素有序、可重复的集合 Set： 元素无序、不可重复的集合 Map接口： 双列数据，保存具有映射关系“key-value对”的集合 Collection 接口 Collection 接口是 List、 Set 和 Que...
JAVA常用方法
weixin_43436570的博客
10-21 152
键盘输入 import java.util.Scanner; Scanner sc = new Scanner(System.in); int n = sc.nextInt(); 随机数 import java.util.Random; Random r = new Random(); int i = r.nextInt(100); ArrayList “ArrayList&amp;lt;要存储元素的数据...
java学习笔记之java集合
qq_39515858的博客
08-21 292
概念：集合类主要负责保存、封装其他数据，因此集合类也被称为容器类。 1.储存对象可以考虑：1数组2集合。 2.数组储存对象的特点。student[] stu=new student [20];    &gt;&gt;弊端1.一旦创建，其长度不变。2.真实的数组存放的对象的个数是不可知的。 3.集合：分为collection和map两种体系 注意： ①、集合只能存放对象。比如你存一个 i...
Java学习笔记 --- List接口方法
乌云的博客
10-30 1117
List 接口是 Collection 接口的子接口1、List 集合类中元素有序（即添加顺序和取出顺序一致）、且可重复2、List 集合中的每个元素都有其对应的顺序索引，即支持索引3、List 容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素4、JDK API中 List 接口的实现类有常用的有：ArrayList、LinkedList 和 Vector。
学习Java第十三天：1、集合框架
Java的第一人称视角
12-06 88
Java中集合框架的体系结构集合 --- “存放一堆乱七八糟的数据”框架 --- Java做好的类库java中的集合框架总体被分为2个大部分第一个大部分是用来处理单列数据的集合，最大的接口是Collection接口例如：100 “hello"Collection接口之下有两个子接口：List接口/Set接口List接口是用来处理有序的单列数据，可以有重复的元素。ArrayList类用来处理有序的单列数据，可以有重复的元素。添加的元素会自动扩展。动态数组结构，查询速度快，添加删除速度慢。LinkedList类
java基础——集合ArrayList ,LinkedList
01-21
目录前言数组与集合区别集合描述集合格式方法ArrayList实例1.add(E e)2.add(int index, E element)3.addAll(Collection c)4.clear() 与 isEmpty()5.contains(Object o)6.indexOf(Object o)7.iterator()8.remove(int ...
java基础——入门篇
07-14
因为在jdk下bin文件夹中有很多我们在开发中要使用的工具如javaexejavacexejarex等那么我们在使用时想要在电脑的任意位置下使用这些java开发工具那么我们就需有把这些工具所在的路径配置到系统的环境变量中当我们使用...
Java 基础 —— 五阶段
05-02
Java 基础 —— 五阶段
java基础篇——java的起源与演变
07-14
Java 的跨平台原理: Java 源代码---编译--->java 字节码(可跨平台) ---运行--->JVM(java 虚拟机)→Windows,Linux 等平台。JVM 屏蔽了底层运行平台的差别,实现了“以此编译,随处运行”。 垃圾回收器: 不...
Java————————进阶
05-04
适合复习java进阶
Java高级之1.8版本JDK中的HashMap的put()方法和putVal()方法
二木成林
02-08 745
put()方法的源码如下： public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } 最核心的就是调用了putVal()方法，用来将元素添加到HashMap集合中，但传递的一个参数中调用了一个hash(key)方法，在JDK1.7中的HashMap源码中也有一个hash(key)方法，下面先来看看两个的代码： 1.7版本的hash(key)方法： 1.8
java之hashMap底层源码（put方法）
yan_pan的博客
03-06 622
put方法 put(K key, V value)调用了 putVal（）方法，此时onlyIfAbsent默认为false,evict默认为true putVal方法 此方法共有五个参数 hash:传入键的哈希值 key: 键 value:值 onlyIfAbsent:如果当前位置已存在一个值，false是替换，true是不替换 evict：表是否在创建模式，如果为false，则表是在创建模式 putVal方法实现 1.如果Node数组为空，或者长度为0，会进行初始化（调用resize方法进行初始
Java集合（超详细-含源码）
m0_63975764的博客
03-03 779
集合是我们在开发中最常用的数据结构，集合分为单列集合和双列集合，不同的集合有各自的特点。我们在实际开发中，要根据问题来使用合适的集合。
JAVA集合源码
gb4215287的博客
04-26 1886
文章目录 JAVA集合 一、框架图 二、List 1.ArrayList（部分源码） 2.LinkedList（部分源码） 3.Vector（部分源码） 三、Set 1.HashSet（部分源码） 2.LinkedHashSet（部分源码） 3.TreeSet（部分源码） 四、Queue 1.LinkedList（用作队列或栈的部分源码） 2.ArrayDeque（部分源码） 五、Map 1.HashMap（部分源码） 2.LinkedHashMap（部分源码） 3.TreeMap（部分源码） 4.Hash
Java基本语法 ---- 集合
遨游在知识海洋的淡水鱼
10-21 457
Collection接口: 常用方法、Iterator: 迭代器方法、foreach循环; List接口: ArrayList、LinkedList、Vector; Set接口: HashSet、LinkedHashSet、TreeSet; Map接口: HashMap、LinkedHashMap、TreeMap、Hashtable、Properties属性、Map常用方法；Collections工具类
java集合（附源码分析）
m0_73257876的博客
08-13 501
Collection接口（单列集合）Map接口（双列集合）总结Map和List、Set的区别List和set的区别有序列表，允许存放重复元素；其实现类由三个：List的四种遍历方式 public class ListTest { public static void main(String[] args) { List<Integer> list=new ArrayList<>(); list.add(1); list.add(
Java爬虫之Jsoup爬Html网页链接
最新发布
withme977的博客
06-20 453
Java爬虫Jsoup
Java学习资料-核心知识
06-16
其中包括Java集合的核心知识点和常用的集合类，以及List、Set和Map三者之间的区别。 Java集合框架中，Map接口和Collection接口是所有集合类的父接口。接口与接口之间可以有继承关系，类与类之间也可以有继承关系，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龍弟-idea

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值