Java基础21（数组）

数组

（1）数组：
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。
即：数（数据）组（一组）就是一组数据

引出数组:
求出农场里六只鸡的平均体重，分别是：3，5，1，3.4，2，50。

传统代码实现：

double hen1 = 3;
double hen2 = 5;
double hen3 = 1;
double hen4 = 3.4;
double hen5 = 2;
double hen6 = 50;

double totalWeight = hen1 + hen2 + hen3 + hen4 + hen5 + hen6;
double avgWeight = totalWeight / 6;
System.out.pirntln("总体重="+ totalWeight + "平均体重=" + avgWeight);

用数组实现：

//定义一个数组
//1.double[] 表示是double类型的数组,数组名 hens
//2.{3,5,1,3.4,2,50}表示数组的值/元素,依次表示数组的第几个元素
double[] hens = {3,5,1,3.4,2,50};

//遍历数组得到数组的所有元素的和 使用for循环
//1.可以通过 hens[下标]来访问数组的元素
//  下标是从 0 开始编号,比如第一个元素就是hens[0]
//  第二个元素就是hens[1],以此类推
//2.通过for循环就可以循环的访问 数组的元素/值
//3.使用一个变量 totalWeight 将各个元素累积

double totalWeight = 0;
for(int i = 0;i<6;i++){
  //System.out.println("第"+(i+1)+"个元素的值="+hens[i]);
  totalWeight + = hens[i];
}
  System.out.pirntln("总体重="+ totalWeight + "平均体重=" + avgWeight);

（2）数组的定义：
使用方式1 - 动态初始化
数据类型 数组名 [ ] = new 数据类型 [ 大小 ]
int a [] = new int [5]; // 创建了一个数组，名字a，存放5个int

数组的引用（使用/访问/获取数组元素）：
数组名[下标/索引/index]
比如：你要使用a数组的第3个数 a[2],数组的下标从 0 开始。

入门案例：

//循环输入5个成绩,保存到double数组，并输出
//步骤
//1.创建一个double数组,大小 5

double scores[] = new double[5];
//2.循环输入
//scores.length 表示数组的大小/长度

Scanner scs = new Scanner(System.in);
for(int i=0;i<scores.length;i++){
   System.out.println("请输入第"+(i+1)+"个元素的值");
   scores[i] = sc.nextDouble();
}
//输出，遍历数组
System.out.println("==数组的元素/值的情况如下：==");
for(int i = 0; i<scores.length;i++){
    System.out.println("第"+(i+1)+"个元素的值="+scores[i]);
}   

使用方式2 - 动态初始化

先声明数组
语法：数据类型 数组名 [] ;也可以 数据类型 [] 数组名;
int a [] ; 或者 int [] a;

创建数组

语法：数组名 = new 数据类型 [ 大小 ];

a = new int[10];

//（1）第1种动态分配方式
//double scores[] = new double[5];
//（2）第2种动态分配方式 ，先声明数组，再new分配空间
//double scores[]; //声明数组，这时 scores是null
//scores = new double[5]; //分配内存空间，可以存放数据

使用方式3 - 静态初始化

初始化数组

语法：数据类型 数组名[] = {元素值，元素值…}

int a[] ={2,5,6,7,8,89,90,34,56},如果知道数组有多少个元素，具体值上面的用法相当于 ： int a[] = new int[9];
a[0] = 2;a[1]=5;a[2]=6;a[3]=7;a[4]=8;
a[5]=89;a[6]=90;a[7]=34;a[8]=56;

入门案例【养鸡场】

double hens[] = {3,5,1,3.4,2,50};
等价
double hens[] = new double[6];
hens[0] = 3; hens[1]=5; hens[2]=1; hens[3]=3.4; hens[4]=2; hens[5]=50;

（3）注意事项：

//1.数组是多个相同类型数据的组合，实现对这些数据的统一管理

int [] arr1 = {1,2,3,60,"hello"}; //会报错，因为hello为String类型不为int类型

