J2EE基础之map集合框架

目录

一、map集合框架特点

二、遍历方式

三、常用实现类HashMap

四、泛型

五、集合框架工具类( Collections和 Arrays )

---

等等先别急，先了解一下什么是Map集合？

Map是用于保存具有映射关系的数据，Map集合里保存着两组值，一组用于保存Map的ley，另一组保存着Map的value。

图解

 

一、map集合框架特点是什么？

键值对

Map是一种依照键（key）存储元素的容器，键（key）很像下标，在List中下标是整数。在Map中键（key）可以使任意类型的对象。Map中不能有重复的键（Key），每个键（key）都有一个对应的值（value）。

一个键（key）和它对应的值构成map集合中的一个元素。

Map中的元素是两个对象，一个对象作为键，一个对象作为值。键不可以重复，但是值可以重复。

Map存储元素使用put方法，而Collection使用add方法

Map集合没有直接取出元素的方法，而是先转成Set集合。

接下来看一下案例来更深刻的了解一下叭~

Map<String,Integer> map=new HashMap<>();
//		V put(K key,V value);

		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		map.put("d", 4);
		System.out.println(map);
    //  移除
		Object remove = map.remove("b");
		System.out.println(remove);
		System.out.println(map);
		//修改 也是调用put方法
		map.put("c", 32);
		System.out.println(map);
		
		//查询
		System.out.println(map.get("c"));

分别打印出的结果为： 

 二、遍历方式有哪些？

  拿到键，再拿值
  拿到映射关系，键值都有了

第一种方式:

使用keySet

将Map转成Set集合（keySet()）

比如查询所有：

//查询所有
		//1、先拿到map集合中的所有key
		Set keys = map.keySet();
		for (Object key : keys) {
			System.out.println("键:"+key+";值:"+map.get(key));
		}

 结果打印为：

        

第二种方式:

使用entrySet

通过Map中的entrySet()方法获取存放Map.Entry<K,V>对象的Set集合。

Set<Map.Entry<K,V>> entrySet()

面向对象的思想将map集合中的键和值映射关系打包为一个对象，就是Map.Entry，

将该对象存入Set集合，Map.Entry是一个对象，那么该对象具备的getKey，getValue获得键和值。
 

看案例：

	//2、拿到映射关系	
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println("键："+entry.getKey()+";值"+entry.getValue());
		}

 结果打印为：

三、常用实现类HashMap

底层是哈希表数据结构，线程是不同步的，可以存入null键，null值。要保证键的唯一性，需要覆盖hashCode方法，和equals方法。

接下来看个案例，

假如给你一串字母，如何知道每一个字母出现的次数？又如何让它们按首字母进行排序呢？

这里先给到你一些实现思路：       

 /**
         * 实现思路：
         * 1、做字符串切割，得到一个字符数组
         * 2、接下来遍历，拿到单个字符
         * 3、如果该字符没有出现过，即value值为null，n那么该字符为key，值初始化为1
         * 4、如果已经出现过值，拿到原来的值+1
         * 
         * debugger的使用，调试代码
         * 1、打断点
         * 2、采用debug的方式运行程序
         * 3、进入调试窗口，左上方又一个step over调试箭头，快捷键F6
         * 4、接下来可以通过F6一步步调试当前程序对应的每一个变量值
         * 按照字符出现次数进行排序输出
         */

我们再一起来探究一下代码：

package com.ycx.map;

import java.util.HashMap;
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) {

		String s= "bdhehdqnuwqssjrdwjqdhllwdxcgmvsrnzyncb";
		
	char[] arr=s.toCharArray();
	Map<Character, Integer> map=new TreeMap<>();//HashMap<Character, Integer>()	TreeMap<>();
	for (char c : arr) {
		Integer value=map.get(c);
		if(value==null) {
			map.put(c, 1);
		}else {
			map.put(c, value+1);
		}
//		System.out.println(value);
	}
	
	Set<Entry<Character, Integer>> entrySet = map.entrySet();
	for (Entry<Character, Integer> entry : entrySet) {
		System.out.println(entry.getKey()+":"+entry.getValue());
	}
	}
	
}

打印结果为：

 这样结果就出来啦，不仅告诉了我们每一个字母的出现次数，并且还按照首字母排序啦~

但是如果又想按照字母出现的次数从小到大，要怎么做呢？

