Java集合——练习笔记及源码概述

原创 于 2020-03-22 14:18:52 发布
· 189 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构 #java

框架集合的概述

 * 一、集合框架的概述
 *
 * 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
 *   说明：此时的存储，主要是指内存层面的存储，不涉及到持久化（.txt,.jpg,.avi，数据库）
 *
 * 2.1数组在存储多个数据方面的特点：
 *      》一旦初始化以后，其长度就确定了。
 *      》一旦定义好，其元素的类型也就确定好，我们也就只能操作指定类型的数据了
 *          比如：String[] arr; int[] arr1;Object[] arr2;
 * 2.2数组在寻相互多个数据方面的缺点：
 *      》一旦初始化以后，其长度就确定不能修改了
 *      》数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
 *      》获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
 *      》数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
 *

集合框架

 * 二、集合框架
 *      |----Collection接口：单列数据，用来存储一个一个的对象
 *          |----List接口：存储有序，可重复的数据。 --> “动态”数组
 *              |----ArrayList,LinkedList,Vector
 *
 *          |----Set接口：存储无序，不可重复的数据  -->高中间的“集合”
 *              |----HashSet,LinkedHashSet,TreeSet
 *
 *      |----Map接口：双列集合用来存储一对（键值对）的数据
 *          |----HashMap,LinkedHapMap,TreeMap,Hashtable,Properties
 *

Collectoin接口中的方法的使用

public class CollectionTest {

    @Test
    public void test1(){
        Collection coll=new ArrayList();

        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add("123");//自动装箱
        coll.add(new Date());
        System.out.println(coll.size());

        //addAll():
        Collection coll1=new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);

        System.out.println(coll.size());
        System.out.println(coll);

        //clear:清空集合元素

        //isEmpty: 判断当前集合是否为空
        System.out.println(coll.isEmpty());

    }

    //练习：在list内取出重复数字值，要求尽量简单
    public static List duplicateList(List list){
        HashSet set=new HashSet();
        set.addAll(list);
        return new ArrayList(set);
    }

    @Test
    public void test2(){
        List list=new ArrayList();
        list.add(new Integer(1));
        list.add(new Integer(2));
        list.add(new Integer(2));
        list.add(new Integer(4));
        list.add(new Integer(4));
        List list2=duplicateList(list);
        for(Object o:list2){
            System.out.println(o);
        }

    }

    @Test
    public void test3(){
        HashSet set=new HashSet();
        Person p1=new Person(1001,"AA");
        Person p2=new Person(1002,"BB");

        set.add(p1);
        set.add(p2);
        p1.name="CC";
        set.remove(p1);
        System.out.println(set);
        set.add(new Person(1001,"CC"));
        System.out.println(set);
        set.add(new Person(1001,"AA"));
        System.out.println(set);
    }
    
}

Set 接口

 * Set接口的框架：
 *
 * |----Collection接口：单列集合，用来存储一个一个的对象
 *    |----Set接口：存储无序，不可重复的数据  -->高中间的“集合”
 *            |----HashSet:作为Set接口的主要实现类：线程不安全的；可以存储null值
 *                 |----LinkedHashSet：作为HashSet的子类，遍历其内部数据时，可以按照添加时的顺序遍历
 *                      优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
 *            |----TreeSet：可以按照添加对象的指定属性，进行排序
 *
 * 1.Set接口中没有额外定义的新的方法，使用的都是Collection中声明过的方法。
 *

Set的存储过程

一、Set：存储无序不可重复的数据
    *   以HashSet为例说明
    *   1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是按照数据的哈希值进行添加
    *
    *
    *   2.不可重复性：保证添加的元素按照equals()判断时，不能返回true ，即，相同的元素只能添加一次。
    *
    * 二、添加元素的过程：以HashSet为例：
    *    我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算出元素a的哈希值，
    *     此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
    *     数组此位置上是否已经有元素：
    *         如果此位置上没有其他元素，则元素a添加成功
    *         如果此位置上有其他元素b（或以链表存在的多个元素），则比较元素a和元素b的hash值：
    *             如果hash值不相同，则元素a添加成功
    *             如果hash值相同，进而需要调用元素a所在类的equals方法：
    *                 equals返回true，元素a添加失败
    *                 equals返回false，则元素a添加成功
    *
    *
    *      对于添加成功的情况2和情况3而言：元素a于已经存在指定索引位置上数据以链表的方式存储。
    *       jdk7：元素a放到数组中，只向原来的元素
    *       jdk8：原来的元素在数组中，只向元素a
    *       总结：七上八下
    *
    *       HashSet底层：数组+链表的结构
    *
    *

TreeSet

* 1.向TreeSet中添加的数据，要求是像同类的对象
    * 2.两中排序方式：自然排序（实现comparable接口）和定制排序（comparable）
    *
    * 3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals
    * 4.定制排序中，                           compare
    * */

Map

Map实现类的结构情况

**Map实现类的结构情况
 * |----Map:双列数据，存储key-value键值对
 *      |----HashMap:作为Map的主要实现类；线程不安全，效率高；存储null的key和value
 *          |----LinkedHashMap:保证在遍历map元素时，可以按照添加时的顺序实现遍历
 *                  原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素
 *                  对于频繁的遍历操作，此类执行效率高于HashMap
 *      |----TreeMap:保证按照添加的key-value对 进行排序，实现排序遍历。（按照key来排序）
 *                      底层使用红黑树
 *      |----Hashtable:作为古老实现类；线程安全，效率低；不能存储null的key和value
 *          |----Properties:常用来处理配置文件。key和value都是String类型
 *
 *
 *
 *     HashMap的底层：数组+链表    （jdk 7 之前）
 *                   数组+链表+红黑树 （jdk8）
 *

