目录
一、Java语言概述
二、基础程序设计
1. 第一个Java程序
2. 变量命名规则
3. 文档注释
4. Java中的数据类型
5. 基本数据类型之间的运算规则
6. String类型变量的使用
7. Scanner类的使用
8. 带标签的break和continue
9. 测一个程序执行的时间
三、数组
1. 数组的概述
2. 一维数组
2.1 一维数组的声明和初始化
2.2 如何获取数组的长度
2.3 数组元素的默认初始化值
2.4 一维数组的内存解析
3. 二维数组
3.1 二维数组的声明和初始化
3.2 如何获取数组的长度
3.3 数组元素的默认初始化值
3.4 二维数组的内存解析
4. 数组中涉及的常见算法
4.1 数组元素的赋值
4.2 求数值型数组的max min aver sum等
4.3 数组的复制、反转、查找
4.4 数组的排序算法
5. Arrays工具类
6. 数组中的常见异常
6.1 数组角标越界的异常
6.2 空指针异常
一、Java语言概述
JDK 是开发工具包，是Java开发和运行所用到的所有工具 Java Development Kit
JRE 是Java运行环境，Java Runtime Environment，运行一个开发好的Java程序只需要装一个JRE就可以了
JVM 是Java 虚拟机，Java Virtual Machine
简单而言，使用JDK的开发工具完成的Java程序，交给JRE去运行
二、基础程序设计
1. 第一个Java程序
使用命令行方式来编译运行第一个java程序, 下面是cmd的常用控制命令 :
用记事本编写第一个Java程序
首先建立一个 .java 文件，用记事本打开，输入java代码
cmd中输入命令到达文件所在目录，输入命令
javac 文件名.java
会编译java文件，并且生成一个或多个以类名命名的 .class 字节码文件
有几个类就有几个字节码文件
cmd中输入命令
java 类名
完成第一个 java 程序的运行 ( 只能运行含有main( ) 的字节码文件)
注意：class可以用public等关键词修饰，但是一个java源文件中只能有一个类是public的，且只能加到和文件名同名的类前面。
程序的入口是 main( ) 方法，格式是固定的
public static void main(String[] args) {//args -- arguments 参数
System.out.println ("Hello World!");//输出后换行
System.out.println();//单纯换行
System.out.print("Hello world!");//输出后不换行
}
2. 变量命名规则
包名：多单词组成时所有字母都小写, xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写，XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词的首字母小写，第二个单词开始每个单词的首字母大写，xxxYyyZzz
常量名：所有字母都大写。多个单词时每个单词用下划线连接。XXX_YYY_ZZZ
注意：java采用unicode字符集，因此标识符也可以用汉字声明，但是不建议使用。
3. 文档注释
java特有的注释方式
注释内容可以被 JDK 提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档
解析方式 :
javadoc -d myHello -author -version Hello.java
4. Java中的数据类型
变量按照数据类型来分 :
-
基本数据类型 :
-
整型 : byte short int long
-
浮点型是 : float double
-
字符型 : char
-
布尔型 : boolean
-
-
引用数据类型 :
-
类 (class)
-
接口 (interface)
-
数组 (array)
-
变量按照在类中声明的位置来分 :
5. 基本数据类型之间的运算规则
只针对七种基本数据类型，不包含boolean
（1）自动类型提升
自动类型提升规则 ：当容量小（表示数的范围大小）的数据类型变量与容量大的数据类型变量做运算时，结果自动提升为容量大的类型
byte short char ----> int ----> long ----> float ----> double
byte short char 之间相互做运算（包括同种之间相互做运算）时，结果为 int 类型，必须拿int类型往上的数据类型来接收
String 类型和以上七个加上boolean类型共八个类型都可以做运算，但是不能把String放到上面
注意：在对float 和 long做定义的时候最好加上 f F 和 l L
（2）强制类型转换
自动类型提升运算的逆运算，容量大的数据类型转换为容量小的数据类型
需要使用强转符 : ( )
注意 : 强制类型转换可能导致精度损失。
（3）常量
对于整型常量来说 : 默认为 int 类型
对于浮点常量来说 : 默认为 double 类型
代码体现 :
public class VariableTest2 {
public static void main(String[] args) {
byte b1 = 2;
int i1 = 12;
//用int类型来接收两者之和
int i2 = b1 + i1;
System.out.println("i2 = " + i2);
//拿float类型来接收也可以 自动补个点0
float f1 = b1 + i1;
System.out.println("f1 = " + f1);
/
long l1 = 1123;//如果是这种较小数的话，会按照int来存入然后自动类型提升为long
long l2 = 254435634563465346L;//比较大的数加后缀才会直接认定为long型 不加后缀会报错
System.out.println("l1 = " + l1);
System.out.println("l2 = " + l2);
float f1 = 1231;//这种整数也是先认定为int型最后自动类型提升为float
float f2 = 12.12F;//小数如果不加后缀那么就会报错 因为先认定的是double double不能往float转
System.out.println("f1 = " + f1);
System.out.println("f2 = " + f2);
System.out.println("******************************");
//char类型的三种使用方式 : ① 直接声明定义一个字符 ② 转义字符 ③ 使用Unicode来声明定义一个字符
char c2 = 'u0043';//转义Unicode C
System.out.println(c2);
}
}
6. String类型变量的使用
-
属于引用数据类型
-
声明String类型时，使用一对双引号
-
String类型的数据中可以什么也不写,char类型中单引号中必须有内容
-
String可以和8种基本数据类型做运算,且运算只能是连接运算：+ 运算的结果也是String类型
属于引用数据类型
声明String类型时，使用一对双引号
String类型的数据中可以什么也不写,char类型中单引号中必须有内容
String可以和8种基本数据类型做运算,且运算只能是连接运算：+ 运算的结果也是String类型
代码体现 :
public class StringTest {
public static void main(String[] args) {
String s1 = "HelloWorld!";
System.out.println(s1);
String s2 = "";//可以没有东西
char c1 = ' ';//不能没有东西
String numberStr = "学号";
int number = 200640103;
String info = numberStr + number;
System.out.println(info);
//练习：
System.out.println("* *");
System.out.println('*' + 't' + '*');
System.out.println('*' + "t" + '*');
System.out.println('*' + 't' + "*");
System.out.println("*" + ("t" + '*'));
}
}
7. Scanner类的使用
作用 : 从键盘上获取不同类型的变量。
具体实现步骤 :
(1) 导包：import java.util.Scanner;
(2) Scanner的实例化
(3) 调用Scanner类的方法,获取相关类型的变量
注意：需要根据相应的方法,来输入指定类型的值,如果输入的数据类型与要求的类型不匹配,会报异常InputMissMatchException导致程序终止。
代码体现 :
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.print("Please input your name : ");
//String 类型的是 next()
String name = scan.next();//调用方法
System.out.print("Please input your age : ");
short age = scan.nextShort();
System.out.print("Please input your weight : ");
double weight = scan.nextFloat();
System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("weight = " + weight);
System.out.print("Do you agree ? (true\false)");
boolean result = scan.nextBoolean();
System.out.println("result = " + result);
System.out.print("Please input your sex : (m\w)");
String gender = scan.next();
char genderChar = gender.charAt(0);//获取字符串位置为0的字符
System.out.println("genderChar = " + genderChar);
}
}
注意 :
-
String调用的方法比较特别为 : next()
-
对于char类型的获取,Scanner没有提供相关方法,只能够获取字符串
8. 带标签的break和continue
break和continue默认都是对就近的一层循环起作用，现在加上label，就对label层循环起作用了。
代码体现 :
public class LabelBreakContinueTest {
public static void main(String[] args) {
label : for (int i = 1; i <= 10; i++){
for (int j = 1; j <= 10; j++){
if (j % 4 == 0){
//break 默认退出就近的一层循环
break label;//退出label层循环
//continue 默认退出就近一次的循环
//continue label;//退出label层一次的循环
}
System.out.print(j + " ");
}
System.out.println();
}
}
}
9. 测一个程序执行的时间
获取当前时间距离1970 - 01 - 01 00:00：00 的毫秒数
代码体现 ：
public class Test {
public static boolean isPrime(int n){
if (n <= 1) return false;
int k = (int)Math.sqrt(n);
for (int i = 2; i <= k; i++){
if (n % i == 0) return false;
}
return true;
}
public static void main(String[] args) {
//获取起始时间
long begin = System.currentTimeMillis();
//输出从 100 以内的所有质数
for (int i = 0; i <= 100000; i++){
if (isPrime(i)) System.out.print(i + " ");
}
System.out.println();
//获取结束时间
long end = System.currentTimeMillis();
System.out.println("运行时间为 : " + (end - begin));
}
}
三、数组
1. 数组的概述
-
数组是引用数据类型变量，数组中的元素可以是引用数据类型也可以是基本数据类型
-
数组的特点 : 数组是有序排列的
-
数组的理解 : 数组是多个相同数据类型按照一定顺序排列的集合，并使用同一个名字命名，通过编号方式对这些数据统一管理
-
创建数组对象会在内存中开辟一整块连续的空间
-
数组的长度一旦确定就不能修改
2. 一维数组
2.1 一维数组的声明和初始化
public class Test {
public static void main(String[] args) {
//一维数组的声明和初始化
int[] ids;//声明
ids = new int[]{1001, 1002, 1003, 1004};//初始化
//静态初始化 : 数组的初始化和数组元素的赋值操作同时进行
int[] ids2 = new int[]{1001, 1002, 1003, 1004};//声明 + 初始化
//动态初始化 : 数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
for (int i = 0; i < 5; i++){
names[i] = "XiaoMing";
}
}
}
2.2 如何获取数组的长度
-
数组是引用数据类型变量，数组中的元素可以是引用数据类型也可以是基本数据类型
-
数组的特点 : 数组是有序排列的
-
数组的理解 : 数组是多个相同数据类型按照一定顺序排列的集合，并使用同一个名字命名，通过编号方式对这些数据统一管理
-
创建数组对象会在内存中开辟一整块连续的空间
-
数组的长度一旦确定就不能修改
2. 一维数组
2.1 一维数组的声明和初始化
public class Test {
public static void main(String[] args) {
//一维数组的声明和初始化
int[] ids;//声明
ids = new int[]{1001, 1002, 1003, 1004};//初始化
//静态初始化 : 数组的初始化和数组元素的赋值操作同时进行
int[] ids2 = new int[]{1001, 1002, 1003, 1004};//声明 + 初始化
//动态初始化 : 数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
for (int i = 0; i < 5; i++){
names[i] = "XiaoMing";
}
}
}
2.2 如何获取数组的长度
public class Test {
public static void main(String[] args) {
//一维数组的声明和初始化
int[] ids;//声明
ids = new int[]{1001, 1002, 1003, 1004};//初始化
//静态初始化 : 数组的初始化和数组元素的赋值操作同时进行
int[] ids2 = new int[]{1001, 1002, 1003, 1004};//声明 + 初始化
//动态初始化 : 数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
for (int i = 0; i < 5; i++){
names[i] = "XiaoMing";
}
}
}
2.2 如何获取数组的长度
用数组的属性length获取
public class Test {
public static void main(String[] args) {
int[] arr = new int[10];
System.out.println("数组的长度是 : " + arr.length);
for (int i = 0; i < arr.length; i++){
arr[i] = 1;
}
System.out.println(Arrays.toString(arr));
}
}
2.3 数组元素的默认初始化值
-
整数类型 : 0
-
浮点类型 : 0.0
-
boolean类型 : false
-
引用数据类型 : null
-
char类型 : ASCII码对应的 0 或 'u0000' 效果显示空白
整数类型 : 0
浮点类型 : 0.0
boolean类型 : false
引用数据类型 : null
char类型 : ASCII码对应的 0 或 'u0000' 效果显示空白
关于char类型默认初始化值的代码演示 :
public class Test {
public static void main(String[] args) {
char c1 = 'u0000';
if (c1 == 0) System.out.println("hello");
char[] arrc = new char[5];
if (arrc[3] == 0) System.out.println("hello");
}
}
2.4 一维数组的内存解析
JVM的内存结构 ( 简化结构 ) ：
一维数组代码的内存解析 :
说明 :
-
在main方法中声明的变量为局部变量，所以arr为局部变量存放在栈空间中，它存放的是new出的int类型数组的首地址值。数组在堆空间中开辟一块连续的空间，int类型默认初始化值为0，分别赋值为1，2，3；
-
arr1为局部变量存放在栈空间中，arr1存放的是String类型数组的首地址值，数组在堆空间中开辟一块连续的空间，由于String类型存放在常量池中，所以堆空间的数组存放的是对应的常量池的地址值。默认初始化为null；
-
通过arr1的地址对应偏移1个地址来给arr1[1]赋值；
-
通过arr1的地址对应偏移2个地址来给arr1[2]赋值；
-
重新在堆区开辟一块连续的String类型数组，将其首地址值赋值给栈中的arr1；
注意 :
-
JVM中的垃圾回收机制使用引用计数算法判断堆空间中的这块空间是否还有栈中的引用指过来，如果没有在栈中没有引用指过来，那么这块空间就会在某个不确定的时间将其回收掉。
-
“刘德华”、“张学友” 实际存放在字符串常量池中，而堆区数组中存放的只是常量池中对应字符串的地址。
3. 二维数组
3.1 二维数组的声明和初始化
由数组构成的数组就是二维数组 : 数组中存放的是数组
import java.util.Arrays;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//静态初始化
int[][] arr = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
//动态初始化1
String[][] arrstr = new String[3][2];
for (int i = 0; i < arrstr.length; i++){
for (int j = 0; j < arrstr[i].length; j++){
arrstr[i][j] = sc.next();
}
}
//动态初始化2
//数组后面那个长度可以不写 但是要在初始化二维数组的时候再定义一维数组
int[][] arr2 = new int[3][];
for (int i = 0; i < arr2.length; i++){
arr2[i] = new int[i+1];
}
for (int i = 0; i < arr2.length; i++){
for (int j = 0; j < arr2[i].length; j++){
arr2[i][j] = sc.nextInt();
}
}
System.out.println("静态初始化 : ");
for (int i = 0; i < arr.length; i++){
System.out.println(Arrays.toString(arr[i]));
}
System.out.println("动态初始化1 : ");
for (int i = 0; i < arr.length; i++){
System.out.println(Arrays.toString(arrstr[i]));
}
System.out.println("动态初始化2 : ");
for (int i = 0; i < arr2.length; i++){
System.out.println(Arrays.toString(arr2[i]));
}
}
}
3.2 如何获取数组的长度
public class Test {
public static void main(String[] args) {
int[][] arr = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
System.out.println("二维数组的长度 : " + arr.length);
for (int i = 0; i < arr.length; i++){
System.out.println("第" + (i+1) + "个一维数组的长度 : " + arr[i].length);
}
//遍历二维数组
for (int i = 0; i < arr.length; i++){
for (int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + " ");
}
}
}
}
3.3 数组元素的默认初始化值
同一维数组的情况相同，二维数组中的元素都是一维数组，为引用数据类型，所以默认初始化值为null。
初始化方式一 :
int[][] arr = new int[4][3];
外层元素初始化值 : 地址值
内层元素初始化值 : 与一维数组情况相同
初始化方式二 :
int[][] arr = new int[4][];
外层元素初始化值 : null
内层元素初始化值 : 不能调用，否则报空指针异常
public class Test {
public static void main(String[] args) {
int[][] arr = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
System.out.println("arr[0] : " + arr[0]);//输出的为地址值 arr[0] : [I@1b6d3586
System.out.println("arr : " + arr);//输出的为地址值 arr : [[I@4554617c
}
}
地址 [I@1b6d3586 的含义 :
-
[ 表示一维数组 [[ 表示二维数组
-
I 表示int类型的
-
@ 表示后面的为地址
附加 : 直接打印char[] 数组，输出是 char[] 数组，因为调用的是 println(char[] c) 方法而非 println(Object o)
public class Test {
public static void main(String[] args) {
int[] arr = new int[] {1, 2, 3};
char[] c = new char[] {'a', 'b', 'c'};
System.out.println(arr);//public void println(@Nullable Object x)
System.out.println(c);//public void println(@NotNull char[] x)
}
}
3.4 二维数组的内存解析
说明 :
-
在栈空间中存放arr1，arr1中存放的是堆空间中二维数组的首地址(实际上就是一个一维数组类型的一维数组)，默认初始化值为null。
-
初始化二维数组的第二个元素的值，存放在堆空间中此元素对应的一维数组的首地址，并将此一维数组中的默认初始化值0改为1、2、3。
-
初始化二维数组的第三个元素的值，存放在堆空间中此元素对应的一维数组的首地址，此一维数组中各个元素的默认初始化值为0。
-
将二维数组的第三个元素对应的一维数组中的第二个元素的值更改为30。
4. 数组中涉及的常见算法
4.1 数组元素的赋值
<1>声明 : int[] x, y[]; 在给 x，y变量赋值以后，以下选项允许通过编译的是 :
-
x[0] = y; no 二维不能赋值给int类型
-
y[0] = x; yes 一维可以赋值给一维
-
y[0] [0] = x; no 一维不能赋值给int类型
-
x[0] [0] = y; no 写法错误
-
y[0] [0] = x[0]; yes int类型可以赋值给int类型
-
x = y; no 二维不能赋值给一维
<说明>
-
只有两个变量数据类型相同，或者支持自动类型提升才可以互相赋值
-
一维数组声明 : int[] x 或者 int x[]
-
二维数组声明 : int[] [] y 或者 int y[] []
<2>打印杨辉三角形 :
使用二维数组打印十行杨辉三角形
public class Test {
public static void main(String[] args) {
int[][] arr = new int[10][];
//生成杨辉三角形1
for (int i = 0; i < arr.length; i++){
arr[i] = new int[i+1];
for (int j = 0; j < arr[i].length; j++){
arr[i][0] = 1;
arr[i][i] = 1;
if ((j != 0) && (j != i)){
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}
}
//生成杨辉三角形2
// for (int i = 0; i < arr.length; i++){
// arr[i] = new int[i+1];
// arr[i][0] = 1;
// arr[i][i] = 1;
// for (int j = 1; j < arr[i].length-1; j++){
// arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
// }
// }
//打印杨辉三角形
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();
}
}
}
<3> 创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同 :
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = new int[6];
for (int i = 0; i < arr.length; i++){
int temp = (int)(Math.random() * 30 + 1); // 返回一个 1 - 30 的随机数
while (isSame(arr, temp, i)){
temp = (int)(Math.random() * 30 + 1);//重新放回一个 1 - 30 的随机数
}
//赋值
arr[i] = temp;
}
//打印
System.out.println(Arrays.toString(arr));
}
public static boolean isSame(int[] arr, int num, int n){
for (int i = 0; i <= n; i++){
if (arr[i] == num) return true;
}
return false;
}
}
<4> 回形二维数组 :
class RectangleTest1 {
public static void main(String[] args) {
int n = 10;
int[][] arr = new int[n][n];
int count = 0; // 要显示的数据
int maxX = n - 1; // x轴的最大下标
int maxY = n - 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 i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
String space = (arr[i][j] + "").length() == 1 ? "0" : "";
System.out.print(space + arr[i][j] + " ");
}
System.out.println();
}
}
}
4.2 求数值型数组的max min aver sum等
定义一个int型的一维数组，随机赋值10个两位整数，求出所有元素的最大值和最小值和总和以及平均值 :
public class ArrayMaxMinAveSum {
public static void main(String[] args) {
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++){
arr[i] = (int)(Math.random() * 90 + 10); // 10 - 99
}
for (int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
int max = arr[0];
int min = arr[0];
int sum = 0;
int aver = 0;
for (int i = 0; i < arr.length; i++){
if (max < arr[i]) max = arr[i];
if (min > arr[i]) min = arr[i];
sum += arr[i];
}
aver = sum / arr.length;
System.out.println("max = " + max);
System.out.println("min = " + min);
System.out.println("sum = " + sum);
System.out.println("aver = " + aver);
}
}
拓展 :
Math.random() 函数返回一个浮点数， 伪随机数在范围从0 到小于1，也就是说，从 0（包括 0）往上，但是不包括 1（排除 1），然后您可以缩放到所需的范围。实现将初始种子选择到随机数生成算法;它不能被用户选择或重置。
获取一个闭区间 [a, b] 的随机整数 :
使用 Math.random方法 : (int)(Math.random() * (b - a + 1) + a)
4.3 数组的复制、反转、查找
<1> 数组的复制
public class Test {
public static void main(String[] args) {
int[] arr1, arr2;
arr1 = new int[]{1, 2, 3, 4};
//错误示范 :
//arr2 = arr1 //不是复制操作 只是指向了同一块堆空间
//手动复制操作如下 :
arr2 = new int[arr1.length];
for (int i = 0; i < arr2.length; i++){
arr2[i] = arr1[i];
}
//或者使用Arrays工具类来实现数组的复制操作 :
//arr2 = Arrays.copyOf(arr1, arr1.length);
//输出 :
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.toString(arr2));
}
}
<2> 数组的反转
public class Test {
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
//数组反转前
System.out.println(Arrays.toString(arr));
//数组反转操作
for (int i = 0, j = arr.length-1; i < j; i++, j--){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//数组反转后
System.out.println(Arrays.toString(arr));
}
}
<3> 查找
线性查找 :
public class Test {
public static void main(String[] args) {
String[] str = new String[]{"AA", "BB", "CC", "DD", "EE"};
//线性查找
String dest = "BB";
boolean index = false;
for (int i = 0; i < str.length; i++)
if (dest.equals(str[i])) index = true;
if (index) System.out.println("Found!");
else System.out.println("Not Found!");
}
}
二分查找 :
此算法适合有序的数组
public class Test {
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
int dest = 3;
int loc = binarySearch(arr, dest);
if (-1 != loc){
System.out.println("Found! The locatoin is " + loc);
}
else {
System.out.println("Not Found!");
}
}
public static int binarySearch(int[] arr, int dest){
int beign = 0;//初始首索引
int end = arr.length - 1;//初始末索引
while(beign <= end){
int mid = (beign + end) / 2;
if (arr[mid] == dest) return mid;
if (arr[mid] < dest) beign = mid + 1;
if (arr[mid] > dest) end = mid - 1;
}
return -1;
}
}
4.4 数组的排序算法
<1> 冒泡排序和选择排序
public class Test {
public static void main(String[] args) {
int[] arr1 = new int[]{1, 8, 2, 6, 9, 14, 0};
int[] arr2 = new int[]{1, 8, 2, 6, 9, 14, 0};
System.out.println("Before BubbleSort : " + Arrays.toString(arr1));
bubbleSort(arr1);
System.out.println("After BubbleSort : " + Arrays.toString(arr1));
System.out.println("Before SelectSort : " + Arrays.toString(arr2));
selectSort(arr2);
System.out.println("After SelectSort : " + Arrays.toString(arr2));
}
//冒泡排序
public static void bubbleSort(int[] arr){
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;
}
}
}
}
//选择排序
public static void selectSort(int[] arr){
for (int i = 0; i < arr.length; i++){
int min = i;
for (int j = i; j < arr.length; j++){
if (arr[min] > arr[j]){
min = j;
}
}
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
}
<2> 快速排序
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//递归调用
subSort(data, high + 1, end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前：n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后：n" + java.util.Arrays.toString(data));
}
}
5. Arrays工具类
Arrays工具类是为操作数组的工具类，包含了用来操作数组的各种方法
public class ArraysClassTest {
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)//所有值都被填充为后面的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);
System.out.println(index);
}
}
6. 数组中的常见异常
6.1 数组角标越界的异常
ArrayIndexOutOfBoundsException
public class ArrayException {
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4, 5};
//右边越界
for (int i = 0; i <= arr.length; i++){
System.out.print(arr[i] + " ");
}
//左边越界
System.out.println(arr[-2]);
}
}
6.2 空指针异常
NullPointerException
public class ArrayException {
public static void main(String[] args) {
//空指针异常 NullPointerException
//情况一
int[] arr = new int[]{1, 2, 3};
arr = null;
for (int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
//情况二
int[][] arr2 = new int[4][];
System.out.println(arr2[0]);//null
System.out.println(arr2[0][0]);
//情况三
String[] arr3 = new String[]{"aa", "bb", "cc"};
System.out.println(arr3[0].toString());
arr3[0] = null;
System.out.println(arr3[0].toString());
}
}
