如何对【javaSE】语法阶段复习

爱被打了一巴掌 2024-03-30 14:37 23阅读 0赞

> #### 下面是我对学习java阶段的总复习，我愿称之为【复习宝典】 ####
> 
> #### 如果你对java的部分语法阶段的知识有所困惑，进来看看吧！ ####

## 文章目录 ##

*  **目录**
    
    文章目录
    
    一、初始java
    
    1.1java 的由来
    
    1.2JDK安装
    
    1.3main方法的介绍
    
    二、数据类型和变量
    
    2.1数据类型
    
    三、运算符与逻辑控制
    
    3.1什么是运算符
    
    3.2逻辑控制
    
    3.2.1顺序结构
    
    3.2.2分支结构
    
    1.if语句
    
    2.switch语句
    
    3.2.3循环结构
    
    1.while循环
    
    2.break
    
    3.continue
    
    4.for循环
    
    3.2.4输入输出
    
    1.输出到控制台
    
    2.从键盘输入
    
    四、方法
    
    4.1方法重载
    
    4.2方法重写
    
    4.3递归
    
    五、java中的数组
    
    5.1数组概念
    
    5.2数组的创建
    
    5.3遍历数组
    
    5.3.1循环打印
    
    5.3.2使用for-each 遍历数组
    
    5.4数组作为参数和返回值
    
    5.4.1参数传数组类型(引用数据类型)
    
    5.4.2作为函数的返回值
    
    5.5二维数组使用
    
    六、类和对象
    
    七、继承和多态
    
    八、抽象类和接口
    
    8.1抽象类概念及语法
    
    8.2抽象类特征
    
    8.3抽象类的作用
    
    8.4接口
    
    8.4.1接口概念及语法规则
    
    8.4.2接口使用
    
    8.4.3接口特性
    
    8.4.4接口还可以实现多个接口
    
    注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。
    
    8.4.5接口间的继承
    
    8.4.6Clonable接口和深拷贝
    
    8.4.6接口和抽象类的核心区别
    
    九、String类如何使用

9.1String常用的构造方法

9.2String对象的比较

9.3字符串查找

9.4字符串的不可变性

9.5StringBuilder和StringBuffer

9.6面试题

--------------------

## 一、初始java ##

### 1.1java 的由来 ###

> 下图数据来自于TIOBE编程语言社区2017年12月和2018年10月最新的排行榜，常年占据语言排行榜榜首，是近些年最火的编程语言之一。
> 
> 注意：上述排名不能说明那个语言好，那个语言不好，每门编程语言都有适应自己的应用场景。

![80af2684fecd44998bfb1cb014bedfdc.png][]

> Java 语言源于 1991 年 4 月，Sun 公司 James Gosling博士 领导的绿色计划(Green Project) 开始启动，此计划最初的目标是开发一种能够在各种消费性电子产品(如机顶盒、冰箱、收音机等)上运行的程序架构。这个就是Java的前身： Oak (得名与Java创始人James Gosling办公室外的一棵橡树)，但由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1995年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布，并提出“Write once, Run anywhere" 的口号。

## ![2ef7282f52ce46059293673bed12679c.png][] ##

### 1.2JDK安装 ###

> 注意：需要配置环境变量
> 
> 1.  java\_home
> 2.  path

### 1.3main方法的介绍 ###

>     public class HelloWorld{
>     public static void main(String[] args){
>     System.out.println("Hello,world");
>     }
>     }
> 
> Java程序的结构由如下三个部分组成：
> 
> 1.源文件（扩展名为\*.java)：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个类。类的内容必须包含在花括号里面。  
> 2.类：类中带有一个或多个方法。方法必须在类的内部声明。  
> 3.方法：在方法的花括号中编写方法应该执行的语句。  
> 总结一下：类存在于源文件里面；方法存在于类中；语句存在于方法中。
> 
> 注意：在一个源文件中只能有一个public修饰的类，而且源文件名字必须与public修饰的类名字相同。

