集合的另一种接口：Map接口和它的3种实现类

package day03;
//实现Comparable<Pen>
public class Pen implements Comparable<Pen>{
    private String name;
    private int health;
    private int love;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        if(health < 0) {
            this.health = 100;
            System.out.println("健康值不合法!");
        }else {            
            this.health = health;
        }
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }

    public Pen() {
        super();
        this.health = 100;
        this.love = 0;
    }
    /*为了比较自定义类的内容重写hashCode方法和equals方法(用编译器自动生成)
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + health;
        result = prime * result + love;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Pen other = (Pen) obj;
        if (health != other.health)
            return false;
        if (love != other.love)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }*/
    
    
    
    public Pen(String name, int health, int love) {
        super();
        this.name = name;
        this.setHealth(health);
        this.setLove(love);
    }
    
    public void showInfo() {
        System.out.print("我的姓名："+this.getName());
        System.out.print(",健康值："+this.getHealth());
        System.out.print(",亲密度"+this.getLove());
    }
    //重写Object 方法
    @Override
    public String toString() {
        return "Pen [name=" + name + ", health=" + health + ", love=" + love
                + "]";
    }
    //重写compareTo方法（先比亲密度，在比较名字）
    /*内部比较器
     * 当一个自定义对象实现Comparable并实现compareTo方法时，通过指定具体的比较策略，此时称为内部比较器。
     * 比较策略的几种情况
         [1]比较策略一般当前对象写在前面，待比较对象也在后面，比较结果默认升序
                      如果想要降序，改变两个比较对象的位置即可。
         [2] 多种比较因素
     * */
    @Override
    public int compareTo(Pen a) {
        if (this.getLove()<a.getLove()){
            return -1;
        }else if(this.getLove()==a.getLove()){
            return this.getName().compareTo(a.getName());//string类型写法
        }else{
            return 1;
        }//简单写法：return this.getLove()-<a.getLove();
    }
}

package day03;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