double[] arr2={1.1,2.2,3.3,60.6,100};//不会报错,int会自动转换成double类型

//2.数组中的元素是可以任何数据类型,包括基本数据类型和引用数据类型,但是不能混用
String[] arr3 = {"北京","jack","amdin"};

//3.数组创建后,如果没有赋值,有默认值int 0, short 0, byte 0, long 0, float 0.0, double 0.0, char \u0000, boolean false, String null 

short[] arr4 = new short[3];
System.out.println("====数组arr4====");
for(int i=0;i<arr.length;i++){
 System.out.println(arr4[i]);
} 

输出
0
0
0

//4.使用数组的步骤 
//(1).声明数组并开辟空间
//(2).给数组各个元素赋值
//(3)使用数组

//5.数组的下标是从0开始的。

//6.数组下标必须在指定范围内使用,否则会报:下标越界异常。 比如: int [] arr = new int[5];,则有效下标为0-4
//即数组的下标/索引 最小:0 最大:数组长度-1(4)

//7.数组属于引用类型,数组型数据是对象(object)

（4）数组应用案例：
1)创建一个char类型的26个元素的数组,分别放置 ‘A’ - ‘Z’。使用for循环访问所有元素并打印出来。提示：char类型数据运算 ‘A’+1->‘B’

思路分析：

1.定义一个数组 char arr[] = new char[26];
2.因为 'A' + 1 = 'B' 类推,所以老师使用for来赋值
3.使用for循环访问所有元素

代码实现：

public static void main(String[] args) {
		//创建一个char类型的26个元素的数组,
		//分别放置      'A' - 'Z'。使用for循环访问所有元素并打印出来。
		//提示：char类型数据运算 'A'+1->'B'
		char arr[]=new char[26];
		for(int i=0;i<=arr.length-1;i++){
			//chars是 char[]
			//chars[i]是char
			arr[i]=(char) ('A'+i); //'A' + i 是int,需要强制转换
			System.out.print(arr[i]+" ");
		}
	}

2)请求出一个数组 int [] 的最大值 {4,-1,9,10,23,56,999},并得到对应的下标。

思路分析：

1.定义一个int数组 int [] arr ={4,-1,9,10,23,56,999};
2.假定arr[0]是最大值,maxIndex=0;
3.从下标1开始遍历数组arr,如果max<当前元素,说明max不是真正的最大值,max=当前元素;maxIndex=当前元素下标
3.遍历这个数组arr后,max就是真正的最大值,maxIndex最大值对应的下标

代码实现：

//解法一：
public static void main(String[] args) {
		//请求出一个数组 int [] 的最大值 {4,-1,9,10,23,56,999},并得到对应的下标。
		int arr[] = {4,-1,9,10,23,56,999};
		int max=arr[0]; //假定第一个元素就是最大值
		int maxIndex = 0;
		
		for(int i=1;i<arr.length;i++){
			if(max<arr[i]){ //如果max<当前元素
				max=arr[i]; //把max 设置成当前元素
				maxIndex = i;
			}
		}
		//遍历数组arr,max就是真正的最大值,maxIndex最大值下标
		System.out.println("max="+max+"maxIndex="+maxIndex);
	}


//解法二：
public static void main(String[] args) {
		//请求出一个数组 int [] 的最大值 {4,-1,9,10,23,56,999},并得到对应的下标。
		int arr[] = {4,-1,9,10,23,56,999};
		int max=0;
		int num=0;
		for(int i=0;i<=arr.length-1;i++){
			if(max<arr[i]){
				max=arr[i];
				num=i;
			}
		}
		System.out.println("数组最大值为:"+max+",下标为:"+num);
	}

（5）数组赋值机制
1.基本数据类型赋值,这个值就是具体的数据,而且相互不影响。

2.数组在默认情况下是引用传递，赋的值是地址。

//基本数据类型赋值,赋值方式为值拷贝
//n2的变化，不会影响到n1的值
int n1=10;
int n2=n1;

n2=80;
System.out.println("n1=" + n1);//10
System.out.println("n1=" + n1);//80