> javac 编译程序把源文件进行编译，生成字节码文件
> 
> java 运行字节码文件

## ![071a62470e8f44e68d71a1047801e3c0.png][] ##

>  【面试题】JDK、JRE、JVM之间的关系？
> 
>  *  JDK(Java Development Kit):Java开发工具包，提供给Java程序员使用，包含了JRE，同时还包含了编译器javac与自带的调试工具Jconsole、jstack等。
>  *  JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程序运行的所需环境。
>  *  JVM：Java虚拟机，运行Java代码

## ![3d5ae2cda4034520a3252d53da4712d6.png][] ##

## 二、数据类型和变量 ##

### 2.1数据类型 ###

> 数据类型分为：
> 
> 基本数据类型：四类：整型、浮点型、字符型以及布尔型
> 
> byte,short,int,long,float,double,char,boolean
> 
> 注意：  
> 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节  
> 整形和浮点型都是带有符号的  
> 整型默认为int型，浮点型默认为double
> 
> 引用数据类型：
> 
> 数组，类，接口，抽象类，自定义的类型

## 三、运算符与逻辑控制 ##

### 3.1什么是运算符 ###

> 作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。Java中运算符可分为以下：算术运算符(+ - \*/)、关系运算符(< > ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等

其中无符号右移要特殊记住，下面我举个例子：

无符号右移 >>>: 最右侧位不要了, 最左侧补 0

int a = 0xffffffff;
    System.out.printf("%x\n", a >>> 1);
    
    // 运行结果(注意, 是按十六进制打印的)
    7fffffff

短路求值  
&& 和 || 遵守短路求值的规则，&& 和 || 左右必须都是布尔表达式

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
    System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
    对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
    对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式

### 3.2逻辑控制 ###

> **1.顺序结构**
> 
> **2.分支结构**
> 
> **3.循环结构**
> 
> **4.输入输出**

#### 3.2.1顺序结构 ####

System.out.println("aaa");
    System.out.println("bbb");
    System.out.println("ccc");
    // 运行结果
    aaa
    bbb
    ccc

#### 3.2.2分支结构 ####

#### 1.if语句 ####

int score = 92;
    if(score >= 90){
    System.out.println("吃个大鸡腿!!!");
    }

举例：判断一个月份是否为闰年

int year = 2000;
    if (year % 100 == 0) {
    // 判定世纪闰年
    if (year % 400 == 0) {
    System.out.println("是闰年");
    } else {
    System.out.println("不是闰年");
    }
    } else {
    // 普通闰年
    if (year % 4 == 0) {
    System.out.println("是闰年");
    } else {
    System.out.println("不是闰年");
    }
    }

#### 2.switch语句 ####

switch(表达式){
    case 常量值1:{
    语句1;
    [break;]
    }
    case 常量值2:{
    语句2;
    [break;]
    }
    ...
    default:{
    内容都不满足时执行语句;
    [break;]
    }
    }

> 执行流程：  
> 1. 先计算表达式的值  
> 2. 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束  
> 3. 当表达式的值没有与所列项匹配时，执行default

举例：根据 day 的值输出星期

int day = 1;
    switch(day) {
    case 1:
    System.out.println("星期一");
    break;
    case 2:
    System.out.println("星期二");
    break;
    case 3:
    System.out.println("星期三");
    break;
    case 4:
    System.out.println("星期四");
    break;
    case 5:
    System.out.println("星期五");
    break;
    case 6:
    System.out.println("星期六");
    break;
    case 7:
    System.out.println("星期日");
    break;
    default:
    System.out.println("输入有误");
    break;
    }

> 【注意事项】
> 
>  *  多个case后的常量值不可以重复
>  *  switch的括号内只能是以下类型的表达式：
>  *  基本类型：byte、char、short、int，注意不能是long类型
>  *  引用类型：String常量串、枚举类型

#### 3.2.3循环结构 ####

#### 1.while循环 ####

while(循环条件){
    循环语句;
    }

举例：计算 1! + 2! + 3! + 4! + 5！

int num = 1;
    int sum = 0;
    // 外层循环负责求阶乘的和
    while (num <= 5) {
    int factorResult = 1;
    int tmp = 1;
    // 里层循环负责完成求阶乘的细节.
    while (tmp <= num) {
    factorResult *= tmp;
    tmp++;
    }
     sum += factorResult;
    num++;
    }
     System.out.println("sum = " + sum);

#### 2.break ####

> break 的功能是让循环提前结束

**举例：找到 100 - 200 中第一个 3 的倍数**

int num = 100;
    while (num <= 200) {
    if (num % 3 == 0) {
    System.out.println("找到了 3 的倍数, 为:" + num);
    break;
    }
    num++;
    } 
    // 执行结果
    找到了 3 的倍数, 为:102
    
    //执行到 break 就会让循环结束

#### 3.continue ####

> continue 的功能是跳过这次循环, 立即进入下次循环

**举例：找到 100 - 200 中所有 3 的倍数**

int num = 100;
    while (num <= 200) {
    if (num % 3 != 0) {
    num++; // 这里的 ++ 不要忘记! 否则会死循环.
    continue;
    } 
    System.out.println("找到了 3 的倍数, 为:" + num);
    num++;
    }
    
    //执行到 continue 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的打印语句.

#### 4.for循环 ####

for(表达式①;布尔表达式②;表达式③){
    表达式④;
    }

**举例：计算 1! + 2! + 3! + 4! + 5!**

int sum = 0;
    for (int i = 1; i <= 5; i++) {
    int tmp = 1;
    for (int j = 1; j <= i; j++) {
    tmp *= j;
    } 
    sum += tmp;
    } 
    System.out.println("sum = " + sum);

#### 3.2.4输入输出 ####

#### 1.输出到控制台 ####

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

#### 2.从键盘输入 ####

使用 Scanner 读取字符串/整数/浮点数

举例：使用 Scanner 循环读取 N 个数字，并求取其平均值

Scanner sc = new Scanner(System.in);
    int sum = 0;
    int num = 0;
    while (sc.hasNextInt()) {
    int tmp = sc.nextInt();
    sum += tmp;
    num++;
    }
    System.out.println("sum = " + sum);
    System.out.println("avg = " + sum / num);
    sc.close();
    // 执行结果
    10
    40.0
    50.5
    
    sum = 150.5
    avg = 30.1

> **注意事项: 当循环输入多个数据的时候, 使用 ctrl + z 来结束输入 (Windows 上使用 ctrl + z, Linux / Mac 上使用 ctrl+ d)**

## 四、方法 ##

> 简单来说，在java中把函数叫做方法，完成某个功能，模块化的组织代码

### 4.1方法重载 ###

> 在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

public class TestMethod {
    public static void main(String[] args) {
    add(1, 2); // 调用add(int, int)
    add(1.5, 2.5); // 调用add(double, double)
    add(1.5, 2.5, 3.5); // 调用add(double, double, double)
    }
    public static int add(int x, int y) {
    return x + y;
    }
    public static double add(double x, double y) {
    return x + y;
    }
    public static double add(double x, double y, double z) {
    return x + y + z;
    }
    }

> **注意：  
> 1. 方法名必须相同  
> 2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)  
> 3. 与返回值类型是否相同无关**

