Map集合的遍历方式以及TreeMap集合保存自定义对象实现比较的Comparable和Comparator两种方式

map集合的特点

1、map集合中保存的都是键值对，键和值是一一对应的

2、一个映射不能包含重复的值

3、每个键最多只能映射到一个值上

 

map接口和collection接口的不同

map是双列集合的根接口，collection是单列集合的根接口

1、map是双列的(是双列集合的根接口),collection是单列的(是单列集合的根接口)

2、map的键是唯一的,collection的子接口set是唯一的

3、map集合的数据结构值针对键有效，跟值无关；如：treemap：键是用二叉树算法，hashmap：键是hash算法， collection集合的数据结构是针对元素有效

 

map集合的遍历方式

 

package com.jd.text;

import java.util.collection;
import java.util.hashmap;
import java.util.iterator;
import java.util.map;
import java.util.map.entry;
import java.util.set;

public class demo06 {

    public static void main(string[] args) {
        // 创建map集合
        map map = new hashmap<>();
        // 添加 将指定的值与此映射中的指定键关联
        map.put("张三", 12);
        map.put("李四", 13);
        map.put("蔡文姬", 14);
        map.put("王五", 15);
        // 删除 如果存在一个键的映射关系，则将其从此映射中移除
        map.remove("王五");
        // map.clear();//删除全部 从此映射中移除所有映射关系
        // 根据指定的key获取对应的value
        object obj1 = map.get("张三");
        system.out.println(obj1);
        // 是否包含指定的key，包含返回true，不包含返回false。
        boolean b = map.containskey("张三");
        system.out.println(b);
        // 是否包含指定的value，包含返回true，不包含返回false。
        boolean c = map.containsvalue(13);
        system.out.println(c);
        
        system.out.println("******************************");
        
        // map集合的遍历,通过keyset()方法(迭代器)
        set keyset = map.keyset();
        iterator iter = keyset.iterator();
        while (iter.hasnext()) {
            object key = iter.next();
            object value = map.get(key);
            system.out.println(key + ":" + value);
        }
        system.out.println("******************************");
        
        // map集合的遍历,通过keyset()方法(foreach)
        set keyset2 = map.keyset();
        for (object key : keyset2) {
            object value = map.get(key);
            system.out.println(key + ":" + value);
        }
        system.out.println("******************************");
        
        // map集合的遍历,通过entryset()方法(foreach)
        set entryset = map.entryset();
        for (object obj3 : entryset) {
            entry e = (entry) obj3;
            object key = e.getkey();
            object value = e.getvalue();
            system.out.println(key + ":" + value);
        }
        system.out.println("******************************");
        
        // map集合的values方法,获取到的map集合的value的值组成的collection集合
        collection coll = map.values();
        for (object obj : coll) {
            system.out.println(obj);
        }
    }
}

运行结果:

12
true
true
******************************
李四:13
张三:12
蔡文姬:14
******************************
李四:13
张三:12
蔡文姬:14
******************************
李四:13
张三:12
蔡文姬:14
******************************
13
12
14

 

treemap集合保存自定义对象

package com.jd.text;

import java.util.set;
import java.util.treemap;

/*
* treemap保存自定义对象,比较的comparable和comparator两种方式
* 1.通过实现comparable接口，重写compareto()方法。
*/
public class demo07 {

public static void main(string[] args) {
treemap map=new treemap<>();
map.put(new user("张三01", 12),11);
map.put(new user("张三01", 10),11);
map.put(new user("张三02", 13),11);
map.put(new user("张三01", 12),11);
//通过重写hashcode()和equals(object obj)方法防止重复的值存入
set set = map.keyset();
for (object key : set) {
object value = map.get(key);
system.out.println(key + ":" + value);
}
}
}

 

package com.jd.text;
/*
 * 通过实现comparable接口，重写compareto()方法。
 */
public class user implements comparable{

    private string name;
    private int age;
    
    public string getname() {
        return name;
    }
    public void setname(string name) {
        this.name = name;
    }
    public int getage() {
        return age;
    }
    public void setage(int age) {
        this.age = age;
    }
    @override
    public string tostring() {
        return "user [name=" + name + ", age=" + age + "]";
    }
    public user(string name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public user() {
        super();
    }
    
    @override
    public int hashcode() {
        final int prime=31;
        int result=1;
        result=prime*result+age;
        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;
        user user=(user) obj;
        if(age!=user.age)
            return false;
        if(name==null){
            if(user.name!=null)
                return false;
        }else if(!name.equals(user.name))
            return false;
        return true;
    }
    @override
    public int compareto(object o) {
        if(o instanceof user){
            user user=(user) o;
            int sum=name.compareto(user.name);
            if(sum==0)
                return age-user.age;
            return sum;
        }
        throw new classcastexception("不是user类型");
    }
    
}

运行结果:

user [name=张三01, age=10]:11
user [name=张三01, age=12]:11
user [name=张三02, age=13]:11

 

package com.jd.text;
/*
 * treemap保存自定义对象,比较的comparable和comparator两种方式
 * 2.自己构造比较器实现comparator接口，重写compare(object o1, object o2)方法
 */

import java.util.comparator;
import java.util.set;
import java.util.treemap;

public class demo08 {

    public static void main(string[] args) {
        treemap map=new treemap(new mycompare());
        map.put(new user2("张三01", 12),11);
        map.put(new user2("张三01", 10),11);
        map.put(new user2("张三02", 13),11);
        map.put(new user2("张三01", 12),11);
        //通过重写hashcode()和equals(object obj)方法防止重复的值存入
        set set = map.keyset();
        for (object key : set) {
            object value = map.get(key);
            system.out.println(key + ":" + value);
        }
    }
}

class user2{
    string name;
    int age;
    
    public user2(string name,int age){
        this.name=name;
        this.age=age;
    }
    
    @override
    public int hashcode(){
        final int prime=31;
        int result=1;
        result=prime*result+age;
        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;
        user2 u=(user2) obj;
        if(age!=u.age)
            return false;
        if(name==null){
            if(u.name!=null)
                return false;
        }else if(!name.equals(u.name))
                return false;
        return true;
    }
    @override
    public string tostring() {
        return "user2 [name=" + name + ", age=" + age + "]";
    }
}
//比较器
class mycompare implements comparator{

    @override
    public int compare(object o1, object o2) {
        if(o1 instanceof user2 && o2 instanceof user2){
            user2 u1=(user2) o1;
            user2 u2=(user2) o2;
            int sum=u1.age-u2.age;
            if(sum==0){
                return u1.name.compareto(u2.name);
            }
            return sum;
        }
        throw new classcastexception("不是user2 类型");
    }
    
}

运行结果:

user2 [name=张三01, age=10]:11
user2 [name=张三01, age=12]:11
user2 [name=张三02, age=13]:11