常用类（String类）

最新推荐文章于 2024-09-21 10:38:43 发布

Java-feng

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量324

点赞数

分类专栏： Java基础文章标签： java 学习

本文链接：https://blog.csdn.net/weixin_45467181/article/details/123443562

版权

Java基础专栏收录该内容

37 篇文章 0 订阅

订阅专栏

String类

概述

API中描述： String 类代表字符串。

Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

字符串是常量；它们的值在创建之后不能更改。

字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

示例：查看String源码

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
}
//String的成员变量

//String的属性值
private final char value[];

//数组被使用的开始位置
private final int offset;

//String中元素的个数
private final int count;

//String类型的hash值
private int hash; // Default to 0

private static final long serialVersionUID = -6849794470754667710L;

private static final ObjectStreamField[] serialPersistentFields =new ObjectStreamField[0];

//String底层使用一个字符数组来维护的

成员变量可以知道String类的值是final类型的，不能被改变的，所以只要一个值改变就会生成一个新的 String类型对象，存储String数据也不一定从数组的第0个元素开始的，而是从offset所指的元素开始。

String的构造方法

String()
   //初始化一个新创建的 String 对象，使其表示一个空字符序列。
String(byte[] bytes)
   //通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String(byte[] bytes, Charset charset)
   //通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
String(byte[] bytes, int offset, int length)
   //通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, int offset, int length, Charset charset)
   //通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, int offset, int length, String charsetName)
   //通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, String charsetName)
   //通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
String(char[] value)
   //分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
String(char[] value, int offset, int count)
   //分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
String(int[] codePoints, int offset, int count)
   //分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。
String(String original)
   //初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
String(StringBuffer buffer)
   //分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。
String(StringBuilder builder)
   //分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。

创建字符串对象方式

直接赋值方式创建对象是在方法区的常量池

String str="hello";//直接赋值的方式

通过构造方法创建字符串对象是在堆内存

String str=new String("hello");//实例化的方式

两种实例化方式的比较

编写代码比较

public static void main(String[] args) {
   String str1 = "Lance";
   String str2 = new String("Lance");
   String str3 = str2; //引用传递，str3直接指向st2的堆内存地址
   String str4 = "Lance";
   /*
    ==:
    基本数据类型：比较的是基本数据类型的值是否相同
    引用数据类型：比较的是引用数据类型的地址值是否相同
    所以在这里的话：String类对象==比较，比较的是地址，而不是内容
   */
   System.out.println(str1==str2);//false
   System.out.println(str1==str3);//false
   System.out.println(str3==str2);//true
   System.out.println(str1==str4);//true
}

内存图比较

构造方法实例化方式的内存图：String str = new String(“Hello”)；

首先
在这里插入图片描述

再一次的new一个String对象时：

在这里插入图片描述

字符串常量池

在字符串中，如果采用直接赋值的方式（String str=“Lance”）进行对象的实例化，则会将匿名对象 “Lance”放入对象池，每当下一次对不同的对象进行直接赋值的时候会直接利用池中原有的匿名对象，我们可以用对象手工入池

public static void main(String args[]){
   String str =new String("Lance").intern();//对匿名对象"hello"进行手工入池操作
   String str1="Lance";
   System.out.println(str==str1);//true
}

两种实例化方式的区别

直接赋值（String str = “hello”）：只开辟一块堆内存空间，并且会自动入池，不会产生垃圾。
构造方法（String str= new String(“hello”);）:会开辟两块堆内存空间，其中一块堆内存会变成垃圾被系统回收，而且不能够自动入池，需要通过public String intern();方法进行手工入池。
在开发的过程中不会采用构造方法进行字符串的实例化。

避免空指向

了解== 和public boolean equals()比较字符串的区别
当==在对字符串比较的时候，对比的是内存地址，而equals比较的是字符串内容，在开发的过程中，equals()通过接受参数，可以避免空指向。

String str = null;
if(str.equals("hello")){//此时会出现空指向异常
   ...
}

if("hello".equals(str)){//此时equals会处理null值，可以避免空指向异常
   ...
}

String类对象一旦声明则不可以改变；而改变的只是地址，原来的字符串还是存在的，并且产生垃圾。

在这里插入图片描述

String常用的方法

基本操作

方法	解释
int length();	获取字符串的长度
int indexOf(int ch);	返回指定字符在此字符串中第一次出现的索引
int lastIndexOf(int ch);	返回指定字符在此字符串中最后一次出现的索引
char charAt(int index);	返回字符串中index位置上的字符其中index的取值范围是：0~（字符串长度-1）

转换操作

