（蓝桥杯软件赛Java研究生组/A组）第一章语言基础-第二节：Java基础

一：标识符、修饰符和注释

（1）标识符

标识符规则

• 包名、类名、方法名、参数名、变量名等，这些符号被称为标识符
• 标识符可以由字母、数字、下划线_和美元符号$组成
• 标识符不能以数字开头，不能是java中的关键字和保留字
• Java 区分大小写，因此 myvar 和 MyVar 是两个不同的标识符
• 标识符不能包含空格
• 标识符不能是常量表达式 false true null等

（2）修饰符

两个重要的修饰符

• static修饰符
  • static 关键字用来声明独立于对象的静态变量。局部变量不能被声明为 static 变量
  • 静态方法只能调用静态方法和静态变量，非静态方法可以调用静态方法
  • static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量
• final修饰符
  • final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值
  • 被 final 修饰的实例变量必须显式指定初始值
  • final 修饰符通常和 static 修饰符一起使用来创建类常量

（3）注释

Java中注释主要分为以下三种

• 单行注释：//注释内容；用的最多
• 多行注释：/*注释内容*/；不推荐使用
• 文档注释：/**注释内容*/；一般用在函数或者类上边

需要注意

• 多行注释不能嵌套使用
• 无论是单行还是多行注释，都不参与编译，也即.class文件中是不包含注释信息的