//数组在默认情况下是引用传递,赋的值是地址,赋值方式为引用赋值
//是一个地址,arr2,变化会影响到arr1
int [] arr1 = {1,2,3];
int [] arr2 = arr1; //把arr1赋给arr2
arr2[0]=10;

//输出arr1的值
System.out.println("===arr1的元素===");
for(int i =0;i<arr.length;i++){
   System.out.println(arr1[i]);
}

//输出的值为:
//10
//2
//3   

图例：

(6)数组拷贝
将int [] arr = {10,20,30};拷贝到arr2数组，要求数据空间式独立的。

public static void main(String[] args) {	
		int arr1[] ={10,20,30};		
		//创建一个新的数组arr2,开辟新的数据空间
		//大小为arr1.length;
		int arr2[] =new int[arr1.length];
		//遍历arr1,把每个元素拷贝到arr2对应的元素位置
		for(int i=0;i<=2;i++){
			arr2[i]=arr1[i];
		}
		//修改arr2
		arr2[0]=200;
		
		//输出arr1
		for(int i=0;i<arr1.length;i++){
			System.out.println(arr1[i]);  //10,20,30
		}
		
		//输出arr2
		for(int j=0;j<=2;j++){
			System.out.println(arr2[j]);
		}
	}

(7)数组反转
要求：把数组的元素内容反转
arr{11,22,33,44,55,66} => {66,55,44,33,22,11}

解法一：

public static void main(String[] args) {
		//arr{11,22,33,44,55,66} => {66,55,44,33,22,11}
		//定义数组
		int arr[]={11,22,33,44,55,66};
		//思路分析:
		
		//规律
		//1.把arr[0]和arr[5] 进行交换 {66,22,33,44,55,11};
		//2.把arr[1]和arr[4] 进行交换 {66,55,33,44,22,11};
		//3.把arr[2]和arr[3] 进行交换 {66,55,44,33,22,11};
		//4.一共要交换3 次 = arr.length /2
		//5.每次交换时,对应的下标是arr[i]和arr[arr.length-1-i]
		
		//代码
		int temp=0;
		for(int i=0;i<arr.length/2;i++){
			    temp=arr[arr.length-1-i];
			    arr[arr.length-1-i]=arr[i];
				arr[i]=temp;
		}
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
		
	}

解法二：逆序赋值

public static void main(String[] args) {
		//arr{11,22,33,44,55,66} => {66,55,44,33,22,11}
		//定义数组
		int arr[]={11,22,33,44,55,66};
		//使用逆序赋值方法
		//思路分析:
		//1.先创建一个新的数组arr2,大小 arr.length
		//2.逆序遍历arr ,将 每个元素拷贝到arr2的元素中(顺序拷贝)
		//加一个循环变量j->0 ->5
		
		//代码
		int arr2[] = new int[arr.length];
		for(int i=arr.length-1,j=0;i>=0;i--,j++){//逆序遍历arr
			arr2[j]=arr[i];
		}
		
		//4.当for循环结束,arr2就是一个逆序的数组{66,55,44,33,22,11}
		//5.让arr指向arr2数据空间,此时arr原来的数据空间就没有变量引用
		//会被当做垃圾销毁
		arr = arr2;
		
		//6.输出arr
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]+"\t");
		}
	}

（8）数组添加
要求：实现动态的给数组添加元素效果,实现对数组扩容。
1）原始数组使用静态分配 int [] arr={1,2,3}
2）增加的元素，直接放在数组的最后 arr={1,2,3,4}
arrNew = {1,2,3,4}
3）用户可以通过如下方法来决定是否继续添加,添加成功,是否继续 y/n

第1步与第2步：代码实现与思路分析

