韩顺平 零基础30天学会Java第六章

数组

为什么需要数组

一个养鸡场有6只鸡,它们的体重分别是3kg,5kg,1kg,3.4kg,2kg,50kg。请问这六只鸡的总体重是多少?平均体重是多少?请你编一个程序。

//思路分析
//1.定义六个变量double ,求和得到总体重
//2.平均体重=总体重/6
//3。分析传统实现的方式问题.6->600->566
//4。引出新的技术->使用数组来解决.
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.println("总体重="+ 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]
//   第2个元素就是 hens[1]
//2.通过for就可以循环的访问数组的元素/值
//3.使用一个变量totalweight将各个元泰累积
//老师提示:可以通过数组名.length得到数组的大小/长度 
double totalWeight = 0;
for( int i = 0; i< 6; i++){
	System.out.println("第"+(i+1)+"个元素的值="+ hens[i]);
	totalWeight += hens[i];
}
system.out.println("总体重=" + totalWeight 
	+ "平均体重=" + (totalWeight / 6));

数组的使用

使用方式1-动态初始化

数组的定义
数据类型 数组名[] = new 数据类型[大小]
int a[] = new int[5];//创建了一个数组,名字a,存放5个int
说明:这是定义数组的一种方法。
数组的引用(使用)
数组名[下标/索引/index] 比如:你要使用a数组的第3个数a[2],数组的下标从0开始。
快速入门案例
循环输入5个成绩,保存到double数组,并输出

import java.util.Scanner;
public class Array02 {
	//编写一个main方法
	public static void main(String[] args) {
		//演示数据类型数组名[]=new数据类型[大小]
		//循环输入5个成绩,保存到double数组,并输出
		//步骤
		//1.创建一个double数组,大小5
		double scores[] = new double[5];
		//2.循环输入
		//scores.length表示数组的大小/长度
		//
		Scanner myScanner = new Scanner(System.in);
		for( int i = 0; i < scores.length; i++) {
			System.out.println("请输入第"+(i+1)+"个元素的值");
			scores[i] = myScanner.nextDouble();
		}
		//输出,逼历数组
		system.out.println("==数组的元素/值的情况如下:===");
		for( int i = 0; i < scores.length; i++){
			system.out.print1n("第"+(i+1)+"个元素的值="+ scores[i]);
		}
	}
}

使用方式2-动态初始化

先声明数组
语法:数据类型 数组名[];也可以数据类型[] 数组名;
int a[ ];或者int[ ] a;
创建数组
语法:数组名=new 数据类型[大小];
a=new int[10];

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;

数组使用注意事项和细节

1.数组是多个相同类型数据的组合,实现对这些数据的统一管理
2.数组中的元素可以是任何数据类型,包括基本类型和引用类型,但是不能混用。
3.数组创建后,如果没有赋值, 有默认值int 0, short 0, byte 0, long 0, float 0.0,double 0.0, char \u0000, boolean false, String null
4.使用数组的步骤:1.声明数组并开辟空间; 2.给数组各个元素赋值; 3.使用数组
5.数组的下标是从0开始的。
6.数组下标必须在指定范围内使用,否则报:下标越界异常,比如
int[] arr=new int[5];则有效下标为0-4
7.数组属引用类型,数组型数据是对象(object)

数组应用案例

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

//思路分析
//1.定义一个数组char[] chars = new char[26]
//2.因为'A' +1 ='B'类推,所以老师使用for来赋值
//3.使用for循环访问所有元素
char[] chars = new char[26];
for(int i = 0; i < chars.length; i++){//循环26次
	// chars 是char[]
	// chars[i]是char
	chars[i] =(char)('A' + i);//'A'+i 是int,需要强制转换
}
//循环输出
system.out.println( "===chars数组===");
for( int i = 0; i < chars.length; i++){//循环26次
	System.out.print(chars[i] +" ");
}

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

//老韩思路分析
//1.定义一个int数组int[] arr = {4,-1,9,10,23];
//2.假定max = arr[O]是最大值, maxIndex=O;
//3.从下标1开始逼历arr,如果max〈当前元素,说明max不是真正的
//   最大值,我们就max=当前元素;maxIndex=当前元素下标
//4.当我们逼历这个数组arr后, max就是真正的最大值, maxIndex最大值
//   对应的下标
int[] arr = {4,-1,910,23};
int max = arr[o];//假定第一个元秦就是最大值
int maxIndex = 0;//
for(int i = 1; i < arr.length; i++) {//从下标1开始逼历arr
	if(max < arr[i]) {//如果max<当前元素
		max = arr[i];//把max设置成当前元素
		maxIndex = i;
	}
}
System.out.println( "max="+ max + " maxIndex=" + maxIndex);

