映射Map

最新推荐文章于 2022-10-27 22:46:27 发布

少喝烫水

最新推荐文章于 2022-10-27 22:46:27 发布

阅读量84

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/tsunagxy/article/details/108113906

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

映射

Map映射

数学定义：两个集合之间的元素对应关系
一个输出对应到一个输出
{1,张三}，{2,李四}，{key,value}，键值对，K-V对

Java中Map

Hashtable （同步，慢，数据量小）
HashMap（不支持同步，快，数据量大）
Properties（同步，文件形式，数据量小）

Hashtable

K-V对，K和V都不允许为null
同步，多线程安全
无序的
适合小数据量
主要方法：clear, contains/containsValue, containsKey, get, put,remove, size

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class HashTableTest {

	public static void main(String[] args) {
		Hashtable<Integer,String> ht = new Hashtable<Integer,String>();
		//ht.put(1, null); 编译不报错，运行报错
		//ht.put(null, 1); 编译报错
		
		ht.put(1000, "aaa");
		ht.put(2, "bbb");
		ht.put(30000, "ccc");
		
		System.out.println(ht.contains("aaa"));//true
		System.out.println(ht.containsValue("aaa"));//true
		System.out.println(ht.containsKey(30000));//true
		System.out.println(ht.get(30000));//ccc
		
		ht.put(30000, "ddd");//更新覆盖ccc
		System.out.println(ht.get(30000));//ddd
		
		ht.remove(2);
		System.out.println("size：" + ht.size());//size:2
		
		ht.clear();
		System.out.println("size：" + ht.size());//size:0
		
		Hashtable<Integer, String> ht2 = new Hashtable<Integer,String>();
		for(int i = 0; i < 100000; i++) {
			ht2.put(i, "aaa");
		}
		traverseByEntry(ht2);
		traverseByKeySet(ht2);
		traverseByKeyEnumeration(ht2);

	}

	private static void traverseByKeyEnumeration(Hashtable<Integer, String> ht) {
		long startTime = System.nanoTime();
		System.out.println("KeyEnumeration迭代器遍历：");
		Integer key;
		String value;
		Enumeration<Integer> keys = ht.keys();
		
		while(keys.hasMoreElements()) {
			key = keys.nextElement();
			value = ht.get(key);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseByKeySet(Hashtable<Integer, String> ht) {
		long startTime = System.nanoTime();
		System.out.println("KeySet迭代器遍历：");
		Integer key;
		String value;
		Iterator<Integer> iter = ht.keySet().iterator();
		
		while(iter.hasNext()) {
			key = iter.next();//获取key
			value = ht.get(key);//获取value
			
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseByEntry(Hashtable<Integer, String> ht) {
		long startTime = System.nanoTime();
		System.out.println("Entry迭代器遍历：");
		Integer key;
		String value;
		Iterator<Entry<Integer,String>> iter = ht.entrySet().iterator();
		
		while(iter.hasNext()) {
			Map.Entry<Integer, String> entry = iter.next();
			key = entry.getKey();//获取key
			value = entry.getValue();//获取value
		//	System.out.println("key:" + key + ",Value: " + value);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

}

HashMap

K-V对，K和V都允许为null
不同步，多线程不安全
无序的

主要方法：clear, containsValue, containsKey, get, put,remove, size

package ddd;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class HashMapTest {

	public static void main(String[] args) {
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(1, null);
		hm.put(null, "abc");
		hm.put(1000, "aaa");
		hm.put(2, "bbb");
		hm.put(30000, "ccc");
		
		System.out.println(hm.containsValue("aaa"));//true
		System.out.println(hm.containsKey(30000));//true
		System.out.println(hm.get(30000));//ccc
		
		hm.put(30000, "ddd");//更新覆盖ccc
		System.out.println(hm.get(30000));//ddd		
		
		hm.remove(2);
		System.out.println("size：" + hm.size());//size:4
		
		hm.clear();
		System.out.println("size：" + hm.size());//size:0
		
		
		HashMap<Integer,String> hm2 = new HashMap<Integer,String>();
		for(int i = 0; i < 100000; i++) {
			hm2.put(i, "aaa");
		}
		
		traverseByEntry(hm2);
		traverseByKeySet(hm2);
	}

	private static void traverseByKeySet(HashMap<Integer, String> ht) {
		long startTime = System.nanoTime();
		System.out.println("KeySet迭代器遍历：");
		Integer key;
		String value;
		Iterator<Integer> iter = ht.keySet().iterator();
		
		while(iter.hasNext()) {
			key = iter.next();//获取key
			value = ht.get(key);//获取value
			
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseByEntry(HashMap<Integer, String> ht) {
		long startTime = System.nanoTime();
		System.out.println("Entry迭代器遍历：");
		Integer key;
		String value;
		Iterator<Entry<Integer,String>> iter = ht.entrySet().iterator();
		
		while(iter.hasNext()) {
			Map.Entry<Integer, String> entry = iter.next();
			key = entry.getKey();//获取key
			value = entry.getValue();//获取value
		//	System.out.println("key:" + key + ",Value: " + value);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

}
Entry迭代器遍历：
13428100纳秒
KeySet迭代器遍历：
34803100纳秒

LinkedHashMap

基于双向链表的维持插入顺序的HashMap

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

public class LinkedHashMapTest {

	public static void main(String[] args) {
		LinkedHashMap<Integer,String> hm = new LinkedHashMap<Integer,String>();
		hm.put(1, null);
		hm.put(null, "abc");
		hm.put(1000, "aaa");
		hm.put(2, "bbb");
		hm.put(30000, "ccc");
		
		System.out.println(hm.containsValue("aaa"));//true
		System.out.println(hm.containsKey(30000));//true
		System.out.println(hm.get(30000));//ccc
		
		hm.put(30000, "ddd");//更新覆盖ccc
		System.out.println(hm.get(30000));//ddd		
		
		hm.remove(2);
		System.out.println("size：" + hm.size());//size:4
		
		hm.clear();
		System.out.println("size：" + hm.size());//size:0
		
		System.out.println("遍历开始：");
		Integer key;
		String value;
		Iterator <Entry<Integer,String>> iter = hm.entrySet().iterator();
		while(iter.hasNext()) {
			Map.Entry<Integer, String> entry = iter.next();
			key = entry.getKey();
			value = entry.getValue();
			System.out.println("Key:" + key + " Value:" + value);
		}
		System.out.println("遍历结束");
		
		LinkedHashMap<Integer, String> hm2 = new LinkedHashMap<Integer,String>();
		for(int i = 0; i < 100000; i++) {
			hm.put(i, "aaa");
		}
		traverseByEntry(hm2);
		traverseByKeySet(hm2);
	}
	
	private static void traverseByKeySet(HashMap<Integer, String> ht) {
		long startTime = System.nanoTime();
		System.out.println("KeySet迭代器遍历：");
		Integer key;
		String value;
		Iterator<Integer> iter = ht.keySet().iterator();
		
		while(iter.hasNext()) {
			key = iter.next();//获取key
			value = ht.get(key);//获取value
			
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseByEntry(HashMap<Integer, String> ht) {
		long startTime = System.nanoTime();
		System.out.println("Entry迭代器遍历：");
		Integer key;
		String value;
		Iterator<Entry<Integer,String>> iter = ht.entrySet().iterator();
		
		while(iter.hasNext()) {
			Map.Entry<Integer, String> entry = iter.next();
			key = entry.getKey();//获取key
			value = entry.getValue();//获取value
		//	System.out.println("key:" + key + ",Value: " + value);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}


}
Entry迭代器遍历：
62200纳秒
KeySet迭代器遍历：
202100纳秒

TreeMap

基于红黑树的Map，可以根据Key的自然排序或者compareTo方法进行排序输出

import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

public class TreeMapTest {

	public static void main(String[] args) {
		TreeMap <Integer,String> hm = new TreeMap<Integer,String>();
	//	hm.put(null, "abc"); 编译不报错，运行报空指针异常
		hm.put(1000, "aaa");
		hm.put(2, "bbb");
		hm.put(30000, "ccc");
		System.out.println(hm.containsValue("aaa"));//true
		System.out.println(hm.containsKey(30000));//true
		System.out.println(hm.get(30000));//ccc

		hm.put(30000, "ddd");//更新覆盖ccc
		System.out.println(hm.get(30000));//ddd		
		
		hm.remove(2);
		System.out.println("size：" + hm.size());//size:2
		
	//	hm.clear();
	//	System.out.println("size：" + hm.size());//size:0
		
		System.out.println("遍历开始：");
		Integer key;
		String value;
		Iterator<Entry<Integer,String>> iter = hm.entrySet().iterator();
		
		while(iter.hasNext()) {
			Map.Entry<Integer, String> entry = iter.next();
			key = entry.getKey();
			value = entry.getValue();
			System.out.println("Key:" + key +" value:" + value);
		}
//		Key:1000 value:aaa
//		Key:30000 value:ddd
		System.out.println("遍历结束");
		
		TreeMap<Integer, String> hm2 = new TreeMap<Integer,String>();
		for(int i = 0; i < 100000; i++) {
			hm2.put(i, "aaa");
		}
		traverseByEntry(hm2);
		traverseByKeySet(hm2);
	}

	private static void traverseByKeySet(TreeMap<Integer, String> hm) {
		long startTime = System.nanoTime();
		System.out.println("Entry迭代器遍历：");
		Integer key;
		String value;
		Iterator<Entry<Integer,String>> iter = hm.entrySet().iterator();
		
		while(iter.hasNext()) {
			Map.Entry<Integer, String> entry = iter.next();
			key = entry.getKey();//获取key
			value = entry.getValue();//获取value
		//	System.out.println("key:" + key + ",Value: " + value);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
		
	}

	private static void traverseByEntry(TreeMap<Integer, String> hm) {
		long startTime = System.nanoTime();
		System.out.println("Entry迭代器遍历：");
		Integer key;
		String value;
		Iterator<Entry<Integer,String>> iter = hm.entrySet().iterator();
		
		while(iter.hasNext()) {
			Map.Entry<Integer, String> entry = iter.next();
			key = entry.getKey();//获取key
			value = entry.getValue();//获取value
		//	System.out.println("key:" + key + ",Value: " + value);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	
}
Entry迭代器遍历：
11129100纳秒
Entry迭代器遍历：
6162200纳秒

Properties

继承于HashTable
可以将K-V对保存在文件中
适用于数据量少的配置文件
继承自Hashtable的方法：clear, contains/containsValue, containsKey, get, put,remove, size
从文件加载的load方法，写入到文件store方法
获取属性getProperty，设置属性setProperty

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.Properties;

public class PropertiesTest {

	public static void main(String[] args) throws IOException {
		System.out.println("写入Test.properties:");
		WriteProperties("Test.properties","name","12345");
		
		System.out.println("加载Test.properties:");
		GetAllProperties("Test.properties");
		
		System.out.println("从Test.properties加载:");
		String value = GetValueByKey("Test.properties","name");
		System.out.println("name is " + value);
	}

	//关于properties类常用操作
	//根据Key读取Value
	private static String GetValueByKey(String filePath, String key) {
		
		Properties pps = new Properties();
		try {
			InputStream in = new BufferedInputStream(new FileInputStream(filePath));
			pps.load(in);//所有K-V对都加载了
			String value = pps.getProperty(key);
			System.out.println(key + "=" + value);
			return value;
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}
		
	}
	//读取Properties的全部信息
	private static void GetAllProperties(String filePath) throws IOException {
		Properties pps = new Properties();
		InputStream in = new BufferedInputStream(new FileInputStream(filePath));
		pps.load(in);//所有K-V对都加载了
		Enumeration en = pps.propertyNames();//得到配置文件的名字
		
		while(en.hasMoreElements()) {
			String strKey = (String) en.nextElement();
			String strValue = pps.getProperty(strKey);
			System.out.println(strKey + "=" +strValue);
		}
		
		
	}
	
	//写入Properties
	private static void WriteProperties(String filePath, String pKey, String pValue) throws IOException {
		File file = new File(filePath);
		if(!file.exists()) {
			file.createNewFile();
		}
		Properties pps = new Properties();
		InputStream in = new FileInputStream(filePath);
		//从输入流中读取属性列表（键和元素对）
		pps.load(in);
		//调用HashTable的方法put，使用getProperty方法提供并行性
		//强调要求为属性的键和值使用字符串，返回值是HashTable，调用put结果
		OutputStream out = new FileOutputStream(filePath);
		pps.setProperty(pKey, pValue);
		//以适合使用load方法加载到Properties 表中的格式
		//将此Propertirs表中的属性列表（键和元素对）写入输出流
		pps.store(out, "Update" + pKey + "name");
		out.close();
		
	}

}

总结

HashMap是最常用的映射结构
如需要排序，考虑LinkedHashMap和TreeMap
如需要将K-V存储为文件，可采用Properties类

少喝烫水

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
映射Map

映射Map映射数学定义：两个集合之间的元素对应关系一个输出对应到一个输出{1,张三}，{2,李四}，{key,value}，键值对，K-V对Java中MapHashtable （同步，慢，数据量小）HashMap（不支持同步，快，数据量大）Properties（同步，文件形式，数据量小）HashtableK-V对，K和V都不允许为null同步，多线程安全无序的适合小数据量主要方法：clear, contains/containsValue, containsKey,
复制链接

扫一扫