集合的基本使用

集合
    集合框架构成及分类


    ArrayList al = new ArrayList();    //需要进行类型转换
    Iterator it = al.iterator();       //获取迭代器(可以解释为一种遍历方式)
            Iterator<String> it = al.iterator();    //确定传入String时可以使用泛型绑定
            只有列表迭代器才能,增删改查,其他迭代器只有删的功能
        while(it.hasNext())            //判断是否存在下一个,存在返回true
        it.next()        //返回下一个对象并将指针移向下一位
        ListIterator li = al.listIterator();            //列表特有的迭代器
            //特有方法
                hasprevious();    //逆向遍历元素,列表前一个位置有元素,则放回true
                previous();        //返回列表的前一个元素
        void remove()     //从迭代去指向的Collection中移除迭代器返回的最后一个元素
    Collection        //集合
                取出方式:
                    迭代器
                    for(  : )
        --List     :元素是有序的,元素可以重复,因为该集合体系有索引

 1     特有方法:
 2                 增:
 3                     add(index,element);       //在指定位置增加元素
 4                     addAll(index,Collection);       //在指定位置增加集合
 5                 删:
 6                     remove(index);            //删除指定位置元素
 7                 改:
 8                     set(index,element);        //更改指定位置元素
 9                 查:
10                     get(index);                //返回指定位置元素
11                     subList(from,to);        //获取子列表,从from到to, to越界会异常

                    listIterator();            //列表特有的迭代器
                        //特有方法
                            hasprevious();    //逆向遍历元素,列表前一个位置有元素,则放回true
                            previous();        //返回列表的前一个元素
                    indexOf(Object o);        //返回第一次出现的指定元素的位置,若无,返回-1
                    lastIndexOf(Object o);    //返回最后一次出现的指定元素的位置,若无,返回-1
            ArrayList:底层数据结构使用的数组结构,特点:查询速度快,但增删稍慢,线程不同步
            LinkedList:底层使用链表数据结构,特点:增删速度快,但查询慢

 1                 特有方法
 2                     获取
 3                         peekFirst();   //获取第一个元素
 4                         peekLast();    //获取最后一个元素
 5  6                         pollFirst();    //获取第一个元素,并删除元素
 7                         pollLast();    //获取最后元素,并删除元素
 8  9                         offerFirst();      增加第一个元素
10                         offerLast();    增加最后一个元素

            Vector:底层使用数据结构使用的数组结构,线程同步,被ArrayList取代
                Enumeration枚举         //Vector特有取出方式,与迭代器相同,因为名称过长而被取代
        --set :元素是无序的,元素不可以重复, 底层使用了map方法
            HashSet     //数据结构以哈希表形式存储元素,
            TreeSet        //底层数据结构是二叉树,可以对set集合中的元素进行排序,
                    保证元素唯一性的依据
                        compareTo方法return 0;
                    TreeSet ts= new TreeSet
                Comparable        //强制让对象具备比较性
                    int compareTo(T o)    //比较此对象与指定对象的顺序。
                            如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。                     
                        TreeSet排序的第一种方法,让元素自身具备比较性,
                        元素需要实现Comparable接口,覆盖compareTo方法,这种方式也称为元素的自然顺序。
                       

 1       //创建学生类,强制让学生具备比较性
 2                         class Student implements Comprable{
 3                         ... ...
 4                             public int compareTo(Object obj){
 5                                 if(!(obj instanceof Student))        //判断类型是否为学生
 6                                     throw new RuntimeException("不是学生对象");    //抛出异常
 7                                 Student s = (Student)obj;    //强制转换类型
 8                                 if(this.age>s.age)        //以年龄为排序依据
 9                                     return 1;
10                                 if(this.age==this.age)    //当年龄相同时,以名字为排序依据
11                                     return this.name.compareTo(s.name);
12                                 return -1;
13                             }
14                         ... ...
15                         }

 



                Comparator        //强行对某个对象 collection 进行整体排序 的比较函数。
                        TreeSet的第二种比较方式,当元素自身不具备比较性时,
                        或者具备的比较性不是所需要时,
                        这时就需要让集合自身具备比较性,在集合的初始化时,就有了比较方法,

 1                        TreeSet ts = new TreeSet (new MyCompare());        //创建使用MyCompare()排序的TreeSet
 2                                 //创建Mycompare排序,继承Comparator,
 3                                 效果:当比较对象小于指定对象,返回负整数,大于时返回正整数,等于时返回0;
 4                         class Mycompare implements Comparator<父>{        //此处泛型可指定父类型继承此类型的子类可使用此方法
 5                                 //重写compare()方法
 6                             public int compare(Object o1,Object o2){
 7                                 Student s1 = (Student)o1;
 8                                 Student s2 = (Student)o2;
 9                                 int num = s1.getName().compareTo(s2.getName());    //第一次比较当相等时返回0
10                                 if(num == 0){
11                                     return new Integer(s1.getAge()).compareTo(new Integer(s2.age));    //第二次次等元素比较
12                                 }
13                                 return sum;
14                             }
15                         }

 


                    compare(T o1, T o2)           //比较用来排序的两个参数。
                     boolean equals(Object obj)           //指示某个其他对象是否“等于”此 Comparator。

 1                 例子
 2                     public static void main(String[] args) {
 3                         TreeSet ts = new TreeSet();
 4                         ts.add("abs");
 5                         ts.add("abx");
 6                         ts.add("abb");
 7                         ts.add("abc");
 8                         Iterator it = ts.iterator();
 9                         while(it.hasNext())
10                             System.out.println(it.next());
11                     }
12                         输出结果:
13                         abb
14                         abc
15                         abs
16                         abx

 

 

 1                 事例
 2                     ArrayList al = new ArrayList();
 3                     al.add("java01");    //添加对象
 4                     al.add("java02");
 5                     al.add("java03");
 6                     System.out.println(al+","+al.size());//返回对象个数
 7                     al.remove("java02");    //删除对象
 8                     al.clear();    //清空集合
 9                     System.out.println("java03是否存在:"+al.contains("java03"));    //判断某对象是否存在
