Map集合解析及运用

Map简介

Map 是一种无序的键值对的集合。Map 是通过 key 来对数据，操作的，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组那样迭代它。不过，他的底层原理是Set，所以Map 也是无序的，我们无法决定它的返回顺序， Map 是使用 hash 表来实现的。

Map常用方法

1，增加方法

put(K key, V value)
首先实例化一个Map集合，HashMap<>里第一个值写的是这个Map集合放的键的数据类型，第二个是值的数据类型，注意的是这两个都一定要使用包装类或者引用数据类型。
之后，使用put()方法对应实例化的Map数据类型加入进去。

HashMap<String, Object> map = new HashMap<>();
  	map.put("java02", 2);
  	map.put("java01", 1);
  	map.put("java03", 3);
  	map.put("java04", 4);

请注意：若加入的键相同，则会把原来的值覆盖！
若想取被覆盖的值，如下就可以了 ↓↓↓↓↓↓

Object put = map.put("java04",12);

2，删除方法

remove(Object key)
在参数里面放入你要删除的键就可删除。

3，判断

containsKey(Object key)
判断是否Map集合是否包含这个键，在参数里面输入键就可以了
containsValue(Object value)
判断是否Map集合是否包含这个值，在参数里面输入值就可以了

isEmpty()
判断此Map集合是否为空。返回boolean类型

4，获取

get(Object key)
通过键取值，返回object类型。
size()
返回此Map的个数。

5，获取-遍历方法

 // 遍历方法一 hashmap entrySet() 遍历
  System.out.println("方法一");
  Iterator it = tempMap.entrySet().iterator();
  while (it.hasNext()) {
   Map.Entry entry = (Map.Entry) it.next();
   Object key = entry.getKey();
   Object value = entry.getValue();
   System.out.println("key=" + key + " value=" + value);
  }
  System.out.println("");
  // JDK1.5中,应用新特性For-Each循环
  // 遍历方法二
  System.out.println("方法二");
  for (Map.Entry<String, Integer> entry : tempMap.entrySet()) {
   String key = entry.getKey().toString();
   String value = entry.getValue().toString();
   System.out.println("key=" + key + " value=" + value);
  }
  System.out.println("");

  // 遍历方法三 hashmap keySet() 遍历
  System.out.println("方法三");
  for (Iterator i = tempMap.keySet().iterator(); i.hasNext();) {
   Object obj = i.next();
   System.out.println(obj);// 循环输出key
   System.out.println("key=" + obj + " value=" + tempMap.get(obj));
  }
  for (Iterator i = tempMap.values().iterator(); i.hasNext();) {
   Object obj = i.next();
   System.out.println(obj);// 循环输出value
  }
  System.out.println("");

  // 遍历方法四 treemap keySet()遍历
  System.out.println("方法四");
  for (Object o : tempMap.keySet()) {
   System.out.println("key=" + o + " value=" + tempMap.get(o));
  }
  System.out.println("11111");

  // java如何遍历Map <String, ArrayList> map = new HashMap <String,
  // ArrayList>();
  System.out
    .println("java  遍历Map <String, ArrayList> map = new HashMap

<String, ArrayList>();");
  Map<String, ArrayList> map = new HashMap<String, ArrayList>();
  Set<String> keys = map.keySet();
  Iterator<String> iterator = keys.iterator();
  while (iterator.hasNext()) {
   String key = iterator.next();
   ArrayList arrayList = map.get(key);
   for (Object o : arrayList) {
    System.out.println(o + "遍历过程");
   }
  }
  System.out.println("2222");

//遍历方法五
  Map<String, List> mapList = new HashMap<String, List>();
  for (Map.Entry entry : mapList.entrySet()) {
   String key = entry.getKey().toString();
   List<String> values = (List) entry.getValue();
   for (String value : values) {
    System.out.println(key + " --> " + value);
   }
  }
 }
}

方法运用

1，将学生作为键，地址作为值进行存储，名字年龄相同则被认定为一个人，最后按年龄进行排序

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapDemo {
	
		public static void main(String[] args) {
			//在这使用TreeMap是因为他的底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序
			Map<Student, String> map = new TreeMap<>(new StuComp());
			map.put(new Student("goudan", 15), "guangzhou");
			map.put(new Student("dabao", 12), "beijing");
			map.put(new Student("xiaohai", 13), "shanghai");
			map.put(new Student("liubao", 12), "nanjing");
			map.put(new Student("goudan", 15), "guangzhou");
			//实例化entrsET用来遍历
			Set<Entry<Student, String>> entrySet = map.entrySet();
			//遍历
			for (Entry<Student, String> entry : entrySet) {
				System.out.println(entry.getKey()+":"+entry.getValue());
			}
			
		}
	}
//Student类实现Comparable接口，实现compareTo排序方法
	class Student implements Comparable<Student>{
		private String name;
		private int 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;
		}
		
		public Student() {}
		public Student(String name, int age) {
			this.name = name;
			this.age = age;
		}
		@Override
		public String toString() {
			return "Student [name=" + name + ", age=" + age + "]";
		}
		
		//判断是否重复方法hashCode()和 equals()
		@Override
		public int hashCode() {
			return this.getName().hashCode()+this.getAge()*29;
		}
		
		@Override
		public boolean equals(Object obj) {
			Student stu = (Student)obj;
			return this.getAge()==stu.getAge()&&this.getName().equals(stu.getName());
		}
		//排序方法 compareTo()
		@Override
		public int compareTo(Student o) {
			int sum = this.getAge()-o.getAge();
			if(sum==0) {
				return this.getName().compareTo(o.getName());
			}
			return sum;
		}
	}	
}

2，统计字符串中字符出现次数,按次数排序

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;



public class HashMapDemo {
	public static void main(String[] args) {
		//随机自定义一个字符串
		String str = "ajdakjsgdockmzxnfqgewqwyijsabkjda";
		//调用方法
		str = cishu(str);
		System.out.println(str);
	}
	
	/**
	 * 字符出现次数
	 * @param str
	 * @return
	 */
	private static String cishu(String str) {
	//把字符串变为字符数组
		char[] charArray = str.toCharArray();
		//实例化遍历对象
		Map<Character, Integer> map = new TreeMap<>();
		for (char c : charArray) {
			Integer value = map.get(c);
			//如果是第一次发现,因为是null使用必须判断然后变为1
			if(value==null) {
				map.put(c, 1);
			}else {
			//如果不是第一次发现则值加1
				map.put(c, ++value);
			}
		}
		//实例化StringBuffer是因为使用append()方法，这样节省空间，不必开辟新空间占用资源。
		StringBuffer sb = new StringBuffer();
		//把键值遍历加进去
		for (Map.Entry<Character, Integer> c : map.entrySet()) {
			sb.append(c.getKey()+"("+c.getValue()+")");
		}
		//把StringBuffer变为String传回去
		return sb.toString();
	}
}