Java基础5~6章

于 2021-11-27 21:12:55 发布
阅读量1k 收藏 4
点赞数
文章标签： css html 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_62297608/article/details/121583418
版权

第五章：数组

为什么需要数组：

题目：计算全班（30人）的平均分

int stu1 = 95;
int stu2 = 89;
int stu3 = 79;
int stu4 = 64;
int stu5 = 76;
int stu6 = 88;
……
avg = (stu1+stu2+stu3+stu4+stu5…+stu30)/30;

弊端：
	1:声明30个变量太繁琐
	2:且不利于数据处理(计算)

什么是数组

数组是一个变量，用来存储一组相同数据类型的数据
声明一个变量就是在内存空间划出一块合适的空间
声明一个数组就是在内存空间划出一串连续的空间

数组基本要素：

标识符：数组的名称，用于区分不同的数组
数组元素：向数组中存放的数据
元素下标：对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问
元素类型：数组元素的数据类型
注意:数组长度固定不变，避免数组越界

如何使用数组：

//例如:定义一个存储分数的数组
//使用数组四步走:
        //第一步：声明数组
        int[] score;

        //第二步：分配空间
        score=new int[5];

        //第三步：赋值
        score[0]=80;
		
        //第四步：处理数组
        score[0]=score[0]*10;

声明数组：

声明数组: 告诉计算机数据类型是什么
示例:int[ ] JavaScore; //Java成绩
语法: 数据类型 数组名[ ] ;
数据类型[ ] 数组名 ;
注意:声明数组时不能规定数组长度

分配空间:

分配空间: 告诉计算机分配几个连续的空间
	JavaScore = new int[30]; 

语法:声明数组并分配空间
	数据类型[ ]  数组名   =   new   数据类型[大小]  ;             	
示例：
	int[] JavaScore = new int[30];

数组赋值：

赋值：向分配的空间里放入数据
	JavaScore[0] = 89;
	JavaScore[1] = 79;
	JavaScore[2] = 76;
	……
	太麻烦！能不能一起赋值？
	
方法1: 边声明边赋值
	int[ ] JavaScore = {89, 79, 76};
	int[ ] JavaScore = new int[ ]{89, 79, 76};
注意：不能指定数组长度          

方法2：动态地从键盘录入信息并赋值	
	int[] JavaScore=new int[5];
	Scanner input = new Scanner(System.in);
	for(int i = 0; i < JavaScore.length; i ++){
    	 score[i] = input.nextInt();
	}

处理数据:

对数据进行处理：计算5位学生的javaScore平均分
方式一：
	int [ ] JavaScore = {60, 80, 90, 70, 85};
	double avg;
	avg = (JavaScore[0] + JavaScore[1] + JavaScore[2] + JavaScore[3] + JavaScore[4])/5;  
  

方式二:
	int [ ] JavaScore = {60, 80, 90, 70, 85};
	int sum = 0;
	double avg;
	for(int i = 0; i < JavaScore.length; i++){
  	   sum = sum + JavaScore[i];
    }
	avg = sum / JavaScore.length; 

注释：
1:访问数组成员：使用“标识符[下标]”
2:数组的length属性
3:JavaScore[i]:访问成员

提问使用数组求10个学生的平均分:

Scanner scanner = new Scanner(System.in);
        //定义存储java成绩数组
        int[] JavaScore=new int[10];
        //定义java成绩数组的总和	
        int sum=0;
        for (int i = 0; i < JavaScore.length; i++) {
            System.out.println("请输入第"+(i+1)+"个学生Java成绩:");
            JavaScore[i]=scanner.nextInt();
            sum =sum+JavaScore[i];
            //简写：sum+= JavaScore[i];
        }
        System.out.println("30个学生的java平均分是："+(sum/JavaScore.length));

数组升序排序:

题目：循环录入5位学员成绩，进行升序排列后输出结果
提示：
	使用java.util.Arrays类
	注意导包：java.util下的
	Arrays类的sort()方法：对数组进行升序排列
