JAVA学习笔记（十七）

Map接口

　　我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同。

　　Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

　　Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

　　Collection中的集合称为单列集合，Map中的集合称为双列集合。

　　需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

　　Map中常用的集合为HashMap集合、LinkedHashMap集合。

Map接口中常用方法

package com.oracle.demo01;

import java.util.HashMap;

public class HashMapDemp {

    public static void main(String[] args) {
        //valuee();
        keyy();

    }
    /*
     * 当自定义类作为键时，一定要重写HashCode（）方法和equals（）方法
     * */
    public static void keyy() {
        HashMap<Person,String> hs=new HashMap<Person,String>();
        hs.put(new Person("张三",18),"java");
        hs.put(new Person("吴彦祖",20), "php");
        hs.put(new Person("张三",18), "python");
        hs.put(new Person("郭富城",18), "java");
        System.out.println(hs);
    }
public static void valuee() {
    HashMap<String,Person> hs=new HashMap<String,Person>();
    hs.put("java", new Person("张三",18));
    hs.put("php", new Person("吴彦祖",20));
    hs.put("python", new Person("张三",18));
    hs.put("java", new Person("郭富城",18));
    System.out.println(hs);
}
}

Map集合遍历键找值方式

package com.oracle.demo01;

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

public class DemoMap {

    public static void main(String[] args) {
        //put();
        //get();
        //delete();
        //bianli();
        bianli2();
    }
    /*
    *V   put(K key,V value)
    *添加元素
    *返回值 1.如果集合存之前没有这个键，返回空
    *            2.如果存之前集合中存在这个键，替换掉这个键所对应的值，并且返回替换前这个键对应的值
    *            
    */
    public static void put() {
        Map<Integer,String> m=new HashMap<Integer,String>(); 
        String v1=m.put(1, "张三");
        String v2=m.put(2, "李四");
        String v3=m.put(3, "王五");
        String v4=m.put(3, "赵六");
        System.out.println(v1+v2+v3+v4);
        System.out.println(m);
    }
    /*
     * V get(Object key)
     * 获取map集合中指定键的值
     * 
     * 
     * */
    public static void get() {
        Map<Integer,String> m=new HashMap<Integer,String>(); 
        m.put(1, "张三");
        m.put(2, "李四");
        m.put(3, "王五");
        String v=m.get(1);
        System.out.println(v);
    }
    /*
     * V remove(Object key)
     * 移除
     * 1.删除传入的键以及对应的值
     * 2.返回你要删除键所对应的值
     * */
    public static void delete() {
        Map<Integer,String> m=new HashMap<Integer,String>(); 
        m.put(1, "张三");
        m.put(2, "李四");
        m.put(3, "王五");System.out.println(m);
        String v=m.remove(2);
        System.out.println(v);
        System.out.println(m);
    }
    /*
     * 1.通过遍历键找值
     *         （1）获取所有键所对应的set集合
     *         （2）遍历set集合然后取对应的value值
     * */
    public static void bianli() {
        Map<Integer,String> m=new HashMap<Integer,String>(); 
        m.put(1, "张三");
        m.put(2, "李四");
        m.put(3, "王五");
        //1.增强for
        for(Integer i:m.keySet()) {
            Integer key=i;
            String value=m.get(key);
            System.out.println(key+"...."+value);
        }
        //2.Iterator遍历set
        Set<Integer> set=m.keySet();
        Iterator<Integer> it=set.iterator();
        while(it.hasNext()) {
            Integer key=it.next();
            String value=m.get(key);
            System.out.println(key+"  "+value);
        }
    }

Entry键值对对象

　　在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

Map集合遍历键值对方式

　　

　键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值：

　　1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。

　　2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象

　　3.通过键值对(Entry)对象，获取Entry对象中的键与值。

package com.oracle.demo03;

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

public class MapDemo {
//Map套Map    
    public static void main(String[] args) {
        HashMap<String,HashMap<Integer,String>> map=new HashMap<String,HashMap<Integer,String>>();
        HashMap<Integer,String> m1=new HashMap<Integer,String>();
        m1.put(1, "吴彦祖");
        m1.put(2,"郭富城");
        map.put("java01", m1);
        HashMap<Integer,String> m2=new HashMap<Integer,String>();
        m2.put(1, "刘能");
        m2.put(2, "赵四");
        map.put("java03", m2);
        
        //取元素：获取set集合
        Set<String> set=map.keySet();
        //遍历set集合
        for(String str:set) {
            //获取的是甲骨文中的班级名称
            String key=str;
            //获取的是甲骨文中班级Map
            HashMap<Integer,String> value=map.get(key);
            //获取班级Map中的KeySet（学生的学号）
            Set<Integer> set2=value.keySet();
            //遍历Set（学号）
            for(int i:set2) {
                //获取学生学号
                int key2=i;
                //获取学生学号对应的姓名
                String value2=value.get(key2);
                System.out.println(key+"....."+key2+"......"+value2);
            }
        }
        //用EntrySet获取元素
        //1.获得映射关系set
        System.out.println("=====================================");
        Set<Map.Entry<String,HashMap<Integer,String>>> set2=map.entrySet();
        for(Map.Entry<String,HashMap<Integer,String>> a:set2) {
            //获取班级名称
            String k1=a.getKey();
            //获取班级Map
            HashMap<Integer,String> v1=a.getValue();
            //获取班级Map的映射关系
            Set<Map.Entry<Integer, String>> s3=v1.entrySet();
            //遍历
            for(Map.Entry<Integer, String> b:s3) {
                //获取学生学号
                int k2=b.getKey();
                //获取学生姓名
                String v2=b.getValue();
                System.out.println(k1+"......"+k2+"......"+v2);
            }
        }
    }

}

　　练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

　　学生类

public class Student {
    private String name;
    private int age;

    //构造方法
    //get,set方法
    //toString方法
}

　　测试类

public class HashMapTest {
    public static void main(String[] args) {
        //1,创建hashmap集合对象。
        Map<Student,String> map = new HashMap<Student,String>();
        
        //2,添加元素。
        map.put(new Student("lisi",28), "上海");
        map.put(new Student("wangwu",22), "北京");
        map.put(new Student("zhaoliu",24), "成都");
        map.put(new Student("zhouqi",25), "广州");
        map.put(new Student("wangwu",22), "南京");
        
        //3,取出元素。键找值方式
        Set<Student> keySet = map.keySet();
                for(Student key : keySet){
            String value = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
        
        //取出元素。键值对方式
        Set<Map.Entry<Student, String>> entrySet = map.entrySet();
        for (Map.Entry<Student, String> entry : entrySet) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key.toString()+"....."+value);
        }
    }
}

　　当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。

　　如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放。

静态导入

　　在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。

　　静态导入：

import static java.lang.System.out;
public class StaticDemo {

	public static void main(String[] args) {
		out.println("静态导入");
		
	}

可变参数

　　在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成可变参数。

public class KeChangeDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(add(1,2,3,4,5,6,7,8,9));
    }
    //可变参数（参数类型必须相同，参数个数不一定）
    //注意：1.在一个参数列表里只能有一个可变参数
    ///2.这个可变参数必须放在参数列表最后
public static int add(int...a) {
    int sum=0;
    for(int i=0;i<a.length;i++) {
        sum=sum+a[i];
    }
    return sum;
}
}