java集合类整理

Collection:
    set(接口)
    AbstractCollection(抽象类)
        AbstractList->List
            AbstractSequentialList
                LinkedList(实现了Deque双端队列接口)
            Vetor<-Stack
            ArrayList
        AbstractSet(实现了Set接口)
            TreeSet:实现了NavigableSet->SortedSet->Set
    List(接口)
    Queue(接口)   
接口
    Collection  Set List    Queue   SortedSet   NavigableSet
    分析:
        1:所有的类或接口都是实现了Collection接口
        2:TreeSet,HashSet,LinkedHashSet实现了Set接口,其中TreeSet实现了SortedSet
        3:ArrayList,Vector,LinkedList实现了List接口
java.util.Collection
    所有集合的根接口
    增加:
        add(o:E):boolean
        addAll(c:Collection<? extends E>):boolean
    删除
        remove(o:E):boolean
        removeAll(c:Collection<?>):boolean
        clear():boolean
    修改:
    查:
        contains(o:Object):boolean
        containsAll(c:Collection<?>):boolean
    其他:
        equal(o:Object)
        hashCode();int  //返回集合的散列码
        size():int  
        toArray():Object[]  //返回集合的数组情势
        isEmpty()
        iterator():Interator<E>     //返回1个迭代器
    备注:Iterator接口
        hasNext()
        Next()
Set集合
    Set接口扩大了Collection接口。它没有引入新的方法或常量,只是规定set的实例不包括重复的元素
        1,Set接口依托hashCode和equals()完成重复元素的判断,关注这点在往后的map接口中也有体现
        2,TreeSet依托Comparable接口来完成排序的操作
        3,Set方法使用时,元素为自定义类时,自定义类要腹泻Object类中的equals(),hashCode(),toString()方法
        4,具体实现类HashSet,TreeSet,LinkedHashSet
        5,特别注意,规则集中不存在重复元素,所以添加重复元素时会返回false,但是不会有异常
散列集java.util.HashSet    
    初始容量为16,客座率为0.75
    当元素个数超过容量*客座率的乘积,容量就会自动翻倍
    初始化
        HashSet()
        HashSet(c:Collection<? extends E>)
        HashSet(initialCapacity:int)
        HashSet(initialCapacity:int,loadFactor:float)   
    方法:
        实现了Collection接口中的方法
链式散列表LinkedHashSet
    用1个链表来扩大HashSet,支持对规则集内的元素排序(所谓的排序就是依照添加的顺序存储,访问的时候也是依照添加的顺序)。HashSet中的元素是没有被排序的,而LinkedHashSet中的元素可以依照他们插入规则集的顺序提取。
    初始化:
        LinkedHashSet()
        LinkedHashSet(c:Collection<? extends E>)
        LinkedHashSet(initialCapacity:int)
        LinkedHashSet(initialCapacity:int,loadFactor:float)
    方法:
        实现了Collection中的方法
    Set方法没有访问索引的方法,只有add,remove,contains类方法
