byte数组存MySQL用什么类型

前言

String 是我们实际开发中使用频率非常高的类，Java 可以通过 String 类来创建和操作字符串，使用频率越高的类，我们就越容易忽视它，因为见的多所以熟悉，因为熟悉所以认为它很简单，其实只是了解到皮毛，并没有真正掌握，而 String 又是面试的高频考点，所以我们有必要将 String 这个类深入研究，彻底搞定，本节课就为大家详细讲解 String 的核心机制以及实际使用。

String 三大核心：

1、不变性：String 是只读字符串，是一个典型的 immutable 对象，对它进行任何操作，其实都是创建一个新的对象，再把引用指向该对象。不变模式的主要作用在于当一个对象需要被多线程共享并频繁访问时，可以保证数据的一致性。

2、常量池优化：String 对象创建之后，会在字符串常量池中进行缓存，如果下次创建同样的对象时，会直接返回缓存的引用。

3、final：使用 final 来定义 String 类，表示 String 类不能被继承，提高了系统的安全性。

考点分析

String 不是基本数据类型

这是很基础的东西，但是很多初学者却容易忽视，Java 的 8 种基本数据类型中不包括 String，基本数据类型中用来描述文本数据的是 char，但是它只能表示单个字符，比如 'a','好' 之类的，如果要描述一段文本，就需要用多个 char 类型的变量，也就是一个 char 类型数组，比如“你好” 就是长度为2的数组 char[] chars = {'你','好'};

但是使用数组过于麻烦，所以就有了 String，String 底层就是一个 char 类型的数组，只是使用的时候开发者不需要直接操作底层数组，用更加简便的方式即可完成对字符串的使用。

String 实例化

String 对象的实例化有两种方式：

1、直接赋值

String str = "Hello";

2、通过构造函数，可以直接将 String 值传入，也可以直接将 char 数组传入。

String str = new String("Hello");
char[] chars = {'你','好'};
String str2 = new String(chars);

看到这里大家可能会感到疑惑，String str = "Hello"，本身就已经是一个 String 了，为什么还要再次调用 String 构造函数，把 str 传入，然后再生成一个 String，这不是多此一举了吗？

这样设计 String 类，一定有它的道理，"Hello" 和 new String("Hello") 的区别在于存储区域不同，"Hello" 存储在字符串常量池中，new String("Hello") 存储在堆内存中，我们通过下面这段代码来比较二者的区别。

String str1 = "Hello";
String str2 = "Hello";
System.out.println(str1 == str2);
String str3 = new String("World");
String str4 = new String("World");
System.out.println(str3 == str4);

上述代码非常简单，用直接赋值的方式创建了 String 对象 str1 和 str2，并且值相等，又用构造函数的方式创建了 str3 和 str4，值也相等。

然后用 == 分别判断 str1 和 str2 、str3 和 str4 是否相等，这里并不是比较值是否相等，而是比较它们的内存地址是否相等，结果如下图所示。

通过结果我们可以得知，str1 和 str2 指向同一块内存区域，而 str3 和 str4 指向不同的内存区域，这是为什么呢？

因为  str = "Hello" 是直接赋值的方式，"Hello" 是存储在字符串常量池中的，在创建 "Hello" 的时候会首先在字符串常量池中寻找是否已经存在 "Hello"，如果存在，则直接将其引用赋给 str，如果不存在则创建 "Hello"，再将其引用赋给 str。

所以 str1 = "Hello"，会在字符串常量池中创建 "Hello"，并将其引用赋给 str1，str2 = "Hello"，会在字符串常量池中找到 "Hello"，并将其引用赋给 str2，所以 str1 和 str2 指向同一块内存地址，str1 == str2 结果为 true。

而使用构造函数的方式则完全不同，String 对象存储在堆内存中，且不会去寻找是否已经存在值相等的对象，而是每创建一个对象，都会在堆内存中开辟一块新的内存空间来保存，所以 str3 = new String("World")，它的创建过程是先在堆内存中开辟空间存储 "World"，然后再将该地址赋给 str3，str4 = new String("World") 是同样的过程，那么 str3 和 str4 所指向的内存地址肯定不同，str3 == str4 结果为 false。

equals 方法

通过上面的例子我们知道，== 是比较内存地址的，我们一般对于字符串的比较都是判断其值是否相等，而非内存地址，那么对于 String 对象，我们如何来判断值是否相等呢？可以使用 equals 方法来完成。

首先来说说 equals 方法的出处，它是 Object 类中定义的方法，源码如下所示。

public boolean equals(Object obj) {
  return (this == obj);
}

可以看到这个方法非常简单粗暴，用 == 比较两个引用对象所指向的内存地址是否一致，和直接使用 == 判断是一样的，这样并不能对值进行判断，所以 String 类在继承的基础上对 equals 方法进行了重写，如下所示。

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String aString = (String)anObject;
        if (coder() == aString.coder()) {
            return isLatin1() ? StringLatin1.equals(value, aString.value)
                              : StringUTF16.equals(value, aString.value);
        }
    }
    return false;
}

