个人java学习路线-集合

介绍

java类集框架可以方便地使用各种常用的数据结构。在存储数据时只需使用适合的集合就行。
集合用起来很方便，用法也不算难，但要了解集合的内部实现原理还是要花费一些时间的。
我们目前只需了解常用类即可，先来张图(还是百度的图片，这个都一样，百度一堆)

Collection集合

Collection介绍

Collection类都实现了Iterable,和Iterator接口
Iterable 是可迭代的，可遍历的。所有集合元素都是可迭代的，可遍历的。
Iterator就是集合的迭代器对象。

1.List介绍

List集合储存元素特点：
有序可重复，储存的元素有下标。和数组类似，都是从下标0开始。
List下有子类ArrayList,LinkList,Vector等子类
1》》
ArrayList:
集合底层直接采用数组这种数据结构，是非线程安全的。
关于存储数据使用，结合代码看

public class ArrayListTest {
    public static void main(String[] args) {
        List list1=new ArrayList();//多态
        List list2=new ArrayList(20);//指定20容量
        System.out.println(list1.size());//输出集合大小-->0
        System.out.println(list2.size());//输出集合大小-->0
        list1.add(1);	//添加数据1进入数组
        list2.add(2);
        list1.add("123");//添加字符串"123"进入数组
        System.out.println(list1.size());
        System.out.println(list2.size());
    }
}

其他方法后面再说
2》》
LinkedList:
集合底层采用了双向链表数据结构，关于链表的实现，其实可以自己写写的，单向链表还好不算难写，单向写出来了，双向多花点时间也就写出来了。
LinkedList代码:

public class LinkedListTest {
    public static void main(String[] args) {
        List list=new LinkedList();
        list.add("a");
        list.add("b");
        list.add("c");
        for (int i = 0; i <list.size() ; i++) {//简单的循环遍历集合
            Object obj=list.get(i);//获得集合下标为i的值
            System.out.println(obj);
        }
    }
}

3》》
Vector：
集合底层也是数组，但是这个集合是线程安全的，所以执行效率较低——少用。
而且也可以用Collections中的方法手动设置线程安全：

 List list=new ArrayList();
 Collections.synchronizedList(list);

2.Set介绍

Set集合存储元素特点：
无序不可重复——表示存进去和取出的顺序不一定一样，集合也没有下标，也不能存入重复元素。Set接口有HashSet和SortedSet等子类。还是挑一些讲。
1》》
HashSet：
实际上HashSet集合在new时，底层new了一个HashMap集合。HashMap集合是一个哈希表数据结构，具体到Map集合在说。
下面是使用代码，遍历数据用Iterator迭代器：

public class CollectionTest3 {
    public static void main(String[] args) {
//        Collection c1=new ArrayList();
        Collection c1=new HashSet();
        c1.add(1);
        c1.add(2);
        c1.add(3);
        c1.add(4);
        c1.add(5);
        c1.add(6);
        c1.add(7);
        String s1=new String("abc");
        String s2=new String("abc");
        c1.add(s1);
        System.out.println(c1.contains(s2));
        Iterator integer=c1.iterator();//集合.iterator()方法即可返回迭代器对象。
        while (integer.hasNext()){//遍历集合
            System.out.print(integer.next()+" ");
        }
    }
}

输出结果：

可见输出和存入顺序并不一样，且不可重复。
2》》
SortedSet也是接口，它存储元素的特点是：
由于继承Set接口，所以也是无序不可重复，但是存入的元素在存入时会自动排序。我们直接看它的实现类TreeSet。
TreeSet:
集合底是TreeMap，new TreeSet集合时，实际底层new TreeMap集合。TreeMap底层时二叉树。也是Map集合时再说。代码也后面再说，都一个样。

Map集合

Map集合和Collection集合没有关系；Map集合以key和value的键值对的方式存储元素；key和value存储java对象的内存地址；Map的key和Set集合存储元素特点相同，即无序不可重复。
Map接口我们目前只需了解HashMap,Hashable,SortedMap类即可

1.HashMap

集合底层是哈希表，是非线程安全的。
（随便百度了张图，简单看一下）

可见哈希表可以看成数组结合链表来存储元素。
运用代码：
主要：这里用了泛型<>，简单了解就行，不难理解。

public class Test4 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();//<Integer,String>泛型，指定第一位是int的包装类Integer，第二位为字符串类型，如果存入类型不匹配，编译无法通过。
        map.put(1,"wanyi");//按key和value存入数据
        map.put(2,"wanger");
        map.put(3,"wusan");
        map.put(4,"lisi");
        map.put(4,"lisi2");//不可重复，覆盖上面的数据
        System.out.println(map.get(4));//按key的值取得value的值
        System.out.println("----------->");
        Set<Integer> set=map.keySet();//第一种遍历方法，正如上面说的key可以看成Set集合，那么用HashMap的xx.keySet()方法把map的key存入Set数组中
        
        for (Integer i:set) {//遍历Set数组，取出key，并通过key取得HashMap中的value，完成遍历
            System.out.println(i+" "+map.get(i));
        }
        System.out.println("----------->");
        Set<Map.Entry<Integer,String>> set1=map.entrySet();//第二种遍历方法，通过xx.entrySet()方法返回一个存储数据的对象(就是一个类，有专门的方法获得key和value)Map.Entry<Integer,String>，把Map.Entry<Integer,String>再存入 Set集合中并指定泛型。
        for (Map.Entry<Integer,String> m:set1) {//遍历set集合，并通过Map.Entry<Integer,String>中方法输出key和value
            System.out.println(m.getKey()+" "+m.getValue());
        }
    }
}

代码运行结果：

2.Hashtable：

底层也是哈希表，集合是线程安全的，效率较低，不用。
Hashtable子类Prorperties在写配置时会用，其实再IO流时就用过了，现在不多介绍。
给个代码感觉一下：

public class PropertiesTest {
    public static void main(String[] args) {
        Properties pro=new Properties();
        pro.setProperty("123","zxc");
        pro.setProperty("456","wort");
        pro.setProperty("789","wet");
        System.out.println(pro.getProperty("123"));//输出自然是zxc
        System.out.println(pro.getProperty("456"));
        System.out.println(pro.getProperty("789"));
    }
}

3.SortedMap：

接口，存储无序不可重复，集合的key会自动排序。我们主要说一些其子类TreeMap。
TreeMap底层是二叉树。
关于二叉树数据结构，并不难理解，随便百度张图来看看

感兴趣自己了解试试，存入检索都可以简单看成根左右的顺序。
关于TreeMap的运用，还是和上面差不多，我们这里提及一下比较器和内部类，是用来制定比较标准的。
TreeMap源码中有：
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
可见本身排序就是自带比较器的，我们复写这个方法即可按照我们自己的想法排序存入数据。
代码：

public class Test3 {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet=new TreeSet<>(new Comparator<Integer>() {//在创建TreeSet时，传入Comparator内部类，内部类不需要类名，无论接口还是抽象，直接new 内部类() {方法;}就行，复写compare方法就是比较的逻辑,比如我们要从小到大存入数据
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        treeSet.add(100);
        treeSet.add(200);
        treeSet.add(10);
        treeSet.add(5);
        for (Integer i:treeSet){
            System.out.println(i);
        }
    }
}

输出结果：