树形集TreeSet
    SortedSet是Set的1个子接口,可以确保规则集中的元素时有序的。另外,它还提供方法first,last方法以返回规则集中的第1个和最后1个,和方法headSet((toElement))和tail(fromElement)返回规则集中小于toElement或大于等于fromElement的部份
    NavigableSet扩大了SortedSet,并提供导航方法lower(e),floor(e),ceiling(e),higher(e)以分别返回小于,小于等于,大于等于和大于给定元素的元素。如果没有就返回null。pollFirst,pollLast会分别删除和返回树形集中的第1个元素和最后1个元素
    TreeSet是SortedSet的1个具体类,元素必须是可比较的,即元素实现了comparable接口或被指定了比较器
    总结1下方法
    TreeSet普通方法:
        Set自我感觉提供的是1种存储的服务,其实不善于找出这个位置,所以他的存储是无序的,因此方法上与list就不1样了,不需要有index参数
        初始化
            TreeSet()
            TreeSet(c:Collection<? extends E>)
            TreeSet(comparator:Comparator<? super E>)
            TreeSet(s:SortedSet<E>)
        增加:
            add()
            addAll()
        删除:
            remove()
            removeAll()
            clear()
        修改:
        查找:
            contains()
            containsAll()
        其他(长度,迭代器,哈希code等):
            size();
            toArray()
            isEmpty()
            iterator()
            equals()
            hashCode()
    TreeSet的特殊方法(实现了接口SortedSet和NavigableSet的方法):
        注意:使用这些方法时,定义对象的类型必须是SortedSet
        增加:
            无
        删除:
            pollFirst()
            pollLast()
        查找:
            导航方法
            首个元素:   first() //空集和时会引发异常
            尾元素:    last()
            小于e的集合  headSet():SortedSet<E> //不存在返回空集
            大于等于e的集合    tailSet():SotedSet<E> //不存在返回空集
            大于e     higher(e)   //不存在返回null
            大于等于    ceiling(e)  //不存在返回null
            小于      lower(e)    //不存在返回null
            小于等于    floor(e)    //不存在返回null     
        修改:
        其他:     
        小技能:
            1、当定义hashset时可使用Set<E> set = new HashSet<E>()定义
            2、定义TreeSet时,最后直接使用TreeSet<E> set = new TreeSet<E>() 
Comparable接口
    位于java.lang
    public interface Companrable<T>{
        public int compareTo(T o);
    }
Comparator接口
    有时候希望将元素插入1个树集合中,这些元素可能不是java.lang.comparable的实例,这时候可以定义1个比较器来比较这些元素。要做到这1点创建1个java.util.Comparator接口的类。
    comparator接口有两个方法:
        public int compare(Object e1,Object e2)
        public boolean equals(Object e)




线性表
    规则集中只能存储不重复的值,为了存储重复的值需要使员工线性表。
    List接口扩大了Collection接口,以定义1个允许重复的有序集合。List接口增加了面向位置的操作,并且增加了1个能够双向遍历线性表的迭代器
    方法:
        1、可使用Collection中的方法
        2、操作中分为面向元素和面向位置两种方式
        增加:
            add(index:int):boolean
            add(index:int,c:Collection<? extends E>)
            add(E)  //末尾添加
            addAll(c:Collection<? extends E>);  //末尾添加
        删除:
            remove(index:int)
            remove(o)
            removeAll(c)
        修改:
            set(index:int,e):E
        查找:
            //查找元素
            get(index:int):E
            contains(o):boolean
            contains(c):boolean
            //面向索引
            indexOf(e)
            lastIndexOf(e)
        其他
            listIterator():ListIterator<E>
            listIterator(startIndex:int):ListIterator<E>
            subList(fromIndex:int,toIndex:int):List<E>  //返回从fromIndex到toIndex⑴的子列表
java.util.ListIterator
        add(o:E):void
        向后:
            hasNext():boolean
            Next():E
            nextIndex():int     //返回下1个元素的下标
            remove():void
        向前:
            hasPrevious()
            previous()
            previousIndex():index   //返回前1个元素的下标
            set(E):void //使用指定的元素替换previous或next返回的最后1个元素
数组线性表ArrayList
java.util.ArrayList<E>:
    初始化:
        List<E> list = new ArrayList<E>();
        ArrayList<E>()
        ArrayList<E>(c:Collection<? extends E>)
        ArrayList<E>(capacity:int)
    增加:
        add(o:E):void
        add(index:int,o:E):void//插入元素
    删除:
        remove(o:E):boolean
        remove(index:int):boolean//索引必须公道,否则有异常出现
        clear()
    修改:
        set(index:int,o:E):E    //索引必须公道,否则有异常出现
    查:
        get(index:int):E
        indexOf(o:E):int    //不存在返回⑴
        lastIndexOf(o:E):int    //不存在返回⑴
        contains(o:E):boolean
        isEmpty():boolean
    长度:
        size()
    自动减小
        线性表不会自动减小,只会自动增加
        trimToSize()    //容量减小到这个列表确当前大小