### 4.2方法重写 ###

> 重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

![8a3ee058a4d445bfa352856be6657e84.png][]

![46a7b0e75475468aaa18f42864beb623.png][]

举例：画图型

class Shape {
    //属性....
    public void draw() {
    System.out.println("画图形！");
    }
    }
    class Rect extends Shape{
    @Override
    public void draw() {
    System.out.println("♦");
    }
    }
    class Cycle extends Shape{
    @Override
    public void draw() {
    System.out.println("●");
    }
    }
    class Flower extends Shape{
    @Override
    public void draw() {
    System.out.println("❀");
    }
    }

### 4.3递归 ###

> 一个方法在执行过程中调用自身, 就称为 "递归".  
> 递归相当于数学上的 "数学归纳法", 有一个起始条件, 然后有一个递推公式.
> 
> **递归的必要条件：  
> 1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同  
> 2. 递归出口**

举例：递归求 N 的阶乘

public static void main(String[] args) {
    int n = 5;
    int ret = factor(n);
    System.out.println("ret = " + ret);
    }
    public static int factor(int n) {
    if (n == 1) {
    return 1;
    } 
    return n * factor(n - 1); // factor 调用函数自身
    } /
    / 执行结果
    ret = 120

执行过程图如下：

![a7a9950aed9846e1bda8c072d691b0fd.png][]

