尚硅谷java配套笔记尚硅谷java基础视频

转载

mob64ca14082604 2024-06-17 03:39:29

文章标签 尚硅谷java配套笔记 java 开发语言 System 数组 文章分类 Java 后端开发

尚硅谷Java入门视频教程第三章

第二章复习

课后习题
复习

嵌套循环典型例题

Ecplise的安装使用
第3章：数组

3.1 数组的概述
3.2 一维数组的使用
3.3 多维数组的使用
3.4 数组中涉及到的常见算法

3.4.1 数组元素赋值
3.4.2 求数值型数组中元素的最大值、最小值、平均数、总和等
3.4.3 数组的复制、反转、查找(线性查找、二分法查找)

数组复制
数组反转
查找

3.4.4 数组元素的排序算法

冒泡排序
快速排序

3.4.5 排序算法性能对比

3.5 Arrays工具类的使用
3.6 数组使用中的常见异常

第二章复习

课后习题

如果一个数如果恰好等于它的因子之和，这个数就称为"完数"。（因子：除去这个数本身的约数），例如6=1＋2＋3。
编程：找出1000以内的所有完数。

class WanShu{
	public static void main(String[] args){
		System.out.println("1-1000之间的完数有：");
		int sum;
		for(int i = 1;i <= 1000;i++){
			sum = 0;
			//for(int j = 1;j < i;j++){
			//优化
			for(int j = 1;j <= i/2;j++){//大于i/2的数，另一个相乘的因子一定在1-2之间，因此不可能出现
				if(i % j == 0){
					sum += j;
				}
			}
			if(sum == i){
				System.out.println(i);
			}
		}
	}
}

复习

嵌套循环典型例题

打印如下的图形：菱形1

* 
   * * 
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    *

class ForForTest{
	public static void main(String[] args){
		for(int i = 1; i <= 5; i++){
			for(int j = 1; j <= 5-i; j++){
				System.out.print(" ");
			}
			for(int k = 1; k <= i; k++){
				System.out.print("* ");
			}
			System.out.println();
		}
		for(int i = 1; i <= 4; i++){
			for(int j = 1; j <= i; j++){
				System.out.print(" ");
			}
			for(int k = 1; k <= 5 - i; k++){
				System.out.print("* ");
			}
			System.out.println();
		}
	}
}

九九乘法表

/*
九九乘法表
1 * 1 = 1
2 * 1 = 2  2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81
*/
class NineNineTable {
	public static void main(String[] args) {
		for(int i = 1;i <= 9;i++){
			for(int j = 1;j <= i;j++){
				System.out.print(i + " * " + j + " = " + i*j + "	");
			}
			System.out.println();
		}

	}
}

输出100以内所有的质数

/*
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

最小的质数是：2
*/
class PrimeNumberTest2 {
	public static void main(String[] args) {
		
		int count = 0;//记录质数的个数
		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				if(i % j == 0){ //i被j除尽
					continue label;
				}		
			}
			//能执行到此步骤的，都是质数
			count++;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));
	}
}

补充：衡量一个代码的优劣

正确性
可读性
健壮性
高效率与低存储：时间复杂度、空间复杂度（衡量算法的好坏）

Ecplise的安装使用

安装
Ecplise可以在官网进行下载安装：官网安装时可选exe安装程序或直接下载压缩包，在使用exe安装程序安装时速度非常慢且经常失败，建议直接下载压缩包。
eclipse-jee-2022-03-R-win32-x86_64的压缩包如下：
链接：https://pan.baidu.com/s/1-VT-nYELPmUywp4uLAMlJA
提取码：p1re
使用注意：
一定要将文件编码格式修改为utf-8！
其余设置如宋老师课程所述即可。
Eclipse下代码字体背景变红/变绿/变黄原因

第3章：数组

3.1 数组的概述

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
数组相关的概念：
数组名
元素
角标、下标、索引
数组的长度：元素的个数
数组的特点：

数组是有序排列的
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能修改。

数组的分类：
① 按照维度：一维数组、二维数组、三维数组、…
② 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

3.2 一维数组的使用

