java_数组_学会数组从本文开始

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
		/*
		1-100以内的求和，求出当和大于20时候的那个数。
		 */ 
		double[] hens = {1.5, 5.6, 56, 30, 60};
		double sum = 0;
		double average;
		// 遍历数组中的元素。
		// java中的元素是从0开始的。
		for (int i = 0;i <= 4 ;i++ ) {
			System.out.println(hens[i]);
			sum += hens[i];
		}
			average = sum / 5;
			System.out.println("最终的平均数：" + average);
	}
}

（1）了解数组的定义(也有好多种数据类型，具体选那种数据类型需要最开始定义)；怎么样遍历数组，用for循环，怎么取出数组中的每一个数。

         怎么打印数组中的数。

（2）数组中的数序号是从0开始的；

（3）第几个数是(i+1);

（4）打印第几个元素的值：

System.out.println("第"+ （i+1）+ "元素的值=" + hens[i]);

在java 中可以根据    数组名.length，这一点很重要哦。

数组的使用

1、动态初始化

数组的定义

数据类型[] 数组名   = new  数据类型[大小]

int[] hens = new int[50];      创建了一个数组，名字为a，存放5个int。

你要使用数组的第三个元素：a[2]

 在没有放值的时候，数据内的元素默认是0.

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
		/*
		键盘输入5个double类型，保存在设置的数组中。
		大小就是大小。获取数组的长度你会吗？
		 */ 
		double[] score = new double[5];
		Scanner myScanner = new Scanner(System.in);

		// 遍历数组中的元素。
		// java中的元素是从0开始的。
		for (int i = 0;i < score.length ;i++ ) {
			System.out.println("请输入第" + (i+1) + "个同学的分数");
			score[i] = myScanner.nextDouble();
		}
			
			System.out.println("输入完毕" );
			System.out.println("接着遍历数组" );

		for (int i = 0;i < score.length ;i++ ) {
			System.out.println("第" + (i+1) + "个数组的值" + score[i]);
		}	

	}
}

2、动态初始化          数组就是[]

（1）先声明数组：    数据类型[] 数组名；   int[ ]  score;   score是null。

（2）创建数组  ：     数组名 = new 数据类型[大小]；    score = int [50]；

         double[] score;
		score = new double[5];

可以一步，也可以两步。这样也有使用场景。

3、静态初始化

int[] score = {1,2,3};   一般知道具体的值的时候采用这个。且个数较小。

这种用法相当于：

int[] score = new int[3] ;

score[0] = 1;  score[1] = 2;...

注意事项：

1、数组是多个相同数据类型的集合；

2、数组中的元素可以是任何数据类型，包括基本数据类型和引用类型，但是不能混用，包括String；

String[] ch = {"我爱你","aini"};

3、数组创建后，若没有使用是有默认值的。

 4、怎么使用呢，三种方法。

        int[] hens = new int[50];   这个过程可以分成两步。还有一种是直接赋值的。

5、数组的下表是从0开始的。

6、数组下表必须在制定的范围内使用，否则报：下表越界异常，比如

     int[] score = new int[5],这个数组的有效下标是0-4.   < score.length

      下标很重要！！！数组的下表最大值是长度减一。最小是0。

7、数组是属于引用类型的，数组型的数据本质上是对象（object）

---

---

数组应用案例

1

symbol[i] = (char)('A' + i) 

这一点一定要注意哈。需要一个强转的。

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
		/*
		键盘输入5个double类型，保存在设置的数组中。
		大小就是大小。获取数组的长度你会吗？
		 */ 
		char[] symbol = new char[26];
	
		for (int i = 0;i < symbol.length ;i++ ) {
				symbol[i] = (char)('A' + i) ;//问题就出现在这。
		}	
		for (int i = 0;i < symbol.length ;i++ ) {
				
			System.out.println("第" + (i+1) + "个数组的值" + symbol[i]);

		}	

	}
}

数组：Array

