黑马程序员技术交流社区

标题: 跪求大神总结一下集合。。。天天都能遇见集合。 [打印本页]

作者: TheBest__^    时间: 2014-8-30 11:03
标题: 跪求大神总结一下集合。。。天天都能遇见集合。
跪求大神总结一下集合。。。天天都能遇见集合。
作者: 陈君    时间: 2014-8-30 11:03
集合框架总结:
主要是collection接口和map接口。
collection接口里主要是List和set子接口
collection接口里的集合都可以用iterator迭代器来实现遍历
list接口的实现类可以存储重复元素  
list接口主要用到3个集合。
1.vector(线程同步,安全,性能低,被arraylist替代)
2.arraylist(线程不同步,性能高,底层数据结构是数组,所以插入元素的时候性能较低)
3.linkedlist(底层数据结构是链表,所以插入元素的时候性能较高)
set接口不能存储重复元素
set接口主要用到2个集合       
1.hashset(底层是hash表结构,存储对象的时候会分别调用hashcode()和equals()方法判断是否和集合里的已有元素重复)
2.treeset(底层是二叉树结构,存储对象的时候改对象必须可以被比较。所以有两种方法:1.创建集合的时候传入一个实现了comparator接口的对象。2.要存储的对象所在的集合实现了comparable接口  对treeset遍历的时候其实就是用中序遍历的方式对二叉树进行遍历)
map接口主要有2种遍历方式(1.通过keyset方法得到set集合来遍历1.通过entryset方法得到一个存放了Map.entry的set集合来遍历,这个集合中存放的其实就是键和值之间的对应关系)
map接口主要有2个集合
1.hashmap
2.treemap
作者: 梦里听传说    时间: 2014-8-30 11:18
感谢分享
作者: 戏言丶    时间: 2014-8-30 11:38
感谢2楼分享
作者: 继续悲伤    时间: 2014-8-30 11:55
希望能帮到你!
1:集合体系(掌握)
        集合
                |--Collection(单列)
                        |--List(有序,可重复)
                                |--ArrayList
                                        底层数据结构是数组,查询快,增删慢。
                                        线程不安全,效率高。
                                |--Vector
                                        底层数据结构是数组,查询快,增删慢。
                                        线程安全,效率低。
                                |--LinkedList       
                                        底层数据结构是链表,查询慢,增删快。
                                        线程不安全,效率高。
                        |--Set(无序,唯一)
                                |--HashSet
                                        底层数据结构是哈希表。
                                        线程不安全,效率高。

                                        怎么保证唯一性的呢?
                                        它依赖两个方法:hashCode()和equals()
                                        顺序:
                                                首先判断hashCode()值是否相同。
                                                同:继续走equals(),看返回值
                                                        如果true:就不添加到集合。
                                                        如果false:就添加到集合。
                                                不同:就添加到集合。
                                |--TreeSet
                                        底层数据结构是二叉树。
                                        线程不安全,效率高。

                                        怎么保证唯一性的呢?是根据返回是否是0。
                                        怎么保证排序的呢?两种方式
                                                自然排序(元素具备比较性)
                                                        实现Comparable接口
                                                比较器排序(集合具备比较性)
                                                        实现Comparator接口
                |--Map(双列 底层结构是针对键有效,跟值无关)
                        |--HashMap
                                底层数据结构是哈希表。
                                线程不安全,效率高。

                                怎么保证唯一性的呢?
                                它依赖两个方法:hashCode()和equals()
                                顺序:
                                        首先判断hashCode()值是否相同。
                                        同:继续走equals(),看返回值
                                                如果true:就不添加到集合。
                                                如果false:就添加到集合。
                                        不同:就添加到集合。
                        |--Hashtable
                                底层数据结构是哈希表。
                                线程安全,效率低。

                                怎么保证唯一性的呢?
                                它依赖两个方法:hashCode()和equals()
                                顺序:
                                        首先判断hashCode()值是否相同。
                                        同:继续走equals(),看返回值
                                                如果true:就不添加到集合。
                                                如果false:就添加到集合。
                                        不同:就添加到集合。
                        |--TreeMap
                                底层数据结构是二叉树。
                                线程不安全,效率高。

                                怎么保证唯一性的呢?是根据返回是否是0。
                                怎么保证排序的呢?两种方式
                                        自然排序(元素具备比较性)
                                                实现Comparable接口
                                        比较器排序(集合具备比较性)
                                                实现Comparator接口

2:应用。(添加功能,判断功能,删除功能,获取功能,长度功能)
        Collection
                add(Object obj)
                remove(Object obj)
                contains(Object obj)
                iterator()
                size()
               
                |--List
                        get(int index)
                        add(int index,Object obj)
                        remove(int index)
                        set(int index,Object obj)
                |--Set

        Map
                put(Object key,Object value)
                remove(Object key)
                containsKey(Object key)
                containsValue(Object value)
                size()
                get(Object key)
                keySet()
                values()

3:遍历方式
        List:
                迭代器(在源码中可以看到的,开发中也经常看到)
                增强for(开发中看到,JDK5以后用)
                普通for

                如果仅仅为了遍历,用任意一种即可。一般选择前两种的任意一种。
                如果要做修改,或者删除指定位置的元素,或者在指定位置添加元素。用普通for。
        Set:
                迭代器
                增强for

                任选一种。
        Map:
                键找值。

4:代码补齐:请对array,hs,hm进行遍历。
        A:
                ArrayList<String> array = new ArrayList<String>();

                方式1:
                Iterator<String> it = array.iterator();
                while(it.hasNext()){
                        String s = it.next();
                        System.out.println(s);
                }

                方式2:
                for(String s : array){
                        System.out.println(s);
                }

                方式3:
                for(int x=0; x<array.size(); x++){
                        String s = array.get(x);
                        System.out.println(s);
                }

        B:
                HashSet<String> hs = new HashSet<String>();
       
                方式1:
                Iterator<String> it = hs.iterator();
                while(it.hasNext()){
                        String s = it.next();
                        System.out.println(s);
                }

                方式2:
                for(String s : hs)
                {
                        System.out.println(s);
                }

        C:
                HashMap<String,Strting> hm = new HashMap<String,String>();       

                Set<String> set = hm.keySet();
                for(String key : set)
                {
                        String value = hm.get(key);
                        System.out.println(key+"***"+value);
                }

5:什么时候用谁?
        是否键值对?
                是:Map
                        是否对键排序?
                                是:TreeMap
                                否:HashMap
                        不懂的情况下,使用HashMap。

                否:Collection
                        是否唯一
                                是:Set
                                        是否对元素进行排序?
                                                是:TreeSet
                                                否:HashSet
                                        不懂的情况下,使用HashSet
                                否:List
                                        是否要安全:
                                                是:Vector(真正开发中也不用)
                                                        List list = Collections.synchronizedList(new ArrayList());

                                                否:ArrayList,LinkedList
                                                        查询多:ArrayList
                                                        增删多:LinkedList
                                        不懂的情况下,使用ArrayList
作者: ximi    时间: 2014-8-30 20:40
这个是我总结的

Java集合框架基础总结.rar

125.84 KB, 阅读权限: 10, 下载次数: 6


作者: 何磊    时间: 2014-8-31 09:45
ximi 发表于 2014-8-30 20:40
这个是我总结的

谢谢分享
作者: 文盲庄稼汉    时间: 2014-8-31 10:52
这个我总结过.可以去看我的帖子。哈哈




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2