## 五、java中的数组 ##

### 5.1数组概念 ###

> 数组在java中是引用类型，数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

### 5.2数组的创建 ###

int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
    double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
    String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组

### 5.3遍历数组 ###

int[]array = new int[]{10, 20, 30, 40, 50};
    System.out.println(array[0]);
    System.out.println(array[1]);
    System.out.println(array[2]);
    System.out.println(array[3]);
    System.out.println(array[4]);

#### 通过观察代码可以发现，对数组中每个元素的操作都是相同的，则可以使用循环来进行打印。   5.3.1循环打印 ####

int[]array = new int[]{10, 20, 30, 40, 50};
    for(int i = 0; i < 5; i++){
    System.out.println(array[i]);
    }

#### 5.3.2使用for-each 遍历数组 ####

int[] array = {1, 2, 3};
    for (int x : array) {
    System.out.println(x);
    }

### 5.4数组作为参数和返回值 ###

#### 5.4.1参数传数组类型(引用数据类型) ####

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    func(arr);
    System.out.println("arr[0] = " + arr[0]);
    }
    public static void func(int[] a) {
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
    } 
    // 执行结果
    a[0] = 10
    arr[0] = 10

#### 5.4.2作为函数的返回值 ####

比如：获取斐波那契数列的前N项

public class TestArray {
    public static int[] fib(int n){
    if(n <= 0){
    return null;
    } 
    int[] array = new int[n];
    array[0] = array[1] = 1;
    for(int i = 2; i < n; ++i){
    array[i] = array[i-1] + array[i-2];
    } 
    return array;
    }
    public static void main(String[] args) {
    int[] array = fib(10);
    for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
      }
     }
    }

### 5.5二维数组使用 ###

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

int[][] arr = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
    };
    for (int row = 0; row < arr.length; row++) {
    for (int col = 0; col < arr[row].length; col++) {
    System.out.printf("%d\t", arr[row][col]);
    } 
    System.out.println("");
    }
    // 执行结果
    1 2 3 4
    5 6 7 8
    9 10 11 12

## 六、类和对象 ##

