Map集合框架！

Map集合框架！

图片了解：

一、集合框架Map介绍

• 方法归类：map集合中存放的都是一组组映射关系 key=value
  （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()

  具体代码：

package com.cjq.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;/**
 * map集合中三个特别的方法
 * 1、put 
 * (1).具有新增的用途;
 * (2).修改的用途（当容器中已经存在了的key，再次存放，那么会覆盖原有的key所对应的值value）;
 * (3).调用此方法，可以获取原来的key对应的值.
 * 
 * 2、entrySet 
 * 3、keySet
 *   [entrySet、 keySet这两个方法是map集合中所特有的遍历方法.]
 * 
 * HashMap是无序的，集合的底层是set集合做的
 *  
 *   HashMap 数据结构 哈希表
 *   TreeMap 数据结构 二叉树
 *    能够进行自然排序以及比较器排序
 *  
 * map集合是不继承collection接口的
 *   这也就意味着它不具备迭代器的方法
 * 
 * @author cjq
 *
 */public class MapDemo {
 public static void main(String[] args) {
  Map<Object,Object> map=new HashMap<>();
  map.put("张三",21);
  map.put("李四",28);
  map.put("王五",31);
  map.put("赵六",22);
  map.put("小明",21);
  Object age=map.put("王五",31);
  System.out.println(age);
  System.out.println(map);
  
//  Set<Entry<Object, Object>> entrySet = map.entrySet();
//  for (Entry<Object, Object> entry : entrySet) {
//   System.out.println("key:"+entry.getKey()+"value:"+entry.getValue());
//  }
  
  Set<Object> keySet = map.keySet();
  for (Object key : keySet) {
   System.out.println("key:"+key + ",value:"+map.get(key));
  }  
 }
 }

运行结果如下：

小结：
Map Hashtable：底层是哈希表数据结构，不可以存入null键null值，该集合石线程同步的，jdk1.0，效率低 ；
HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。将Hashtable替代；jdk1.2，效率高 ；
TreeMap：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序

注意：
添加元素时，如果键已经在集合中存在，那么后添加的值会覆盖原来的值，并且put方法会将原有的值返回

二、集合框架Map应用
应用一：
1、将学生作为键，地址作为值进行存储，名字年龄相同则被认定为一个人，最后输出
2、最后按年龄进行排序
3、需求改变、按姓名进行排序
具体代码如下：

package com.cjq.map;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Set;
import java.util.TreeMap;
/**
 * 思路：
 *   a、封装学生类
 *   b、判重复（hashCode/equals）
 *   c、打印
 * 2、最后按年龄进行排序 
 *   需要让学生类自身具备比较性，实现Comparable接口
 * 3、需求改变、按姓名进行排序
 *   改变的代码是不可取的，我们需要新增个比较器来完成需求
 *   实现java.util.comparator
 * 
 * @author cjq
 *  */public class HashMapDemo {
 public static void main(String[] args) {
//  TreeMap map=new TreeMap<>();
  TreeMap map=new TreeMap<>(new StuNameComp());
  map.put(new Student("张三",21),"上海");
  map.put(new Student("李四",28),"北京");
  map.put(new Student("王五",31),"南京");
  map.put(new Student("赵六",22),"广州");
  map.put(new Student("张三",21),"苏州");
  map.put(new Student("小明",25),"长沙");
  map.put(new Student("张三",21),"苏州");
  
  Set keySet = map.keySet();
  for (Object key : keySet) {
   System.out.println(key);
  }
 }
}class StuNameComp implements Comparator<Student>{ @Override
 public int compare(Student o1, Student o2) {
  int num=o1.getName().compareTo(o2.getName());
  if(num==0) {
   return o1.getAge()-o2.getAge();
  }
  return num;
 }
}class Student implements Comparable<Student>{
 private String name;
 private int age;
 
 public Student() {
  super();
 }
 public Student(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 } @Override
 public String toString() {
  return "Student [name=" + name + ", age=" + age + "]";
 }
 
 @Override
 public int hashCode() {
  return this.name.hashCode()+this.age;
 }
 
 @Override
 public boolean equals(Object obj) {
  Student stu=(Student) obj; 
  return this.name.equals(stu.name) && this.age==stu.age;
 }
 
 @Override
 public int compareTo(Student o) {
  int num = this.age - o.age;
  if(num == 0) {
   this.name.compareTo(o.name);
  }
  return num;
 }
 
}

