javatreeset源碼

1. java中的treeset是實現了sortedset介面的set,但為什麼要叫treeset呢

treeset實現了sortedset介面，也就是重寫了裡面的方法，但具體實現的方式由實現的子類自己編寫，所以treeset在實現set集合採用的演算法是樹型演算法。

TreeSet是一個有序集合，TreeSet中的元素將按照升序排列，預設是按照自然排序進行排列，意味著TreeSet中的元素要實現Comparable介面。或者有一個自定義的比較器。Treeset演算法：

構造一個新的空TreeSet，它根據指定比較器進行排序。插入到該set的所有元素都必須能夠由指定比較器進行相互比較：對於set中的任意兩個元素e1和e2，執行comparator.compare(e1,e2)都不得拋出ClassCastException。如果用戶試圖將違反此約束的元素添加到set中，則add調用將拋出ClassCastException。
packagetest.treeset;

importjava.util.Comparator;
importjava.util.Iterator;
importjava.util.TreeSet;

publicclassTreeSetTest{
@SuppressWarnings("unchecked")
publicstaticvoidmain(String[]args){
TreeSetts=newTreeSet(newTeacher2.TeacherCompare());
ts.add(newTeacher2("zhangsan",2));
ts.add(newTeacher2("lisi",1));
ts.add(newTeacher2("wangmazi",3));
ts.add(newTeacher2("mazi",3));
Iteratorit=ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}

classTeacher2{
intnum;
Stringname;

Teacher2(Stringname,intnum){
this.num=num;
this.name=name;
}

publicStringtoString(){
return"學號："+num+"姓名："+name;
}

{//老師自帶的一個比較器
//o1中存放的事目標節點
//o2中存放時的紅黑二叉樹中的節點，從根節點開始比較
publicintcompare(Objecto1,Objecto2){
Teacher2s1=(Teacher2)o1;//轉型
Teacher2s2=(Teacher2)o2;//轉型
intresult=s1.num>s2.num?1:(s1.num==s2.num?0:-1);
if(result==0){
result=s1.name.compareTo(s2.name);
}
returnresult;
}

}

}

2. Java關於一個java.util.TreeSet的問題

你好，看到這種問題，你最好能看看源碼，我截取TreeSet代碼如下：
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
public TreeSet() {
this(new TreeMap<E,Object>()); //默認構造
}
HashSet的內部實現就是一個new TreeMap<E,Object>()，繼續看TreeMap：
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
// TBD:
// 5045147: (coll) Adding null to an empty TreeSet should
// throw NullPointerException
//
// compare(key, key); // type check
root = new Entry<K,V>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<K,V>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
看到這里我想你也明白了吧，這里就對調用對象的compareTo方法，而你的那個方法返回的正好是相等也就是0.所以在put的時候每次的鍵相同是不可以繼續添加的，所以返回是false。

3. 深入淺出的分析 Set集合

Set集合的特點主要有：元素不重復、存儲無序的特點。

打開 Set 集合，主要實現類有 HashSet、LinkedHashSet 、TreeSet 、EnumSet（ RegularEnumSet、JumboEnumSet ）等等，總結 Set 介面實現類，圖如下：

由圖中的繼承關系，可以知道，Set 介面主要實現類有 AbstractSet、HashSet、LinkedHashSet 、TreeSet 、EnumSet（ RegularEnumSet、JumboEnumSet ），其中 AbstractSet、EnumSet 屬於抽象類，EnumSet 是在 jdk1.5 中新增的，不同的是 EnumSet 集合元素必須是枚舉類型。

HashSet 是一個輸入輸出無序的集合，集合中的元素基於 HashMap 的 key 實現，元素不可重復；
LinkedHashSet 是一個輸入輸出有序的集合，集合中的元素基於 LinkedHashMap 的 key 實現，元素也不可重復；
TreeSet 是一個排序的集合，集合中的元素基於 TreeMap 的 key 實現，同樣元素不可重復；
EnumSet 是一個與枚舉類型一起使用的專用 Set 集合，其中 RegularEnumSet 和 JumboEnumSet 不能單獨實例化，只能由 EnumSet 來生成，同樣元素不可重復；
下面咱們來對各個主要實現類進行一一分析！

HashSet 是一個輸入輸出無序的集合，底層基於 HashMap 來實現，HashSet 利用 HashMap 中的key元素來存放元素，這一點我們可以從源碼上看出來，閱讀源碼如下：

public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable{

}

打開HashSet的add()方法，源碼如下：

public boolean add(E e) {
//向 HashMap 中添加元素
return map.put(e, PRESENT)==null;
}

其中變數PRESENT，是一個非空對象，源碼部分如下：
private static final Object PRESENT = new Object();

可以分析出，當進行add()的時候，等價於
HashMap map = new HashMap<>();
map.put(e, new Object());//e 表示要添加的元素

在之前的集合文章中，咱們了解到 HashMap 在添加元素的時候 ，通過equals()和hashCode()方法來判斷傳入的key是否相同，如果相同，那麼 HashMap 認為添加的是同一個元素，反之，則不是。

從源碼分析上可以看出，HashSet 正是使用了 HashMap 的這一特性，實現存儲元素下標無序、元素不會重復的特點。

HashSet 的刪除方法，同樣如此，也是基於 HashMap 的底層實現，源碼如下：

public boolean remove(Object o) {
//調用HashMap 的remove方法，移除元素
return map.remove(o)==PRESENT;
}

HashSet 沒有像 List、Map 那樣提供 get 方法，而是使用迭代器或者 for 循環來遍歷元素，方法如下：

public static void main(String[] args) {
Set<String> hashSet = new HashSet<String>();
System.out.println("HashSet初始容量大小："+hashSet.size());
hashSet.add("1");
hashSet.add("2");
hashSet.add("3");
hashSet.add("3");
hashSet.add("2");
hashSet.add(null);

}

輸出結果：
HashSet初始容量大小：0
HashSet容量大小：4
null,1,2,3,
===========
null,1,2,3,

需要注意的是，HashSet 允許添加為null的元素。

LinkedHashSet 是一個輸入輸出有序的集合，繼承自 HashSet，但是底層基於 LinkedHashMap 來實現。

如果你之前了解過 LinkedHashMap，那麼你一定知道，它也繼承自 HashMap，唯一有區別的是，LinkedHashMap 底層數據結構基於循環鏈表實現，並且數組指定了頭部和尾部，雖然數組的下標存儲無序，但是卻可以通過數組的頭部和尾部，加上循環鏈表，依次可以查詢到元素存儲的過程，從而做到輸入輸出有序的特點。

如果還不了解 LinkedHashMap 的實現過程，可以參閱集合系列中關於 LinkedHashMap 的實現過程文章。

閱讀 LinkedHashSet 的源碼，類定義如下：

public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, java.io.Serializable {

}

查詢源碼，super調用的方法，源碼如下：

HashSet(int initialCapacity, float loadFactor, boolean mmy) {
//初始化一個 LinkedHashMap
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

LinkedHshSet沒有重寫add方法，而是直接調用HashSet的add()方法，因為map的實現類是LinkedHashMap，所以此處是向LinkedHashMap中添加元素，當進行add()的時候，等價於
HashMap map = new LinkedHashMap<>();
map.put(e, new Object());//e 表示要添加的元素

LinkedHashSet也沒有重寫remove方法，而是直接調用HashSet的刪除方法，因為LinkedHashMap沒有重寫remove方法，所以調用的也是HashMap的remove方法，源碼如下：

public boolean remove(Object o) {
//調用HashMap 的remove方法，移除元素
return map.remove(o)==PRESENT;
}

同樣的，LinkedHashSet 沒有提供 get 方法，使用迭代器或者 for 循環來遍歷元素，方法如下：

public static void main(String[] args) {
Set<String> linkedHashSet = new LinkedHashSet<String>();
System.out.println("linkedHashSet初始容量大小："+linkedHashSet.size());
linkedHashSet.add("1");
linkedHashSet.add("2");
linkedHashSet.add("3");
linkedHashSet.add("3");
linkedHashSet.add("2");
linkedHashSet.add(null);
linkedHashSet.add(null);

}

輸出結果：
linkedHashSet初始容量大小：0
linkedHashSet容量大小：4
1,2,3,null,
===========
1,2,3,null,
可見，LinkedHashSet 與 HashSet 相比，LinkedHashSet 輸入輸出有序。

TreeSet 是一個排序的集合，實現了NavigableSet、SortedSet、Set介面，底層基於 TreeMap 來實現。TreeSet 利用 TreeMap 中的key元素來存放元素，這一點我們也可以從源碼上看出來，閱讀源碼，類定義如下：

public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable {

}

new TreeSet<>()對象實例化的時候，表達的意思，可以簡化為如下：
NavigableMap<E,Object> m = new TreeMap<E,Object>();

因為TreeMap實現了NavigableMap介面，所以沒啥問題。

public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable{
......
}

打開TreeSet的add()方法，源碼如下：

public boolean add(E e) {
//向 TreeMap 中添加元素
return m.put(e, PRESENT)==null;
}

其中變數PRESENT，也是是一個非空對象，源碼部分如下：
private static final Object PRESENT = new Object();

可以分析出，當進行add()的時候，等價於
TreeMap map = new TreeMap<>();
map.put(e, new Object());//e 表示要添加的元素

TreeMap 類主要功能在於，給添加的集合元素，按照一個的規則進行了排序，默認以自然順序進行排序，當然也可以自定義排序，比如測試方法如下：

public static void main(String[] args) {
Map initMap = new TreeMap();
initMap.put("4", "d");
initMap.put("3", "c");
initMap.put("1", "a");
initMap.put("2", "b");
//默認自然排序，key為升序
System.out.println("默認 排序結果:" + initMap.toString());
//自定義排序，在TreeMap初始化階段傳入Comparator 內部對象
Map comparatorMap = new TreeMap<String, String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2){
//根據key比較大小，採用倒敘，以大到小排序
return o2.compareTo(o1);
}
});
comparatorMap.put("4", "d");
comparatorMap.put("3", "c");
comparatorMap.put("1", "a");
comparatorMap.put("2", "b");
System.out.println("自定義 排序結果:" + comparatorMap.toString());
}

