Java核心技术第九章——集合

1. 集合分为Collection和Map接口

2. For-Each用法

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a");
arrayList.add("b");
arrayList.forEach(action->{
	String string = "ab";
	System.out.println(string+action);
});

Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "a");
map.put(2, "b");
map.forEach((k,v)->{
	System.out.println(k+v);
});

3. Iterator与Enumeration的区别

1. Enumeration的速度更快是Iterator的两倍，也使用更少的内存。
2. 与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。
3. 迭代器取代了Java集合框架中的Enumeration，迭代器允许调用者从集合中移除元素，而Enumeration不能移除元素。

4. 重写equals方法的同时一定要重写hashCode
重写equal方法的时候为什么要重写hashcode的方法

public class overwrite {
	public int a;
	public overwrite(int val){
		this.a = val;
	}
	@Override
	public boolean equals(Object k){
		if(this == k){
			return true;
		}
		if(k instanceof overwrite){
			overwrite s = (overwrite)k;
			return ((overwrite) k).a == s.a;
		}
		return false;
	}
	public int hashCode(){//不重写的话，下面的s1和s2的hashCode就会不同，但是s1和s2的id相同，理应认为s1=s2
		return this.a*10;
	}
	public static void main(String[] args){
		HashMap<overwrite,Integer> test = new HashMap<overwrite,Integer>();
		overwrite s1 = new overwrite(1);
		overwrite s2 = new overwrite(1);
		test.put(s1, 1);
		test.put(s2, 2);
		/**
		 * 不重写的情况
		 */
		System.out.println(test.get(s1));//1
		System.out.println(test.get(s2));//2
		//map里面的key应该是唯一的，这样却失去了唯一性。
		//注意TreeMap不是按照对象的散列值存储的，是比较对象的compareTo方法
		//如果compareTo返回0，则表示两个对象相同，则只存最后put上去的对象
	}
}

5. Arrays的用法
Arrays:用于操作数组的工具类，里面都是静态方法
参考Arrays类常用方法解析
1）Arrays.asList(T… data)将数组转为集合

String[] strings = {"a","b"};
List<String> sList = Arrays.asList(strings);
sList.forEach(s->System.out.println(s));

int[] a = {1,2,3};
List<int[]> iList = Arrays.asList(a);
iList.forEach(action->System.out.println(Arrays.toString(action)));//[1,2,3]

Integer[] aIntegers = {1,2,3};
List<Integer> iList2 = Arrays.asList(aIntegers);
iList2.forEach(action->System.out.println(action));//1,2,3

2）Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)从起始位置到结束位置，取头不取尾

		int[] c = {1,2,3,4,5};
		Arrays.fill(c,0,2,0);
		System.out.println(Arrays.toString(c));//[0,0,3,4,5]

3）Arrays.sort(T[] array, Comparator<? super T> comparator)使用自定义比较器，对数组元素进行排序 (串行排序)

		String[] str = {"ab","c","dd","aaa"};
		Arrays.sort(str);//默认按字典顺序比较
		System.out.println(Arrays.toString(str));//[aaa, ab, c, dd]
		Arrays.sort(str,(o1,o2)->{
			return o1.length()-o2.length();
		});//lambda方式自定义比较器，按字符串长度排序
		System.out.println(Arrays.toString(str));//[c, ab, dd, aaa]

4）Arrays.binarySearch(Object[] array, Object key)在调用该方法之前，必须先调用 Arrays.sort() 方法进行排序，注意：当搜索元素是数组元素时，返回该元素的索引值；当搜索元素不是数组元素时，返回 - (索引值 + 1)

		int[] binaryArray = {1,3,5,7};
		System.out.println(Arrays.binarySearch(binaryArray, 1));//print 0
		System.out.println(Arrays.binarySearch(binaryArray, 2));//print -(1+1)
		System.out.println(Arrays.binarySearch(binaryArray, 0));//print -(0+1)
		System.out.println(Arrays.binarySearch(binaryArray, 9));//print -(4+1)

