集合类学习之HashMap经典储存 分拣存储与面向对象组合

HashMap:键值对（key-value）

通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value.

默认是1:1关系（一对一）

存在则覆盖，当key已经存在，则利用新的value覆盖原有的value

例1：给定一个字符串，求出字符串中每一个单词在字符串中出现的次数

旨意：map的分拣思想。

第一种分拣思想：（1）先为key创建对应的容器（2）使用容器，存放key对应的值

 /**
  * 作为包装类，用来存放英文单词，和该英文单词出现的次数
 * @author qjc
 * @date 2016-3-9
 */
 public class Str {
     private String st;
     private int count;
    //....
 }

 /**
  * 字符串：this is a cat and that is a nice and where is the food
  * 将该字符串的每个单词出现的次数统计出来
  * 【分拣的思想】
  *  第一种：为所有key创建容器
  *        之后存放对应的value
  *  第二种:第一次创建容器，并存放value
  *       第二次之后，直接使用容器存放value
 * @author qjc
 * @date 2016-3-9
 *
  */
 public class TestMap {

     public static void main(String[] args) {
         test4();

     }

     //第一种分拣思路 （1）先为所有的key创建对应的容器（2）为对应key的容器中存放值
     public static void test1(){
         String sts="this is a cat and that is a nice and where is the food";
         //将字符串分割成一个个单词，并存放入数组中
         String[] strings=sts.split(" ");
         //创建一个map对象，用来存放单词和单词出现的次数
         Map<String, Str> countMap=new HashMap<String, Str>();
         //第一种分拣思想
         //第一步：为所有的key创建容器，
         for(int i=0;i<strings.length;i++){
             String temp=strings[i];
             //判断map是否含有此key，如果有返回true,否则返回false
             //第一次为所有的key创建容器
             if(!countMap.containsKey(temp)){
                 Str str=new Str();
                 countMap.put(temp, str);
             }
         }

         //第二步:使用容器，存放值
         for(String temp:strings){
             Str clsStr=countMap.get(temp);
             clsStr.setCount(clsStr.getCount()+1);
             clsStr.setSt(temp);
         }

         //测试countMap是否算是成功达到目的
         Set<String> keys=countMap.keySet();
         for (String key:keys) {
             Str sd=countMap.get(key);
             Integer cInteger=sd.getCount();
             System.out.println("字母："+key+"--次数:"+cInteger);
         }

     }
     //第一种分拣思路 （1）先为所有的key创建对应的容器（2）为对应key的容器中存放值
     public static void test2(){
         String sts="this is a cat and that is a nice and where is the food";
         //将字符串分割成一个个单词，并存放入数组中
         String[] strings=sts.split(" ");
         //创建一个map对象，用来存放单词和单词出现的次数
         Map<String, Str> countMap=new HashMap<String, Str>();
         //第一种分拣思想
         //第一步：为key创建容器的同时，并存放值
         for(int i=0;i<strings.length;i++){
             String temp=strings[i];
             //判断map是否含有此key，如果有返回true,否则返回false
             //先创建容器，之后为容器存放值
             if(!countMap.containsKey(temp)){
                 Str str=new Str();
                 countMap.put(temp, str);
             }
                 //使用容器存放值
                 Str str=countMap.get(temp);
                 str.setCount(str.getCount()+1);

         }

         //测试countMap是否算是成功达到目的
                 Set<String> keys=countMap.keySet();
                 for (String key:keys) {
                     Str sd=countMap.get(key);
                     Integer cInteger=sd.getCount();
                     System.out.println("字母："+key+"--次数:"+cInteger);
                 }
     }

 }

 //第二种分拣思想：（1）第一次为key创建容器，并存key对应的值（2）第二次使用创建好的容器，存放key对应的值

 /* 【分拣的思想】
  *  第一种：为所有key创建容器
  *        之后存放对应的value
  *  第二种:第一次创建容器，并存放value
  *       第二次之后，直接使用容器存放value
 * @author qjc
 * @date 2016-3-9
 *
  */
 public class TestMap {
     public static void main(String[] args) {
         test4();
     }
     //分拣第二种思想 （1）第一次为key创建容器，并存放值（2）第二次使用容器存放值
     public static void test3(){
         String sts="this is a cat and that is a nice and where is the food";
         //将字符串分割成一个个单词，并存放入数组中
         String[] strings=sts.split(" ");
         //创建一个map对象，用来存放单词和单词出现的次数
         Map<String, Str> countMap=new HashMap<String, Str>();
         //第一种分拣思想
         //第一步：为key创建容器的同时，并存放值
         for(int i=0;i<strings.length;i++){
             String temp=strings[i];
             //判断map是否含有此key，如果有返回true,否则返回false
             //第一次创建容器，并为容器中存放值
             if(!countMap.containsKey(temp)){
                 Str str=new Str();
                 str.setCount(1);
                 countMap.put(temp, str);
             }else{
                 //第二次使用容器存放值
                 Str str=countMap.get(temp);
                 str.setCount(str.getCount()+1);
             }
         }

         //测试countMap是否算是成功达到目的
                 Set<String> keys=countMap.keySet();
                 for (String key:keys) {
                     Str sd=countMap.get(key);
                     Integer cInteger=sd.getCount();
                     System.out.println("字母："+key+"--次数:"+cInteger);
                 }
     }

     //第二种分拣思路：（1）第一次为key创建容器，并存放值（2）第二次使用容器存放值
     public static void test4(){
         String sts="this is a cat and that is a nice and where is the food";
         //将字符串分割成一个个单词，并存放入数组中
         String[] strings=sts.split(" ");
         //创建一个map对象，用来存放单词和单词出现的次数
         Map<String, Str> countMap=new HashMap<String, Str>();
         //第一种分拣思想
         //第一步：为key创建容器的同时，并存放值
         for(int i=0;i<strings.length;i++){
             String temp=strings[i];
             //判断map是否含有此key，如果有返回true,否则返回false
             //第一次创建容器，并为容器中存放值
             Str str=null;
             if(null==(str=countMap.get(temp))){
                  str=new Str();
                 str.setCount(1);
                 countMap.put(temp, str);
             }else{
                 //第二次使用容器存放值
                  str=countMap.get(temp);
                 str.setCount(str.getCount()+1);
             }
         }

         //测试countMap是否算是成功达到目的
                 Set<String> keys=countMap.keySet();
                 for (String key:keys) {
                     Str sd=countMap.get(key);
                     Integer cInteger=sd.getCount();
                     System.out.println("字母："+key+"--次数:"+cInteger);
                 }
     }
 }

