emm，作者学了两周放弃了

题型结构

结果填空——2题，5分一题

程序设计——6题，10，10，15，15，20，20，共140

基础语法

运算符

1、算术运算符

public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        
        // 基本算术运算
        System.out.println(a + b);   // 13  加法
        System.out.println(a - b);   // 7   减法
        System.out.println(a * b);   // 30  乘法
        System.out.println(a / b);   // 3   除法（整数除法，结果为整数）
        System.out.println(a % b);   // 1   取模（求余数）
        
        // 特殊情况
        System.out.println(10 / 3.0);    // 3.3333333333333335 浮点数除法
        System.out.println(10.0 / 3);    // 3.3333333333333335
    }
}

2、自增自减运算符

public class IncrementDecrement {
    public static void main(String[] args) {
        int x = 5;
        
        // 后置自增：先使用，后增加
        System.out.println(x++);  // 输出5，然后x变为6
        System.out.println(x);    // 输出6
        
        // 前置自增：先增加，后使用
        int y = 5;
        System.out.println(++y);  // 输出6，y变为6
        System.out.println(y);    // 输出6
    }
}

3、关系（比较）运算符

public class RelationalOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        System.out.println(a == b);  // false  等于
        System.out.println(a != b);  // true   不等于
        System.out.println(a > b);   // false  大于
        System.out.println(a < b);   // true   小于
        System.out.println(a >= b);  // false  大于等于
        System.out.println(a <= b);  // true   小于等于
        
        // 字符串比较要用equals()
        String s1 = "Hello";
        String s2 = "Hello";
        System.out.println(s1.equals(s2));   // true（正确方式）
        
        String s3 = new String("Hello");
        String s4 = new String("Hello");
        System.out.println(s3 == s4);        // false（比较的是内存地址）
        System.out.println(s3.equals(s4));   // true（比较的是内容）
    }
}

4、逻辑运算符

&——同真则真
| —— 一个满足就为真
^ —— 相同为false，不同为true

public class LogicalOperators {
    public static void main(String[] args) {
        boolean t = true;
        boolean f = false;
        
        // 与运算（&& 和 &）—— 同真则真（都满足才为真）
        System.out.println(t && t);  // true  逻辑与（短路）
        System.out.println(t && f);  // false
        System.out.println(f && t);  // false（右边不会执行，短路）
        
        System.out.println(t & t);   // true  逻辑与（非短路）
        System.out.println(t & f);   // false
        
        // 或运算（|| 和 |）—— 有一个满足就为真
        System.out.println(t || f);  // true  逻辑或（短路）
        System.out.println(f || t);  // true
        System.out.println(f || f);  // false
        
        System.out.println(t | f);   // true  逻辑或（非短路）
        
        // 非运算
        System.out.println(!t);      // false 逻辑非
        System.out.println(!f);      // true
        
        // 异或 —— 相同false不同true
        System.out.println(t ^ t);   // false 相同为false
        System.out.println(t ^ f);   // true  不同为true
    }
}

5、三元运算符

public class TernaryOperator {
    public static void main(String[] args) {
        int age = 18;
        
        // 语法：条件 ? 表达式1 : 表达式2
        String status = age >= 18 ? "成年人" : "未成年人";
        System.out.println(status);  // 成年人
        
        // 可以嵌套使用，但不推荐（可读性差）
        int score = 85;
        String grade = score >= 90 ? "A" : (score >= 60 ? "B" : "C");
        System.out.println(grade);   // B
    }
}

Scanner输入

import java.util.Scanner;//导入scanner类
public class Person {
	public static void main(String args[]) {
	
		//创建Scanner对象	
		Scanner scan = new Scanner(System.in);
		
		//输入字符串
		System.out.println("请输入姓名：");
		String name = scan.nextLine();
		
		//输入整数
		System.out.println("请输入年龄：");
		int age = scan.nextInt();
		
		System.out.println("姓名：" + name + "，年龄：" + age);
		
		//关闭Scanner
		scan.close();
	}
}

面向对象基础

public class Person {
	String name;	
	int age;
	
	//构造方法
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	//方法
	public void study() {
		System.out.println(name + " " + age);
	}
	
	public static void main(String args[]) {
		Person person = new Person("NGC 2237",18);//传参
		person.study();
	}
}

