/**
* 向所有元素末尾添加一个新元素。
*
* @param e 添加的元素
*/
public void addLast(int e){
// if (isFull()){ // throw new IllegalArgumentException("AddLast failed. Array is Full"); // }else { // data[size] =e; // data[size++] =e; // size++; // } add(size,e); }
/**
* 向索引0号位置添加元素
*
* @param e 添加的元素
*/
public void addFirst(int e){
add(0,e);
}
/**
* 在index位置插入一个新元素e
*
* @param index 插入位置索引
* @param e 插入元素
*/
public void add(int index,int e){
if (isFull())
throw new IllegalArgumentException("AddLast failed. Array is Full");
// 大于size就不是紧密排列了
if (index<0 || index>size){
throw new IllegalArgumentException("AddLast failed. Required index<0 or index>size ");
}
else {
// 从哪开始挪呢: 从size-1这个元素(size本身是指向空的),挪到哪个呢，index位置的这个元素也是要挪的。
for (int i=size-1; i>=index; i--){
data[i+1] = data[i]; // 后一个等于前一个，从数组最后一个元素开始。
// 极端值验证: size 1 index 0;(i=0;i>=0;i--)会执行一次data[1]=data[0].正确。
}
data[index] = e;
size++;
}
}
77插入，后面的元素都要向后挪动。
这里注意必须从100这里，向后挪，否则会造成值覆盖。
在数组中查询元素和修改元素
/**
* 打印数组信息及遍历元素。
*
* @return 数组信息和元素遍历结果
*/
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("Array: size = %d, capacity = %d\n",size,data.length));
res.append('[');
for (int i = 0; i < size; i++) {
res.append(data[i]);
if (i !=size-1) // 最后一个元素不要加，
res.append(", ");
}
res.append(']');
return res.toString();
}
package cn.mtianyan;
public class ArrayTest { public static void main(String[] args) { Array array = new Array(20); for (int i = 0; i < 10; i++) { array.addLast(i); } System.out.println(array); } }
java中的八种基本类型: boolean , byte, char , short , int , long , float , double;
每个基本数据类型都有对应的包装类: Boolean , Byte , Char , Short, Int , Long , Float , Double。自动的拆包，解包。
public class Array<Element> public class Array<E> 为类名后面添加泛型类型标识，此处的类型标识可以自定义。
private E[] data;
这里无法直接通过E实例化。只能通过间接的Object再转换。
data = (E[]) new Object[capacity]; /**
静态数组入参构造函数
@param data 传入静态数组 */ public Array(E[] data) { this.data = data; } public void add(int index,E e){ public void addLast(E e){ public void addFirst(E e){ public boolean contains(int E){ for (int i = 0; i < size; i++) { if (data[i].equals(E)){ return true; } } return false; } 这里注意，两个对象之间的比较要使用equals方法，将所有的与成员数组类型相关的都改了。
public E remove(int index){ // 判空，空数组 removeFirst index=0,size=0，index>=size异常。空数组 removeLast index=-1 index<0异常; if (index<0 || index>=size){ throw new IllegalArgumentException("Remove failed. Required index<0 or index>=size "); }else { E ret = data[index]; for (int i=index+1;i < size;i++){ // 从哪个元素开始挪，从index位置的后一个元素开始，挪到哪个元素结束，挪到size-1(因此没等号) data[i-1] = data[i]; // 前一个等于后一个 } size--; data[size] = null; return ret; } } data[size]还指着一个值不过用户访问不到而已，新的元素添加会自动覆盖。使用泛型后，data数组中存放的是类对象的引用， size-- 后data[size]依然指向一个引用，引用就涉及到空间释放的问题，Java有自动垃圾回收机制，但如果 data[size]仍存放引用，就不会被自动垃圾回收。data[size] = null;(不必须，可以被新对象覆盖)
if (isFull())
throw new IllegalArgumentException("AddLast failed. Array is Full");
// 大于size就不是紧密排列了
if (index<0 || index>size){
throw new IllegalArgumentException("AddLast failed. Required index<0 or index>size ");
}
private void resize(int newCapacity) {
E[] newData = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
package cn.mtianyan;
public class ArrayTestDynamic { public static void main(String[] args) { Array<Integer> array = new Array<>(); for (int i = 0; i < 10; i++) { array.addLast(i); } System.out.println(array); array.addFirst(99); System.out.println(array); array.addLast(100); System.out.println(array); } }
删除时压缩数组容量
public E remove(int index){
// 判空，空数组 removeFirst index=0,size=0，index>=size异常。空数组 removeLast index=-1 index<0异常;
if (index<0 || index>=size){
throw new IllegalArgumentException("Remove failed. Required index<0 or index>=size ");
}else {
E ret = data[index];
for (int i=index+1;i < size;i++){
// 从哪个元素开始挪，从index位置的后一个元素开始，挪到哪个元素结束，挪到size-1(因此没等号)
data[i-1] = data[i]; // 前一个等于后一个
}
size--;
data[size] = null;
public class ArrayTestDynamic { public static void main(String[] args) { Array<Integer> array = new Array<>(); for (int i = 0; i < 10; i++) { array.addLast(i); } System.out.println(array); array.addFirst(99); System.out.println(array); array.addLast(99); System.out.println(array); array.removeAllElement(99); System.out.println(array); for (int i = 0; i < 5; i++) { array.removeElement(i); } System.out.println(array); } }
简单的复杂度分析
简单的时间复杂度分析 感性认识 考研: 细致推导
O(1), O(n) , O(lgn) , O(nlogn) , O(n^2);
大O描述的是算法的运行时间和输入数据之间的关系
public static int sum(int[] nums){ int sum = 0; for(int num: nums) sum += num; return sum; } 通常我们说上面这个代码的算法，时间复杂度是O(n)的。n是nums中的元素个数;算法和n呈线性关系,线性关系表现在一次方。
Java技术网站 → 『 Java开发技术 』 → 『 数据结构和算法专题 』 → 数据结构中的数组
消息
查看
搜索
好友
邮件
复制
引用