> 请大家看这篇详细文章
> 
> [http://t.csdn.cn/vu3fr][http_t.csdn.cn_vu3fr]

## 七、继承和多态 ##

> [http://t.csdn.cn/RcS56][http_t.csdn.cn_RcS56]请大家看这篇详细文章
> 
> [http://t.csdn.cn/RcS56][http_t.csdn.cn_RcS56]

## 八、抽象类和接口 ##

### 8.1抽象类概念及语法 ###

> 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。
    
    // 抽象类：被abstract修饰的类
    public abstract class Shape {
    // 抽象方法：被abstract修饰的方法，没有方法体
    abstract public void draw();
    abstract void calcArea();
    // 抽象类也是类，也可以增加普通方法和属性
    public double getArea(){
    return area;
    }
    protected double area; // 面积
    }

> 注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

### 8.2抽象类特征 ###

> 1. 抽象类不能直接实例化对象  
> 2. 抽象方法不能是 private 的  
> 3. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写  
> 4. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰  
> 5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类  
> 6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

### 8.3抽象类的作用 ###

> 使用抽象类相当于多了一重编译器的校验。很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.充分利用编译器的校验, 在实际开发中是非常有意义的。

### 8.4接口 ###

#### 8.4.1接口概念及语法规则 ####

> 在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型

接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

public interface 接口名称{
    // 抽象方法
    public abstract void method1(); // public abstract 是固定搭配，可以不写
    public void method2();
    abstract void method3();
    void method4();
    }

#### 8.4.2接口使用 ####

> **接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。**

举例：请实现笔记本电脑使用USB鼠标、USB键盘的例子

// USB接口
    public interface USB {
    void openDevice();
    void closeDevice();
    } 
    // 鼠标类，实现USB接口
    public class Mouse implements USB {
    @Override
    public void openDevice() {
    System.out.println("打开鼠标");
    }
    @Override
    public void closeDevice() {
    System.out.println("关闭鼠标");
    }
    public void click(){
    System.out.println("鼠标点击");
    }
    } 
    // 键盘类，实现USB接口
    public class KeyBoard implements USB {
    @Override
    public void openDevice() {
    System.out.println("打开键盘");
    } 
    @Override
    public void closeDevice() {
    System.out.println("关闭键盘");
    }
    public void inPut(){
    System.out.println("键盘输入");
    }
    } 
    // 笔记本类：使用USB设备
    public class Computer {
    public void powerOn(){
    System.out.println("打开笔记本电脑");
    }
    public void powerOff(){
    System.out.println("关闭笔记本电脑");
    }
    public void useDevice(USB usb){
    usb.openDevice();
    if(usb instanceof Mouse){
    Mouse mouse = (Mouse)usb;
    mouse.click();
    }else if(usb instanceof KeyBoard){
    KeyBoard keyBoard = (KeyBoard)usb;
    keyBoard.inPut();
    } 
    usb.closeDevice();
    }
    } 
    // 测试类：
    public class TestUSB {
    public static void main(String[] args) {
    Computer computer = new Computer();
    computer.powerOn();
    // 使用鼠标设备
    computer.useDevice(new Mouse());
    // 使用键盘设备
    computer.useDevice(new KeyBoard());
    computer.powerOff();
    }
    }

#### 8.4.3接口特性 ####

> **1. 接口类型是一种引用类型，但是不能直接new接口的对象  
> 2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错）**
> 
> **3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现  
> 4. 重写接口中方法时，不能使用默认的访问权限  
> 5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量  
> 6. 接口中不能有静态代码块和构造方法  
> 7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class  
> 8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类  
> 9. jdk8中：接口中还可以包含default方法。**

#### 8.4.4接口还可以实现多个接口 ####

class Duck extends Animal implements IRunning, ISwimming, IFlying {
    public Duck(String name) {
    super(name);
    } 
    @Override
    public void fly() {
    System.out.println(this.name + "正在用翅膀飞");
    } 
    @Override
    public void run() {
    System.out.println(this.name + "正在用两条腿跑");
    }
    @Override
    public void swim() {
    System.out.println(this.name + "正在漂在水上");
    }
    }

> #### 注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。 ####

#### 8.4.5接口间的继承 ####

> **接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。**

interface IRunning {
    void run();
    } in
    terface ISwimming {
    void swim();
    }
    // 两栖的动物, 既能跑, 也能游
    interface IAmphibious extends IRunning, ISwimming {
    }

#### 8.4.6Clonable接口和深拷贝 ####

> **Java 中内置了一些很有用的接口, Clonable 就是其中之一。  
> Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常。**

class Animal implements Cloneable {
    private String name;
    @Override
    public Animal clone() {
    Animal o = null;
    try {
    o = (Animal)super.clone();
    } catch (CloneNotSupportedException e) {
    e.printStackTrace();
    } 
    return o;
    }
    }
    public class Test {
    public static void main(String[] args) {
    Animal animal = new Animal();
    Animal animal2 = animal.clone();
    System.out.println(animal == animal2);
    }
    } 
    // 输出结果
    // false

> Cloneable 拷贝出的对象是一份 "浅拷贝“

#### 8.4.6接口和抽象类的核心区别 ####

> **抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! 常见面试题).**  
> **核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。**
> 
> class Animal \{  
> protected String name;  
> public Animal(String name) \{  
> this.name = name;  
> \}  
> \}
> 
> **再次提醒:  
> 抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.**

![c9176c00f6cd41f69851853f472c282b.png][]

## 九、String类如何使用 ##

### 9.1String常用的构造方法 ###

> String类提供的构造方式非常多，常用的就以下三种：

public static void main(String[] args) {
    // 使用常量串构造
    String s1 = "hello bit";
    System.out.println(s1);
    // 直接newString对象
    String s2 = new String("hello bit");
    System.out.println(s1);
    // 使用字符数组进行构造
    char[] array = {'h','e','l','l','o','b','i','t'};
    String s3 = new String(array);
    System.out.println(s1);
    }

> **【注意】**  
> **1. String是引用类型，内部并不存储字符串本身**  
> ![9af4b1b1d20840b3a385c65789518619.png][]
> 
>  **2. 在Java中“”引起来的也是String类型对象**
> 
> // 打印"hello"字符串(String对象)的长度  
> System.out.println("hello".length());

### 9.2String对象的比较 ###

> 1. ==比较是否引用同一个对象
> 
> 注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int c = 10;
    // 对于基本类型变量，==比较两个变量中存储的值是否相同
    System.out.println(a == b); // false
    System.out.println(a == c); // true
    // 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
    String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("world");
    String s4 = s1;
    System.out.println(s1 == s2); // false
    System.out.println(s2 == s3); // false
    System.out.println(s1 == s4); // true
    }

> 2. boolean equals(Object anObject) 方法：按照字典序比较  
> 字典序：字符大小的顺序  
> String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照如下规则进行比较，比如： s1.equals(s2)

**重写equals**

public boolean equals(Object anObject) {
    // 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
    if (this == anObject) {
    return true;
    }
    // 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
    if (anObject instanceof String) {
    // 将anObject向下转型为String类型对象
    String anotherString = (String)anObject;
    int n = value.length;
    // 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
    if (n == anotherString.value.length) {
    char v1[] = value;
    char v2[] = anotherString.value;
    int i = 0;
    // 4. 按照字典序，从前往后逐个字符进行比较
    while (n-- != 0) {
    if (v1[i] != v2[i])
    return false;
    i++;
    }
    return true;
    }
    } 
    return false;
    }
    
    public static void main(String[] args) {
    String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("Hello");
    // s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
    System.out.println(s1 == s2); // false
    System.out.println(s1 == s3); // false
    // equals比较：String对象中的逐个字符
    // 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
    // s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
    System.out.println(s1.equals(s2)); // true
    System.out.println(s1.equals(s3)); // false

> 3. int compareTo(String s) 方法: 按照字典序进行比较  
> 与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：  
> 1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值  
> 2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

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)); // 相同输出 0
    System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
    }