輸出結果：
默認 排序結果:{1=a, 2=b, 3=c, 4=d}
自定義 排序結果:{4=d, 3=c, 2=b, 1=a}

相信使用過TreeMap的朋友，一定知道TreeMap會自動將key按照一定規則進行排序，TreeSet正是使用了TreeMap這種特性，來實現添加的元素集合，在輸出的時候，其結果是已經排序好的。

如果您沒看過源碼TreeMap的實現過程，可以參閱集合系列文章中TreeMap的實現過程介紹，或者閱讀 jdk 源碼。

TreeSet 的刪除方法，同樣如此，也是基於 TreeMap 的底層實現，源碼如下：

public boolean remove(Object o) {
//調用TreeMap 的remove方法，移除元素
return m.remove(o)==PRESENT;
}

TreeSet 沒有重寫 get 方法，而是使用迭代器或者 for 循環來遍歷元素，方法如下：

public static void main(String[] args) {
Set<String> treeSet = new TreeSet<>();
System.out.println("treeSet初始容量大小："+treeSet.size());
treeSet.add("1");
treeSet.add("4");
treeSet.add("3");
treeSet.add("8");
treeSet.add("5");

}

輸出結果：
treeSet初始容量大小：0
treeSet容量大小：5
1,3,4,5,8,
===========
1,3,4,5,8,

