可以对 key 进行排序，但必须要集合元素必须实现 Comparable 接口或者接口必须实现 Comparator 比较器

常用方法

Modifier and Type	Method and Description
Map.Entry<K,V>	ceilingEntry(K key) 返回与大于或等于给定键的最小键相关联的键值映射，如果没有此键，则 null 。
K	ceilingKey(K key) 返回大于或等于给定键的 null键，如果没有此键，则返回 null 。
void	clear() 从这张地图中删除所有的映射。
Object	clone() 返回此 TreeMap实例的浅拷贝。
Comparator<? super K>	comparator() 返回用于订购此地图中的键的比较器，或null如果此地图使用其键的natural ordering 。
boolean	containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
boolean	containsValue(Object value) 如果此地图将一个或多个键映射到指定值，则返回 true 。
NavigableSet<K>	descendingKeySet() 返回此地图中包含的键的相反顺序NavigableSet 。
NavigableMap<K,V>	descendingMap() 返回此映射中包含的映射的反向排序视图。
Set<Map.Entry<K,V>>	entrySet() 返回此地图中包含的映射的Set视图。
Map.Entry<K,V>	firstEntry() 返回与该地图中的最小键相关联的键值映射，如果地图为空，则返回 null 。
K	firstKey() 返回此地图中当前的第一个（最低）键。
Map.Entry<K,V>	floorEntry(K key) 返回与小于或等于给定键的最大键相关联的键值映射，如果没有此键，则 null 。
K	floorKey(K key) 返回小于或等于给定键的最大键，如果没有这样的键，则返回 null 。
void	forEach(BiConsumer<? super K,? super V> action) 对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
V	get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
SortedMap<K,V>	headMap(K toKey) 返回此地图部分的视图，其密钥严格小于 toKey 。
NavigableMap<K,V>	headMap(K toKey, boolean inclusive) 返回此地图部分的视图，其键值小于（或等于，如果 inclusive为真） toKey 。
Map.Entry<K,V>	higherEntry(K key) 返回与最小密钥相关联的密钥值映射严格大于给定密钥，如果没有这样的密钥则 null 。
K	higherKey(K key) 返回严格大于给定键的最小键，如果没有这样的键，则返回 null 。
Set<K>	keySet() 返回此地图中包含的键的Set视图。
Map.Entry<K,V>	lastEntry() 返回与该地图中最大关键字关联的键值映射，如果地图为空，则返回 null 。
K	lastKey() 返回当前在此地图中的最后（最高）键。
Map.Entry<K,V>	lowerEntry(K key) 返回与最大密钥相关联的密钥值映射严格小于给定密钥，如果没有这样的密钥，则 null 。
K	lowerKey(K key) 返回严格小于给定键的最大键，如果没有这样的键，则返回 null 。
NavigableSet<K>	navigableKeySet() 返回此地图中包含的键的NavigableSet视图。
Map.Entry<K,V>	pollFirstEntry() 删除并返回与该地图中的最小键相关联的键值映射，如果地图为空，则返回 null 。
Map.Entry<K,V>	pollLastEntry() 删除并返回与该地图中最大密钥相关联的键值映射，如果地图为空，则返回 null 。
V	put(K key, V value) 将指定的值与此映射中的指定键相关联。
void	putAll(Map<? extends K,? extends V> map) 将指定地图的所有映射复制到此地图。
V	remove(Object key) 从此TreeMap中删除此键的映射（如果存在）。
V	replace(K key, V value) 只有当目标映射到某个值时，才能替换指定键的条目。
boolean	replace(K key, V oldValue, V newValue) 仅当当前映射到指定的值时，才能替换指定键的条目。
void	replaceAll(BiFunction<? super K,? super V,? extends V> function) 将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
int	size() 返回此地图中键值映射的数量。
NavigableMap<K,V>	subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回此地图部分的视图，其关键范围为 fromKey至 toKey 。
SortedMap<K,V>	subMap(K fromKey, K toKey) 返回此地图部分的视图，其关键字范围从 fromKey （含）到 toKey ，独占。
SortedMap<K,V>	tailMap(K fromKey) 返回此地图部分的视图，其键大于等于 fromKey 。
NavigableMap<K,V>	tailMap(K fromKey, boolean inclusive) 返回此地图部分的视图，其键大于（或等于，如果 inclusive为真） fromKey 。
Collection<V>	values() 返回此地图中包含的值的Collection视图。

两种实现方式

元素实现 Comparable 接口

package 集合;

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

public class TreeMapDemo implements Comparable {
	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 TreeMapDemo(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "[name=" + name + ", age=" + age + "]";
	}