public class ScoreSort {
	public static void main(String[] args) {
		int[] scores = new int[5];	//成绩数组
		Scanner input = new Scanner(System.in);
		System.out.println("请输入5位学员的成绩：");
		//循环录入学生成绩并存储在数组中
		for(int i = 0; i < scores.length; i++){
			scores[i] = input.nextInt();
		}
		//数组中的元素被重新排列
		Arrays.sort(scores);	
		System.out.print("学员成绩按升序排列：");
		//循环输出数组中的信息
		for(int i = 0; i < scores.length; i++){
			System.out.print(scores[i] + " ");
		}
	}
}

使用Arrays类的各种方法:

public class Arrays_Study {
    public static void main(String[] args) {
        //返回值：boolean 方法名称:equals(array1,array2)
        //作用：比较数组array1和array2是否相等
        System.out.println("---------equals(array1,array2)方法:----------");
        int[] arr1={10,50,90,80,60};
        int[] arr2={10,50,90,80,60};
        int[] arr3={20,40,90};
        //判断arr1与arr2的长度及元素是否相等
        System.out.println(Arrays.equals(arr1,arr2));
        //判断arr1与arr3的长度及元素是否相等
        System.out.println(Arrays.equals(arr1,arr3));

        //方法名称： sort(array)
        //作用：对数组array的元素进行升序排列
        System.out.println("\n---------sort(array)方法:----------");
        int[] JavaScores ={90,50,100,60,30,70};
        //对数组进行升序排列
        Arrays.sort(JavaScores);
        System.out.println("Java成绩升序排列后：");
        for (int i = 0; i <JavaScores.length ; i++) {
            System.out.print(JavaScores[i]+"\t");
        }

        System.out.println();
        //返回值：String 方法名称：toString(array)
        //作用:将数组array转换成一个字符串
        System.out.println("\n---------toString(array)方法:----------");
        int[] SqlScores = {70,80,50,40,60,20};
        //对数组进行升序排列
        Arrays.sort(SqlScores);
        //将SqlScores数组转换为字符串并输出
        System.out.println(Arrays.toString(SqlScores));

        //方法名称：fill(array,val)
        //作用：把数组array所有元素都赋值为value
        System.out.println("\n---------fill(array,val)方法:----------");
        int[] HtmlScores = {70,50,90,40,30,100};
        Arrays.fill(HtmlScores,60);
        //将HtmlScores数组转换为字符串并输出
        System.out.println(Arrays.toString(HtmlScores));

        //方法名称：copyOf(array,length)
        //作用：把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
        System.out.println("\n---------copyOf(array,length)方法:----------");
        int[] arr11={10,90,80,70,60};
        int[] arr22=Arrays.copyOf(arr11,6);
        System.out.println(Arrays.toString(arr22));
        int[] arr33=Arrays.copyOf(arr11,3);
        System.out.println(Arrays.toString(arr33));
        //将arr11复制成长度为5的新数组arr44
        int[] arr44=Arrays.copyOf(arr11,5);
        System.out.println(Arrays.toString(arr44));

        //返回值：int 方法名称：binarySearch(array, val)
        //作用：查询值val在数组array中的下标
        //（要求数组中元素已经按升序排列，如果没有找到，则返回一个负整数）
        System.out.println("\n---------binarySearch(array, val)方法:----------");
        int[] MathScores ={60,70,40,20,80,100};
        Arrays.sort(MathScores);
        int index = Arrays.binarySearch(MathScores,99);
        System.out.println(index);
        int indexTwo = Arrays.binarySearch(MathScores,20);
        System.out.println(indexTwo);
    }
}

求数组最大值：

题目:从键盘输入五位学生的成绩，求考试成绩最高分	
示例：    
	public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //定义存储5个学生的成绩数组
		int[] scores = new int[5];
        //记录最大值
		int max = 0;	
		System.out.println("请输入5位学员的成绩：")
		for(int i = 0; i < scores.length; i++){
			scores[i] = input.nextInt();
		}
		//假设第一个元素为最大的成绩
		max = scores[0];
        //从第一个成绩开始比较
		for(int i = 1; i < scores.length; i++){
            //循环判断
			if(scores[i] > max){
				max = scores[i];
			}
		}
		System.out.println("考试成绩最高分为：" + max);
	}