流程控制

1、选择结构

if语句

		if (hasTicket) {
            if (isVip) {
                System.out.println("VIP通道进入");
            } else {
                System.out.println("普通通道进入");
            }
        } else {
            System.out.println("请先购票");
        }

switch语句

		int score = 85;
        String grade = switch (score / 10) {
            case 10, 9 -> "A";
            case 8 -> "B";
            case 7 -> "C";
            case 6 -> "D";
            default -> "F";
        };
        System.out.println("成绩等级：" + grade);
		
		// yield返回值
        String result = switch (dayOfWeek) {
            case 1, 2, 3, 4, 5 -> {
                System.out.println("工作日");
                yield "工作日";
            }
            case 6, 7 -> {
                System.out.println("周末");
                yield "周末";
            }
            default -> "无效";
        };

循环结构

for-each

for (元素类型 变量名 : 数组或集合) {
    // 循环体
}

//遍历一维数组
int[] numbers = {1, 2, 3, 4, 5};
System.out.println("数组元素：");
for (int num : numbers) {
    System.out.print(num + " ");
}
// 输出：数组元素：1 2 3 4 5

//遍历字符串数组
String[] names = {"张三", "李四", "王五"};
for (String name : names) {
    System.out.println("姓名：" + name);
}
// 输出：
// 姓名：张三
// 姓名：李四
// 姓名：王五

//遍历二维数组
int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
for (int[] row : matrix) {      // 外层循环：每次取出一行（一维数组）
    for (int num : row) {        // 内层循环：遍历这一行的每个元素
        System.out.print(num + " ");
    }
    System.out.println();        // 每行结束后换行
}
// 输出：
// 1 2 
// 3 4 
// 5 6

for-each不能修改数组元素，可以使用索隐变量修改

int[] arr = {1, 2, 3};
int index = 0;
for (int num : arr) {
    arr[index] = num * 2;  // 通过索引修改
    index++;
}
// arr现在是{2, 4, 6}

while

public class WhileLoop {
    public static void main(String[] args) {
        // 1. while循环
        int count = 1;
        while (count <= 5) {
            System.out.println("第" + count + "次循环");
            count++;
        }
        
        // 2. 计算数字位数
        int num = 12345;
        int temp = num;
        int digits = 0;
        while (temp > 0) {
            temp /= 10;
            digits++;
        }
        System.out.println(num + "有" + digits + "位");
    }
}

 // 3. 读取输入直到特定条件
java.util.Scanner scanner = new java.util.Scanner(System.in);
String input;
while (true) {
    System.out.print("输入exit退出：");
    input = scanner.nextLine();
    if (input.equals("exit")) {
        break;
    }
    System.out.println("你输入了：" + input);
}

do-while——至少执行一次，即便不符合条件

public class DoWhileLoop {
    public static void main(String[] args) {
        // 即使条件不满足，也会执行一次
        int j = 10;
        do {
            System.out.println("这个会执行一次，j=" + j);
        } while (j < 5);
        
        // 菜单选择示例
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        int choice;
        do {
            System.out.println("\n=== 菜单 ===");
            System.out.println("1. 查询余额");
            System.out.println("2. 存款");
            System.out.println("3. 取款");
            System.out.println("0. 退出");
            System.out.print("请选择：");
            choice = scanner.nextInt();
            
            switch (choice) {
                case 1:
                    System.out.println("余额查询");
                    break;
                case 2:
                    System.out.println("存款");
                    break;
                case 3:
                    System.out.println("取款");
                    break;
                case 0:
                    System.out.println("再见");
                    break;
                default:
                    System.out.println("无效选择");
            }
        } while (choice != 0);
        
        scanner.close();
    }
}

跳转语句

break语句

break——跳出当前循环，不再执行

public class BreakStatement {
    public static void main(String[] args) {
        // 1. 跳出当前循环
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                break;  // i=5时跳出循环
            }
            System.out.print(i + " ");  // 输出：1 2 3 4
        }
        System.out.println();
        
        // 2. 跳出嵌套循环（使用标签）
        outer: for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i == 1 && j == 1) {
                    System.out.println("跳出外层循环");
                    break outer;
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }
    }
}

continue语句

跳过条件

