TreeMap

概述

TreeMap集合是基于红黑树（Red-Black tree）的 NavigableMap实现。该集合最重要的特点就是可排序，该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator方法进行排序。

API方法实例演示

ceilingEntry

@Test
public void ceilingEntry() {
    //ceilingEntry: 返回指定键的键值对数据
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"ceilingEntry");
    //根据1号键获取数据
    Map.Entry<Integer, String> entry = treeMap.ceilingEntry(1);
    System.out.println(entry);
}

ceilingKey

@Test
public void ceilingKey() {
    //ceilingKey: 返回指定的键
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"ceilingKey");
    //设置返回的键
    Integer ceilingKey = treeMap.ceilingKey(1);
    System.out.println(ceilingKey);
}

clear

@Test
public void clear() {
    //clear: 清除所有的键值对
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"clear");
    treeMap.clear();
}

Clone

@Test
public void Clone() {
    //clone: 拷贝集合的键值对
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"clone");
    //复制打印集合数据
    System.out.println("treeMap.clone() = " + treeMap.clone());
}

containsKey

@Test
public void containsKey() {
    //containsKey: 判断是否包含指定的键，包含则返回true
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"containsKey");
    //有1这个键，打印为true
    System.out.println("treeMap.containsKey(2) = " + treeMap.containsKey(1));
}

containsValue

@Test
public void containsValue() {
    //containsValue: 判断是否包含指定的值，包含则返回true
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"containsValue");
    System.out.println(treeMap.containsValue("containsValue"));
}

descendingKeySet

@Test
public void descendingKeySet() {
    //descendingKeySet: 返回键的相反顺序，倒序输出
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"descendingKeySet");
    treeMap.put(2,"descendingKeySet");
    treeMap.put(3,"descendingKeySet");
    //输出键分别为3，2，1
    System.out.println("treeMap.descendingKeySet() = " + treeMap.descendingKeySet());
}

descendingMap

@Test
public void descendingMap() {
    //descendingMap: 按照倒序返回集合的数据
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"descendingMap");
    treeMap.put(2,"descendingMap");
    treeMap.put(3,"descendingMap");
    NavigableMap<Integer, String> descendingMap = treeMap.descendingMap();
    //按照倒序打印集合数据
    System.out.println(descendingMap);
}

entrySet

@Test
public void entrySet() {
    //entrySet: 遍历所有集合的数据
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"entrySet");
    treeMap.put(2,"entrySet");
    Set<Map.Entry<Integer, String>> entries = treeMap.entrySet();
    //使用增强for循环遍历
    for (Map.Entry<Integer, String> entry : entries) {
        System.out.println(entry.getKey() + entry.getValue());
    }
}

firstEntry

@Test
public void firstEntry() {
    //firstEntry: 返回集合中最小的键值
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(0,"firstEntry");
    treeMap.put(1,"firstEntry");
    treeMap.put(2,"firstEntry");
    //最小的0键会被打印
    Map.Entry<Integer, String> firstEntry = treeMap.firstEntry();
    System.out.println(firstEntry);
}

firstKey

@Test
public void firstKey() {
    //firstKey: 返回集合中最小值的key
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(0,"firstKey");
    treeMap.put(1,"firstKey");
    System.out.println("treeMap.firstKey() = " + treeMap.firstKey());
}

floorEntry

@Test
public void floorEntry() {
    //floorEntry: 返回等于或大于集合中key的值
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"floorEntry");
    //指定的key大于集合的key，返回键值对数据
    System.out.println(treeMap.floorEntry(2));
}

floorKey

@Test
public void floorKey() {
    //floorKey: 返回大于或等于集合中的key
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"floorKey");
    //2键大于集合的key，会打印集合中的key
    System.out.println(treeMap.floorKey(2));
}

forEach

@Test
public void forEach() {
    //forEach: 对集合进行指定的操作
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"forEach");
    //KV表示键和值遍历，下面表示打印K键
    treeMap.forEach((K,V) -> System.out.println(K));
}

get

@Test
public void get() {
    //get: 根据指定的key获取value
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"get");
    System.out.println(treeMap.get(1));
}

headMap

@Test
public void headMapOneArg() {
    //headMap: 根据指定的key返回集合的数据，key不能小于集合的key
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"headMap");
    System.out.println(treeMap.headMap(2));
}

headMap(K toKey, boolean inclusive)

@Test
public void headMapThreeArgs() {
    //headMap(K toKey, boolean inclusive) : 根据指定键返回数据，参数如果为true表示可以小于或等于集合的key
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"headMap");
    //第二个参数为true，可以小于等于集合的key，false则不可
    System.out.println(treeMap.headMap(0, true));
}

higherEntry

@Test
public void higherEntry() {
    //higherEntry: 根据指定的key返回集合数据，如果给定参数大于集合的key则打印为null
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"higherEntry");
    //给定的key参数小于集合的key，打印数据
    System.out.println(treeMap.higherEntry(0));
}

higherKey

@Test
public void higherKey() {
    //higherKey: 根据指定的key参数返回集合的key数据，参数大于等于集合的key则返回null
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"higherKey");
    //参数小于集合的key，可以返回集合key数据
    System.out.println(treeMap.higherKey(0));
}

keySet

@Test
public void keySet() {
    //keySet: 返回一个Set集合，可遍历map集合的key
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"keySet");
    treeMap.put(2,"keySet");
    Set<Integer> keySet = treeMap.keySet();
    //打印map集合的key
    System.out.println("keySet = " + keySet);
}

lastEntry

