Java集合框架-Collection03-Map集合

目录

​​1. Map​​

​​用一个题目给大家说一下吧！​​

​​Map集合3层嵌套使用（2Map+1List）​​

​​ 1.2 遍历（代码如下）​​

​​        1.2.1 先取出保存所有键的Set,再遍历Set即可(2种)​​

​​        1.2.2 先取出保存所有Entry的Set,再遍历此Set即可​​

​​2.HashMap与Hashtable之间的区别（重点）​​

​​3. 其它（地狱回调） ​​

---

1. Map

        1.1 特点：无序、以键值对的形式添加元素，键不能重复，（如果多次往同一个索引存储元素，以最后一个存储为准，后面存储内容会将前面存储内容覆盖）值可以重复
           它没有继承Collection接口，map集合一次要存两个元素，第一个是Key（键-索引）、第二个内容是value（值）

用一个题目给大家说一下吧！

Map集合3层嵌套使用（2Map+1List）

//一.定义一个Map集合,key和value不规定类型，任意放入数据，用keySet()和entrySet()两种方式遍历出Map集合的数据
//二.定义一个Map集合,key和value不规定类型，任意放入数据,单独拿到所有的value的数据
//三.Map集合3层嵌套使用（2Map+1List）
    //List<Student> lst = new ArrayList<>();
    //Map<String, List<Student>> map = new TreeMap<>();
    Map<String, Map<String,List<Student>>> map1 = new HashMap<>();
    
    // 每一个部
    Map<String, List<Student>> m1 = new HashMap<>();// 初中部
    Map<String, List<Student>> m2 = new HashMap<>();// 高中部
    Map<String, List<Student>> m3 = new HashMap<>();// 大学部
    
    // 初中部
    List<Student> lst1 = new ArrayList<>();
    lst1.add(new Student("张晓东", 90f));
    lst1.add(new Student("张晓西", 75f));
    List<Student> lst2 = new ArrayList<>();
    lst2.add(new Student("张晓北", 80f));
    lst2.add(new Student("张晓南", 82f));
    m1.put("T110", lst1);
    m1.put("T272", lst2);
    map1.put("初中部", m1);
    
    // 高中部
    List<Student> lst3 = new ArrayList<>();
    lst3.add(new Student("张三", 90f));
    lst3.add(new Student("李四", 100f));
    List<Student> lst4 = new ArrayList<>();
    lst4.add(new Student("王五", 70f));
    lst4.add(new Student("小六", 100f));
    List<Student> lst5 = new ArrayList<>();
    lst5.add(new Student("小八 ", 70f));
    lst5.add(new Student("小九", 100f));
    m2.put("T206", lst3);
    m2.put("T222", lst4);
    m2.put("T272", lst5);
    map1.put("高中部", m2);
    
    // 大学部
    List<Student> lst6 = new ArrayList<>();
    lst6.add(new Student("可乐", 60f));
    lst6.add(new Student("雪碧", 50f));
    List<Student> lst7 = new ArrayList<>();
    lst7.add(new Student("哇哈哈", 90f));
    lst7.add(new Student("老干妈", 80f));
    m3.put("T230", lst6);
    m3.put("T231", lst7);
    map1.put("大学部", m3);
    Set<String> ks = map1.keySet();
    
    for (String str : ks) {
      Map<String, List<Student>> mp = map1.get(str);
      Set<Entry<String, List<Student>>> sy = mp.entrySet();
      for (Entry<String, List<Student>> sr : sy) {
        String key = sr.getKey();
        List<Student> val = sr.getValue();
        Iterator<Student> it5 = val.iterator();
        while (it5.hasNext()) {
          System.out.println(it5.next() + "," + key + "," + str);
        }
      }
    }

 1.2 遍历（代码如下）

        1.2.1 先取出保存所有键的Set,再遍历Set即可(2种)

        1.2.2 先取出保存所有Entry的Set,再遍历此Set即可

package com.zking.Collection03.util;

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