public class ContinueStatement {
    public static void main(String[] args) {
        // 1. 跳过当前迭代
        System.out.println("1到10的偶数：");
        for (int i = 1; i <= 10; i++) {
            if (i % 2 != 0) {
                continue;  // 跳过奇数
            }
            System.out.print(i + " ");  // 输出：2 4 6 8 10
        }
        System.out.println();
        
        // 2. 带标签的continue
        outer: for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    System.out.println("跳过外层循环的当前迭代");
                    continue outer;  // 跳到外层循环的下一次迭代
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }
        
        // 3. 实际应用：跳过无效数据
        int[] scores = {85, -1, 90, 75, -1, 95};
        int sum = 0;
        int count = 0;
        for (int score : scores) {
            if (score < 0) {
                System.out.println("跳过无效分数：" + score);
                continue;
            }
            sum += score;
            count++;
        }
        System.out.println("平均分：" + (double)sum / count);
    }
}

return

直接结束

public class ReturnStatement {
    public static void main(String[] args) {
        System.out.println("开始执行");
        
        if (args.length == 0) {
            System.out.println("没有参数，提前返回");
            return;  // 结束main方法
        }
        
        System.out.println("有参数，继续执行");
        
        int result = calculate(10, 5);
        System.out.println("计算结果：" + result);
    }
    
    public static int calculate(int a, int b) {
        if (b == 0) {
            System.out.println("除数不能为0");
            return 0;  // 提前返回
        }
        return a / b;
    }
}

数组

创建数组（初始化）

public class ArrayInitialization {
    public static void main(String[] args) {
        // 1. 动态初始化（指定长度，系统赋默认值）
        int[] arr1 = new int[5];        // [0, 0, 0, 0, 0]
        double[] arr2 = new double[3];   // [0.0, 0.0, 0.0]
        boolean[] arr3 = new boolean[2]; // [false, false]
        String[] arr4 = new String[4];   // [null, null, null, null]
        
        // 2. 静态初始化（指定具体值）
        int[] arr5 = new int[]{1, 2, 3, 4, 5};
        String[] arr6 = new String[]{"Java", "Python", "C++"};
        
        // 3. 静态初始化的简化形式
        int[] arr7 = {1, 2, 3, 4, 5};
        String[] arr8 = {"张三", "李四", "王五"};
        
        // 注意：简化形式不能拆分
        // int[] arr9;
        // arr9 = {1, 2, 3};  // 错误！必须在一行完成
        
        // 正确拆分
        int[] arr10;
        arr10 = new int[]{1, 2, 3};  // 正确
    }
}

获取数组长度

int length = arr.length;
System.out.println("数组长度：" + length);    // 5

二维数组

public class TwoDimensionalArray {
    public static void main(String[] args) {
        // 1. 声明和初始化
        // 方式1：指定行和列
        int[][] matrix1 = new int[3][4];
        
        // 方式2：静态初始化
        int[][] matrix2 = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 方式3：不规则数组（每行长度可以不同）
        int[][] jagged = new int[3][];
        jagged[0] = new int[]{1, 2};
        jagged[1] = new int[]{3, 4, 5};
        jagged[2] = new int[]{6, 7, 8, 9};
        
        // for-each遍历
        System.out.println("for-each遍历：");
        for (int[] row : matrix2) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
        
        // 4. 不规则数组遍历
        System.out.println("不规则数组：");
        for (int i = 0; i < jagged.length; i++) {
            for (int j = 0; j < jagged[i].length; j++) {
                System.out.print(jagged[i][j] + " ");
            }
            System.out.println();
        }
    }
}

String类的常用方法

字符串长度

String str = "Hello Java";
int len = str.length();//len = 10;
//空格也算在内

字符串比较

equals() —— 比较内容是否相等

String str1 = "Hello";
String str2 = "Hello";
String str3 = "hello";

System.out.println(str1.equals(str2));        // true
System.out.println(str1.equals(str3));        // false
System.out.println(str1.equalsIgnoreCase(str3)); // true (忽略大小写)

compareTo()——比较字典顺序

字符串查找

charAt() —— 获取指定位置的字符

String str = "Hello";
char ch = str.charAt(1);  // 返回 'e'（索引从0开始）
System.out.println(ch);

indexOf() —— 查找子串位置

