Map和Collection的区别

Posted 2023-05-05

参考技术A Collection接口，包含list和set子接口
Collection和Map接口之间的主要区别在于：Collection中存储了一组对象，而Map存储关键字/值对。
在Map对象中，每一个关键字最多有一个关联的值。
Map:不能包括两个相同的键，一个键最多能绑定一个值。null可以作为键，这样的键只有一个；可以有一个或多个键所对应的
值为null。当get()方法返回null值时，即可以表示Map中没有该键，也可以表示该键所对应的值为null。因此，在Map中不能由get()方法来判断Map中是否存在某个键，而应该用containsKey()方法来判断。 参考技术B Collection接口，包含list和set子接口
Collection和Map接口之间的主要区别在于：Collection中存储了一组对象，而Map存储关键字/值对。
在Map对象中，每一个关键字最多有一个关联的值。
Map:不能包括两个相同的键，一个键最多能绑定一个值。null可以作为键，这样的键只有一个；可以有一个或多个键所对应的
值为null。当get()方法返回null值时，即可以表示Map中没有该键，也可以表示该键所对应的值为null。因此，在Map中不能由get()方法来判断Map中是否存在某个键，而应该用containsKey()方法来判断。
继承Map的类有：HashMap，HashTable
HashMap：Map的实现类，缺省情况下是非同步的，可以通过Map Collections.synchronizedMap(Map m)来达到线程同步
HashTable：Dictionary的子类，确省是线程同步的。不允许关键字或值为null
当元素的顺序很重要时选用TreeMap，当元素不必以特定的顺序进行存储时，使用HashMap。Hashtable的使用不被推荐，因为HashMap提供了所有类似的功能，并且速度更快。当你需要在多线程环境下使用时，HashMap也可以转换为同步的。本回答被提问者和网友采纳

Map类

package map;

public class differentDemo {
    /**
     * map和Collection集合的区别
     * map集合是键值对的集合    Collection是单一出现数据的聚合
     * Map的键是唯一的，而collection的子接口List集合中的元素是可以重复的，set是唯一的
     * map是夫妻对，collection是光棍
     */
}

package map;

import java.util.HashMap;
import java.util.Map;

public class MapDemo1 {
    public static void main(String[] args) {
        
        /**
         * Map的特点：
         * 数据成对出现
         * 数据的键是唯一的
         * 一个键只能对应一个值
         * 值可以重复
         * 键允许一个为空，值可以多个是空
         * 方法：
         * put()
         * putAll()
         * remove()
         * clear()
         * 
         * get()
         *  Set<k>   keySet
         *  
         *  判断功能：
         *  containsKey()
         *  containsValue()
         *  isEmpty()
         *  
         *  
         *  遍历方式：
         *  Set<Entry<String,Person>> entry = map.entrySet();
         *  for(Entry<String,Person> sp:entry){
         *      String key = sp.getKey();
         *      Person value = sp.getValue();
         *  System.out.println("键："+key+"   值:"+value);
         *  
         *  }
         *  HashMap:
         *  
         *  HashMap是map的实现类
         *   允许多个null值和null键
         *   Hashmap中的元素没有顺序
         *   hashmap不是线程安全的
         *   Map<String,String> map = new HashMap<String,String>();
         *   map = Collections.synchronizedMap(map);
         *   这样就变成了线程安全的
         *   
         *   Treemap：
         *   可以进行自然排序
         *   可以创建comparetor进行排序，可以重写compareto进行排序
         *   
         *   key不能为null，不能重复
         *   
         *   
         *   HashTable：
         *   不允许有任何null值和null键
         *   
         *   HashTable中的元素没有顺序
         *   是线程安全的
         *   
         *   LinkedHashMap:
         *   
         *   有顺序，
         *   允许多个null值和null键
         *   不是线程安全的
         *   
         *  
         *  
         */
        Map<String,String> map = new HashMap<String,String>();
        map.put("鼓上蚤","时迁");
        map.put("行者","武松");
        //键是唯一的，如果有俩会存在覆盖的情况
        map.put("行者","武大郎");
        
        
    }
}

