数组的局限性：长度固定，一旦定义不能修改1.1 数组元素的增加
核心思想：
创建一个新数组，长度为原数组+1，将原数组赋值到新数组， 最后将增加的元素放到新数组最后一个位置，把新数组赋值给原数组。
代码实现：
import java.util.Arrays;
public class ArrayAppend {
//在数组末尾追加一个元素
public static void main(String[] args) {
//解决数组长度不可变问题
int[] arr=new int[]{1,2,3};
//快速查看数组中的元素
System.out.println(Arrays.toString(arr));
//目标元素
int aim=4;
//创建新数组长度+1
int[] newArr=new int[arr.length+1];
//遍历将原数组的值放到新数组
for (int i=0;i
结果：
[1, 2, 3]
[1, 2, 3, 4]
1.2 数组元素的删除
核心思想：
（假如删除索引为index的元素）
创建一个新数组，长度为原数组长度-1，遍历新数组
在索引小于index时，我们直接将新数组和原数组对应赋值即可
在索引大于index时，我们发现原数组的index+1对应的是新数组，即 newArr[i]=arr[i+1]
代码实现：
import java.util.Arrays;
public class ArrayDelete {
//数组元素的删除
public static void main(String[] args) {
int[] arr=new int[]{1,2,3,4};
System.out.println(Arrays.toString(arr));
//删除元素的下标/位置
int index=0;
//新的数组长度=原数组-1
int[] newArr=new int[arr.length-1];
//遍历新数组
for(int i=0;i=index时，因为index处的元素删除，所以newArr的i对应的arr应当i+1
else{
newArr[i]=arr[i+1];
}
}
//替换原数组
arr=newArr;
System.out.println(Arrays.toString(arr));
}
}
运行结果：
[1, 2, 3, 4]
[2, 3, 4]
1.3 面向对象的数组
思想：
将操作数组的一系列方法进行封装，在构造函数中传入数组，调用方法即对数组增删改查
add insert delete set get 等方法
代码：
import java.util.Arrays;
public class MyArray {
//私有成员变量-数组
private int[] arr;
//初始化
public MyArray(){
this.arr=new int[0];
}
//获取数组长度
public int getLength(){
return arr.length;
}
//获取数组元素
public int get(int index){
if (index < 0 || index >= arr.length) {
throw new RuntimeException("下表越界");
}
return arr[index];
}
//修改数组元素
public int[] set(int index,int element){
if (index < 0 || index >= arr.length) {
throw new RuntimeException("下表越界");
}
arr[index]=element;
return arr;
}
//打印数组元素
public void show(){
System.out.println(Arrays.toString(arr));
}
//往数组最后添加元素
public void add(int element){
//初始化一个数组
int[] newArr=new int[arr.length+1];
for(int i=0;i= arr.length) {
throw new RuntimeException("下表越界");
}
int[] newArr=new int[arr.length+1];
//遍历数组，将arr除了index位置 其他位置全部复制到newArr
for(int i=0;i= arr.length) {
throw new RuntimeException("下表越界");
}
//新的数组长度=原数组-1
int[] newArr = new int[arr.length - 1];
//遍历原数组将除了index的元素复制到新数组
for (int i = 0; i < newArr.length; i++) {
if (i < index) {
newArr[i] = arr[i];
} else{
newArr[i] = arr[i+1];
}
}
//替换原数组
arr = newArr;
}
}
测试类
public class MyTest {
public static void main(String[] args) {
MyArray myArray = new MyArray();
myArray.add(1);
myArray.add(2);
myArray.add(3);
myArray.add(4);
myArray.add(5);
myArray.show();
System.out.println("第三个元素为："+myArray.get(2));
myArray.set(1,1000);
System.out.println("修改了第2个元素为1000");
myArray.show();
System.out.println("数组长度为："+myArray.getLength());
//插入元素
System.out.println("在index为3处插入100");
myArray.insert(3,100);
myArray.show();
//删除元素
System.out.println("删除索引为4的元素");
myArray.delete(4);
myArray.show();
}
}
结果：
[1, 2, 3, 4, 5]
第三个元素为：3
修改了第2个元素为1000
[1, 1000, 3, 4, 5]
数组长度为：5
在index为3处插入100
[1, 1000, 3, 100, 4, 5]
删除索引为4的元素
[1, 1000, 3, 100, 5]
1.4 查找
以下两个方法可归并到上面的数组方法中
（1）线性查找
代码：
//线性查找
public class Search {
public static void main(String[] args) {
//目标数组
int[] arr=new int[]{1,3,5,7,9};
//目标元素
int target=5;
//目标元素下标，-1表示没有查找到
int index=-1;
//遍历数组，找到后终止循环
for (int i=0;i
结果：
index:2
二分查找
思想：
（只适用于已经排好序的数组，以从小到大排序举例）
有三个关键的记录值：开始位置begin、中间位置mid、结束位置end
每次目标元素都和中间位置mid元素比较，
如果相等，直接返回下标值，结束查找
如果大于mid元素则目标元素在mid元素右侧，即调整 begin=mid+1
如果小于mid元素则目标元素在mid元素左侧，即调整 end=mid-1
重复以上步骤（此处可以用循环，也可用递归）
代码：
//二分法查找
public class BinarySearch {
public static void main(String[] args) {
//目标数组
int[] arr=new int[]{1,3,5,7,9,110,123,234,678,1234,12};
//目标元素 目标元素下标
int target=1234;
int index=-1;
//开始、结束、中间位置
int begin=0;
int end=arr.length-1;
int mid=(begin+end)/2;
//这里要注意：应该是<= 因为可能begin和end重合时，才找到目标元素
while(begin<=end){
//如果相等即找到了元素，保存下标，退出循环
if(arr[mid]==target){
index=mid;
break;
}else{
//目标元素小于mid，说明在左侧，end=mid-1
if(arr[mid]>target){
end=mid-1;
//目标元素大于mid，说明在右侧，begin=mid+1
}else{
begin=mid+1;
}
//记得将中间位置元素重新计算
mid=(begin+end)/2;
}
}
System.out.println("index:"+index);
}
}
结果：
index:9
好啦！我的第一篇博客到这里就结束啦，感谢你观看到最后。
当作作为记录自己学习的一种方式，
之后还会接着以这种方式来记录自己学习数据结构和算法的过程。
