Java零基础学习（Map集合 HashMap和Hashtable的区别）

本文主要是介绍Java零基础学习（Map集合 HashMap和Hashtable的区别），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java零基础学习（Map集合 HashMap和Hashtable的区别）

• Map集合概述和特点

  1.需求：根据学号获取学生姓名
  	这时候就需要一一对应的关系，就引出了Map集合
  2.Map集合概述：
  	将键映射到值的对象
  	一个映射不能包含重复的键，每个键最多只能映射到一个值
  3.Map接口和Collection接口的不同
  	Map是双列的，Collection是但列的
  	Map的键是唯一的，Collection的子体系Set是唯一的
  	Map集合的数据结构针对键有效，跟值无关，Collection集合数据结构是针对元素有效
  

  • Map集合的功能概述

  1.添加功能
  	V put(K key,V value):如果是第一次存储，就是直接存储元素，返回null，如果键不是第一次存在，就是用值把以前的值换掉，返回以前的值。
  2.删除功能
  	void clear():移除所有键值对元素
  	V remove(Object key):根据键删除键值对元素，并把值返回
  3.判断功能
  	boolean containsKey(Object key):判断集合是够包含指定的键
  	boolean containsValue(Object value):判断集合是否包含指定的值
  	boolean isEmpty():判断集合是否为空
  4.获取功能
  	Set<Map.Entry<K,V>> entrySet():返回一个键值对的Set集合
  	V get(Object key):根据键获取值
  	Set<K> keySet():获取集合中所有键的集合
  	Collection<V> values():获取集合中所有值的集合
  5.长度功能
  	int size():返回集合中键值对的对数
  

  • 基本功能测试

  public class MyTest {
      public static void main(String[] args) {
          HashMap<Integer, String> strs = new HashMap<>();
          //当键不存在的时候存储就是直接存储，当键已经存在就是将以前的值换掉
          strs.put(1,"周一");
          strs.put(2,"周二");
          strs.put(3,"周三");
          strs.put(4,"周四");
          strs.put(5,"周五");
          System.out.println(strs);
          String a = strs.put(1, "周二");
          System.out.println(a);
          //根据键删除键值对元素，并且将值返回
          String b = strs.remove(2);
          System.out.println(b);
          //清空集合中的所有元素
          strs.clear();
          System.out.println(strs);
      }
  }
  

  • Map集合的遍历（键找值）

  import java.util.HashMap;
  import java.util.Map;
  import java.util.Set;
  
  public class MyTest {
      public static void main(String[] args) {
          Map<Integer, String> strs = new HashMap<>();
          //当键不存在的时候存储就是直接存储，当键已经存在就是将以前的值换掉
          strs.put(1,"周一");
          strs.put(2,"周二");
          strs.put(3,"周三");
          strs.put(4,"周四");
          strs.put(5,"周五");
          Set<Integer> integers = strs.keySet();
          for(Integer integer:integers){
              String s = strs.get(integer);
              System.out.println(s);
          }
      }
  }
  

  • Map集合的遍历（键值对对象找键和值）

  import java.util.HashMap;
  import java.util.Map;
  import java.util.Set;
  
  public class MyTest {
      public static void main(String[] args) {
          Map<Integer, String> strs = new HashMap<>();
          //当键不存在的时候存储就是直接存储，当键已经存在就是将以前的值换掉
          strs.put(1,"周一");
          strs.put(2,"周二");
          strs.put(3,"周三");
          strs.put(4,"周四");
          strs.put(5,"周五");
          Set<Map.Entry<Integer, String>> entries = strs.entrySet();
          for (Map.Entry<Integer, String> entry : entries) {
              Integer key = entry.getKey();
              String value = entry.getValue();
              System.out.println(key+"="+value);
          }
      }
  }
  

  • Map集合遍历的两种方式比较图解

  

• HashMap集合

  • HashMap集合键是String值是Sting的案例

  import java.util.HashMap;
  
  public class MyTest {
      public static void main(String[] args) {
          HashMap<String, String> strs = new HashMap<>();
          //允许插入null键和null值
          strs.put("杨过","小龙女");
          strs.put("猪八戒","嫦娥");
          strs.put("郭靖","黄蓉");
          strs.put("乔峰","阿朱");
          strs.put(null,null);
          System.out.println(strs);
      }
  }
  	打印出来是无序的
  

  • HashMap集合键是String值是Student的案例

  import java.util.HashMap;
  
  public class MyTest {
      public static void main(String[] args) {
          HashMap<String, Student> stus = new HashMap<>();
          stus.put("班长",new Student(15,"小明"));
          stus.put("副班长",new Student(15,"李亮"));
          stus.put("学习委员",new Student(15,"刘强"));
          stus.put("文艺委员",new Student(15,"小红"));
          stus.put("劳动委员",new Student(15,"郝建"));
          stus.put("生活委员",new Student(15,"刘红"));
          System.out.println(stus);
      }
  }
  	自定义一个Student类，然后当做值的参数
  

  • HashMap集合键是Student值是String的案例

  import java.util.HashMap;
  
  public class MyTsest2 {
      public static void main(String[] args) {
          HashMap<Student, String> stus = new HashMap<>();
          stus.put(new Student(15,"小明"),"班长");
          stus.put(new Student(15,"李亮"),"副班长");
          stus.put(new Student(15,"刘强"),"学习委员");
          stus.put(new Student(15,"小红"),"文艺委员");
          stus.put(new Student(15,"郝建"),"劳动委员");
          stus.put(new Student(15,"刘红"),"生活委员");
          System.out.println(stus);
      }
  }
  
  注意：Student类要重写hashCode()方法和equals()方法来保证键的唯一性
  