方法	解释
char[] toCharArray();	将此字符串转换为一个字符串数组 char[] arr=str.toCharArray();–str是字符串
String valueOf(int i);	将int类型数转换为字符串
String toLowerCase();	使用默认语言环境的规则将String中中所有的字符都转换为小写
String toUpperCase();	使用默认语言环境的规则将String中中所有的字符都转换为大写

替换与去除

方法	解释
String replace(CharSequence oldstr,CharSequence newstr);	用nsewstr替换所有的oldstr得到一个新的字符串
String trim();	返回一个新的字符串，它去除了原字符串收尾的空格

截取和分割

方法	解释
String[] split(String regex);	根据参数regex将原来的字符串分割为若干个字符串
String substring(int beginIndex);	截取从索引beginIndex后的所有字符
String substring(beginindex,endIndex);	截取从beginIndex到endIndex索引之间的字符

判断操作

方法	解释
boolean equals(Object anobject);	与指定的字符串比较是否相等
boolean startWith(String prefix);	判断此字符串是否以指定的字符串开始
boolean endWith(String prefix);	判断此字符串是否以指定的字符串结束
boolean contains(CharSequence cs);	判断此字符串是否包含指定的字符串序列
boolean isEmpty();	当前仅当字符串长度为0时返回true

String的判断

常用方法

boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String str)： 比较字符串的内容是否相同,忽略大小写
boolean startsWith(String str)： 判断字符串对象是否以指定的str开头
boolean endsWith(String str)： 判断字符串对象是否以指定的str结尾

范例：

public static void main(String[] args) {
    
   // 创建字符串对象
   String s1 = "hello";
   String s2 = "hello";
   String s3 = "Hello";
    
   // boolean equals(Object obj):比较字符串的内容是否相同
   System.out.println(s1.equals(s2)); //true
   System.out.println(s1.equals(s3)); //false
   System.out.println("-----------");
    
   // boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
   System.out.println(s1.equalsIgnoreCase(s2)); //true
   System.out.println(s1.equalsIgnoreCase(s3)); //true
   System.out.println("-----------");
    
   // boolean startsWith(String str):判断字符串对象是否以指定的str开头
   System.out.println(s1.startsWith("he")); //true
   System.out.println(s1.startsWith("ll")); //false   
}

String截取

常用方法

int length()  //获取字符串的长度，其实也就是字符个数
char charAt(int index)  //获取指定索引处的字符
int indexOf(String str)  //获取str在字符串对象中第一次出现的索引
String substring(int start)  //从start开始截取字符串
String substring(int start,int end)  //从start开始，到end结束截取字符串。包括start，不包括end

范例：

public static void main(String args[]) {
    
   // 创建字符串对象
   String s = "helloworld";
    
   // int length():获取字符串的长度，其实也就是字符个数
   System.out.println(s.length()); //10
   System.out.println("--------");
    
   // char charAt(int index):获取指定索引处的字符
   System.out.println(s.charAt(0)); //h
   System.out.println(s.charAt(1)); //e
   System.out.println("--------");
    
   // int indexOf(String str):获取str在字符串对象中第一次出现的索引
   System.out.println(s.indexOf("l")); //2
   System.out.println(s.indexOf("owo")); //4
   System.out.println(s.indexOf("ak")); //-1
   System.out.println("--------");
    
   // String substring(int start):从start开始截取字符串
   System.out.println(s.substring(0)); //helloworld
   System.out.println(s.substring(5)); //world
   System.out.println("--------");
    
   // String substring(int start,int end):从start开始，到end结束截取字符串
   System.out.println(s.substring(0, s.length())); //helloworld
   System.out.println(s.substring(3, 8)); //lowor
}

String的转换

常用方法

char[] toCharArray()  //把字符串转换为字符数组
String toLowerCase()  //把字符串转换为小写字符串
String toUpperCase()  //把字符串转换为大写字符串

范例：

public static void main(String args[]) {
   // 创建字符串对象
   String s = "abcde";
    
   // char[] toCharArray():把字符串转换为字符数组
   char[] chs = s.toCharArray();
   for (int x = 0; x < chs.length; x++) {
      System.out.println(chs[x]);
   }
   System.out.println("-----------");
    
   // String toLowerCase():把字符串转换为小写字符串
   System.out.println("HelloWorld".toLowerCase());
   // String toUpperCase():把字符串转换为大写字符串
   System.out.println("HelloWorld".toUpperCase());
}

其他方法

常用方法

String trim()  //去除字符串两端空格
String[] split(String str)  //按照指定符号分割字符串

范例：

public static void main(String args[]) {
   // 创建字符串对象
   String s1 = "helloworld";
   String s2 = " helloworld ";
   String s3 = " hello world ";
   System.out.println("---" + s1 + "---");
   System.out.println("---" + s1.trim() + "---");
   System.out.println("---" + s2 + "---");
   System.out.println("---" + s2.trim() + "---");
   System.out.println("---" + s3 + "---");
   System.out.println("---" + s3.trim() + "---");
   System.out.println("-------------------");
   // String[] split(String str)
    
   // 创建字符串对象
   String s4 = "aa,bb,cc";
   String[] strArray = s4.split(",");
   for (int x = 0; x < strArray.length; x++) {
      System.out.println(strArray[x]);
   }
}