> 4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

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)); // 不同输出字符差值-1
    System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
    System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
    }

### 9.3字符串查找 ###

> 字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> 
    <table> 
     <tbody> 
      <tr> 
       <td>方法</td> 
       <td>功能</td> 
      </tr> 
      <tr> 
       <td>char charAt(int index)</td> 
       <td>返回index位置上字符，如果index为负数或者越界，抛出<br> IndexOutOfBoundsException异常</td> 
      </tr> 
      <tr> 
       <td>int indexOf(int ch)</td> 
       <td>返回ch第一次出现的位置，没有返回-1</td> 
      </tr> 
      <tr> 
       <td>int indexOf(int ch, int<br> fromIndex)</td> 
       <td>从fromIndex位置开始找ch第一次出现的位置，没有返回-1</td> 
      </tr> 
      <tr> 
       <td>int indexOf(String str)</td> 
       <td>返回str第一次出现的位置，没有返回-1</td> 
      </tr> 
      <tr> 
       <td>int indexOf(String str, int<br> fromIndex)</td> 
       <td>从fromIndex位置开始找str第一次出现的位置，没有返回-1</td> 
      </tr> 
      <tr> 
       <td>int lastIndexOf(int ch)</td> 
       <td>从后往前找，返回ch第一次出现的位置，没有返回-1</td> 
      </tr> 
      <tr> 
       <td>int lastIndexOf(int ch, int<br> fromIndex)</td> 
       <td>从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返<br> 回-1</td> 
      </tr> 
      <tr> 
       <td>int lastIndexOf(String str)</td> 
       <td>从后往前找，返回str第一次出现的位置，没有返回-1</td> 
      </tr> 
      <tr> 
       <td>int lastIndexOf(String str, int<br> fromIndex)</td> 
       <td>从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返<br> 回-1</td> 
      </tr> 
     </tbody> 
    </table><br> &nbsp;</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
    String s = "aaabbbcccaaabbbccc";
    System.out.println(s.charAt(3)); // 'b'
    System.out.println(s.indexOf('c')); // 6
    System.out.println(s.indexOf('c', 10)); // 15
    System.out.println(s.indexOf("bbb")); // 3
    System.out.println(s.indexOf("bbb", 10)); // 12
    System.out.println(s.lastIndexOf('c')); // 17
    System.out.println(s.lastIndexOf('c', 10)); // 8
    System.out.println(s.lastIndexOf("bbb")); // 12
    System.out.println(s.lastIndexOf("bbb", 10)); // 3

