java input 数组_Java基础之：数组

Java基础之：数组

一组相同数据类型的数据，我们即称之为 数组，数组也是一种数据类型。

需要注意的是 ， 数组和String 字符串 相同，也是引用类型的。

数组的初始化

方式一：动态初始化

四种格式：

int[] arr = new int[5];

int arr[] = new int[5];

int arr[]; arr = new int[5];

int[] arr; arr = new int[5];

我们可以通过 ： 数组名.length (返回值为int类型) 的方式获得数组的长度，需要注意的是，数组的下标是从0开始的。

//生成一个int类型数组，放入5个数 {1,2,3,4,5}

int[] arr = new int[5];

for(int i = 0;i < arr.length;i++){

arr[i] = i + 1;

}

注意：若声明了数组，却没有赋值，则需要注意每个数据类型创建的数组默认值是什么。

int/short/byte/long默认值为0，String默认值为null，float/double默认值为0.0，char默认值为 \u0000，boolean默认值为false.

方式二：静态初始化

两种格式：

int[] arr = {1,2,3};

int[] arr = new int[]{1,2,3};

数组的赋值

arr[0] = 1; 这就是最基本的数组赋值方式，通常我们使用循环的方式来给数组赋值。

但需要注意的是，数组是引用类型。

说明：

这里声明了两个数组，第二个数组并没有生成一个新的堆空间，而是在栈中生成了一个空间指向arr1在堆中的空间。

arr1 与 arr2共用一个堆空间，导致了若改变arr2中的值也会影响到arr1。

若要改变这一点应该让arr2重新生成一个空间，再将arr1中的内容复制到arr2中，代码如下：

int[] arr1 = {1,2,3};

int[] arr2 = new int[arr1.length];

for(int i = 0;i < arr2.length;i++){

arr2[i] = arr1[i];

}

数组灵活运用

数组逆序输出

import java.util.Scanner;

//数组元素反转

public class ArrayApply

