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的区别
- Enumeration的速度更快是Iterator的两倍,也使用更少的内存。
- 与Enumeration相比,Iterator更加安全,因为当一个集合正在被遍历的时候,它会阻止其它线程去修改集合。
- 迭代器取代了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]