java 集合练习

TestCollection.java

package com.jhy.www.test;

import sun.security.util.AuthResources_it;

import javax.sound.midi.Soundbank;
import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        //测试集合
        //常用的实现类如下6种，至于接口Collection下的Queue,再研究
        //Collection(ArrayList  LinkedList  HashSet  LinkedHashSet) Map(HashMap  LinkedHashMap)

        /*
        *   1. List 接口
               List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。
               List 接口存储一组不唯一，有序（插入顺序）的对象。
        * */
         ArrayList<Integer> arrayList = new ArrayList();
         arrayList.add(72);
         arrayList.add(22);
         arrayList.add(32);
         arrayList.add(42);
         arrayList.add(52);
         arrayList.add(52);
         arrayList.add(null);
         arrayList.add(null);
        //System.out.println(arrayList.get(0));  //72
        //System.out.println("arrayList:"+arrayList);   //[72, 22, 32, 42, 52, 52, null, null]

        LinkedList<String> linkList = new LinkedList<String>();
        linkList.add("ab");
        linkList.add("bc");
        linkList.add("cd");
        linkList.add("de");
        linkList.add("ef");
        linkList.add("ef");
        //linkList.remove("ef");
        //linkList.remove(linkList.size()-1);
        //linkList.remove(1);
        //linkList.removeLast();
        //linkList.remove();  //如果只调用 .remove()方法，那么会删除目前list的第一个，再调用，再删除第一个
        //linkList.remove();
        //System.out.println(linkList.get(0));  //ab
        //System.out.println("linkList:"+linkList);   //[ab, bc, cd, de, ef, ef]

        /*
        * 2.Set
            Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。
            Set 接口存储一组唯一，无序的对象。
        * */
        HashSet<Integer> hashSet = new HashSet();
        HashSet<Integer> hashSet3 = new HashSet();
        hashSet3.add(12);
        hashSet3.add(32);
        hashSet3.add(42);
        hashSet.add(12);
        hashSet.add(22);
        hashSet.add(32);
        hashSet.add(null);
        hashSet.add(32);
        hashSet.add(null);
        //hashSet.remove(12);
        //hashSet.removeAll(hashSet3);  //[null, 22]
//        hashSet.removeAll(new HashSet<Integer>(22));
//        HashSet<Integer> hashSet4 = new HashSet<>(22);   //这么写没有什么卵用，想知道为什么再看看源码
//        System.out.println("hashSet4:"+hashSet4);   //hashSet4:[]
        //System.out.println(hashSet);   //[32, null, 22, 12]   结果不变，确实没有添加了重复的元素

        HashSet<String> hashset2 = new HashSet();
        hashset2.add("aa");
        hashset2.add("bb");
        hashset2.add("cc");
        hashset2.remove(1);    //这里API 没有传入下标数字的这个方法，应该是将1识别为Object了，结果是没有效果
        //System.out.println(hashset2);

        /*
        * 备注：
        * Set和List的区别
            1). Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
            2). Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
            3). List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。
        * */



        /*
        * 3.Map
            Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
        * */
        HashMap<String,String> hashMap = new HashMap<>();
        hashMap.put("b","bb");
        hashMap.put("a","aa");
        hashMap.put("c","cc");
        hashMap.put("c","c4");   //后面的覆盖前面的
        hashMap.put(null,null);
        hashMap.put(null,"woshi null");
        //System.out.println(hashMap.get("a"));   //aa
        //System.out.println(hashMap.get("null"));  //null
        //System.out.println(hashMap.get(null));  //woshi null    这里需要理解下 字符串null 和 null对象本身
        //System.out.println(hashMap);   //{null=woshi null, a=aa, b=bb, c=c4}  也证明了Map的key是唯一的

        LinkedHashMap<String,String> lHashmap = new LinkedHashMap<>();
        lHashmap.put("b","b1");
        lHashmap.put("a","a1");
        lHashmap.put("c","c1");
        //System.out.println(lHashmap);   //{b=b1, a=a1, c=c1}  这个要注意下： 继承于HashMap，使用元素的自然顺序对元素进行排序.

        //
        TreeSet treeSet = new TreeSet();  //实现的一个借口里有接口 Comparator 所以可以比较


        /*
        * 4.List 和 Map 的遍历
        * */
        // 4.1 遍历 List
        // 4.1.1 增强for(foreach)
//        System.out.println("增强for:");
//        for(Integer num : arrayList){
//            System.out.println("num:"+num);
//        }
        // 4.1.2 基本for循环
//        System.out.println("基本for循环:");
//        for(int i=0; i<arrayList.size(); i++){
//            System.out.println(arrayList.get(i));
//        }
        // 4.1.3 迭代器循环
//        System.out.println("迭代器循环:");
//        Iterator<Integer> ite = arrayList.iterator();
//        while(ite.hasNext()){
//            System.out.println(ite.next());
//        }
        /*
        *  备注： 三种方法都是用来遍历ArrayList集合，第三种方法是采用迭代器的方法，该方法可以不用担心在遍历的过程中会超出集合的长度。
        * */

        // 4.2 遍历 Map
        // 4.2.1 foreach 遍历 key(普遍使用，二次取值)
//        System.out.println("foreach 遍历 key:");
//        for(String key : hashMap.keySet()){
//            System.out.println("key:"+key+",value:"+hashMap.get(key));
//
//        }
        // 4.2.2 遍历所有的value,但不能遍历 key
//        for(String value : hashMap.values()){
//            System.out.println("value:"+value);
//        }
        // 4.2.3 推荐使用，容量大时效率较快
//        for(Map.Entry<String,String> entry : hashMap.entrySet()){
//            System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
//        }
        // 4.2.4 迭代器遍历(因为 .iterator()这个方法是 AbstractCollection抽象类的，所以Map里是没有这个方法，所以需要将map.entrySet()获取到）
        Iterator<Map.Entry<String,String>> iterator = hashMap.entrySet().iterator();
        System.out.println(hashMap.entrySet());
        while(iterator.hasNext()){
            Map.Entry<String, String> entry = iterator.next();  //写出来便于理解
            //System.out.println("key:"+iterator.next().getKey()+",value:"+iterator.next().getValue());  //这里这么写会有个错误，需要仔细点（iterator.next()调用了2次，导致遍历出来的key是当前的，value是下一次的）
            System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
        }
    }
}

----------------------------------------------------------------------------------------------------------------------

附图一：

附图二：

 

注意：

1. 1）集合框架的类和接口均在java.util包中。

    2）任何对象加入集合类后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换。

2.如何使用比较器（Comparator）

TreeSet和TreeMap的按照排序顺序来存储元素. 然而，这是通过比较器来精确定义按照什么样的排序顺序。

这个接口可以让我们以不同的方式来排序一个集合。