Java 集合代码

package com.neusoft.test1;

import java.text.ParseException;
import java.text.RuleBasedCollator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
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.TreeSet;

public class Test1 {

public static void main(String[] args) throws ParseException {
	// TODO Auto-generated method stub
	method15();
}


public static void method15() {
	Person p1=new Person();
	p1.id="123";
	p1.age=19;
	p1.name="张三";
	Person p2=new Person();
	p2.id="123";
	p2.age=20;
	p2.name="李四";
	HashSet hs=new HashSet();
	hs.add(p1);
	hs.add(p2);
	
	Iterator i=	hs.iterator();
	while(i.hasNext()) {
		System.out.println(i.next());
	}
	
}

// HashSet
// 无序不可重复
// 可以为null
// 初始容量 16
// 加载因子0.75 跟扩容相关的阈值
// 桶 hashcode值相同 在一个桶中 （equals 不同）

public static void method14() {
		
		HashSet hs=new HashSet();
		hs.add("tom");
		hs.add("jerry");
		hs.add("scott");
		hs.add("king");
		hs.add(null);
		hs.add(null);
		
		Iterator i=	hs.iterator();
		while(i.hasNext()) {
			System.out.println(i.next());
		}
		
		
	}

// TreeSet ----> 红黑树
// 自然顺序对元素进行排序
// 输出结果 可能与 输入顺序不同 所以称之为无序集合
// TreeSet 集合不能为空

public static void method13() {
		TreeSet ts=new TreeSet();
		ts.add("1");
		ts.add("100");
		ts.add("10");
//		ts.add(null);
//		ts.add("13");
//		ts.add("3");
//		ts.add(11);
//		ts.add(21);
//		ts.add(12);
//		ts.add(13);
//		ts.add(3);
		Iterator i=	ts.iterator();
		while(i.hasNext()) {
			System.out.println(i.next());
		}
		
	}

// Set 集合
// 不可重复， 无序

public static void method12() {
		Set s=new HashSet();
		s.add("tom");
		s.add("scott");
		s.add("jerry");
		s.add("tom");
		
		
		Iterator i=	s.iterator();
		while(i.hasNext()) {
			System.out.println(i.next());
		}
	}

// LinkedList 模拟队列
// 方法一： add 与 remove方法可以模拟队列
// 方法二： 阿里笔试 如何用栈 模拟队列 使用双栈 实现队列

public static void method11() {
		LinkedList ll=new LinkedList();
//  push pop
		ll.push("a");
		ll.push("b");
		ll.push("c");
		LinkedList ll2=new LinkedList();
		ll2.push(ll.pop());
		ll2.push(ll.pop());
		ll2.push(ll.pop());
		
		System.out.println(ll2.pop());
		System.out.println(ll2.pop());
		System.out.println(ll2.pop());
		
	}

// method9 与method10 实现了双端队列

public static void method10() {
		LinkedList ll=new LinkedList();
		ll.addLast("aa");
		ll.addLast("bb");
		ll.addLast("ccc");
		
		System.out.println(ll.remove());
		System.out.println(ll.remove());
//		ListIterator i=ll.listIterator();   // List 下的集合为有序集合
//		while(i.hasNext()) {
//			System.out.println(i.next());
//		}
	}

// 模拟队列
// 使用add 与remove方法实现 队列功能

public static void method9() {
		LinkedList ll=new LinkedList();
		ll.addFirst("aa");
		ll.addFirst("bb");
		ll.addFirst("ccc");
		System.out.println(ll.removeLast());
		System.out.println(ll.removeLast());
		System.out.println(ll.removeLast());
//		System.out.println(ll.remove());//NoSuchElementException
//		System.out.println(ll.pop());  //java.util.NoSuchElementException
//		ListIterator i=ll.listIterator();   // List 下的集合为有序集合
//		while(i.hasNext()) {
//			System.out.println(i.next());
//		}
	}

// 使用LinkedList push 与 pop 方法 模拟栈内存

public static void method8() {
		
		LinkedList ll=new LinkedList();
		ll.push("aa");
		ll.push("bbb");
		ll.push("ccc");
		System.out.println(ll.pop());
		System.out.println(ll.pop());
		System.out.println(ll.pop());
//		System.out.println(ll.pop());  //java.util.NoSuchElementException
//		ListIterator i=ll.listIterator();   // List 下的集合为有序集合
//		while(i.hasNext()) {
//			System.out.println(i.next());
//		}
	}

public static void method7() {
	
	LinkedList ll=new LinkedList();
	ll.add("b");
	ll.add("a");
	ll.add("c");
	ll.add("d");
	ll.add("f");
	
	ListIterator i=ll.listIterator();   // List 下的集合为有序集合
	while(i.hasNext()) {
		System.out.println(i.next());
	}
}

public static void method6() throws ParseException {
		ArrayList al=new ArrayList(); 
		al.add("1");
		al.add("3");
		al.add("2");
		al.add("4");
		al.add("6");
//		 String simple = "<2 < 1< 5<6 < 3";
//		 RuleBasedCollator mySimple = new RuleBasedCollator(simple);
		al.sort(null);  //ArrayList 的sort 方法    封装了 Arrays.sort();
		ListIterator i=al.listIterator();   // List 下的集合为有序集合
		while(i.hasNext()) {
			System.out.println(i.next());
		}
	}

// ArrayList
// 数据结构：线性数组结构
// arraylist 中有一个 容量（capcity）
// 默认为10 也可以自己指定
// 可以自动扩容
// arraylist 比list 多了关于 容量的一些处理方法
// 如： 自动扩容 底层为 对 数组的拷贝 system.array.copy()

public static void method5() {
		Collection c1=new TreeSet();
		c1.add("aaaa");
		c1.add("cccc");
		c1.add("ddddd");
		c1.add("ffff");
		c1.add("bbbb");
		
		ArrayList al=new ArrayList(c1);   //保留 c1 collection 原有的遍历顺序 添加到 al ArrayList当中

		
		ListIterator i=al.listIterator();   // List 下的集合为有序集合
		while(i.hasNext()) {
			System.out.println(i.next());
		}
	}

public static void method4() {
		List l1=new ArrayList();
		l1.add("tom");
		l1.add("scott");
		l1.add("jerry");
		l1.add("tom");  //List集合中可以存储重复的元素
//		l1.add(1, "king"); //在下标为1的位置添加元素
		l1.remove(3); // 按照指定的坐标去删除对应位置的元素
		
//		System.out.println(l1.get(1));
//		System.out.println(l1.get(5));//IndexOutOfBoundsException
		ListIterator i=l1.listIterator();   // List 下的集合为有序集合
		while(i.hasNext()) {
			System.out.println(i.next());
		}
	}