① 一维数组的声明和初始化
② 如何调用数组的指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组

public class ArrayTest {
	public static void main(String[] args) {
		
		//① 一维数组的声明和初始化
		//1.1 静态初始化：数组的初始化和数组元素的赋值操作同时进行
		int[] ids;	
		ids = new int[] {1001,1002,1003,1004};
		//1.2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];
		
		//错误的写法：
//		int[] arr1 = new int[];
//		int[5] arr2 = new int[5];
//		int[] arr3 = new int[3]{1,2,3};
        //也是正确的写法：
		int[] arr4 = {1,2,3,4,5};//类型推断
		
		//总结：数组长度一旦初始化完成，其长度就确定了
		
		//2.如何调用数组的指定位置的元素:通过角标的方式调用。
		//数组的角标（或索引）从0开始的，到数组的长度-1结束。
		names[0] = "王明";
		names[1] = "王贺";
		names[2] = "张学良";
		names[3] = "张巨龙";
		names[4] = "王宏志";
		//names[5] = "周杨";//运行错误：java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
		
		//3.如何获取数组的长度
		//属性：length
		System.out.println( names.length);
		System.out.println(ids.length);
		
		//4. 如何遍历数组
		/*System.out.println(names[0]);
		System.out.println(names[1]);
		System.out.println(names[2]);
		System.out.println(names[3]);
		System.out.println(names[4]);*/
		
		for(int i = 0;i < names.length;i++) {
			System.out.println(names[i]);
		}
	
	}

}

⑤ 数组元素的默认初始化值
数组元素是整型：0
数组元素是浮点型：0.0
数组元素是char型：0或’\u0000’（ASCII码为0的值），而非’0’
数组元素是boolean型：false
数组元素是引用数据类型：null，而非“null”

public class ArrayTest1 {
	public static void main(String[] args) {
		//5.数组元素的默认初始化值
		int[] arr = new int[4];
		for(int i = 0;i < arr.length;i++) {
			System.out.println(arr[i]);
		}
		System.out.println("*************************");
		
		short[] arr1 = new short[4];
		for(int i = 0;i < arr1.length;i++) {
			System.out.println(arr1[i]);
		}
		System.out.println("*************************");
		
		float[] arr2 = new float[4];
		for(int i = 0;i < arr2.length;i++) {
			System.out.println(arr2[i]);
		}
		System.out.println("*************************");
		
		char[] arr3 = new char[4];
		for(int i = 0;i < arr3.length;i++) {
			System.out.println("----" + arr3[i] + "****");
		}
		if(arr3[0] == 0) {
			System.out.println("你好！");
		}
		System.out.println("*************************");
		
		boolean[] arr4 = new boolean[4];
		for(int i = 0;i < arr4.length;i++) {
			System.out.println(arr4[i]);
		}
		System.out.println("*************************");
		
		String[] arr5 = new String[5];
		for(int i = 0;i < arr5.length;i++) {
			System.out.println(arr5[i]);
		}
		if(arr5[0] == null) {
			System.out.println("Hello！");
		}
	}
}

⑥ 数组的内存解析

内存结构：

尚硅谷java配套笔记尚硅谷java基础视频_java

一维数组的内存解析：

尚硅谷java配套笔记尚硅谷java基础视频_System_02

实际上，“刘德华”等字符串不在堆中存放，而是在方法区的常量池中，对中存放的只是该字符串的地址（此处的地址值为JVM计算出来的哈希值，并不是真实的内存结构中的地址）。

引用类型变量中存储的为null或地址值。

尚硅谷java配套笔记尚硅谷java基础视频_System_03

例题

import java.util.Scanner;