String str = "Hello Java";
System.out.println(str.indexOf('e'));      // 1（查找字符）
// 索引:    0 1 2 3 4 5 6 7 8 9
// 字符:    H e l l o   J a v a
//           ↑
//         'e' 在索引1

System.out.println(str.indexOf("Java"));   // 6（查找字符串）
// 索引:    0 1 2 3 4 5 6 7 8 9
// 字符:    H e l l o   J a v a
//                      ↑
//                   "Java" 从索引6开始

System.out.println(str.indexOf('l', 3));   // 3（从索引3开始查找）
// 索引:    0 1 2 3 4 5 6 7 8 9
// 字符:    H e l l o   J a v a
//                ↑ ↑
//        第一个l在索引2，但起始位置是3
//        从索引3开始找：第一个字符是索引3的 'l'
//        所以找到的是索引3的 'l'

System.out.println(str.lastIndexOf('l'));  // 3（从后往前查找）
// 索引:    0 1 2 3 4 5 6 7 8 9
// 字符:    H e l l o   J a v a
//                ↑ ↑
//        从后往前找：先遇到索引3的 'l'，然后索引2的 'l'
//        最后一次出现的是索引3的 'l'

contains() —— 是否包含子串

String str = "Hello Java";
System.out.println(str.contains("Java"));
System.out.println(str.contains("Python"));

startsWith()/endsWith() —— 判断前缀/后缀

String str = "Hello Java";
System.out.println(str.startsWith("Hell"));//true
System.out.println(str.endsWith("ava"));//true
System.out.println(str.startsWith("hello"));//false

字符串截取

substring() —— 截取子串

String str = "Hello Java";
System.out.println(str.substring(6));   //"Java"——从索引6到结尾
System.out.println(str.substring(0,5)); //"Hello"——从0到5，不包括5

字符串转换

toUpperCase()/toLowerCase() —— 大小写转换

String str = "Hello Java";
System.out.println(str.toUpperCase()); // "HELLO JAVA"
System.out.println(str.toLowerCase()); // "hello java"

toCharArray() —— 转换为字符数组

String str = "Hello";
char[] chars = str.toCharArray();  // {'H','e','l','l','o'}

valueOf() —— 转换为字符串

int num = 123;
String str1 = String.valueOf(num); //"123"

boolean bool = true;
String str2 = String.valueOf(bool); //"true"

char[] ch = {'a','b','c','d'};
String str3 = String.valueOf(ch);  //"abcd"

字符串替换

replace()——替换字符或子串

String str = "Hello Java";
System.out.println(str.replace('l','L')); //将l替换为L //"Hello Java"
System.out.println(str.replace("Java","World")); //将Java替换为World  //"Hello World"

replaceAll()——使用正则表达式替换

public class ReplaceAllDemo {
    public static void main(String[] args) {
        String str = "a1b2c3";
        
        System.out.println("原字符串: " + str);
        System.out.println();
        
        // 1. 替换所有数字为 *
        System.out.println("1. replaceAll(\"\\\\d\", \"*\")");
        System.out.println("   结果: " + str.replaceAll("\\d", "*"));
        // a*b*c*
        
        // 2. 替换所有字母为 *
        System.out.println("\n2. replaceAll(\"\\\\D\", \"*\")");
        System.out.println("   结果: " + str.replaceAll("\\D", "*"));
        // *1*2*3 (\\D 匹配非数字)
        
        // 3. 替换所有字母为 #
        System.out.println("\n3. replaceAll(\"[a-z]\", \"#\")");
        System.out.println("   结果: " + str.replaceAll("[a-z]", "#"));
        // #1#2#3
        
        // 4. 只替换数字为 X
        System.out.println("\n4. replaceAll(\"[0-9]\", \"X\")");
        System.out.println("   结果: " + str.replaceAll("[0-9]", "X"));
        // aXbXcX
    }
}