数组插入数据：

public static void main(String[] args){
		int[] list = new int[6];
		list[0] = 99;
		list[1] = 85;
		list[2] = 82;
		list[3] = 63;
		list[4] = 60;
		//将最后一个元素空出
		//保存新增成绩将插入的位置
		int index = list.length;
		System.out.println(index);
		System.out.println("请输入新增成绩： ");
		Scanner input = new Scanner(System.in);
		int num = input.nextInt();
		//找到新元素的要插入的位置
		for(int i = 0; i < list.length; i++){
			if(num > list[i]){
				index = i;
				break;
			}
		}
		//元素后移
		for(int j = list.length-1; j > index; j--){
			list[j] = list[j-1];
		}
		list[index] = num;
		System.out.println("插入成绩的下标是："+index);
		System.out.println("插入后的成绩信息是： ");
		for (int k = 0; k < list.length; k++) {
			System.out.print(list[k] + "\t");
		}

}

数组降序排序:

实现思路：
  1:先使用arrays类的sort方法进行升序排列
  2:再使用for循环降序排列
  int[] numbers = {9,41,52,1,8,90,60};
  Arrays.sort(numbers);
  			
  //从最后一个下标的输入开始  小于第一个下标   递减
  for (int i = numbers.length-1; i >=0 ; i--) {
            System.out.println(numbers[i]);
  }

二维数组：

语法：
<数据类型> [ ][ ] 数组名; 或者 <数据类型> 数组名 [ ][ ];
示例：
int [ ][ ] scores; //定义二维数组
scores=new int[5][50]; //分配内存空间
或者
int [ ][ ] scores = new int[5][50];
注意：定义二维数组时，要定义最大维数
二维数组本质上仍是一个一维数组，只是它的每个元素又是一个一维数组

二维数组定义:

定义并赋值
写法一
	int[][] scores=new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};

写法二
	int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

写法三
    int[][] scores ={{4},{5,78,18,13,78},{45,788}};

第六章：循环进阶

什么是二重循环：

一个循环体内又包含另一个完整的循环结构
外层循环变量变化一次，内层循环变量要变化一遍

利用二重循环实现九九乘法表:

for (int i = 1; i <=9; i++) {
            for (int j = 1; j<=i; j++) {
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println("");
}

什么是冒泡排序?

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它通过将相邻元素进行比较和交换，逐步将一个无序序列排列为一个有序序列。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

冒泡排序算法实现原理？

冒泡排序算法的运作如下：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
核心思想：两层比较

冒泡排序速记口诀（升序）

N 个数字来排队
两两相比小靠前
外层循环 N-1
内层循环 N-1-I
每次比较相邻两数
小的交换到前面
每轮结束后最大的数交换到最后

冒泡排序代码示例：

public static void main(String[] args) {
        int[] scores = {16, 25, 9, 90, 23};
        for (int i = 0; i < scores.length - 1; i++) {
            for (int j = 0; j < scores.length - 1 - i; j++) {
                if (scores[j] > scores[j + 1]) {
                    // 交换元素
                    int temp = scores[j];
                    scores[j] = scores[j + 1];
                    scores[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡排序后：");
        for (int i = 0; i < scores.length; i++) {
            System.out.println(scores[i]);
        }
   
    	/*for (int score : scores) {
            System.out.println(score);
        }*/
    
}

嵌套/双层循环中的continue和break详解

大部分直到在一层循环中continue和break的作用，其作用为：
continue：跳过这次循环，直接开始下一次循环
break：直接结束循环
但在嵌套循环中，却不清楚这两的作用范围：
1:continue在嵌套循环中：
内层的continue直接跳过了其之下的内层代码，直接开始了下一次的内层循环
2:break在嵌套循环中：
break使得内层循环直接提取结束，直接就开始了下一次的外循环
嵌套循环中的break和continue都只对一层循环起作用，用在内层循环时，只对内层循环其作用，对外层循环无影响。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值