TreeMap 实现类
作者:互联网
可以对
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]=纽约}
*/
标签:返回,name,映射,实现,age,tree,TreeMap,key 来源: https://blog.csdn.net/m0_52423355/article/details/122653695