@Test
public void lastEntry() {
    //lastEntry: 返回集合中数值最大的键值对
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"lastEntry");
    treeMap.put(2,"lastEntry");
    treeMap.put(3,"lastEntry");
    //3号key最大，会打印返回这个键值对
    System.out.println(treeMap.lastEntry());
}

lastKey

@Test
public void lastKey() {
    //lastKey: 返回集合中最大的key
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"lastKey");
    treeMap.put(3,"lastKey");
    treeMap.put(4,"lastKey");
    System.out.println("treeMap.lastKey() = " + treeMap.lastKey());
}

lowerEntry

@Test
public void lowerEntry() {
    //lowerEntry: 根据指定key参数返回集合的键值对，参数小于集合的key则返回null
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"Entry");
    //给定的key参数大于集合的key，可以打印显示集合的结果
    System.out.println(treeMap.lowerEntry(2));
}

lowerKey

@Test
public void lowerKey() {
    //lowerKey: 根据指定参数返回集合的键值，小于集合键值则返回null
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"lowerKey");
    //给定的参数大于集合的key值，可以打印显示结果
    System.out.println(treeMap.lowerKey(2));
}

navigableKeySet

@Test
public void navigableKeySet() {
    //navigableKeySet: 返回一个视图接口
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"navigableKeySet");
    NavigableSet<Integer> navigableKeySet = treeMap.navigableKeySet();
    //打印显示集合的key值
    System.out.println("navigableKeySet = " + navigableKeySet);
}

pollFirstEntry

@Test
public void pollFirstEntry() {
    //pollFirstEntry: 删除并返回最小的键值
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"pollFirstEntry");
    treeMap.put(2,"pollFirstEntry");
    //1号键数值最小会被删除并返回结果
    System.out.println("treeMap.pollFirstEntry() = " + treeMap.pollFirstEntry());
}

pollLastEntry

@Test
public void pollLastEntry() {
    //pollLastEntry: 删除并返回最大的键值
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"pollLastEntry");
    treeMap.put(2,"pollLastEntry");
    //2号键最大，会被删除并返回结果
    System.out.println("treeMap.pollLastEntry() = " + treeMap.pollLastEntry());
}

put

@Test
public void put() {
    //put: 往集合里添加一个键值对
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"put1");
    treeMap.put(2,"put2");
    System.out.println(treeMap);
}

putAll

@Test
public void putAll() {
    //putAll: 根据一个map集合批量添加键值数据
    TreeMap<Integer, String> treeMap1 = new TreeMap<>();
    TreeMap<Integer, String> treeMap2 = new TreeMap<>();
    treeMap2.put(1,"putAll");
    //参数为treeMap2集合的数据
    treeMap1.putAll(treeMap2);
    System.out.println("treeMap1 = " + treeMap1);
}

remove

@Test
public void remove() {
    //remove: 根据key移除指定的参数
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"remove");
    System.out.println("treeMap.remove(1) = " + treeMap.remove(1));
}

replace

@Test
public void replaceTwoArgs() {
    //replace: 根据key值替换集合value值，并返回替换结果
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"replace");
    //替换1号键的值为replace2
    System.out.println(treeMap.replace(1, "replace2"));
    //打印结果替换后的值
    System.out.println(treeMap);
}

replace(K key, V oldValue, V newValue)

@Test
public void replaceThreeArgs() {
    //replace: 指定key和value替换新值
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"replace");
    //指定原先的key和value，第三个参数为要替换的新值
    boolean replace = treeMap.replace(1, "replace", "shit");
    System.out.println(replace);
}

replaceAll

@Test
public void replaceAll() {
    //replaceAll: 根据lambda表达式批量添加值
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"replaceAll");
    treeMap.replaceAll((K,V) -> "Value1"+ " " +"Value2");
    System.out.println("treeMap = " + treeMap);
}

size

@Test
public void size() {
    //size: 返回集合的长度值
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    //没有添加数据，返回值为0
    System.out.println("treeMap.size() = " + treeMap.size());
}

subMap

@Test
public void subMapTwoArgs() {
    //subMap: 返回指定范围的集合数据，范围长度-1
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"subMap");
    treeMap.put(2,"subMap");
    treeMap.put(3,"subMap");
    treeMap.put(4,"subMap");
    //获取1-4之间的值
    System.out.println(treeMap.subMap(1, 4));
}

subMap(四个参数)

@Test
public void subMapFourArgs() {
    //subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive): 返回集合指定范围的参数，若都为true则指定范围不会减1
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"subMap");
    treeMap.put(2,"subMap");
    treeMap.put(3,"subMap");
    System.out.println(treeMap.subMap(1, true, 3, true));
}

tailMap

@Test
public void tailMapOneArg() {
    //tailMap: 根据指定key参数返回集合的key值，集合参数需大于方法key参数，否则为null
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"tailMap");
    //给定的key参数大于集合的key值，返回为空
    System.out.println(treeMap.tailMap(3));
}

tailMap(两个参数)

@Test
public void tailMapTwoArgs() {
    //tailMap(K fromKey, boolean inclusive):根据参数返回集合key值，参数需要小于集合key值，否则为空
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"tailMap");
    System.out.println(treeMap.tailMap(2, true));
}

values

@Test
public void values() {
    //values: 返回一个Collection接口，可以遍历所有map集合数据
    TreeMap<Integer, String> treeMap = new TreeMap<>();
    treeMap.put(1,"values");
    Collection<String> values = treeMap.values();
    System.out.println("values = " + values);
}