luogg_java学习_04_数组

2021-10-22 23:13:31

本文为博主辛苦总结,希望自己以后返回来看的时候理解更深刻,也希望可以起到帮助初学者的作用.

**转载请注明出自 : luogg的博客园 ** 谢谢配合!

数组

数组是多个相同类型数据的组合

//1.定义数组

		String [] name;

		//2.静态初始化

		name = new String []{"张三","李四","王五","赵六"};

		//3.遍历数组

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

			System.out.println(name[i]);

		}

		//1.定义一个动态数组

		int [] score;

		//2.动态初始化

		score = new int[5];

		score[0] = 87;

		score[1] = 88;

		score[2] = 89;

		score[3] = 90;

//		score[4] = 87;

		//3.遍历数组

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

			System.out.println(score[i]);

		}

//数组的默认初始化值

//对于基本的数据类型，byte,short,int,long,float,double,boolean,char,

		//1.对于byte,short,int,long而言，默认初始化是0

		byte [] score = new byte [3];

		score [0] = 3;

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

			System.out.println(score[i]);//3,0,0

		}

		//2.对于float,double而言，默认初始化是0.0

		float [] f = new float[3];

		f [0] = 1.3f;

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

			System.out.println(f[i]);//1.3,0.0,0.0

		}

		//3.对于boolean而言，默认初始化值是false

		boolean [] b = new boolean [3];

		b [0] = true;

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

			System.out.println(b[i]);//true,false,fasle

		}

		//4.对于char 而言，默认初始化值是空格

		char [] c = new char[3];

		c [0] = 'a';

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

			System.out.println(c[i]);//a, , ,

		}

		//4.对于引用数据类型，默认初始化值为null,数组也是‘引用数据类型,以Stirng为例

		String [] str = new String [3] ;

		str [0] = "旺财";

		str [1] = "小强";

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

			System.out.println(str[i]);//旺财，小强，null

		}

/*

 * 从键盘输入学生成绩，找出最高分，并输出学生成绩等级。

 * 成绩 >= 最高分-10 等级为A

 * 成绩 >= 最高分-20 等级为B

 * 成绩>= 最高分-30 等级为C

 * 其余  等级为D

 *

 */

public class t04_StudentScore {

	public static void main (String [] args){

		//1.创建一个Scanner对象，并从键盘获取学生的个数。

		Scanner s = new Scanner(System.in);

		System.out.println("请输入学生个数: ");

		int count = s.nextInt();//count 用来记录学生的个数

		//2.创建一个长度和学生个数相同的int型数组。(动态数组)

		int [] score = new int [count];

		int maxScore = 0;

		System.out.println("请输入学生成绩");

		//3.从键盘一次获取学生的成绩，并赋值给数组元素。并获取学生中的最高分。

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

			int scores = s.nextInt();

			score[i] = scores;

			if(score[i] > maxScore){

				maxScore = score[i];

			}

		}

		//4.遍历学生成绩的数组，并根据成绩与最高分的差值，赋予相应的等级，并输出。

		System.out.println("最高分为:" + maxScore);

		char level;

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

			if(score[i] >= maxScore - 10){

				level = 'A';

			}else if(score[i] >= maxScore - 20){

				level = 'B';

			}else if(score[i] >= maxScore - 30){

				level = 'C';

			}else{

				level = 'D';

			}

		System.out.println("student:" + i + " score:"+score[i]+" level:"+level);

		}

		s.close();

	}

}

内存中动态初始化数组的步骤

某数组:

int [ ] score = new int [4];

score[0]=89;

score[3]=90;

首先，栈中会先开辟一个score的空间，然后堆中生成一个带有16进制地址值长度为4的数组，然后将这个地址值传递给栈中的score，最后score将他的值score[0]和score[3]传给堆中的数组中。

只要new出来的，都在堆空间。
数组长度一旦初始化，其长度不可以改变。

//二维数组的静态初始化和遍历

//		int [][] i = new int[][]{{1,2,3},{3,4,5},{6}};

		int [][] i;

		i = new int[][]{{1,2,3},{3,4,5},{6}};

		for(int m = 0 ; m < i.length; m++){//行

			for(int n = 0; n < i.length; n++){//列

				System.out.print(i[m][n]+" ");

			}

			System.out.println();

		}

		//获取二维数组的长度

		System.out.println(i.length);//3

		//获取二维数组元素的长度

		System.out.println(i[0].length);//3

		//二位数组的动态初始化

		String [][] name;

		name = new String[5][4];//动态初始化方法一

		name = new String[5][];//动态初始化方法二

		name[0] =new String[6];

		name[1] =new String[3];

		name[2] =new String[4];

		name[3] =new String[2];

		name[4] =new String[5];

		name[0][3] = "哈哈";

		/*错误的初始化方式

		name = new String[][];

		name = new String[][5];

		*/

	}

常见的数组异常

数组下标越界异常:java.lang.ArrayIndexOutOfBoundsException
空指针异常(栈空间空指针，堆空间空指针)

//		数组下标越界异常:java.lang.ArrayIndexOutOfBoundsException

        /*int[] i = new int [5];

		i[10] = 10;

		System.out.println(i);*/

//		2.空指针异常: java.lang.NullPointerException

		/*boolean [] b = new boolean[3];

		b=null;//栈空间中的空指针异常

		System.out.println(b[0]);*/

		//堆空间中的空指针异常

		String [] s = new String[3];

		System.out.println(s[0].toString());

		//空值无法调用方法，不是实体

		//		二维数组堆空间中的空指针异常

		int [][] i = new int [3][];

		i[3][0] = 2;

		//因为new的int[3][]中本身就是3个null的对象，无法给i[3][0]传值