• 按年龄进行排序 ：

• 按姓名进行排序：
  
  应用二：
  统计字符串中字符出现次数，
  并按次数排序

具体代码如下：

package com.cjq.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;/**
 * 统计字符串中字符出现次数
 * 1、分析结果得出结论：我们需要将字符a-z当作键key，将次数作为值value，
 *   也就是说我们需要创建一个map集合来做这些事情
 * 2、需要将待处理的字符串转成字符数组，以便于获取map集合的key
 * 3、如果该字符（e）第一出现的时候，就给a对应key映射值value赋值为1
 *   如果说该字符再次出现，那么就是value+1；
 * 4、打印出e(4)i(2)...y(1)格式串
 *   意味着需要对key进行排序
 * @author cjq
 *
 */
public class TreeMapDemo {
 
 public static void main(String[] args) {
  String str = "qwerrrertyupoiiuqeeq";
//  Map<Character, Integer> map = new HashMap<>();
  Map<Character, Integer> map = new TreeMap<>();
  char[] charArray = str.toCharArray();
  for (char c : charArray) {
   Integer obj = map.get(c);
   if(obj == null) {//字符第一次出现
    map.put(c, 1);
   }else {//不止第一次出现
    map.put(c, ++obj);
   }
  }
  
  
/*
 *   String,StringBuffer,StringBuilder三者的区别？
 *   String a = new String("abc");
 * 
 *   String b = "abc";
 *   a+="de";
 * 
 *   StringBuffer sb1 = new StringBuffer("abc");
 *   StringBuilder sb2 = new StringBuilder("abc");
 *   sb1.append("de");
 *   sb2.append("de");
 * 
 *   StringBuffer与StringBuilder的区别？
 *   StringBuffer 同步 安全
 *   StringBuilder 异步 不安全
 * 
 */
  StringBuilder sb = new StringBuilder();
  Set<Entry<Character, Integer>> entrySet = map.entrySet();
  for (Entry<Character, Integer> entry : entrySet) {
   sb.append(entry.getKey()+"("+entry.getValue()+")");
  }
  System.out.println(sb);
 }}

运行结果如下：

三、集合框架工具类（Collections、Arrays）
简介：

1. Arrays:里面都是静态方法，直接用来对各种集合进行操作的公有方法。
2. Collections:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

主要有：

1、asList将数组变成list集合：

       static <> List<T> asList(T... a)

返回一个受指定数组支持的固定大小的列表。
2、二分方查找：
基本数据类型：byte、short、int、double、float、long、char
可以获得指定的值或者对象。
3、复制指定的数组：
基本数据类型：boolean、byte、short、int、double、float、long、char
复制指定的数组，截取或用 0或false或null填充（如有必要），以使副本具有指定的长度。
4、将指定原数组范围复制到新数组。
5、比较两个数组中的内容是否相同。
static boolean equals(基本数据类型[] a, 基本数据类型[] a2)
如果两个指定的基本数据类型数组彼此相等，则返回 true。
static boolean deepEquals(Object[] a1, Object[] a2)
如果两个指定数组彼此是深层相等 的，则返回 true。
6、返回数组的哈希值。
7、以字符串形式返回数组内容。
8、用内容替换数组指定索引的内容、反转、替换 、交换
9、排序：
根据元素的自然顺序对指定对象数组按升序进行排序。
static void sort(Object[] a, int fromIndex, int toIndex)
根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static void sort(基本数据类型[] a)
对指定的基本数据类型数组按数字升序进行排序。
static void sort(基本数据类型[] a, int fromIndex, int toIndex)
对指定基本数据类型数组的指定范围按数字升序进行排序。
static void sort(T[] a, Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组进行排序。
static void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
10.逆转比较器
11、Collections:里面都是静态方法，直接用来对各种集合进行操作的公有方法。