当我们不加static修饰的时候
我们需要创建一个对象才可以去访问
这里ArrayList是一个类名
当是用static修饰的方法的时候 我们用类名.方法名进行访问即可
清空的时候我们直接:
因为这条代码就已经告诉外界 我们动态数组的元素数量已经是0了 不可以再继续使用
这样我们可以在内部继续使用 也是一种节省空间的操作
删除元素:
把后面的元素往前挪就行了
注意一点:把77的值赋值给前面一个的时候
那么77怎么处理?
不处理即可 因为size--已经是告诉外界了 告诉了能访问的元素范围
当在某一个位置插入一个元素的时候
我们把这个位置及其以后的所有元素都往后挪动
申请一块更大的内存空间
Java有垃圾回收机制 会自动回收原来的空间内存
注意:
因为所有的类都是继承于Object这个类的
之后再强制转换为E[ ]类型
对象数组:
放地址节省空间
这个objects[0]等等 存放的是引用地址
注意:
当仅仅是销毁下标6处的引用指向这根线断掉
那么仅仅是下标为6处的元素被杀
倘若objects指向堆空间的主线断掉的时候
我们可知整个对象数组都没了
当我们new引用类型时
那么对clear这个方法就要进行更新
这里不可以单单的对size=0进行操作了
若只是只样操作 但是对象的引用地址指向依然是保存着的
也就是说对象依旧存在着 外部依旧可以调用
我们可以这样把每一个对象的引用地址给清空
但是我们的这块内存空间并没有消失
因此我们还可以在下一次new的时候创建新的对象 和引用指向
因此可循环利用。。
总代码:
package 链表动态数组.动态数组;
public class ArrayList<E> {
//元素的数量
private int size;
//所有的元素
private E[] element;
private static final int DEFAULT_CAPACITY=10;
private static final int ELEMENT_NOT_FOUND=-1;
public ArrayList(int capaticy) {
capaticy=(capaticy<DEFAULT_CAPACITY)?DEFAULT_CAPACITY:capaticy;
element= (E[]) new Object[capaticy];
}
public ArrayList(){
//当main函数中new一个对象的时候 会调用这个无参构造器
//把这个值传给有参构造器的参数
this(DEFAULT_CAPACITY);
}
/**
* 清除所有元素
*/
public void clear(){
for (int i = 0; i < size; i++) {
element[i]=null;
}
size=0;
}
/**
* 元素的数量
*/
public int size() {
return size;
}
/**
* 判断是否为空
*/
public boolean isEmpty(){
return size==0;
}
/**
* 判断是否包含某个元素
*/
public boolean contains(E elements){
return indexOf(elements)!=ELEMENT_NOT_FOUND;
}
/**
* 添加元素到尾部
*/
public void add(E elements) {
element[size++]=elements;
}
/**
* 获取index位置的元素
*/
public E get(int index) {
if(index<0||index>=size){
throw new IndexOutOfBoundsException("index");
}
return element[index];
}
/**
* 设置index位置的元素为elements
*/
public E set(int index,E elements){
if(index<0||index>=size){
throw new IndexOutOfBoundsException("index");
}
E old=element[index];//把原来的元素取出来
element[index]=elements;
return old;
}
/**
* 在index插入一个元素
*/
public void add(int index,E elememts) {
if(index<0||index>=size){
throw new IndexOutOfBoundsException("index");
}
for (int i =size-1; i <=index; i++) {
element[i+1]=element[i];
}
element[index]=elememts;
size++;
}
/**
* 删除index位置的元素
*/
public E remove(int index){
if(index<0||index>=size){
throw new IndexOutOfBoundsException("index");
}
E old=element[index];//把原来的元素取出来
for (int i =index+1; i <size-1; i++) {
element[i-1]=element[i];
}
size--;
return old;
}
/**
* 查看元素的索引
*/
public int indexOf(E elements){
for (int i = 0; i <size; i++) {
if(elements.equals(element[i])){
return i;
}
}
return ELEMENT_NOT_FOUND;//无此元素
}
/**
* 保证capacity的容量够用
*/
private void ensureCapacity(int capacity){
int oldCapacity=element.length;
if(oldCapacity>=capacity){
return;
}
//我们通常扩容 新容量为旧容量的1.5倍
int newCapacity=oldCapacity+(oldCapacity>>1);
E[] newElement= (E[]) new Object[newCapacity];
for (int i = 0; i <size; i++) {
newElement[i]=element[i];
}
element=newElement;
}
/**
*重写toString打印方法
* 目标 打印出来 size=3,[1,2,3]
*/
@Override
public String toString() {
StringBuilder string=new StringBuilder();
string.append("size=").append(size).append(",[");
for (int i = 0; i <size; i++) {
string.append(element[i]);
if(i!=size-1){
string.append(",");
}
}
string.append("]");
return string.toString();
}
@Override
public boolean equals(Object obj) {
//这里面可以自定义比较的规则
}
public static void main(String[] args) {
ArrayList.main(args);
}
}