Java（知识总结）-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_61941522/article/details/143573952

Java基础知识：

一、初始Java入门

1、JDK、JRE、JVM之间的关系？

JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程序运行的所需环境。注：运行一个已有的Java程序，那么只需安装JRE即可
JDK(Java Development Kit):Java开发工具包，提供给Java程序员使用，，同时还包含了编译器(javac.exe)与自带的调试运行工具(java.exe)。注：需要开发一个全新的java程序，那么必须安装JDK。
JVM：Java虚拟机，运行Java代码（能保证Java程序跨平台运行）

2、Java编译和运行：
使用命令行或集成开发环境(IDE)编译和运行Java程序。

代码编写完成后 java.class 编辑-编译-运行在jvm虚拟机上

三个步骤：编写编程、编译程序、运行程序

3、java第一个程序"Hello World"

public class Hello World{
        public static void main(String[] args){ //这是main方法 代码执行从main方法开始
            System.out.println("Hello World"); //这是输出语句
            }
}

Java程序中最基本的组成单位是类。

类的定义格式:
    public class 类名{

    }

二、Java变成基础
1、注释

//单行注释
/* 多行显示注释*/  $以/*开始,*/结束；

2、关键字

3、标识符
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。关于 Java 标识符，有以下几点需要注意：
所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary
变量名的密码规范：首字母和小写和驼峰原则 monthSalary
4、修饰符
像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：
访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized
5、变量

//数据类型 变量名=值；
——————————————————————

int i；//声明一个变量
i=0;//赋值变量

类变量、实例变量、局部变量

public class Variable{
static int allClicks=0;//类变量
String str="hello world";//实例变量

    public void method(){
                int i=0;//局部变量
}
}

6、常量

//声明一个常量
final 数据类型 常量名=值；
————————————————————
final double PI=3.14；  //赋值一次不能被更改

常量一旦初始化被赋值就不允许改变。

final关键字
7、运算符
三、Java流程控制
1、用户交互
Sacnner类获取用户的输入
Scanner类在java.util包下，通过nextByte()
nextShort()、nextInt()、netxLong()、nextFloat()、nextDouble()获取用户输入的基本数据类型

import java.util.Sacnner;//导入Scanner包
Scanner scanner=new Sacnner(System.in);//创建Scanner类获取用户的输入
int i=scanner.nextInt();//变量i接收获取用户的输入整数

2、选择结构
if选择结构

if单选择结构
if（条件表达式）{
如果条件表达式为true将执行语句
}

if双选择结构
if（条件表达式）{
如果条件表达式为true将执行语句
}else{
如果条件表达式为false将执行语句
}

{}//代码块

//if多选结构
if(条件表达式){
}else if(条件表达式){
else{
}

例60-80为合格 80-90良好 90以上为优秀

if(i>90)
{System.out.println("优秀");}
else if(i>80)
{System.out.println("良好");}
else
{System.out.println("合格");}

switch（条件表达式）{
case value：
//语句
break；//可选
case value：
//语句
break；//可选
default：//可选
//语句


}

public class Main {
    public static void main(String[] args) {
       char grade='C';
       switch(grade){
           case 'A':
               System.out.println("优秀");
               break;
           case 'B':
               System.out.println("良好");
               break;
           case 'C':
               System.out.println("合格");
               break;
           case 'D':
               System.out.println("不合格");
               break;
           default:
               System.out.println("暂无");
       }
    }

}//输出了合格

swith选择结构
swith匹配语句后执行case匹配的语句，若都没有匹配执行default语句；
注（case穿透）：case后不带break情况下会在匹配后把case后面下一条的case语句一起输出，除非下一条case语句带break否则将会一直执行输出后面的case语句直到遇到break或者default
3、循环结构
while循环
只要布尔表达式为真，循环就一直执行下去

while(布尔表达式)//只要表达式为真就会一直执行下去
{//循环内容
}
——————————————————————
int i=0;
while(i<100)
{i++;
System.out.printlf(i);} //输出1-100

do...while循环
与while循环会相似，但do...while至少会执行一次
while和do...while的区别：while是先判定后执行，do...while是先至少执行一次后判断，后续根据判断决定是否执行下去

do{
//语句
}
while(布尔表达式);
————————————————————
题目计算1到100相加等于多少

int i=0;
int sum=0;

do{
sum=sum+i;
i++;}
while(i<=100)

for循环
for循环执行次数是在执行前就确定的语法结构如下

for(初始化；布尔表达式；更新){
语句}


————————————
九九乘法表
public class jiu {

    public static void main(String[] args) {
        for(int i=1;i<=9;i++) {
            for(int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+(i*j)+"\t");}
        }
        System.out.println();
    }
}