5）Arrays.copyOf(T[] original, int newLength)其内部调用了System.arraycopy() 方法

		int[] copyArray = {1,2,3,4};
		int[][] twoDimension = {{1,2},{3,4}};
		int[] copy1 = Arrays.copyOf(copyArray,copyArray.length);
		copy1[0] = 0;
		int[][] copy2 = Arrays.copyOf(twoDimension, twoDimension.length);
		copy2[0][0] = 0;
		System.out.println(Arrays.toString(copyArray));//print [1, 2, 3, 4]
		System.out.println(Arrays.deepToString(twoDimension));//print [[0, 2], [3, 4]] 未成功拷贝
		for(int i=0;i<twoDimension.length;i++) {
			copy2[i] = Arrays.copyOf(twoDimension[i], twoDimension[i].length);
		}
		copy2[0][0] = 1;
		System.out.println(Arrays.deepToString(twoDimension));//print [[0, 2], [3, 4]] 成功拷贝,twoDimension[0][0]不为1

6. Collections方法
Collections:集合框架的工具类，里面定义的都是静态方法。
Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法,它有两个常用的子接口:
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类,该类中的方法都是静态的。
提供的方法中有可以对list集合进行排序，二分查找等方法，通常常用的集合都是线程不安全的,因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
1）Collections.sort方法 对集合元素排序

		ArrayList<String> sortList = new ArrayList<>();
		sortList.add("aaa");
		sortList.add("bb");
		sortList.add("ba");
		Collections.sort(sortList);
		System.out.println(sortList.toString());// [aaa, ba, bb]
		Collections.sort(sortList,(a,b)->{
			return a.length()-b.length();
		});
		System.out.println(sortList.toString());// [ba, bb, aaa]

2）Collections.shuffle方法 随机打乱集合的元素

		ArrayList<Integer> shuffleList = new ArrayList<>();
		shuffleList.add(1);
		shuffleList.add(2);
		shuffleList.add(3);
		Collections.shuffle(shuffleList);
		System.out.println(shuffleList.toString());  //随即输出，也可能还是1,2,3

3）reverse()反转集合中元素的顺序

		ArrayList<Integer> reverseList = new ArrayList<>();
		reverseList.add(1);
		reverseList.add(2);
		reverseList.add(3);
		Collections.reverse(reverseList);
		System.out.println(reverseList); //[3, 2, 1]

4）max()\min()求集合的最大\最小值

		ArrayList<Integer> maxminList = new ArrayList<>();
		maxminList.add(1);
		maxminList.add(2);
		maxminList.add(3);
		System.out.println(Collections.max(maxminList));// 3
		System.out.println(Collections.min(maxminList));// 1

5）swap()交换集合的两个元素

		ArrayList<Integer> swapList = new ArrayList<>();
		swapList.add(1);
		swapList.add(2);
		swapList.add(3);
		Collections.swap(swapList, 0, 2);
		System.out.println(swapList.toString());// [3, 2, 1]

6）copy(List m,List n)将集合n中的元素全部复制到m中,并且覆盖相应索引的元素

		ArrayList<Integer> copy1List = new ArrayList<>();
		copy1List.add(1);
		copy1List.add(2);
		copy1List.add(3);
		//这样拷贝比较麻烦
		ArrayList<Integer> copy2List = new ArrayList<>(Arrays.asList(new Integer[copy1List.size()]));
		Collections.copy(copy2List, copy1List);
		//可以这样
		ArrayList<Integer> copy3List = new ArrayList<>(copy1List);
		//或者这样
		ArrayList<Integer> copy4List = (ArrayList<Integer>) copy1List.clone();
		System.out.println(copy2List.toString());// [1, 2, 3]

7）replaceAll(List list,Object old,Object new) 替换批定元素为某元素,若要替换的值存在刚返回true,反之返回false

		ArrayList<Integer> replaceAllList = new ArrayList<>();
		replaceAllList.add(1);
		replaceAllList.add(2);
		replaceAllList.add(3);
		replaceAllList.add(3);
		Collections.replaceAll(replaceAllList, 3, 1);
		System.out.println(replaceAllList); // [1, 2, 1, 1]