Java常用类（一）-CSDN博客

import org.junit.Test;


public class StringTest {
    @Test
    public void test1(){
        String s1="abc";//字面量的定义方式
        String s2="abc";
        s1="hello";
        System.out.println(s1 == s2);//比较地址值
        System.out.println(s1);//hello
        System.out.println(s2);//abc
    }
}

输出结果为

内存解析

String实例化方式二：通过new构造器的方式

import org.junit.Test;



public class StringTest {
     @Test
    public void test2(){

        //* 方式一：通过字面量定义的方式
        String s1="JavaEE";
        String s2="JavaEE";
        //* 方式二：通过new+构造器的方式
        String s3=new String("JavaEE");
        String s4=new String("JavaEE");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s3 == s4);//false
        System.out.println(s1 == s4);//false
    }
}

运行结果为

内存解析

字符串的特性

* 1、常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量
* 2、只要其中有一个是变量，结果就在堆中
* 3、如果拼接的结果调用intern()方法，返回值就在常量池中

import org.junit.Test;
public class StringTest {
  @Test
    public void test3(){
        String s1="java";
        String s2="ee";

        String s3="javaee";
        String s4="java"+"ee";
        String s5=s1+"ee";
        String s6="java"+s2;
        String s7=s1+s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s4 == s5);//false
        System.out.println(s3 == s7);//false

        String s8=s5.intern();//返回值的得到的s8使用的常量值中已经存在的"javaee "
        System.out.println(s3 == s8);//true

    }
}

运行结果

true
false
false
false
false
true

String使用陷阱

String s1 = "a";
- 说明：在字符串常量池中创建了一个字面量为"a"的字符串。
s1 = s1 + "b";
- 说明：实际上原来的“a”字符串对象已经丢弃了，现在在堆空间中产生了一个字符串s1+"b"（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。
String s2 = "ab";
- 说明：直接在字符串常量池中创建一个字面量为"ab"的字符串。
String s3 = "a" + "b";
- 说明：s3指向字符串常量池中已经创建的"ab"的字符串。
String s4 = s1.intern();
- 说明：堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串赋值给s4。

面试题

String s=new String("abc");方式创建对象，在内存中创建了几个对象？

答：两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

String的常用方法

String与基本数据类型转换

字符串--->基本数据类型、包装类

Interger包装类的public static parseInt(String s)：可以将“数字”字符组成的字符串转换为整型
类似的使用java.lang包下的Byte、Short、Long、Double、Float类调用相应的类方法可以将“数字”字符组成的字符串转换为相应的基本数据类型

基本数据类型、包装类---->字符串

调用String类的public String valueOf(int n)：可以将int型转换为字符串
相应的valueOf(byte b)、valueOf(long l)、 valueOf(float f) 、valueOf(double d)、 valueOf(boolean b)可有参数的相应类型到字符串的转换

String与字符数组的转换

字符数组--->字符串

调用String类的构造器：String(char[]) String(char[],int offset,int length)分别用字符数组中的全部自负和部分字符创建字符串对象

字符串--->字符数组

public char[] toCharArray()：将字符串的全部字符存放在一个字符数组中
public void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：提供了将指定索引范围的字符串存放到数组中的方法

String与字节数字转换

字节数组--->字符串（调用String的构造器）

String(byte[])：使用平台的默认字符集解码指定的btye数组，构造一个新的String
String(byte[],int offset,int length)：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象

字符串--->字节数组

public byte[] getBytes()：使用平台默认字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中
public byte[] getBytes(String charsetName)：使用指定的字符集将此String编码到byte序列，并将结果存储到新的byte数组

package com.light.java;

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringTest {

 /**
     * String与byte[]之间的转换
     * 编码：字符串---->字节
     * String--->byte[]：调用String的getBytes()
     *
     * 解码：编码的逆过程，字节---->字符串
     * byte--->String：调用String的构造器
     * 说明：解码时使用的字符集必须与编码时所使用的字符集一致，否则会出现乱码
     */
    @Test
    public void test4() throws UnsupportedEncodingException {
        String str1="abc123战国";
        System.out.println("********编码*********");
        //编码
        byte[] bytes = str1.getBytes();//使用默认字符集编码（utf-8）
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码
        System.out.println(Arrays.toString(gbks));

        System.out.println("********解码*********");
        //解码
        //调用String的构造器
        String s = new String(bytes);//默认（utf-8）
        System.out.println(s);
        String s1 = new String(gbks,"gbk");//gbk字符集解码
        System.out.println(s1);
    }
}

运行结果为

二、StringBuffer类（线程安全）

java.lang.StringBuffer代表可变字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新对象

StringBuffer内部也是用char[]存储

源码分析

StringBuffer str2=new StringBuffer();//char[] value=new char[16];
底层创建了长度为16的字符型数组
* StringBuffer str3=new StringBuffer("abc");//char[] value=new char["abc".length+16];
底层创建了长度为"abc".length+16的字符型数组