TreeMap-CSDN博客

本文链接：https://blog.csdn.net/u014798557/article/details/38039187
/*
 *TreeMap:以二叉树为数据结构的Map集合。
 */

package classfile;

import java.util.*;

public class TreeMapDemo
{
	public static void main(String[] args)
	{
		method_create();
		method_delete();
		method_update();
		method_read();
	}

	public static void method_create()
	{
		TreeMap<String,Integer> tmOne = new TreeMap<String,Integer>();
		TreeMap<String,Integer> tmTwo = new TreeMap<String,Integer>();
		
		//添加单个键值对
		tmOne.put("a",1);
		tmOne.put("b",2);
		tmOne.put("c",3);
		System.out.println(tmOne);

		tmTwo.put("i",9);
		tmTwo.put("j",10);
		tmTwo.put("k",11);
		System.out.println(tmTwo);

		//添加一个Map集合
		tmOne.putAll(tmTwo);
		System.out.println(tmOne);
	}

	public static void method_delete()
	{
		TreeMap<String,Integer> tm = new TreeMap<String,Integer>();
		
		tm.put("a",1);
		tm.put("b",2);
		tm.put("c",3);
		tm.put("d",4);
		tm.put("e",5);
		System.out.println(tm);

		//移除集合中最小键的键值对
		tm.pollFirstEntry();
		System.out.println("移除最小键值对后:"+tm);

		//移除集合中最大键的键值对
		tm.pollLastEntry();
		System.out.println("移除最大键值对后:"+tm);

		//移除指定键的键值对
		tm.remove("c");
		System.out.println("移除指定的键值对后:"+tm);

		//清空集合
		tm.clear();
		System.out.println("清空后的集合:"+tm);
	}

	public static void method_update()
	{
		TreeMap<String,Integer> tm = new TreeMap<String,Integer>();
		
		tm.put("a",1);
		tm.put("b",2);
		tm.put("c",3);
		tm.put("d",4);
		tm.put("e",5);
		System.out.println(tm);

		//修改单个值
		tm.put("a",11);
		System.out.println("修改过值后的集合:"+tm);

		//修改单个映射项
		tm.remove("d");
		tm.put("f",6);
		System.out.println("修改过键值对后的集合:"+tm);
	}

