一、数组的基本使用
?
我们可以看出，该数组的地址是连续的，我们要想取到数据下面的值，我们可以直接通过数组的下标进行获取。
public class TestArray {
public static void main(String[] args) {
//创建一个数组
int[] arr = new int[3];
//获取数组的长度
int arrlength = arr.length;
System.out.println(arrlength);
//访问数组当中的元素：数组名【下标】 注意：下标从0开始，最大可取到长度 -1
int element0 = arr[0];
System.out.println("element0:"+element0);
//为数组当中的元素赋值
arr[0] = 99;
System.out.println("element0"+arr[0]);
arr[1] = 98;
arr[2] = 97;
for (int i = 0; i < arr.length; i++) {
System.out.println("arr length"+i+":" + arr[i]);
}
//创建数组的同时为数组当中的元素赋值
int[] arr1 = new int[] {90,58,5,15,9};
//获取数组的长度
System.out.println("arr length:"+arr1.length);
}
}
结论：数组在构建的时候需要给定长度，数组的长度是不可变得
二、数组的扩容
由于数组的长度是不可变的，那么就会给我们造成一个问题，既当我们给数组添加数据满了以后就不能在添加了
那么我们现在就来解决一下这个问题：解决数组长度不可变问题
解决思路
我们只需要重新见一个数组，新的数组的长度是原来数组长度+1，然后将数组当中的值传递
给新数组，老数组的句柄指向新数组的堆内存空间
?
public static void main(String[] args) {
//定义数组
int[] arr = new int[] {1,2,3};
//快速的查询出数组当中的元素
System.out.println(Arrays.toString(arr));
//要加入数组的目标元素
int dst = 10;
//创建一个数组，数组长度是原数组长度 + 1
int[] brr = new int[arr.length+1];
//数组当中的数据全部复制到新的数组当中去
for (int i = 0; i < arr.length; i++) {
brr[i] = arr[i];
}
//将目标元素放入到新数组的最后
brr[3] = dst;
//新数组替换元素组
arr = brr;
//快速的查询出数组当中的元素
System.out.println(Arrays.toString(arr));
}三、数组的插入
数组的插入和删除都需要移动数据元素，插入x作为第 i 个元素，首先必须将元素ai,ai+1.......an-1向后移动，空出第 i 个元素，然后将 x 插入。如果数组，则不能插入，称为数组 溢出 。解决数据 溢出 的办法是，申请一个更大容量的数组，并复制全部的数组元素，这样就扩充了顺序表得容量
?
申请更大容量的数组
代码：
public class ArrayInsert {
public static void main(String[] args) {
System.out.println("---请输入数组的长度---");
Scanner scanner = new Scanner(System.in);
int arrLength = scanner.nextInt();
int[] arr = new int[arrLength];
System.out.println("---输入0代表输入截止---");
int temp = 0; // 定义变量用与记录数组当中有多少数据
for (int i = 0; i < arr.length; i++) {
int value = scanner.nextInt();
if(value == 0) {
break;
}
arr[i] = value;
temp += 1;
}
//输出当前数组
System.out.println(Arrays.toString(arr));
System.out.println("----请继续输入 您所想要输入的值------");
int value = scanner.nextInt();
System.out.println("----请输入您想要插入的位置，您可以输入0-"+ temp +"的值");
int index = scanner.nextInt();
inset(arr, value, index, temp);
}
public static void inset(int[] arr,int value,int index,int temp) {
//判断index的位置是否在数组的范围内
if (index<=0 || index >a rr.length) {
System.out.println("您的输入不在范围。。。。");
}else {
//判断数据是否已满
if (temp == arr.length) {
//满了就扩容
int[] brr = new int[arr.length * 2];
for (int i = 0; i < arr.length; i++) {
brr[i] = arr[i];
}
arr = brr;
}
//数据向后边移动
for (int i = temp-1; i >= index; i--) {
System.out.println(i);
arr[i+1] = arr[i];
}
arr[index] = value;
}
System.out.println(Arrays.toString(arr));
}
}
时间复杂度是O(n)
四、数组的删除
public class ArrayDelete {
public static void main(String[] args) {
System.out.println("---请输入数组的长度---");
Scanner scanner = new Scanner(System.in);
int arrLength = scanner.nextInt();
int[] arr = new int[arrLength];
System.out.println("---输入0代表输入截止---");
int temp = 0; // 定义变量用与记录数组当中有多少数据
for (int i = 0; i < arr.length; i++) {
int value = scanner.nextInt();
if(value == 0) {
break;
}
arr[i] = value;
temp += 1;
}
//输出当前数组
System.out.println(Arrays.toString(arr));
System.out.println("----请继续输入 您所想要删掉的值------");
int value = scanner.nextInt();
int index = 0; //查询出该值的位置
for (int i = 0; i < arr.length; i++) {
if (value == arr[i]) {
index = i;
delete(arr, value, index, temp);
}
}
}
public static void delete(int[] arr,int value,int index,int temp) {
//判断index的位置是否在数组的范围内
//判断删除的是否为第最后一个
if (temp == index+1) {
//如果是最后一个直接变为0
arr[index] = 0;
}else {
//数据向前边移动
for (int i = index; i < arr.length;i++) {
if (i == arr.length- 1) {
//如果是最后一个直接变为0
arr[i] = 0;
break;
}
arr[i] = arr[i+1];
}
}
System.out.println(Arrays.toString(arr));
}
}
时间复杂度是O(n)
五、有序数组的二分法查找
思路
以及数组元素是按顺序排序的，value是我们要查询的数据，begin和end表示要查询子序列 的范围 ①：从子序列的中间位置mid开始比较。value和mid元素相等，则查找成功；否则根据value 大小缩小查询范围，若value较小，则继续在子序列的前半段查找；反之继续在后半段查 找 ②：重复①，直到查询成功；当begin和end表示范围无效时，表示查询不成功
假设数据是以升序的
public class ArrayBinarySearch {
public static void main(String[] args) {
//定义一个有序的数组
int[] arr = new int[100];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
binarySearch(arr, 40);
}
/***
*
* @param arr
* @param value
* @return 查询的次数
*/
public static int binarySearch(int[] arr,int value) {
System.out.println("****************使用二分法查找****************");
int mid = 0; // 检索的时候
int start = 0; //用start和end两个索引控制它的查询范围
int end = arr.length;
int count = 0;
for (int i = 0; i < arr.length; i++){
count++;
mid = (start + end) / 2;
if(arr.length - 1 == i){
System.out.println("抱歉，没有找到");
}else if (arr[mid] < value){
start = mid;
}else if (arr[mid] > value){
end = mid;
}else{
System.out.println(arr[mid] + "找到了，在数组下标为" + mid + "的地方,查找了" + count + "次。");
break;
}
}
return count;
}
}
?
六：有序数组的插入
public class OrdArray {
int[] arr = new int[10]; //定义一个数组
int flage = 0;//定义一个变量
//插入方法
public void insert(int value){
//判断是不是插满了
if(flage == arr.length) {
System.out.println("插满了，可以考虑扩容了");
return;
}
//需要判断flage是不是0
if(flage == 0) {
arr[flage] = value;
flage +=1;
}else{
//判断该值是不是必flage地址的当前的值大
if(value >arr[flage-1]) {
System.out.println("----------");
//插入
arr[flage] = value;
flage +=1;
}else {
//循环去判断该插入那个位置
for(int i=0;i<flage;i++) {
//找到第一个必value大的值，将他们依次往后移动
if(arr[i]>value) {
System.out.println(flage+"==============");
int temp = flage;
for (int j = 0; j <= flage - i; j++) {
arr[temp] = arr[temp-1];
temp --;
}
arr[i] = value;
flage ++;
break;
}
}
}
}
System.out.println(Arrays.toString(arr));
}
}