使用自定義排序，有 2 種方法，第一種在需要添加的元素類，實現Comparable介面，重寫compareTo方法來實現對元素進行比較，實現自定義排序。

/**

創建一個Person實體類，實現Comparable介面，重寫compareTo方法，通過變數age實現自定義排序 測試方法如下：

public static void main(String[] args) {
Set<Person> treeSet = new TreeSet<>();
System.out.println("treeSet初始容量大小："+treeSet.size());
treeSet.add(new Person("李一",18));
treeSet.add(new Person("李二",17));
treeSet.add(new Person("李三",19));
treeSet.add(new Person("李四",21));
treeSet.add(new Person("李五",20));

}

輸出結果：
treeSet初始容量大小：0
treeSet容量大小：5
按照年齡從小到大，自定義排序結果：
李二:17,李一:18,李三:19,李五:20,李四:21,

第二種方法是在TreeSet初始化階段，Person不用實現Comparable介面，將Comparator介面以內部類的形式作為參數，初始化進去，方法如下：

public static void main(String[] args) {
//自定義排序
Set<Person> treeSet = new TreeSet<>(new Comparator<Person>(){
@Override
public int compare(Person o1, Person o2) {
if(o1 == null || o2 == null){
//不用比較
return 0;
}
//從小到大進行排序
return o1.getAge() - o2.getAge();
}
});
System.out.println("treeSet初始容量大小："+treeSet.size());
treeSet.add(new Person("李一",18));
treeSet.add(new Person("李二",17));
treeSet.add(new Person("李三",19));
treeSet.add(new Person("李四",21));
treeSet.add(new Person("李五",20));

}

輸出結果：
treeSet初始容量大小：0
treeSet容量大小：5
按照年齡從小到大，自定義排序結果：
李二:17,李一:18,李三:19,李五:20,李四:21,
需要注意的是，TreeSet不能添加為空的元素，否則會報空指針錯誤！

EnumSet 是一個與枚舉類型一起使用的專用 Set 集合，繼承自AbstractSet抽象類。與 HashSet、LinkedHashSet 、TreeSet 不同的是，EnumSet 元素必須是Enum的類型，並且所有元素都必須來自同一個枚舉類型，EnumSet 定義源碼如下：

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
implements Cloneable, java.io.Serializable {
......
}

EnumSet是一個虛類，不能直接通過實例化來獲取對象，只能通過它提供的靜態方法來返回EnumSet實現類的實例。

EnumSet的實現類有兩個，分別是RegularEnumSet、JumboEnumSet兩個類，兩個實現類都繼承自EnumSet。

EnumSet會根據枚舉類型中元素的個數，來決定是返回哪一個實現類，當 EnumSet元素中的元素個數小於或者等於64，就會返回RegularEnumSet實例；當EnumSet元素個數大於64，就會返回JumboEnumSet實例。

這一點，我們可以從源碼中看出，源碼如下：

public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
Enum<?>[] universe = getUniverse(elementType);
if (universe == null)
throw new ClassCastException(elementType + " not an enum");
//當元素個數小於或者等於 64 的時候，返回 RegularEnumSet
if (universe.length <= 64)
return new RegularEnumSet<>(elementType, universe);
else
//大於64，返回 JumboEnumSet
return new JumboEnumSet<>(elementType, universe);
}
noneOf是EnumSet中一個靜態方法，用於判斷是返回哪一個實現類。

我們來看看當元素個數小於等於64的時候，使用RegularEnumSet的類，源碼如下：

class RegularEnumSet<E extends Enum<E>> extends EnumSet<E> {

}
RegularEnumSet 通過二進制運算得到結果，直接使用long來存放元素。

我們再來看看當元素個數大於64的時候，使用JumboEnumSet的類，源碼如下：

class JumboEnumSet<E extends Enum<E>> extends EnumSet<E> {

}
JumboEnumSet 也是通過二進制運算得到結果，使用long來存放元素，但是它是使用數組來存放元素。

二者相比，RegularEnumSet 效率比 JumboEnumSet 高些，因為操作步驟少，大多數情況下返回的是 RegularEnumSet，只有當枚舉元素個數超過 64 的時候，會使用 JumboEnumSet。

添加元素：
//新建一個EnumEntity的枚舉類型，定義2個參數
public enum EnumEntity {
WOMAN,MAN;
}

創建一個空的 EnumSet：
//創建一個 EnumSet，內容為空
EnumSet<EnumEntity> noneSet = EnumSet.noneOf(EnumEntity.class);
System.out.println(noneSet);
輸出結果：
[]

創建一個 EnumSet，並將枚舉類型的元素全部添加進去：
//創建一個 EnumSet，將EnumEntity 元素內容添加到EnumSet中
EnumSet<EnumEntity> allSet = EnumSet.allOf(EnumEntity.class);
System.out.println(allSet);

輸出結果：
[WOMAN, MAN]

創建一個 EnumSet，添加指定的枚舉元素：
//創建一個 EnumSet，添加 WOMAN 到 EnumSet 中
EnumSet<EnumEntity> customSet = EnumSet.of(EnumEntity.WOMAN);
System.out.println(customSet);

查詢元素
EnumSet與HashSet、LinkedHashSet、TreeSet一樣，通過迭代器或者 for 循環來遍歷元素，方法如下：

EnumSet<EnumEntity> allSet = EnumSet.allOf(EnumEntity.class);
for (EnumEntity enumEntity : allSet) {
System.out.print(enumEntity + ",");
}

輸出結果：
WOMAN,MAN,

HashSet 是一個輸入輸出無序的 Set 集合，元素不重復，底層基於 HashMap 的 key 來實現，元素可以為空，如果添加的元素為對象，對象需要重寫 equals() 和 hashCode() 方法來約束是否為相同的元素。

LinkedHashSet 是一個輸入輸出有序的 Set 集合，繼承自 HashSet，元素不重復，底層基於 LinkedHashMap 的 key來實現，元素也可以為空，LinkedHashMap 使用循環鏈表結構來保證輸入輸出有序。

TreeSet 是一個排序的 Set 集合，元素不可重復，底層基於 TreeMap 的 key來實現，元素不可以為空，默認按照自然排序來存放元素，也可以使用 Comparable 和 Comparator 介面來比較大小，實現自定義排序。

EnumSet 是一個與枚舉類型搭配使用的專用 Set 集合，在 jdk1.5 中加入。EnumSet 是一個虛類，有2個實現類 RegularEnumSet、JumboEnumSet，不能顯式的實例化改類，EnumSet 會動態決定使用哪一個實現類，當元素個數小於等於64的時候，使用 RegularEnumSet；大於 64的時候，使用JumboEnumSet類，EnumSet 其內部使用位向量實現，擁有極高的時間和空間性能，如果元素是枚舉類型，推薦使用 EnumSet。

1、JDK1.7&JDK1.8 源碼

2、程序園 - java集合－EnumMap與EnumSet

3、 Java極客技術 - https://blog.csdn.net/javageektech/article/details/103077788

4. 求Java程序，TreeSet問題

importjava.util.Iterator;
importjava.util.Scanner;
importjava.util.TreeSet;
publicclassDay14_B{
	staticScannersc=newScanner(System.in);
	staticTreeSet<Double>ts=newTreeSet<Double>();
	publicstaticvoidmain(String[]args){
		while(ts.size()<10){
			System.out.print("輸入:");
			ts.add(sc.nextDouble());
		}
		for(Iterator<Double>it=ts.iterator();it.hasNext();){
			System.out.print(it.next()+",");
		}
		sc.close();
	}
}

5. 關於java中TreeSet類的一些問題

范型E是TreeSet的類型參數，比較器的類型參數應該是TreeSet類型參數的父類
Person是比較器的類型參數，Worker是TreeSet的類型參數，Person是Worker的父類，所以沒毛病

6. java TreeSet 倒序是怎麼實現的

TreeSet是一個有序的集合。

第一：構造、增加、遍歷、刪除和判斷是否包含某個元素同HashSet是一致的。、

第二：證明TreeSet是一個有序的集合。

TreeSet hashSet = new TreeSet();

hashSet.add("a"); //向集合中添加一個字元串
hashSet.add("e");
hashSet.add("b");
hashSet.add("d");
hashSet.add("c");

Iterator it = hashSet.iterator();
while(it.hasNext()){
System.out.println(it.next()+",");
}

輸出結果是：

a,
b,
c,
d,
e,

注意：（1）從結果中可以看出元素被排序了，但是這個用默認的排序方法。如何自定義排序呢？可以實現Comparator介面來自定義排序。例如：

import java.util.Comparator;

import ws.wph.android.util.StringUtils;

public class MyCmp implements Comparator {
public int compare(Object element1, Object element2) {
int x = element2.toString().compareTo(element1.toString());
return x;
}

}

然後將該類的對象作為TreeSet構造方法的實參，即TreeSet hashSet = new TreeSet(new
MyCmp());。原理是：向TreeSet增加元素時，自動調用MyCmp類的compare(Object element1, Object
element2)方法，根據方法返回值決定element1和element2的順序。（此時的輸出結果是：e,
d,
c,
b,
a,）

（2）當element1 == element2時返回0，element1 > element2 返回正數，element1 < element2返回負數。

第三：按照學生成績排序，當成績相同時按照學號排序

public int compare(Object element1, Object element2) {
int x=0;
Stuendt s1 = (Stuendt)element1;
Stuendt s2 = (Stuendt)element2;
if(s1.getScore() > s2.getScore()){
x=-1;
}else if(s1.getScore() < s2.getScore()){
x=1;
}else{
x = s1.getSno().compareTo(s2.getSno());
}
return x;
}

（3）將漢字轉換成拼音

public static String getPingYin(String src){
char[] t1 = null;
t1=src.toCharArray();
String[] t2 = new String[t1.length];
HanyuPinyinOutputFormat t3 = new HanyuPinyinOutputFormat();
t3.setCaseType(HanyuPinyinCaseType.LOWERCASE);
t3.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
t3.setVCharType(HanyuPinyinVCharType.WITH_V);
String t4="";
int t0=t1.length;
try {
for (int i=0;i<t0;i++)
{
//判斷是否為漢字字元
if(java.lang.Character.toString(t1[i]).matches("[\\u4E00-\\u9FA5]+"))
{
t2 = PinyinHelper.toHanyuPinyinStringArray(t1[i], t3);
t4+=t2[0];
}
else
t4+=java.lang.Character.toString(t1[i]).toLowerCase();
}
return t4;
}catch ( e1) {
e1.printStackTrace();
}
return t4;
}

但是需要導入一個包

7. 有關java中TreeSet的問題

經研究TreeSet源代碼發現，它最終是調用調用Comparator.compare()來遍歷TreeSet中的元素，並與你的這個temp比較，如果有一個元素比較時返回0，則contains（temp)返回true。

unused_partion_list.contains(temp)返回結果分析：
從你的Comparator邏輯來看，只有當unused_partion_list中存在某個元素，其size和start屬性均與temp的對應屬性相等時，這個方法才有可能返回true,否則將始終返回false。

8. java TreeSet問題

1. TreeSet是集合，是用來存數據的，就像數組一樣，但TreeSet是動態的。

2. TreeSet存的數據是無序號的，你不能通過get的方法獲得裡面的數據。

3. TreeSet存數據是有順序的，這個順序是你規定的，規定方法就是通過實現Comparator介面。

4. 你上面的存儲順序的規則就是static class compareToStudent implements Comparator {....... }這個方法，至於public int compareTo(Object o) {.....}那是它的一部分，你可以理解成：

   
   

   {

   ....

   if（result==0）{

   publicintcompareTo(Objecto){.....}

   }

   }

   剩下的應該自己思考。。。

9. java的TreeSet底層是怎麼實現的

TreeSet是一個有序集合，裡面的元素若要實現自然排序就需要實現Comparable介面，或者你也可以自定義一個Comparator實現自己的比較方式。TreeSet底層無非是通過比較元素實現排序，那也是調用Comparable或者Comparator來實現的。至於排序演算法那就是更底層的東西了，java不關心這些

10. java TreeSet問題

publicclassA{
publicstaticvoidmain(String[]args){
SortedSet<String>st=newTreeSet<String>(Arrays.asList("".split("")));
Objectlow=st.first(),
high=st.last();
System.out.println(st);
Iterator<String>it=st.iterator();
for(inti=0;i<st.size();i++){
if(i==3)
low=it.next();
elseif(i==6)
high=it.next();
elseit.next();
}
System.out.println(low);
System.out.println(high);
}
}