集合( LinkedList,HashSet,Collection ) 总结

List集合存储数据的结构：数据存储的常用结构有：堆栈、队列、数组、链表

特点：

1.堆栈：先进后出(即，存进去的元素，要在后面的元素依次取出后，才能取出该元素) 例如：子弹压弹夹；栈的入口/出口都在栈的顶端位置；弹栈：就是取元素（即把栈的顶端位置取出，栈中已有的元素向栈的顶方向移动）

2.队列：先进先出(即，存进去的元素，要在后面的元素依次取出后，才能取出该元素)例如：安检，依次检查；队列的入口、出口各占一侧.

3.数组：查找元素快，增删慢。

 * 数组：
 * 		查询快：数组是有首地址,我们通过首地址可以快速找到数组对象,通过数组的索引快速找到数组中的每一个元素;数组地址是连续的arr[0] arr[1]
 * 		增删慢：数组的长度是固定的,我们想要给数组添加一个元素或减少一个元素,必须新建一个新数组,把原数组的元素复制到新的数组中
 * 			   在内存中,频繁的建数组,复制数组,销毁数组,效率低,速度慢
 *      底层原理的实现
 *      public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
 *        T[] copy = ((Object)newType == (Object)Object[].class)
 *           ? (T[]) new Object[newLength]
 *          : (T[]) Array.newInstance(newType.getComponentType(), newLength);
 *        System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));
 *        return copy;
 *      }

4.链表：多个节点之间，通过地址进行连接，查找慢，增删快

链表的每一个元素,称之为一个节点(由两个指针域和一个数据域组成)
单向链表：只有一条链子,元素是无序的,存储元素和取出的元素的顺序可能不一致；存储a,b,c 取出可能b,c,a
使用单向链表的集合：HashSet,HashMap
双向链表：有两条链子,上一个的元素会记住下一个元素的地址;下一个元素也会记住上一个元素的地址;是有序的,存和取都是一致的
使用双向链表的集合：LinkedHashSet,LinkedHashMap

public class LinkedListDemo {
	
	public static void main(String[] args) {
		show3();
	}
	/*
	* E removeFirst() 移除并返回此列表的第一个元素。
	* E pop() 移除并返回此列表的第一个元素。 此方法等效于 removeFirst()。
	* E removeLast() 移除并返回此列表的最后一个元素。
	*/
	private static void show3() {
		LinkedList<String> linked = new LinkedList<String>();
		//往集合的末尾追加元素
		linked.add("aaa");
		linked.add("bbb");
		linked.add("ccc");
		linked.add("dddd");
		System.out.println(linked);
		String removeFirst = linked.removeFirst();
		System.out.println("返回移除元素：" + removeFirst);
		System.out.println(linked);
		String removeLast = linked.removeLast();
		System.out.println("返回移除元素：" + removeLast);
		System.out.println(linked);
	}
	/*
	* E getFirst() 返回此列表的第一个元素。
	* E getLast() 返回此列表的最后一个元素。
	* boolean isEmpty() 如果列表不包含元素，则返回 true。 
	*/
	private static void show2() {
		//创建LinkedList对象
		LinkedList<String> linked = new LinkedList<String>();
		//往集合的末尾追加元素
		linked.add("aaa");
		linked.add("bbb");
		linked.add("ccc");
		linked.add("dddd");
		//linked.clear();
		if(!linked.isEmpty()){
			String first = linked.getFirst();
			System.out.println("first:" + first);
			String last = linked.getLast();
			System.out.println("last:" + last);
		}
	}
	/*
	* void addFirst(E e) 将指定元素插入此列表的开头。
	* void push(E e) 将该元素插入此列表的开头。 此方法等效于 addFirst(E)。
	* void addLast(E e) 将指定元素添加到此列表的结尾。相当于 add(E e)
	*/
	private static void show1() {
		LinkedList<String> linkedList01 = new LinkedList<String>();
		linkedList01.add("aaa");
		linkedList01.add("bbb");
		linkedList01.add("ccc");
		System.out.println(linkedList01);
		//void addFirst(E e) 将指定元素插入此列表的开头。
		linkedList01.addFirst("ddd");
		linkedList01.push("eee");//void push(E e) 将该元素插入此列表的开头。 此方法等效于 addFirst(E)。
		System.out.println(linkedList01);
		System.out.println("--------------------");
		LinkedList<String> linkedList02 = new LinkedList<String>();
		linkedList02.addLast("b");
		linkedList02.addLast("c");
		linkedList02.addLast("d");
		linkedList02.addFirst("3");
		linkedList02.addFirst("2");
		linkedList02.addFirst("1");
		System.out.println(linkedList02);
	}
}