10                     System.out.println("集合是否为空:al.isEmpty()");    //判断集合是否为空
11                     
12                     输出:[java01, java02, java03],3
13                             java03是否存在:false
14                             集合是否为空:true

 

 

 1         方法
 2             增加
 3                 addAll(Collection<>);            //添加集合
 4             删除
 5                 clear()        //移出所有元素
 6                 al1.retainAll(al2);                //保留al1中与al2相同的对象
 7                 al1.removeAll(al2);    //移除al1中与al2相同的对象
 8                  boolean remove(Object o)           //从此 collection 中移除指定元素的单个实例,如果存在的话(可选操作)。
 9             判断
10                 contains(Object obj)    //判断是否包含元素
11                     运用的是equals方法
12                 isEmpty()        //判断是否元素(不包含返回true)
13                 containsAll(Collection<>);        //判断是否包含集合
14                     运用的是equals方法
15             获取
16                 size()        //返回元素个数
17                 Object[] toArray()        //返回包含所有元素的数组形式
18                 int hashCode()           //返回此 collection 的哈希码值。 

 


        Collections    //服务于Collection的静态多态方法
                此类不能实例化,就像一个工具类
                Collections.max();        //使用方法

 1             方法:
 2                 void copy(List<? super T> dest, List<? extends T> src)    //将所有元素从一个列表复制到另一个列表。
 3                 查找
 4                     int binarySearch(List<? extends Comparable<? super T>> list, T key)    //以二分法搜索在指定列表中的指定对象,返回坐标
 5                                 若集合中不存在元素,返回(-(插入点) - 1)
 6                                 Collections.binarySearch(list, "aaa");        //使用方法
 7                                 第三参数,比较器
 8                     max(Collection<? extends T> coll)    //根据自然顺序,返回最大元素,//第二参数,比较器
 9                     min(Collection<? extends T> coll)    //根据自然顺序,返回最小元素,//第二参数,比较器
10                 修改
11                     顺序
12                         Comparator<T> reverseOrder()  //反转元素顺序,返回比较器
13                                 List list = new List(Collections.reverseOrder)  //使用方法
14                                 Comparator<T> reverseOrder(Comparator<T> cmp)    //可以将如参数,自定义比较器
15                                 List list = new List(Collections.reverseOrder(new comparator))  //使用方法
16                         void  sort(List<T> list)    //根据自然顺序,列表升序排序, 第二参数,比较器
17                         void swap(List<?> list, int i, int j)  //交换列表中的元素位置
18                                 Collections.swap(list, 1, 2);    //使用方法,将角标1与2元素换位
19                         void shuffle(List<?> list)  //将列表中元素随机放置
20                         void reverse(List<?> list)  //反转列表中元素顺序
21                     替换
22                         boolean replaceAll(List<T> list, T oldVal, T newVal)   //将列表中某一值替换为另一个值
23                                 Collections.replaceAll(list,"aaa","qq")  //使用方法  //将列表中的"aaa"替换为"qq"
24                         void fill(List<? super T> list, T obj)  //将指定元素替换列表中的所有元素
25                                 Collections.fill(list, "qq");        //使用方法    //将list中的所有元素替换为"qq"
26                                 可以写一个方法:将List中的某一段元素替换为其他元素

 


        for(T t   :   t)     //对集合t,或数组t进行遍历//局限性:必须有被遍历的目标,不能对集合进行操作
    Map        //集合(地图)
            Map<K,V>    //K为key,键,V为value,值,键与值只能传基本数据类型例如:Integer
            每次存入都为一对一对
            Map<String,String> map = new HashMap<String,String>();
            取出方式:
            Set<k> keySet    //将amp中所有的键存入到set集合中
            Set<Map.Entry<K,V>> entrySet()    //将map集合的映射关系存入到set集合中

 1         方法
 2  3                 V put(K key, V value)     //添加元素,返回值
 4                     map.put("01","zhansan");
 5                     如果出现添加,相同的键,那么会覆盖原有键的对应值
 6                     并返回被覆盖的值,第一次返回null
 7  8                 clear    //移除所有
 9                  V remove(Object key)    //删除键,返回值
