数据结构之动态数组

一些基本概念和细节

1.数组中所有元素的内存地址都是连续的，基本所有编程语言的数组都是不能动态修改容量的，定义时就确定了大小。

2.Java成员变量会自动初始化，int为0，对象为null。

3.动态数组扩容的本质是开辟更大的空间把数组原来的内容拷贝过去，而不可能找到一段内存正好接在原来数组的后面。

内存管理的细节

对于动态数组而言，普通数组和对象数组的存储方式是有本质区别的，普通数组中存储的是数值本身，对象数组存储的是对象地址。清除普通数组时，只要size=0，就可以虚拟表示内存释放了（并不是真的回收了数组所占的内存）。

对于对象数组，一方面我们想要重复利用数组，以避免add对象时又要耗费系统资源去开辟空间。但如果仅仅size=0，那么数组中的地址仍然指向对象，对象的内存不会回收，造成了资源浪费。（图中箭头断裂，也就是内存没有箭头指向的时候，Java回收机制会使得内存被回收。）所以要循环遍历使得数组中的地址为null。这样既释放了对象的空间，又使得数组空间重复利用。（objects=null 意味着数组空间和对象空间全部消灭。）

Object[] objects = new Object[7];创建对象数组objects。

int[] elements = new int[7]创建普通数组。

实现动态数组

public class Main {
	public static void main(String[] args) {
	
		//java.util.ArrayList;//内置的动态数组类
		
		/*
		Person[] person = new Person[3];
		person[0] = new Person(11, "hj");//对象数组存的是对象的地址，此时才分配类的空间
		*/
		
		/*如果是整数不能传 因为泛型要传一个类 Integer
		java中所有类都继承了java.long.Object*/
		ArrayList<Person> m_list = new ArrayList<>();//new是向堆申请内存
		m_list.add(new Person(18,"sj"));
		m_list.add(new Person(22,"sm"));
		m_list.clear();
		
		//打印数组 通过重写toString方法
		System.out.println(m_list);//本质是调用toString方法
		
		System.gc();//JVM只有内存不够了才回收，这句话可以提醒他快点回收
	}
}

/*这是自己手动编写的一个动态数组类*/
@SuppressWarnings("unchecked")
public class ArrayList<E> {
	//成员变量 
	private int size;//容量
	private E[] elements;//指向所有元素
	
	//控制初次创建数组大小
	private static final int DEFAULT_CAPACITY = 2;
	private static final int ELEMENT_NOT_FOUND = -1;
	//创建动态数组
	public ArrayList(int capacity) {
		capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
		elements = (E[]) new Object[capacity];
		
	}
	
	public ArrayList() {
		this(DEFAULT_CAPACITY);
	}
	
	public int size() {
		return size;
	}
	
	public boolean isEmpty() {
		return size == 0;
	}
	
	private void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	
	private void checkIndex(int index) {
		if(index < 0 || index >= size) {
			outOfBounds(index);
		}
	}
	
	private void checkIndexForAdd(int index) {
		if(index < 0 || index > size) {
			outOfBounds(index);
		}
	}
	/**
	 * 扩容的函数 
	 * @param capacity 需要的容量=size+1
	 */
	
	private void ensureCapacity(int capacity) {
		int oldCapacity = elements.length;
		if(oldCapacity >= capacity) return;
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		E[] newElements = (E[]) new Object[newCapacity];
		for (int i = 0; i < size; i++) {
			newElements[i] = elements[i];
		}
		elements = newElements;
		//System.out.println(oldCapacity+"扩容为"+newCapacity);
	}
	/**
	 * 获取索引位置的值
	 * @param index
	 * @return index位置的值
	 */
	public E get(int index) {
		checkIndex(index);
		return elements[index];
	}
	
	/**
	 *  设置index位置的值为element
	 * @param index
	 * @param element
	 * @return 返回index位置原来的值
	 */
	public E set(int index,E element) {
		checkIndex(index);
		E old = elements[index];
		elements[index] = element;
		return old;
	}
	
	/**
	 * 找到值的索引
	 * @param element
	 * @return index 找不到返回-1 用常量表示
	 */
	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++) 
				//因为element!=null所以互换
				if(element.equals(elements[i])) return i;
		}
		/*//这样写也不行,因为允许存入null,null不能调用方法
		for (int i = 0; i < size; i++) {
			//if(elements[i] == element) return i;//这样是比内存地址，那必须的是一模一样同一个类才相等
			if(elements[i].equals(element)) return i;
		}	*/	
		return ELEMENT_NOT_FOUND;
	}
	
	public boolean contains(E element) {
		return indexOf(element)!=ELEMENT_NOT_FOUND;
	}
	//巧妙的设计
	public void clear() {
		/*对象数组和普通数组clear的区别*/
		for (int i = 0; i < size; i++) {
			elements[i] = null;//让对象因为没有人指向它而消失
		}
		//这句话不对是因为 存地址的对象数组要重复利用
		//elements = null;//相当于数组也为空
		size = 0;//外面看起来失去了对空间的使用权
	}
	
	public void add(E element) {
		//elements[size] = element;
		//size++;
		add(size,element);
	}
	
	public E remove(int index) {
		checkIndex(index);
		E old = elements[index];
		for (int i = index + 1; i < size ; i++) {
			elements[i - 1] = elements[i];
		}
		elements[--size] = null;
		return old;
	}
	
	public void add(int index,E element) {
		checkIndexForAdd(index);
		ensureCapacity(size + 1);
		for (int i = size; i > index; i--) {
			elements[i] = elements[i-1];
		}
		elements[index] = element;
		size++;
	}
	
	//打印数组
	@Override 
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("size=").append(size).append(", [");
		for (int i = 0; i < size; i++) {
			if(i != 0) {//输出格式的一种控制办法
				string.append(", ");
			}
			string.append(elements[i]);
		}
		string.append("]");
		return string.toString();//StringBuilder 转换成string
	}
}

public class Person {
	private int age;
	private String name;
	public Person(int age, String name) {
		this.age = age;
		this.name = name;
	}
	@Override
	public String toString() {
		return "Person [age=" + age + ", name=" + name + "]";
	}
	@Override
	protected void finalize() throws Throwable {
		// TODO Auto-generated method stub
		super.finalize();
		
		System.out.println("Person-finalize");
	}
	@Override
	//不重写的话默认是比内存地址
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if(obj == null)  return false;
		if(obj instanceof Person) {//Object可以是任意类，不一定是Person
			Person person = (Person)obj;
			return this.age == person.age;
		}
		return false;
	}
	
}

PS：学习网站https://ke.qq.com/course/385223