Java 中集合框架知识点的总结

在Java的学习中最早接触的保存批量数据的是数组，但是数组有一个缺陷是保存的数据的个数必须在创建数组的时候就确定下来。Java为我们提供给了更好的保存数据的方式就是使用集合框架，在这里介绍List,Set 和Map三种，我说点这三者之间的关系，这三者都是Collection接口的子接口，三种的区别主要是在内存中保存数据的数据结构不同，在下面的例子中会分别详细的进行叙述。

首先我们看看List,List保存数据使用的是数组进行保存的，因此保存的数据之间可以重复，分别有三个子类在我们的开发中使用的比较多 ArrayList,LinkedList,Vector,其中ArrayList 和Vector使用的都是数组结构进行数据保存的，区别在意ArrayList 是不线程安全的，而Vector 是线程安全的。LinkedList是使用链表进行数据的保存的。Vector 现在使用的比较少，因为为了线程的安全，我们完全可以自己加锁，或者使用Collections 提供的方法为我们的ArrayList 和LinkedList 进行加锁。API 中提供了使用这些的具体方法，都算比较简单，我们需要特别注意的是数据取出的API,我们可以使用 get(int index),也可以使用迭代器取出数据。下面我们看个很简单的例子代码：

// 我们创建一个 ArrayList 对象，并给其中添加数据
        ArrayList arrayList = new ArrayList<>();
        arrayList.add("test1");
        arrayList.add("test2");
        arrayList.add("test3");
        arrayList.add("test4");

        // 取出数据的方式有二种
        // 第一种，由于在底层使用数组进行数据的保存，所以我们可以 使用  get(int index) 进行获取
        String test01_string = (String)arrayList.get(0);
        System.out.println(test01_string);
        String test02_string = (String)arrayList.get(1);
        System.out.println(test02_string);
        //第二种，我们可以使用Iterator
        Iterator iterator = arrayList.iterator();
        while(iterator.hasNext()){  
            System.out.println(iterator.next());
        }

        // 需要特别注意的使用如果我们在使用迭代器的时候，使用数组的方法修改数据，
        //会出现并发修改的异常，比如下面的代码
        Iterator iterator_02 = arrayList.iterator();
        while(iterator_02.hasNext()){
            if(iterator_02.next().equals("test1")){
                arrayList.add("test5");
            }
        }// 运行的时候报错 java.util.ConcurrentModificationException

        // 为什么会出现这样的问题那，这是因为 我们在使用迭代器的时候，使用了数组的方法去修改arrayList
        // 中的元素，我们在操作arrayList 中的数据的时候，要么使用数组的方法，要么使用迭代器的方法
        // 对于List Java 为我们提供了一种特殊的迭代器，listIterator,里面都有更多的方法提供给我们
        // 比如 add(E e),set(E e) 等等方法，具体使用的时候，你可以自己查看API选择合适的方法，下面
        // 举个例子，还是上面的代码，我们做点修改

        ListIterator iterator_03 = arrayList.listIterator();
        while(iterator_03.hasNext()){
            if(iterator_03.next().equals("test1")){
                iterator_03.add("test5");
            }
        }

关于这LinkedList 就不举例子了，这个和ArrayList类似，使用的使用我们只需要根据不同的使用情景选择合适的就行了。

接下来我们是第二个Set ,Set和List的区别在于Set 保存的数据不能重复，也就是Set在保存数据进去的时候要进行数据重复性的检查，如果数据已经保存过我们就不用保存了。那么在进行数据的保存之前，我们需要确认我们要保存的对象之间是具有比较性的。Set有二个比较重要的子类，HashSet 和TreeSet,HashSet 使用的是Hash表，而TreeSet 使用的是二叉树进行数据的保存的。在使用HashSet 进行数据的保存的时候，会先后调用对象的hashCode 和 equals 函数和集合中已经有的数据进行比较，如果hashCode得到的不同则这直接保存进去，如果 hashcode相同，则会继续调用equals ，如果equals得到的是true,那么说明这个数据在集合中已经有存在，我们不需要进行保存，如果equals 不同，那么会在原来保存的数据上进行顺延保存。对于TreeSet ，使用的是二叉树进行数据的保存，因此在存入之前我们会对对象进行比较，通过二种方法来实现，第一种是我们的对象在定义的时候就实现 Comparable 接口，第二种是我们可以给传入比较器对象。下面我们分别看关于HashSet和 TreeSet 的例子。

public class Student {

    private String name;  // 姓名
    private int ID;       // 学号