4、break&continue（return）
break：直接强行跳出当前循环，不再执行剩余部分。当循环中遇到break语句时，忽略循环体中任何其他语句和循环条件测试，程序控制在循环后面语句重新开始。所以，当多层循环嵌套，break语句出现在嵌套循环中的内层循环，它将仅仅只是终止了内层循环的执行，而不影响外层循环的执行。

continue：停止当次循环，回到循环起始处，进入下一次循环操作。continue语句之后的语句将不再执行，用于跳过循环体中的一部分语句，也就是不执行这部分语句，而不是跳出整个循环执行下一条语句，这就是continue与break的主要区别。简单地说，continue只是中断一次循环的执行而已。

return：return语句是一个跳转语句，用来表示从一个方法返回（返回一个值或其他复杂类型），可以使程序控制返回到调用它方法的地方。当执行main方法时，return语句可以使程序执行返回到Java运行系统。
四、Java方法
1.什么是方法
方法（在有些编程语言中也叫函数）是一段用来完成特定功能的代码块，它可以接收输入参数（也可以没有参数），执行一系列操作后，可以返回一个结果（也可以没有返回值）。通过使用方法可以提高代码的复用性和可维护性。

2.2 方法的调用

public class MethodDemo {
    public static void main(String[] args) {
        // 调用add方法，并将返回结果赋值给result变量
        int result = add(5, 3);
        System.out.println("两数之和为: " + result);

        printMessage("Hello, World!");
    }

    // 声明一个有返回值的方法，接收两个整数参数，返回它们的和
    public static int add(int num1, int num2) {
        return num1 + num2;
    }

    // 声明一个无返回值（返回类型为void）的方法，用于打印消息
    public static void printMessage(String message) {
        System.out.println(message);
    }
}

3.方法的重载

public class MethodOverloadingDemo {
    public static void main(String[] args) {
        int sum1 = add(3, 5);
        System.out.println("整数相加结果: " + sum1);

        double sum2 = add(3.5, 2.5);
        System.out.println("浮点数相加结果: " + sum2);

        int sum3 = add(2, 3, 4);
        System.out.println("三个整数相加结果: " + sum3);
    }

    // 两个整数相加的方法重载版本
    public static int add(int num1, int num2) {
        return num1 + num2;
    }

    // 两个浮点数相加的方法重载版本
    public static double add(double num1, double num2) {
        return num1 + num2;
    }

    // 三个整数相加的方法重载版本
    public static int add(int num1, int num2, int num3) {
        return num1 + num2 + num3;
    }
}

4.方法的递归

public class RecursionDemo {
    public static void main(String[] args) {
        int n = 5;
        System.out.println(n + " 的阶乘是: " + factorial(n));
    }

    public static int factorial(int n) {
        if (n == 0) {
            // 终止条件，0的阶乘定义为1
            return 1;
        }
        // 递归调用，n的阶乘等于n乘以(n-1)的阶乘
        return n * factorial(n - 1);
    }
}

五、数组
1. 数组的概述

数组是一种用于存储多个相同类型数据的数据结构，它在内存中是连续的存储空间。可以通过数组名和索引（下标）来访问数组中的元素，索引从 0 开始，依次递增。例如，定义一个存储整数的数组，就可以用来存放一组整数，方便对这些数据进行统一管理和操作。

