一、ArrayList
动态扩容分析
在Java中,由于数组的大小是固定的,所以扩容会申请一个更大的数组,然后把引用指向新的数组。
代码实现:
/**
* 保证要有capacity的容量(elements数组的长度)
* @param capacity
*/
private void ensureCapacity(int capacity){
int oldCapacity = elements.length;
//如果现在容量够,则不用扩容
if(oldCapacity >= capacity) {return;}
else {
//如果不够,则扩容。 *1.5
int newCapacity = oldCapacity + (oldCapacity >> 1);
System.out.println("扩容后长度:" + newCapacity);
int[] newElements = new int[newCapacity];
//移动元素
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
//更换引用
elements = newElements;
}
}
泛型分析
有的时候我们的集合中需要放对象,这时候我们可以用泛型来解决。
使用泛型技术可以让动态数组更加通用,可以存放任何数据类型。
public class ArrayList<E>{
elements = (E[]) new Object[capacity];
}
ArrayList<Integer> list = new ArrayList();
注意:对象数组的存储方式:
内存管理细节:
以前的清除(clear)操作:
/**
* 清除所有元素
*/
public void clear(){
//只要size=0别人就拿不到其中的元素了(对使用者来说已清除)
size = 0;
}
泛型之后的清楚操作:
不但要销毁数组名与数组的引用,还要销毁数组元素与对象的引用。
/**
* 清除所有元素
*/
public void clear(){
// //只要size=0别人就拿不到其中的元素了(对使用者来说已清除)
// size = 0;
for (int i = 0; i < size; i++) {
elements[i] = null; //销毁数组元素与对象的引用
}
size = 0;
}
remove()细节
/**
* 删除元素
* 删除当前下标的元素 == 把它之后的元素往前移动,size--,最后设置为null
* @param index
* @return elements[index]
*/
public E remove(int index){
E old = elements[index];
rangeCheck(index);
for (int i = index+1; i < size; i++) {
elements[i-1] = elements[i];
}
size--;
elements[size] = null;
return old;
}
手写ArrayList
package 链式结构.arraylist;
/**
* @ClassName: ArrayList
* @Description: 自定义Arraylist
* @author: wangz
* @date: 2021-12-24 15:00
*/
public class ArrayList<E> {
/**
* 动态数组成员变量的设计
* 1.size 元素的数量
* 2.elements 用于存储元素
* 3.DEFAULT_CAPACITY 默认容量
*/
private int size;
private E[] elements;
private static final int DEFAULT_CAPACITY = 10;
private static final int ELEMENT_NOT_FOUND = -1;
/*===========构造方法================*/
public ArrayList(){
this(DEFAULT_CAPACITY);
}
public ArrayList(int capaticy){
capaticy = (capaticy < DEFAULT_CAPACITY ? DEFAULT_CAPACITY : capaticy);
elements = (E[]) new Object[capaticy];
}
/*===========成员方法===============*/
/**
* 元素的数量
*/
public int size(){
return size;
}
/**
* 判断是否为空
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 获取index位置的元素
* @return
*/
public E get(int index){
rangeCheck(index);
return elements[index];
}
/**
* 设置新元素,返回原来的元素
*/
public E set(int index, E element){
rangeCheck(index);
E old = elements[index];
elements[index] = element;
return old;
}
/**
* 遍历元素,返回下标
*/
public int indexOf(E element){
if (element == null){
for (int i = 0; i <size ; i++) {
if (elements[i] == null){return i;}
}
}else {
for (int i = 0; i < size; i++) {
if (elements[i].equals(element)) {
return i;
}
}
}
return ELEMENT_NOT_FOUND;
}
/**
* contains ,是否包含某个元素
*/
public boolean contains(E element){
return indexOf(element) != ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
// //只要size=0别人就拿不到其中的元素了(对使用者来说已清除)
// size = 0;
for (int i = 0; i < size; i++) {
elements[i] = null; //销毁数组元素与对象的引用
}
size = 0;
}
/**
* 新增元素
* 往size的位置放元素
* @param element
*/
public void add(E element){
// elements[size++] = element;
add(size,element);
}
/**
* 打印
*/
@Override
public String toString(){
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("size=")
.append(size)
.append(",[");
for (int i = 0; i < size; i++) {
if (i != 0){
stringBuilder.append(",");
}
stringBuilder.append(elements[i]);
}
stringBuilder.append("}");
return stringBuilder.toString();
}
/**
* 删除元素
* 删除当前下标的元素 == 把它之后的元素往前移动,size--,最后设置为null
* @param index
* @return elements[index]
*/
public E remove(int index){
E old = elements[index];
rangeCheck(index);
for (int i = index+1; i < size; i++) {
elements[i-1] = elements[i];
}
size--;
elements[size] = null;
return old;
}
/**
* 添加元素
* 让当前元素的值==element、后面的元素往后移动、size--
* @param index
* @param element
*/
public void add(int index,E element){
rangeCheckForAdd(index);
ensureCapacity(size+1);
for (int i = size-1; i >= index; i--) {
elements[i+1] = elements[i];
}
elements[index] = element;
size++;
}
/*================保证容量================*/
/**
* 保证要有capacity的容量(elements数组的长度)
* @param capacity
*/
private void ensureCapacity(int capacity){
int oldCapacity = elements.length;
//如果现在容量够,则不用扩容
if(oldCapacity >= capacity) {return;}
else {
//如果不够,则扩容。 *1.5
int newCapacity = oldCapacity + (oldCapacity >> 1);
System.out.println("扩容后长度:" + newCapacity);
E[] newElements = (E[]) new Object[newCapacity];
//移动元素
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
//更换引用
elements = newElements;
}
}
/*================异常封装=================*/
private void outOfBoundsException(int index){
throw new IndexOutOfBoundsException("Index"+index+",Size"+size);
}
private void rangeCheck(int index){
if (index < 0 || index >= size){
outOfBoundsException(index);
}
}
private void rangeCheckForAdd(int index){
if (index < 0 || index > size){
outOfBoundsException(index);
}
}
}
JDK源码分析
源码中的扩容:
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
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);
}