### 9.4字符串的不可变性 ###

> String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：  
> **1. String类在设计时就是不可改变的，String类实现描述中已经说明了**  
> ![d3cf1753c0934ee8b935a5a67aefd6ff.png][]
> 
> String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：
> 
>  *   String类被final修饰，表明该类不能被继承
>  *   value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。
> 
> **2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象**  
> ![f4eed8db2d2d4a74b3fb3c3177f509ee.png][]

> **注意：final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。**

public static void main(String[] args) {
    final int array[] = {1,2,3,4,5};
    array[0] = 100;
    System.out.println(Arrays.toString(array));
    // array = new int[]{4,5,6}; // 编译报错：Error:(19, 9) java: 无法为最终变量array分配值
    }

### 9.5StringBuilder和StringBuffer ###

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> 
    <table> 
     <tbody> 
      <tr> 
       <td>方法</td> 
       <td>说明</td> 
      </tr> 
      <tr> 
       <td>StringBuff append(String<br> str)</td> 
       <td>在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、<br> double、float、int、long、Object、String、StringBuff的变量</td> 
      </tr> 
      <tr> 
       <td>char charAt(int index)</td> 
       <td>获取index位置的字符</td> 
      </tr> 
      <tr> 
       <td>int length()</td> 
       <td>获取字符串的长度</td> 
      </tr> 
      <tr> 
       <td>int capacity()</td> 
       <td>获取底层保存字符串空间总的大小</td> 
      </tr> 
      <tr> 
       <td>void ensureCapacity(int<br> mininmumCapacity)</td> 
       <td>扩容</td> 
      </tr> 
      <tr> 
       <td>void setCharAt(int index,<br> char ch)</td> 
       <td>将index位置的字符设置为ch</td> 
      </tr> 
      <tr> 
       <td>int indexOf(String str)</td> 
       <td>返回str第一次出现的位置</td> 
      </tr> 
      <tr> 
       <td>int indexOf(String str, int<br> fromIndex)</td> 
       <td>从fromIndex位置开始查找str第一次出现的位置</td> 
      </tr> 
      <tr> 
       <td>int lastIndexOf(String str)</td> 
       <td>返回最后一次出现str的位置</td> 
      </tr> 
      <tr> 
       <td>int lastIndexOf(String str,<br> int fromIndex)</td> 
       <td>从fromIndex位置开始找str最后一次出现的位置</td> 
      </tr> 
      <tr> 
       <td>StringBuff insert(int<br> offset, String str)</td> 
       <td>在offset位置插入：八种基类类型 &amp; String类型 &amp; Object类型数据</td> 
      </tr> 
      <tr> 
       <td>StringBuffer<br> deleteCharAt(int index)</td> 
       <td>删除index位置字符</td> 
      </tr> 
      <tr> 
       <td>StringBuffer delete(int<br> start, int end)</td> 
       <td>删除[start, end)区间内的字符</td> 
      </tr> 
      <tr> 
       <td>StringBuffer replace(int<br> start, int end, String str)</td> 
       <td>将[start, end)位置的字符替换为str</td> 
      </tr> 
      <tr> 
       <td>String substring(int start)</td> 
       <td>从start开始一直到末尾的字符以String的方式返回</td> 
      </tr> 
      <tr> 
       <td>String substring(int<br> start，int end)</td> 
       <td>将[start, end)范围内的字符以String的方式返回</td> 
      </tr> 
      <tr> 
       <td>StringBuffer reverse()</td> 
       <td>反转字符串</td> 
      </tr> 
      <tr> 
       <td>String toString()</td> 
       <td>将所有字符按照String的方式返回</td> 
      </tr> 
     </tbody> 
    </table><p></p> </td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
    StringBuilder sb1 = new StringBuilder("hello");
    StringBuilder sb2 = sb1;
    // 追加：即尾插-->字符、字符串、整形数字
    sb1.append(' '); // hello
    sb1.append("world"); // hello world
    sb1.append(123); // hello world123
    System.out.println(sb1); // hello world123
    System.out.println(sb1 == sb2); // true
    System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
    System.out.println(sb1.length()); // 获取字符串的有效长度14
    System.out.println(sb1.capacity()); // 获取底层数组的总大小
    sb1.setCharAt(0, 'H'); // 设置任意位置的字符 Hello world123
    sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
    System.out.println(sb1);
    System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
    System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
    sb1.deleteCharAt(0); // 删除首字符
    sb1.delete(0,5); // 删除[0, 5)范围内的字符
    String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
    System.out.println(str);
    sb1.reverse(); // 字符串逆转
    str = sb1.toString(); // 将StringBuffer以String的方式返回
    System.out.println(str);
    }

