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);
}
}