public class Demo1 {
  public static void main(String[] args) {
    //1、Collection接口：集合框架的顶级接口，是List和Set的父接口，不是Map的父接口
    //Map特点：
    //1）无序
    //2）以键值对的形式存储数据，键唯一，值不唯一
    //3）没有继承Collection接口
    Map<String, Object> map = new HashMap<>();
    map.put("name", "zs");
    map.put("sex", "boy");
    map.put("age", "21");
    //问题：如何键相同，值如何处理
    map.put("name", "ww");
    map.put("score", 21);
    System.out.println(map);
    
    //2、遍历方式（三种）
    //1）获取所有的keys
    System.out.println("-------------1）获取所有的keys----------");
    Set<String> keys = map.keySet();
    for(String key : keys) {
      System.out.println(key);
    }
    //2）获取所有的values
    System.out.println("------------------2）获取所有的values-------------------");
    Collection<Object> values = map.values();
    for(Object object : values) {
      System.out.println(object);
    }
    //3)获取所有的键值对
    System.out.println("------------3)获取所有的键值对-------------");
    Set<Entry<String, Object>> entrySet = map.entrySet();
    for(Entry<String, Object> entry : entrySet) {
      System.out.println(entry.getKey()+"="+entry.getValue());
    }
    System.out.println("---------3)获取所有的键值对2-----------");
    entrySet.forEach(entry->{
      System.out.println(entry.getKey()+"="+entry.getValue());
    });
  }

}

2.HashMap与Hashtable之间的区别（重点）

2.1同步(synchronized)既排队  线程安全的     hashtable
     异步                                      线程非安全的   hashmap

 2.2.Hashtable 默认的初始大小为 11，之后每次扩充，容量变为原来的 2n+1。HashMap 默认的初始化大小为 16。之后每次扩充，容量变为原来的 2 倍。

2.3.Hashtable的方法是同步的，而HashMap的方法不是。

 2.4.只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。

3. 其它（地狱回调）

        3.1 Collections：工具类，提供一组静态方法操作Collection集合
        3.2 Arrays：工具类，提供了一组静态方法操作数组

package com.zking.Collection03.util;

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Demo2 {
  public static void main(String[] args) {
    //TreeMap
    //1)按照Key排序
    //1.1默认按照Key的升序排序
    //1.2通过Comparator.reverseOrder()方法实现key的降序排序
    Map<String,Object> map = new TreeMap<>(Comparator.reverseOrder());
    map.put("zs", 100);
    map.put("ls", 80);
    map.put("ww", 110);
    System.out.println(map);
    //2）按照Value排序
    //获取键值对
    Set<Entry<String, Object>> entrySet = map.entrySet();
    //将键值对转换成List集合
    List<Entry<String,Object>> lst = new ArrayList(entrySet);
    //使用Collections帮助类进行排序
    //面试题：Collection和Collections的区别？
    //Colection:集合框架顶级接口
    //Collection:集合框架帮助类
    Collections.sort(lst,new Comparator<Entry<String, Object>>() {

      @Override
      public int compare(Entry<String, Object> o1, Entry<String, Object> o2) {
      /*public int compare(Entry<String, Student> o1, Entry<String, Object> o2) {
        // TODO Auto-generated method stub
        Student s1 = o1.getValue();
        Student s2 = o2.getValue();
        s1.getSid()-s2.getSid();*/
        return o1.getValue().hashCode()-o2.getValue().hashCode();
      }
    });
    lst.forEach(System.out::println);
    
    //将数组转换成集合
    String str = "1,2,3,4,5,6";
    String[] split = str.split(",");
    List<String> asList = Arrays.asList(split);
    System.out.println(asList);
    
    String ss = Arrays.toString(split);
    System.out.println(ss);
    
  }

}

最后给大家分享一个题目，很简单，与上面的代码差不多，不一样的是我的值放的是对象

//四.定义一个Map集合,key和value不规定类型，针对集合中的元素进行排序
    Map<String,Student> mm = new TreeMap<>(Comparator.reverseOrder());
    mm.put("zs",new Student("zs",100f));
    mm.put("ls",new Student("ls",80f));
    mm.put("ww",new Student("ww",70f));
    mm.put("zl",new Student("zl",90f));
    System.out.println(mm);

以上就是今天的分享，请各位多多指教！

下期给大家分享→1.什么是DTD？2.什么是XML？