HashSet接口特点：

  1.底层是个哈希表（数组+链表）; 查询快，又增删快

  2.是一个无序的集合，储存元素和取出的可能不一致 

  此类为基本操作提供了稳定性能，这些基本操作包括 add、remove、contains 和 size，

  假定哈希函数将这些元素正确地分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例的大小（元素的数量）和底层 HashMap 

  实例（桶的数量）的“容量”的和成比例。因此，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。 

public class HashSetDemo {
	public static void main(String[] args) {
		HashSet<String> hashSet = new HashSet<String>();
		hashSet.add("张三");
		hashSet.add("李四");
		hashSet.add("王五");
		hashSet.add("赵六");		
		//使用迭代器
		Iterator<String> iterator = hashSet.iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.println(string);
		}
		System.out.println("-----------");
		for (String string : hashSet) {
			System.out.println(string);
		}
		//赵六
		//张三
		//李四
		//王五
	}
}

java.util.LinkedHashSet集合 extends HashSet implments Set接口
  特点：
   1.不允许重复元素
   2.底层是哈希表(数组+单向链表) + 单向链表组成，就是一个双向链表，新添加的链表就可以保证迭代顺序

public class LinkedHashSetDemo {
	public static void main(String[] args) {
		LinkedHahSetM();
		
		//保证ArrayList集合中元素不重复
		ArrayList<Integer> arrayList = new ArrayList<Integer>();
		arrayList.add(1);
		arrayList.add(1);
		arrayList.add(1);
		System.out.println(arrayList);//[1, 1, 1]
		
		LinkedHashSet<Integer> hashSet = new LinkedHashSet<Integer>();
		for (Integer integer : arrayList) {
			hashSet.add(integer);
		}
		System.out.println(hashSet);//[1]		
	}

	private static void LinkedHahSetM() {
		//不允许重复，无序的
		HashSet<String> hashSet = new HashSet<String>();
		hashSet.add("杨贵妃");
		hashSet.add("貂蝉");
		hashSet.add("貂蝉");
		hashSet.add("西施");
		System.out.println(hashSet);//[西施, 杨贵妃, 貂蝉]
		System.out.println("--------");
		//不允许重复，有序的
		LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
		linkedHashSet.add("杨贵妃");
		linkedHashSet.add("貂蝉");
		linkedHashSet.add("貂蝉");
		linkedHashSet.add("西施");
		System.out.println(linkedHashSet);//[杨贵妃, 貂蝉, 西施]
	}
}

5.哈希值

  哈希值：是一个十进制的整数，由操作系统随机给的
  注意:如果给出的这个哈希值，没有其它使用，那么会重复给出
  Object类中有一个方法叫 HashCode
intHashCode  返回该对象的哈希码值

public class HashCodeDemo {
	public static void main(String[] args) {
		personHashCode();
	}
	private static void personHashCode() {
		Person person = new Person();
		int hashCode = person.hashCode();
		System.out.println(hashCode);//1321522194
		/*
		 *    	xinfei.code.data.Demo_03.Person@5c3f1224      把十进制的整数转换为十六进制
		 * 反射	return getClass().getName()  + @ + Interger.toHexString(HashCode());
		 */
		System.out.println(person);
	}	
}

HashSet储存数据不重复原理

/*
 * HashSetc存储数据不重复的原理
 */
public class StringHashCodeDemo {
	public static void main(String[] args) {
		String str01 = new String("abc");
		String str02 = new String("abc");
		String str03 = "abc";
		System.out.println(str01.hashCode());//96354
		System.out.println(str02.hashCode());//96354
		System.out.println(str03.hashCode());//96354
	}
}

String类重写Object类的HashCode方法；String类底层是一个字符数组：用数组存储多个字符

private final char value[];

private int hash; // Default to 0

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
 }

//第一次遍历：h = 31*h+val[0] = 31*0+'a' = 97
//第二次遍历：h = 31*h+val[1] = 31*97+'b' = 3007 + 98 = 3105
/第三次遍历：h = 31*h+val[2] = 31*3105+'c' = 96255 + 99 = 96354