实现数组
对应的代码
package com.wei.array;
import java.lang.reflect.Array;
import java.sql.PreparedStatement;
/**
* @author www
* @date 2021/11/3 14:32
* @description: 实现数组
*/
public class MyArray {
private int[] data;
private int size;
/**
* 构造函数,传入数组的容量capacity
*
* @param capacity
*/
public MyArray(int capacity) {
data = new int[capacity];
size = 0;
}
/**
* 无参构造函数,指定初始值
*/
public MyArray() {
this(10);
}
/**
* 获取数组中的元素的个数
*
* @return
*/
public int getSize() {
return size;
}
/**
* 获取数组的容量
*/
public int getCapacity() {
return data.length;
}
/**
* 数组是否为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 在元素开头的地方添加一个元素
*/
public void addFirst(int e) {
add(0, e);
}
/**
* 向所有元素后添加一个新元素
*/
public void addLast(int e) {
// if (size == data.length) {
// throw new IllegalArgumentException("AddLast Failed.Array is full")
// }
// data[size] = e;
// size++;
add(size, e);
}
/**
* 向数组中的指定位置,添加新元素
*/
public void add(int index, int e) {
// 进行动态扩容
if (size == data.length) {
resize(2 * data.length);
}
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add failed");
}
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
data[index] = e;
size++;
}
/**
* 获取index索引位置的元素
*/
public int get(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("index out of range");
}
return data[index];
}
/**
* 查找数组中是否有元素e
*/
public boolean contains(int e) {
for (int i = 0; i < size; i++) {
if (data[i] == e) {
return true;
}
}
return false;
}
/**
* 查找对应元素的索引,如果不存在对应的索引,则返回-1
*/
public int find(int e) {
for (int i = 0;i < size; i++) {
if (data[i] == e) {
return i;
}
}
return -1;
}
/**
* 对应元素的删除,返回并删除的元素
*/
public int remove(int index) {
if (index < 0 && index > size) {
throw new IllegalArgumentException("index illegal");
}
int value = data[index];
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
size--;
// 进行数组长度的缩减
if (size == data.length / 2) {
resize(data.length / 2);
}
return value;
}
/**
* 从数组中删除第一个元素,返回删除的元素
*/
public int removeFirst() {
return remove(0);
}
/**
* 从数组中删除最后一个元素,返回删除的元素
*/
public int removeLast() {
return remove(size - 1);
}
/**
* 数组中删除元素e
*/
public void removeElement(int e) {
int index = find(e);
if (index != -1) {
remove(index);
}
}
/**
* 指定位置元素的更新
*/
public void set(int index, int e) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("index out of range");
}
data[index] = e;
}
/**
* 进行动态扩容
*/
private void resize(int newCapacity) {
int[] newData = new int[newCapacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
/**
* 重写toString方法来实现对象的对应的打印
*/
@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 com.wei.array;
import java.lang.reflect.Array;
/**
* @author www
* @date 2021/11/3 21:03
* @description: 栈的基本实现
*/
public class MyStack {
/**
利用数组来进行实现
*/
private int[] data;
/**
* 栈的最大长度
*/
private int size;
/**
* 栈顶的位置
*/
private int top;
public MyStack(int size) {
this.size = size;
data = new int[size];
top = -1;
}
public int getSize() {
return size;
}
public int getTop() {
return top;
}
/**
* 判断是否为空栈
*/
public boolean isEmpty() {
return top == -1;
}
/**
* 判断是否是满栈
*/
public boolean isFull() {
return (top + 1) == size;
}
/**
* 进栈
*/
public boolean push(int data) {
if (isFull()) {
System.out.println("this stack is full");
return false;
} else {
top++;
this.data[top] = data;
return true;
}
}
/**
* 出栈
*/
public int pop() throws Exception {
if (isEmpty()) {
throw new Exception("this stack is empty");
} else {
int value = data[top];
top--;
return value;
}
}
/**
* 获取栈顶的元素
*/
public int peek() {
return data[getTop()];
}
public static void main(String[] args) {
MyStack stack = new MyStack(20);
stack.push(0);
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println("Now the top_num is:" + stack.peek());
while(! stack.isEmpty()) {
try {
System.out.println(stack.pop());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}