链表线性表LinkedList
    实现了List的接口和Queue接口
    初始化
        LinkedList()
        LinkedList(c:Collection<? extends E>)
    增加:
        addFist(o:E)    //添加到列表头
        addLast(o:E)    //添加到列表尾
        //List中的方法
        add(index)
        add(index,e)
        addAll(c)
    删除
        removeFirst()
        removeLast()
        //List
        remove(index)
    查找
        getFirst()
        getLast()
        //List
        get(index)
        indexOf(e)
        lastIndexOf(e)
    其他
        //List
        listIterator():ListIterator<E>
        listIterator(index):ListIterator<E>()
        subList(start,end);     //start~end⑴
Collection静态方法
    排序(改进归并排序)
        sort(list:List):void
        sort(list:List,c:Comparator):void
    查找
        binarySearch(list,key)
        binarySearch(list,key,comparator)
    颠倒
        reverse(list)
    倒序
        reverseOrder();//返回逆序的比较器
    随机打乱
        shuffle(list)
        shuffle(list,random) //用随机对象打乱
    复制
        copy(des:List,src:List):void
        nCopies(n:int,o:Object):List    //返回o的n个副本的列表
    填充
        fill(list,o)    //用指定元素替换线性表中的所有元素
    最大值
        max(c:Collection):Object
        max(c:Collection,c:comparator):Object
    最小值
        min(c):Object
        min(c1,c2):Object
    某元素出现次数
        frequency(c:Collection,o:Object):int    
向量类Vector
    与ArrayList几近1样,只是添加了同步方法    
    实现了List方法
    初始化
        Vector()
        Vector(c:Collection<? extends E>)
        Vector(initialCapacity:int);
        Vector(initialCapacity:int,CapacityIncr:int)
    增加:
        addElement(o:E)
        insertElementAt(o:E,index:int)
    删除
        removeAllElements()
        removeElement(o)
        removeElementAt(index)
    修改:
        setElementAt(o,index)
    查找
        firstElement()
        lastElement()
        ElementAt(index)
Stack
    Stack()
    empty()
    pop()
    push()
    peek():返回栈顶元素
    search(o): 返回栈中指定元素的位置
Queue
    offer(e):向队列中插入1个元素
    poll(): 出队,空时返回null
    remove():出队,空时出现异常
    peek(): 获得队首元素,为空时返回null
    element():获得队首元素,为空时出现异常
Deque   双端队列
    LinkedList 实现了Deque接口,因此可使用LinkedList创建1个双端队列
    addFirst()
    addLast()
    removeFirst()
    removeLast()
    getFirst()
    getLast()


Map
    用于存储键值对情势的数据
    map接口提供的方法
        查询
            get(key):V
            values():Collection<V>
            keySet():Set<K>
            entrySet():Set<Map.Entry<K,V>>
            containsKey(key):boolean
            containsValue(value):boolean
            isEmpty()
            size()
        增加
            put(key,value)
            put(map)
        删除
            remove(key)
            clear()
        修改
HashMap

LinkedHashMap
    使用linked list实现来扩大HashMap
TreeMap         
    在遍历排好序的键值时高效
    有新的导航方法
        firstKey()
        lastKey()
        headMap(toKey)
        tailMap(fromKey)

        floorKey(key)
        ceillingKey(key)
        lowerKey(key)
        higherKey(key)
    附:map的遍历方法
        Set<Map.Entry<K,V>> set = map.entrySet();
        for(Map.Entry<K,V> m : set){
            key=m.getKey();
            value=m.getValue();
        }
波比源码 – 精品源码模版分享 | www.bobi11.com
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是赞助,收取费用仅维持本站的日常运营所需!
7. 如遇到加密压缩包,请使用WINRAR解压,如遇到无法解压的请联系管理员!

波比源码 » java集合类整理

发表评论

Hi, 如果你对这款模板有疑问,可以跟我联系哦!

联系站长
赞助VIP 享更多特权,建议使用 QQ 登录
喜欢我嘛?喜欢就按“ctrl+D”收藏我吧!♡