10             判断
11                 boolean containKey(Object key)      //判断是否包含键与值
12             获取
13                 V get(Object key)    //返回指定键的值,如不存在则返回null
14                 Collection<V> values()    //返回集合的值
15                 Set<k> keySet    //将amp中所有的键存入到set集合中
16                     因为set具备迭代器,所有可以以迭代方式取出所有的键,
17                     根据get方法,获取每一个键对应的值
18                 Set<Map.Entry<K,V>> entrySet()    //将map集合的映射关系存入到set集合中
19                         这个关系的数据类型是Map.Entry
20                         Set<Map.Entry<String,String>> entrySet = map.entrySet();
21                         Iterator<Map.Entry<String,String>> it = entrySet.iterator();    //使用迭代器
22                         while(it.hasNext()){
23                             Map.Entry<String,String> me = it.next();
24                             String key = me.getKey();
25                             String value = me.getValue();
26                         }
27                     Map.Entry<K,V>
28                          boolean equals(Object o)          // 比较指定对象与此项的相等性。
29                          K getKey()           //返回与此项对应的键。
30                          V getValue()          // 返回与此项对应的值。
31                          int hashCode()          // 返回此映射项的哈希码值。
32                          V setValue(V value)          // 用指定的值替换与此项对应的值(可选操作)。 

 


                    例子

1                         Iterator iter = hashCode.entrySet().iterator();
2                         while (iter.hasNext()) {
3                             Map.Entry entry = (Map.Entry) iter.next();
4                             Object key = entry.getKey();
5                             Object val = entry.getValue();
6                             System.out.println(key+"......"+val);
7                         }

 


        Hashtable    //底层是哈希表结构,不可以存入null键null值,该集合线程同步, JDK1.0,效率低
        HashMap    //底层是哈希表结构,允许使用null键,null值,该集合不同步
                JDK1.2,效率高
                HashMap<String,String> hashMap = new HashMap<String,String>()    //创建
                hashMap.put("asdasd","sadasd");        //添加元素
            Properties       //可以用于储存键值对形势的软件配置信息
                    在加载数据时需要固定格式,  键=值
                void load(InputStream inStream)      //从输入流中读取属性列表(键和元素对)。
                   

1 load(Reader reader)
2                               按简单的面向行的格式从输入字符流中读取属性列表(键和元素对)。
3                     Proerties pro = new proerties();
4                     FileInputStream fileInput = new FileInputStream("demo.txt");
5                     FileOutputStream fileOutput = new FileOutputStream("demo.txt");
6                     pro.load(fileInput);                            //将文件流中的数据写入集合
7                     pro.list(System.out);                          //输出

 


                Object setProperty(String key, String value)          //根据键,更改集合中的数据
                void store(OutputStream out, String comments)         //将集合中的数据保存入文件
                void storeToXML(OutputStream os, String comment)           //发出一个表示此表中包含的所有属性的 XML 文档。
                void list(PrintStream out)          //将集合中的数据输出
                    pro.list(System.out);                          //输出
                String getProperty(String key)     //通过键返回值
                    String getProperty(String key, String defaultValue)
                              用指定的键在属性列表中搜索属性。
                    ,第二参数为默认值,若文件中无此键,则返回默认值,
                    无第二参数返回null;
        TreeMap    //底层是二叉树数据结构,线程不同步, 用于给map中的键进行排序,
            Comparator        //强行对某个对象 collection 进行整体排序 的比较函数。同TreeSet相同
                compare(T o1, T o2)           //比较用来排序的两个参数。
                 boolean equals(Object obj)           //指示某个其他对象是否“等于”此 Comparator。
            Comparable        //强制让对象具备比较性
                int compareTo(T o)    //比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。
    比较器
        Comparable        //强制让对象具备比较性
            int compareTo(T o)    //比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。
        Comparator        //强行对某个对象 collection 进行整体排序 的比较函数。
            compare(T o1, T o2)           //比较用来排序的两个参数。
             boolean equals(Object obj)           //指示某个其他对象是否“等于”此 Comparator。

posted @ 2014-11-14 03:04  四点水这  阅读(339)  评论(0编辑  收藏  举报