java集合类_数据
集合类型主要有3种：set(集）、list(列表）和map(映射)。

集合接口分为：Collection和Map，list、set实现了Collection接口

List总结：

可以重复，通过索引取出加入数据，顺序与插入顺序一致，可以含有null元素

ArrayList:底层数据结构使数组结构array，查询速度快，增删改慢，因为是一种类似数组的形式进行存储，因此它的随机访问速度极快；

Vector：底层是数组结构array，与ArrayList相同，查询速度快，增删改慢；

LinkedList:底层使用链表结构，增删速度快，查询稍慢；

ArrayList与Vector的区别：

1.如果集合中的元素数量大于当前集合数组的长度时，Vector的增长率是目前数组长度的100%，而ArryaList增长率为目前数组长度的50%。所以，如果集合中使用数据量比较大的数据，用Vector有一定优势

2.线程同步ArrayList是线程不同步，所以Vector线程安全，但是因为每个方法都加上了synchronized，所以在效率上小于ArrayList

Set总结：

数据无序且唯一,实现类都不是线程安全的类，解决方案：Set set = Collections.sysnchronizedSet(Set对象);

HashSet：是Set接口（Set接口是继承了Collection接口的）最常用的实现类，顾名思义，底层是用了哈希表（散列/hash）算法。其底层其实也是一个数组，存在的意义是提供查询速度，插入的速度也是比较快，但是适用于少量数据的插入操作，判断两个对象是否相等的规则：1、equals比较为true；2、hashCode值相同。要求：要求存在在哈希表中的对象元素都得覆盖equals和hashCode方法。

LinkedHashSet：继承了HashSet类，所以它的底层用的也是哈希表的数据结构，但因为保持数据的先后添加顺序，所以又加了链表结构，但因为多加了一种数据结构，所以效率较低，不建议使用，如果要求一个集合急要保证元素不重复，也需要记录元素的先后添加顺序，才选择使用LinkedHashSet

TreeSet：Set接口的实现类，也拥有set接口的一般特性，但是不同的是他也实现了SortSet接口，它底层采用的是红黑树算法（红黑树就是满足一下红黑性质的二叉搜索树：①每个节点是黑色或者红色②根节点是黑色的③每个叶子结点是黑色的④如果一个节点是红色的，那么他的两个子节点是黑色的⑤对每个节点，从该节点到其所有的后代叶子结点的简单路径上，仅包含相同数目的黑色结点，红黑树是许多“平衡”搜索树的一种，可以保证在最坏情况下的基本操作集合的时间复杂度为O(lgn)。普及：二叉搜索树的性质：它或者是一棵空树；或者是具有下列性质的二叉树：若左子树不空，则左子树上所有结点的值均小于它的根结点的值；若右子树不空，则右子树上所有结点的值均大于它的根结点的值；左、右子树也分别为二叉排序树。若子树为空，查找不成功。），要注意的是在TreeSet集合中只能存储相同类型对象的引用。

Tree最重要的就是它的两种排序方式：自然排序和客户端排序

自然排序；实现了Comparable接口，所以TreeSet可以调用对象的ComparableTo()方法来比较集合的大小，然后进行升序排序，这种排序方式叫做自然排序。其中实现了Comparable接口的还有BigDecimal、BigInteger、Byte、Double、Float、Integer、Long、Short（按照数字大小排序）、Character（按照Unicode值的数字大小进行排序）String（按照字符串中字符的Unicode值进行排序）类等。
序列化排序：其实就是实现java.util.Comparator接口提供的具体的排序方式， 是具体要比较对象的类型，他有个compare的方法，如compare(x,y)返回值大于0表示x大于y，以此类推，当我们希望按照自己的想法排序的时候可以重写compare方法。
java集合类_数据_02

Map总结：

java的Map(映射)是一种把键对象和值对象进行映射的集合，其中每一个元素都包含了键对象和值对象，其中值对象也可以是Map类型的数据，因此，Map支持多级映射，Map中的键是唯一的，但值可以不唯一，Map集合有两种实现，一种是利用哈希表来完成的叫做HashMap，它和HashSet都是利用哈希表来完成的，区别其实就是在哈希表的每个桶中，HashSet只有key，而HashMap在每个key上挂了一个value；另一种就是TreeMap，它实现了SortMap接口，也就是使用了红黑树的数据结构，和TreeSet一样也能实现自然排序和客户化排序两种排序方式，而哈希表不提供排序。

HashMap：哈希表的实现原理中，先采用一个数组表示位桶，每个位桶的实现在1.8之前都是使用链表，但当每个位桶的数据较多的时候，链表查询的效率就会不高，因此在1.8之后，当位桶的数据超过阈值（8）的时候，就会采用红黑树来存储该位桶的数据（在阈值之前还是使用链表来进行存储），所以，哈希表的实现包括数组+链表+红黑树，在使用哈希表的集合中我们都认为他们的增删改查操作的时间复杂度都是O(1)的，不过常数项很大，因为哈希函数在进行计算的代价比较高,HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap 的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

TreeMap：TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。TreeMap 实现了Cloneable接口，意味着它能被克隆。TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。

TreeMap基于红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。另外，TreeMap是非同步的。 它的iterator 方法返回的迭代器是fail-fastl的。

HashTable:Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value，线程安全。
java集合类_红黑树_03

List方法

public class ListTestDemo01 {
    @Test
    public void test1(){
        ArrayList a1 = new ArrayList();
        a1.add("123");
        a1.add("456");
        a1.add("aa");
        a1.add(123);
        System.out.println(a1);
        a1.add(1,"bb");
        List integers = Arrays.asList(1, 2, 3);
        a1.add(integers);//size=6
        a1.addAll(integers);//size=9
        System.out.println(a1.size());
        //get:index
        System.out.println(a1.get(1));
        //indexOf:第一次出现的index
        System.out.println(a1.indexOf(123));
        //lastIndexOf:最后出现的index
        System.out.println(a1.lastIndexOf(123));
        //remove
        Object obj = a1.remove(1);
        System.out.println(obj);
        System.out.println(a1);
        //set
        a1.set(1,"cc");
        System.out.println(a1);
        List a2 = a1.subList(1,3);
        System.out.println(a2);
        System.out.println(a1);//不会改变a1
    }

    @Test
    public void test2(){
        ArrayList a1 = new ArrayList();
        a1.add("123");
        a1.add("456");
        a1.add("aa");
        a1.add(123);
        //遍历:
        Iterator iterator = a1.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        for(Object i : a1){
            System.out.println(i);
        }

        for(int i = 0; i < a1.size();i++){
            System.out.println(a1.get(i));
        }
    }
}

Map方法

public class MapTestDemo {
    @Test
    public void test1(){
        Map map = new HashMap();
        map.put(null,123);
        map.put(123,345);
        map.put(234,456);
        System.out.println(map.get(null));
        Set keyset = map.keySet();
        Iterator iterator = keyset.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        Set entry = map.entrySet();
        Iterator iterator1 = entry.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
//        Collection values = map.values();
//        Iterator iterator2 = values.iterator();
//        while (iterator2.hasNext()){
//            System.out.println(iterator.next());
//        }

    }

    @Test
    public void test2(){
        Map m1 = new HashMap();
        m1.put("1","tom");
        m1.put("2","jerry");
        m1.put("3","Alice");
        //putAll
        Map m2 = new HashMap();
        m2.put("4","king");
        m2.put("5","sam");
        m1.putAll(m2);
        System.out.println(m1);
        //remove
        Object values = m1.remove("5");
        System.out.println(values);
        //clear
        m1.clear();
        System.out.println(m1);

    }

    @Test
    public void test3(){
        //get(int index)
        //containsKey boolean
        //containsValue boolean
        Map m1 = new HashMap();
        m1.put("1","tom");
        m1.put("2","jerry");
        m1.put("3","Alice");
        System.out.println(m1.get("1"));
        System.out.println(m1.containsKey("1"));
        System.out.println(m1.containsValue("tom"));
        //size
        System.out.println(m1.size());
        System.out.println(m1.isEmpty());
        //equals
        Map m2 = new HashMap();
        m2.put("1","tom");
        System.out.println(m1.equals(m2));

    }

    @Test
    public void test4(){
        Map m1 = new HashMap();
        m1.put("1","tom");
        m1.put("2","jerry");
        m1.put("3","Alice");
        //遍历key
        Set set = m1.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        Collection values = m1.values();
        for(Object obj : values){
            System.out.println(obj);
        }

        Set set1 = m1.entrySet();
        Iterator iterator1 = set1.iterator();
        while (iterator1.hasNext()){
//            System.out.println(iterator1.next());
            //Object entry -> Map.Entry entry
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey() + "---" + entry.getValue());
        }
    }


}

Collection方法

public class CollectionTestDemo01 {
    @Test
    public void test1(){
        Collection c1 = new ArrayList();
        //add(Object e)
        c1.add("aa");
        c1.add("bb");
        c1.add(123);//自动装箱
        c1.add(new Date());
        System.out.println(c1.size());//4
        //addAll
        Collection c2 = new ArrayList();
        c2.add("cc");
        c2.add("dd");
        c1.addAll(c2);
        System.out.println(c1.size());//6
        System.out.println(c1);
        //isEmpty
        System.out.println(c1.isEmpty());//false
        //clear
        c1.clear();
        System.out.println(c1.isEmpty());
    }

    @Test
    public void test2(){
        Collection c1 = new ArrayList();
        c1.add("aa");
        c1.add("bb");
        //contains
        boolean b1 = c1.contains("aa");
        System.out.println(b1);//true
        //containsAll
        Collection c2 = new ArrayList();
        c2.add("aa");
        boolean b2 = c1.containsAll(c2);
        System.out.println(b2);
        //remove
        c1.remove("bb");
        System.out.println(c1);
        //removeAll:从c1集合中移除所有c2的元素,移除交集:获取差集
        //retainAll:获取c1集合和c2集合的交集
        c1.add("bb");
        c1.add("cc");
        c1.add("dd");
        System.out.println(c1);
        System.out.println(c2);
        c2.add("bb");
//        c1.removeAll(c2);
//        System.out.println(c1);//cc.dd
        c1.retainAll(c2);
        System.out.println(c1);

        boolean b3 = c1.equals(c2);
        System.out.println(b3);//true

    }

    @Test
    public void test3(){
        Collection c1 = new ArrayList();
        c1.add("aa");
        c1.add("bb");
        System.out.println(c1.hashCode());//返回当前对象的hash值

        //集合->数组
        //toArray方法
        Object o1[] = c1.toArray();
        for(Object i1 : o1){
            System.out.println(i1);
        }
        //数组->集合
        //asList方法
        List objects = Arrays.asList(o1);
        System.out.println(objects);
        List strings = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(strings);
        System.out.println(strings.size());

        //1个元素
        List ints = Arrays.asList(new int[]{111, 222});
        System.out.println(ints);
        System.out.println(ints.size());

        //2个元素
        List integers = Arrays.asList(new Integer[]{111, 222});
        System.out.println(integers);
        System.out.println(integers.size());

    }
    @Test
    public void test4(){
        //Iterator:迭代器模式,就是为容器而生,容器就是数组或者集合
        Collection c1 = new ArrayList();
        c1.add("aa");
        c1.add("bb");
        Iterator iterator = c1.iterator();
//        System.out.println(iterator.next());//aa
//        System.out.println(iterator.next());//bb

//        for(int i = 0;i < c1.size();i++){
//            System.out.println(iterator.next());
//        }

        while(iterator.hasNext()){
            //hasNext判断是否有下一个元素
            //next指针下一,返回元素
            System.out.println(iterator.next());
        }



    }
}

TreeMap方法

public class TreeMapTest {
    //要求key是一个类型的
    //按照key进行自然排序和定制排序
    @Test
    public void test1(){
        TreeMap map = new TreeMap();

        User u1 = new User("tom",11);
        User u2 = new User("jerry",11);
        User u3 = new User("sam",11);
        User u4 = new User("king",11);

        map.put(u1,1);
        map.put(u2,2);
        map.put(u3,3);
        map.put(u4,4);

        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey() + "---" + entry.getValue());
        }
    }

    @Test
    public void test2(){
        //定制排序,只可以按照key的属性排序,不可以按照value排序
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User user1 = (User)o1;
                    User user2 = (User)o2;
                    return Integer.compare(user1.getAge(),user2.getAge());

                }

                throw new RuntimeException("异常");
            }
        });

        User u1 = new User("tom",21);
        User u2 = new User("jerry",31);
        User u3 = new User("sam",11);
        User u4 = new User("king",12);

        map.put(u1,1);
        map.put(u2,2);
        map.put(u3,3);
        map.put(u4,4);

        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey() + "---" + entry.getValue());
        }

    }


}