这里就要用到比较器排序了（Comparator）,

package com.ycx.map;

import java.util.HashMap;
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) {
		String s= "bdhehdqnuwqssjrdwjqdhllwdxcgmvsrnzyncb";
	
	char[] arr=s.toCharArray();
	Map<Character, Integer> map=new TreeMap<>();
	for (char c : arr) {
		Integer value=map.get(c);
		if(value==null) {
			map.put(c, 1);
		}else {
			map.put(c, value+1);
		}
	}
map.entrySet().stream().sorted((x,y)->x.getValue() - y.getValue()).forEach(System.out::println);//最关键

	}

}

 然后就成功运行处得到我们想要的结果：

 

 

课外延伸：

  * HashMap与HashTable的区别
 * 1、HashTable是线程安全的
 * 2、在jdk1.7以下的版本中，HashTable不能放null值

四、泛型 

泛型
     之前：不健壮代码，会在运行时才会把错误暴露出来
     之后：将潜在的问题暴露出来，早预防早治疗，
         将运营期出现的异常转换为编译期的错误

看案例：

package com.ycx.map;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Demo3 {
	public static void main(String[] args) {
		Set<Integer> set=new HashSet<>();
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(4);
		set.add(5);
		//set.add("a");
		for (Object obj : set) {
			if(Integer.valueOf(obj.toString()) % 2==0) {
				System.out.println(obj);
			}
			//set.remove(obj);
		}
	}
}
//class UserDao extends BaseDao{
//	
//}
class BaseDao<T>{
	void add(T t) {
		
	}
	void del(T t) {
			
		}
	void edit(T t) {
		
	}
	List<T> list(T t) {
		return null;
	}
}
class Result{
	<T> void del(T t) {
		
	}
}

这样的话，它的结果是：

 但是如果加上 set.remove(obj);

那么就会报错，

 五、集合框架工具类

1、Collections

是集合框架的工具类，里面的方法都是静态的。

        *排序

        *集合转数组:toArray

package com.ycx.map;

import java.util.Arrays;
import java.util.List;


public class Demo4 {
	public static void main(String[] args) {
		String[] arr ={"a","b","c","d"};
		List<String> list = Arrays.asList(arr);
		//Object[] array = list.toArray();
		list.add("e");
//		java.lang.UnsupportedOperationException
		System.out.println(list.size());
	}
}

 运行结果为：

 

 注意：
（1）数组的长度是固定的，所以对于集合的增删方法是不可以使用的
否则会发生UnsupportedOperationException。

 集合之间的相互转换:
 * 1、数组转成集合，本质上依然是一个数组，长度是不可变的
 * 2、集合与数组所具备的方法是不一样的，如对于数组而言，就有判断内部包含哪个元素 

2、Arrays

集合框架的工具类。里面的方法都是静态的。

toString   

asList 

sort

         sort(List) ： 根据元素的自然顺序对指定 List 集合元素按升序排序

         sort(List ， Comparator) ： 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序

对于工具类其他方法的应用:

package com.ycx.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
 * 对于工具类其他方法的应用
 * @author Administrator
 *
 */
public class Demo5 {
	public static void main(String[] args) {
//		ArrayList<Object> list = new ArrayList<>();
//		list.add("b");
//		list.add("c");
//		list.add("a");
//		System.out.println(list);
//		Collections.sort(list);
//		System.out.println(list);
		这里面x、y指的是集合中的元素
//		Collections.sort(list, (x,y)-> y.compareTo(x));
//		System.out.println(list);
		
		ArrayList<Person> list = new ArrayList<>();
		list.add(new Person("b", 18));
		list.add(new Person("c", 20));
		list.add(new Person("a", 17));
		System.out.println(list);
	//	Collections.sort(list);
		Collections.sort(list, (x,y)-> x.getName().compareTo(y.getName()));
		System.out.println(list);
		
		
		Integer[] arr= {3,6,9,2,5,8};
		Arrays.sort(arr, (x,y)-> y-x);
		System.out.println(Arrays.toString(arr));
	}
}
class Person implements Comparable<Person>{
	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 Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Person o) {
		return o.getName().compareTo(this.name);
	}
	
	
}

运行结果为： 

     

 

     今日分享就到这里结束啦~希望能够给大家带来帮助，再会！