3.请求出一个数组的和和平均值。(养鸡场)

数组赋值机制

1.基本数据类型赋值,赋值方式为值拷贝,这个值就是具体的数据,而且相互不影响。
int n1 = 2; int n2 = n1;
2.数组在默认情况下是引用传递,赋的值是地址,赋值方式为引用赋值,是一个地址, 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 < arr1.length; i++) {
	system.out.println(arr1[i]);//10,2,3
}
System.out.println( "====arr2的元素====");
for(int i = 0; i < arr2.length; i++) {
	System.out.println(arr2[i]);//10,2,3
}

在这里插入图片描述

数组拷贝

编写代码实现数组拷贝(内容复制)
将int[] arr1 = {10,20,30};拷贝到arr2数组,要求数据空间是独立的。

int[]arr1 = {10,20,30};
//创建一个新的数组arr2,开辟新的数据空间
//大小arr1.length;
int[] arr2 = new int[arr1.length];
//遍历arr1 ,把每个元素拷贝到arr2对应的位置
for(int i = 0; i < arr1.length; i++) {
	arr2[i] = arr1[i];
}
//老师修改arr2
arr2[0] =100;
//输出arr1
system.out.println( "====arr1的元素====");
for(int i = 0; i < arr1.length; i++) {
	System.out.println(arr1[i]);//10,20,30
}
System.out.println( "====arr2的元素====");
for(int i = 0; i < arr2.length; i++) {
	System.out.println(arr2[i]); //100,20,30
}

数组反转

要求:把数组的元素内容反转。
{11,22,33,44,55,66} →{66, 55,44,33,22,11}
1)方式1:通过找规律反转【思路分析】

//定义数组
int[] arr = {11223344,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;
int len = arr.length;//计算数组的长度
for( int i = 0; i < len / 2; i++) {
	temp = arr[ len - 1 - i];//保存
	arr[len - 1 - i] = arr[i];
	arr[i] = temp;
}
System.out.println( "===翻转后数组==="");
for(int i = 0; i < arr.length; i++) {
	System.out.print(arr[i] +"\t");//66,55,44,33,22,11
}

2)方式2:使用逆序赋值方式【思路分析,学员自己完成】

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

数组添加

要求:实现动态的给数组添加元素效果,实现对数组扩容。
1)原始数组使用静态分配int[] arr = {1,2,3}
2)增加的元素4,直接放在数组的最后arr ={1,2.3.4}

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

3)用户可以通过如下方法来决定是否继续添加,添加成功,是否继续? y/n

import java.util.Scanner;
public class ArrayAdd02 {
	//编写一个main方法
	public static void main(String[]args) {
	/*
	思路分析
	1.定义初始数组int[] arr = {1,2,3}//下标0-2
	2.定义一个新的数组int[] arrNew = new int[ arr.length+1];
	3.遍历arr数组,依次将arr的元素拷贝到arrNew数组
	4.将4赋给arrNew[ arrNew.length - 1]= 4;把4赋给arrNew最后一个元素
	5. 让arr 指向arrNew ; arr = arrNew那么原来的arr数组就被销毁
	6. 创建一个Scanner可以接受用户输入
	7.因为用户什么时候退出,不确定,老师使用do-while + break来控制
	*/
	Scanner myScanner = new Scanner(System.in);
	int[] arr = {1,2,3};
	do {
		int[] arrNew = new int[arr.length + 1];
		//遍历arr数组,依次将arr的元素拷贝到arrNew数组
		for(int i = 0; i < arr.length; i++) {
			arrNew[i] = arr[i];
		}
		System.out.println("请输入你要添加的元素");
		int addNum = myScanner.nextInt();
		//把addNum赋给arrNew最后一个元素
		arrNew[ arrNew. length - 1] = addNum;//让arr指向arrNew,
		arr = arrNew;
		//输出arr看看效果
		System.out.print1n( "====arr扩容后元素情况====");
		for(int i = 0; i < arr.length; i++) {
			system.out.print(arr[i] + "\t");
		}
		//问用户是否继续
		system.out.println("是否继续添加y/n");
		char key = myScanner.next().charAt(0);
		if( key == 'n') {//如果输入n,就结束
			break;
		}
	}while(true);
	system.out.print1n("你退出了添加..");
}

课后练习题

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

排序

排序的介绍

排序是将一群数据,依指定的顺序进行排列的过程。排序的分类:
1.内部排序:
指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法);
2.外部排序法:
数据量过大,无法全部加载到内存中,需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)。

冒泡排序法