public static void main(String[] args) {
		//1）原始数组使用静态分配 int [] arr={1,2,3}
		//2）增加的元素，直接放在数组的最后 arr={1,2,3,4}
		// arrNew = {1,2,3,4}
		//3）用户可以通过如下方法来决定是否继续添加,添加成功,是否继续 y/n

		//思路分析
		//1.定义初始数组 int[] arr ={1,2,3}
		//2.定义一个新的数组 int[] arrNew = new int[arr.length+1];
		//3.遍历arr数组,依次将arr的元素拷贝到arrNew数组
		//4.将 4 赋值给arrNew[arr.length-1] = 4; 把4赋给arrNew最后一个元素
		//5.让arr 指向 arrNew arr = arrNEew;那么arr数组就被销毁
		
		
		
		int arr[] ={1,2,3};
		int[] arrNew = new int[arr.length+1];
		for(int i=0;i<arr.length;i++){
			arrNew[i] = arr[i];
		}	
		//把4赋给arrNew最后一个元素
		arrNew[arrNew.length-1] = 4;
		//让arr指向 arrNew
		arr = arrNew;		
		//输出arr
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]+" ");
		}		
	}

添加第三步是否需要继续添加：

	public static void main(String[] args) {
		//1）原始数组使用静态分配 int [] arr={1,2,3}
		//2）增加的元素，直接放在数组的最后 arr={1,2,3,4}
		// arrNew = {1,2,3,4}
		//3）用户可以通过如下方法来决定是否继续添加,添加成功,是否继续 y/n

		//思路分析
		//1.定义初始数组 int[] arr ={1,2,3}
		//2.定义一个新的数组 int[] arrNew = new int[arr.length+1];
		//3.遍历arr数组,依次将arr的元素拷贝到arrNew数组
		//4.将 4 赋值给arrNew[arr.length-1] = 4; 把4赋给arrNew最后一个元素
		//5.让arr 指向 arrNew arr = arrNEew;那么arr数组就被销毁
		//6.创建一个Scanner可以接收用户输入
        //7.因为用户什么时候退出，不能确定，所以使用do-while + break来控制
		
		Scanner sc = new Scanner(System.in);
		//初始化数组
		int arr[] ={1,2,3};
		do{
	    int[] arrNew = new int[arr.length+1];
		for(int i=0;i<arr.length;i++){
			arrNew[i] = arr[i];
		}
		System.out.println("请输入要添加的元素:");
		int addNum = sc.nextInt();
		//把addNum赋给arrNew最后一个元素
		arrNew[arrNew.length-1] =addNum;
		//让arr指向 arrNew
		arr = arrNew;
		//输出arr
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]+" ");
		}
		//问用户是否继续
		System.out.println("是否继续添加 y/n");
		char key =sc.next().charAt(0);
		if(key == 'n'){  //如果输入n,就结束
			break;
		}
		}while(true);
	}

（9）数组缩减：
有一个数组{1,2,3,4,5},可以将该数组进行缩减,提示用户是否继续缩减,每次缩减最后哪个元素。当只剩下最后一个元素,提示,不能再缩减。

代码实现与思路：

public static void main(String[] args) {
    //有一个数组{1,2,3,4,5},可以将该数组进行缩减,提示用户是否继续缩减
    //,每次缩减最后那个元素。当只剩下最后一个元素,提示,不能再缩减。
		
		int arr[] ={1,2,3,4,5};
		Scanner sc = new Scanner(System.in);
		
		
		do{
		System.out.println("是否要删减第"+arr.length+"个元素？y/n");
		char shan = sc.next().charAt(0);
		
		//判断用户输入的是否为n,是则结束删除
		if(shan=='n'){
			System.out.println("删除结束");
			break;
		}
		//创建新数组arrNew
		int arrNew[] =new int[arr.length-1];

		//把arr数组中的每个元素赋给arrNew数组,并且删掉最后一个元素
		for(int i=0;i<arrNew.length;i++){
			arrNew[i]=arr[i];
		}
		
		//把arrNew拷贝给arr
		arr = arrNew;
		
		//输出数组arr
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]+" ");
		}
		
		//当数组只剩最后一个元素,则不能再缩减
		if(arr.length==1){
			System.out.println("数组只剩最后一个元素,不能再缩减");
			break;
		}
		}while(true);
	}