	public static void method_read()
	{
		TreeMap<String,Integer> tm = new TreeMap<String,Integer>();
		
		tm.put("a",1);
		tm.put("b",2);
		tm.put("c",3);
		tm.put("d",4);
		tm.put("e",5);
		System.out.println(tm);

		//获取一个键值对，其中的键是大于等于指定键的最小键
		Map.Entry<String,Integer> meOne = tm.ceilingEntry("c");
		System.out.println("符合条件的最小项:"+meOne.getKey()+"..."+meOne.getValue());

		//获取一个键，该键是大于等于指定键的最小键
		System.out.println("符合条件的最小键:"+tm.ceilingKey("c"));

		//获取此集合的比较器，没有则返回null
		System.out.println("此集合的比较器为:"+tm.comparator());

		//判断集合中是否包含指定键的映射项
		System.out.println("集合中是否包含指定键的键值对:"+tm.containsKey("d"));

		//判断集合中是否包含指定值的映射项
		System.out.println("集合中是否包含指定值的键值对:"+tm.containsValue(5));

		//获取集合中键的逆序Set视图
		NavigableSet<String> navigableSetOne = tm.descendingKeySet();
		for(Iterator<String> iterator = navigableSetOne.iterator();iterator.hasNext();)
		{
			System.out.println("集合中键的逆序遍历:"+iterator.next());
		}

		//获取集合中键值对的逆序Map视图
		NavigableMap<String,Integer> navigableMapOne = tm.descendingMap();
		Set<Map.Entry<String,Integer>> setTwo = navigableMapOne.entrySet();
		for(Iterator<Map.Entry<String,Integer>> iterator = setTwo.iterator();iterator.hasNext();)
		{
			Map.Entry<String,Integer> me = iterator.next();

			System.out.println("集合映射项的逆序遍历:"+me.getKey()+"..."+me.getValue());
		}

		//获取集合中键值对的正序视图
		Set<Map.Entry<String,Integer>> setThree = tm.entrySet();
		for(Iterator<Map.Entry<String,Integer>> iterator = setThree.iterator();iterator.hasNext();)
		{
			Map.Entry<String,Integer> me = iterator.next();

			System.out.println("集合映射项的正序视图:"+me.getKey()+"..."+me.getValue());
		}

		//获取集合中最小键的映射项
		Map.Entry<String,Integer> meTwo = tm.firstEntry();
		System.out.println("集合中最小的键值对:"+meTwo.getKey()+"..."+meTwo.getValue());

		//获取集合中最小的键
		System.out.println("集合中最小的键:"+tm.firstKey());

		//获取一个键值对，其中的键是小于等于指定键的最大键
		Map.Entry<String,Integer> meThree = tm.floorEntry("c");
		System.out.println("符合条件的最大键值对:"+meThree.getKey()+"..."+meThree.getValue());

		//获取一个键，该键是小于等于指定键的最大键
		System.out.println("符合条件的最大键:"+tm.floorKey("c"));

		//获取指定键的值
		System.out.println("获取指定键的值:"+tm.get("b"));

		//获取集合的部分Map视图，其中的键要严格小于指定的键
		SortedMap<String,Integer> sortedMapOne = tm.headMap("c");
		Set<Map.Entry<String,Integer>> setFour = sortedMapOne.entrySet();
		for(Iterator<Map.Entry<String,Integer>> iterator = setFour.iterator();iterator.hasNext();)
		{
			Map.Entry<String,Integer> me = iterator.next();

			System.out.println("符合条件的部分键值对:"+me.getKey()+".."+me.getValue());
		}

		//获取集合的部分Map视图，其中的键是否严格小于指定的键，取决于boolean型参数
		NavigableMap<String,Integer> navigalbeMapTwo = tm.headMap("c",true);
		Set<Map.Entry<String,Integer>> setFive = navigalbeMapTwo.entrySet();
		for(Iterator<Map.Entry<String,Integer>> iterator = setFive.iterator();iterator.hasNext();)
		{
			Map.Entry<String,Integer> me = iterator.next();

			System.out.println("符合条件的部分键值对:"+me.getKey()+"..."+me.getValue());
		}

		//获取一个键值对，其中的键是严格大于指定键的最小键
		Map.Entry<String,Integer> meFour = tm.higherEntry("c");
		System.out.println("符合条件的最小键值对:"+meFour.getKey()+"..."+meFour.getValue());

		//获取一个键，该键是严格大于指定键的最小键
		System.out.println("符合条件的最小键:"+tm.higherKey("c"));

		//获取集合中键的正序Set视图
		Set<String> setOne = tm.keySet();
		for(Iterator<String> iterator = setOne.iterator();iterator.hasNext();)
		{
			System.out.println("集合中键的正序遍历:"+iterator.next());
		}

		//获取集合中最大键的映射项
		Map.Entry<String,Integer> meFive = tm.lastEntry();
		System.out.println("集合中最大键的键值对:"+meFive.getKey()+"..."+meFive.getValue());

		//获取集合中的最大键
		System.out.println("集合中的最大键为:"+tm.lastKey());

		//获取一个键值对，其中的键是严格小于指定键的最大键
		Map.Entry<String,Integer> meSix = tm.lowerEntry("c");
		System.out.println("符合条件的最大键值对:"+meSix.getKey()+"..."+meSix.getValue());

		//获取一个键，该键是严格小于指定键的最大键
		System.out.println("符合条件的最大键:"+tm.lowerKey("c"));

		//获取集合中键的可导航Set视图
		NavigableSet<String> navigableSetTwo = tm.navigableKeySet();
		for(Iterator<String> iterator = navigableSetTwo.iterator();iterator.hasNext();)
		{
			System.out.println("集合中键的遍历:"+iterator.next());
		}

		//获取集合中映射项的数量
		System.out.println("集合中键值对的数量为:"+tm.size());

		//获取集合的部分Map视图，按照键获取
		NavigableMap<String,Integer> navigableMapThree = tm.subMap("b",true,"d",true);
		Set<Map.Entry<String,Integer>> setSix = navigableMapThree.entrySet();
		for(Iterator<Map.Entry<String,Integer>> iterator = setSix.iterator();iterator.hasNext();)
		{
			Map.Entry<String,Integer> me = iterator.next();

			System.out.println("集合的部分视图:"+me.getKey()+"..."+me.getValue());
		}

		//获取集合的部分Map视图，按照键获取，含头不含尾
		SortedMap<String,Integer> sortedMapTwo = tm.subMap("b","d");
		Set<Map.Entry<String,Integer>> setSeven = sortedMapTwo.entrySet();
		for(Iterator<Map.Entry<String,Integer>> iterator = setSeven.iterator();iterator.hasNext();)
		{
			Map.Entry<String,Integer> me = iterator.next();

			System.out.println("集合的部分视图:"+me.getKey()+"..."+me.getValue());
		}

		//获取集合的部分Map视图，其中的键要大于等于指定的键
		SortedMap<String,Integer> sortedMapThree = tm.tailMap("c");
		Set<Map.Entry<String,Integer>> setEight = sortedMapThree.entrySet();
		for(Iterator<Map.Entry<String,Integer>> iterator = setEight.iterator();iterator.hasNext();)
		{
			Map.Entry<String,Integer> me = iterator.next();

			System.out.println("集合的部分视图:"+me.getKey()+"..."+me.getValue());
		}

		//获取集合的部分Map视图
		NavigableMap<String,Integer> navigableMapFour = tm.tailMap("c",false);
		Set<Map.Entry<String,Integer>> setNine = navigableMapFour.entrySet();
		for(Iterator<Map.Entry<String,Integer>> iterator = setNine.iterator();iterator.hasNext();)
		{
			Map.Entry<String,Integer> me = iterator.next();

			System.out.println("集合的部分视图:"+me.getKey()+"..."+me.getValue());
		}

		//获取集合的值的Collection视图
		Collection<Integer> collection = tm.values();
		for(Iterator<Integer> iterator = collection.iterator();iterator.hasNext();)
		{
			System.out.println("集合中值的遍历:"+iterator.next());
		}
	}
}