冒泡排序(Bubble Sorting)的基本思想是:通过对待排序序列从后向前(从下标较大的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒

冒泡排序法案例

下面我们举一个具体的案例来说明冒泡法。我们将五个序:24,69,80,57,13使用冒泡排序法将其排成一个从小到大的有序数列。
分析冒泡排序
数组[24,69,80,57,13]

  • 第1轮排序:目标把最大数放在最后
    第1次比较[24,69,80,57,13]
    第2次比较[24,69,80,57,13]
    第3次比较[24,69,57,80,13]
    第4次比较[24,69,57,13,80]
  • 第2轮排序:目标把第二大数放在倒数第二位置
    第1次比较[24,69,57,13,80]
    第2次比较[24,57,69,13,80]
    第3次比较[24,57,13,69,80]
  • 第3轮排序:目标把第3大数放在倒数第3位置
    第1次比较[24,57,13,69,80]
    第2次比较[24,13,57,69,80]
  • 第4轮排序:目标把第4大数放在倒数第4位置
    第1次比较[13,24,57,69,80]

总结冒泡排序特点
1.我们一共有5个元素
2.一共进行了4轮排序,可以看成是外层循环
3.每1轮排序可以确定一个数的位置,比如第1轮排序确定最大数,第2轮排序,确定第2大的数位置,依次类推
4.当进行比较时,如果前面的数大于后面的数,就交换
5.每轮比较在减少4->3->2->1

int[] arr = {246980,57,13};
int temp = 0;//用于辅助交换的变量
//将多轮排序使用外层循环包括起来即可
//先死后活=》4就是arr.length - 1
for( int i =0; i <arr.length - 1; i++){//外层循环是4次
	for( int j =0; j < arr.length - 1 - i; j++){//4次比较-3次-2次-1次
		//如果前面的数>后面的数,就交换
		if(arr[j] > arr[j + 1]){
			temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
		}
	}
	System.out.println( "\n==第"+(i+1)+"轮==");
	for(int j = 0; j < arr.length; j++){
		System.out.print(arr[j]+ "\t");
	}
}

查找

介绍:

在java中,我们常用的查找有两种:
1.顺序查找 SeqSearch.java
2.二分查找【二分法,我们放在算法讲解】

案例演示:

1.有一个数列:白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏:从键盘中任意输入一个名称,判断数列中是否包含此名称【顺序查找】
要求:如果找到了,就提示找到,并给出下标值。

//思路分析
//1.定义一个字符串数组
//2.接收用户输入,逼历数组,逐一比较,如果有,则提示信息,并退出
//定义一个字符串数组
string[] names = ={"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入名字");
String findName = myScanner.next();
//这里老师给大家一个编程思想/技巧,一个经典的方法
int index = -1;
for(int i = 0; i < names.length; i++) {
	//比较字符串比较equals,如果要找到名字就是当前元素	
	if(findName.equals(names[i])){
		system.out.println("恭喜你找到"+ findName);
		system.out.println("下标为="+ i);
		//把i保存到index
		index = i;
		break;//退出
	}
}
if(index == -1){//没有找到
	System.out.println( "sorry ,没有找到" + findName);
}

2.请对一个有序数组进行二分查找{1,8,10,89,1000,1234},输入一个数看
看该数组是否存在此数,并且求出下标,如果没有就提示"没有这个数"。

多维数组

多维数组-二维数组

多维数组我们只介绍二维数组。

二维数组的应用场景
比如我们开发一个五子棋游戏,棋盘就是需要二维数组来表示。如图;
在这里插入图片描述

/*
请用二维数组输出如下图形
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
*/
//什么是二维数组://老韩解读
//1.从定义形式上看int[][]
//2.可以这样理解,原来的一维数组的每个元秦是一维数组,就构成二维数组
int[][] arr = {{000000},{001000},
				{0,20300},{000000}};
//输出二维图形
for(int i = 0; i < arr.length; i++) {//遍历二维数组的每个元素
	//遍历二维数组的每个元素(数组)
	//老韩解读
	//1. arr[i]表示二维数组的第i+1个元素比如arr[0]:二维数组的第一个元秦
	//2. arr[i].length得到对应的每个一维数组的长度
	for(int j = 0; j < arr[i].length; j++) {
		System.out.print(arr[i][j] + " ");//输出了一维数组
	}
		system.out. println();//换行
}


//关于二维数组的关键概念
//(1)
System.out.print1n("二维数组的元素个数=" + arr.length);
//(2)二维数组的每个元素是一维数组,所以如果需要得到每个―维数组的值
//    还需要再次逼历
//(3)如果我们要访问第(i+1)个一维数组的第j+1个值arr[i][j];
//    举例访问3,=》他是第3个一维数组的第4个值arr[2][3]
System.out.println("第3个一维数组的第4个值=" + arr[2][3]);

二维数组的使用

使用方式1:动态初始化

1)语法:类型[ ][ ] 数组名 = new 类型[大小][大小]
2)比如: int a[ ][ ]=new int[2][3]
使用演示
二维数组在内存的存在形式