    public Student(String name,int ID){
        this.name = name;
        this.ID = ID;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getID() {
        return ID;
    }
    public void setID(int iD) {
        ID = iD;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()+ID*5;
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub

        if(obj instanceof Student){
            Student student_obj =(Student)obj;

            return this.name.equals(student_obj.name)&& this.ID==student_obj.ID;
        }
        else{
            return false;
        }
    }
}

HashSet hashSet  =  new HashSet();
        hashSet.add("uiui");
        hashSet.add("yuiuyq");
        hashSet.add("trqnjci");
        /**
         *下面代码的输出结果是这样的：
         *trqnjci
         *yuiuyq
         *uiui
         *我们可以看到我们输出的结果和我们保存进去的顺序并不相同，为什么会出现这样的问题，这是因为
         *hashSet 在保存进去的时候会按照 对象的hashCode 进行保存的，如果我们需要按照我们的自己
         *的需求进行排序的，我们需要对 对象的hashCode和 equals 方法进行覆盖
         */
        Iterator iterator = hashSet.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());    
        }
        /**
         * 下面的例子是对 人按照姓名和年龄进行排序，只有姓名和年龄相同的才是同一个人
         * 首先我们可以定义一个类，Student,然后我们创建这个类的对象，保存到HashSet中
         * 程序输出的结果是下面的样子：
         * Cat......3
         * Lisn......5
         * Tom......1
         * John......2
         * Helen......4
         * 
         * 在这里我们第二次保存John 2 的时候，因为 我们覆盖了 hashCode 和 equlas 方法，HashSet
         * 会认为数据是重复的，并不会把数据保存进去。
         */
        HashSet  student_set = new HashSet();
        student_set.add(new Student("Tom",1));
        student_set.add(new Student("John",2));
        student_set.add(new Student("John",2));
        student_set.add(new Student("Cat",3));
        student_set.add(new Student("Helen",4));
        student_set.add(new Student("Lisn",5));
        Iterator iterator2 = student_set.iterator();
        while(iterator2.hasNext()){
            Student stu =(Student)iterator2.next();
            System.out.println(stu.getName()+"......"+stu.getID());     
        }

我们看看TreeSet的例子：

TreeSet treeSet = new TreeSet();
        treeSet.add(new Student("Tom", 1));
        treeSet.add(new Student("Jhon", 3));
        treeSet.add(new Student("Alen", 4));

还是上面的Student 类，当我们运行程序的时候会报错：
java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable，这个错误很明显，我们一看就知道这是因为我们的Student类 不具有比较性导致的，要解决这个问题，我们有二种方法，下面首先看第一种：

public class Student implements Comparable{

    private String name;  // 姓名
    private int ID;       // 学号

    public Student(String name,int ID){
        this.name = name;
        this.ID = ID;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getID() {
        return ID;
    }
    public void setID(int iD) {
        ID = iD;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()+ID*5;
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub

        if(obj instanceof Student){
            Student student_obj =(Student)obj;

            return this.name.equals(student_obj.name)&& this.ID==student_obj.ID;
        }
        else{
            return false;
        }
    }
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        // 在这里我们需要 调用 compareTo 方法实现对象的比较
        if(o instanceof Student){

            Student s = (Student)o;
            if(this.ID>s.ID)
                return 1;
            if(this.ID==s.ID)
            {
                return this.name.compareTo(s.name);
            }
            return -1;

        }else{
                throw  new RuntimeException("传入的类型不是 Student,不能进行比较");
        }


    }
}

接下来我们进行数据的添加：

第二种方法是我们可以创建一个比较器对象，并不需要给Student 类实现Comparable 接口：

public class MyComparator implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        // TODO Auto-generated method stub
        Student stu_01 = (Student)o1;
        Student stu_02 = (Student)o2;
        if(stu_01.getID()==stu_02.getID()){

            return stu_01.getName().compareTo(stu_02.getName());
        }else{

            return stu_01.getID()-stu_02.getID();
        }

    }

}

保存数据的代码：

/** 创建TreeSet 的时候，传入了比较器对象，按照学号进行排序
         * 同样的new Student("Jhon", 3) 第二次会认为是同一个对象并不能保存进去
         * 程序输出的结果是这样的：
         * Tom...1
         * Jhon...3
         * Alen...4
         * 按照学号进行了排序
         */
        TreeSet treeSet = new TreeSet(new MyComparator());
        treeSet.add(new Student("Tom", 1));
        treeSet.add(new Student("Jhon", 3));
        treeSet.add(new Student("Jhon", 3));
        treeSet.add(new Student("Alen", 4));
        Iterator iterator_01 = treeSet.iterator();

        while(iterator_01.hasNext()){
            Student stu =(Student)iterator_01.next();
            System.out.println(stu.getName()+"..."+stu.getID());

        }

接下来我们看Map,Map 中存入的是数据对，也就是Key 和Value的形式，存入的是键值对。Map 有三个子类，HashTable ,HashMap和TreeMap,其中HashTable 和HashMap 都使用的是哈希表作为数据结构的，二者的区别在于HashTable 是不允许null键和null值存在的，并且是线程同步的，但是HashMap 是允许null键和null 值的，并且是线程不同步的，使用哈希表保存，那么会按照 key进行排序。TreeMap 使用的是二叉树进行数据保存的，会对key进行比较，和使用TreeSet 一样，我们需要对key对象实现比较性。在这里我们写一个简单的例子是使用HashMap 的，是关于数据取出。

HashMap<String,String> hashMap = new HashMap<String,String>();
        hashMap.put("Tom", "15");
        hashMap.put("Cat","25");
        hashMap.put("Jhon", "26");
        // 第一种
        Set<String> key_set_string = hashMap.keySet();

        Iterator<String> iterator = key_set_string.iterator();
        while(iterator.hasNext()){
            String key_string = iterator.next();
            System.out.println(key_string+"..."+hashMap.get(key_string));
        }
        // 第二种
        Set<Map.Entry<String, String>> sEntries = hashMap.entrySet();
        Iterator<Map.Entry<String, String>> set_iterator = sEntries.iterator();

        while(set_iterator.hasNext()){
            Map.Entry<String, String> mEntry = set_iterator.next();
            System.out.println(mEntry.getKey());
            System.out.println(mEntry.getValue());      
        }

就写这些吧，写这篇的主要是为了说清楚这几种集合框架的选择问题，对API的使用，大家可以自己查看Java API 。博客中出现的任何问题，大家可以给我留言，我会进行查看和修改。