public class ArrayDemo1 {
	public static void main(String[] args) {
		//1. 使用Scanner，读取学生个数
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入学生人数：");
		int number = scanner.nextInt();
		
		//2.创建数组，存储学生成绩：动态初始化
		int[] scores = new int[number];
		//3.给数组中的元素赋值
		System.out.println("请输入" + number + "个学生的成绩：");
		int maxScore = 0;
		for(int i = 0;i < scores.length;i++) {
			scores[i] = scanner.nextInt();
			//4.获取数组中的元素的最大值:最高分
			if(scores[i] > maxScore) {
				maxScore = scores[i];
			}
		}
		System.out.println("最高分是：" + maxScore);
		//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
		char level;
		for(int i = 0;i < scores.length;i++) {
			if(scores[i] >= maxScore - 10) {
				level = 'A';
			}else if(scores[i] >= maxScore - 20) {
				level = 'B';
			}else if(scores[i] >= maxScore - 30) {
				level = 'C';
			}else {
				level = 'D';
			}
			System.out.println("stuent " + i + " score is " + scores[i] + ", grade is " + level + ".");
		}
	}
}

3.3 多维数组的使用

对于二维数组的理解，可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。
二维数组的使用：
规定：二维数组分为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等

二维数组的声明和初始化
如何调用数组的指定位置的元素
如何获取数组的长度
如何遍历数组

public class ArrayTest2 {
	public static void main(String[] args) {
		//1.二维数组的声明和初始化
		int[] arr = new int[]{1,2,3};//一维数组
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
		//错误的情况 
//		String[][] arr4 = new String[][4];
//		String[4][3] arr5 = new String[][];
//		int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
		
		//也是正确的写法：
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};
		
		//2.如何调用数组的指定位置的元素
		System.out.println(arr1[0][1]);//2
		System.out.println(arr2[1][1]);//null
		
		arr3[1] = new String[4];
		System.out.println(arr3[1][0]);
		
		//3.获取数组的长度
		System.out.println(arr4.length);//3
		System.out.println(arr4[0].length);//3
		System.out.println(arr4[1].length);//4
		
		//4.如何遍历二维数组
		for(int i = 0;i < arr4.length;i++){
			
			for(int j = 0;j < arr4[i].length;j++){
				System.out.print(arr4[i][j] + "  ");
			}
			System.out.println();
		}
		
	}
}

数组元素的默认初始化值
① 针对于初始化方式一：比如：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同
② 针对于初始化方式二：比如：int[][] arr = new int[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。

public class ArrayTest3 {
	public static void main(String[] args) {
		
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);//[I@3d012ddd//[表示一维数组，I表示Int型，@后为地址值
		System.out.println(arr[0][0]);//0
		
		System.out.println(arr);//[[I@626b2d4a
		
		System.out.println("*****************");
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);//地址值[F@5e91993f
		System.out.println(arr1[0][0]);//0.0
		
		System.out.println("*****************");
		
		String[][] arr2 = new String[4][2];
		System.out.println(arr2[1]);//地址值[Ljava.lang.String;@1175e2db
		System.out.println(arr2[1][1]);//null
		
		System.out.println("*****************");
		double[][] arr3 = new double[4][];
		System.out.println(arr3[1]);//null
//		System.out.println(arr3[1][0]);//报错
		
	}
}

数组的内存解析

尚硅谷java配套笔记尚硅谷java基础视频_java_04

数据结构与算法：

数据结构

数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
数据的存储结构：
线性表：顺序表（比如：数组）、链表、栈、队列
树形结构：二叉树
图形结构：

算法

排序算法
搜索算法

练习题

获取arr数组中所有元素的和。

public class ArrayExer1 {
	public static void main(String[] args) {
		//数组初始化
		int[][] arr = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
		
		//记录总和
		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);
	}
}

声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是：
注意：

x：int类型的一维数组
y：int类型的二维数组
一维数组：int[] x 或者int x[]
二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
变量赋值时，允许赋值同种类型的或可以进行类型提升的

x[0] = y; no，一维数组的元素不可以是二维的
y[0] = x; yes，二维数组的元素是一维的
y[0][0] = x; no，二维数组的元素的元素应当为int类型的数
x[0][0] = y; no，一维数组没有内层元素
y[0][0] = x[0]; yes，正确
x = y; no，类型不匹配

使用二维数组打印一个 10 行杨辉三角