	//比较规则：先比较名字再比较年龄
	@Override
	public int compareTo(Object o) {
		TreeMapDemo t = (TreeMapDemo) o;
		int n1 = this.getName().compareTo(t.getName());
		int n2 = this.getAge() - t.getAge();
		return n1 == 0 ? n2 : n1;
	}
	public static void main(String[] args) {
		TreeMap<TreeMapDemo, String> tree = new TreeMap<>();
		TreeMapDemo t1 = new TreeMapDemo("a张三", 21);
		TreeMapDemo t2 = new TreeMapDemo("c李四", 22);
		TreeMapDemo t3 = new TreeMapDemo("b王五", 19);
		tree.put(t1, "北京");
		tree.put(t2, "上海");
		tree.put(t3, "杭州");
		System.out.println(tree.size());
		System.out.println(tree);
		//添加名字相同年龄不同的key后
		TreeMapDemo t4 = new TreeMapDemo("b王五", 17);
		tree.put(t4, "武汉");
		System.out.println(tree.size());
		System.out.println(tree);
		//添加相同的key，覆盖
		tree.put(t4, "深圳");
		System.out.println(tree.size());
		System.out.println(tree);
		//两种遍历方式
		System.out.println("------keyset遍历--------");
		Set<TreeMapDemo> key = tree.keySet();
		Iterator<TreeMapDemo> it = key.iterator();
		 while(it.hasNext()) {
			 TreeMapDemo s = it.next();
			 System.out.println(s + "=" + tree.get(s));
		 }
		 System.out.println("-------entry遍历--------------");
		 Set<Map.Entry<TreeMapDemo, String>> entries = tree.entrySet();
		 for (Map.Entry<TreeMapDemo, String> entry : entries) {
			System.out.println(entry);
		}
	}
}
/*
3
{[name=a张三, age=21]=北京, [name=b王五, age=19]=杭州, [name=c李四, age=22]=上海}
4
{[name=a张三, age=21]=北京, [name=b王五, age=17]=武汉, [name=b王五, age=19]=杭州, [name=c李四, age=22]=上海}
4
{[name=a张三, age=21]=北京, [name=b王五, age=17]=深圳, [name=b王五, age=19]=杭州, [name=c李四, age=22]=上海}
------keyset遍历--------
[name=a张三, age=21]=北京
[name=b王五, age=17]=深圳
[name=b王五, age=19]=杭州
[name=c李四, age=22]=上海
-------entry遍历--------------
[name=a张三, age=21]=北京
[name=b王五, age=17]=深圳
[name=b王五, age=19]=杭州
[name=c李四, age=22]=上海

*/

使用比较器

package 集合;

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMap2 {
	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 TreeMap2(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "[name=" + name + ", age=" + age + "]";
	}
	public static void main(String[] args) {
		TreeMap<TreeMap2, String> tree = new TreeMap<TreeMap2, String>(new Comparator<TreeMap2>() {
			//比较规则，先比较名字长短，再比较年龄
			@Override
			public int compare(TreeMap2 o1, TreeMap2 o2) {
				int n1 = o1.name.length() - o2.name.length();
				int n2 = o1.age - o2.age;
				return n1 == 0 ? n2 : n1;
			}
		});
		TreeMap2 t1 = new TreeMap2("Bob", 21);
		TreeMap2 t2 = new TreeMap2("Ernest", 20);
		TreeMap2 t3 = new TreeMap2("Frank",19);
		tree.put(t1, "伦敦");
		tree.put(t2, "纽约");
		tree.put(t3, "华盛顿");
		System.out.println(tree.size());
		System.out.println(tree);
		//添加名字长短一样，年龄不同的key后
		TreeMap2 t4 = new TreeMap2("Abc", 19);
		tree.put(t4, "旧金山");
		System.out.println(tree.size());
		System.out.println(tree);
		//添加相同的键，将覆盖值
		tree.put(t4, "悉尼");
		System.out.println(tree.size());
		System.out.println(tree);
	}
}
/*
3
{[name=Bob, age=21]=伦敦, [name=Frank, age=19]=华盛顿, [name=Ernest, age=20]=纽约}
4
{[name=Abc, age=19]=旧金山, [name=Bob, age=21]=伦敦, [name=Frank, age=19]=华盛顿, [name=Ernest, age=20]=纽约}
4
{[name=Abc, age=19]=悉尼, [name=Bob, age=21]=伦敦, [name=Frank, age=19]=华盛顿, [name=Ernest, age=20]=纽约}
*/