JAVA集合理解

1.集合

集合只能存放对象包括：

　　　　　　　　　　　　　　　ArrayList　以数组的形式保存集合中的对象根据索引可以随机快速的访问集合中的元素。

　　　　　　　　　　List

　　　　　　　　　　　　　　  LinkedList 以链表的结构保存集合中的元素，随机访问集合中的元素较差，但向集合中插入和删除集合中元素的时候性能出色。

　　Collection：

　　　　　　　　　　　　　　 HashSet  是Set的实现类，不允许有重复的元素。

　　　　　　　　　　Set　　　　

　　　　　　　　　　　　　　TreeSet 不仅实现了Set同时也实现了 SortedSet接口因此遍历TreeSet时会默认的按元素升序排列，创建TreeSet时，使用 

　　　　　　　　　　　　　　Comparator接口还可以实现定制排序，例如降序。

　　　　　　　　　  HashMap        实现了Map接口，虽然能够通过哈希表快速的查找其内部的映射关系，但不保证映射的顺序，并且最多有一个Key为null，可以有无                                                                              数的null value。

　　Map：       

　　　　　　　　　 TreeMap          不仅实现了Map,还实现了SortedMap接口，存储时会按照Key进行排序，所以Key不能为null。 

 

注意：1. Iterator的next（）方法返回值类型是Object，使用Iterator迭代器时需使用Collection接口中的iterator（）方法创建一个Iterator对象。

　　　2.Comparator接口，即“比较器”，它提供一个compare（T o1,T o2）o1>o2,返回证书，通常为1，等于返回0，小于返回-1，如果想定制TreeSet的排序规则可以在实例化TreeSet对象时，将一个已经写好的比较器作为构造参数传入，或让TreeSet中的所有元素都实现Comparable接口。

　　　3.HashSet和TreeSet都是Set的实现类，他们都不允许有重复的值，但是HashSet遍历元素时不关心元素的排序TreeSet类则会按升序进行遍历。

　　　4.Map中如果只是添加删除元素用HashMap如果希望Map集合存在一定的顺序，应该使用TreeMap实现Map集合。

代码如下：

package com.zhao.cllection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class CllectionAndMap {

    public CllectionAndMap() {
        // TODO 自动生成的构造函数存根
    }

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(7);
        list.add(9);
        list.add(6);
        list.add(5);
        list.add(9);
        System.out.println("ArrayList:" + list);
        //List集合有Collection么有，将下标为一的元素改为10
        list.set(1, 10);
        // 创建迭代器
        Iterator<Integer> it = list.iterator();
        // 判断是否有下一个元素
        while (it.hasNext()) {
            // it.next() 获取集合中的元素
            System.out.println("ArrayList:" + it.next());

        }
        Collection<Integer> list1 = new ArrayList<>();
        System.out.println("判断集合是否为空："+list1.isEmpty());
        list1.add(7);
        list1.add(9);
        list1.add(6);
        list1.add(5);
        System.out.println("判断集合是否为空："+list1.isEmpty());
        // 创建迭代器
        Iterator<Integer> it1 = list1.iterator();
        // 判断是否有下一个元素
        while (it1.hasNext()) {
            // it.next() 获取集合中的元素
            System.out.println("List1:" + it1.next());

        }
        List<Integer> linklist=new LinkedList<>();
        linklist.add(3);
        linklist.add(2);
        linklist.add(1);
        //linklist.remove(1);
        System.out.println("LinkedList"+linklist);
        for(Integer o:linklist){
            System.out.println("LinkedList:"+o);
        }
        //Set集合，不按特定的元素排序，只是简单的存放在集合中，元素不能重复
        //Collection<Integer> set=new HashSet<>();
        Set<Integer> set=new HashSet<>();
        set.add(6);
        set.add(7);
        set.add(9);
        //再添加一个9Set集合中也是一个9，Set中不允许存入重复的元素
        set.add(9);
        System.out.println("HashSet"+set);
        // 创建迭代器
                Iterator<Integer> setit = set.iterator();
                // 判断是否有下一个元素
                while (setit.hasNext()) {
                    // it.next() 获取集合中的元素
                    System.out.println("HashSet:" + setit.next());

                }
        //TreeSet 默认将元素按照升序排序
        Set<Integer> treeset=new TreeSet<>();
        treeset.add(2);
        treeset.add(1);
        treeset.add(0);
        System.out.println("TreeSet"+treeset);
        for(int i=0;i<treeset.size();i++){
            System.out.println("TreeSet:"+i);
        }
        Map<String, String> map=new HashMap<>();
        map.put("姓名","赵");
        map.put("性别","男");
        map.put(null,"HashMap允许键有一个键是空值");
        Set<String> mapkey=map.keySet();
        System.out.println("map的所有键值"+mapkey);
        // 必须写成Collection<String> Set<String>不允许有重复的值所以会报  java.lang.ClassCastException
        Collection<String> mapvalues=map.values();
        System.out.println("map的所有值"+mapvalues);
//        遍历它的值，键类似
        Iterator<String> mapvalue=mapvalues.iterator();
        
        while(mapvalue.hasNext()){
            System.out.println("HashMap.values():"+mapvalue.next());
        }
        Map<String, Integer> treeMap=new TreeMap<>();
        treeMap.put("c", 3);
        treeMap.put("a", 1);
        treeMap.put("b", 2);
        treeMap.put("d", 0);
        //treeMap的键不能为null否则会报错   java.lang.NullPointerException
        //treeMap.put(null, 4);
        Set<String> treemapkey=treeMap.keySet();
        System.out.println("treemapkey的所有键值"+treemapkey);
//        遍历它的值，键类似
        Collection<Integer> treeMapValues=treeMap.values();
        System.out.println("treemapvalues的所有值"+treeMapValues);
        Iterator<Integer> treeMapValue=treeMapValues.iterator();
        
        while(treeMapValue.hasNext()){
            System.out.println("TreeMapValue:"+treeMapValue.next());
        }
    }

}

ArrayList:[7, 9, 6, 5, 9]
ArrayList:7
ArrayList:10
ArrayList:6
ArrayList:5
ArrayList:9
判断集合是否为空：true
判断集合是否为空：false
List1:7
List1:9
List1:6
List1:5
LinkedList[3, 2, 1]
LinkedList:3
LinkedList:2
LinkedList:1
HashSet[6, 7, 9]
HashSet:6
HashSet:7
HashSet:9
TreeSet[0, 1, 2]
TreeSet:0
TreeSet:1
TreeSet:2
map的所有键值[null, 姓名, 性别]
map的所有值[HashMap允许键有一个键是空值, 赵, 男]
HashMap.values():HashMap允许键有一个键是空值
HashMap.values():赵
HashMap.values():男
treemapkey的所有键值[a, b, c, d]
treemapvalues的所有值[1, 2, 3, 0]
TreeMapValue:1
TreeMapValue:2
TreeMapValue:3
TreeMapValue:0