2. 数组的常见操作

2.1 数组的声明与初始化
```
// 声明一个整型数组，此时数组还未分配内存空间
int[] array;

// 初始化数组，指定数组长度为5，并分配内存空间，数组元素默认初始化为对应类型的默认值（int类型为0）
array = new int[5];

// 声明并初始化数组的同时赋值
int[] anotherArray = {1, 2, 3, 4, 5};
```
2.2 访问数组元素

int[] numbers = {10, 20, 30, 40, 50};
// 通过索引访问数组元素，输出索引为2的元素（值为30）
System.out.println(numbers[2]);

// 修改数组元素的值
numbers[3] = 45;
System.out.println(numbers[3]);

2.3 获取数组长度

int[] data = {1, 2, 3};
int length = data.length;
System.out.println("数组的长度为: " + length);

3. 数组的排序算法

3.1 冒泡排序（简单实现示例）

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 7};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换元素位置
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

3.2 选择排序（简单实现示例）

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 7};
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; 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;
            }
        }
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

4. 二分查找法

二分查找法要求数组必须是有序的。以下是简单的二分查找实现示例：

public class BinarySearch {
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1; // 表示未找到目标元素
    }

    public static void main(String[] args) {
        int[] sortedArray = {1, 3, 5, 7, 9};
        int target = 5;
        int result = binarySearch(sortedArray, target);
        if (result!= -1) {
            System.out.println("目标元素在数组中的索引为: " + result);
        } else {
            System.out.println("未找到目标元素");
        }
    }
}

二分查找每次比较中间元素与目标元素的大小关系，然后缩小查找区间，直到找到目标元素或者确定目标元素不存在。

5. 方法中可变参数

可变参数允许在方法的参数列表中传入不定数量的同类型参数。在方法内部，可变参数实际上被当作数组来处理。

public class VarArgsDemo {
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }

    public static void main(String[] args) {
        int result1 = sum(1, 2, 3);
        int result2 = sum(4, 5, 6, 7);
        System.out.println("result1: " + result1 + ", result2: " + result2);
    }
}

6. 二维数组

二维数组可以看作是数组的数组，常用于表示表格、矩阵等二维结构的数据

public class TwoDimensionalArray {
    public static void main(String[] args) {
        // 声明并初始化一个二维整型数组，模拟一个3行4列的矩阵
        int[][] matrix = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12}
        };

        // 访问二维数组元素，输出第2行第3列的元素（值为7）
        System.out.println(matrix[1][2]);

        // 遍历二维数组
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

7、JVM中堆内存和栈内存
五、面向对象程序
1、面向对象是什么
面向对象思想
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进
行单独思考。最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。抽象
三大特性：
封装、继承、多态
2、方法的调用
注:static是类一起加载的没有static需要创建对象才能去调用
3、类和对象的创建
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物，动物、植物、手机、电脑.
Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念.
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：
1.必须和类的名字相同
2.必须没有返回类型，也不能写void
4、构造器
一个类即使里面什么都不写，他也会存在一个方法：无参构造

一旦定义了有参构造，无参构造显示定义

5、创建对象内存分析
6、封装
该露的露，该藏的藏
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。记住这句话就够了：属性私有，get/set
7、继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。
子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有"is a"的关系。
在Java中所有的类都默认继承object类
object类
super
方法重写
8、Super详解
子类调用父类的无参构造必须放在子类的无参构造的第一行
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方法！
this注意点:
代表的对象不同：
this:本身调用者这个对象
super:代表父类对象的应用
前提区别super与this
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法
this（）；本类的构造
super（）：父类的构造
9、方法重写

重写都是方法的重写与属性无关