//StringLatin1.equals
public static boolean equals(byte[] value, byte[] other) {
      if (value.length == other.length) {
         for (int i = 0; i             if (value[i] != other[i]) {
               return false;
            }
         }
         return true;
      }
      return false;
}

//StringUTF16.equals
public static boolean equals(byte[] value, byte[] other) {
      if (value.length == other.length) {
         int len = value.length >> 1;
         for (int i = 0; i             if (getChar(value, i) != getChar(other, i)) {
               return false;
            }
         }
         return true;
      }
      return false;
}

在 String 对 equals 方法重写的逻辑里，将 == 判断改为了值的判断，即将 String 转为 byte 数组，然后依次比较两个 byte 数组中的每一个值是否相等，如果两个数组完全一致，则返回 true，否则返回 false。

String 不可变

实际上 String 类在存储字符串时，会将字符串的值保存在 byte 类型的数组中，我们知道数组一旦创建，其长度就是不可改变的。既然长度不可改变，也就意味着 byte 类型所存储的字符串值不可修改。一旦修改，就会重新创建一个 String 对象，用新对象的 byte 数组来存储修改之后的字符串。即如果我们修改了 String 对象的值，它就已经不是之前的对象了，而是一个新的对象，如下所示。

String str1 = new String("Hello");
String str2 = str1;
System.out.println(str2 == str1);
str1 += " World";
System.out.println(str2 == str1);

运行结果如下图所示。

intern 方法

当调用某个字符串对象的 intern 方法时，会去字符串常量池中寻找，如果已经存在一个等于该 String 对象的字符串(equals 方法判断)，则返回该字符串，否则将这个 String 对象添加到字符串常量池中，并返回它的引用，代码如下所示。

String str1 = "Hello World";
String str2 = new String("Hello World");
System.out.println(str1 == str2);
System.out.println(str1 == str2.intern());

运行结果如下图所示。

"Hello World" 保存在字符串常量池中，new String("Hello World") 保存在堆内存中，所以引用肯定不相等，但是 new String("Hello World").intern() 就是在字符串常量池中的 "Hello World"。

String 常用方法

具体使用如下所示。

char[] array = {'J','a','v','a',',','H','e','l','l','o',',','W','o','r','l','d'};
String str = new String(array);
System.out.println(str);
System.out.println("str长度："+str.length());
System.out.println("str是否为空："+str.isEmpty());
System.out.println("下标为2的字符是："+str.charAt(2));
System.out.println("H的下标是："+str.indexOf('H'));
String str2 = "Hello";
System.out.println("str和str2是否相等："+str.equals(str2));
String str3 = "HELLO";
System.out.println("str2和str3忽略大小写是否相等："+str2.equalsIgnoreCase(str3));
System.out.println("str是否以Java开头："+str.startsWith("Java"));
System.out.println("str是否以Java结尾："+str.endsWith("Java"));
System.out.println("从2开始截取str："+str.substring(2));
System.out.println("从2到6截取str："+str.substring(2, 6));
System.out.println("将str中的World替换为Java："+str.replaceAll("World", "Java"));
System.out.println("用逗号分割str："+Arrays.toString(str.split(",")));
System.out.println("将str转为char类型数组："+Arrays.toString(str.toCharArray()));
System.out.println("str3转为小写："+str3.toLowerCase());
System.out.println("str2转为大写："+str2.toUpperCase());

运行结果如下图所示。

String 所有方法中最常用的有两个：

1、字符串截取

字符串截取是 String 最常用的操作之一，String 提供了两个截取字符串的方法。

public String substring(int beginIndex)public String substring(int beginIndex, int endIndex)

substring(int beginIndex) 是从下标为 beginIndex 的位置开始截取，一直到字符串的结尾。

substring(int beginIndex, int endIndex) 是从下标为 beginIndex 的位置开始截取，一直到 endIndex 的位置结束，且不包括该位置的字符。

需要注意的是 substring 方法会将截取的结果以新字符串的形式返回，原字符串的值不会改变，具体操作如下所示。

String str = new String("Hello World");
System.out.println(str.substring(3));
System.out.println(str);

运行结果如下图所示。

2、字符串分割

字符串分割也是 String 最常用的操作之一，它是指将目标字符串按照某个分割符，切割成一个字符串数组，String 通过 split 方法完成字符串分割。

public String[] split(String regex)

split 方法支持传入正则表达式，进行复杂的字符串分割，比如 "Hello,World;Java-String"，如果要将 Hello、World、Java、String 截取出来，使用统一的分割符肯定无法完成，这时候可以借助于正则表达式 "[,|;|-]" 来实现，具体操作如下所示。

String str = new String("Hello,World;Java-String");
String[] array = str.split("[,|;|-]");
for (String item:array){
  System.out.println(item);
}

