集合框架之Map

2024-03-04 16:34:53

一，Map的讲解
（1）Map接口：Map中的集合，元素是成对存在的。每个元素由键和值两部分组成（键值对），通过键可以找到对应的值。Map中的集合成为双列集合。需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。Map集合中存放的都是一组映射关系 ,都是一个键对一个值。
（2）Map的底层结构是set
(3) Map中常用的集合为HashMap集合，TreeMap集合。
（4）Map的方法：
1、增加put(K key, V value) putAll(Map<? extends K,? extends V> m)
2、删除clear() remove(Object key)
3、判断containsKey(Object key) containsValue(Object value) isEmpty()
4、获取 get(Object key)size()values() 遍历时所要用到的 entrySet() keySet()
下面是有Put , keySet ，entryset 的方法代码：

package com.zmy.Map; import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;/**
 * 初识map
 * put  增加
 * put 的基本特点：1，往集合容器中添加键值对映射关系
 *                2，当集合中存在该键的映射关系，后来的映射关系会覆盖前面的映射关系。
 *                3，put有返回值，会返回上一个映射关系的对应值
 * ，
 * 
 * keySet 键不能重复，键就是set集合  获取
 * entryset   获取
 * 
 * 多表联查用 list<map>
 * 
 * @author Admin
 *
 */
public class MapDemo {
 public static void main(String[] args) {
  Map<String, String> map=new HashMap<>();
  map.put("zs", "12");
  map.put("ls", "22");
  map.put("ww", "23");
  map.put("mazi", "11");
//  String put = map.put("zs", "34"); //输出是之前覆盖的对应值
//  System.out.println(put);

  /*Set<String> keySet = map.keySet(); //获取
  for (String key: keySet) {
   System.out.println(key+":"+map.get(key));
  }
  */

  //拿到所有映射关系
  Set<Entry<String, String>> entrySet = map.entrySet();
  for (Entry<String, String> entry : entrySet) {
   System.out.println(entry+":" +entry.getKey());
  }

  System.out.println(map);
 }}

二，HashMap集合**
(1) HashMap集合它的底层数据结构是哈希表,允许使用null值和null键，
该集合是不同步的。将Hashtable替代效率高。
（2）HashMap集合的实现：

  Map<String, String> map=new HashMap<>();

三，TreeMap集合
（1）底层数据结构是二叉树，线程不同步，可以用于给Map集合中的键进行排序
（2）TreeMap集合的实现：

TreeMap< Student, String> hm=new TreeMap<>(new Stucomp()); //排序必须用二叉树结构来排序。

四，应用一（HashMap）
需求：1、将学生作为键，地址作为值进行存储，名字年龄相同则被认定为一个人，最后输出。
思路：
必须调用hashCode()和equals方法；

 @Override
 public int hashCode() {
  // TODO Auto-generated method stub
  return this.getName().hashCode()+this.getAge();
 }

 @Override
  public boolean equals(Object obj) {
   // TODO Auto-generated method stub
  if(obj instanceof Student) {
   Student stu=(Student)obj;
   return this.getName().equals(stu.getName()) && this.getAge()==stu.getAge();
  }
   return false;
  }

2、最后按年龄进行排序（TreeMap）
思路：
实现TreeMap
然后还有实现Comparable接口
还有实现compareTo方法。

class Student implements Comparable<Student>{
@Override
 public int compareTo(Student o) {
  // TODO Auto-generated method stub
  int num=this.getAge() -o.getAge();
  if(num==0) {
   return this.getName().compareTo(o.getName());
  }


  return num;
 }
}

3、需求改变、按姓名进行排序（TreeMap）
思路：
先定义一个比较器，实现实现Comparator
在实现TreeMap< Student, String> hm=new TreeMap<>(new Stucomp())后面要new 一个比较器。

//Stucomp是比较器 class Stucomp implements Comparator<Student>{  
 @Override
 public int compare(Student o1, Student o2) {
  // TODO Auto-generated method stub
       int num =o1.getName().compareTo(o2.getName());
       if(num==0) {
        return o1.getAge() - o2.getAge();
       }
  return num;
 }