重写：需要有继承关系，子类重写父类的方法！
1．方法名必须相同
2.参数列表列表必须相同
3.修饰符：范围可以扩大但不能缩小：
public>Protected>Default>private
4．抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException--〉Exception(大)
重写，子类的方法和父类必要一致；方法体不同！为什么需要重写：
1．父类的功能，子类不一定需要，或者不一定满足！
10、什么是多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
有继承关系
子类重写父类方法
父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性。 instanceof

//对象能执法的方法 主要看对象左边类型

多态注意事项：
1、多态是方法的多态，属性没有多态
2、父类和子类，有联系类型转换异常！cLassCastException！
3、存在条件：继承关系，方法需要重写，父类引用指向子类对象！
11、static关键字
static方法只执行一次
12、抽象类
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
1、不能new这个抽象类，只能靠子类是去继承它的约束
2、抽象类可以写普通的方法
3、抽象方法必须在抽象类中
13、接口的定义和实现
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法)都有！
接口：只有规范！

声明类的关键字class，声明接口的关键字interface

作用：
1.约束
2.定义一些方法，让不同的人实现

3.public abstract
4.public static final
5.接口不能被实例化~，接口中没有构造方法~
6.implements可以实现多个接口 7.必须要重写接口中的方法~

14、内部类
内部类就是在一个类的内部在定义一个类，
比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类
六、异常
1、异常是什么
实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了。等等。
软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：
Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃
异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。·
异常发生在程序运行期间，它影响了正常的程序执行流程。
2、异常体系结构
Java把异常分为了两大类，错误Erro和Exception
Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
Java虚拟机运行错误（VirtualMachineError），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止;
还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不充许出现的状况。
在Exception分支中有一个重要的子类RuntimeException（运行时异常）

ArraylndexOutOfBoundsException(数组下标越界)
NullPointerException(空指针异常) ArithmeticException (算术异常)
MissingResourceException （丢失资源）
ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；
Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

3、Java异常处理机制
抛出异常
捕获异常
异常处理的五个关键字:try、catch、finally、throw、throws
4、自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定
义异常。用户自定义异常类，只需继承Exception类即可。·在程序中使用自定义异常类，大体可分为以下几个步骤：
1．创建自定义异常类。
2.在方法中通过throw关键字抛出异常对象。
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法
的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
4.在出现异常方法的调用者中捕获并处理异常。
七、Java常用类
一、包装类概述

Java的包装类是为了方便操作基本数据类型而提供的类。Java的基本数据类型（如int、char、boolean等）是非对象的，不能直接参与面向对象的操作，也不能直接调用方法。为了解决这个问题，Java提供了对应的包装类。

Java的包装类分为两种：基本数据类型对应的包装类和常用功能类。

    基本数据类型对应的包装类：Java为每种基本数据类型都定义了一个对应的包装类，用于将基本数据类型转换为对象。这些包装类提供了一些常见的方法，以便于操作基本数据类型的值。
        Integer：对应int类型
        Long：对应long类型
        Short：对应short类型
        Byte：对应byte类型
        Float：对应float类型
        Double：对应double类型
        Character：对应char类型
        Boolean：对应boolean类型

    这些包装类提供了很多有用的方法，如将字符串转换为对应基本数据类型的值、将基本数据类型的值转换为字符串、比较两个对象的值等。

    常用功能类：除了基本数据类型对应的包装类，Java还提供了一些常用的功能类，用于操作基本数据类型的值。
        Math：提供了常见的数学运算方法，如求绝对值、平方根、最大值、最小值等。
        String：虽然String是引用类型，但它也可以看作是对基本数据类型的包装。String类提供了很多有用的方法，如字符串的拼接、截取、替换、转换等。
二、包装类和基本数据类型的转换

包装类和基本数据类型之间的转换主要通过两种方式实现：自动装箱和拆箱。