> **从上述例子可以看出：String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder。**  
> **注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:  
> String变为StringBuilder: 利用StringBuilder的构造方法或append()方法  
> StringBuilder变为String: 调用toString()方法**

### 9.6面试题 ###

> **1. String、StringBuffer、StringBuilder的区别**
> 
>  *  String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
>  *  StringBuffer与StringBuilder大部分功能是相似的
>  *  StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作
> 
> **2. 以下总共创建了多少个String对象【前提不考虑常量池之前是否存在】**
> 
> String str = new String("ab"); // 会创建多少个对象  
> String str = new String("a") + new String("b"); // 会创建多少个对象

[80af2684fecd44998bfb1cb014bedfdc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4a13d7d597cb4004a9f1df56100c3176.png
[2ef7282f52ce46059293673bed12679c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4183ea081f9044afa2d259fdc271efbd.png
[071a62470e8f44e68d71a1047801e3c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c8a37843a9a845a488b07a72e2175b06.png
[3d5ae2cda4034520a3252d53da4712d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e82d3800b77c40188932d756e047c150.png
[8a3ee058a4d445bfa352856be6657e84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/fdbf68a50492471dbe1bf520490674d3.png
[46a7b0e75475468aaa18f42864beb623.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/633c3ef0153243c5887e3a6af6c855b7.png
[a7a9950aed9846e1bda8c072d691b0fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9f059d5435ff40249538cb5a996ad670.png
[http_t.csdn.cn_vu3fr]: http://t.csdn.cn/vu3fr
[http_t.csdn.cn_RcS56]: http://t.csdn.cn/RcS56
[c9176c00f6cd41f69851853f472c282b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/70605e7d13f348ab904c2994929c442c.png
[9af4b1b1d20840b3a385c65789518619.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/08c63baf285945909874d4b47700261f.png
[d3cf1753c0934ee8b935a5a67aefd6ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/826719274b2448fb811e40e3eac684d6.png
[f4eed8db2d2d4a74b3fb3c3177f509ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e67203abbd794494ba389e1dbc8baaa5.png