运行结果如下图所示。

高频面试题

1、== 和 equals 的区别？

== 可以理解为是比较栈内存中的值，如果变量是基本数据类型，则栈内存中存放的就是具体数值，如果是引用类型，则栈中存放的是引用的内存地址。

所以对于基本数据类型，== 是比较值是否相等，对于引用数据类型，比较的是引用的内存地址是否相等。

equals 是 Object 类提供的一个方法，其本质就是在用 == 进行判断。

public boolean equals(Object obj) {
  return (this == obj);
}

同时 Java 中任意一个类都可以对其进行重写，根据具体需求重新定义其判断逻辑，比如我们自定义一个 Student 类，如下所示。

public class Student {
    private Integer id;
    private String name;
    public Student(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
}

创建两个成员变量值完全相等的实例化对象，并用 equals 方法判断是否相等。

Student student1 = new Student(1,"张三");
Student student2 = new Student(1,"张三");
System.out.println(student1.equals(student2));

结果为 false，因为有两个实例化对象，就必然会在堆内存中开辟两块空间来存储，引用一定是不相同的。而在现实的逻辑中，如果两个学生的 id 和 name 都一样，我们就认为他们是同一个学生，用程序如何来实现呢？通过重写 equals 方法即可，如下所示。

public class Student {
    private Integer id;
    private String name;

    public Student(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        Student student = (Student) obj;
        if(id.equals(student.id) && name.equals(student.name)){
            return true;
        }
        return false;
    }
}

再次运行代码，返回值为 true。

2、下面代码的运行结果是？

String str1 = "Hello World";
String str2 = "Hello"+" World";
System.out.println(str1 == str2);

true，"Hello" 和 " World" 都是字符串字面值，字符串字面值 + 字符串字面值的结果仍然保存在字符串常量池中，所以 str1 和 str2 相同。

3、下面代码的运行结果是？

String str1 = "Hello World";
String str2 = "Hello";
str2 += " World";
System.out.println(str1 == str2);

false，这题看似与第 2 题一样，为什么结果完全不同呢？因为 str2 = "Hello"+" World" 是直接创建，str2 = "Hello"; str2 = "Hello"; 是先创建再修改，同时修改完成之后的字符串是放在堆内存中的，为什么呢？因为 str2 是一个字符串变量，" World" 是字符串字面值，当字符串字面值与 String 类型变量拼接时，得到的新字符串不再保存在常量池中，而是在堆中开辟一块新的空间来存储，所以 str1 引用指向字符串常量池，str2 引用指向堆内存，肯定不相同。

4、下面代码的运行结果是？

String str1 = "Hello World";
String str2 = " World";
String str3 = "Hello"+str2;
System.out.println(str1 == str3);

false，str2 是变量，"Hello" 是字符串字面值，字符串字面值 + 变量会在堆内存中开辟新的空间来存储，所以 str1 和 str3 不同。

5、下面代码的运行结果是？

String str1 = "Hello World";
final String str2 = " World";
String str3 = "Hello"+str2;
System.out.println(str1 == str3);

true，"Hello" 是字符串字面值，str2 是常量，字符串字面值+常量的结果仍然保存在字符串常量池中，所以 str1 和 str3 相同。

6、下面代码的运行结果是？

String str1 = "Hello World";
final String str2 = new String(" World");
String str3 = "Hello"+str2;
System.out.println(str1 == str3);

false，str2 是常量，但是 new String(" World") 保存在堆内存中，所以即使使用 final 进行了修饰，str2 仍然保存在堆中，则 str3 也就保存在堆中，所以 str1 和 str3 不同。

7、下面代码的运行结果是？

String str1 = "Hello World";
String str2 = "Hello";
String str3 = " World";
String str4 = str2 + str3;
System.out.println(str4.intern() == str1);

true，当调用 str4 的 intern 方法时，如果字符串常量池已经包含一个等于 str4 的字符串，则返回该字符串，否则将 str4 添加到字符串常量池中，并返回其引用，所以 str4.intern() 与 str1 相同。

8、什么是字符串常量池？

字符串常量池位于堆内存中，专门用来存储字符串常量，可以提高内存的使用率，避免开辟多块空间存储相同的字符串，在创建字符串时 JVM 会首先检查字符串常量池，如果该字符串已经存在池中，则返回它的引用，如果不存在，则实例化一个字符串放到池中，并返回其引用。

9、String 是线程安全的吗？

String 是不可变类，一旦创建了String对象，我们就无法改变它的值。因此它是线程安全的，同一个字符串实例可以被多个线程共享，保证了多线程的安全性。

10、在使用 HashMap 的时候，用 String 做 key 有什么好处？

HashMap 内部实现是通过 key 的 hashcode 来确定 value 的存储位置，因为字符串是不可变的，所以当创建字符串时，它的 hashcode 被缓存下来，不需要再次计算，所以相比于其他对象更快。