清新区住房和城乡建设局网站网站首页不见怎么做

目录

基本概念

底层实现原理

底层数据结构

容量初始化机制

自动扩容机制

增删改查操作原理

内存管理细节

常用方法

遍历方式

普通for循环

增强for循环

Iterator 迭代器

Java 8 Lambda

ArrayList与线程安全

ArrayList与数组

常见误区与注意点

Java 8 Stream 结合使

基本概念

ArrayList 是 Java 集合框架中常用的 可变长度数组。

位于 java.util 包下。

实现了 List 接口，支持元素的 有序存储、重复元素。

特点：

• 动态数组结构（相比数组可自动扩容）

• 查询速度快（随机访问性能优）

• 插入、删除效率相对较低（涉及元素移动）

底层实现原理

底层数据结构

• ArrayList的底层是动态数组Object[] elementData来进行存储元素

• 初始时并不立即分配空间（JDK 1.8 起，懒加载）。

• 数组中元素是对象引用，对象本身存储在堆上。

容量初始化机制

在ArrayList的源码当中有这么几个成员变量

    // 默认的初始容量private static final int DEFAULT_CAPACITY = 10;
​//空数组实例private static final Object[] EMPTY_ELEMENTDATA = {};
​//用于默认尺寸的空尺寸的空数字实例。我们将其与empty_elementdata区分开，以知道添加第一个元素时会充气多少private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
​//存储元素的数组对象transient Object[] elementData; // non-private to simplify nested class access
​//大小private int size;

无参构造函数：

public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

注意：这里无参构造函数把数组初始化成了成员变量中的空数组对象DEFAULTCAPACITY_EMPTY_ELEMENTDATA

有参构造函数：

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);}}

这里是初始化一个有大小的数组对象并且赋值给elementData

public ArrayList(Collection<? extends E> c) {elementData = c.toArray();if ((size = elementData.length) != 0) {// c.toArray might (incorrectly) not return Object[] (see 6260652)if (elementData.getClass() != Object[].class)elementData = Arrays.copyOf(elementData, size, Object[].class);} else {// replace with empty array.this.elementData = EMPTY_ELEMENTDATA;}
}

这个构造函数是构建包含指定集合的元素列表，接受一个泛型的Collection对象

从源码中我们可以看到ArrayList中初始化了一个大小为10的成员变量

然后根据add方法中的源码：

public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;
}

只有在第一次add元素的时候才会初始化大小为10

也可以在创建ArrayList的时候直接指定大小

自动扩容机制

//ArrayList中的add方法
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 codeif (minCapacity - elementData.length > 0)grow(minCapacity);}
}//扩容private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length; //原数组的大小int newCapacity = oldCapacity + (oldCapacity >> 1); //新数组大小为原来的1.5倍if (newCapacity - minCapacity < 0) //新数组大小< 原数组newCapacity = minCapacity; //保持原数组大小if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity); //// minCapacity is usually close to size, so this is a win:elementData = Arrays.copyOf(elementData, newCapacity);}

详细解释以上代码：在add方法中首先调用ensureCapacityInternal方法，在方法中调用ensureExplicitCapacity是否需要扩容，calculateCapacity给数组默认大小为10，ensureExplicitCapacity将数组大小与10比对，如果数组大小 > 10，则需要扩容。然后将需要添加的元素追加到列表末尾。

增删改查操作原理

//查询元素E elementData(int index) {return (E) elementData[index];}//移除元素
public E remove(int index) {rangeCheck(index);
​modCount++;E oldValue = elementData(index);
​int numMoved = size - index - 1;if (numMoved > 0)System.arraycopy(elementData, index+1, elementData, index,numMoved);elementData[--size] = null; // clear to let GC do its workreturn oldValue;}//修改元素public E set(int index, E element) {rangeCheck(index);
​E oldValue = elementData(index);elementData[index] = element;return oldValue;
}

根据以上源码，我们可以看见查询的时间复杂度为O(1)，修改也是O(1),移除元素的话需要移动后面的元素，时间复杂度为O(n)

内存管理细节

我们知道ArrayList中的底层是动态数组，也是对象的一种，所以数组的指向是JAVA堆，所以我们将数组删除后需要将当前内存指向设置为NULL，有利于GC，不然容易导致内存泄漏。

常用方法

方法	说明
add(E e)	添加元素到末尾
add(int index, E e)	指定位置插入元素
remove(int index)	删除指定索引元素
remove(Object o)	删除指定对象（首次出现）
get(int index)	获取元素
set(int index, E e)	替换指定位置的元素
clear()	清空列表
contains(Object o)	是否包含元素
size()	返回当前元素数量
isEmpty()	判断是否为空
indexOf(Object o)	查找元素位置
toArray()	转换为数组

遍历方式

 List<String> list = new ArrayList<>();// 添加元素list.add("Hello");list.add("World");list.add("Java");

普通for循环

//普通遍历
for (int i = 0; i < list.size(); i++) {System.out.println("普通遍历元素 " + i + ": " + list.get(i));
}

增强for循环

//增强for循环
for (String item : list) {System.out.println("增强for循环元素: " + item);
}

Iterator 迭代器

//iterator遍历Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {System.out.println("Iterator元素: " + iterator.next());}

Java 8 Lambda

//lambda表达式遍历
list.forEach(item -> System.out.println("Lambda元素: " + item));

ArrayList与线程安全

• ArrayList 本身 不是线程安全的。

• 多线程同时读写时需加锁。

• 线程安全的替代方式：

以下代码执行情况按理来说数组长度应该是0

package com.hyh;
​
import java.util.ArrayList;
import java.util.List;
​
public class ArrayListThreadSafetyDemo {public static void main(String[] args) throws InterruptedException {List<Integer> list = new ArrayList<>();
​// 创建线程1：不断添加元素Thread t1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {list.add(i);}});
​// 创建线程2：不断读取元素Thread t2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {if (list.size() > 0) {list.remove(0); // 可能触发数组越界异常}}});
​t1.start();t2.start();t1.join();t2.join();
​System.out.println("最终列表大小: " + list.size());}
}

实际情况：

ArrayList与数组

特性	ArrayList	数组
大小	动态扩容	固定大小
类型	泛型对象	基本类型或对象
功能	支持增删查改	仅支持索引访问
安全性	支持越界检查	编译期固定大小
使用便捷性	方法丰富	操作较原始

List与数组的转换

//List转为数组
String[] array = list.toArray(new String[list.size()]);
//数组转为List
List<String> list1 = Arrays.asList(array);

常见误区与注意点

并发修改问题：

for (String item : list) {list.remove(item); // 会抛 ConcurrentModificationException
}

正确做法：

Iterator<String> it = list.iterator();
while (it.hasNext()) {it.next();it.remove(); // 合法
}

扩容频繁性能低：

建议使用构造函数设置初始容量：

new ArrayList<>(1000);

数组转列表陷阱：

Arrays.asList() 返回的是固定长度列表，不能进行 add/remove 操作。

基本类型不能直接使用：

必须使用包装类如 Integer，不能用 int。

Java 8 Stream 结合使用

List<String> hello = list.stream().filter(s -> s.startsWith("H")) // 过滤出 "Hello".map(String::toUpperCase) // 转为大写.collect(Collectors.toList());//将满足条件的收集成结合
​
hello.forEach(s -> System.out.println("转换后的元素: " + s));