Java集合（三）

红太狼 2021-11-02 00:44 203阅读 0赞

# Java集合（三） #

[Java集合（一）][Java]  
[Java集合（二）][Java 1]

### 文章目录 ###

*  Java集合（三）
 *   *   *  一、Map接口
         *  二、自动打包和解包
         *  三、泛型
         *  四、总结

### 一、Map接口 ###

1.  实现Map接口的类用来存储“键–值”对。
2.  Map接口的实现类有HaspMap和TreeMap等
3.  Map类中存储的“键–值”对通过键来表示，所有键值不能重复，也就是说键值之间不能equals，实际当中他们比较的是hashcode是否相同，因为这样效率会比较高。
4.  Map接口常见的方法：

Object put(Object key,Object value);//添加一个键值对
    Object get(Object key);//通过key找到相对应的value对象
    Object remove(Object key);//通过key把对应的value去掉，key也会自动会被去掉
    boolean containKey(Object key);//是否包含某个键
    boolean containsValue(Object value);//是否包含某个值
    int size();//一共装了多少对对象
    boolean isEmpty();//是否为空
    void putAll(Map t);//把另外一个Map集合里面的所有元素添加进去
    void clear();//清空集合

示例如下：

public class MapTest {
        public static void main(String[] args) {
            Map m1 = new HashMap();
            Map m2 = new TreeMap();
            m1.put("one",new Integer(1));
            m1.put("two",new Integer(2));
            m1.put("three",new Integer(3));
            m2.put("A",new Integer(1));
            m2.put("B",new Integer(2));
            System.out.println(m1.size());
            System.out.println(m1.containsKey("one"));
            System.out.println(m2.containsValue(new Integer(1)));//其实内部仍然会执行equals和hashcode方法，但是Integer类已经重写了，所以可找到
            if (m1.containsKey("two")){
                int i = ((Integer) m1.get("two")).intValue();
                System.out.println(i);
            }
            Map m3 = new HashMap(m1);
            m3.putAll(m2);
            System.out.println(m3);
        }
    }

打印结果如下：  
![结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70]

### 二、自动打包和解包 ###

Auto-boxing、Auto-unboxing  
在合适的时机自动打包、解包

自动将基础类型转换成对象（打包）

自动将对象转换为基础类型（解包）  
根据这个特性上面的程序可以修改为：

public class MapTest {
        public static void main(String[] args) {
            Map m1 = new HashMap();
            Map m2 = new TreeMap();
    //        m1.put("one",new Integer(1));
            m1.put("one",1);
    //        m1.put("two",new Integer(2));
            m1.put("two",2);
    //        m1.put("three",new Integer(3));
            m1.put("three",3);
    //        m2.put("A",new Integer(1));
            m2.put("A",1);
    //        m2.put("B",new Integer(2));
            m2.put("B",2);
            System.out.println(m1.size());
            System.out.println(m1.containsKey("one"));
    //        System.out.println(m2.containsValue(new Integer(1)));
            System.out.println(m2.containsValue(1));//其实内部仍然会执行equals和hashcode方法，但是Integer类已经重写了，所以可找到
            if (m1.containsKey("two")){
    //            int i = ((Integer) m1.get("two")).intValue();
                int i = (int) m1.get("two");
                System.out.println(i);
            }
            Map m3 = new HashMap(m1);
            m3.putAll(m2);
            System.out.println(m3);
        }
    }

### 三、泛型 ###

起因–JDK1.4以前类型不明确：

1.  装入集合的类型都被装作Object对待，从而失去自己的实际类型。
2.  从集合中取出时往往需要转型，效率低，并且容易产生错误。

解决办法：

1.  在定义的时候同时定义集合中对象的类型。

*  可以在定义Collection的时候指定
 *  可以在循环时用Iterator指定

1.  好处：增强程序的可读性和稳定性
2.  示例如下：

import java.util.*;
    
    public class BasicGeneric {
    
        public static void main(String[] args) {
            //指定list集合内部只能是String对象
            List<String> list = new ArrayList<>();
            list.add("aaa");
            list.add("bbb");
            list.add("ccc");
            for(int i = 0;i < list.size();i++){
                String s = list.get(i);
                System.out.println(s);
            }
    
            Collection<String> collection = new HashSet<>();
            collection.add("aaa");
            collection.add("bbb");
            collection.add("ccc");
            for(Iterator<String> iterator = collection.iterator();iterator.hasNext();){
                //在循环时用iterator指定泛型
                String s = iterator.next();
                System.out.println(s);
            }
        }
    }

输出结果：  
![输出结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 1]  
Comparable接口也可以指定泛型，同类之间比较才有意义：

class MyName implements Comparable<MyName>{
    	int age;
    	public int compareTo(MyName mm){
    		if(this.age > mm.age){
    			return 1;
    		}else if(this.age < mm.age){
    			return -1;
    		}else{
    			return 0;
    		}
    	}
    }

泛型示例2：

public class MapTest {
        public static void main(String[] args) {
            Map<String,Integer> map = new HashMap<>();
            map.put("one",1);
            map.put("two",2);
            map.put("three",3);
            System.out.println(map.size());
            System.out.println(map.containsKey("one"));
            if(map.containsKey("two")){
                //用了泛型无需再用强制类型转换
                int i = map.get("two");
                System.out.println(i);
            }
        }
    }

输出结果：  
![输出结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 2]

### 四、总结 ###

*  一个图，java集合之间关系图
 *  一个类 Collections
 *  三个知识点:增强for循环，泛型，自动打包解包
 *  六个接口：collection、set、list、map、iterator、comparable。其中iterator接口标准的统一的来遍历一个collection的方式，comparable可以应用泛型，来定义这个类两个对象之间谁大谁小。

[Java]: https://blog.csdn.net/Mysky984/article/details/98020294
[Java 1]: https://blog.csdn.net/Mysky984/article/details/99211865
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70]: /images/20211101/9a71eab8af4148e58c01d0fee68430b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 1]: /images/20211101/21e5eb4d70694d779c400d4afba39a3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 2]: /images/20211101/74af49377594456c8bb8b2cde72e1e11.png