自动装箱（Autoboxing）：将基本数据类型转换为对应的包装类对象。当我们将一个基本数据类型赋值给对应的包装类对象时，编译器会自动进行装箱操作。
```
    int num = 10;  // 定义一个基本数据类型
    Integer integer = num;  // 自动装箱，将基本数据类型转换为Integer对象
```
自动拆箱（Unboxing）：将包装类对象转换为对应的基本数据类型。当我们将一个包装类对象赋值给一个基本数据类型时，编译器会自动进行拆箱操作。

Integer integer = 20;  // 定义一个Integer对象
int num = integer;  // 自动拆箱，将Integer对象转换为基本数据类型

三、基本类型和包装类的自动转换

在Java中，基本类型和对应的包装类之间可以进行自动转换。这种自动转换称为装箱和拆箱。

装箱（Boxing）指的是将基本类型转换为对应的包装类对象。例如，将int类型转换为Integer类型：
```
int num = 10;
Integer integerObj = num; // 自动装箱
```
拆箱（Unboxing）指的是将包装类对象转换为对应的基本类型。例如，将Integer类型转换为int类型：
```
    Integer integerObj = 10;
    int num = integerObj; // 自动拆箱
```
自动装箱和自动拆箱是Java编译器的功能，它们使得基本类型和包装类之间的转换更加方便。

此外，还存在基本类型和包装类之间的强制类型转换。例如，将Integer类型强制转换为int类型：
需要注意的是，如果进行自动装箱或拆箱时，包装类对象为null，会抛出NullPointerException异常。因此，在进行自动装箱或拆箱时，需要确保包装类对象不为null。
```
Integer integerObj = 10;
int num = (int) integerObj; // 强制类型转换
```
总结来说，基本类型和包装类之间的转换有三种方式：

    自动装箱：将基本类型转换为对应的包装类对象。
    自动拆箱：将包装类对象转换为对应的基本类型。
    强制类型转换：将包装类对象强制转换为基本类型。
四、Sring类
String 类位于 java.lang 包中，无需引入，直接使用即可。

String 类是由 final 修饰的，表示 String 类是一个最终类，不能够被继承。

String 类构建的对象不可再被更改

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

1.String对象的比较
1==比较是否指向同一个引用
对于内置类型，==比较的是变量中的值
对于引用类型，==比较的是引用中存放的地址

2、str1 equals(str2)
判断两个字符串是否相等
这里比较的是value数组的值，则比较的是字符串

3、str1 equalIgnore(str2)
忽略大小写，判断两个字符串是否相等

4、str1 compare(str2)
比较两个字符串谁大谁小
a.先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值（str1 > str2 返回正数）
b.如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

5、str1 compareToIgnoreCase(str2)
忽略大小写，比较两个字符串谁大谁小
2.大小写转换
小写转大写：str1.toUpperCase()
大写转小写：str2.toLowerCase()

public String toLowerCase();//转换为小写
public String toUpperCase();//转换为大写

3.获取字符串长度

public int length(); //获取字符串的长度

4.字符串对比

五、StringBuilder和StringBuffer
StringBuilder 类位于 java.lang 包中，无需引入，直接使用即可。

StringBuilder 类是由 final 修饰的，表示 StringBuilder 是一个最终类，不可能被继承

StringBuilder 类构建的对象，可以实现字符序列的追加，但不会产生新的对象，只是将这个字符序列保存在字符数组中。

public StringBuilder(); //构建一个StringBuilder对象，默认容量为16
public StringBuilder(int capacity);//构建一个StringBuilder对象并指定初始化容量
public StringBuilder(String str); //构建一个StringBuilder对象，并将指定的字符串存
储在其中

六、String、StringBuffer、StringBuilder的区别
1）String的内容不可修改，StringBuffer与StringBuilder的内容可以修改
2）StringBuffer与StringBuilder大部分功能是相似的
3）StringBuffer采用同步处理，属于线程安全操作，该方法中基本都被synchronized修饰，相当于一个锁头，当里面有人时，别人进不去，虽然安全，但是浪费资源，在多线程情况下使用；而StringBuilder未采用同步处理，属于线程不安全操作，没有锁，具有不安全性，在单线程使用