int arr[][] = new int[2][3];
arr[1][1]= 8;
//遍历arr数组
for(int i =0; i < arr.length; i++){
	for( int j = 0; j < arr[i].length; j++){
		system.out.print(arr[i][j]+"");
	}
	System.out.println();//换行
}

在这里插入图片描述

使用方式2:动态初始化

1)先声明:类型数组名[ ][ ];
2)再定义(开辟空间)数组名=new类型[大小][大小]
3)赋值(有默认值,比如int类型的就是0)
4)使用演示

int arr[][];//声明二维数组
arr = new int[2][3];//再开空间

使用方式3:动态初始化-列数不确定

1)看一个需求:动态创建下面二维数组,并输出。
在这里插入图片描述
2)完成该案例
3)画出执行分析示意图

int[][]arr = new int[3][]; //创建二维数组,一个有3个一维数组,但是每个一维数组还没有开数据空间
for(int i = 0; i < arr.length; i++) {//遍历arr每个一维数组
	//给每个一维数组开空间new
	//如果没有给―维数组new ,那么arr[i]就是null
	arr[i] = new int[i + 1];
	//遍历一维数组,并给一维数组的每个元素赋值
	for(int j = 0; j < arr[i].length; j++) {
		arr[i][j] = i + 1;
	}
}
system.out.println( "=====arr元素=====");//遍历arr输出
for(int i = 0; i < arr.length; i++) {
	//输出arr的每个一维数组
	for(int j =0; j < arr[i].length; j++) {
		system.out.print(arr[i][j]+" ");
	}
	system.out.println();//换行
}

使用方式4:静态初始化

1.定义类型数组名[={值1,值2…].{值1,值2…}.{值1,值2…]}
2.使用即可[固定方式访问]

比如:
int[ ][ ] arr = {{1,1,1], {8,8,9}, {100}};
解读
1.定义了一个二维数组arr
2.arr有三个元素(每个元素都是一维数组)
3.第一个一维数组有3个元素,第二个一维数组有3个元素,第三个一维数组有1个元素

案例

int arr[ ][ ] = {{4,6},{1,4,5,7},{-2}};遍历该二维数组,并得到和

//思路
//1.逼历二维数组,并将各个值累计到int sum
int arr[][]= {{4,6},{1,4,5,7},{-2}};
int sum = 0;
for(int i = 0; i <arr.length; i++) {
	//遍历每个一维数组
	for(int j = 0; j < arr[i].length; j++) {
		sum +=arr[i][j];
	}
}
System.out.println( "sum=" + sum);

二维数组的应用案例

1.使用二维数组打印一个10行杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
【提示】
1.第一行有1个元素,第n行有n个元素2.每一行的第一个元素和最后一个元素都是1
3.从第三行开始,对于非第一个元素和最后一个元素的元素的值.
arr[i][j] = arr[i-1][j]+ arr[i-1][j-1];//必须找到这个规律

int[][] yangHui = new int[10][];
for(int i = 0; i < yangHui.length; i++) {//遍历yangHui的每个元秦
	//给每个一维数组(行)开空间
	yangHui[i] = new int[i+1];//给每个一维数组(行)赋值
	for(int j =0; j < yangHui[i].length; j++){
		//每一行的第一个元素和最后一个元素都是1
		if(j== 0 || j == yangHui[i].length - 1){
			yangHui[i][j]= 1;
		}else {//中间的元素
			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][i] +"\t");
	}
	system.out.println();//换行·
}

二维数组使用细节和注意事项

1.一维数组的声明方式有:
int[] x或者int x[]
2.二维数组的声明方式有:
int[ ][ ] y或者int[ ] y[ ]或者int y[ ][ ]
3.二维数组实际上是由多个一维数组组成的,它的各个一维数组的长度可以相同,也可以不相同。比如: map0[ ][ ]是一个二维数组
int map = {{1,2},{3,4,5}};
由map[0]是一个含有两个元素的一维数组,map[1]是一个含有三个元素的一维数组构成,我们也称为列数不等的二维数组。

二维数组课堂练习

