Java 集合框架3

一、集合框架分类

二、关于Map接口的常用类

1.HashMap

HashMap类是Map接口的子类，是处理无序键值对集合的

HashMap特征
1.允许有null键和null值
2.数据保存是无序的
3.重复的键被算作一个数据

i.HashMap构造方法

//HashMap() 构造一个初始存储空间为16，负载因子为0.75的空HashMap集合
HashMap hashMap = new HashMap();
//HashMap(int initialCapacity) 构造一个初始空间为自定义，负载因子为0.75的空的HashMap
HashMap hashMap1 = new HashMap(20);
//HashMap(int initialCapacity,float loadFactor) 构造一个初始空间为自定义，负载因子也为自定义的空的HashMap集合
HashMap hashMap2 = new HashMap(34,0.5f);
//HashMap(Map) 将通过实现Map接口的类型，转换为HashMap类
Hashtable hashtable = new Hashtable();
HashMap hashMap3 = new HashMap(hashtable);

ii.实例方法

/*
            HashMap类的常用方法
            1.Object put(Object) 向HashMap集合中添加元素
            2.boolean containsKey(Object obj) 集合中是否包含指定键
            3.boolean containsValue(Object obj) 集合中是否包含指定值
            4.Object get(key) 得到指定键的值
            5.boolean isEmpty() 集合是否为空
            6.void clear() 清空集合
            7.int size() 得到集合的键值对个数
            8.Value remove(Object key) 根据指定的键删除对应的键值对数据值,返回被删除键的value值
         */
HashMap hashMap = new HashMap();
hashMap.put("id",972);
hashMap.put("name","张全蛋");
hashMap.put("age",25);
hashMap.put(null,34);
hashMap.put("address",null);
hashMap.put(null,null);
System.out.println(hashMap);
System.out.println(hashMap.size());
System.out.println(hashMap.containsKey(null));
System.out.println(hashMap.containsValue(25)); System.out.println(hashMap.get("address"));
System.out.println(hashMap.isEmpty());
System.out.println(hashMap.remove(null));
System.out.println(hashMap.remove("id"));
hashMap.put("id",972);
System.out.println(hashMap);


//遍历集合
        //Set	keySet() 得到集合中所有的键保存到Set集合中
        Set set = hashMap.keySet();
        for (Object objectkey:set){
            System.out.println(objectkey);
        }
        //	Collection	values() 得到集合中所有的值保存到Collection集合中
        Collection collection = hashMap.values();
        for (Object objectvalue:collection){
            System.out.println(objectvalue);
        }
        //	Set<Map.Entry<K,V>>	entrySet() 得到集合中所有的键值对数据Set集合中
        HashMap<Object,Object> hashMap4 = new HashMap<Object, Object>();
        hashMap4.put("class",238);
        hashMap4.put("soc",78);
        hashMap4.put(23,90);
//        Set<Map.Entry<Object,Object>> set1 = hashMap4.entrySet();
        for (Object object:hashMap4.entrySet()){
            System.out.println(object);
        }

2.Hashtable

Hashtable特征

1.不允许nul键/null值

2.数据保存是无序的

3.重复的数据被算组一个

4.线程安全

5.用作键的对象必须实现hashCode方法和equals方法

i.构造方法

 //Hashtable类 是Map接口的子类，是无序集合，处理键值对的集合
        /*
            Hashtable类的构造特征
            1.不允许null键和null值
            2.数据保存是无序的
            3.用作键的对象必须实现hashCode方法和equals方法
            4.重复的键被视为一个数据
            5.线程安全
         */
        //Hashtable类的构造方法
        //1.Hashtable() 构造一个初始容量为11，负载因子为0.75的空集合
        Hashtable hashtable = new Hashtable();
        //2.Hashtable(int initialCapacity) 构造一个自定义初始容量，负载因子为0.75的空集合
        Hashtable hashtable1 = new Hashtable(35);
        //3.Hashtable(int initialCapacity,float loadFactor) 构造一个自定义初始容量，负载因子也为自定义的空集合
        Hashtable hashtable2 = new Hashtable(40,0.5f);
        //4.Hashtable(Map) 将通过Map实现的类，转换为Hashtable
        HashMap hashMap = new HashMap();
        Hashtable hashtable3 = new Hashtable(hashMap);

ii.实例方法

 /*
            Hashtable类的实例方法
            1.Object put(key,value) 向Hashtable集合中添加键值对
            2.int size() 得到集合中的键值对个数
            3.boolean containsKey() 是否包含键
            4.boolean containsValue() 是否包含值
            5.Value get(key) 根据键得到值
            6.boolean isEmpty() 是否为空
            7.void clear() 清空
            8.Value remove(key) 删除指定键的键值对,返回被删除键的值
         */
        hashtable.put("id",837);
        hashtable.put("name","文秀");
        hashtable.put("age",33);