public class YangHuiTest {
	public static void main(String[] args) {
		//1. 声明并初始化数组
		int[][] yangHui = new int[10][];
		
		//2. 数组元素赋值
		for(int i = 0;i < yangHui.length;i++) {
			//初始化各个元素的长度
			yangHui[i] = new int[i + 1];
			//2.1 首末元素赋值
			yangHui[i][0]=yangHui[i][i]=1;
			//2.2 非首末元素赋值
			//if(i > 1){//可以省略，i=0|1时，不满足j < yangHui[i].length-1
			for(int j = 1;j < yangHui[i].length-1;j++) {
				yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
			}
			//}
		}
		
		//数组元素遍历输出
		for(int m = 0;m < yangHui.length;m++) {
			for(int n = 0;n < yangHui[m].length;n++) {
				System.out.print(yangHui[m][n] + "\t");
			}
			System.out.println();
		}
	}
}

3.4 数组中涉及到的常见算法

常见算法：

数组元素的赋值(杨辉三角、回形数等)
求数值型数组中元素的最大值、最小值、平均数、总和等
数组的复制、反转、查找(线性查找、二分法查找)
数组元素的排序算法

3.4.1 数组元素赋值

使用二维数组打印一个 10 行杨辉三角

public class YangHuiTest {
	public static void main(String[] args) {
		//1. 声明并初始化数组
		int[][] yangHui = new int[10][10];
		
		//2. 数组元素赋值
		for(int i = 0;i < yangHui.length;i++) {
			//初始化各个元素的长度
			yangHui[i] = new int[i + 1];
			//2.1 首末元素赋值
			yangHui[i][0]=yangHui[i][i]=1;
			//2.2 非首末元素赋值
			//if(i > 1){//可以省略，i=0|1时，不满足j < yangHui[i].length-1
			for(int j = 1;j < yangHui[i].length-1;j++) {
				yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
			}
			//}
		}
		
		//数组元素遍历输出
		for(int m = 0;m < yangHui.length;m++) {
			for(int n = 0;n < yangHui[m].length;n++) {
				System.out.print(yangHui[m][n] + "\t");
			}
			System.out.println();
		}
	}
}

创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同

public class RandomArray {
	public static void main(String[] args) {
		//声明与初始化数组
		int[] arr = new int[6];
		//数组赋值
		for(int i = 0;i < arr.length;i++) {
			//随机数生成
			arr[i] = (int)(Math.random()*30) + 1;
			//判断是否和前边的元素相同
			for(int j = 0;j < i;j++) {
				if(arr[i] == arr[j]) {
					i--;//若相同则i--并跳出此次循环（内层循环j），然后回到外层循环i++，等于i不变，外层循环再次执行随机赋值
					break;
				}
			}
		}
		
		//遍历数组并输出
		for(int i = 0;i < arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
}

回形数格式方阵的实现
从键盘输入一个整数（1~20）则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。

public class RectangleTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入一个1-20的整数：");
		int num = scan.nextInt();
		
		//声明并初始化数组
		int[][] arr = new int[num][num];
		
		//初始化变量
		int count = 1; // 要显示的数据
		int maxX = num - 1; // x轴的最大下标
		int maxY = num - 1; // Y轴的最大下标
		int minX = 0; // x轴的最小下标
		int minY = 0; // Y轴的最小下标
		
		//数组元素赋值
		while(minX <= maxX) {
			for(int x = minX;x <= maxX;x++) {
				arr[minY][x]= count++; 
			}
			minY++;
			for(int y = minY;y <= maxY;y++) {
				arr[y][maxX] = count++; 
			}
			maxX--;
			for(int x = maxX;x >= minX;x--) {
				arr[maxY][x] = count++;
			}
			maxY--;
			for(int y = maxY;y >= minY;y--) {
				arr[y][minX] = count++;
			}
			minX++;
		}
		
		//数组输出
		for (int m = 0; m < arr.length; m++) {
			for (int n = 0; n < arr[m].length; n++) {
				//格式化输出
				String space = (arr[m][n] + "").length() == 1 ? "0" : "";
				System.out.print(space + arr[m][n] + "\t");
			}
			System.out.println();
		}
	}
}

