小记

 * Collections集合工具类
 * 		public static <T> boolean addAll(Collection<? super T> c,T... elements)
 * 		将所有指定元素添加到指定 collection 中。
 * 		public static void reverse(List<?> list)
 * 			反转指定列表中元素的顺序。
 * 		public static void shuffle(List<?> list)
 * 			使用默认随机源对指定列表进行置换。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> x = new ArrayList();
        Collections.addAll(x,"abc","acb","bac","bca","cab","cba");
        System.out.println("x = " + x);
        Collections.reverse(x);
        System.out.println("x = " + x);
        Collections.sort(x);
        System.out.println("x = " + x);
        Collections.shuffle(x);
        System.out.println("x = " + x);
    }
}

	x = [abc, acb, bac, bca, cab, cba]
	x = [cba, cab, bca, bac, acb, abc]
	x = [abc, acb, bac, bca, cab, cba]
	x = [bac, abc, bca, cba, cab, acb]
		
	Process finished with exit code 0

 * Vector集合的特点:
 * 		1.具备List集合的特点(一共四点)
 * 			a.List集合是一个有序的集合
 * 				有序:存入的顺序和取出的顺序是一致的
 * 				无序:存入的顺序和取出的顺序不是一致的
 * 			b.List集合是一个含有索引的集合
 * 			c.List集合是一个可以存储重复元素的集合
 * 			d.List集合有4种遍历方式
 * 		2.Vector集合底层数据结构是数组
 * 			数组数据结构的特点:相比链表结构
 * 				查询效率高(索引),增删效率低(new)
 * 		3.创建Vector集合,数组初始化大小取决于用了哪个构造器
 * 			public Vector(Collection<? extends E> c)
 * 				数组初始长度:根据参数集合进行构建数组大小
 * 			public Vector(int initialCapacity)
 * 				数组初始长度:自定义
 * 			public Vector()
 * 				数组初始长度:长度为10
 * 				Vector()在JDK1.2版本之后代码就没有修改过
 * 		4.数组如何进行自动扩容
 * 				原来数组的长度 + 原来数组的长度
 * 		5.线程安全性:
 * 				Vector是一个线程安全的集合,效率比较低
 * 				Vector在JDK1.2这个版本被ArrayList进行取代
 *

 * ArrayList,LinkedList,Vector
 * 		1.底层数据结构
 * 			ArrayList:数组
 * 			LinkedList:链表
 * 			Vector:数组
 * 		2.数据结构的特点:
 * 			ArrayList:查询快,增删慢
 * 			LinkedList:查询慢,增删快
 * 			Vector:查询快,增删慢
 * 		3.线程安全性:
 * 			ArrayList:线程不安全,效率高
 * 			LinkedList:	线程不安全,效率高
 * 			Vector:线程安全,效率低
 *
 * 	如果选择List集合
 * 		如果查询数据偏多,选择ArrayList
 * 		如果增删数据偏多,选择LinkedList
 *

 * Map<key,value>
 *     1.Map集合中含有两个值(一对值),一个是key,一个value
 *     2.一个映射不能包含重复的键；每个键最多只能映射到一个值
 *     3.在Map集合中value是可以重复的
 *
 * Map集合的常用方法:
 * 		V put(K key, V value)
 * 			将指定的值与此映射中的指定键关联
 * 			返回值:原来映射关系中的value值
 * 		V remove(Object key)
 * 			如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
 * 		V get(Object key)
 * 			返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
 * 		boolean containsKey(Object key)
 * 			如果此映射包含指定键的映射关系，则返回 true。
 *

public class Test {
    public static void main(String[] args) {
        Map<String ,String > x = new HashMap<>();
        x.put("1","1");
        x.put("2","2");
        x.put("3","3");
        x.put("4","4");
        x.put("5","5");
        System.out.println("x = " + x);

        String remove = x.remove("1");
        System.out.println("remove = " + remove);

        String get = x.get("2");
        System.out.println("get = " + get);

        System.out.println("x.containsKey(\"1\") = " + x.containsKey("1"));

        System.out.println("x.containsKey(\"2\") = " + x.containsKey("2"));


    }
}


		x = {1=1, 2=2, 3=3, 4=4, 5=5}
		remove = 1
		get = 2
		x.containsKey("1") = false
		x.containsKey("2") = true
		
		Process finished with exit code 0

 * Map集合遍历方式1:通过key找value