/*Map接口
 * Map接口的实现类HashMap、LinkedHashMap、TreeMap
Map接口称为键值对集合或者映射集合，其中的元素(entry)是以键值对(key-value)的形式存在。
Map 容器接口中提供了增、删、改、查的方式对集合进行操作。
Map接口中都是通过key来操作键值对，一般key是已知。通过key获取value。*/
public class MapTest01 {
public static void main(String[] args) {
    /**map常用方法
     * 增:put/putAll
     * 删:clear/remove
     * 改:put
     * 查:get/containsKey/containsValue
     * 其他:isEmpty/size
     */
    Map<String, String> map=new HashMap<String, String>();
    // 【1】put
    map.put("a", "apple3");
    map.put("b", "apple1");
    map.put("c", "apple2");
    System.out.println(map);//输出结果：{b=apple1, c=apple2, a=apple3}Map也是无序的，{}这个代表Map接口
    // 可以根据key的自然顺序 让map有序  => 一般用string作为key
    
    
    // 【2】删除（以key来控制）
    map.remove("a");
    System.out.println(map);//输出结果：{b=apple1, c=apple2}
     map.clear();
     System.out.println(map);//输出结果：{}
    
     
     map.put("a", "apple3");
        map.put("b", "apple1");
        map.put("c", "apple2");
    
        // 【3】修改（以key来控制）
     map.put("a", "apple x");
     System.out.println(map);//输出结果：{b=apple1, c=apple2, a=apple x}    
            
     // 【4】查看（以key来控制）
    String val = map.get("a");
     System.out.println(val);//输出结果：apple x
    //有没有key："d"
     System.out.println(map.containsKey("d"));//输出结果：false
            
            
    //map的遍历输出        ：通过keySet() 返回map中键的set集合。
    
    // keyset方式（通过keySet() 返回map中键的set集合。）
            Set<String> keys = map.keySet();
            for (String key : keys) {
                System.out.println(key+"=>"+map.get(key));//输出结果：b=>apple1  c=>apple2  a=>apple x
            }
            
            Iterator<String> it = keys.iterator();
            while(it.hasNext()) {
                String key = it.next();
                System.out.println(key+"=>"+map.get(key));//输出结果：    b=>apple1  c=>apple2  a=>apple x
            }
            
            
            
            
            // entrySet；；；map中以键值对作为元素，键值对在map中称为entry，entrySet返回键值对的set集合。
            //向自定义类差不多
            Set<Entry<String, String>> entrySet = map.entrySet();//返回此映射中包含的映射关系的 Set 视图。
            for (Entry<String, String> entry : entrySet) {
                System.out.println(entry.getKey()+"=>"+entry.getValue());//输出结果：b=>apple1  c=>apple2  a=>apple x
            }
            
            Iterator<Entry<String, String>> it2 = entrySet.iterator();
            while(it2.hasNext()) {
                Entry<String, String> entry = it2.next();
                System.out.println(entry.getKey()+"=>"+entry.getValue());//输出结果：    b=>apple1  c=>apple2a  =>apple x
            }
    
    
            //Map接口的实现类HashMap、LinkedHashMap、TreeMap
            
       //HashMap
        //HashMap 是Map的实现类，key以HashSet存储。
            // 向HashMap中存储元素时，key一定要实现hashCode和equals
             // 一般建议使用String作为Map接口的key    
            HashMap<String, Object> map2 = new HashMap<String,Object>();
            
            ArrayList<String> list1 = new ArrayList<String>();
            list1.add("alex");
            list1.add("alice");
            list1.add("allen");
            map2.put("A", list1);//把Collection容器的元素存入Map容器中
            
            
            ArrayList<String> list2 = new ArrayList<String>();
            list2.add("ben");
            list2.add("bill");
            map2.put("B", list2);//把Collection容器的元素存入Map容器中
            //两个元素
            System.out.println(map2);    //输出结果：    {A=[alex, alice, allen], B=[ben, bill]}
            
            
            
            
            
            //用自定义的Pen类来当key，因为要比较内容，所以要在Pen类中重写比较方法
            HashMap<Pen, Object> map3 = new HashMap<Pen,Object>();
            
            ArrayList<String> list5 = new ArrayList<String>();
            list5.add("alex");
            list5.add("alice");
            list5.add("allen");
            Pen s1 = new Pen("大狗",120,0);
            map3.put(s1, list5);
            
            
            ArrayList<String> list6 = new ArrayList<String>();
            list6.add("ben");
            list6.add("bill");
            Pen s2 = new Pen("2狗",100,10);
            
            map3.put(s2, list6);
            System.out.println(map3);    
//输出结果：{Pen [name=大狗, health=120, love=0]=[alex, alice, allen], Pen [name=2狗, health=100, love=10]=[ben, bill]}
                
            // 修改（把s1中的Value修改成s2中的Value）        
            map3.put(s1, list6);    
            System.out.println(map3);            
//{Pen [name=大狗, health=120, love=0]=[ben, bill], Pen [name=2狗, health=100, love=10]=[ben, bill]}    
                    
                
                    
                
            
            /*LinkedHashMap
              LinkedHashMap是Map接口的实现类，key以LinkedHashSet存储。
                                      哈希表散列key,链表维持key的添加顺序。
*/
            LinkedHashMap<String, Object> map6 = new LinkedHashMap<String,Object>();
            
            ArrayList<String> list7 = new ArrayList<String>();
            list7.add("ben");
            list7.add("bill");
            map6.put("B", list7);
            
            ArrayList<String> list8 = new ArrayList<String>();
            list8.add("alex");
            list8.add("alice");
            list8.add("allen");
            map6.put("A", list8);
            
            System.out.println(map6);//输出结果：{B=[ben, bill], A=[alex, alice, allen]}
           // 以输出顺序来排
    
    
            
        /*TreeMap
           TreeMap是Map的实现类，key以TreeSet存储。底层数据结构是二叉树。
           key是自定义类的话，要比较里面的内容则要重写Comparator
           下面是外部比较器；
*/    
    
    
    

            TreeMap<Pen, Object> map10 = new TreeMap<Pen,Object>(new Comparator<Pen>(){

                public int compare(Pen o1, Pen o2) {
                    return o1.getLove() - o2.getLove();}
            });
                


            ArrayList<String> list10 = new ArrayList<String>();
            list10.add("alex");
            list10.add("alice");
            list10.add("allen");
            Pen s11 = new Pen("大狗",100,10);
            map10.put(s11, list10);
            
            
            ArrayList<String> list20 = new ArrayList<String>();
            list20.add("ben");
            list20.add("bill");
            Pen s20 = new Pen("大狗",1000,0);
            
            map10.put(s20, list20);
            System.out.println(map10);
//{Pen [name=大狗, health=1000, love=0]=[ben, bill], Pen [name=大狗, health=100, love=10]=[alex, alice, allen]}    
    
    
}
}