String的不可变性

阅读源代码的时候，会有这样的一句话：

Strings are constant; their values cannot be changed after they are created.
    //String是个常量，从一出生就注定不可变。

为什么String不可变了？

String类被final修饰，官方注释说明创建后不能被改变，但是为什么String要使用final修饰呢？

经典的面试题：

public static void main(String[] args) {
   String a = "abc";
   String b = "abc";
   String c = new String("abc");
   System.out.println(a==b); //true
   System.out.println(a.equals(b)); //true
   System.out.println(a==c); //false
   System.out.println(a.equals(c)); //true
}

内存图分析：

在这里插入图片描述

分析：

由于String太过常用，Java类库的设计者在实现时做了个小小的变化。
即采用了享元模式,每当生成一个新内容的字符串时，他们都被添加到一个共享池中，当第二次再次生成同样内容的字符串实例时，就共享此对象，而不是创建一个新对象，但是这样的做法仅仅适合于通过=符号进行的初始化。

String不可变的好处：

可以实现多个变量引用堆内存中的同一个字符串实例，避免创建的开销。
我们的程序中大量使用了String字符串，有可能是出于安全性考虑。
大家都知道HashMap中key为String类型，如果可变将变的多么可怕。
当我们在传参的时候，使用不可变类不需要去考虑谁可能会修改其内部的值，如果使用可变类的话，可能需要每次记得重新拷贝出里面的值，性能会有一定的损失。

字符串常量池

常量池表（Constant_Pool table）

Class文件中存储所有常量（包括字符串）的table。这是Class文件中的内容，还不是运行时的内容，不要理解它是个池子，其实就是Class文件中的字节码指令。
运行时常量池（Runtime Constant Pool）

JVM内存中方法区的一部分，这是运行时的内容。这部分内容（绝大部分）是随着JVM运行时候，从常量池转化而来，每个Class对应一个运行时常量池。

上一句中说绝大部分是因为：除了 Class中常量池内容，还可能包括动态生成并加入这里的内容。
字符串常量池（String Pool）

这部分也在方法区中，但与Runtime Constant Pool不是一个概念，String Pool是JVM实例全局共享的，全局只有一个。

JVM规范要求进入这里的String实例叫“被驻留的interned string”，各个JVM可以有不同的实现，HotSpot是设置了一个哈希表StringTable来引用堆中的字符串实例，被引用就是被驻留。
- 亨元模式
  
  其实字符串常量池这个问题涉及到一个设计模式，叫“享元模式”，顾名思义 - - - > 共享元素模式也就是说：一个系统中如果有多处用到了相同的一个元素，那么我们应该只存储一份此元素，而让所有地方都引用这一个元素 Java中String部分就是根据享元模式设计的，而那个存储元素的地方就叫做“字符串常量池 - String Pool”

分析

int x = 10;
String y = "hello";

首先， 10 和 “hello” 会在经过javac（或者其他编译器）编译过后变为Class文件中 constant_pool table 的内容
当我们的程序运行时，也就是说JVM运行时，每个Class constant_pool table 中的内容会被加载到JVM内存中的方法区中各自Class的 Runtime Constant Pool。
一个没有被String Pool包含的Runtime Constant Pool中的字符串（这里是"hello"）会被加入到 String Pool中（HosSpot使用hashtable引用方式）。步骤如下：

在Java Heap（堆）中根据"hello"字面量create一个字符串对象
将字面量"hello"与字符串对象的引用在hashtable中关联起来键 - 值形式是：“hello” = 对象的引用地址。
另外来说，当一个新的字符串出现在Runtime Constant Pool中时怎么判断需不需要在Java Heap中创建新对象呢？
策略是这样：会先去根据equals来比较Runtime Constant Pool中的这个字符串是否和String Pool中某一个是相等的（也就是找是否已经存在），如果有那么就不创建，直接使用其引用；反之，就如同上面的第三步。如此，就实现了享元模式，提高的内存利用效率。

使用String s = new String(“hello”);会创建几个对象

答：

会创建2个对象
首先，出现了字面量"hello"，那么去String Pool中查找是否有相同字符串存在，因为程序就这一行代码所以肯定没有，那么就在Java Heap中用字面量"hello"首先创建1个String对象。
接着，new String(“hello”)，关键字new又在Java Heap中创建了1个对象，然后调用接收String 参数的构造器进行了初始化。最终s的引用是这个String对象。