treemap源码

Ⅰ java TreeMap 源码中的 buildFromSorted方法 建树原理是什么

你在网络搜 四湖论坛 希望对你有帮助

Ⅱ java中TreeSet,SortedMap 的底层用的排序算法是什么二分法快排

看了下源码
TreeSet里面有一个NavigableSet引用m
在调用TreeSet构造方法时 会将m引用到一个新建的TreeMap对象
TreeSet一系列的操作都是通过这个TreeMap 完成的 可以去看看TreeMap的方法
具体底层的算法.......我也没看懂

Ⅲ Hashtable，HashMap和TreeMap的区别

Java为数据结构中的映射定义了一个接口java.util.Map，

它有四个实现类，分别是HashMap、HashTable、LinkedHashMap和TreeMap。

这里介绍这4中实例的用法和区别。

关键技术剖析：
Map用于存储键值对，根据键得到值，因此不允许键重复，值可以重复。
l （1）HashMap是一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为null，不允许多条记录的值为null。HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要同步，可以用Collections.synchronizedMap(HashMap map)方法使HashMap具有同步的能力。

l （2）Hashtable与HashMap类似，不同的是：它不允许记录的键或者值为空；它支持线程的同步，即任一时刻只有一个线程能写Hashtable，然而，这也导致了Hashtable在写入时会比较慢。

l （3）LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的。在遍历的时候会比HashMap慢。有HashMap的全部特性。
l （4）TreeMap能够把它保存的记录根据键排序，默认是按升序排序，也可以指定排序的比较器。当用Iteraor遍历TreeMap时，得到的记录是排过序的。TreeMap的键和值都不能为空。

importjava.util.HashMap;
importjava.util.Hashtable;
importjava.util.Iterator;
importjava.util.LinkedHashMap;
importjava.util.Map;
importjava.util.TreeMap;


publicclassTestMap{


publicstaticvoidinit(Mapmap){
if(map!=null){
Stringkey=null;
for(inti=5;i>0;i--){
key=newInteger(i).toString()+".0";
map.put(key,key.toString());
//Map中的键是不重复的，如果插入两个键值一样的记录，
//那么后插入的记录会覆盖先插入的记录
map.put(key,key.toString()+"0");}
}
}

publicstaticvoidoutput(Mapmap){
if(map!=null){
Objectkey=null;
Objectvalue=null;
//使用迭代器遍历Map的键，根据键取值
Iteratorit=map.keySet().iterator();
while(it.hasNext()){
key=it.next();
value=map.get(key);
System.out.println("key:"+key+";value:"+value);
}
//或者使用迭代器遍历Map的记录Map.Entry
Map.Entryentry=null;
it=map.entrySet().iterator();
while(it.hasNext()){
//一个Map.Entry代表一条记录
entry=(Map.Entry)it.next();
//通过entry可以获得记录的键和值
//System.out.println("key:"+entry.getKey()+";value:"+entry.getValue());
}
}
}

(Mapmap,Objectkey){
if(map!=null){
returnmap.containsKey(key);
}
returnfalse;
}

(Mapmap,Objectvalue){
if(map!=null){
returnmap.containsValue(value);
}
returnfalse;
}

publicstaticvoidtestHashMap(){
MapmyMap=newHashMap();
init(myMap);
//HashMap的键可以为null
myMap.put(null,"ddd");
//HashMap的值可以为null
myMap.put("aaa",null);
output(myMap);
}

publicstaticvoidtestHashtable(){
MapmyMap=newHashtable();
init(myMap);
//Hashtable的键不能为null
//myMap.put(null,"ddd");
//Hashtable的值不能为null
//myMap.put("aaa",null);
output(myMap);
}

(){
MapmyMap=newLinkedHashMap();
init(myMap);
//LinkedHashMap的键可以为null
myMap.put(null,"ddd");
myMap.put(null,"aaa");
//LinkedHashMap的值可以为null
myMap.put("aaa",null);
output(myMap);
}

publicstaticvoidtestTreeMap(){
MapmyMap=newTreeMap();
init(myMap);
//TreeMap的键不能为null
//myMap.put(null,"ddd");
//TreeMap的值不能为null
//myMap.put("aaa",null);
output(myMap);
}

publicstaticvoidmain(String[]args){
System.out.println("采用HashMap");
TestMap.testHashMap();
System.out.println("采用Hashtable");
TestMap.testHashtable();
System.out.println("采用LinkedHashMap");
TestMap.testLinkedHashMap();
System.out.println("采用TreeMap");
TestMap.testTreeMap();

MapmyMap=newHashMap();
TestMap.init(myMap);
System.out.println("新初始化一个Map:myMap");
TestMap.output(myMap);
//清空Map
myMap.clear();
System.out.println("将myMapclear后，myMap空了么?"+myMap.isEmpty());
TestMap.output(myMap);
myMap.put("aaa","aaaa");
myMap.put("bbb","bbbb");
//判断Map是否包含某键或者某值
System.out.println("myMap包含键aaa?"+TestMap.containsKey(myMap,"aaa"));
System.out.println("myMap包含值aaaa?"+TestMap.containsValue(myMap,"aaaa"));
//根据键删除Map中的记录
myMap.remove("aaa");
System.out.println("删除键aaa后，myMap包含键aaa?"+TestMap.containsKey(myMap,"aaa"));
//获取Map的记录数
System.out.println("myMap包含的记录数:"+myMap.size());
}
}

