在java集合中,Collection基接口实现List(数组),Set(集合),Queue(队列)三个接口,而List又实现了AbstractList接口,ArrayList类就继承了AbstractList接口。
ArrayList底层就是一个数组,默认数组大小是10,查询效率高,1.5倍扩容,基于数组索引来定位数据,我们在使用的时候可以用两种方法来创建ArrayList数组(如下):
ArrayList<Integer>integers = new ArrayList(); //无参的数组初始化,数组默认大小是10
ArrayList<Integer>list = new ArrayList(); //有参构造,指定初始化数组大小
在其中,源码中为我们提供了add,remove,get等一些方法,我们可以直接使用。
public class ArrayListDemo {
public static void main(String[] args) {
/**
* 无参的数组初始化,数组默认大小是10
*/
ArrayList<Integer>integers = new ArrayList();
/**
* 有参构造,指定初始化数组大小
*/
ArrayList<Integer>list = new ArrayList();
//add 添加数据
list.add(1);
list.add(3);
//查询集合是否包含当前查询元素
list.addAll(integers);
//System.out.println(list.contains(3));
list.contains(3);
//删除指定元素
list.remove(1);
//获取集合容量大小
int size = list.size();
//System.out.println(size);
for (int i = 0;i <size;++i){
//get获得指定位置索引数据
//System.out.println(list.get(i));
}
}
}
下面我们将自己实现一个简单的ArrayList,完成他的add,remove以及get三个简单的方法:
class MyArrayList {
private int[] array;
private int usedsize = 0;
public javaTest(){
this(10);
}
public javaTest(int usedsize){
this.usedsize = usedsize;
this.array = new int[usedsize];
}
/**
* add方法
* @param
* @return
*/
public boolean add(int val){
if (isFull()){
this.array = Arrays.copyOf(this.array,this.array.length*2);
}
this.array[this.usedsize++] = val;
return true;
}
/**
* remove方法
*/
public boolean remove(int val){
int i = 0;
for (;i < usedsize;i++){
if (this.array[i] == val){
break;
}
}
for (i = i-1;i+1 < this.usedsize;++i){
this.array[i] = this.array[i+1];
}
this.usedsize--;
return true;
}
/**
* get方法
*/
public int get(int key){
if (key > this.usedsize){
throw new ArrayIndexOutOfBoundsException("Array is over");
}
return this.array[key];
}
public boolean isFull(){
return this.usedsize == this.array.length;
}
public int getSize(){
return this.usedsize;
}
}
Iterator(迭代器)是一种设计模式,迭代器提供一种方法,来访问集合(容器),对集合进行遍历特点:达到对集合的遍历访问与集合底层数据结构进行解耦。下面我们将自己实现一个简单的Iterator:
public class MyArrayList<T> implements Iterable<T>{
private T[] data;
private int size;
public MyArrayList() {
this(10);
}
public MyArrayList(int capcity) {
data = (T[])new Object[capcity];
size = 0;
}
private boolean isFull () {
return size == data.length;
}
public void add(T value) {
if (isFull()) {
data = Arrays.copyOf(data, data.length<<1+data.length>>1);
}
data[size++] = value;
}
public T remove(int index){
if (index < 0 || index > size) {
return null;
}
T oldValue = data[index];
//数组移动操作
for (int i= index; i < size; i++) {
data[i]= data[i+1];
}
data[size-1] = null;
size--;
return oldValue;
}
@Override
public Iterator<T> iterator() {
return new MyIterator();
}
class MyIterator implements Iterator<T> {
private int index = 0;
@Override
public boolean hasNext() {
return index < size;
}
@Override
public T next() {
T value = data[index];
index++;
return value;
}
@Override
public void remove() {
MyArrayList.this.remove(index);
index--;
}
}
public static void main(String[] args) {
MyArrayList <Integer> list = new MyArrayList <Integer>();
list.add(1);
list.add(2);
list.add(3);
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer next = iterator.next();
System.out.println(next);
}
}
}