面试题

  • 1.HashMap的底层实现原理？
  • 2.HashMap和Hashtable的区别？
  • 3.CurrentHashMap与Hashtable的异同？

Map结构的理解：

 *      Map中的key：无序的、不可重复的，使用Set存储所有的key --->key所在的类要重写equals()和HashCode()（以Hashmap为例）
 *      Map中的value：无序的、可重复的，使用Collection存储所有的value --->value所在的类需要重写equals()
 *      一个键值对：key-value构成了一个Entry对象。
 *      Map中的Entry：无序的、不可重复的，使用Set存储所有的entry
 *

HashMap的底层实现原理？以jdk7为例说明：

*      HashMap map=new HashMap():
 *          在实例化以后，底层创建了长度是16的一维数组Entry[] table
 *          ...可能已经执行过多次put...
 *          map.put(key1,value1)：
 *            首先，计算key1所在类的HashCode()计算key1的哈希值，再经过某种计算，得到Entry数组中该存放的位置
 *            如果此位置上的数据为空，此时的key1-value1添加成功  -----------情况1
 *            如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表存在）），比较key1和已经存在的数据
 *             的哈希值：
 *                  如果key1的哈希值与已存在的数据的哈希值不一样，此时key1-value1添加成功  ----------情况2
 *                  如果key1的哈希值与已存在的数据（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals方法，比较：
 *                      如果equals()返回false：此时key1添加成功。  --------情况3
 *                      如果equals()返回时true：使用value1替换value2值.
 *
 *             补充：关于情况2和情况3
 *
 *            在不断地添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空）时默认的扩容方式：扩容为原来的2倍，并将原来的数据复制过来。
 *
 *            jdk8 相较于jdk7在底层实现方面的不同：
 *            1.new HashMap():底层没有创建一个长度为16的数组
 *            2.jdk 8底层的数组时：Node[],而非Entry[]
 *            3.首次调用put()方法时，底层创建长度为16的数组
 *            4.jdk底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。
 *              当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，
 *              此时此索引位置上的所有数据改为使用红黑树有存储
 *
 *
 *            DEFAULT_INITIAL_CAPACITY:HashMap的默认容量 16
 *            DEFAULT_LOAD_FACTOR:HashMap的默认加载因子： 0.75
 *            threshold:扩容的临界值，=容量*填充因子：16*0.75=>12
 *            TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值，转换为红黑树：8
 *            MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量为 64
 *

LinkedHashMap的底层实现原理（了解）

*      源码中：
 *      static class Entry<K,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);
 *      }

Map中定义的方法

*      添加删除修改操作：
 *      Object put(Object key,Object value):
 *      vaid putAll(Map m):将m中的所有key-value对存到当前map中
 *      Object remove(Object key):移除指定key的key-value对，并返回value
 *      void clear():
 *      元素查询操作：
 *      Object get(Object key):
 *      boolean containsKey(Object key):是否包含指定的key
 *      boolean containsValue(Object value):是否包含指定的value
 *      int size():返回map中key-value对的个数
 *      boolean isEmpty():
 *      boolean equals(Object obj):判断当前map和参数对象obj是否相等
 *      元视图操作的方法：
 *      Set keySet():返回所有key构成的Set集合
 *      Collection values():返回所有value构成的Collection集合
 *      Set entrySet():返回所有key-value构成的Set集合
 *
 *      总结：常用方法：
 *      添加：put(key,value)
 *      删除：remove
 *      修改：put
 *      查询：get
 *      长度：size()
 *      遍历：keySet   /values  /entrys
 *

代码实现

public class MapTest {

    @Test
    public void test1(){
        Map map=new HashMap();
        //添加
        map.put("AA",123);
        map.put("BB",12);
        map.put("CC",13);
        //修改
        map.put("AA",23);
        map.remove("CC");
        System.out.println(map);
        Map map1=new HashMap();
        map1.put("DD",123);
        map.putAll(map1);
        System.out.println(map);
    }
    @Test
    public void test2(){
        Map map=new HashMap();
        map.put("AA",123);
        map.put("BB",123);
        map.put("CC",123);
        map.put("DD",123);
        map.put("EE",123);
        System.out.println(map.get("BB"));
        boolean isExist=map.containsKey("BB");
        System.out.println(isExist);
        isExist=map.containsValue(12);
        System.out.println(isExist);
        map.clear();
        System.out.println(map.isEmpty());
    }

    @Test
    public void test3(){

        /*
        *       Set keySet():返回所有key构成的Set集合
         *      Collection values():返回所有value构成的Collection集合
         *      Set entrySet():返回所有key-value构成的Set集合
        * */
        Map map=new HashMap();
        map.put("AA",1);
        map.put("BB",2);
        map.put("CC",3);
        map.put("DD",4);
        map.put("EE",5);
        //遍历所有的key：KeySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //遍历所有的value
        Collection values = map.values();
        for(Object obj:values){
            System.out.println(obj);
        }
        //遍历所有的key-value
        Set set1 = map.entrySet();
        Iterator iterator1 = set1.iterator();
        while(iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry= (Map.Entry) obj;
            System.out.println(entry.getKey()+"------"+entry.getValue());

        }


    }
}

test3结果
在这里插入图片描述

J.Bloom
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值