集合与泛型

 

Java中集合框架层次结构:

Iterable接口:
    Collection接口:
    List接口:
    
Iterator接口:
    ListIterator接口:

Collection接口: 
    List接口:
        ArrayList类:
        LinkedList类:
        Vector类:
            Stack
    Set接口:
        HashSet类:
        TreeSet类:
        
Map接口:
    HashMap类:
    Hashtable类:
    TreeMap类:

Collection和Map没有关系,
Collection和Collections的区别是Collection是接口,Collections是类

    
数组:
    数组也是容器,它是定长的,不会自动扩容;一块连续的内存,访问快;可以存储基本数据类型和引用数据类型的对象
    
java.util.*;
集合:变长的,自动扩容,只能存储引用数据类型的对象
    数组或者链表
    
    分类:
        1)集:Set接口:元素无序且不重复,可以放null,但是只能存放一个
            无序:
                元素存入顺序和集合内存储的顺序不同,打印结果是按照存储顺序来打印
            无重复:
                两个对象e1和e2,如果e1.equals(e2)返回true,则认为e1和e2重复,在set中只保留一个(先判断hashCode()方法再用equals()方法进行判断)

            1-1)HashSet:内部对象散列存取,采用哈希技术
                线程不安全,不同步的,存取速度比较快,底层实现是用HashMap实现
                1)初始容量:默认初始容量16
                2)加载因子:默认0.75,
                    一般情况下,加载因子系数必须<=1,当元素个数超过容量长度*加载因子系数的时候,自动进行扩容
                3)扩容增量:原容量的一倍
            1-2)TreeSet:存入顺序跟存储顺序不同,但存储按照排序存储
                线程不安全,不同步的,此类保证排序后的set按照升序排列元素
        2)列表:List接口:有序的,允许重复,可以放null,且可以放多个
            ArrayList:
                初始容量:默认初始容量10
                加载因子:1???
                扩容增量:原容量的0.5倍+1;
            Vector:
                初始容量:默认初始容量10
                加载因子:1
                扩容增量:原容量的1倍
        
        
            ArrayList和LinkedList的区别:
                1)ArrayList:线性顺序存储,是一种线性表
                    底层数据结构是数组,查询比较快,插入/删除比较慢
                2)LinkedList:数据结构中链表的Java实现
                    底层数据结构是双向链表,查询用二分查找,所以查询效率比ArrayList低,插入/删除效率比ArrayList高
            ArrayList和Vector的区别:底层的数据结构都是数组
                1)ArrayList:
                    线程不安全的,不同步的,数据不安全,速度比较快
                2)Vector:
                    线程安全的,同步的,数据安全,速度比较慢
        3)字典:Map:键值对,键是唯一的
            1)HashMap:数组+单向链表+红黑树
                初始容量:默认16;
                加载因子:默认0.75
                扩容增量:原容量的1倍
            2)Hashtable:数组+单向链表+红黑树(平衡二叉树)
                初始容量:默认11
                加载因子:默认0.75
                扩容增量:原容量的1倍+1
            3)TreeMap:按照键升序排序,底层数据结构是红黑树
            
            HashMap和Hashtable的区别:
                1)HashMap:
                    a)线程不安全,不同步,数据不安全,但是效率高;
                    b)允许键值可以为null;
                2)Hashtable:
                    a)线程安全,加锁同步,数据安全,效率比较低;
                    b)不允许键值为null
                    
            HashMap和TreeMap的区别:
                1)HashMap:
                    a):HashMap基于哈比表实现,所以里面元素不进行排序
                    b):HashMap可以通过调优初始容量和负载因子,优化HashMap空间的使用
                    c)HashMap性能优于TreeMap
                2)TreeMap:
                    a):TreeMap基于树实现,所以里面的元素按照键升序排列
                    b):TreeMap没有调优选项,因为该数总处于平衡状态
                    
            Map中对元素进行修改:
                Map中因为键必须是唯一的,所以要对map中的元素进行修改时,重新添加一个元素,键与要修改的元素的键一致即可,去覆盖掉原来的数据
    如何选择集合类:
        1)Set内存放的元素不允许重复,List存放的元素有一定的顺序
        2)Map的应用主要在利用键/值对进行快速查询 
        3)ArrayList和LinkedList的区别在于随机查询性能上ArrayList要好,但LinkedList的中间元素的插入与删除性能好
        4)HashSet和TreeSet的区别在于集合内元素是否排序
    注意点:
        集合中的add()方法接受的是一个Object对象的参数,在获取集合中的对象时,必须进行造型(强制类型转换)操作
        
    Iterator接口:单向遍历,ListInterator:双向遍历
        1)Iterator对象称作迭代器,用来方便的实现对容器内的元素进行遍历操作
        2)所有实现了Collection接口的集合类都有一个iterator()方法,返回一个实现了Iterator接口的对象
        3)Iterator对象实现了统一的一个用来遍历Collection中对象的方法
        4)Iterator是为遍历而设计,能够从集合中取出元素和删除元素,但是没有添加元素的功能
        5)Iterator的功能上比较简单，
        5)使用中，只能单向移动

    Collections类:
        Comparable:java.lang.*;
        Comparator:java.util.*;
        常用方法:
            Object  max(collection c):
                返回集合中的最大元素,需要考虑比较接口的实现
            Object  min(Collection c):
                返回集合中的最小元素
            void  reverse(Collection c):
                把集合中的元素顺序反转
            void  copy(List dest,List src):
                src集合中元素复制到dest集合,dest集合中的元素数量要比src集合中的多,否则报错
            void  fill(List list,Object o):
                填充list集合,填充元素为o
            int  binarySearch(List list,Object key):
                对排序后的集合list进行查询元素操作
            void  sort(List list):
                对一种List做排序
        
    泛型:参数化的数据类型:数据类型可以像参数传递一样进行传递
        1)安全的
        2)减少了数据类型转换所带来的风险,减少了装箱拆箱
        分类:
            1)泛型方法:
                [访问修饰符] <T>返回值 方法名([参数列表]){方法体}
            2)泛型类:增加泛型类无意中增加了继承的复杂性
                类中的成员的数据类型不确定时,可以做成泛型类
                声明:
                    [访问修饰符] class 类名<T>{类的成员}
                使用:
                    类名<T> 引用名 = new 类名<T>();
            3)泛型接口:
                [访问修饰符] interface 接口名<T>{接口的成员}
    
    类型T  元素E 键K 值V
    
    T:包括Object在内的所有的类型都可以
        <T extends Number>:表示把T限定在Number及其子类的类的类型
            extends后面只能是一个类
        <T extends Number&Comparable&...>
            限定在Number类并且实现了Comparable接口的数据类型,接口可以连接多个
    通配符:?
    上界通配符: ? extends A  : A类或者A类的子类
    下界通配符: ? super  A   : A类或者A类的父类
        
数组:length        字符串:length()        集合:size()

isEmpty():判断的是集合的长度是否为0,即集合中是否中存在元素,而不是判断集合是否为null

//扩充0次,指定了初始容量直接开辟相应的空间
ArrayList list = new ArrayList(20);

ArrayList进行自动扩容时,是找一个新的内存,把原来的数据拷贝过来,然后加上新的数据,造成内存浪费,所以在明确要存储多少个元素时,要指定长度,避免扩容