数组(反转 查 增 删)

数组反转

public static void main(String[] args) {
    int[] arr = {1, 2, 3, 4, 5, 6};//定义数组
    System.out.println("==反转后的数组情况==");
    reverseArr(arr);//调用反转数组方法
    for (int i = 0; i < arr.length; i++) {//遍历新数组
        System.out.print(arr[i] + " ");
    }
}
public static int[] reverseArr(int[] arr){
    //将下标为0-5 1-4 2-3数组元素的值转换
    int temp = 0;//定义中间量 进行数组元素交换
    for (int i = 0; i < arr.length/2; i++) {
        temp = arr[i];
        arr[i] = arr[arr.length-1-i];
        arr[arr.length-1-i] = temp;
    }
    return arr;
}
/*
==反转后的数组情况==
6 5 4 3 2 1 
*/

数组查找

根据数组下标查找数组元素

package com.test;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        Scanner sc = new Scanner(System.in);
        System.out.println("输入需要查找的数组元素下标 0~" + (arr.length - 1));
        int find = sc.nextInt(); //查找的数组元素下标
        //判断
        if (find <= arr.length){
            System.out.println("找到了下标为" + find + " 数组元素为" + findArr(arr, find));//调用查找方法
        }else {
            System.out.println("输入的数组元素下标不存在 退出程序");
        }
    }

    public static int findArr(int[] arr, int find){
        int element = 0;//定义查找到的数组元素
        for (int i = 0; i < arr.length; i++) {
            if (find == i){
                element = arr[i];
            }
        }
        return element;
    }
}
/*
输入需要查找的数组元素下标 0~5
3
找到了下标为3 数组元素为 4
 */

根据数组元素查找数组下标

package com.test;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 4};
        Scanner sc = new Scanner(System.in);
        System.out.println("输入需要查找的数组元素值");
        int find = sc.nextInt(); //查找的数组元素值
        
        int index = -1;//判断数组中是否有需要查找的元素
        for (int i = 0; i < arr.length; i++) {
            if (find == arr[i]) {
                System.out.println("找到了元素" + find + " 下标为" + i);
                index = 0;//找到元素之后将index值改变
            }
        }
        if (index == -1){//若index值未改变 则在数组中没有找到该元素
            System.out.println("数组中没有该元素");
        }
    }
}
/*
输入需要查找的数组元素值
4
找到了元素4 下标为3
找到了元素4 下标为6
========================
输入需要查找的数组元素值
8
数组中没有该元素
*/

数组增加元素

package com.test;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        Scanner sc = new Scanner(System.in);
        System.out.println("输入需要添加的位置");
        int inIndex = sc.nextInt();//添加的下标
        System.out.println("输入需要添加的元素");
        int inArr = sc.nextInt();//添加的元素

        //创建新数组 比旧数组多一个元素
        int[] newArr = new int[arr.length + 1];

        //判断
        if (inIndex >= newArr.length){
            System.out.println("添加的数组下标越界\n默认将元素添加在数组最后");
            inIndex = newArr.length-1;
        }else if (inIndex < 0){
            System.out.println("添加的数组下标越界\n默认将元素添加在数组第一位");
            inIndex = 0;
        }

        //赋值
        for (int i = 0, j = 0; i < newArr.length; i++) {
            //i->newArr j->arr
            if (inIndex == i){
                newArr[i] = inArr;
            }else {
                newArr[i] = arr[j];
                j++;
            }
        }

        //遍历
        System.out.println("==添加元素后的数组情况==");
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }
}

/*
输入需要添加的位置
3
输入需要添加的元素
80
==添加元素后的数组情况==
1 2 3 80 4 5 6
**************************
输入需要添加的位置
100
输入需要添加的元素
20
添加的数组下标越界
默认将元素添加在数组最后
==添加元素后的数组情况==
1 2 3 4 5 6 20
**************************
输入需要添加的位置
-20
输入需要添加的元素
30
添加的数组下标越界
默认将元素添加在数组第一位
==添加元素后的数组情况==
30 1 2 3 4 5 6 
 */

数组删除元素

根据数组下标删除数组元素

package com.test;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        Scanner sc = new Scanner(System.in);
        System.out.println("输入需要删除的位置");
        int outIndex = sc.nextInt();//下标
        //判断
        if (outIndex < 0){
            System.out.println("输入的数组下标<0 默认删除第一位元素");
        }else if (outIndex >= arr.length){
            System.out.println("输入的数组下标>=数组长度 默认删除最后一位元素");
        }
        //创建新数组
        int[] newArr = new int[arr.length - 1];
        //为新数组赋值
        for (int i = 0; i < newArr.length; i++) {
            if (i >= outIndex){
                newArr[i] = arr[i+1];
            }else {
                newArr[i] = arr[i];
            }
        }
        //遍历
        System.out.println("==删除元素后的数组情况==");
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }
}
/*
输入需要删除的位置
2
==删除元素后的数组情况==
1 2 4 5 6 
*********************
输入需要删除的位置
100
输入的数组下标>=数组长度 默认删除最后一位元素
==删除元素后的数组情况==
1 2 3 4 5 
**************************************
输入需要删除的位置
-1
输入的数组下标<0 默认删除第一位元素
==删除元素后的数组情况==
2 3 4 5 6 
 */

根据数组元素删除数组元素

package com.test;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        Scanner sc = new Scanner(System.in);
        System.out.println("输入需要删除的元素");
        int outArr = sc.nextInt();//元素
        //创建新数组
        int[] newArr = new int[arr.length - 1];
        //判断输入的是否存在与该数组中
        if (outArrIndex(arr, outArr) == -1){
            System.out.println("输入的元素在数组中找不到 自动退出");
            return;
        }else {
            printArr(assignmentArr(arr, newArr, outArrIndex(arr, outArr)));
        }
    }
    //找删除元素下标方法
    public static int outArrIndex(int[] arr, int outArr){
        int outArrIndex = -1;//删除元素的下标
        for (int i = 0; i < arr.length; i++) {
            if (outArr == arr[i]){
                outArrIndex = i;
            }
        }
        return outArrIndex;
    }
    //赋值方法
    public static int[] assignmentArr(int[] arr, int[] newArr, int outArrIndex){
        for (int i = 0; i < newArr.length; i++) {
            if (i >= outArrIndex){
                newArr[i] = arr[i+1];
            }else {
                newArr[i] = arr[i];
            }
        }
        return newArr;
    }
    //遍历新数组
    public static void printArr(int[] newArr){
        System.out.println("==删除元素后的数组情况==");
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }
}
/*
输入需要删除的元素
3
==删除元素后的数组情况==
1 2 4 5 6
*********************
输入需要删除的元素
100
输入的元素在数组中找不到 自动退出
 */