java集合框架---集合的实现类

一.集合的继承体系图

 1).  根接口:Collection(单列集合)

          子接口:Set  ,   List

          List接口的实现类: ArrayList    Vector   LinkedList

          Set接口的实现类: HashSet     TreeSet

 2). 根集合:Map(双列集合)

         子实现类:HashMap   TreeMap

二.List集合的子实现类

 1).ArrayList

        遍历方式:   迭代器遍历      size()+get()方法遍历    //迭代器遍历可用增强for循环替代

        常用方法:  重写父类接口的所有方法(见 核心内库(2) 六.集合)

  2).Vector

      Vector集合
         底层是一种可增长的对象数组,查询快,增删慢
         线程安全,同步.执行效率低
         特有功能
                public void addElement(Object obj)------->add(Object obj)
                public Enumeration element():返回此向量的枚举------>相当于 public Iterator iterator( )                                                       boolean hasMoreElemen   t()-------->boolean hasNext()

                Object nextElement()------------>boolean next()

使用如图:

3).LinkedList

LinkedList集合的特点:
       底层是一种链表实现,查询慢,增删快

       线程不安全,不可同步,执行效率高

特有功能:

     添加功能:
        addFirst(Object e) :将指定的元素插入到列表的开头
        addLast(Object e):将指定的元素添加到列表末尾
     获取功能:
        getFirst():获取列表的第一个元素
        getLast():获取列表的最后一个元素
     删除功能:
        public Object removeFirst()移除并返回列表的第一个元素

        public Object removeLast() 移除并返回列表的最后一个元素

使用如图:

注释:其元素的输出顺序是先进后出和栈结构的输出方式相同

自定义对象模拟栈结构实例:

三.泛型的使用

1).泛型的好处

       1).优化了设计,解决了黄色警告线的问题
       2).避免了强制类型转换
       3).提高了程序的安全性

2).泛型参数类型是由调用者根据自己的需求来给定的

3).泛型定义在集合上

ArrayList<person> p=new ArrayList<person>();//加泛型就是意味着不用强制转型

4).泛型定义在类上

//如果在类上泛型已经明确了是那种类型,则泛型的前后应该保持一致

//将泛型定义在类上后增加了代码量,每次创建对象都要指明泛型参数类型

5).泛型定义在方法上

6).泛型定义在接口上

 泛型定义在接口上有两种情况:

          1).已知子实现类是什么类型

          2).不知子实现类是什么类型

定义如图所示

四.jdk5以后的新特性

增强for,静态导入,可变参数,泛型,自动拆装箱

1)静态导入

静态导入的前提:
           1).前提是该方法必须是静态方法
           2).必须导入到方法的级别
静态导入的格式:
           import static 包名.类名.方法名; 

注意: 当类中定义的方法名和静态导入的方法名相同时,则必须加前缀 

使用如图:

2).方法的可变参数

//方法的可变参数的底层还是数组实现的,可以利用反编译工具看到

//实现了参数个数可变,可以在实际参数中添加元素

3).增强for循环

 增强for循环的格式
           for(数组或集合储存数据的类型  变量名: 数组或者集合对象名){
               输出变量即可
                }

  增强for循环是替代迭代器的,所以在遍历数组元素或者集合元素时可以使用增强for循环减少代码量

注意:增强for循环遍历集合元素(同迭代器遍历),如果要添加新元素,就会出现异常,此时要用size()+get()方法遍历

4).泛型的高级通配符(认识即可)

<?>     :代表任意类型Object类型,或者任意的java类

<? extend E> :向下限定  ,子实现类的泛型类型可以是E或者E的子类

<? super   E> :向上限定  ,子实现类的泛型类型可以是E及其E的父类

五.用户注册和登录实例

共创建四个类: 实体类(entity)   接口(dao)和实现类  测试类(test)

实体类

接口:

实现类:

测试类:

六.Set集合的子实现类

1)HashSet

  Set集合为什么可以保证元素的唯一性?
   看源码:
   HashSet集合的add方法底层依赖于双列集合HashMap,它依赖于两个方法,HashCode()方法和equals()方法
       先比较字符串的HashCode()码值是否一样,再比较equals方法
   如果HashCode值一样,还要比较内容是否相同,由于存储的String类型,String类型的HashCode具有唯一性,

     底层已经重写了equals方法,所以不用重写此方法

//Set集合存储自定义的对象,必须重写hashCode方法和equals方法,否则输出的是地址

