JAVA之集合类学习笔记

简介

JAVA的集合类就像一个容器，专门用来存储JAVA类的对象。虽然数组可以保存对象，但是数组的长度不可变，当我们无法确定需要保存多少个对象时，此时不可变长度的数组将不再适用。为了保存这些数目不确定的对象，JDK中提供了一系列特殊的类，这些类可以存储任意类型的对象，并且长度可变，统称之为集合(java.util包中)。
集合按照其存储结构可以分为两大类。单列集合Collection和双列集合Map，这两类集合各有不同的用处，各自的特点如下：
Collection是单列集合的根接口，用于存储一系列符合某种规则的元素，其中包括二个重要的子接口(List和Set)。List和Set有很大的用法区别，其中List中元素有序、元素可重复。Set中元素是无序并且不可重复的。List接口主要实现类包括：ArrayList、LinkedList，Set接口的主要实现类：HashSet、Treeset。
Map是双列集合类的根接口，用于存储具有键(Key)、值(Value)映射关系的元素，每个元素都包含一对键值。Map接口主要实现类有HashMap和TreeMap。

Collection接口

List接口

List集合元素有序，即元素存入顺序和去除顺序一致。
ArrayList是List接口的一个实现类。在ArrayList内部封装了一个长度可变的数组对象，当存入的元素超过数组的长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。

注意：由于ArrayList底层是使用一个数组来保存元素，增删元素时会导致创建新的数组，效率低，因此不适合用来做大量的增删操作。但是这种数组的结构允许程序通过索引的方式来访问元素，因此很适合查找元素操作。

为了克服ArrayList增删操作元素效率低的缺点，可以使用List的另一个实现类LinkedList。该集合内部维护了一个双向循环链表，链表中的每一个元素都使用引用方式来记住它的前一个元素和后一个元素，从而可以将所有元素连接起来。增删节点时，只需要修改元素之间的这种引用关系即可。

Java还提供一个Iterator用于迭代访问(遍历)Collection的元素，因此Iterator对象也被称为迭代器。

Demo：

 public static void BasicArraylist() {
        ArrayList list = new ArrayList();
        list.add("s1");
        list.add("s2");
        list.add("s1");
        String s=(String)list.set(1, "s3");
        System.out.println("被替换元素："+s);
        System.out.println("s2替换成："+list.get(1));
        System.out.println("list大小为："+list.size());
        System.out.println("s1第一次出现的位置:"+list.indexOf("s1"));
        System.out.println("s1在集合最后出现位置:"+list.lastIndexOf("s1"));
        System.out.println("list集合元素："+list.toString());
    }

    public static void BasicLinkedList(){
        LinkedList link = new LinkedList();
        link.add("s1");
        link.add("s2");
        link.addFirst("s0");
        link.addLast("s3");
        link.add(4,"s4");
        System.out.println(link.toString());
    }

    public static void Traverse()
    {
        ArrayList list = new ArrayList();
        list.add("s1");
        list.add("s2");
        list.add("s1");
        //Iterator方式
        Iterator it = list.iterator();
        while (it.hasNext())
        {
            Object obj = it.next();
            System.out.print(obj + ",");
        }
        System.out.println();
        //for each方式
        for (Object obj: list)
            System.out.print(obj + ",");
    }

Set接口

Set接口中元素无序，并且会以某种规则保证存入的元素不出现重复。Set接口有二个重要实现类，HashSet和TreeSet，HaseSet根据对象的哈希值来确定元素的存储位置，具有良好的存取和查找性能，而TreeSet则是以二叉树的方式存储元素，可以实现对元素进行排序。

Demo:

  public static void BasicHashSet(){
        HashSet set = new HashSet();
        set.add("Jack");
        set.add("Rose");
        set.add("Jack");
        Iterator it = set.iterator();
        while (it.hasNext())
        {
            Object obj = it.next();
            System.out.println(obj);
        }
    }

    public static void BasicTreeSet(){
        TreeSet ts = new TreeSet();
        ts.add("Jack");
        ts.add("He");
        ts.add("Eva");
        //会调用Comparable接口中compareTo()方法(自定义，则需要重写)
        Iterator it = ts.iterator();
        while (it.hasNext())
            System.out.println(it.next());
    }

Map接口

HashMap集合

HashMap集合是Map接口的一个实现类，用于存储键值映射关系，必须保证键不重复。遍历集合元素是无序的，若希望得到顺序和存入顺序一致，可以使用HashMap的子类LinkedHashMap。

Demo:

public static void BasicHashMap(){
        HashMap map = new HashMap();
        map.put("1","Jack");
        map.put("2","Rose");
        System.out.println(map.get("2"));
        map.put("2","Lucy");
        System.out.println(map.get("2"));

        //遍历：先遍历Map集合中所有的键
        Set KeySet = map.keySet();// 获取键的集合
        Iterator it = KeySet.iterator();
        while (it.hasNext())
        {
            Object key = it.next();
            Object value = map.get(key);
            System.out.println("key:"+key+" value:"+value);
        }

        //遍历：先获取集合中所有的映射关系
        Set entrySet = map.entrySet();
        Iterator it1 = entrySet.iterator();
        while (it1.hasNext())
        {
            HashMap.Entry entry =(HashMap.Entry) (it1.next());
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }

TreeMap集合

TreeMap也是Map的一个实现类，用于存储键值映射关系，也必须保证键不重复。TreeMap通过二叉树的原理来保证键的唯一性，与TreeSet集合存储的原理一样，因此TreeMap中的键是按照某种顺序排列的。

Demo:

   public static void BasicTreeMap(){
        //不重写compare方法则按照自然顺序排序
        //Key倒排序
        TreeMap tm = new TreeMap(new MyComparator());
        tm.put("1","Jack");
        tm.put("2","Rose");
        tm.put("3","Lucy");
        Set keySet = tm.keySet();
        Iterator it = keySet.iterator();
        while (it.hasNext())
        {
            Object key = it.next();
            Object value = tm.get(key);
            System.out.println(key+":"+value);
        }
    }

    static class MyComparator implements Comparator{
        @Override
        public int compare(Object o1, Object o2) {
            String id1=(String) o1;
            String id2=(String) o2;
            return id2.compareTo(id1);
        }
    }

泛型、工具类

泛型

我们知道集合可以存储任何类型的对象，但是当把一个对象存入集合后，集合会“忘记”这个对象的类型，将对象从集合取出时，这个对象的编译类型就变成了Object类型。也就是说程序不确定取出元素是什么类型时，进行强制类型转换就很容易出错。比如定义了一个ArrayList，在里面添加了字符型和整型元素，那么在取出时强制转换成字符型或者整型都会出错，因为我们并不知道那个元素是整型的。为了解决这个问题，JAVA引入了泛型。它限定方法操作的数据类型。

Collections工具类

针对集合的操作非常频繁，例如排序、查找等，所以JDK提供了一个工具类专门用来操作集合，这个类就是Collections，Collections提供了大量的方法用于对集合中的元素进行排序、查找、修改等。

JAVA还提供了一个专门操作数组的工具类：Arrays工具类。