数组
为什么需要数组
一个养鸡场有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,9，10,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 = {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;
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 = {24，69，80,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 = {{0，0，0，0，0，0},{0，0，1，0，0，0},
{0,2，0，3，0，0},{0，0，0，0，0，0}};
//输出二维图形
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");
}
788
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
