写在前面
本系列代码Gitee地址为点击这里
实现的方法
// 获取数组的元素个数
int getSize();
// 获取数组的容量
int getCapacity();
// 判断数组是否为空
boolean isEmpty();
// 获取index索引位置的元素
E get(int index);
// 获取第一个元素
E getFirst();
// 获取最后一个元素
public E getLast();
// 修改index索引位置的元素为e
void set(int index, E e);
// 修改头部元素
void setFirst(E e);
// 修改尾部元素
void setLast(E e);
// 交换i,j两处索引的元素
public void swap(int i, int j);
// 向指定位置添加元素
void add(int index, E e);
// 向所有元素后添加一个新元素
void addLast(E e);
// 向所有元素前添加一个新元素
void addFirst(E e);
// 查找数组中是否有元素e
boolean contains(E e);
// 查找数组中元素e所在的索引，如果不存在，返回-1
int find(E e);
// 查找数组中元素e所在的全部索引
List findAll(E e);
// 从数组中删除index位置的元素，返回删除的元素
E remove(int index);
// 从数组中删除第一个元素
E removeFirst();
// 从数组中删除最后一个元素
E removeLast();
// 从数组中删除元素e
boolean removeElement(E e);
// 从数组中删除所有元素e
boolean removeAllElement(E e);
代码
public class Array<E> {
private E[] data;
private int size;
// 构造函数，传入数组容量capacity构造Array
public Array(int capacity) {
data = (E[]) new Object[capacity];
size = 0;
}
// 无参数的构造函数，默认数组的容量capacity = 10
public Array() {
this(10);
}
// 用一个数组初始化本数组
public Array(E[] arr) {
data = (E[]) new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
data[i] = arr[i];
}
size = arr.length;
}
// 获取数组的元素个数
public int getSize() {
return size;
}
// 获取数组的容量
public int getCapacity() {
return data.length;
}
// 判断数组是否为空
public boolean isEmpty() {
return size == 0;
}
// 获取index索引位置的元素
public E get(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Get failed. Index is illegal.");
}
return data[index];
}
// 获取第一个元素
public E getFirst() {
return get(0);
}
// 获取最后一个元素
public E getLast() {
return get(size - 1);
}
// 修改index索引位置的元素为e
public void set(int index, E e) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Get failed. Index is illegal.");
}
data[index] = e;
}
// 修改头部元素
public void setFirst(E e) {
set(0, e);
}
// 修改尾部元素
public void setLast(E e) {
set(size - 1, e);
}
// 交换i,j两处索引的元素
public void swap(int i, int j) {
if (i < 0 || i >= size || j < 0 || j >= size) {
throw new IllegalArgumentException("Index is illegal.");
}
E t = data[i];
data[i] = data[j];
data[j] = t;
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append('[');
if (!isEmpty()) {
for (int i = 0; i < size - 1; i++) {
res.append(data[i] + ", ");
}
res.append(data[size - 1]);
}
res.append(']');
return res.toString();
}
// 向指定位置添加元素
public void add(int index, E e) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add failed. Require index >=0 and index <= size");
}
if (size == data.length) {
resize(2 * data.length);
}
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
data[index] = e;
size++;
}
// 向所有元素后添加一个新元素
public void addLast(E e) {
add(size, e);
}
// 向所有元素前添加一个新元素
public void addFirst(E e) {
add(0, e);
}
// 查找数组中是否有元素e
public boolean contains(E e) {
for (int i = 0; i < size; i++) {
if (e.equals(data[i])) {
return true;
}
}
return false;
}
// 查找数组中元素e所在的索引，如果不存在，返回-1
public int find(E e) {
for (int i = 0; i < size; i++) {
if (e.equals(data[i])) {
return i;
}
}
return -1;
}
// 查找数组中元素e所在的全部索引
public List findAll(E e) {
List list = new ArrayList();
for (int i = 0; i < size; i++) {
if (e.equals(data[i])) {
list.add(i);
}
}
return list;
}
// 从数组中删除index位置的元素，返回删除的元素
public E remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Remove failed. Index is illegal.");
}
E ret = data[index];
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
size--;
data[size] = null;
if (size >= 5 && size == data.length / 4) {
resize(data.length / 2);
}
return ret;
}
// 从数组中删除第一个元素
public E removeFirst() {
return remove(0);
}
// 从数组中删除最后一个元素
public E removeLast() {
return remove(size - 1);
}
// 从数组中删除元素e
public boolean removeElement(E e) {
int index = find(e);
if (index != -1) {
remove(index);
return true;
}
return false;
}
// 从数组中删除所有元素e
public boolean removeAllElement(E e) {
List list = findAll(e);
if (list.isEmpty()) return false;
for (int i = list.size() - 1; i >= 0; i--) {
remove((int) list.get(i));
}
return true;
}
// 数组大小重置
public void resize(int newCapacity) {
if (newCapacity < size) {
throw new IllegalArgumentException("改变后的数组容量不得小于元素个数");
}
E[] newData = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
}