public class Test {
    public static void main(String[] args) {
        Map<String ,String > x = new HashMap<>();
        x.put("1","1");
        x.put("2","2");
        x.put("3","3");
        x.put("4","4");
        x.put("5","5");
        Set<String> y = x.keySet();
        System.out.println("y = " + y);
    }
}

	y = [1, 2, 3, 4, 5]
	
	Process finished with exit code 0

 * Set接口集合通用特点:
 * 		1.Set集合是一个不可以存储重复元素
 * 		2.Set集合最多包含一个 null 元素
 * 		3.Set集合没有索引值
 * 		4.Set集合里面包含有序的集合,也包含无序的集合,所以不能说Set集合是无序或者有序
 * 			无序:存入的顺序和取出顺序不一致
 * 			有序:存入的顺序和取出顺序一致


 * HashSet的特点:
 * 		1.HashSet集合是一个不可以存储重复元素
 * 		2.HashSet集合最多包含一个 null 元素
 * 		3.HashSet集合没有索引值
 * 		4.HashSet集合的底层数据结构是:哈希表(实际上是一个 HashMap 实例)
 * 			哈希表:
 * 				JDK7.0(包含)	以前:数组 + 链表
 * 				JDK8.0(包含)以后:数组 + 链表 或者 数组+红黑树 (在讲解HashMap的时候关注什么时候由链表转换为红黑树)
 *		5.HashSet集合是一个无序的集合
 *		6.HashSet集合也是在JDK1.2版本新增的,线程不安全,效率高

 * HashSet集合保证元素唯一的原理:
 * 		1.重写Object类的hashCode()
 * 		2.重写Object类的eqauls()
 *
 * 在String类中hashCode()中为什么乘以的数字时31,而不是其他数字?
 * 		1.默认数字不能太大,如果太大,当字符串过长的时候,h值会超出int的取值范围
 * 		2.如果大小,字符串的h值重复的概率太大
 * 		3.为了降低h值的重复性,选择质数
 * 			Java工程师经过一系列测试:发现2个数字比较好:29和31
 * 		4.因为31数字它写法和整数取值范围的格式是一样的,选择31
 *
 * 	abc:96354
 * 	"通话" :1179395
 * 	"重地":1179395
 *

public class SetDemo04 {
	public static void main(String[] args) {
		HashSet<String> hs = new HashSet<>();

		String s1 = new String("abc");
		String s2 = new String("abc");

		hs.add(s1);
		hs.add(s2);
		hs.add("通话");
		hs.add("重地");

		System.out.println(hs);
	}
}

 * LinkedHashSet的特点:
 * 		1.LinkedHashSet集合是一个不可以存储重复元素
 * 		2.LinkedHashSet集合最多包含一个 null 元素
 * 		3.LinkedHashSet集合没有索引值
 * 		4.LinkedHashSet集合的底层数据结构是:哈希表(实际上是一个 HashMap 实例) + 链表
 * 			哈希表:
 * 				JDK7.0(包含)	以前:数组 + 链表
 * 				JDK8.0(包含)以后:数组 + 链表 或者 数组+红黑树 (在讲解HashMap的时候关注什么时候由链表转换为红黑树)
 * 			链表:
 * 				记录元素存储的顺序,保证迭代顺序
 *		5.LinkedHashSet集合是一个有序的集合
 *		6.LinkedHashSet集合也是在JDK1.4版本新增的,线程不安全,效率高




 * TreeSet集合的特点:
 *		1.数据结构:红黑树
 *		2.特点:
 *			就是针对集合中的数据进行自然排序
 *			String类:根据码表数值
 *			Integer类:数字的大小
 *			自定义类型:需要通过自然排序或者定制排序,给其制定比较规则
 *				自然排序:
 *					让比较的类型实现Comparable<T>,重写接口中的方法
 *				定制排序:
 *					让比较的类型实现Comparator<T>,重写接口中的方法
 *
 *		3.TreeSet集合不可以存储null值