例2:

分拣思想的应用

　需求:查询出学生List集合，对学生集合进行加工，将学生按照班级分类，并求出班级的总分和平均分

　思路:map分拣思想。需要创建一个班级po，班级po里存放学生信息，该班集的总分，班级号码。

/**
 *思考:
 *    定义一个Student类,属性:name 姓名,no班号,score 成绩
 *    现在将若干Student对象放入List,请统计出每个班级的总分和平均分
 *方案: 面向对象+分拣存储(1:N)
* @author qjc
 * 2016-3-9
 */
public class MapDemo02 {
    /**
     * 模拟考试 测试数据到List
     */
    public static List<Student> exam(){
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三", "java", 84));
        list.add(new Student("李四", "java", 88));
        list.add(new Student("王五", "c++", 90));
        list.add(new Student("赵六", "c++", 98));
        return list;
    }
    /**
     * 统计分析
     *     1、面向对象
     *     2、分拣存储
     */
    public static Map<String, ClassRoom> count(List<Student> list){
        Map<String, ClassRoom> map = new HashMap<String, ClassRoom>();
        //1、遍历List
        for(Student stu : list){
            String no = stu.getNo(); //班级编号
            double score = stu.getScore(); //成绩
            //2、分拣 查看是否存在该编号的班级
            //如果不存在，创建班级
            ClassRoom room = map.get(no);
            if(null==room){
                room = new ClassRoom(no);
                map.put(no, room);
            }
            //存在，放入学生
            room.getStudents().add(stu);
            //计算总分
            room.setTotal(room.getTotal()+score);
        }
        return map;
     }
    /**
     * 查看每个班级的总分和平均分 --->遍历map
     */
    public static void view(Map<String, ClassRoom> map){
        Set<String> keySet = map.keySet();
        Iterator<String> iter = keySet.iterator();
        while(iter.hasNext()){
            String no = iter.next();
            ClassRoom room = map.get(no);
            //查看总分  计算平均分
            double total = room.getTotal();
            double avg = total/room.getStudents().size();
            System.out.println(no+"---->"+total+"---->"+avg);
        }
    }
    public static void main(String[] args) {
        //1、考试
        List<Student> list = exam();
        //2、分析成绩
        Map<String, ClassRoom> map = count(list);
        //3、查看成绩（总分、平均分）
        view(map);
    }
}

/**
 * 一个班级多个学生（学生列表）
 * @author qjc
 * 2016-3-9
 */
public class ClassRoom {
    private String no;//班级
    private List<Student> students; //班级列表
    private double total; //总分
    public ClassRoom() {
        students = new ArrayList<>();
    }
    public ClassRoom(String no) {
        this();
        this.no = no;
    }
    //…..
}

public class Student {
    private String name;
    private String no; //班级
    private double score; //成绩
    //…..
}