JAVA学习--Map接口

Map接口用于存储（键/值对）。Map中的元素都是成对出现的，键值对就像数组的索引和数组内容的关系一样，把一个键映射到一个值的对象。每个键最多只能映射到一个值，可以通过键去寻找到相应的值。

key <----> Value

value可以存储任意类型的对象，可以根据key键快速查找value。Map中的键/值对以Entry类型的对象实例形式存在。

方法	返回值	说明
clear()	void	从此映射中移除所用映射关系（可选操作）
containsKey(Object key)	boolean	如果此映射包含指定键的映射关系，则返回true
containsValue(Object value)	boolean	如果此映射将一个或多个键映射到指定值，则返回 true
entrySet()	Set<Map.Entry<K,V>>	返回此映射中包含的映射关系的 Set 视图
equals(Object o)	boolean	比较指定的对象与此映射是否相等
get(Object key)	V	返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
hashCode()	int	返回此映射的哈希码值
isEmpty()	boolean	如果此映射未包含键-值映射关系，则返回 true
keySet()	Set	返回此映射中包含的键的 Set 视图
put(K key, V value)	V	将指定的值与此映射中的指定键关联（可选操作）
putAll(Map<? extends K, ? extends V> m)	void	从指定映射中将所有映射关系复制到此映射中（可选操作）
remove(Object key)	V	如果存在一个键的映射关系，则将其从此映射中移除（可选操作）
size	int	返回此映射中的键-值映射关系数
values()	Collection	返回此映射中包含的值的 Collection 视图

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
// Course.java
class Course{
//public class Course{
    public String id;
    public String name;
    public Course(String id,String name){
        this.id = id;
        this.name = name;
    }
}

//MapTest.java
public class MapTest{
    /**
     * 用来承装课程类型对象
     */
     public Map<String,Course> courses;
     /**
     * 在构造器中初始化 courses 属性
     * @param args
     */
     public MapTest(){
         this.courses = new HashMap<String,Course>();
     }
     /**
     * 测试添加：输入课程 ID，判断是否被占用
     * 若未被占用，输入课程名称，创建新课程对象
     * 并且添加到 courses 中
     * @param args
     */
     public void testPut(){
        //创建一个 Scanner 对象，用来获取输入的课程 ID 和名称
        Scanner console = new Scanner(System.in);

        for(int i=0;i<3;i++){
            System.out.println("请输入课程 ID: ");
            String ID = console.next();
            //判断该 ID 是否被占用
            Course cr = courses.get(ID);
            if(cr == null){
                //提示输入课程名称
                System.out.println("请输入课程名称：");
                String name = console.next();
                //创建新的课程对象
                Course newCourse = new Course(ID,name);
                //通过调用 courses 的 put 方法，添加 ID-课程映射
                courses.put(ID,newCourse);
                System.out.println("成功添加课程：" + courses.get(ID).name);
            }
            else{
                System.out.println("该课程 ID 已被占用");
                continue;
            }
        }
     }
     /**
     * 测试 Map 的 keySet 方法
     * @param args
     */
     public void testKeySet(){
         //通过 keySet 方法，返回 Map 中的所有键的 Set 集合
         Set<String> keySet = courses.keySet();
         //遍历 keySet，取得每一个键，在调用 get 方法取得每个键对应的 value
         for(String crID:keySet){
             Course cr = courses.get(crID);
             if(cr!=null){
                 System.out.println("课程：" + cr.name);
             }
         }
     }
     /**
     * 测试删除 Map 中的映射
     * @param args
     */
     public void testRemove(){
         //获取从键盘输入的待删除课程 ID 字符串
         Scanner console = new Scanner(System.in);
         while(true)
         {
             //提示输出待删除的课程 ID
             System.out.println("请输入要删除的课程 ID！");
             String ID = console.next();
             //判断该 ID 是否对应的课程对象
             Course cr = courses.get(ID);
             if(cr == null)
             {
                 //提示输入的 ID 并不存在
                System.out.println("该 ID 不存在！");
                continue;
             }
             courses.remove(ID);
             System.out.println("成功删除课程" + cr.name);
             break;
         }
     }
     /**
     * 通过 entrySet 方法来遍历 Map
     * @param args
     */
     public void testEntrySet()
     {
         //通过 entrySet 方法，返回 Map 中的所有键值对
         Set<Entry<String,Course>> entrySet = courses.entrySet();
         for(Entry<String,Course> entry:entrySet)
         {
             System.out.println("取得键：" + entry.getKey());
             System.out.println("对应的值为：" + entry.getValue().name);
         }
     }
     /**
     * 利用 put 方法修改Map 中的已有映射
     * @param args
     */
     public void testModify()
     {
        //提示输入要修改的课程 ID
        System.out.println("请输入要修改的课程 ID：");
        //创建一个 Scanner 对象，去获取从键盘上输入的课程 ID 字符串
        Scanner console = new Scanner(System.in);
        while(true)
        {
            //取得从键盘输入的课程 ID
            String crID = console.next();
            //从 courses 中查找该课程 ID 对应的对象
            Course course = courses.get(crID);
            if(course == null)
            {
                System.out.println("该 ID 不存在！请重新输入！");
                continue;
            }
            //提示当前对应的课程对象的名称
            System.out.println("当前该课程 ID，所对应的课程为：" + course.name);
            //提示输入新的课程名称，来修改已有的映射
            System.out.println("请输入新的课程名称：");
            String name = console.next();
            Course newCourse = new Course(crID,name);
            courses.put(crID, newCourse);
            System.out.println("修改成功！");
            break;
        }
     }

