Java专题 Collection下list，set关系 hashset去重原理 总结+案例

Collection 对象数组不能扩展和修改，每一次添加元素都必须重新建立一个新的对象

//	Collection					        单列集合的顶层接口
//	 	    List						有序的子接口
//	 	 	    ArrayList 	 	 	顺序存储，查询修改快
//	 	 	    LinkedList			链式存储，增加删除快
//	 	 	    Vector 	 	 	 	顺序存储，都慢但线程安全
//	 	    Set							无序的子接口
//	 	 	    HashSet				哈希存储
//	 	 	 	    LinkedHashSet

构造方法 以及常用方法

	
	//构造方法		Collection为接口需要实现类来创建
	Collection collection = new ArrayList<>();		//可在类名或接口名后加泛型
	Collection collection1 = new LinkedList<>();
	Collection collection2 = new Vector();
	List co = new ArrayList<>();					//可在类名或接口名后加泛型
	List col = new LinkedList<>();
	List coll = new Vector();
	
	
	//常用方法
	collection.add("adwaw");				//不用泛型修饰则可添加任意类型
	collection.add("adwaw");
	collection.add(135342);
	collection.add(132.142);
	collection.add('s');
	collection.add(true);
	
	collection.remove("adwaw");			//删除任意类型的某个元素  用一次删一个 没有就不删
	
	collection.size();					//元素个数
	collection.contains(collection);    //是否包含参数中的元素
	collection.isEmpty();				//是否为空
	collection.clear();					//清空集合
	

遍历方式

结果
增删LinkedList最快， 查询Linked List最慢 ArrayList平均时间在Vector 和 Linked List之间
ArrayList最常用

Collection 的遍历方式

	//Collection 的遍历方式
	//第一种
	Collection collection3 = new ArrayList<>();
	collection3.add("asdasd");
	collection3.add("asdasd");
	collection3.add("asdasd");
	
	Object[] array = collection3.toArray();
	
	for (int i = 0; i < array.length; i++) {
		System.out.println(array[i]);
	}
	
	
	//Collection 中带All的方法
	collection.addAll(collection1);				//将参数中的所有元素添加到调用者中
	collection.removeAll(collection3);			//删除也存在于参数中的所有元素
	collection.containsAll(collection3);		//是否包含参数中的所有
	collection.retainAll(collection3);			//保留与参数中同样拥有的元素	交集
	
	
	//第二种遍历方式
	Collection	c1 = new ArrayList<>();
	c1.add("123sv");
	c1.add("123sv");
	c1.add("123sv");
	c1.add("123sv");
	c1.add("123sv");
	
	Iterator iterator = c1.iterator();
	while (iterator.hasNext()) {
		System.out.println(iterator.next());	//每获取一个,指针指向下一位
	}
	

List

	//List			有索引
	
	//特有方法
	List list = new ArrayList<>();
	list.add(0, "daw");				//在指定位置添加元素   没有泛型就可以任意类型
	list.add(0, "daw");
	
	list.remove(0);			//删除指定位置元素
	list.set(0, "341");		//修改指定位置的值
	list.get(0);			//得到指定位置的元素
	
	
	//遍历方式
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}

特殊异常

	ConcurrentModificationException
	并发修改异常
	出现原因：
	在使用【迭代器对象】遍历集合的同时，使用【集合对象】增加或删除集合的元素
	解决方法：两种解决方式都是针对List集合可以解决
	方式1：迭代器遍历、迭代器增加
	方式2：集合遍历、集合增加

	//Vector		已过时被ArraysList替代	线程安全，效率较低 顺序存储，增删较慢
	
	//ArrayList    时List的一个实现类 没有特殊方法 数组实现 顺序存储
	
	//LinkedList   链表式的数组	结点中除了元素还有下一个元素的地址，链表  查询慢 每一个都要访问
								//删减最快 与顺序无关 转移指针即可。
	//LinkedList  特有方法
	LinkedList list2 = new LinkedList<>();
	list2.addFirst(list);				//首尾添加
	list2.addLast(list);
	list2.getFirst();					//获取首尾
	list2.getLast();
	list2.removeLast();					//删除首尾
	list2.removeFirst();
	

set 以及hashset去重原理

	//Set（集合）           Collection 中的另一个子接口
	//元素不能重复，没有顺序
	
	//实现类
	Set<String> set = new HashSet<String>();
	
	
	//Set集合遍历
	//1
	Object[] array = set.toArray();
	for (int i = 0; i < array.length; i++) {
		System.out.println(array[i]);
	}
	
	
	//2
//	转成数组，toArray(T[] arr)，带泛型的转数组，得到的是T类型的数组。
// 	1、自己创建的数组大小，小于集合元素个数
// 	 	在方法中，就只能创建一个新的数组，使用集合元素将数组填充，将新数组返回
// 	2、自己创建的数组大小，等于集合元素个数
// 	  	在方法中，就不需要创建新的数组，使用集合元素将传入的数组填充，将原数组返回
// 	3、自己创建的数组大小，大于集合元素个数
// 	 	在方法中，也不创建新的数组，直接将传入的数组前面几个位置填充，为集合的元素，剩余位置使用null填充（默认值就是null）
	public static void test2(Set<String> s) {
		//数组长度与集合元素个数相等，不会创建新的数组
		String[] strArr=new String[s.size()];
		String[] array = s.toArray(strArr);
		
		bianli(array);
		System.out.println("=========");
		bianli(strArr);
	}
	public static void test3(Set<String> s) {
		//数组长度小于集合元素个数，会创建新的数组
		String[] strArr=new String[s.size()-3];
		String[] array = s.toArray(strArr);
		
		bianli(array);
		System.out.println("=========");
		bianli(strArr);
	}
	public static void test4(Set<String> s) {
		//数组长度大于集合元素个数，不会创建新的数组
		String[] strArr=new String[s.size()+5];
		String[] array = s.toArray(strArr);
		
		bianli(array);
		System.out.println("=========");
		bianli(strArr);
	}
	public static void bianli(String[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
	}

	
	//迭代器
	Iterator<String> iterator = set.iterator();
	while (iterator.hasNext()) {
		System.out.println(iterator.next());
	}
	
	
	//foreach 循环
	for (Object object : array) {
		System.out.println(object);
	}
	
	
	//HashSet 去重原理 
	//对内在元素的hashcode和euals进行对比
	//将hashcode和equals方法进行重写之后将可以对自定义类进行去重，没有重写的类将不会除重
	
	//linkedlist 固定了顺序的set集合