java集合框架中TreeSet的奇怪现象两个

先贴出输出：
TreeSet Integer
集合为：[-1, 0, 6, 8, 66]
更改temp为：55
集合为：[-1, 0, 6, 8, 66]集合并未因为temp的改变而改变,说明java对基本类型做了特殊处理
-----------------------------
TreeSet 自定义的Int
集合为：[6, 66]
treeSet.contains(6)=  true
treeSet.contains(66)=  true
更改temp为：-55
集合为：[6, -55]集合因为temp的改变而改变，但排序并未改变
treeSet.contains(6)=  false
treeSet.contains(66)=  false
treeSet.contains(-55)=  true


代码：

package Tests;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class testSet {
	public static void main(String[] args) {
//		 testHashSet();
		 testTreeSet();//数据自动排序
		 System.out.println("-----------------------------");
		testTreeSetInt();// 数据自动排序

		// testLinkedList();

	}

	private static void testLinkedList() {
		LinkedList<Object> list = new LinkedList<Object>();
		list.add("asdf");
		list.add("2");
		list.add(-1);
		list.add(55);
		System.out.println(list);
		Iterator<Object> it = list.iterator();
		while (it.hasNext()) {
			System.out.print(it.next() + "   ");
		}
		System.out.println();

		ListIterator<Object> lit = list.listIterator(1);// 从第2个开始
		System.out.print("前向：");
		while (lit.hasNext()) {// 前向
			System.out.print(lit.next() + "  ");
			// System.out.println("序号："+lit.nextIndex());
		}
		System.out.println();

		System.out.print("后向：");
		while (lit.hasPrevious()) {// 后向
			System.out.print(lit.previous() + "  ");
			lit.previousIndex();
		}
		System.out.println();
	}

	private static void testTreeSet() {
		System.out.println("TreeSet Integer");
		SortedSet<Integer> treeSet = new TreeSet<Integer>();
		Integer temp = 66;
		treeSet.add(temp);
		treeSet.add(6);
		treeSet.add(8);
		treeSet.add(-1);
		treeSet.add(0);
		treeSet.add(6);
		treeSet.add(6);
		temp = 55;// 奇怪现象
		System.out.println("集合为："+treeSet);
		System.out.println("更改temp为："+temp);
		System.out.println("集合为："+treeSet+"集合并未因为temp的改变而改变,说明java对基本类型做了特殊处理");
//		System.out.println("treeSet.contains(6)=  " + treeSet.contains(6));
//		for (int integer : treeSet) {
//			System.out.println(integer == 0);
//		}

	}

	private static void testTreeSetInt() {
		System.out.println("TreeSet 自定义的Int");
		SortedSet<Int> treeSet = new TreeSet<Int>();
		Int temp = new Int(66);
		treeSet.add(temp);
		treeSet.add(new Int(6));
//		 treeSet.add(new Int(-8));//是否注释以下几行6和temp的错误不同
//		 treeSet.add(new Int(100));
//		 treeSet.add(new Int(222));
//		 treeSet.add(new Int(333));
//		 treeSet.add(new Int(444));

		System.out.println("集合为："+treeSet);
		System.out.println("treeSet.contains(6)=  " + treeSet.contains(new Int(6)));//正确
		System.out.println("treeSet.contains(66)=  " + treeSet.contains(new Int(66)));//出错

		temp.x = -55;// 奇怪现象
		System.out.println("更改temp为："+temp.x);
		System.out.println("集合为："+treeSet+"集合因为temp的改变而改变，但排序并未改变");
		System.out.println("treeSet.contains(6)=  " + treeSet.contains(new Int(6)));
		System.out.println("treeSet.contains(66)=  " + treeSet.contains(new Int(66)));
		System.out.println("treeSet.contains(-55)=  " + treeSet.contains(new Int(-55)));//出错

	}

	static class Int implements Comparable<Int> {
		int x;

		public Int(int x) {
			super();
			this.x = x;
		}

		@Override
		public int compareTo(Int o) {

			return x - o.x;
		}

		@Override
		public String toString() {
			return ""+x;
		}

	}

	private static void testHashSet() {
		System.out.print("hashSet");
		HashSet<Object> hset = new HashSet<Object>();
		hset.add(5);
		hset.add("asdf");
		hset.add(-9.999);
		hset.add(5);
		hset.add("asdf");
		hset.add(-9.999);
		System.out.println(hset);
	}
}

评论

1 楼 clue 2010-06-21  

temp = 55;
这一句创建了一个新的Integer对象，而不是更改了旧的Integer对象的值。

第一个就直接更改了对象的属性
这时TreeSet不知道属性变了，所以它的次序也乱了
对应的contains算法也有可能出错（因为它认为当前已经排好序了）