输出结果：
采用HashMap
key: null; value: ddd
key: 3.0; value: 3.00
key: aaa; value: null
key: 4.0; value: 4.00
key: 1.0; value: 1.00
key: 5.0; value: 5.00
key: 2.0; value: 2.00
采用Hashtable
key: 4.0; value: 4.00
key: 1.0; value: 1.00
key: 3.0; value: 3.00
key: 5.0; value: 5.00
key: 2.0; value: 2.00
采用LinkedHashMap
key: 5.0; value: 5.00
key: 4.0; value: 4.00
key: 3.0; value: 3.00
key: 2.0; value: 2.00
key: 1.0; value: 1.00
key: null; value: aaa
key: aaa; value: null
采用TreeMap
key: 1.0; value: 1.00
key: 2.0; value: 2.00
key: 3.0; value: 3.00
key: 4.0; value: 4.00
key: 5.0; value: 5.00
新初始化一个Map: myMap
key: 3.0; value: 3.00
key: 4.0; value: 4.00
key: 1.0; value: 1.00
key: 5.0; value: 5.00
key: 2.0; value: 2.00
将myMap clear后，myMap空了么? true
myMap包含键aaa? true
myMap包含值aaaa? true
删除键aaa后，myMap包含键aaa? false
myMap包含的记录数: 1