求一个数组中数的最大值。

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
		/*
		找到数组中的最大值。
		1、假定max = array[0]，maxIndex = 0.
		2、从下标1 开始遍历，如果max < 当前数。将当前数赋值给max，maxIndex = i（当前的i）。
		3、自己和自己比较是没什么意义的，因此从第一个开始比较。也就是一个遍历、赋值比较。
		 */ 
		int i;
		int[] num = {4,-1,9,999,23,25,80,1000,8928};
		int maxnum = num[0];
		// System.out.println("此时的下标是 ：" + maxnum);
		int maxIndex = 0;
		for (i = 1;i < num.length ;i++) {
			if ( num[i] > maxnum) {
				maxnum= num[i];
				maxIndex = i;
			}
			
		}

			System.out.println("最大的值是 ：" + maxnum);
			System.out.println("此时的下标是 ：" + maxIndex);
}
		

	}

---

---

数组赋值机制：

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

 看上面的代码，将arr1的值赋值给arr2，赋的值是地址。地址的重新指向。

此时arr2的值变化会影响到arr1的值。

栈   堆  方法区

 把这个图记住。地址的指向正这看。

记住这就话：在内存里面只要分配了一个空间，一定会对应一个地址。

也就是两个共用一个地址空间。数组元素放在堆。

自我胡说八道：地址就像祖籍，这个东西是一生下来就固定的，基本上看你的爸爸爷爷辈，而户口是后天可以改变的，若你以后再上海北京有了户口（原来是祖籍的户口），无论你走到哪里，祖籍永远是哪个不变的。

 

遍历数组1，并且将值赋值给arr2.

 

 

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
		/*
		
		 */ 
		int[] arr1 = {10,20,30};
		//创建一个行的数组arr2，开辟新的数据空间。
		//大小  arr1.length
		int[] arr2 = new int[arr1.length];
		// 这条语句的作用是重新开辟一个空间。
		// arr2 = {10,20,30};//再次赋值
		for (int i = 0;i < arr1.length ; i++) {
			arr2[i] = arr1[i]; 
 		}
			for (int i = 0;i < arr2.length ; i++) {
				System.out.println("第 "+(i + 1)+"数组的值是;" + arr2[i]);
			}

     }
}

再次赋值就不会出现覆盖的情况了。

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
		/*
		
		 */ 
		int[] arr1 = {10,20,30};
		//创建一个行的数组arr2，开辟新的数据空间。
		//大小  arr1.length
		int[] arr2 = new int[arr1.length];
		// 这条语句的作用是重新开辟一个空间。
		// arr2 = {10,20,30};//再次赋值
		for (int i = 0;i < arr1.length ; i++) {
			arr2[i] = arr1[i]; 
 		}
 		arr2[0] = 25;
			for (int i = 0;i < arr2.length ; i++) {
				System.out.println("第 "+(i + 1)+"数组2的值是;" + arr2[i]);
			}
			for (int i = 0;i < arr2.length ; i++) {
				System.out.println("第 "+(i + 1)+"数组1的值是;" + arr1[i]);
			}

     }
}

数组反转

---

{22,112,56}  ---------------------------------------------------------------------------》{56,112,22}

将数组反转的几种方法：

第一种方法：重新定义一个新的数组。不是逆序遍历，是正顺序的遍历，将其赋值给数组2的最后一个地址。

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
		/*
		
		 */ 
		int[] arr1 = {10,20,30};
		//创建一个行的数组arr2，开辟新的数据空间。
		//大小  arr1.length
		int[] arr2 = new int[arr1.length];
		int j = 2;
		// 这条语句的作用是重新开辟一个空间。
		// arr2 = {10,20,30};//再次赋值
		for (int i = 0;i < arr1.length ; i++) {
		
			arr2[j] = arr1[i]; 
			j--;
 		}
 		
			for (int i = 0;i < arr2.length ; i++) {
				System.out.println("第 "+(i + 1)+"的值是;" + arr2[i]);
			}

     }
}

int[] hens = new int[arr.length] 