五，应用二
需求：
1，统计字符串中字符出现次数
2，按次数排序
比如：ssfgffykhhgklluyufvfrdddtteesekh
我们先来分析一下：
1，字符是唯一的，可以将其Map集合的key,次数就是map集合的value.
2.将指定的字符串装到一个容器中筛选,将字符串转成一个字符数组。
3.当字符第一次出现的时候，意味着在map集合中找不到对应的值，就给它赋值为1
当字符第二次出现的时候，意味着map集合中存在对应的值，给它对应的值加一，
代码如下：

import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;/**
 *** 应用二：  统计字符串中字符出现次数**

  按次数排序

 assfgffykhhaasklluyufvfrdddtteesekh  
  1.统计字符出现的次数。
  2.从a到z进行统计

  分析：
  1，字符是唯一的，可以将其Map集合的key,次数就是map集合的value.
  2.将指定的字符串装到一个容器中筛选,将字符串转成一个字符数组。
  3.当字符第一次出现的时候，意味着在map集合中找不到对应的值 ，就给它赋值为
     当字符第二次出现的时候，意味着map集合中存在对应的值，给它对应的值加一，

 * @author Admin
 *
 */public class HashMapDemo {
 public static void main(String[] args) {
  String s="  assfgffykhhaasklluyufvfrdddtteesekh  ";
          getRepeatTimes(s);

 } /**
  * 统计次数的方法
  * @param s
  */
 private static void getRepeatTimes(String s) {
  // TODO Auto-generated method stub
     char[] charArray = s.toCharArray();
     Map<Character,Integer> map=new TreeMap<>();
     for (char c : charArray) {
      Integer val=(Integer)map.get(c);
   if(val == null) {
    map.put(c,1);

   }else {
    map.put(c, ++val);
   }
   //i++先运算，  ++i先运算后赋值
     }

     //字符串容器  
     StringBuffer  sb=new StringBuffer();
    Set<Entry<Character, Integer>> entrySet = map.entrySet();
    for (Entry<Character, Integer> entry : entrySet) {
  sb.append(entry.getKey()+"("+entry.getValue()+")");
 }
    System.out.println(sb.toString());
 }}

结果如下：

六，集合框架工具类（Collections、Arrays）
（1）Collections的方法：
1， sort(List list) ; 它是按自然排序。
2， Collections.reverseOrder(new Stucomp() ）强行把自然排序的顺序逆转了，后面new 了一个比较器。它可以加入比较器，按自定义比较方法逆转。

（2）Arrays的方法：
1，Arrays.sert（）;排序
2, Arrays.equals() 如果两个数组相等的话，就可以用这个判断，两个数组包含相同数量的元素,并且两个数组中的所有相应元素都是相等的，

七集合框架课外拓展（增强for循环、可变参数、静态导入）
(1) 增加for循环
概念：其实它就是我们的 foreach 循环。
作用：简化迭代器的书写格式（其实它底层基于迭代器的）。

//三种遍历方式   
 
   for (Object obj : al) {  
    System.out.println(obj);  
    }    
   for (int i = 0; i < al.size(); i++) {  
    System.out.println(al.get(i)); 
     }      

    //迭代器  
   Iterator it = ll.iterator();
  while(it.hasNext()) {
  System.out.println(it.next());
  }
 }

（2）可变参数
概念：我们写一个方法然后我们填写几个参数，如果觉得还想添加一些参数，我们可以用可变参数；
作用：我们在方法定义了可变的参数后，我们可以像操作数组一样操作该参数；因为可变参数，会自动变化
注意：1，传多种参数时需要将可变参数写在最后。
2，每一个方法中只能有一个可变参数。

（3）静态导入
概念：1，如果要使用静态成员（方法和变量）我们必须提供一个静态成员的类
2，使用静态导入类的静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给他们的类
静态导入方法的语法：精确导入方式：import static 包名，类或者接口。静态成员名：

import java.util.ArrayList;

码农公寓

相关文章