3.4.2 求数值型数组中元素的最大值、最小值、平均数、总和等

定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数(10-99)。

public class ArrayTest1 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		int max = 0;
		int min = 99;
		int sum = 0;
		int average = 0;
		for(int i = 0;i < arr.length;i++) {
			arr[i] = (int)(Math.random()*(99 - 10 + 1) + 10);
			System.out.print(arr[i] + "\t");
			if(max < arr[i]) {
				max = arr[i];
			}
			if(min > arr[i]) {
				min = arr[i];
			}
			sum += arr[i];
		}
		average = sum / arr.length;

		System.out.println();
		System.out.println("最大值为：" + max);
		System.out.println("最小值为：" + min);
		System.out.println("和值为：" + sum);
		System.out.println("平均值为：" + average);	
	}
}

3.4.3 数组的复制、反转、查找(线性查找、二分法查找)

数组复制

使用简单数组
(1) 创建一个名为ArrayTest的类，在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。
思考：array1和array2是什么关系？array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。

public class ArrayExer2 {
	public static void main(String[] args) {
		//在main()方法中声明array1和array2两个变量
		int[] array1, array2;
		
		//使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19
		array1 = new int[] {2,3,5,7,11,13,17,19};
		
		//显示array1的内容
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + "\t");
		}
		
		//赋值array2变量等于array1
		//不能称为array的复制，array2相当于array1的快捷方式
		array2 = array1;
		
		System.out.println();
		//修改array2中的偶索引元素，使其等于索引值,并打印array2
		for(int i = 0;i < array2.length;i++) {
			if(i % 2 == 0) {
				array2[i] = i;
			}
			System.out.print(array2[i] + "\t");
		}
		
		//打印array1的内容
		System.out.println();
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + "\t");
		}
	}

}

输出结果：

尚硅谷java配套笔记尚硅谷java基础视频_开发语言_05

内存结构：

尚硅谷java配套笔记尚硅谷java基础视频_数组_06

数组的复制

public class ArrayTest2 {
	public static void main(String[] args) {
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
		//数组的复制(区别于数组变量的赋值：arr1 = arr)
		String[] arr1 = new String[arr.length]; 
		for(int i = 0;i < arr.length;i++) {
			arr1[i] = arr[i];
		}
		arr1[0] = "TEST";
		// 遍历
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr1[i] + "\t");
		}
	}
}

输出：

尚硅谷java配套笔记尚硅谷java基础视频_尚硅谷java配套笔记_07

数组反转

package com.atguigu.java;
/*
 * 算法的考查：数组的复制、反转、查找(线性查找、二分法查找)
 * 
 * 
 */
