数组的基础操作Java

• 数组基础操作包含，插入元素、删除元素、查找元素
• 数组的遍历、以及二维数组遍历

查找数组元素

import java.util.Scanner;

class FindArrays{
	public static void main(String[] args){
		int[] nums = {1,2,3,4,5,6,7};
		Scanner str = new Scanner(System.in);
		System.out.println("请输入查找元素");
		int a = str.nextInt();
		findArr(nums,a);
	}
	
	//for循环查找数组元素
	static void findArr(int[] arrs,int target){
		int i;
		for(i=0;i<arrs.length;i++){
			if(arrs[i] == target){
				System.out.println("目标元素索引："+i);
				break;
			}
		}
		if(i > arrs.length-1){
				System.out.println("当前元素不在该数组中");
		}
	}
}

查找数组元素思路：

• 将目标值与数组内的每个元素进行对比，一直比较到最后一位即arrs.length-1。i从for循环出来如果找到了该元素则返回该元素索引。
• 反之如果未找到，则此时的i一定是等于数组长度的，数组长度-1是最后一位元素但是仍然不是目标元素则说明i已经全部对比过。因此判断i大于该数组最大索引时即为“该元素不存在数组中”

插入数组元素

import java.util.Arrays;

class InsertionArrays{
	public static void main(String[] args){
		//数组插入元素，插入位置索引，插入元素值
		int[] nums = {1,2,3,4,5,6,7,8,9};
		int tar = 7;//插入索引位置
		int inser = 999;//插入数据值
		InsertionArrays(nums,tar,inser);
		
	}
	static void InsertionArrays(int[] arrs,int targetIndex,int insertionDate){
		int[] Array  = new int[arrs.length+1];
		int i,k;
		for(i=0,k=0;i<arrs.length;i++){
			if(i != targetIndex){
				Array[k] = arrs[i];
				k++;
			}else{
		/*进入这一步说明i=3   k=3   把目标数据值插入新数组该索引当中
		插入之后k=3的位置就有值了，需要把k向后移动一位，而i不变，所以把i位置的值赋给移动后k的位置
		此时k=4，i=3，下一步需要将i=4赋值给k=5，所以需要再次将k后移一位
		*/
				Array[targetIndex] = insertionDate;
				k +=1;
				Array[k] = arrs[i];
				k++;
			}
		}
		System.out.print("插入后数组为："+Arrays.toString(Array));
	}
}

插入数组元素思路

• 由用户来定义要插入的位置，以及插入元素的数值
• 因为是插入一个元素，所以定义一个长度比原数组+1的新数组来存放元素，其他数值的相对位置不变。
• 利用for循环将插入元素的索引与每个循环变量i进行比较，当未达到插入位置时，将旧数组的元素依次赋值到新数组的对应位置。达到索引位置时，则将要插入的元素数值赋给新数组的索引位置。

删除数组元素

import java.util.Arrays;
import java.util.Scanner;

class DeletArrays{
	public static void main(String[]args){
		DeletArrays noo = new DeletArrays();
		Scanner str = new Scanner(System.in);
		int[] arrs = {1,2,3,4,5};
		System.out.print("请输入要删除的元素索引：");
		int temp = str.nextInt();
		while(temp<0 || temp>arrs.length-1){
			System.out.print("输入有误，请重新输入：");
			temp = str.nextInt();
		}
			
		int[] Array = noo.delet1(arrs,temp);//删除元素3，索引2
		
		System.out.print(Arrays.toString(Array));
	}
	int[] delet1(int[] nums,int targetIndex){
		int[] arr = new int[nums.length-1];
		for(int i=0,k=0;i<nums.length;i++){//两个循环变量，i，k
			if(i!=targetIndex){//达到删除元素的时候不进if选择，则k不加一，i继续加一
			arr[k] = nums[i];
			k++;
			}
		}
	return arr;
	}
}

删除数组元素思路

• 与插入元素较为相似，同样是新定义一个数组。新数组的长度等于旧数组长度-1，由用户自定义要删除元素的索引。
• 利用for循环，为两个数组定义循环的索引变量i和k，将就数组的每个索引上的值赋到新数组的对应索引上。for循环内嵌套一个if判断。达到要删除元素的索引时，就不进入if选择中，则就数组的该索引位置的值并未赋到新数组对应位置中，达到删除的效果

---

遍历二维数组

public class PrintSecondSort{
	public static void main(String[] args){
		int[][] nums = {{1,2},{3,4},{5,6},{7,8}};
		System.out.println(nums[0][0]);//1
		System.out.println(nums[0][1]);//2
		System.out.println(nums[3][0]);//7
		prin(nums);
	}
	public static int[][] prin(int[][] arrs){
		for(int i=0;i<=arrs.length-1;i++){
			for(int j=0;j<=arrs[i].length-1;j++){
				System.out.print(arrs[i][j]);
				System.out.print(" ");
			}
			System.out.println();
		}
		
		return arrs;
	}
}

数组遍历

//调用Arrays类进行打印
import java.util.Arrays;
int[] nums = {1,2,3,4,5};
System.out.println(Arrays.toString(nums));

public static int[] _5(int[] arrays ){//增强for循环
        for (int array : arrays) {
            System.out.println(array);
        }
        return arrays;
    }

    public static int[] _6(int[] array){//for循环打印
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
        }
        return array;
    }

数组反转、获取最值

public static int[] _3(int[] arrays){//反转数组
        int[] result = new int[arrays.length];
        for (int i = 0,j = arrays.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
    public static int _4(int[] arr){//获取最值
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            if (max<arr[i]){
                max = arr[i];
            }
        }
        return max;
    }