package practice;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo1 {
    public static void main(String[] args) {
        /**
         * map的特点： 1.数据成对出现 2.数据的键是唯一的，如果有相同的会被覆盖的 3.一个键只能有一个值 4.值可以重复
         * 5.键允许有一个为空，值可以多个是空，有一个null可以对应，有两个null就无法正确对应了
         */
        Map<String, String> map = new HashMap<String, String>();
        map.put("鼓上蚤", "时迁");
        map.put("行者", "武松");
        map.put("及时雨", "宋江");
        map.put("呼保义", "宋江");
        map.put(null, "无用");
        map.put("晓晓", null);
        map.put("螃蟹", null);
        // 只能有一个null键，否则，会被覆盖
//        map.put(null, "无1用");
        System.out.println(map);

        Map<String, String> map1 = new HashMap<String, String>();
        map1.put("花和尚", "鲁智深");
        map1.put("青面兽", "杨志");
        // 一个map添加到另一个map中
        map.putAll(map1);
        System.out.println(map);
//        清空map
        map1.clear();
        System.out.println(map1);
        // 删除一个键值对
        map.remove("青面兽");
        // 通过对应的键来获取值
        System.out.println(map);
        // 通过get来获取键值对  如果没有相应的键就返回null
        String a = map.get("花和尚");
        System.out.println(a);
            
        Set<String> set = map.keySet();
        //这里输出的是所有的键
        System.out.println(set);
        for(String key:set) {
            //根据当前的key来获得value
            String value  = map.get(key);
            System.out.println(value);
        }
        
        Map<String,Person> map2 = new HashMap<String,Person>();
        
        map2.put("3", new Person(1,"阿彪",1));
        map2.put("2", new Person(1,"拖拉机",2));
        System.out.println(map2);
        //是否包含某个值
        boolean iscon = map.containsKey("花和尚");
        System.out.println(iscon);
        boolean isval = map.containsValue("鲁智深");
        System.out.println(isval);
        
        boolean isval1 = map2.containsValue(new Person(1,"阿彪",1));
        System.out.println(isval1);
        
        Set<Entry<String, String>> entry  = map.entrySet();
        for(Entry<String, String> et : entry)
        {        //for循环中自己定义的那个就是元素
            String key1 = et.getKey();
            String value1 = et.getValue();
            System.out.println("键：  "+key1+"     值:"+value1);
        }
        
    }
}

package practice;

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo {
        
    
    public static void main(String[] args) {
        /**
         * map的实现类HashMap
         * 1.允许多个null值和一个null键
         * 2.HashMap中的元素没有顺序（跟添加的顺序无关）
         * 3.HashMap不是线程安全的
         */
        Map<String,String> map = new HashMap<String,String>();
        map.put("鼓上蚤", "时迁");
        map.put("呼保义", "宋江");
        map.put("及时雨", "宋江");
        map.put("行者", "武松");
        System.out.println(map);
        
    }
}

package practice;

public class HashtableDemo {
/**
 * 不允许有null值和null键
 */
}

package practice;

public class HashtableDemo {
/**
 * 不允许有null值和null键
 */
}

package practice;

public class Person {
    private int age;
    
    private String name;
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + ", gender=" + gender + "]";
    }

    public Person(int age, String name, int gender) {
        super();
        this.age = age;
        this.name = name;
        this.gender = gender;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + gender;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person)obj;
        if(this.age == p.age&&this.gender==p.gender
                &&this.name!=null&&p.name!=null&this.name.equals(p.name)) {
            return true;
        }
        else {
            return false;
        }
        
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }

    private int gender;
}

package practice;

public class TreeMap {
/**
 * 有自然排序
 */
}