• LinkedHashMap概述

  1.概述：Map接口的哈希表和链接列表实现，具有可预知的迭代顺序
  2.特点：底层的数据结构是链表好哈希表 元素有序并且唯一
  	元素的有序性有链表数据结构保证，唯一性有哈希表数据结构保证
  	Map集合的数据结构只和键有关
  

• TreeMap集合概述

  1.概述：
  	键的数据结构是红黑树结构的，可以保证键的排序和唯一性
  	排序分为自然排序和比较器排序
  	线程是不安全的效率比较高
  2.演示
  	TreeMap集合键是Integer值是String的案例
  import java.util.TreeMap;
  
  public class MyTest {
      public static void main(String[] args) {
          TreeMap<Integer, String> strs = new TreeMap<>();
          //键是排序的而且是唯一的
          strs.put(12,"小明");
          strs.put(15,"李雷");
          strs.put(14,"李华");
          strs.put(11,"刘亮");
          strs.put(18,"张三");
          strs.put(13,"李四");
  
          System.out.println(strs);
      }
  }
  

  • TreeMap集合键是Student值是String的案例

  import java.util.TreeMap;
  
  public class MyTest {
      public static void main(String[] args) {
          TreeMap<Student, String> stub = new TreeMap<>();
          stub.put(new Student(17,"小明"),"班长");
          stub.put(new Student(15,"李亮"),"副班长");
          stub.put(new Student(18,"刘强"),"学习委员");
          stub.put(new Student(13,"小红"),"文艺委员");
          stub.put(new Student(12,"郝建"),"劳动委员");
          stub.put(new Student(10,"刘红"),"生活委员");
          System.out.println(stub);
      }
  }
  Student类重写equals()和hashCode()方法，实现Comparable接口重写compareTo()方法，按照年龄排序。
  

  • 统计字符串中每一个字符出现的次数

  统计字符串中每个字符出现的次数
  	"aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
  	
  import java.util.HashMap;
  public class MyTest {
      public static void main(String[] args) {
      	//将字符串存入StringBuilder类中，然后创建一个Map集合
          StringBuilder sb = new StringBuilder("aababcabcdabcde");
          HashMap<Character, Integer> ss = new HashMap<>();
          //开始对出现过的字符进行统计，统计过之后就删除掉，以免重复
          for (int i=0;i<sb.length();i++){
              int a=1;
              for (int j=i+1;j<sb.length();j++){
                  if (sb.charAt(i)==sb.charAt(j)){
                      a++;
                      sb.deleteCharAt(j);
                  }
              }
              ss.put(sb.charAt(i),a);
          }
          System.out.println(ss);
      }
  }
  

  • 集合嵌套之HashMap嵌套HashMap

  A:案例演示
  	集合嵌套之HashMap嵌套HashMap
  			基础班
  					张三		20
  					李四		22
  			就业班
  					王五		21
  					赵六		23
  现在有两个班级，一个是基础班，一个是就业班，但是每个班级又有不同的学生，这时候就需要用集合的嵌套将他们放到集合中
  import java.util.HashMap;
  import java.util.Set;
  public class MyTest {
      public static void main(String[] args) {
          HashMap<String, HashMap<String, Integer>> aclass = new HashMap<>();
          HashMap<String, Integer> jc = new HashMap<>();
          HashMap<String, Integer> jy= new HashMap<>();
          Integer stu1 = jc.put("张三", 20);
          Integer stu2 = jc.put("李四", 22);
          Integer stu3 = jy.put("王五", 21);
          Integer stu4 = jy.put("赵六", 23);
          aclass.put("基础班",jc);
          aclass.put("就业班",jy);
          //遍历集合遍历两层集合，取出aclass的键集合，通过键集合得到值，再的到值的键集合，最终的到值的值；
          Set<String> strings = aclass.keySet();
          for (String string : strings) {
              System.out.println(string);
              HashMap<String, Integer> aclass1 = aclass.get(string);
              Set<String> strings1 = aclass1.keySet();
              for (String s : strings1) {
                  Integer integer = aclass1.get(s);
                  System.out.println("\t"+s+"\t"+integer);
              }
          }
      }
  }
  

  • HashMap和HashTable的区别

  HashMap：线程不安全，效率高，允许null值和null键
  HashTable：线程安全，效率低，不允许null值和null键
  

  • Collections工具类的概述和常见方法

  1.Collections类概述：针对集合操作的工具类
  2.Collections成员方法
  	public static <T> void sort(List<T> list):排序,默认按照自然顺序
  	public static <T> int binarySearch(List<?> list,T key):二分查找
  	public static <T> T max(Collection<?> coll):获取最大值
  	public static void reverse(List<?> list):反转
  	public static void shuffle(List<?> list):随机置换
  

这篇关于Java零基础学习（Map集合 HashMap和Hashtable的区别）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！