     public static void main(String[] args)
     {
        MapTest mt = new MapTest();
        mt.testPut();
        mt.testKeySet();
        mt.testRemove();
        mt.testModify();
        mt.testEntrySet();
    }
}

请输入课程 ID：
1
请输入课程名称：
语文
成功添加课程：语文
请输入课程 ID：
1
该课程 ID 已被占用
请输入课程 ID：
2
请输入课程名称：
数学
成功添加课程：数学
课程：语文
课程：数学
请输入要删除的课程 ID！
1
成功删除课程语文
请输入要修改的课程 ID：
2
当前该课程 ID，所对应的课程为：数学
请输入新的课程名称：
英语
修改成功！
取得键：2
对应的值为：英语

Set接口

//PD.java
import java.util.HashSet;
import java.util.Set;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.List;
/*
 * 项目组长类
 */
class PD
 {
     public String id;
     public String name;
     //集合后面的<>代表泛型的意思
     //泛型是规定了集合元素的类型
     public Set<Student> students;
     public PD(String id,String name)
     {
         this.id = id;
         this.name = name;
         this.students = new HashSet<Student>();
     }
 }
/**
 * 学生类
 */
 // Student.java
class Student
 {
     public String id;
     public String name;
     public Student(String id,String name)
    {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString()
    {
        return "Student{"+"id='"+id+'\''+",name = '"+name+'\''+'}';
    }
 }
 //SetTest.java
 public class SetTest
 {
     public List<Student> students;

     public SetTest()
     {
         students = new ArrayList<Student>();
     }
     /*
     * 用于往students中添加学生
     */
     public void testAdd()
    {
        //创建一个学生对象，并通过调用add方法，添加到学生管理List中
        Student st1 = new Student("1", "张三");
        students.add(st1);
        //添加到List中的类型均为Object，所以取出时还需要强转
        Student st2 = new Student("2","李四");
        students.add(st2);

        Student[] student = {new Student("3", "王五"),new Student("4", "马六")};
        students.addAll(Arrays.asList(student));

        Student[] student2 = {new Student("5", "周七"),new Student("6", "赵八")};
        students.addAll(Arrays.asList(student2));
    }
    /**
     * 通过for each 方法访问集合元素
     * @param args
     */
    public void testForEach()
    {
        System.out.println("有如下学生（通过for each）：");
        for(Object obj:students)
        {
            Student st = (Student)obj;
            System.out.println("学生：" + st.id + ":" + st.name);
        }
    }
    public static void main(String[] args)
    {
        SetTest st = new SetTest();
        st.testAdd();
        st.testForEach();
        PD pd = new PD("1","张老师");
        System.out.println("请：" + pd.name + "选择小组成员！");
        //创建一个 Scanner 对象，用来接收从键盘输入的学生 ID
        Scanner console = new Scanner(System.in);

        for(int i=0;i<3;i++)
        {
            System.out.println("请输入学生 ID");
            String studentID = console.next();
            for(Student s:st.students)
            {
                if(s.id.equals(studentID))
                {
                    pd.students.add(s);
                }
            }
        }
        st.testForEachForSer(pd);
        // 关闭 Scanner 对象
        console.close();
    }
    //打印输出，老师所选的学生！Set里遍历元素只能用foreach 和 iterator
    //不能使用 get() 方法，因为它是无序的，不能想 List 一样查询具体索引的元素
    public void testForEachForSer(PD pd)
    {
        for(Student s: pd.students)
        {
        System.out.println("选择了学生：" + s.id + ":" + s.name);
        }
    }
 }