杨辉三角

/*

 * 使用二维数组打印10行的杨辉三角(开始结束都为1，内部为上边的上边左边的和)

 * 1

 * 1	1

 * 1	2	1

 * 1	3	3	1

 * 1	4	6	4	1

 * 1	5	10	10	5	1

 * ~~~

 */

public class t08_杨辉三角 {

	public static void main(String[] args) {

		// 1.创建数组

		int[][] yangHui = new int[10][];

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

			yangHui[i] = new int[i + 1];// 定义列的个数

		}

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

			for (int j = 0; j < yangHui[i].length; j++) {

				yangHui[i][0] = yangHui[i][i] = 1;

				if (i > 1 && j > 0 && j < i) {

					yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j-1];

				}

			}

		}

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

			for (int j = 0; j < yangHui[i].length; j++) {

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

			}

			System.out.println();

		}

	}

}

练习

//使用简单数组

//(1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，

//	他们是int[]类型的数组。

//(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。

//(3)显示array1的内容。

//(4)赋值array2变量等于array1，修改array2中的偶索引元素，

//	使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。

public class t10_两数组值转换 {

	public static void main(String[] args) {

		int[] array1,array2;

		array1 = new int[]{2,3,5,7,11,13,17,19};

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

			System.out.print(array1[i]+" ");

		}

		System.out.println();

		array2 = array1;

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

			if(i%2==0){

				array2[i] = i;

			}

			System.out.print(array2[i]+" ");

		}

		System.out.println();

		//将array1的值赋给array2，修改array2之后打印array1，发现也跟着改变了

		//原因就是array1赋值给array2的是它的地址，修改array2的时候就是修改了array1.

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

			System.out.print(array1[i]+" ");

		}

	}

}

array2 = array1 的内存图解

正确的数组复制方式:

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

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

			arr1[i] = arr[i];

			System.out.print(arr1[i]+" ");

		}

数组的常用算法

/*

	1.求数组元素的最大值、最小值、平均数、总和等

	2.数组的复制、反转

	3.数组元素的排序

*/ 

public class t09_数组常用算法1 {

	public static void main(String[] args) {

		int[] arr = new int[]{2,43,23,55,75,-3,-99,100,75,-9};

		//求最大值

		int max = arr[0];

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

			if(max < arr[i]){

				max = arr[i];

			}

		}

		System.out.println("数组的最大值:" +max);

		//求最小值

		int min = arr[0];

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

			if(min > arr[i]){

				min = arr[i];

			}

		}

		System.out.println("数组的最小值为:" +min);

		//求和

		int sum = 0;

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

			sum += arr[i];

		}

		System.out.println("数组的和为:" +sum);

		//求平均值

		int avg;

		avg = sum / arr.length;

		System.out.println("数组的平均值为:" +avg);

		//数组的复制

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

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

			arr1[i] = arr[i];

			System.out.print(arr1[i]+" ");

		}

		System.out.println();

		//数组元素的反转

//		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;

//		}

//		数组元素反转方法二:

		for(int x = 0 , y = arr.length - 1 ; x < y ; x++ , y--){

			int temp = arr[x];

			arr[x] = arr[y];

			arr[y] = temp;

		}

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

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

		}

	}

}

输出结果:

冒泡排序和直接选择排序

/*

	冒泡排序的思想:(从小到大)

		相邻两个元素比较，前边比后边大，那么就前后交换位置，一直比到最后一个。

		每完成一次循环就将最大元素排在最后（如从小到大排序），

		下一次循环是将其它的数进行类似操作。

*/

public class t11_冒泡排序 {

	public static void main(String[] args) {

		int[] arr = new int[]{2,43,23,55,75,-3,-99,100,75,-9};

		System.out.println("冒泡排序之前:");

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

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

		}

		//使用冒泡排序将数组元素从小到大排序

		//外层控制轮数，内层比较相邻元素大小

		for(int i = 0 ; i < arr.length-1 ; i++){//有n个数，循环n-1次

			for(int j = 0 ; j < arr.length - 1 - i ; j++){//循环到数组长度-1-i终止

				if(arr[j] > arr[j + 1]){

					int temp = arr[j];

					arr[j] = arr[j + 1];

					arr[j + 1] = temp;

				}

			}

		}

		System.out.println();

		System.out.println("冒泡排序之后:");

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

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

		}

	}

}

/*

 * 直接选择排序就是先用第一个元素和下一个比，下一个比他小，则交换，再和下下一个比一直到最后。

 * 然后用第二个和下一个比，以此类推。

 */

public class t12_直接选择排序 {

	public static void main(String[] args) {

		int[] arr = new int[]{2,43,23,55,75,-3,-99,100,75,-9};

		//使用直接排序将元素从小到大排序

		for(int i = 0 ; i < arr.length - 1 ; 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;

				}

			}

		}

		//遍历元素

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

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

		}

	}

}

码农公寓

luogg_java学习_04_数组

本文为博主辛苦总结,希望自己以后返回来看的时候理解更深刻,也希望可以起到帮助初学者的作用.

转载请注明出自 : luogg的博客园谢谢配合!

数组

内存中动态初始化数组的步骤

常见的数组异常

杨辉三角

练习

数组的常用算法

冒泡排序和直接选择排序

码农公寓

本文为博主辛苦总结,希望自己以后返回来看的时候理解更深刻,也希望可以起到帮助初学者的作用.

**转载请注明 出自 : luogg的博客园 ** 谢谢配合!

数组

内存中动态初始化数组的步骤

常见的数组异常

杨辉三角

练习

数组的常用算法

冒泡排序和直接选择排序

相关文章

转载请注明出自 : luogg的博客园谢谢配合!