目录
1. ArrayList简介
在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：
【说明】
- ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
- ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
- ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
- 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList(用的较多)
- ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表
2. ArrayList使用
2.1 浅谈ArrayList 的三种构造方法
| 方法 | 解释 |
|---|---|
| ArrayList() | 无参构造 |
| ArrayList(Collection<? extends E> c) | 利用其他 Collection 构建 ArrayList |
| ArrayList(int initialCapacity) | 指定顺序表初始容量 |
2.1.1ArrayList()构造方法
// 无参的构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
可以看出来，当我们直接创建ArrayList时，elementData被赋予了 默认空容量 \color{red}{默认空容量} 默认空容量的数组。注意，因为默认空容量数组是被final修饰的，此时ArrayList数组是空的、固定长度的，也就是说其容量此时是0，元素个数size为默认值0。
没有添加元素的时候容量为空，添加了以后容量为 10 ，若满则以 1.5 倍去扩容 \color{red}{没有添加元素的时候容量为空，添加了以后容量为10，若满则以1.5倍去扩容} 没有添加元素的时候容量为空，添加了以后容量为10，若满则以1.5倍去扩容
2.1.2 ArrayList(Collection<? extends E> c)构造方法
// 传容量的构造方法
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
-
当initialCapacity > 0时，会在堆上new一个大小为initialCapacity的数组，然后将其引用赋给elementData，此时ArrayList的容量为initialCapacity，元素个数size为默认值0。
-
当initialCapacity = 0时，elementData被赋予了默认空数组，因为其被final修饰了，所以此时ArrayList的容量为0，元素个数size为默认值0。
-
当initialCapacity < 0时，会抛出异常
2.1.3 ArrayList(int initialCapacity)构造方法
// 传入Collection元素列表的构造方法
public ArrayList(Collection<? extends E> c) {
// 将列表转化为对应的数组
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// 此处见下面详细解析
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 赋予空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}
传入Collection元素列表后，构造方法首先会将其转化为数组，将其索引赋给elementData。
如果此数组的长度为0，会重新赋予elementData为空数组，此时ArrayList的容量是0，元素个数size为0。
如果此数组的长度大于0，会更新size的大小为其长度，也就是元素的个数，然后执行里面的程序。大家对里面的代码可能不理解，让我们等会看下面解析。执行完后此时ArrayList的容量为传入序列的长度，也就是size的大小，同时元素个数也为size，也就是说，此时ArrayList是满的。
public static void main(String[] args) {
// ArrayList创建，推荐写法
// 构造一个空的列表
List<Integer> list1 = new ArrayList<>();
// 构造一个具有10个容量的列表
List<Integer> list2 = new ArrayList<>(10);
list2.add(1);
list2.add(2);
list2.add(3);
// list2.add("hello"); // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
// list3构造好之后，与list中的元素一致
ArrayList<Integer> list3 = new ArrayList<>(list2);
// 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
List list4 = new ArrayList();
list4.add("111");
list4.add(100);
}
3. List 的几种遍历方式
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(12);
list.add(23);
list.add(34);
System.out.println("=========通过变量名直接打印=========");
System.out.println(list);
System.out.println("=========for循环=========");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
System.out.println();
System.out.println("=========foreach=========");
for (int x:list) {
System.out.print(x + " ");
}
System.out.println();
System.out.println("=========迭代器1=========");
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println();
System.out.println("=========迭代器2=========");
ListIterator<Integer> it2 = list.listIterator();
while (it.hasNext()) {
System.out.print(it2.next() + " ");
}
System.out.println();
}
4. ArrayList的扩容机制
ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容：以下是ArrayList源码中扩容方式
Object[] elementData; // 存放元素的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空间
private static final int DEFAULT_CAPACITY = 10; // 默认容量大小
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// 获取旧空间大小
int oldCapacity = elementData.length;
// 预计按照1.5倍方式扩容
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 调用copyOf扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
【总结】
【总结】
- 检测是否真正需要扩容，如果是调用grow准备扩容
- 预估需要库容的大小
- 初步预估按照1.5倍大小扩容
- 如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
- 真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
- 使用copyOf进行扩容
5. 使用实例
5.1 扑克牌
class Card {
public int rank;// 数值
public String suit;// 花色
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
//打印牌
@Override
public String toString() {
return suit + " " + rank;
}
}
public class CardDemo {
public static final String[] suits = {"♥","♠","♣","♦"};
// 买牌
public List<Card> buyDeskCard() {
List<Card> cards = new ArrayList<>();
for (int i = 1; i <= 13; i++) {
for (int j = 0; j < 4; j++) {
Card card = new Card(i,suits[j]);
cards.add(card);
}
}
return cards;
}
// 洗牌
public void shuffle(List<Card> cards) {
for (int i = cards.size()-1; i > 0; i--) {//52张牌 最后一个下标为51
Random random = new Random();
int index = random.nextInt(i);
swap(cards,index,i);
}
}
// 交换牌
private void swap(List<Card> cards,int i, int j) {
// Card tmp = cards[i];
Card tmp = cards.get(i);
cards.set(i,cards.get(j));
cards.set(j,tmp);
// cards[i] = cards[j];
// cards[j] = cards[tmp];
}
// 揭牌
public List<List<Card>> test(List<Card> cards) {
List<Card> hand1 = new ArrayList<>();
List<Card> hand2 = new ArrayList<>();
List<Card> hand3 = new ArrayList<>();
List<List<Card>> hands = new ArrayList<>();
hands.add(hand1);
hands.add(hand2);
hands.add(hand3);
// 有三个人, 每个人轮流抓4张牌
for (int i = 0; i < 4; i++) {// 揭牌
for (int j = 0; j < 3; j++) {// 人
// 你怎么知道 哪张牌 放到哪个hand中
Card card = cards.remove(0);// 揭走相当于删除了
hands.get(j).add(card);
}
}
return hands;
}
//测试
public static void main(String[] args) {
CardDemo cardDemo = new CardDemo();
List<Card> ret = cardDemo.buyDeskCard();
System.out.println("未洗牌: ");
System.out.println(ret);
System.out.println("洗牌以后: ");
cardDemo.shuffle(ret);
System.out.println(ret);
System.out.println("揭牌: ");
List<List<Card>> ret2 = cardDemo.test(ret);
for (List<Card> cards : ret2) {
System.out.println(cards);
}
for (int i = 0; i < ret2.size(); i++) {
System.out.println("第" + i + "个人的牌" + ret2.get(i));
}
System.out.println("剩余的牌: ");
System.out.println(ret);
}
}
5.2 杨辉三角
class Solution {
public List<List<Integer>> generate(int numRows) {
List<List<Integer>> ret = new ArrayList<>();
List<Integer> list = new ArrayList<>();
list.add(1);
ret.add(list);
for (int i = 1; i < numRows; i++) {
// curRow 当前行
List<Integer> curRow = new ArrayList<>();
curRow.add(1);
// prevRow 上一行
List<Integer> prevRow = ret.get(i-1);
for (int j = 1; j < i; j++) {
int num = prevRow.get(j)+prevRow.get(j-1);
curRow.add(num);
}
curRow.add(1);
ret.add(curRow);
}
return ret;
}
}
public class Test2 {
public static void main(String[] args) {
Solution solution = new Solution();
List<List<Integer>> ret = solution.generate(4);
System.out.println(ret);
}
}
顺序表优缺点总结
- 定义：是一段地址连续的存储单元依次存储数据元素的线性结构
- 优点：存取速度高效，通过下标来直接存取
- 缺点：插入和删除比较慢，不可以实时增长长度
- 适用场景：适用于需要大量访问元素的，而增加/删除元素较少的程序
创作于：2022年10月16日17:36:43😅😅😅
扫一扫
3494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