public class ReplaceAllExamples {
    public static void main(String[] args) {
        String str = "Hello123World456Java789";
        
        System.out.println("原字符串: " + str);
        System.out.println();
        
        // 1. 删除所有数字
        System.out.println("删除所有数字: " + str.replaceAll("\\d", ""));
        // HelloWorldJava
        
        // 2. 删除所有字母
        System.out.println("删除所有字母: " + str.replaceAll("[a-zA-Z]", ""));
        // 123456789
        
        // 3. 替换所有数字为 #
        System.out.println("数字变#: " + str.replaceAll("\\d", "#"));
        // Hello###World###Java###
        
        // 4. 替换连续数字为一个 *
        System.out.println("连续数字变*: " + str.replaceAll("\\d+", "*"));
        // Hello*World*Java*
        
        // 5. 替换所有小写字母为大写字母的标记
        System.out.println("小写字母变*: " + str.replaceAll("[a-z]", "*"));
        // H*******W*****J****
        
        // 6. 只保留数字
        System.out.println("只保留数字: " + str.replaceAll("\\D", ""));
        // 123456789
        
        // 7. 只保留字母
        System.out.println("只保留字母: " + str.replaceAll("[^a-zA-Z]", ""));
        // HelloWorldJava
    }
}

字符串分割

split() —— 分割字符串

String str = "apple,banana,orange";
String[] fruits = str.split(",");  //["apple","banana","orange"]

String str2 = "a b c d";
String[] arr = str.split(" ");  //["a","b","c","d"]

join() —— 连接字符串

String[] arr = {"Java","Python","C++"};
String results = String.join(",",arr);  //"Java,Python,C++"

去除空格

trim() —— 去除首尾空格

String str = " Hello Java ";
System.out.println(str.trim());  //"Hello Java"

判断空字符串

isEmpty() —— 是否为空字符串

String str1 = "";
String str2 = "Hello";
System.out.println(str1.isEmpty());  //true
System.out.println(str2.isEmpty());  //false

contact() —— 字符串连接

String str1 = "Hello";
String str2 = "Java";
String result = str1.contact(" ").contact(str2);
//str1 + " " + str2
//"Hello Java"

repeat() —— 重复字符串

String str = "Ha";
System.out.println(str.repeat(3));
//"HaHaHa"

速查

方法	描述	示例
`length()`	返回字符串长度	`"Hello".length()` → 5
`charAt(int index)`	返回指定索引的字符	`"Hello".charAt(1)` → ’e'
`equals(Object obj)`	比较字符串内容	`"Hi".equals("Hi")` → true
`equalsIgnoreCase(String)`	忽略大小写比较	`"HI".equalsIgnoreCase("hi")` → true
`indexOf(String str)`	返回子串首次出现的位置	`"Hello".indexOf("l")` → 2
`lastIndexOf(String str)`	返回子串最后出现的位置	`"Hello".lastIndexOf("l")` → 3
`substring(int begin)`	截取从begin开始到结尾	`"Hello".substring(2)` → “llo”
`substring(int begin, int end)`	截取[begin, end)	`"Hello".substring(1,3)` → “el”
`toUpperCase()`	转换为大写	`"Hi".toUpperCase()` → “HI”
`toLowerCase()`	转换为小写	`"Hi".toLowerCase()` → “hi”
`trim()`	去除首尾空格	`" Hi ".trim()` → “Hi”
`replace(char old, char new)`	替换字符	`"Hi".replace('i','e')` → “He”
`replace(CharSequence old, CharSequence new)`	替换字符串	`"Hi".replace("Hi","Hello")` → “Hello”
`split(String regex)`	分割字符串	`"a,b,c".split(",")` → [“a”,“b”,“c”]
`contains(CharSequence s)`	是否包含子串	`"Hello".contains("ell")` → true
`startsWith(String prefix)`	是否以前缀开头	`"Hello".startsWith("He")` → true
`endsWith(String suffix)`	是否以后缀结尾	`"Hello".endsWith("lo")` → true
`isEmpty()`	是否为空	`"".isEmpty()` → true
`concat(String str)`	连接字符串	`"Hi".concat("!")` → “Hi!”
`toCharArray()`	转换为字符数组	`"Hi".toCharArray()` → [‘H’,‘i’]
`valueOf(各种类型)`	转换为字符串	`String.valueOf(123)` → “123”

Arrays类工具——操作数组

数组转换

** toString() —— 转换为字符串** 一维数组用Arrays.toString，二维及多维用Arrays.deepToString

