一些基本概念和细节
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;
}
}