//        hashtable.put(null,83);
//        hashtable.put(67,null);
//        hashtable.put(null,null);
        System.out.println(hashtable);
        System.out.println(hashtable.size());
        System.out.println(hashtable.containsKey("name"));
        System.out.println(hashtable.containsValue(34));
        System.out.println(hashtable.get("id"));
        System.out.println(hashtable.isEmpty());
        hashtable.put("asdf",232);
        System.out.println(hashtable.remove("asdf"));
        System.out.println(hashtable);

        //遍历
        //Set keySet() 根据键遍历
        Set set = hashtable.keySet();
        for (Object objectkey:set){
            System.out.println(objectkey);
        }
        //Collection values() 根据值遍历
        Collection collection = hashtable.values();
        for (Object objectvalue:collection){
            System.out.println(objectvalue);
        }
        //Set<Map.Entry<k,v>> entrySet() 根据键值遍历
        Hashtable<Object,Object> hashtable4 = new Hashtable<Object, Object>();
        hashtable4.put("learn","java");
        hashtable4.put("time",1999);
        hashtable4.put("soc",89);
        hashtable4.put("sex","男");
        Set<Map.Entry<Object,Object>> set1 = hashtable4.entrySet();
        for (Object object:set1){
            System.out.println(object);
        }

3.TreeMap

TreeMap特征

1.按照键的字母/数字顺序排列---有序

2.键不能为null，值可以为null

3.重复的键被算作一个数据

5.非线程安全

i.构造方法

//TreeMap是有序集合，是Map的子类
        /*
            TreeMap类的特征
            1.按照字母或数字顺序排列
            2.不能有null键，可以有null值
            3.重复的键被算作一个数据
            4.非线程安全
         */
        //TreeMap构造方法
        //1.TreeMap() 构造一个空的集合
        TreeMap treeMap = new TreeMap();
        //2.TreeMap(Map) 将其他实现Map的类，转换为TreeMap类
        HashMap hashMap = new HashMap();
        TreeMap treeMap1 = new TreeMap(hashMap);

ii.实例方法

/*
        TreeMap类的实例方法
        1.Object put(key,value) 添加键值对
        2.int size() 返回键值对的个数
        3.boolean containsKey() 是否包含键
        4.boolean containsValue() 是否包含值
        5.Value get(key) 根据指定键，获取其值
        6.Value remove(key) 根据指定键，删除键值对，返回值
        7.void clear()清空集合
        8.boolean isEmpty() 集合是否为空
         */
        treeMap.put("id",238);
        treeMap.put("name","张全蛋");
        treeMap.put("class","java");
        treeMap.put("address","雁塔区");
//        treeMap.put(1,1);
        System.out.println(treeMap);
        System.out.println(treeMap.size());
        System.out.println(treeMap.containsKey("class"));
        System.out.println(treeMap.containsValue(238));
        System.out.println(treeMap.get("address"));
        System.out.println(treeMap.isEmpty());
        treeMap.put("jhjhd",23);
        System.out.println(treeMap.remove("jhjhd"));
        System.out.println(treeMap);


        //遍历TreeMap集合
        //1.Set keySet() 根据键值遍历
        Set set = treeMap.keySet();
        for (Object objectkey:set){
            System.out.println(objectkey);
        }
        //2.Collection values() 根据值遍历
        Collection collection =treeMap.values();
        for (Object objectvalue:collection){
            System.out.println(objectvalue);
        }
        //Set<Map.Entry<k,v>> entrySet() 根据键值遍历
        TreeMap<String,Integer> treeMap2 = new TreeMap<String, Integer>();
        treeMap2.put("ces",2323);
        treeMap2.put("123",123);
        treeMap2.put("user",23233);
        Set<Map.Entry<String,Integer>> set1 = treeMap2.entrySet();
        for (Map.Entry<String,Integer> entry:set1){
            String key = entry.getKey();
            Integer values = entry.getValue();
            int value = values;
            System.out.println(value+1);
        }

4.ConcurrentHashMap

ConcurrentHashMap特征

1.数据保存是无序的

2.不允许null键和null值

3.重复的键被算作一个数据

4.线程安全

5.支持高并发处理

i.构造方法