public class ToStringDemo {
    public static void main(String[] args) {
        // 一维数组
        int[] arr1 = {1, 2, 3, 4, 5};
        System.out.println("直接输出：" + arr1);           // [I@15db9742
        System.out.println("Arrays.toString：" + Arrays.toString(arr1));  // [1, 2, 3, 4, 5]
        
        // 二维数组
        int[][] arr2 = {{1, 2}, {3, 4}, {5, 6}};
        System.out.println("二维数组：" + Arrays.toString(arr2));  // [[I@6d06d69c, [I@7852e922, ...]
        System.out.println("deepToString：" + Arrays.deepToString(arr2));  // [[1, 2], [3, 4], [5, 6]]
        
        // 多维数组
        int[][][] arr3 = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};
        System.out.println("三维数组：" + Arrays.deepToString(arr3));
        // [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
        
        // 对象数组
        String[] names = {"张三", "李四", "王五"};
        System.out.println(Arrays.toString(names));  // [张三, 李四, 王五]
    }
}

`sort()` —— 排序

import java.util.Arrays;
public class Homework {
	public static void main(String[] args) {
		//基本类型数组排序（升序）
		int[] numbers = {5,2,8,1,9,3,7,4,6};
		Arrays.sort(numbers);
		System.out.println("升序排序：" + Arrays.toString(numbers));
		//升序排序：[1, 2, 3, 4, 5, 6, 7, 8, 9]
		
		//部分排序
		int[] arr1 = {5,2,8,1,9,3,7,4,6};
		Arrays.sort(arr1,2,6); //排序索引2到6的元素
		System.out.println("部分排序：" + Arrays.toString(arr1));
		//部分排序：[5, 2, 1, 3, 8, 9, 7, 4, 6]
		
		//对象数组排序（需要实现Comparable）
        String[] names = {"张三", "李四", "王五", "赵六"};
        Arrays.sort(names);
        System.out.println("字符串排序：" + Arrays.toString(names));  // [张三, 李四, 王五, 赵六]
	}
}

`copyOf() 和 copyOfRange()` —— 数组复制

public class CopyDemo {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};
        
        // 1. copyOf - 复制数组（指定新长度）
        int[] copy1 = Arrays.copyOf(original, 3);
        System.out.println("复制前3个：" + Arrays.toString(copy1));  // [1, 2, 3]
        
        int[] copy2 = Arrays.copyOf(original, 8);
        System.out.println("扩展长度：" + Arrays.toString(copy2));  // [1, 2, 3, 4, 5, 0, 0, 0]
        
        int[] copy3 = Arrays.copyOf(original, original.length);
        System.out.println("完整复制：" + Arrays.toString(copy3));  // [1, 2, 3, 4, 5]
        
        // 2. copyOfRange - 复制指定范围
        int[] copy4 = Arrays.copyOfRange(original, 1, 4);
        System.out.println("复制索引1-3：" + Arrays.toString(copy4));  // [2, 3, 4]
        
        int[] copy5 = Arrays.copyOfRange(original, 2, 7);
        System.out.println("超出范围：" + Arrays.toString(copy5));  // [3, 4, 5, 0, 0]
    }
}

`binarySearch()` —— 二分查找

public class BinarySearchDemo {
    public static void main(String[] args) {
        // 二分查找要求数组已排序
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        
        // 查找存在的元素
        int index = Arrays.binarySearch(arr, 7);
        System.out.println("7的索引：" + index);  // 3
        
        index = Arrays.binarySearch(arr, 13);
        System.out.println("13的索引：" + index);  // 6
        
        // 查找不存在的元素
        index = Arrays.binarySearch(arr, 8);
        System.out.println("8的索引：" + index);  // -5（-插入点-1）
        
        // 插入点计算：-5 表示应该插入在索引4的位置（5前面）
        // 公式：插入点 = -结果 - 1
        
        // 部分查找
        int[] arr2 = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        index = Arrays.binarySearch(arr2, 2, 8, 7);  // 在索引2-7范围内查找
        System.out.println("在指定范围内查找7：" + index);  // 3
        
        // 对象数组查找
        String[] names = {"Alice", "Bob", "Charlie", "David"};
        Arrays.sort(names);  // 必须先排序
        index = Arrays.binarySearch(names, "Charlie");
        System.out.println("Charlie的索引：" + index);  // 2
        
    }
}

Java蓝桥杯备赛记录