{

public static void main(String[] args) {

//要求：随机生成五个数，并将其反转打印，把数组的元素内容反转.

//arr{1,2,3,4,5} {5,4,3,2,1}

/*

思路分析

1. 第一个元素和最后元素交换， 第二个元素和倒数第二个元素交换 , 以此类推

2. 交换次数 arr.length / 2

也可以使用一个中间数组 temp 先将arr放入temp中，再将temp逆序复制给arr

*/

int[] arr = {1, 2, 3, 4, 5, 10};

int temp = 0;

for( int i = 0 ; i < arr.length / 2; i++) { // i 次数， 同时下标

// i = 0 i = 4 (arr.length-1-0)

// i = 1 i = 3 (arr.length-1- 1)

temp = arr[i];

arr[i] = arr[arr.length-1 - i];

arr[arr.length-1 - i] = temp;

}

System.out.println("==============");

for( int i = 0; i < arr.length; i++) {

System.out.print(arr[i] + "\t");

}

}

在数组指定位置插入数据

//将一个数插入数组中的指定位置。 化繁为简的思路！！！

//1.首先考虑如何将一个数放入数组的最后，即数组扩容

//2.其次考虑如何实现数组的动态增减

//3.最后思考将数据放入数组中的指定位置

import java.util.Scanner;//一定要注意这里需要一个分号！！

public class ArrayApply1

{

public static void main(String[] args){

//动态输入数组

Scanner input = new Scanner(System.in);

int max = 0;

int maxIndex = 0;

System.out.println("输入数组长度：");

int arrLength = input.nextInt();

int[] arr = new int[arrLength];

System.out.println("输入数组内容：");

for(int i = 0 ; i < arr.length ; i++){

arr[i] = input.nextInt();

}

//1.实现将一个数放入数组的最后，即数组扩容

//思路： 1.使用一个临时数组，temp，temp.length = arr.length+1

// 2.再将arr数组中的数据遍历赋值到temp中

// 3.最后将arr指向temp数组

//String flag = null;//初始化String，JVM默认分配的值也是null，所以这里可以不写null

//do{

//System.out.println("是否要添加数据(Y/N)");

//flag = input.next();

//if("Y".equalsIgnoreCase(flag)){//equalsIgnoreCase()代表不区分大小写的比较

//int[] temp = new int[arr.length + 1];

//for(int i = 0 ; i < arr.length ; i++){//先将arr赋值给temp

//temp[i] = arr[i];

//}

//System.out.println("输入要添加的数据：");

//int tempInt = input.nextInt();

//temp[temp.length-1] = tempInt;//将数据放在temp最后

//arr = temp;//栈空间中的arr指向temp数组在堆中的空间

//}

//System.out.println("插入数据后的数组为：");

//for(int i = 0 ; i < arr.length ; i++){//插入完后打印一下数组

//System.out.print(arr[i]+ "\t");

//}

//System.out.println();

//}while(!"N".equalsIgnoreCase(flag));

//========================================================================================

//2.实现数组的动态增减(默认减掉数组最后一个数据)

//String flag = null;//初始化String，JVM默认分配的值也是null，所以这里可以不写null

//String flag2 ;

//do{

//System.out.println("是否要改变数据(Y/N)");

//flag = input.next();

//if("Y".equalsIgnoreCase(flag)){//equalsIgnoreCase()代表不区分大小写的比较

//System.out.println("增加数据或减少数据(IN/OUT)");

//flag2 = input.next();

//if("IN".equalsIgnoreCase(flag2)){

//int[] temp = new int[arr.length + 1];

//for(int i = 0 ; i < arr.length ; i++){//先将arr赋值给temp

//temp[i] = arr[i];

//}

//System.out.println("输入要添加的数据：");

//int tempInt = input.nextInt();

//temp[temp.length-1] = tempInt;//将数据放在temp最后

//arr = temp;//栈空间中的arr指向temp数组在堆中的空间

//}else if("OUT".equalsIgnoreCase(flag2)){//减掉数组的最后一位

//int[] temp = new int[arr.length - 1];

//for(int i = 0 ; i < temp.length ; i++){//先将arr赋值给temp

//temp[i] = arr[i];

//}

//arr = temp;//栈空间中的arr指向temp数组在堆中的空间

//}else{

//System.out.println("输入错误！");

//}

//}

//System.out.println("改变数据后的数组为：");

//for(int i = 0 ; i < arr.length ; i++){//插入完后打印一下数组

//System.out.print(arr[i]+ "\t");

//}

//System.out.println();

//}while(!"N".equalsIgnoreCase(flag));

//========================================================================================

//3.数据放入数组中的指定位置自己的思路

//String flag ;

//int inIndex;

//do{

//System.out.println("是否要添加数据(Y/N)");

//flag = input.next();

//if("Y".equalsIgnoreCase(flag)){//equalsIgnoreCase()代表不区分大小写的比较

//System.out.println("输入要添加数据的位置(下标)：");

//inIndex = input.nextInt();

//int[] temp = new int[arr.length + 1];

//for(int i = 0 ; i < arr.length ; i++){//先将arr赋值给temp，i表示arr数组的下标

//if(i == inIndex){

//temp[i] = 0;//将要插入的位置空出

//temp[i+1] = arr[i];//由于将temp这个位置空出来了，所以arr[i]赋值给下一个位置

//}else if(i < inIndex){

//temp[i] = arr[i];//将要插入位置前面的数据放入

//}else{

//temp[i+1] = arr[i];

将要插入位置后面的数据放入，由于空出了一个位置所以这里需要i+1

//}

//}

//System.out.println("输入要添加的数据：");

//int tempInt = input.nextInt();

//temp[inIndex] = tempInt;

//arr = temp;//栈空间中的arr指向temp数组在堆中的空间

//}

//System.out.println("插入数据后的数组为：");

//for(int i = 0 ; i < arr.length ; i++){//插入完后打印一下数组

//System.out.print(arr[i]+ "\t");

//}

//System.out.println();

//}while(!"N".equalsIgnoreCase(flag));

//3.数据放入数组中的指定位置韩顺平老师的思路

String flag ;

int inIndex;

do{

System.out.println("是否要添加数据(Y/N)");

flag = input.next();

if("Y".equalsIgnoreCase(flag)){//equalsIgnoreCase()代表不区分大小写的比较

System.out.println("输入要添加数据的位置(下标)：");

inIndex = input.nextInt();

//加入一个判断下标是否正确的语句

if(!(inIndex >= 0 && inIndex <= arr.length)){

//满足条件执行，那么取反则不执行，这样易于代码的阅读

System.out.println("输入下标错误，应该在0-"+arr.length+"之间！");

continue;

}else{

int[] temp = new int[arr.length + 1];

//这里需要 i < temp.length ， 因为 i 不再是表示arr的下标，而是temp的下标

for(int i = 0,j = 0 ; i < temp.length ; i++){//j表示arr的下标

if(i != inIndex){//到了插入的位置，直接跳过temp数组的这个位置

temp[i] = arr[j];

j++;

}

}

System.out.println("输入要添加的数据：");

int tempInt = input.nextInt();

temp[inIndex] = tempInt;

arr = temp;//栈空间中的arr指向temp数组在堆中的空间

}

}

System.out.println("插入数据后的数组为：");

for(int i = 0 ; i < arr.length ; i++){//插入完后打印一下数组

System.out.print(arr[i]+ "\t");

}

System.out.println();

}while(!"N".equalsIgnoreCase(flag));

}

}