本篇文章解决以下问题:
目录
1、Arrays.asList()返回的集合为什么不可新增,删除?
2、ArrayList的实现为什么实现了List,又要继承AbstractList?
3、为什么访问Collection尽量使用for each 循环?
4、集合的拷贝如何使用?
5、集合的初始化大小如何设计比较好?
1、Arrays.asList()返回的集合为什么不可新增,删除?
private static void problem1() {
List strings = Arrays.asList("1", "2", "3");
strings.set(0, "0");// 操作成功,返回【"0", "2", "3"】
strings.add("4");// 提示UnsupportedOperationException
strings.remove(2);// 提示UnsupportedOperationException
}
原因是Arrays.asList()返回的是Arrays的内部类ArrayList,该类继承了AbstractList,AbstractList只要求实现get()和size()方法,且内部类ArrayList,也没有去复写add()和remove方法,那么就会抛出
UnsupportedOperationException!
2、ArrayList的实现为什么实现了List,又要继承AbstractList?
首先List接口,可以看到几个主要的接口方法:
- 在末尾添加一个元素:boolean add(E e)
- 在指定索引添加一个元素:boolean add(int index, E e)
- 删除指定索引的元素:E remove(int index)
- 删除某个元素:boolean remove(Object e)
- 获取指定索引的元素:E get(int index)
- 获取链表大小(包含元素的个数):int size()
这些接口仔细看的话在AbstractList都是已经实现过了,只是大部分都是抛出UnsupportedOperationException,我想设计者用此将需要单独实现增删的单独拎出来实现接口,告知开发者这是个可增删的集合类;(仔细读一下这些类的注释应该就能明白)
3、为什么访问Collection尽量使用for each 循环?
我们来比较一下ArrayList和LinkedList:
ArrayList LinkedList 获取指定元素 速度很快 需要从头开始查找元素 添加元素到末尾 速度很快 速度很快 在指定位置添加/删除 需要移动元素 不需要移动元素 内存占用 少 较大
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
for (int i=0; i
在for循环的内部我们通过get()方法获取下标i对应的元素,ArrayList由于是数组实现,是被分配的连续地址,可以通过首个元素的下标内存地址很快获取到下标i对应的内存地址;对于链表,由于是通过指针连接,要获取下标i对应的内存地址,需要从第一个元素开始逐个遍历;(双向链表会根据下标的位置判断是从头还是从尾部开始遍历);使用链表进行遍历的时候,每次获取下标i的元素都需要从头开始,这个时候如果能够获取到前一个元素该有多好,迭代器就是用来干这个的!
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
for (Iterator it = list.iterator(); it.hasNext(); ) {
String s = it.next();
System.out.println(s);
}
}
Java的for each循环本身就可以帮我们使用Iterator遍历。
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
for (String s : list) {
System.out.println(s);
}
}
4、集合的拷贝如何使用?
private static void problem4() {
// 基础数据类型拷贝
List integers = new ArrayList<>();
integers.add(0);
integers.add(1);
integers.add(2);
integers.add(3);
ArrayList integers1 = new ArrayList<>(integers);
for (int i = 0; i < integers.size(); i++) {
integers.set(i, integers.get(i) + 1);
}
System.out.println(integers);// [1, 2, 3, 4]
System.out.println(integers1);// [0, 1, 2, 3]
// 对象浅拷贝
List personList = new ArrayList<>();
personList.add(new Person(0, "0"));
personList.add(new Person(1, "1"));
personList.add(new Person(2, "2"));
personList.add(new Person(3, "3"));
List personList1 = new ArrayList<>(personList);
for (int i = 0; i < personList.size(); i++) {
Person person = personList.get(i);
person.setId(i + 10);
personList.set(i, person);
}
System.out.println(personList);// 两个值一样
System.out.println(personList1);
}
private static class Person {
private int id;
private String name;
public Person(int id, String name) {
this.id = id;
this.name = name;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + ''' +
'}';
}
}
5、集合的初始化大小如何设计比较好?
这里主要比较jdk1.8,ArrayList和HashMap:
- ArrayList的初始化容量为10,超过10时进行扩容,扩容为1.5倍 = 15;
- HashMap的初始化容量为16,有一个装载因子 = 0.75,超过16*0.75 = 12时进行扩容,扩容为初始化容量*2 = 32;
测试ArrayList,debug ArrayList的89行,执行下面的代码
private static void problem5() {
List integers = new ArrayList<>();
for (int i = 0; i < 11; i++) {
integers.add(i);
}
}
注意要多点几次向下执行,因为每次新增都会进入;
测试HahsMap,debug之前先取消掉ArrayList的debug,不然又会进入到ArrayList的debug哪里;
private static void problem52() {
HashMap map = new HashMap<>();
for (int i = 0; i < 13; i++) {
map.put(i, i);
}
}
HashMap为什么要使用16,2的幂次做为初始化容量?后续补!
首先List
- 在末尾添加一个元素:boolean add(E e)
- 在指定索引添加一个元素:boolean add(int index, E e)
- 删除指定索引的元素:E remove(int index)
- 删除某个元素:boolean remove(Object e)
- 获取指定索引的元素:E get(int index)
- 获取链表大小(包含元素的个数):int size()
这些接口仔细看的话在AbstractList都是已经实现过了,只是大部分都是抛出UnsupportedOperationException,我想设计者用此将需要单独实现增删的单独拎出来实现接口,告知开发者这是个可增删的集合类;(仔细读一下这些类的注释应该就能明白)
3、为什么访问Collection尽量使用for each 循环?
我们来比较一下ArrayList和LinkedList:
| ArrayList | LinkedList | |
|---|---|---|
| 获取指定元素 | 速度很快 | 需要从头开始查找元素 |
| 添加元素到末尾 | 速度很快 | 速度很快 |
| 在指定位置添加/删除 | 需要移动元素 | 不需要移动元素 |
| 内存占用 | 少 | 较大 |
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
for (int i=0; i
在for循环的内部我们通过get()方法获取下标i对应的元素,ArrayList由于是数组实现,是被分配的连续地址,可以通过首个元素的下标内存地址很快获取到下标i对应的内存地址;对于链表,由于是通过指针连接,要获取下标i对应的内存地址,需要从第一个元素开始逐个遍历;(双向链表会根据下标的位置判断是从头还是从尾部开始遍历);使用链表进行遍历的时候,每次获取下标i的元素都需要从头开始,这个时候如果能够获取到前一个元素该有多好,迭代器就是用来干这个的!
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
for (Iterator it = list.iterator(); it.hasNext(); ) {
String s = it.next();
System.out.println(s);
}
}
Java的for each循环本身就可以帮我们使用Iterator遍历。
public static void main(String[] args) {
List list = List.of("apple", "pear", "banana");
for (String s : list) {
System.out.println(s);
}
}
4、集合的拷贝如何使用?
private static void problem4() {
// 基础数据类型拷贝
List integers = new ArrayList<>();
integers.add(0);
integers.add(1);
integers.add(2);
integers.add(3);
ArrayList integers1 = new ArrayList<>(integers);
for (int i = 0; i < integers.size(); i++) {
integers.set(i, integers.get(i) + 1);
}
System.out.println(integers);// [1, 2, 3, 4]
System.out.println(integers1);// [0, 1, 2, 3]
// 对象浅拷贝
List personList = new ArrayList<>();
personList.add(new Person(0, "0"));
personList.add(new Person(1, "1"));
personList.add(new Person(2, "2"));
personList.add(new Person(3, "3"));
List personList1 = new ArrayList<>(personList);
for (int i = 0; i < personList.size(); i++) {
Person person = personList.get(i);
person.setId(i + 10);
personList.set(i, person);
}
System.out.println(personList);// 两个值一样
System.out.println(personList1);
}
private static class Person {
private int id;
private String name;
public Person(int id, String name) {
this.id = id;
this.name = name;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + ''' +
'}';
}
}
5、集合的初始化大小如何设计比较好?
这里主要比较jdk1.8,ArrayList和HashMap:
- ArrayList的初始化容量为10,超过10时进行扩容,扩容为1.5倍 = 15;
- HashMap的初始化容量为16,有一个装载因子 = 0.75,超过16*0.75 = 12时进行扩容,扩容为初始化容量*2 = 32;
测试ArrayList,debug ArrayList的89行,执行下面的代码
private static void problem5() {
List integers = new ArrayList<>();
for (int i = 0; i < 11; i++) {
integers.add(i);
}
}
注意要多点几次向下执行,因为每次新增都会进入;
测试HahsMap,debug之前先取消掉ArrayList的debug,不然又会进入到ArrayList的debug哪里;
private static void problem52() {
HashMap map = new HashMap<>();
for (int i = 0; i < 13; i++) {
map.put(i, i);
}
}
HashMap为什么要使用16,2的幂次做为初始化容量?后续补!



