Java 入门（二）

🎛 流程控制

分支语句

单分支

双分支

多分支

if-else

switch-case

Copy
switch (x) {
case y:
zzz;
break;
case a:
bbb;
break;
default:
ccc;
}

x 中可传入 byte、short、int 或 char 的数据类型

从 Java SE 7 开始支持字符串 String 类型 同时 case 标签须为字符串常量或字面量

不加 break 时会发生 case 穿透

循环语句

三要素

起始值

终止条件

步长

计数循环

Copy
for(起始值;终止条件;步长){

}

先执行起始值 (只执行一次)
然后执行终止条件 为 false 时终止循环

真假循环

Copy
while(){

}

Copy
do{

}while()

至少保证循环一次

跳转语句

continue 跳过本次循环

break 终止当前循环

Copy
outfor:for(int i = 0; i < 5; i+ +) {
for(int j = 0; j < 5; j++) {
if (i == 3){
// continue a;
break outfor;
}
System.out.print(0 + " ");
}
System.out.println()
}

🍂 方法

一堆代码的集合 创建空间存储 并设置名字 可以通过名字找到
目的：代码复用 易维护 易扩展 更灵活
可设置多个修饰符

修饰符列表

可有可无 可以有多个 (有些是不能同时出现)
多个修饰符没有先后顺序

权限控制

public

private

protected

留空 (默认包权限)

四选一

static 表示静态 不加则为成员
final 和 abstract 不能同时出现

返回值

return 作用

终止方法运行

将数据返回到调用处

如果无返回值 且存在 return 那么此时只能终止方法运行 不会返回数据

类型

静态方法
在类体中，被 static 修饰的变量

成员方法
在类体中，没有被 static 修饰的变量

构造方法

调用

前缀。方法名 (参数)
方法被调用才会执行，并会把结果返回给调用处

静态方法 类名.方法名(参数)
如果调用当前类中的静态方法类名可以省略

成员方法 对象.方法名(参数)

重载

方法名相同 参数列表不同 (个数不同或类型不同)

递归

递归和迭代 (循环) 等价

以此类推，同时也是循环的基本思想
递归和迭代是等价的，迭代就是循环

循环可以做的，递归也能做，但是递归能做的，循环不一定能做

一般树状结构都可以遍历查询等操作
递归需要频繁压栈弹栈，比较消耗内存，并且效率较低，所以循环能完成的，就不要使用递归
能使用循环搞定的，就不要使用递归，除非循环搞不定
例如：获取目录下所有的文件 (包括子文件夹中的文件)
比如 树状结构 目录遍历等都需要使用递归完成
需要有初始值 终止条件 步长 否则会死循环 (一直压栈 不会弹栈 导致栈内存溢出)

直接递归

间接递归

📚 数组

放置在堆内存中 引用类型 内置对象
内存地址查询 查询、修改速度快
连续存储 数组长度不能修改

数据结构

计算机中存储、组织数据的方式。数据结构是一种具有一定逻辑关系，在计算机中应用某种存储结构，并且封装了相应操作的数据元素集合。它包含三方面的内容，逻辑关系、存储关系及操作。

声明

静态声明
数据类型[] 变量名 = {值,值,值,值}
数据类型 变量名[] = {值,值,值,值}

动态声明
数据类型 变量名[] = new 数据类型[长度] 不推荐
数据类型[] 变量名 = new 数据类型[长度]
数据类型[] 变量名 = new 数据类型[长度]{值,值,值,值}

数组使用

长度 数组.length

查询 数组 [下标]

遍历 fori

传值传址

传址

数组复制

替换合并

System.arraycopy(源数组,源数组起始位置,目标数组,目标数组起始位置,复制个数)

排序

冒泡排序 BubbleSort

算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

Copy
import java.util.Arrays;

public class BubbleSort {
public int[] sort(int[] sourceArray) {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
for (int i = 1; i < arr.length; i++) {
// 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
boolean flag = true;

for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;

flag = false;
}
}

if (flag) {
break;
}
}
return arr;
}
}

选择排序 SelectionSort

算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

然后再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

以此类推，直到所有元素均排序完毕。

Copy
public class SelectionSort {
public void sort(int[] arr) {
int minIndex;
for(int i = 0;i < arr.length;i++) {
minIndex = i;
//遍历找出未排序中的元素中最小值下标
for(int j = i;j < arr.length;j++) {
if(arr[j] < arr[minIndex]) {
minIndex = j;
}
}
//若最小值下标与未排序中最左侧下标不一致则交换
if(minIndex != i) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
}

查找

顺序查找

二分查找

又称为折半查询

查询步骤

每次都和中间数据进行比较

目标数据大于中间数据，结束索引不变，起始索引 = 中间索引 + 1, 再生成中间索引
目标数据小于中间数据，起始索引不变，结束索引 = 中间索引 - 1, 再生成中间索引
当起始索引，大于结束索引时，终止，说明不存在该数据

缺点：必须建立在已排序的基础之上

优点：因为每次筛选一半，所以效率比较高，尽管数据靠前或者靠后，查询性能都比较均衡

Copy
public class Search {
public int binarySearch(int[] array, int target) {
// 默认起始索引
int startIndex = 0;
// 默认结束索引
int endIndex = array.length - 1;
// 默认中间索引
int index = (startIndex + endIndex) / 2;
for (int i = 0; i < array.length; i++) {
// 目标数据大于中间数据,结束索引不变,起始索引=中间索引+1,再生成中间索引
if (target > array[index]) {
startIndex = index + 1;
// 目标数据小于中间数据,起始索引不变,结束索引=中间索引-1,再生成中间索引
} else if (target < array[index]) {
endIndex = index - 1;
} else if (target == array[index]) {
return index;
}
index = (startIndex + endIndex) / 2;
}
return -1;
}
}