/**
 文档注释
 @version v1.0.1
 @deprecated  2024/02/19
 @author  fa

 第一个HelloWorld，以供练习
*/
public class HelloWorld {
    /*
    1.main方法是Java程序的入口方法
    2. main函数的格式是固定的，必须为public static void main(String[] args)
     */
    public static void main(String[] args) {
         System.out.println是Java中标准输出，会将内容输出到控制台
        System.out.println(10);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

二：数据类型

（1）分类

数据类型：数据类型是用来定义变量的，它规定了一个变量占用的空间大小，Java中的数据类型分为以下两类

• 基本数据类型
• 引用数据类型

（1）基本数据类型

基本数据类型见下表，需要注意

• 每个基本数据类型都会对应一个类类型，也即包装类

• 无论是16位还是32位系统，int都占用4个字节，long都占用8个字节

• 整型和浮点型都是有符号的（意思就是肯定有正负）

• 整型默认为int，浮点型默认为double

• 计算机使用 二进制(bit) 表示数据

• 字节（Byte）是计算机中表示空间大小的基本单位，1B=8bit

（2）引用数据类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如Employoyee、Puppy等。变量一旦声明后，类型就不能被改变了

三：变量

变量及赋值：除常量外，生活中更多见的是变量（比如人的年龄就处在不断变化之中）；可以把变量想象成一个箱子，这个箱子可以装特定的东西（例如苹果箱子规定只能装苹果），而箱子的大小则由数据类型决定，箱子的名字就叫做变量名，即数据类型 变量名=数值，在赋值时需要注意

• 变量在使用前必须初始化，否则无法运行（Java对数据类型的检查非常严格）
• 给变量赋的值不能超过该类型变量所规定的的范围，否则溢出
• 在方法内部定义的变量叫做局部变量、外部定义的是成员变量

（1）整型变量

A：int

需要注意

• 无论在何种系统下，int都是4个字节
• int的包装类型为integer
• int范围为：-2³¹~ 2³¹-1
• case1：建议使用这种方式
• case3：通过integer的MAX_VALUE和MIN_VALUE可以得到整型的最大和最小值
• case4：定义时未初始化或超出int范围，Java会直接报错

public class TestDemo {
    public static void main(String[] args) {
        //case1：在定义时给出初值
        int a = 10;
        System.out.println(a);
        System.out.println("---------------------------------------------");
        //case2：先定义后赋值
        int b;
        b = 20;
        System.out.println(b);
        System.out.println("---------------------------------------------");
        //case3：输出最大和最小值
        System.out.println("最大值"+Integer.MAX_VALUE);
        System.out.println("最小值"+Integer.MIN_VALUE);
        //case4：定义时未初始化或者超过范围，Java将直接报错，非常安全
        /*
        int c = 9999999999999999999999999999999999;//error
        int d;
        System.out.println(d);//error
       
      
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

B：long

需要注意

• 无论在何种系统下，long都是4个字节
• long的包装类型为Long
• long范围为：-2⁶³~ 2⁶³-1
• case2：建议使用这种方式初始化，以区分int
• case3：通过Long的MAX_VALUE和MIN_VALUE可以得到长整型的最大和最小值

public class TestDemo {
    public static void main(String[] args) {
        //case1
        long a = 100;
        System.out.println(a);
        System.out.println("--------------");
        //case2：初始化时为了进行区分，建议在后面加L
        long b = 100L;
        System.out.println(a);
        System.out.println("--------------");
        //case3：输出最大和最小值
        System.out.println("最大值"+Long.MAX_VALUE);
        System.out.println("最小值"+Long.MIN_VALUE);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

C：short

需要注意

• 无论在何种系统下，short都是2个字节
• short的包装类型为Short
• short范围为：-2¹⁵~ 2¹⁵-1
• case2：通过Short的MAX_VALUE和MIN_VALUE可以得到短整型的最大和最小值

public class TestDemo{
    public static void main(String[] args) {
        //cas1:
        short a = 10;
        System.out.println(a);
        //case2:
        System.out.println("最大值"+Short.MAX_VALUE);
        System.out.println("最小值"+Short.MIN_VALUE);
    }
}
1
2
3
4
5
6
7
8
9
10

D：byte

需要注意

• 无论在何种系统下，byte都是1个字节
• byte的包装类型为Byte
• byte范围为：-128~127
• case2：通过Byte的MAX_VALUE和MIN_VALUE可以得到byte的最大和最小值

public class TestDemo{
    public static void main(String[] args) {
        //cas1:
        byte a = 10;
        System.out.println(a);
        //case2:
        System.out.println("最大值"+Byte.MAX_VALUE);
        System.out.println("最小值"+Byte.MIN_VALUE);
    }
}
1
2
3
4
5
6
7
8
9
10

这里再补充一点，如下代码看似是没有错误的，因为变量b的结果是11，并没有超过byte的范围，但编译器却报出了错误

这是因为变量a的确是byte型的，但在Java中整型字面常量默认为int，整型提升后变量a+1自然就变为了int型，类型不正确。正确写法如下

（2）浮点型变量

A：float

需要注意

• 无论在何种系统下，float都是4个字节
• float存储遵守IEEE 754标准，更多可点击了解：(计算机组成原理)第二章数据的表示和运算-第三节2：IEEE754标准
• 不推荐使用float，因为其范围较小，常用的还是double
• float包装类型为Float
• case1：由于浮点型字面常量默认为double，所以在定义时后面必须加f或F，否则无法编译通过

public class TestDemo{
    public static void main(String[] args) {
        //cas1:
        float a = 3.14F;
        System.out.println(a);
    }
}
1
2
3
4
5
6
7

B：double

• 无论在何种系统下，double都是8个字节
• double存储遵守IEEE 754标准，更多可点击了解：[(计算机组成原理)第二章数据的表示和运算-第三节2：IEEE754标准]
• double包装类型为Double
• case2：Java中，int与int相除是不会得到double的，除非两个都是double（或者让其中一个暂时变为小数）
• case3：在计算机中某些小数是无法用二进制精确表示的，所以很多时候计算的结果会和我们想象的存在误差（具体见：(计算机组成原理)第二章数据的表示和运算-第一节1：一文总结进制转换，妈妈再也不用担心我不会进制转换了）

public class TestDemo{
    public static void main(String[] args) {
        //case1:
        double  a = 3.14;
        System.out.println(a);

        //case2:
        int b1 = 1;
        int c1= 2;
        System.out.println(b1/c1);//不等于0.5，等于0
        double b2 = 1;
        double c2 = 2;
        System.out.println(b2/c2);//等于0.5
        System.out.println(b1*1.0/c1);//这样也是0.5

        //case3:
        double d = 1.1;
        System.out.printf("%.20f", d*d);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（3）字符型变量

需要注意

• char的包装类型为Character

• char范围为：0~65535

• case1：计算机中的字符本质上是一个整数。在C语言中使用ASCII表示字符，而Java中使用Unicode表示字符。因此一个字符占用两个字节,表示的字符种类更多,包括中文（具体见（(计算机组成原理)第二章数据的表示和运算-第一节3：字符与字符串在计算机中的表示详解））

• case2：字符可以存放整数（显示时会显示为整数对应的字符；不能是负数）

public class TestDemo{
    public static void main(String[] args) {
        //case1
        char a = 'a';
        char b ='6';
        System.out.println(a);
        System.out.println(b);

        //case2
        char c = 97;
        System.out.println(c);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（4）布尔型变量

需要注意

• 在Java中 boolean类型只有两种取值：ture和false（没有所谓的0是假非0是真的说法）
• boolean的包装类型为Boolean
• boolean并没有规定它的大小

public class TestDemo{
    public static void main(String[] args) {
        //case1
        boolean flg = true;
        System.out.println(flg);
    }
}
1
2
3
4
5
6
7

四：类型转换

类型转换：Java是一门强类型编程语言，在进行变量赋值时会有严格的类型检查，检查不通过编译也会失败，如下

• 在C/C++中顶多会给你一个warning，很不安全

public class TestDemo{
    public static void main(String[] args) {
        int a = 10;
        long b = 100L;
        b = a;//编译通过
        a = b;//编译失败，4字节存不了8字节的
    }
}
1
2
3
4
5
6
7
8

如果编译可以通过，那么当数据类型不一致时就会进行类型转换，分为两类

• 自动类型转换（隐式）
• 强制类型转换（显式）

（1）自动类型转换（隐式）

自动类型转换（隐式）：即代码不需要经过任何处理，在编译时编译器自动进行转换；典型特征就是数据范围小的转数据范围大的

public class TestDemo{
    public static void main(String[] args) {
        //case1:
        int a = 10;
        long b = 100L;
        b = a;//编译通过；4字节转向8字节
        a = b;//编译失败；8字节转向4字节会丢失

        //case2:
        float f = 3.14F;
        double d =5.12;
        d = f;//编译通过；4字节转向8字节
        f = d;//编译失败；8字节转向4字节会丢失

        //case3：
        byte b1 = 100;//编译通过；未超过byte范围，会将int下的100转化为byte
        byte b2 = 257;编译失败；超出范围，数据丢失
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（2）强制类型转换（显式）

强制类型转换（显式）：操作时，代码需要一定的格式处理，一旦强转意味着程序员需要为此次转换负责；典型特征就是数据范围大的转数据范围小的

• 注意：强转不一定成功，两个不相干的类型不能强转

public class TestDemo{
    public static void main(String[] args) {
        //case1:
        int a = 10;
        long b = 100L;
        b = a;//编译通过；4字节转向8字节
        a = b;//编译失败；8字节转向4字节会丢失
        a = (int)b;//强转

        //case2:
        float f = 3.14F;
        double d =5.12;
        d = f;//编译通过；4字节转向8字节
        f = d;//编译失败；8字节转向4字节会丢失
        f = (float)d;//强转

        //case3：
        byte b1 = 100;//编译通过；未超过byte范围，会将int下的100转化为byte
        byte b2 = 257;编译失败；超出范围，数据丢失
        byte b3 = (byte)257;//强转
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

五：逻辑控制

（1）分支结构

if语句

public class TestDemo {
    public static void main(String[] args) {
        //格式1
        int a = 10;
        if(a > 1){
            System.out.println("不知道写啥");
        }
        System.out.println("---------------------------------");

        //格式2
        int b = 3;
        int c = 5;
        if(b > c){
            System.out.println("b比c要大");
        }else{
            System.out.println("b比c要小");
        }
        System.out.println("---------------------------------");

        //格式3
        int score = 77;
        if(score >= 90){
            System.out.println("优秀");
        }else if(score >= 80 && score < 90){
            System.out.println("良好");
        }else if(score >= 70 && score < 80){
            System.out.println("中等");
        }else if(score >= 60 && score < 70){
            System.out.println("及格");
        }else if(score >= 0 && score < 60){
            System.out.println("不及格");
        }else{
            System.out.println("错误数据");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

Switch语句

• 多个case后的常量值不可以重复
• switch括号内不能是以下数据类型
  • long、float、double、boolean
• 不要遗漏break，否则switch将失去“多分支选择”的效果

public class TestDemo {
    public static void main(String[] args) {
        int day = 2;
        switch(day){
            case 1:
                System.out.println("周一");
                break;
            case 2:
                System.out.println("周二");
                break;
            case 3:
                System.out.println("周三");
                break;
            default:
                System.out.println("休息");
                break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（2）循环结构

while循环

• break：结束循环
• continue：跳过本次循环直接进入下一次循环

public class TestDemo {
    public static void main(String[] args) {
        int i = 1;
        while(i <= 10){
            System.out.println(i++);
        }
    }
}
1
2
3
4
5
6
7
8

for循环

public class TestDemo {
    public static void main(String[] args) {
        for(int i = 1; i <= 10; i++){
            System.out.println(i);
        }
    }
}
1
2
3
4
5
6
7

增强for循环

public class TestDemo{
	public static void main(String[] args){
		
		int[] a = new int[10];
		for (int x : a) {
			System.out.println(x);
		}
	}
}
1
2
3
4
5
6
7
8
9

do while循环

int num = 1;
do {
System.out.println(num);
num++;
} while (num <= 10);
1
2
3
4
5

六：方法

（1）概述

Java中的方法是用来执行特定任务的一段代码块。方法可以接受参数，执行操作，并返回结果。在Java中，方法通常定义在类中，并且可以被该类的对象调用。以下是Java方法的一些基本特征和语法：

• 方法声明：方法声明包括方法的访问修饰符（如public、private、protected或默认修饰符），返回类型，方法名，参数列表以及方法体
• 访问修饰符：控制方法的访问级别，例如public表示公共方法，可以从任何地方访问；private表示私有方法，只能在同一类中访问；protected表示受保护方法，可以在同一包或子类中访问；默认修饰符表示包私有方法，只能在同一包中访问
• 返回类型：方法可以返回一个值，其类型由返回类型指定。如果方法不返回任何内容，则返回类型为void
• 方法名：方法的名称，用来在程序中调用方法
• 参数列表：方法可以接受零个或多个参数。参数列表是方法名称后的括号内部声明的变量列表，每个参数由参数类型和参数名组成
• 方法体：包含方法执行的代码块

下面是一个简单的Java方法示例： add方法接受两个整数作为参数，并返回它们的和。main方法是Java程序的入口点，在其中调用了add方法，并输出了结果

public class Example {
    // 方法声明
    public static int add(int num1, int num2) {
        // 方法体
        int sum = num1 + num2;
        return sum; // 返回结果
    }

    public static void main(String[] args) {
        // 调用方法
        int result = add(3, 5);
        System.out.println("Result: " + result);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（2）重载

方法的重载（Overloading）是指在同一个类中可以定义多个同名的方法，但它们的参数列表必须不同（参数类型、参数个数或参数顺序不同）。在调用方法时，编译器会根据提供的参数类型和数量来确定调用哪个重载方法

• 方法名相同：重载的方法必须有相同的方法名
• 参数列表不同：重载的方法的参数列表必须不同，至少有以下一点不同：
  • 参数个数不同
  • 参数类型不同
  • 参数顺序不同
• 返回类型可以相同也可以不同：即使两个重载方法的返回类型不同，只要它们的参数列表不同，它们仍然被认为是重载方法
• 访问修饰符、返回类型、抛出的异常等都可以不同：重载的方法可以具有不同的访问修饰符，返回类型以及抛出的异常类型

下面是一个方法重载的示例： Calculator类中定义了四个重载方法add，分别用于执行整数相加、双精度浮点数相加、字符串连接等操作。在main方法中，演示了如何调用这些重载方法

public class Calculator {
    // 重载方法1：两个整数相加
    public int add(int a, int b) {
        return a + b;
    }

    // 重载方法2：三个整数相加
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 重载方法3：两个双精度浮点数相加
    public double add(double a, double b) {
        return a + b;
    }

    // 重载方法4：两个字符串连接
    public String add(String a, String b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();

        // 调用重载方法1
        System.out.println("Result 1: " + calc.add(3, 5));
        
        // 调用重载方法2
        System.out.println("Result 2: " + calc.add(3, 5, 7));
        
        // 调用重载方法3
        System.out.println("Result 3: " + calc.add(3.5, 2.5));
        
        // 调用重载方法4
        System.out.println("Result 4: " + calc.add("Hello, ", "world!"));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

七：类与对象

在Java中，类（Class）是一种用来描述对象的模板或蓝图，它定义了对象的属性和方法。而对象（Object）则是类的实例化，是类的具体实体，可以执行类中定义的方法，访问类中定义的属性。以下是关于Java类和对象的一些基本概念：

• 类（Class）：类是一种用户自定义的数据类型，用来描述具有相似特征和行为的对象集合。类定义了对象的属性（成员变量）和行为（成员方法）
• 对象（Object）：对象是类的实例，它是类的具体实体，具有类中定义的属性和行为。可以通过new关键字来创建对象
• 属性（成员变量）：类的属性是描述对象状态的变量，也称为成员变量或实例变量。每个对象都有自己的一组属性
• 方法（成员方法）：类的方法是描述对象行为的函数，也称为成员方法或实例方法。通过调用对象的方法，可以执行特定的操作
• 封装（Encapsulation）：封装是面向对象编程的基本概念之一，它指的是将数据和方法封装在类的内部，并对外部提供访问接口。通过封装，可以隐藏对象的内部实现细节，提高代码的安全性和可维护性
• 继承（Inheritance）：继承是面向对象编程中的另一个重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以扩展或修改父类的行为，从而实现代码的重用和扩展
• 多态（Polymorphism）：多态是指同一个方法调用可以在不同的对象上具有不同的行为。Java中的多态性通过方法重写（Override）和方法重载（Overload）来实现

下面是一个简单的Java类和对象的示例：Car类描述了汽车的属性（品牌、型号、年份）和行为（显示汽车信息）。在main方法中，通过new关键字创建了一个Car对象myCar，并调用了它的displayInfo方法来显示汽车信息

// 定义一个类
public class Car {
    // 成员变量
    String brand;
    String model;
    int year;

    // 构造方法
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // 成员方法
    public void displayInfo() {
        System.out.println("Brand: " + brand);
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
    }

    public static void main(String[] args) {
        // 创建对象
        Car myCar = new Car("Toyota", "Camry", 2022);
        
        // 调用对象的方法
        myCar.displayInfo();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

八：接口

在Java中，接口（Interface）是一种抽象类型，它定义了一组抽象方法（没有方法体）以及常量（变量值不可改变）。接口提供了一种定义行为的方式，而不涉及具体的实现。类可以实现一个或多个接口，从而具备接口定义的方法和属性。以下是Java接口的一些基本特征和规则

①定义接口：使用interface关键字来定义接口。接口中可以包含抽象方法、常量、默认方法和静态方法

public interface MyInterface {
    // 抽象方法
    void abstractMethod();

    // 常量
    int CONSTANT_VALUE = 10;

    // 默认方法
    default void defaultMethod() {
        System.out.println("Default method implementation");
    }

    // 静态方法
    static void staticMethod() {
        System.out.println("Static method implementation");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

②实现接口：使用implements关键字来让一个类实现一个或多个接口。一个类可以同时实现多个接口

public class MyClass implements MyInterface {
    // 实现接口中的抽象方法
    @Override
    public void abstractMethod() {
        System.out.println("Implementation of abstractMethod");
    }

    // MyClass可以选择重写默认方法
}

1
2
3
4
5
6
7
8
9
10

③多继承：Java中允许类实现多个接口，这提供了一种弥补Java单继承限制的方式

public class MyOtherClass implements MyInterface, AnotherInterface {
    // 实现接口中的抽象方法
    @Override
    public void abstractMethod() {
        System.out.println("Implementation of abstractMethod");
    }

    // 实现AnotherInterface中的抽象方法
    @Override
    public void anotherMethod() {
        System.out.println("Implementation of anotherMethod");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

其他

• 接口继承：接口可以继承其他接口，通过extends关键字
• 默认方法：接口中的默认方法是具有方法体的方法，实现类可以选择重写或者直接继承
• 静态方法：接口中的静态方法是使用static关键字修饰的方法，可以通过接口名直接调用

九：输出和输入

（1）输出

Java中向控制台输出信息主要有三种方式

System.out.println(msg);
//输出一一个字符串,带换行
System.out.print(msg);
//输出一个字符串,不带换行
System.out.printf(format, msg); // 格式化输出

1
2
3
4
5
6

其中格式化字符串如下

（2）输入

Java中需要输入信息时需要导入util包

import java.util.Scanner;
1

导入之后，可以new出一个Scanner对象用于接收信息

Scanner sc = new Scanner(System.in);
1

接着可以调用该Scanner对象的各种方法去接收各种类型的值（注意输入的值的类型一定要匹配）

如果最后不需要输入，记得关闭Scanner

Scanner.close()
1

---

这里举一些常见的例子

①：Scanner.nextLine()：接收一行信息，使用String接收按下回车时结束输入

• Scanner.nextLine()：接收一行信息，碰到空格时结束输入

public class TestDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的姓名：");
        String name =sc.nextLine();
        System.out.println(name);
    }
}
1
2
3
4
5
6
7
8

②：Scanner.nextInt()：接收整型

• Scanner.nextFloat()/Scanner.nextDouble()：接收浮点型

public class TestDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的姓名：");
        String name = sc.nextLine();
        System.out.println(name);
        System.out.println("请输入您的年龄：");
        int age = sc.nextInt();
        System.out.println(age);
    }
}
1
2
3
4
5
6
7
8
9
10
11

③：使用如下方式处理循环输入

• 如下例子用于循环读取10个数字并求它们的和
• 结束输入时按下ctrl+D

public class TestDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
       int sum = 0;
       int num = 0;
       while(sc.hasNextInt()){
           int temp = sc.nextInt();
           sum += temp;
           num++;
           if(num == 10) {
               break;
           }
       }
        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

④：Scanner.next：接收不带空格的字符串

十：String和StringBuilder

（1）字符串构造

A：常用构造方法

字符串构造：构造一个字符串方法有很多，常用的有以下三种

• 使用常量字符串构造
• 直接newString对象
• 使用字符数组构造

public class TestDemo {
    public static void main(String[] args){
        //使用常量字符串构造
        String str1 = "Hello World1";
        //直接newString对象
        String str2 = new String("Hello World2");
        //使用字符数组进行构造
        char[] arr = {'H','e','l','l','o','W','o','r','l','d','3'};
        String str3 = new String(arr);

        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

B：注意

String是引用类型，但是其内部并不存储字符串本身，实际回报存在一个char类型的数组中

完整的关系应该是下面这样

public static void main(String[] args){
	//s1和s2引用的不是同一个对象
	//s1和s3引用的是同一个对象
	String s1 = new String("hello");
	String s2 = new String("world");
	String s3 = s1;
}
1
2
3
4
5
6
7

（2）字符串比较

①：==用于比较是否引用的是同一个对象

• 内置类型：比较的是变量的值
• 引用类型：比较的是地址

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;

        //对于基本类型，比较的是值
        System.out.println(a == b);
        System.out.println(a == c);

        System.out.println("----------------------------------------------");

        //对于引用类型，比较是否引用的是同一个对象
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        String s4 = s1;
        System.out.println(s1 == s2);
        System.out.println(s2 == s3);
        System.out.println(s1 == s4);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

②：boolean equals(Object anObject)方法会按照字典序进行比较。如下，String类中重写了父类Object中的equals方法

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("hello");

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}
1
2
3
4
5
6
7
8
9
10

③：int compareTo(String s)方法也会按照字典序进行比较，但与equals有所不同的是，它返回的是int。具体比较规则如下

• 先按照字典序进行比较，如果出现不等的字符，直接返回这两个字符的大小差值
• 如果前k个字符相等（k为两个字符长度最小值），则返回两个字符串长度差值

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("abc");
        String s4 = new String("abcdef");

        System.out.println(s1.compareTo(s2));//不同输出字符差值 -1
        System.out.println(s1.compareTo(s3)); //相同为零
        System.out.println(s1.compareTo(s4)); //前k个字符完全相同，输出长度差值 -3
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

④：int compareTolgnoreCase(String str)方法：与compareTo方法相同，但是忽略大小写

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("ABc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareToIgnoreCase(s2));
        System.out.println(s1.compareToIgnoreCase(s3));//相同
        System.out.println(s1.compareToIgnoreCase(s4));
    }
}
1
2
3
4
5
6
7
8
9
10
11

（3）字符串查找

①：char charAt(inde index)：返回index位置上字符

• 如果index为负数或者越界，抛出"indexOutofBoundsException"异常

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("Hello");
        String s2 = new String("World");

        char c1 = s1.charAt(2);
        System.out.println(c1);
        System.out.println("-----------------------------------");

        for(int i = 0; i < s2.length(); i++){
            System.out.println(s2.charAt(i));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

②：int indexOf(int ch)：返回字符ch第一次出现的位置

• 如果没有ch这个字符则会返回-1

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("Hello");
        String s2 = new String("World");

        System.out.println(s1.indexOf('e'));
        System.out.println(s2.indexOf('c'));
    }
}
1
2
3
4
5
6
7
8
9

③：int indexOf(int ch, int fromIndex)：从“fromIndex”位置开始寻找字符“ch”第一次出现的位置

• 如果没有ch这个字符则会返回-1

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("Hello World!");

        System.out.println(s1.indexOf('e', 1));
        System.out.println(s1.indexOf('o', 5));
        System.out.println(s1.indexOf('e', 5));
    }
}
1
2
3
4
5
6
7
8
9

④：int indexOf(String str)：返回字符串str第一次出现的位置

• 如果没有str这个字符串则会返回-1

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("Hello World!");

        System.out.println(s1.indexOf("World"));
        System.out.println(s1.indexOf("Worls"));

    }
}
1
2
3
4
5
6
7
8
9

⑤：int indexOf(String str, int fromIndex)：从“fromIndex”位置开始寻找字符串“str”第一次出现的位置

• 如果没有str这个字符串则会返回-1

public class TestDemo {
    public static void main(String[] args) {
        String s1 = new String("one two three one four nine");

        System.out.println(s1.indexOf("one", 4));
        System.out.println(s1.indexOf("one", 15));
        
    }
}
1
2
3
4
5
6
7
8
9

⑥：int lastIndexOf(int ch)、int lastIndexOf(int ch, int fromIndex)、int lastIndexOf(String str)、int lastIndexOf(String str, int fromIndex)：和前面类似，只不过是从后向前找

（4）字符串转化

A：数值和字符串的转换

数字转换为字符串可以使用String.valueOf()

public class TestDemo {
    public static void main(String[] args) {
        String s1 = String.valueOf(123);
        String s2 = String.valueOf(3.14);
        String s3 = String.valueOf(true);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}
1
2
3
4
5
6
7
8
9
10

字符串转化为数字常用方法如下

public class TestDemo {
    public static void main(String[] args) {
        int num1 = Integer.parseInt("1234");
        int num2 = Integer.parseInt("64", 8);//8表示八进制，八进制下的64对应十进制下的52
        double num3 = Double.parseDouble("3.14");
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
    }
}
1
2
3
4
5
6
7
8
9
10

B：大小写转换

字母大小写转换可以使用toUpperCase()和toLowerCase()。需要注意是，转换完成后，原来字符串的值并不会改变

public class TestDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";

        //小写转换为大写
        System.out.println(s1 + "->" + s1.toUpperCase());
        //大写转换为小写
        System.out.println(s2 + "->" + s2.toLowerCase());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

C：字符串转数组

可以使用String.toCharArray()将一个字符串转为一个字符数组

public class TestDemo {
    public static void main(String[] args) {
        String str = "Hello!";
        char[] ch = str.toCharArray();

        for(int i = 0; i < ch.length; i++){
            System.out.println(ch[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10

D：格式化

使用String.format()可以将一个字符串格式化为目标字符串

public class TestDemo {
    public static void main(String[] args) {
        String str = String.format("%d-%d-%d", 2000, 10, 12);
        System.out.println(str);
    }
}
1
2
3
4
5
6

（5）字符串替换

①：String replaceAll(String regex, String replacement)：将原字符串中regex替换为replacement

public class TestDemo{
    public static void main(String[] args) {
        String s1 = "HelloWorld,Hello You";
        String s2 = s1.replaceAll("Hello", "Bye"); //将Hello替换为Bye
        String s3 = s1.replace('H', 'S'); //将H替换为S
        System.out.println(s2);
        System.out.println(s3);
    }
}
1
2
3
4
5
6
7
8
9

②：String replaceFirst(String regex, String replacement)：仅替换首次出现的regex

public class TestDemo{
    public static void main(String[] args) {
        String s1 = "HelloWorld,Hello You";
        String s2 = s1.replaceFirst("Hello", "Bye"); //将第一个Hello替换为Bye
        System.out.println(s2);
    }
}
1
2
3
4
5
6
7

（6）字符串拆分

①：String[] split(String regex)：以regex为分割标志，将原字符串拆分为多个字符串

public class TestDemo{
    public static void main(String[] args) {
        String str = "中国-北京市-东城区-长安街-天安门广场";
        String[] ret = str.split("-");
        for(String s : ret){
            System.out.println(s);
        }
    }
}
1
2
3
4
5
6
7
8
9

②：String[] split(String regex, int limit)：以regex为分割标志，将原字符串拆分为limit字符串

public class TestDemo{
    public static void main(String[] args) {
        String str = "中国-北京市-东城区-长安街-天安门广场";
        String[] ret = str.split("-", 3);
        for(String s : ret){
            System.out.println(s);
        }
    }
}
1
2
3
4
5
6
7
8
9

③：一旦以"|“、”*“、”+“等作为分割标志时，前面都得加上”\\“，而且如果是”\“，那么就得写上”\\\\"

public class TestDemo{
    public static void main(String[] args) {
        String str = "www.baidu.com";
        String[] ret = str.split("\\.");
        for(String s : ret){
            System.out.println(s);
        }
    }
}
1
2
3
4
5
6
7
8
9

④：如果第一次拆分出来的字符串中还需要进行拆分，那么就要使用下面这种多次拆分的写法

• 首先以&为分割标志拆分出name=zhangsan和age=18
• 然后再以=为分割标志拆分出name、zhangsan、age和18

public class TestDemo{
    public static void main(String[] args) {
        String str = "name=zhangsan&age=18";
        String[] result = str.split("&");
        for(int i = 0; i < result.length;i++){
            String[] temp = result[i].split("=");
            System.out.println(temp[1]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10

（7）字符串截取

使用String substring(int beginIndex, int endIndex)可以截取[beginIndex, endIndex)区间内的字符串

• 如果不写endIndex，那么表示从beginIndex开始一直截取到末尾

public class TestDemo{
    public static void main(String[] args) {
        String str = "-Hello_World";
        String str1 = str.substring(7);
        String str2 = str.substring(1,6);
        System.out.println(str1);
        System.out.println(str2);
    }
}
1
2
3
4
5
6
7
8
9

（8）StringBuilder

String和StringBuilder都是用于处理字符串的类，但它们之间有几个重要的区别：

• 不可变性：

  • String是不可变的，即一旦创建了String对象，就不能修改其内容。对String对象进行任何操作（如拼接、替换等）都会创建一个新的String对象。
  • StringBuilder是可变的，它允许对字符串进行动态修改，而不会创建新的对象。因此，对于频繁修改字符串内容的情况，使用StringBuilder会更高效

• 线程安全性：

  • String是线程安全的，因为它的不可变性保证了多个线程同时访问一个String对象时不会出现竞态条件
  • StringBuilder是非线程安全的，如果多个线程同时访问一个StringBuilder对象并进行修改，可能会导致数据不一致或其他并发问题。如果需要在多线程环境下使用可变字符串，应该使用StringBuffer，它和StringBuilder功能类似但是线程安全的

基于上述区别，我们可以得出以下结论：

• 如果字符串内容不需要经常修改，或者只需进行少量的字符串拼接、替换操作，那么使用String是合适的，因为它的不可变性可以带来线程安全性和更简单的代码。
• 如果字符串需要频繁修改，例如在循环中进行大量的拼接操作，或者需要动态构建较大的字符串，那么使用StringBuilder会更加高效

常用方法如下

• append(): 用于在字符串末尾添加字符、字符串、基本类型数据或其他 StringBuilder 对象的内容
• insert(): 用于在指定位置插入字符、字符串、基本类型数据或其他 StringBuilder 对象的内容
• delete(): 用于删除从指定起始位置到指定结束位置的字
• deleteCharAt(): 用于删除指定位置的字符
• replace(): 用于将指定范围内的字符替换为新的字符或字符
• reverse(): 用于颠倒字符串中字符的顺序
• charAt(): 用于获取指定位置的字符
• length(): 用于获取字符串的长度
• toString(): 用于将 StringBuilder 对象转换为 String 对象
• indexOf() 和 lastIndexOf(): 用于查找指定字符或字符串在 StringBuilder 中第一次和最后一次出现的位置

StringBuilder sb = new StringBuilder();

// append() 示例
sb.append("Hello");
sb.append(" ").append("world");
sb.append(2024);

// insert() 示例
sb.insert(5, ", ");
sb.insert(0, "Greetings, ");

// delete() 示例
sb.delete(6, 11);

// deleteCharAt() 示例
sb.deleteCharAt(7);

// replace() 示例
sb.replace(5, 11, "Java");

// reverse() 示例
sb.reverse();

// charAt() 示例
char c = sb.charAt(1);

// length() 示例
int len = sb.length();

// toString() 示例
String str = sb.toString();

// indexOf() 和 lastIndexOf() 示例
int firstIndex = sb.indexOf("o");
int lastIndex = sb.lastIndexOf("o");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

十一：常见数学方法

Java中的Math类是一个包含了许多用于执行数学运算的工具方法的内置类。它提供了一系列静态方法来执行常见的数学运算，如取绝对值、取最大值、取最小值、求平方根、求幂运算等等。以下是Math类中一些常用方法的介绍：

• abs(double a)：返回参数的绝对值。
• ceil(double a)：返回大于等于参数的最小整数。
• floor(double a)：返回小于等于参数的最大整数。
• round(float a)：将参数四舍五入为最接近的整数。
• max(int a, int b)：返回两个参数中的较大值。
• min(int a, int b)：返回两个参数中的较小值。
• sqrt(double a)：返回参数的平方根。
• pow(double a, double b)：返回第一个参数的第二个参数次方。
• sin(double a)：返回参数的正弦值（参数是以弧度表示的角度）。
• cos(double a)：返回参数的余弦值（参数是以弧度表示的角度）。
• tan(double a)：返回参数的正切值（参数是以弧度表示的角度）。
• random()：返回一个介于0.0（包含）和1.0（不包含）之间的随机浮点数。