JAVA中String构造超链接 java中string的构造方法

文章目录

• 一、字符串的构造
• 二、String对象的比较
• 三、字符串的查找
• 四、转化

• 数值和字符串转化
• 大小写转化
• 字符串转数组
• 格式化

• 五、浅识常量池

• class文件常量池
• 运行时常量池
• 字符串常量池

• 六、String、StringBuilder、StringBuffer

• String,StringBuffer,StringBuilder的区别

一、字符串的构造

可参考Java在线文档（String官方文档） 字符串构造的三种常见方法：
1、使用常量串构造
2、直接newString对象
3、使用字符数组进行构造

public class Test {
    public static void main(String[] args) {
        // 使用常量串构造
        String s1 = "good morning";
        System.out.println(s1);

        // 直接newString类对象
        String s2 = new String("good morning");
        System.out.println(s2);

        // 使用字符数组进行构造
        char[] arr = {'g','o','o','d',' ','m','o','r','n','i','n','g'};
        String s3 = new String(arr);
        System.out.println(s3);

    }
}

• String 是引用类型，内部并不存储字符串本身

public class Test {
    public static void main(String[] args) {
        String s1 = new String("good");
        String s2 = new String("morning");
        String s3 = s1;

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

        System.out.println(s1.length());
        System.out.println(s1.isEmpty());
    }
}

运行结果

good
morning
good
4
false

在Java中，“”引起来的也是String 类型的对象

System.out.println("good".length());

二、String对象的比较

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("good");
        String s2 = new String("morning");
        String s3 = new String("good");
        String s4 = s1;
        System.out.println(s1 == s2);   // false
        System.out.println(s1 == s3);   // false
        System.out.println(s1 == s4);   // true

    }

运行结果

false
true
false
false
true

2. boolean equals(Object anObject) 方法：按照字典序比较
   字典序：字符大小的顺序

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

public static void main(String[] args) {
        String s1 = new String("morning");
        String s2 = new String("morng");
        String s3 = new String("morning");
        String s4 = new String("morningbaby");
        String s5 = new String("goodmorning");

        System.out.println(s1.compareTo(s2));
        System.out.println(s1.compareTo(s3));
        System.out.println(s1.compareTo(s4));
        System.out.println(s1.compareTo(s5));    // g的ASCII码为103，m的ASCII码为109，差值为6

    }

运行结果

2
0
-4
6

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

public static void main(String[] args) {
        String s1 = new String("Morning");
        String s2 = new String("morng");
        String s3 = new String("MORNING");
       
        System.out.println(s1.compareToIgnoreCase(s2));
        System.out.println(s1.compareToIgnoreCase(s3));
       
    }

2
0

三、字符串的查找

常见的查找方法：

方法	功能
char charAt(int index)	返回index位置上字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常
int indexOf(int ch)	返回ch第一次出现的位置，没有返回-1
int indexOf(int ch, int fromIndex)	从fromIndex位置开始找ch第一次出现的位置，没有返回-1
int indexOf(String str)	返回str第一次出现的位置，没有返回-1
int indexOf(String str, int fromIndex)	从fromIndex位置开始找str第一次出现的位置，没有返回-1
int lastIndexOf(int ch)	从后往前找，返回ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch, int fromIndex)	从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
int lastIndexOf(String str)	从后往前找，返回str第一次出现的位置，没有返回-1
int lastIndexOf(String str, int fromIndex)	从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

举例：

public static void main(String[] args) {
        String s = "abcabcabcabc";

        // System.out.println(s.charAt(-4));   // 负数抛出java.lang.StringIndexOutOfBoundsException异常
        System.out.println(s.charAt(1));       // b   返回下标为1对应的字符为b

        System.out.println(s.indexOf('c'));    // 2   字符c第一次出现是下标为2的位置，所以返回2，没有返回-1
        System.out.println(s.indexOf('a',4));   // 6   从下标为4的位置开始找a,返回第一次出现a的下标
        System.out.println(s.indexOf("cab"));       // 2     在给出的字符串中找字符串cab，返回所找字符串中第一个字母下标
        System.out.println(s.indexOf("cab",5));   //5

        System.out.println(s.lastIndexOf('a'));     // 9  从后往前找，返回第一次出现a的下标
        System.out.println(s.lastIndexOf('a',7));   // 6  从后往前找，从下标为7开始向前找，返回第一次出现a的下标
        System.out.println(s.lastIndexOf("abc"));     // 9  从后往前找字符串abc，返回所找字符串中最后一个字母的下标
        System.out.println(s.lastIndexOf("abc",4));   // 3  

    }

四、转化

数值和字符串转化

public static void main(String[] args) {
        // 数字转字符串
        String s1 = String.valueOf(1234);   // 1234
        String s2 = String.valueOf(true);   // true
        
        // 字符串转数字，利用包装类
        int a = Integer.parseInt("1234");   // 1234
        int b = Integer.parseInt("1234",8);  // 668  1234转为八进制
        double c = Double.parseDouble("12.34");   // 12.34
        
    }

大小写转化

public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.toUpperCase());   // 转大写
        System.out.println(s2.toLowerCase());   // 转小写
    }

字符串转数组

public static void main(String[] args) {
        String s = "hello";

        // 字符串转数组
        char[] ch = s.toCharArray();
        for(int i = 0;i < ch.length;i++){
            System.out.print(ch[i]);
        }
        System.out.println();

        //数组转字符串
        String s2 = new String(ch);
        System.out.println(s2);
    }

格式化

public static void main(String[] args) {
        String s = String.format("%d-%d-%d",2022,4,18);
        System.out.println(s);
    }

五、浅识常量池

class文件常量池

字节码文件常量池类似是一个数组，每个.java源文件编译后生成.class文件中会保存当前类中的字面常量以及符号信息。节省内存

运行时常量池

在.class文件被加载到JVM时，.class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份

字符串常量池

字符串常量值在JVM中是 StringTable 类，实际是一个固定大小的 HashTable ，不同JDK版本下字符串常量池的位置以及默认大小是不同的。

1. 在JVM中字符串常量池只有一份，是全局共享的
2. 刚开始字符串常量池是空的，随着程序不断运行，字符串常量池中元素会越来越多
3. 当类加载时，字节码文件中的常量池也被加载到JVM中，称为运行时常量池，同时会将其中的字符串常量保存 在字符串常量池中
4. 字符创常量池中的内容：一部分来自运行时常量池，一部分来自程序动态添加

在一串数据中找data:
1、直接比较
2、排序+二分查找
3、哈希—借助哈希表将数据管理起来—通过哈希函数将数据与其存储位置建立一 一对应的关系

六、String、StringBuilder、StringBuffer

由于String的不可更改特性，为了方便字符串的修改，Java中又提供了StringBuilder和StringBuffer类。这两个类大部分功能是相同的
StringBuilder的常用方法：

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

String,StringBuffer,StringBuilder的区别

1.String的内容不可修改，StringBuffer与StringBuilder的内容可以修改
2.StringBuffer与StringBuilder大部分功能相似
3.StringBuffer采用同步处理，属于线程安全操作;而StringBuilder未采用同步处理，属于线程不安全操作