2)TreeSet

  TreeSet集合的构造方式不同,使用的排序方式也不同
       自然排序:自定义的类实现Comparable接口,通过无参构造形式创建对象,并且重写ComparaTo()方法
       比较器排序:通过public TreeSet(Comparator<E> comparator)构造方法创建对象,并且重写了Compare()方法
       比较器排序的两种方式:
                     1).创建实现类继承Comparator接口,并且重写Compare()方法

                     2).直接使用匿名内部类实现 ,重写Compare()方法,不用创建实现类

  TreeSet集合保证元素是看ComparaTo()方法或者Compare()方法返回值是否为0;
  TreeSet集合底层依赖于TreeMap集合的方法,存储方式为红黑树结构

自然排序中重写CompareTo()方法的两种排序规则实例:

前提:实体类继承于Comparable接口,并且通过无参构造来创建TreeSet集合的对象

比较器排序实现类的实例:

前提:通过public TreeSet(Comparator<E> comparator)构造方法创建对象

TreeSet集合add()方法的源码分析:

int cmp; //cmp变量
        Entry<K,V> parent; //parent =root = 根节点
        // split comparator and comparable paths //如果有根节点,分两种方式:comparable接口 和Compartor(比较排序)
       
        //比较器排序
        Comparator<? super K> cpr = comparator; //创建了Compartor实例,属于比较函数(实现比较器排序)
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else { //自然排序的底层代码
            if (key == null) //元素是否为空
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
                //创建了实例Comparable接口的实例对象(自己实现类) //
            do {
                parent = t; // 开始存储:先存储点
                //k,除过根节点后面的元素和根节点进行比较
                cmp = k.compareTo(t.key); //底层依赖于就是Compareable接口中的compareTo比较
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;s
                else
                    return t.setValue(value); //如果重复的值,将第一次存储的值存进去
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent); //创建了一个键值对对象
        if (cmp < 0) //后面的元素大于前面元素
            parent.left = e; //左边开始取元素
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null; //如果没有元素 ,返回nulll
    }


}

七.Map集合

Map集合:是一种键和值的映射关系(双列集合) 

//键只能出现一次,二值可以重复出现

Map接口的功能:
      V put(K key,V value):添加功能:将指定的值和键关联起来
     注意:
             put方法的返回值:如果该键是第一次存储则返回值是null;
                                   如果该键不是第一次存储,则返回的值是第一次键所对应的值,并且当前的值就把上一个值替换掉了
      Map<K,V>.在Map集合中,只对键有效,跟值无关
      获取功能
      Set<Map.Entry<K,V>> entrySet() :和Map集合的遍历功能有关系(键值对对象)
      Set<k> keySet():获取映射关系中所有的键的集合
      int size() :返回此映射中的键-值映射关系数
      V get(Object key) :返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 
      删除功能
      void claer():删除所有映射关系
      V remove(Object key) :如果存在一个键的映射关系，则将其从此映射中移除 。
      
      判断功能:
      boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true
      boolean containsValue(Object value)如果此映射将一个或多个键映射到指定值，则返回 true

      boolean isEmpty()如果此映射未包含键-值映射关系，则返回 true

使用如图:

Map集合的两种遍历方式:

        1)利用Set<k> keySet():获取映射关系中所有的键的集合,然后利用  V get(Object key) :
              返回指定键所映射的值,输出
        2)Set<Map.Entry<K,V>> entrySet() :和Map集合的遍历功能有关系(键值对对象)
                 接口 Map.Entry<K,V>里面的方法:
                                 K getKey()返回与此项对应的键 

                                 V getValue()返回与此项对应的值

第一种遍历方式如图:

第二种遍历方式如图:

//从内存角度上考虑,第一种遍历方式更好,第二种遍历方式比较耗内存

集合的嵌套遍历:

       利用循环的嵌套来遍历,外层循环先遍历大集合里面的元素,然后内层循环再遍历每个小集合的元素

实例如图:

            

Map集合与Collection集合的区别:

                       Map集合:是一种键和值的映射关系(双列集合) , 当作为:夫妻对

                       Collection集合:单列集合,只能存储一种类型的元素, 当作为:光棍

//Map集合和Collection集合没有直接关系,但有间接关系

间接关系:

           HashSet底层依赖于Map接口的子实现类HashMap

           TreeSet底层依赖于Map接口的子实现类TreeMap