//声明:int[] x,y[];以下选项允许通过编译的是():
//说明:x是int类型一维数组, y是int类型的二维数组
a) x[0]=y//f错误int[][]->int
b) y[0] = x;//t正确int[] -> int[]
c) y[0][0] = x;//错误int[]->int
d) x[0][0] = y;//f错误x[0][0]是错误
e) y[0][0] = x[0];//正确int->int
f) x = y//f正确int->int

本章作业

1.下面数组定义正确的有

A.String strs[] = {'a','b','C'};//f,char ->String
B.String[] strs = {"a", "b","c"};//t
C.String[] strs = new String{"a" "b" "c"};//f
D.String strs[] = new String[]{"a", "b","c"};//t
E.String[] strs = new String[3]{"a", "b", "c"};//f

2.写出结果

String foo="blue";
boolean[] bar=new boolean[2];//bar[0]默认false bar[1] false
if(bar[0]) {
	foo="green";
}
System.out.println(foo);//blue

3.以下Java代码的输出结果为(1,3,5,7)。

int num=1;
while(num< 10) {
	System.out.println(num);
	if(num>5) {
		break;
	}
	num +=2;
}
//1,3,5,7

4.已知有个升序的数组,要求插入一个元素,该数组顺序依然是升序,比如:[10,12,45,90],添加23后,数组为[10,12,23,45,90]

//思路 本质数组扩容+定位
//1.我们先确定添加数应该插入到哪个索引
//2.然后扩容
//先定义原数组
int[] arr = {10,12,45,90};
int insertNum = 23;
int index = -1; //index就是要插入的位置

//遍历arr数组,如果发现insertNum<=arr[i],说明i就是要插入的位置
//使用index保留index = i;
//如果遍历完后,没有发现 insertNum <=arr[i],说明index = arr.length
//即:添加到arr的最后

for(int i = o; i < arr. length; i++) {
	if(insertNum <= arr[i]){
		index = i;
		break;//找到位置后,就退出
	}
}
//判断index的值
if(index == -1) {//说明没有还没有找到位置
	index = arr.length;
}
//扩容
//先创建一个新的数组,大小arr.length + 1
int[] arrNew = new int[arr.length + 1];
//下面老师准备将arr的元素拷贝到arrNew ,并且要跳过index位置
for(int i = 0,j = 0; i < arrNew.length; i++) {
	if( i != index ) {//说明可以把arr的元素拷贝到arrNew
		arrNew[i] = arr[j];
		j++;
	}else {//i这个位置就是要插入的数
		arrNew[i] = insertNum;
	}
}
5.随机生成10个整数(1_100的范围)保存到数组,并倒序打印以及求平均值、求最大值和最大值的下标、并查找里面是否有8

```java
int[] arr = new int[10];
//(int)(Math.random() * 100) +1 生产随机数1-100
for(int i = 0; i < arr.length; i++) {
	arr[i] = (int) (Math.random() * 100)+ 1;
}
System.out.println( "====arr的元素情况=====");
for(int i = 0; i < arr. length; i++){
	system.out.print(arr[i] + "\t")
}
system.out.println( " \n====arr的元素情况(倒序)=====");
for(int i = arr.length -1; i >= 0; i--) {
	System.out.print(arr[i] + "\t");
}
double sum = arr[0];
int max = arr[0];
int maxIndex = 0;
for(int i = 1; i < arr. length; i++ ) {
	sum += arr[i];//累积和
	if( max < arr[i]){//说明max不是最大值,就变化
		max = arr[i];
		maxIndex = i;
	}
}
System.out.println( "\nmax=" + max + " maxIndex=" + maxIndex);
System.out.println("\n平均值="+(sum / arr.length));


//查找数组中是否有8->使用顺序查找
int findNum = 8;
int index = -1;//如果找到,就把下标记录到index
for(int i =0; i < arr. length; i++) {
	if(findNum == arr[i]){
		System.out.println("找到数"+ findNum + "下标=" +i);
		index = i;
		break;
	}
}
if(index == -1) {
	System.out.println("没有找到数" + findNum );
}

6.试写出以下代码的打印结果

char[] arr1 = {'a', 'z', 'b', 'c'};
char[] arr2 = arr1;
arr1[2]='韩';
for(int i=0; i < arr2.length; i++) {
	System.out.println(arr1[0] + "," + arr2[i]);
}
//a,a
//z,z
//韩,韩
//c,c

7.写出冒泡排序的代码

int[] arr = {20, -1, 89, 2, 890, 7};
int temp = 0;//辅助交换
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]) {//前面的数大,就交换
			temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
		}
	}
}
//搞定
system.out.println( " \n====排序后====" );
for(int i =0; i < arr.length; i++){
	system.out.print(arr[i] + "\t");
}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值