Set方法

  @Test
    public void test1(){
        Set set = new HashSet();
        set.add("123");
        set.add(456);
        set.add("AA");
        set.add("CC");
        set.add(new Date());
        set.add(111);

        //无序
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

Properties方法

public class PropertiesTestDemo {

        //Properties主要处理配置文件,String的key和value
        public static void main(String[] args) throws Exception {
            Properties pros = new Properties();
            FileInputStream fis = new FileInputStream("jdbc.properties");

            pros.load(fis);

            String name = pros.getProperty("name");
            String password = pros.getProperty("password");
            System.out.println(name);
            System.out.println(password);


        }


}

Collections工具类方法

public class CollectionsTestDemo {
    //Collections是操作Set,List,Map的工具类
    //操作Collection和Map的工具栏
    //Collection和Collections的区别:Collection是一个接口,而Collections是一个工具类
    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);

        Collections.reverse(list);
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        Collections.swap(list,1,2);
        System.out.println(list);

        System.out.println(Collections.max(list));
        System.out.println(Collections.min(list));
        //出现的频率
        System.out.println(Collections.frequency(list,1));
    }

    @Test
    public void test2(){
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);

        List dest = Arrays.asList(new Object[3]);
        Collections.copy(dest,list);//需要复制的在前面,被复制的在后面
        System.out.println(dest);
    }
}