//ConcurrentHashMap类是无序集合，是Map的子类
        //ConcurrentHashMap类的特征
        //1.不允许null的值和null键
        //2.数据保存是无序的
        //3.重复的键被算作是一个数据。
        //4.线程安全
        //5.支持高并发处理
        //构造方法
        //ConcurrentHashMap() 创建一个新的，空的地图与默认的初始表大小（16）。
        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
        //ConcurrentHashMap(int initialCapacity)创建一个新的空的地图，其初始表格大小适应指定数量的元素，而不需要动态调整大小
        ConcurrentHashMap conmap2=new ConcurrentHashMap(26);
        //ConcurrentHashMap(int initialCapacity, float loadFactor) 根据给定的元素数量（ initialCapacity ）和初始表密度（ loadFactor ）
        ConcurrentHashMap conmap3=new ConcurrentHashMap(20,0.5f);
        //ConcurrentHashMap(Map<? extends K,? extends V> m) 创建与给定地图相同的映射的新地图。
        Hashtable hashtable = new Hashtable();
        ConcurrentHashMap concurrentHashMap1 = new ConcurrentHashMap(hashtable);

ii.实例方法

 /*
        实例方法
        1.Object 	put(Object key, Object value) 向集合中添加键值对数据
        2.int size() 返回键值对的个数
        3.boolean containsKey(key)是否包含键
        4.boolean contaninsValue(value)是否包含值
        5.void clear()清空集合
        6.value get(key) 根据键，得到值
        7.value remove(key) 根据键删除键值对，返回被删除键的值
        8.boolean isEmpty() 集合是否为空
         */
        concurrentHashMap.put("id",1234);
        concurrentHashMap.put("name","张三");
        concurrentHashMap.put("age",32);
        concurrentHashMap.put("school","北京大学");
        System.out.println(concurrentHashMap.size());
        System.out.println(concurrentHashMap.isEmpty());
        System.out.println(concurrentHashMap.containsKey("age"));
        System.out.println(concurrentHashMap.containsValue(32));
        System.out.println(concurrentHashMap.get("school"));
        concurrentHashMap.put("asdf",23);
        System.out.println(concurrentHashMap.remove("asdf"));

        //遍历
        //Set keySet()按照键遍历
        Set set = concurrentHashMap.keySet();
        for (Object objectkey:set){
            System.out.println(objectkey);
        }
        //Collection values() 按照值遍历
        Collection collection = concurrentHashMap.values();
        for (Object objectvalue:collection){
            System.out.println(objectvalue);
        }

        //Set<Map.Entry<k,v>> entrySet() 根据键和值遍历
        ConcurrentHashMap<String,Integer> concurrentHashMap2 = new ConcurrentHashMap<String, Integer>();
        concurrentHashMap2.put("id",238);
        concurrentHashMap2.put("name",232);
        concurrentHashMap2.put("address",248);
        concurrentHashMap2.put("cool",38);
        for (Map.Entry<String,Integer> entry:concurrentHashMap2.entrySet()){
            String str_key = entry.getKey();
            Integer int_value = entry.getValue();
//            int value = int_value;
//            System.out.println(value+1);
            System.out.println(str_key+"="+int_value);

        }

5.Collections类

1.Collections类是操作集合中元素的帮助类

2.Collections类中的方法都是静态的【对集合元素的检索，排序，线程安全操作】

i.常用方法

//Collections.copy(复制到的列表,被复制的列表)将所有元素从一个列表复制到另一个列表中
        ArrayList arrayList = new ArrayList();
        arrayList.add("id");
        arrayList.add("name");
        arrayList.add("age");
        ArrayList arrayList1 = new ArrayList();
        arrayList1.add(123);
        arrayList1.add(234);
        arrayList1.add(734);
        arrayList1.add(5239);
        Collections.copy(arrayList1,arrayList);
        for (Object ob:arrayList1){
            System.out.println(ob);
        }
        for (Object ob:arrayList){
            System.out.println(ob);
        }
        //static <T> void fill(List<? super T> list, T obj)用指定的元素代替指定列表的所有元素
        Collections.fill(arrayList1,"java");
        System.out.println(arrayList1);
        //static T max(Collection<? extends T> coll)根据其元素的自然顺序返回给定集合的最大元素
        ArrayList arrayList3 = new ArrayList();
        arrayList3.add(123);
        arrayList3.add(24);
        arrayList3.add(7342323);
        System.out.println(Collections.max(arrayList3));
        //static T min(Collection<? extends T> coll)根据其元素的自然顺序返回给定集合的最小元素
        System.out.println(Collections.min(arrayList3));
        //static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)将列表中一个指定值的所有出现替换为另一个
        //将arrayList3中的24替换成189
        Collections.replaceAll(arrayList3,24,189);
        System.out.println(arrayList3);
        //static void reverse(List<?> list)反转指定列表中元素的顺序
//        Collections.reverse(arrayList3);
//        System.out.println(arrayList3);
        //static void sort(List<T> list)根据其元素的natural ordering对指定的列表进行排序
        Collections.sort(arrayList3);//从小到大
        System.out.println(arrayList3);
        Collections.sort(arrayList3);//排序
        Collections.reverse(arrayList3);//反转
        System.out.println(arrayList3);//从大到小