java集合基础

<pre name="code" class="java"><span style="font-size:18px;">public class MainClasss {

	public static void main(String[] args) {
		
		// 泛型占位符上限约束
		List<? extends String> list = new ArrayList<String>();
		// list.add(""); // 编译错误， 不能把String类型添加至未知类型的集合
		test(list);
		
		// 无序,元素不能重复，判断元素相同的标准就是equals方法返回true和hashCode方法相同(地址相同)
		Set set = new HashSet<Object>();
		set.add(new ClassA());
		set.add(new ClassA());
		set.add(new ClassB());
		set.add(new ClassB());
		set.add(new ClassC());
		set.add(new ClassC());
		Iterator iterator = set.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}

		// TreeSet实现于SortedSet接口， 里面的元素处于排序状态
		TreeSet<String> treeSet;
		
		// 使用双向链表，是有序的，也就是以插入的顺序保存
		LinkedHashSet linkedHashSet = new LinkedHashSet<String>();
		
		// string对象的equals方法是根据两个对象的值判断是否相等的
		System.out.println(new String("aaa").equals(new String("aaa")));
		
		List<String> lists = new ArrayList<String>();
		lists.add("1");
		lists.add("2");
		lists.add("3");
		lists.add("4");
		
		// List提供了一个遍历的对象，与Iterator不同的是ListIterator提供了向前迭代的方法
		ListIterator<String> listIterator = lists.listIterator();
		
		// vector继承于List，是线程安全的
		Vector vector;
		
		// Arrays的asList方法得到的是它内部类的List，只能遍历，不支持增加删除操作。
		String[] str = new String[]{"a", "b", "c"};
		List<String> list2 = Arrays.asList(str);
		// list2.add("d"); // 不支持添加删除操作
		
		// LinkedList支持双向队列、栈、list的操作，相比List，对插入删除操作效率比较高
		LinkedList linkedList = new LinkedList<String>();
		
		/*
		 * List和LinkedList遍历性能比较，按说LinkedList性能应该比List好，但是测试结果恰恰相反。
		 * 也许数据太少，有待进一步测试
		 * */
		String[] test = new String[900000];
		for (int i = 0; i < test.length; i++) {
			test[i] = String.valueOf(i);
		}
		List<String> listTest = new ArrayList<String>();
		for (int i = 0; i < test.length; i++) {
			listTest.add(test[i]);
		}
		LinkedList<String> linkedListTest = new LinkedList<String>();
		for (int i = 0; i < test.length; i++) {
			linkedListTest.add(test[i]);
		}
		Iterator it = listTest.iterator();
		long start = System.currentTimeMillis();
		while (it.hasNext()) {
			it.next();
		}
		System.out.println("List迭代花费时间：" + (System.currentTimeMillis() - start));
		
		Iterator it1 = linkedListTest.iterator();
		long start1 = System.currentTimeMillis();
		while (it1.hasNext()) {
			it1.next();
		}
		System.out.println("LinkedList迭代花费时间：" + (System.currentTimeMillis() - start1));
		
		// HashMap是无序的。重写了toString方法，也是无序的，HashTable是线程安全的
		Map<String, String> map = new HashMap<String, String>();
		map.put("key1", "1");
		map.put("key2", "2");
		map.put("key3", "3");
		map.put("key4", "4");
		map.put("key5", "5");
		map.put("key6", "6");
		map.put("key7", "7");
		map.put("key8", "8");
		map.put("key9", "9");
		System.out.println("HashMap是无序的");
		for (String strs : map.keySet()) {
			System.out.println(map.get(strs));
		}
		
		/*
		 * LinkedHashMap处于排序结构,和LinkedList和LinkedHashSet一样，
		 * 都是采用链表的结构
		 * */
		LinkedHashMap linkedHashMap = new LinkedHashMap<String, String>();
		linkedHashMap.put("key1", "1");
		linkedHashMap.put("key2", "2");
		linkedHashMap.put("key3", "3");
		linkedHashMap.put("key4", "4");
		linkedHashMap.put("key5", "5");
		linkedHashMap.put("key6", "6");
		linkedHashMap.put("key7", "7");
		linkedHashMap.put("key8", "8");
		linkedHashMap.put("key9", "9");
		System.out.println("LinkedHashMap是有序的");
		for (Object strs : linkedHashMap.keySet()) {
			System.out.println(map.get(strs));
		}
	}
	
	public static void test(List<?> list) {
		
	}
}</span>

<span style="font-size:18px;">/*
 * 重写equals方法，总是返回true
 */
public class ClassA {

    @Override
    public boolean equals(Object obj) {
        return true;
    }
    
    @Override
    public int hashCode() {
        return super.hashCode();
    }
}</span>

<span style="font-size:18px;">/*
 * 重写hashCode方法，总是返回1
 */
public class ClassB {

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
    
    @Override
    public int hashCode() {
        return 1;
    }
}</span>

<span style="font-size:18px;">/*
 * 重写equals方法，总是返回true，重写haahCode方法，总是返回2
 */
public class ClassC {

	@Override
	public boolean equals(Object obj) {
		return true;
	}
	
	@Override
	public int hashCode() {
		return 2;
	}
}</span>