🎛 流程控制#
分支语句#
- 单分支
- 双分支
- 多分支
if-else#
switch-case#
switch (x) {
case y:
zzz;
break;
case a:
bbb;
break;
default:
ccc;
}
x 中可传入 byte、short、int 或 char 的数据类型
从 Java SE 7 开始支持字符串 String 类型 同时 case 标签须为字符串常量或字面量
不加 break 时会发生 case 穿透
循环语句#
三要素
- 起始值
- 终止条件
- 步长
计数循环#
for(起始值;终止条件;步长){
}
先执行起始值 (只执行一次)
然后执行终止条件 为 false 时终止循环
真假循环#
while(){
}
do{
}while()
至少保证循环一次
跳转语句#
- continue 跳过本次循环
- break 终止当前循环
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#
算法步骤#
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
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#
算法步骤#
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
- 然后再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
- 以此类推，直到所有元素均排序完毕。
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, 再生成中间索引
当起始索引，大于结束索引时，终止，说明不存在该数据
- 缺点：必须建立在已排序的基础之上
- 优点：因为每次筛选一半，所以效率比较高，尽管数据靠前或者靠后，查询性能都比较均衡
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;
}
}