一维数组的应用:遍历.复制.排序.反转.查找功能及键盘录入总结

键盘输入长度为6,区间为[30,60)之间的不重复的整数, 完成数组元素的遍历.复制.逆序.排序.查找功能,功能以方法形式.

1. 键盘输入长度为6,区间为[30,60)之间的不重复的整数

public static void main(String[]  args){
		Scanner sc = new Scanner(System.in);
		
		//创建动态数组.长度为6
		int[] arr = new int[6];
		int[] arr2 = new int[arr.length];
		
		//键盘录入数组数据
		for(int i = 0 ; i < arr.length ; i++ ){
			System.out.print("请输入第" + i + "个数组元素数据: ");
			arr[i] = sc.nextInt();
			/* 判断数据是否在范围内,若不在,i--,且提示,并结束本次循环.
			若在范围内,判断数据是否重复,当前录入数据和已录入的数据逐个比较.
			若相等,则i--,提示重新录入,结束本次循环.! */
			
			if(arr[i] >=60 || arr[i] < 30){
				i -- ;
				System.out.println("录入数据不在范围内,请重新录入!");
				//此处只能用continue结束本次循环,不能用break,break为跳出当前循环.
				continue;
			}else{
				for(int  j = 0;j < i ; j++ ){
					if(arr[i] == arr[j]){
						i --;
						System.out.println("录入数据重复,请重新录入!!!");
						//此处即可以用break,又可以用continue,break跳出当前的内循环,不会跳出外部的for循环!
						//break;
						continue;
					}else{
						
					}
				}
			}
		}
		
		//数组遍历
		printArray(arr);
		
		//数组复制
		copyArray(arr,arr2);
		System.out.println("复制后的数组元素为:");
		printArray(arr2);
		
		//数组反转
		reverse2(arr2);
		System.out.println("反转后的数组元素为:");
		printArray(arr2);
		
		//对数组arr2进行排序
		bubbleSort(arr2);
		System.out.println("排序后的数组元素为:");
		printArray(arr2);
		
		//查找arr2数组中某个元素,
		System.out.print ("请输入要查找元素值: ");
		int index = sc.nextInt();
		int key =  indexArray(arr,index);
		System.out.println("查找的元素" + index + "索引位置在:" + key) ;
		
	}

2.数组的遍历

注意事项:
①打印左括号,不换行!!!
②当为数组元素的最后一个值时,打印右括号,换行!!!
③其他数组元素,打印数组"元素+ 逗号 + 空格",不换行!!!

	public static void printArray(int[] arr){
		System.out.print("[");
		for(int i = 0;i <= arr.length - 1 ; i++){
			if(i == arr.length - 1){
				
				System.out.println(arr[i] + "]");
			}else{
				System.out.print(arr[i] + ", ");
			}
		}
	}

3.数组复制

将数组1复制到数组2

	public static void copyArray(int[] arr1,int[] arr2){
		for(int i = 0;i < arr1.length ; i++ ){
			arr2[i] = arr1[i];
		}
	}

4.数组逆序

在不创建新数组的情况下,实现数组元素反转

	//方式一:定义索引min和max,首次分别指向数组的第一个和最后一个元素,并交换,交换成立的条件为min < max 
	public static void reverse(int[] arr){
		for(int min = 0,max = arr.length - 1;min < max ; min++,max--){
			int temp = arr[min];
			arr[min] = arr[max];
			arr[max] = temp;
		}
	}
	
	//方式二：数组长度折半，将第i个位置上的元素和第（arr.length -1 -i）位置上的元素进行交换。
	public static void reverse2(int[] arr){
		for(int i = 0;i < arr.length/2; i++){
			int temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp ;
		}
	}

5.排序

冒泡排序和直接选择排序

//冒泡排序  （比较次数：arr.length-1 次  外层循环:整个比较的次数，内层循环：每次比较的次数）
	public static void bubbleSort(int[] arr){
		for(int i = 0 ;i< arr.length-1 ; i++){
			for (int j = 0; j < arr.length-1-i;j++){
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}

 //方法二:直接选择排序:
	public static void selected(int[] arr){
		for(int i = 0 ;i< arr.length ; i++){
			for (int j = i+1; j < arr.length;j++){
				if(arr[i]>arr[j]){
					int temp = arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
	}	 

6.查找:

查找数组中某个元素的位置,找到元素,返回元素索引,未找到,返回-1

	public static int indexArray(int[] arr,int key){
		//boolean isFlag = true;
		for (int i = 0; i < array1.length; i++ ){
			if(arr[i] == key){
				//System.out.println("找到了目标元素，位置在:" + i);
				return i;
			}
		}
		return -1;
	}

7.运行结果

	请输入第0个数组元素数据: 65
	录入数据不在范围内,请重新录入!
	请输入第0个数组元素数据: 48
	请输入第1个数组元素数据: 49
	请输入第2个数组元素数据: 30
	请输入第3个数组元素数据: 28
	录入数据不在范围内,请重新录入!
	请输入第3个数组元素数据: 58
	请输入第4个数组元素数据: 59
	请输入第5个数组元素数据: 47
	原数组元素为:
	[48, 49, 30, 58, 59, 47]
	复制后的数组元素为:
	[48, 49, 30, 58, 59, 47]
	反转后的数组元素为:
	[47, 59, 58, 30, 49, 48]
	排序后的数组元素为:
	[30, 47, 48, 49, 58, 59]
	请输入要查找元素值: 20
	查找的元素20索引位置在:-1