public class ArrayTest2 {
	public static void main(String[] args) {
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
		//数组的反转
		//方法1：
		for(int i = 0;i < arr.length / 2;i++) {
			String temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
		//方法二：
		for(int i = 0,j = arr.length -1;i < j;i++,j--) {
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		
		// 遍历
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
	}
}

查找

public class ArrayTest2 {
	public static void main(String[] args) {
		String[] arr = new String[] { "JJ", "DD", "MM", "BB", "GG", "AA" };
		// 查找（或搜索）
		// 线性查找：
		String dest = "BB";
		dest = "CC";

		boolean isFlag = true;

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

			if (dest.equals(arr[i])) {
				System.out.println("找到了指定的元素，位置为：" + i);
				isFlag = false;
				break;
			}

		}
		if (isFlag) {
			System.out.println("很遗憾，没有找到的啦！");

		}


		// 二分法查找：(熟悉)
		// 前提：所要查找的数组必须有序。
		int[] arr2 = new int[] { -98, -34, 2, 34, 54, 66, 79, 105, 210, 333 };

		int dest1 = -34;
		dest1 = 35;
		int head = 0;// 初始的首索引
		int end = arr2.length - 1;// 初始的末索引
		boolean isFlag1 = true;
		while (head <= end) {

			int middle = (head + end) / 2;

			if (dest1 == arr2[middle]) {
				System.out.println("找到了指定的元素，位置为：" + middle);
				isFlag1 = false;
				break;
			} else if (arr2[middle] > dest1) {
				end = middle - 1;
			} else {// arr2[middle] < dest1
				head = middle + 1;
			}
		}

		if (isFlag1) {
			System.out.println("很遗憾，没有找到的啦！");
		}
	}
}

3.4.4 数组元素的排序算法

排序：假设含有n个记录的序列为{R1，R2，…,Rn},其相应的关键字序列为{K1，K2，…,Kn}。将这些记录重新排序为{Ri1,Ri2,…,Rin},使得相应的关键字值满足条Ki1<=Ki2<=…<=Kin,这样的一种操作称为排序。
通常来说，排序的目的是快速查找。
衡量排序算法的优劣：

时间复杂度：分析关键字的比较次数和记录的移动次数
空间复杂度：分析排序算法中需要多少辅助内存
稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

排序算法分类：内部排序和外部排序。

内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成

算法的5大特征

说明：满足确定性的算法也称为：确定性算法。现在人们也关注更广泛的概念，例如考虑各种非确定性的算法，如并行算法、概率算法等。另外，人们也关注并不要求终止的计算描述，这种描述有时被称为过程（procedure）。
排序算法分类

选择排序
直接选择排序、堆排序
交换排序
冒泡排序、快速排序
插入排序
直接插入排序、折半插入排序、Shell排序
归并排序
桶式排序
基数排序

冒泡排序

介绍：
冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
排序思想：

比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

代码实现：

public class BubbleSort {
	public static void main(String[] args) {
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		
		//冒泡排序
		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]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		
		//遍历输出
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
	}
}

快速排序

排序思想：

从数列中挑出一个元素，称为"基准"（pivot），
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

3.4.5 排序算法性能对比

尚硅谷java配套笔记尚硅谷java基础视频_开发语言_08

各种内部排序方法性能比较：

从平均时间而言：快速排序最佳。但在最坏情况下时间性能不如堆排序和归并排序。
从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序。
从稳定性看：直接插入排序、冒泡排序和归并排序时稳定的；而直接选择排序、快速排序、 Shell排序和堆排序是不稳定排序
从待排序的记录数n的大小看，n较小时，宜采用简单排序；而n较大时宜采用改进排序。

3.5 Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

尚硅谷java配套笔记尚硅谷java基础视频_开发语言_09

import java.util.Arrays;
/*
 * java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
 * 
 * 
 */
public class ArraysTest {
	public static void main(String[] args) {
		
		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}
	}
}

输出：

尚硅谷java配套笔记尚硅谷java基础视频_System_10

3.6 数组使用中的常见异常

数组脚标越界异常(ArrayIndexOutOfBoundsException)：访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)：arr引用没有指向实体，却在操作实体中的元素时。

public class ArrayExceptionTest {
	public static void main(String[] args) {

		// 1. 数组角标越界的异常：ArrayIndexOutOfBoundsException
		int[] arr = new int[] { 1, 2, 3, 4, 5 };

//		for(int i = 0;i <= arr.length;i++){
//			System.out.println(arr[i]);//arr[5]不存在-> ArrayIndexOutOfBoundsException
//		}

//		System.out.println(arr[-2]);//java中不允许通过负数访问数组元素，Python可以 -> ArrayIndexOutOfBoundsException

//		System.out.println("hello");//上边出现异常，下边代码不可执行

		// 2.2. 空指针异常：NullPointerException
		// 情况一：
//		int[] arr1 = new int[]{1,2,3};
//		arr1 = null;
//		System.out.println(arr1[0]);//null没有元素 -> NullPointerException
		// 情况二：
//		int[][] arr2 = new int[4][];
//		System.out.println(arr2[0]);//输出null
//		System.out.println(arr2[0][0]);//null没有元素-> NullPointerException

		// 情况三：
		String[] arr3 = new String[] { "AA", "BB", "CC" };
		arr3[0] = null;
		System.out.println(arr3[0].toString());//null没有toString方法 -> NullPointerException
	}
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Python打印字符串的中间部分 python打印字符串变量

下一篇：android 网络往返延迟检测手机网络延迟测试在线

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