	public static void method3() {
		List l1=new ArrayList();
		l1.add("tom");
		l1.add("scott");
		l1.add("jerry");
//		l1.add(123);
//		Iterator 与ListIterator 不同
//		 使用范围： Iterator collection
//				ListIterator   list集合
//		继承关系：ListIterator 是Iterator 子类
//		方法拓展：ListIterator 比Iterator多了add 方法等
//		特殊 ListIterator 可以指定遍历的开始下标（index）
		
//		Iterator i=	l1.iterator();
//		while(i.hasNext()) {
//			System.out.println(i.next());
//		}
		ListIterator i=l1.listIterator();
		while(i.hasNext()) {
			String name =(String) i.next();
			if("tom".equals(name)) {
				i.add("king");
			}
			
			System.out.println(i.previous());
			i.next();
//			System.out.println(i.previous());
//			l1.add("king");  //ConcurrentModificationException  并发修改异常 
//			System.out.println(i.next());
			
		}
		System.out.println();
		while(i.hasNext()) {
//			l1.add("king");
			System.out.println(i.next());
		}
		
		
		ArrayList l2=new ArrayList();
		
	}

public static void method2() {
	int[] a=new int[] {1,7,2,9,3,6};
	Arrays.sort(a);
	for(int n:a) {
		System.out.println(n);
	}
}

// Collection 接口
public static void method1() {
// 集合的有序与无序
// 取决于 添加元素的顺序与存储（遍历）的顺序是否一致
// 如果是一致的 则成为有序集合
// 如果是不一致 则称为无序集合

// 父类引用指向子类对象 只能调用 父类中定义的方法

	Collection c=new ArrayList();
		Collection c1=new ArrayList();
		c1.add("2");
		c1.add("2");
		c1.add("3");
		c1.add("4");
		c1.add("1");
		c.add("2");
		c.add("3");
		c.add("4");
		c.add("2");
		c.add("1");
		c.remove("2");
		c.remove("2");
//		只清除元素
		System.out.println("c1.isEmpty()"+c1.isEmpty());
		System.out.println("c1.size()"+c1.size());
		c1.clear();
		System.out.println("c1.isEmpty()"+c1.isEmpty());
		System.out.println("c1.size()"+c1.size());
		c.addAll(c1);
//		集合变成数组
		Object[] oarr=c.toArray();
		for(Object n:oarr) {
			System.out.println(n);
		}
//		System.out.println();
//		 想要遍历集合 要使用 迭代器 （遍历器）   迭代器设计模式 ：不用知道集合的数据类型 依旧可以遍历
//		Iterator  i=c.iterator();
//		while(i.hasNext()) {
//			System.out.println(i.next());
//		}
//		for(Object n:c) {
//			System.out.println(n);
//		}
		
		
	}

}