这样的方法很无聊。本质是上是创建了一个新的数组，也就是新的地址，将原来数组中的值重新赋值给新的地址。

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
		/*
		1、将数组的第一个和最后一个交换顺序。将第二个和倒数第二个进行交换。
		2、依次进行，可以按照奇偶进行变换啊。本来我想的是要考虑奇偶，但是7 / 2 = 3
		6 / 2 = 3,也就是说：要是偶数的话，也是交换这么多次。奇数时，中间的那个数就不交换
		3、 0和5，交换；1和4交换。2和3交换。他们的和都是5（arr1.length-1），而对应的另外一个数就是
		arr1.length-1-i；就是要去找规律。
		4、最主要的是要先定义一个临时变量。
		5、优化，
		 */ 
		int[] arr1 = {10,20,30,40,50,60,70};
		int temp;
		for (int i = 0;i < arr1.length / 2 ; i++) {
			temp = arr1[arr1.length - 1 - i];
			arr1[arr1.length-1-i] = arr1[i]; 
			arr1[i] = temp;		
 		}
		
		for (int i = 0;i < arr1.length ; i++) {

			System.out.println("第 "+(i + 1)+"的值是;" + arr1[i]);
		}
    }
}

---

---

数组的添加

1、就是加上添加数据；这是转接的是地址，不能想赋值那样，地址空间时固定的。

这样就是另外一个数组啦。将数组之前的值遍历出来赋值给新的数组。

我的代码;

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
	int[] arr1 = {1,2,3};
	int[] arr = new int[4];
	// arr = arr1;这是地址的指向，那样的话，后面的语句就会越界，
	arr[3] = 4;
	for (int i = 0;i < arr1.length ;i++ ) {
		arr[i] = arr1[i];
	}
	for (int i = 0;i < arr.length  ;i++ ) {
		System.out.println("最后的结果：  " + arr[i]);
	}
//其实还可以先死后活。继续增加变量。
    }
}

改进后的：

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
	int[] arr = {1,2,3};
	int[] arrNew = new int[4];
	// arr = arr1;
	arrNew[3] = 4;
	for (int i = 0;i < arr.length ;i++ ) {
		arrNew[i] = arr[i];
	}
	arr = arrNew;//将arr的地址指向arrNew的地址空间，这样的话，数组还是那个数组，他的值变化喽。
	for (int i = 0;i < arr.length  ;i++ ) {
		System.out.println("最后的结果：  " + arr[i]);
	}

    }
}

do {

}while(true);  配合break使用。

接收字符： char key = myScanner.next().charAt（0）;括号别忘记了。
    arr = arrNew;//将arr的地址指向arrNew的地址空间，这样的话，数组还是那个数组，他的值变化喽。（睁着看）原先的空间就被jvm销毁，这样的话节省空间哦！

下面的代码是缩减数组的值的，有缺陷，暂不改进，保留最后一个数值。

import java.util.Scanner;
public class Change{
	public static void main(String[] args){
	// 创建一个Scanner可以接受用户输入
	// 因为用户什么时候退出不确定。
	Scanner myScanner = new Scanner(System.in);
	int[] arr = {1,2,3,4,5};
	int count = arr.length;
	do{
	System.out.println("请问你要缩减数组的值吗 y/n ");
	char key = myScanner.next().charAt(0);//先要输入吗？然后在接收一个
	
	if (key == 'n') {
		break;
	}else{
		count--;

		if (count == 1) {
				System.out.println("不能在减少了");
				System.out.println("最后一个数组的值 = " + arr[0]);

			break;
		}
		int[] arrNew = new int[arr.length - 1];
	// arrNew[arrNew.length - 1] = num;
		for (int i = 0;i < arr.length - 1;i++ ) {
			arrNew[i] = arr[i];
		}
			arr = arrNew;//将arr的地址指向arrNew的地址空间，这样的话，数组还是那个数组，他的值变化喽。
			for (int i = 0;i < arr.length  ;i++ ) {
				System.out.println("最后的结果：  " + arr[i]);
			}

         }  
		}while(true);


    }
}

完结撒花！！