源码分析：
遍历Map有两种方法：
（1）map的keySet()方法获得键的集合，再调用键集合的iterator方法获得键的迭代器，以此迭代地取出Map中的键，用get方法获得键对应的值，便完成了Map的遍历。代码如下所示：
//使用迭代器遍历Map的键，根据键取值
Iterator it = map.keySet().iterator();
while (it.hasNext()){
key = it.next();
value = map.get(key);
System.out.println("key: " + key + "; value: " + value );
}
（2）使用Map的entrySet方法获得Map中记录的集合，每条对象都是一个Map.Entry对象，使用其getKey方法获得记录的键，使用其getValue方法获得记录的值。代码如下所示：
//或者使用迭代器遍历Map的记录Map.Entry
Map.Entry entry = null;
it = map.entrySet().iterator();
while (it.hasNext()){
//一个Map.Entry代表一条记录
entry = (Map.Entry)it.next();
//通过entry可以获得记录的键和值
//System.out.println("key: " + entry.getKey() + "; value: " + entry.getValue());

Ⅳ Java中HashMap和TreeMap的区别深入理解

HashMap通过hashcode对其内容进行快速查找，而 TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。
HashMap 非线程安全 TreeMap 非线程安全

线程安全
在Java里，线程安全一般体现在两个方面：
1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized。如ArrayList和Vector，HashMap和Hashtable
（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element，问题就出现了。

2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。
1.AbstractMap抽象类和SortedMap接口
AbstractMap抽象类：(HashMap继承AbstractMap)覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。
SortedMap接口：（TreeMap继承自SortedMap）它用来保持键的有序顺序。SortedMap接口为映像的视图(子集)，包括两个端点提供了访问方法。除了排序是作用于映射的键以外，处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一份实现。

2.两种常规Map实现
HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。
(1)HashMap(): 构建一个空的哈希映像
(2)HashMap(Map m): 构建一个哈希映像，并且添加映像m的所有映射
(3)HashMap(int initialCapacity): 构建一个拥有特定容量的空的哈希映像
(4)HashMap(int initialCapacity, float loadFactor): 构建一个拥有特定容量和加载因子的空的哈希映像
TreeMap：基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。
(1)TreeMap():构建一个空的映像树
(2)TreeMap(Map m): 构建一个映像树，并且添加映像m中所有元素
(3)TreeMap(Comparator c): 构建一个映像树，并且使用特定的比较器对关键字进行排序
(4)TreeMap(SortedMap s): 构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序

3.两种常规Map性能
HashMap：适用于在Map中插入、删除和定位元素。
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

4.总结
HashMap通常比TreeMap快一点(树和哈希表的数据结构使然)，建议多使用HashMap，在需要排序的Map时候才用TreeMap。

Ⅳ 如何遍历有序的TreeMap-CSDN论坛

你想按照map的value进行排序，首先你的compare接口就是个错误的实现，一般会实现2个if分支，就是比较的值要求是返回3种情况-1,0,1。为啥要这样？如果你不这样做会产生很多bug，你去看看treemap的源码，在使用你自己实现的comparator借口进行比较的时候有while(p!=null){intcmp=cpr.compare(k,p.key);if(cmp0)p=p.right;elsereturnp;}但是你自己实现的接口没有else那种情况，就是cmp=0那种情况，所以永远得不到key对应的value了。你的问题有两种方法解决在你的comapre方法改为publicintcompare(Stringa,Stringb){if(base.get(a)>base.get(b)){return-1;}elseif(base.get(a)>set=sorted_map.entrySet();for(Entryi:set){System.out.println(i.getValue());}

Ⅵ 在TreeMap treemap类声明时遇到的疑惑， 源代码：

TreeMap中插入数据是需要(键，值)对的，作为一种靠红黑树实现的高效查找结构，对插入的数据必须有方法能按键进行大小比较，因此必须提供对键的比较方法，但这不是必须的，因为内置对象和结构有些实现了比较方法，例如：键是int时就不需要了，但是当键是自定义类时，就必须实现这个比较器

Ⅶ map是以什么方式存储键值对的

Map是一种把键对象和值对象进行关联的容器，而一个值对象又可以是一个Map，依次类推，这样就可形成一个多级映射。对于键对象来说，像Set一样，一个Map容器中的键对象不允许重复，这是为了保持查找结果的一致性;如果有两个键对象一样，那你想得到那个键对象所对应的值对象时就有问题了，可能你得到的并不是你想的那个值对象，结果会造成混乱，所以键的唯一性很重要，也是符合集合的性质的。当然在使用过程中，某个键所对应的值对象可能会发生变化，这时会按照最后一次修改的值对象与键对应。对于值对象则没有唯一性的要求。你可以将任意多个键都映射到一个值对象上，这不会发生任何问题（不过对你的使用却可能会造成不便，你不知道你得到的到底是那一个键所对应的值对象）。Map有两种比较常用的实现：HashMap和TreeMap。HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map。键和值的关联很简单，用pub(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象。

Ⅷ java treeMap 排序后 get不到value

你想按照map的value进行排序，首先你的compare接口就是个错误的实现，一般会实现2个if分支，就是比较的值要求是返回3种情况-1,0,1。为啥要这样？如果你不这样做会产生很多bug，你去看看treemap的源码，在使用你自己实现的comparator借口进行比较的时候有

while(p!=null){
intcmp=cpr.compare(k,p.key);
if(cmp<0)
p=p.left;
elseif(cmp>0)
p=p.right;
else
returnp;
}

但是你自己实现的接口没有else那种情况，就是cmp=0那种情况，所以永远得不到key对应的value了。

你的问题有两种方法解决在你的comapre方法改为

publicintcompare(Stringa,Stringb){
if(base.get(a)>base.get(b)){
return-1;
}elseif(base.get(a)<base.get(b)){
return1;
}else{
return0;
}
}

或者你取value的时候不通过get方法，而是通过

Set<Entry<String,Double>>set=sorted_map.entrySet();
for(Entry<String,Double>i:set){
System.out.println(i.getValue());
}

Ⅸ java程序：统计单词词频，

不多说，先看代码：

import java.util.*;
import java.io.*;
public class wordsRate {
public static void main(String[] args) throws Exception {

BufferedReader infile = new BufferedReader(new FileReader("article.txt"));
String string;
String file = null;
while ((string = infile.readLine()) != null) {
file += string;
}
file = file.toLowerCase();
file = file.replaceAll("[^A-Za-z]", " ");
file = file.replaceAll("\\s+", " ");
String words[];
words = file.split("\\s+");
Map<String, Integer> hashMap = new HashMap<String, Integer>();
for (int i = 0; i < words.length; i++) {
String key = words[i];
if (hashMap.get(key) != null) {
int value = ((Integer) hashMap.get(key)).intValue();
value++;
hashMap.put(key, new Integer(value));
} else {
hashMap.put(key, new Integer(1));
}
}
Map<String, Object> treeMap = new TreeMap<String, Object>(hashMap);
Map<String, Object> treeMap1 = new TreeMap<String, Object>(hashMap);
BufferedWriter bw = new BufferedWriter(new FileWriter("result.txt"));

//下面是我改动的你的代码：

Iterator iter = treeMap.entrySet().iterator();
//定义两个新的数组ss1和ss2，数组长度就是hashMap的长度，里面放分别是hashMap的value和key
String ss1[]=new String[treeMap.size()];;
int ss2[]=new int[treeMap.size()];
int i=0;
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
int val = (Integer)entry.getValue();
String key =(String) entry.getKey();
ss1[i]=key;
ss2[i]=val;
i++;
}
//下面将ss1数组进行排序,并将其与ss2数组的内容相对应起来
int sValue=0;
String sKey="";
for(int j=0;j<ss2.length;j++){
for(int k=0;k<i;k++){
if(ss2[j]>ss2[k]){
sValue=ss2[j];
sKey=ss1[j];
ss2[j]=ss2[k];
ss1[j]=ss1[k];
ss2[k]=sValue;
ss1[k]=sKey;
}
}
}
for(int j=0;j<ss2.length;j++){
System.out.println(ss1[j]+"="+ss2[j]);
bw.write(ss1[j]+"="+ss2[j]);
bw.newLine();
bw.flush();
}
}
}

代码是本人自己写的，也经过了自己的验证，肯定没问题，希望采纳。
功能实现了，我是将其key和value值放在了数组之中，然后进行排序，将其输出到了txt文件里
排序方式不一样，实现的方式也不一样，所谓仁者见仁智者见智。

Ⅹ java 的TreeMap是怎么存放和读取的借着下面的程序帮我解释一下，谢谢

前面的A,B,C...是KEY，后面的1,2,3是value， 需要从treemap里取值的话就只需要treemap.get（"A");或者其他就可以

System.out.print(treemap); 这个语句调用了treemap的toString方法，是用前面KEY的升序排列