Java-String类

Neo丶

已于 2023-03-20 19:52:55 修改

阅读量676

点赞数

文章标签： java 学习开发语言

于 2022-08-15 16:22:58 首次发布

本文链接：https://blog.csdn.net/Ego_Ekko/article/details/126330686

版权

String类的理解和创建对象

1）String对象用于保存字符串，也就是一组字符序列；

2）字符串常量对象使用双引号括起的字符串序列；例如："你好"、"12.97"、"boy"等；

3）字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节；

4）String类较常用的构造方法：

String s1 = new String();

String s2 = new String(String original);

String s3 = new String(char[] a);

String s4 = new String(char[] a,int startIndex,int count);

★String 实现了Serializable接口，String可以串行化可以在网络传输

★String 实现了Comparable，String对象可以进行比较

package com.pero.string_;

/**
 * @author Pero
 * @version 1.0
 */
public class String01 {
    public static void main(String[] args) {
        //1）String对象用于保存字符串，也就是一组字符序列；
        //2）字符串常量对象使用双引号括起的字符串序列；例如："jake"
        //3）字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节；
        //4）String类较常用的构造方法：
        //   String s1 = new String();
        //   String s2 = new String(String original);
        //   String s3 = new String(char[] a
        //   String s4 = new String(char[] a,int startIndex,int count);
        //5）String 实现了Serializable接口，String可以串行化可以在网络传输
        //6）String 实现了Comparable，String对象可以进行比较
        //7）String是一个final类不能被继承
        //8）String类中有个属性private final char value[];用于存放字符串内容
        //8）value是一个final类型的，一旦复制不能改变（不能修改地址，可以修改字符）
        String name = "jake";
        name = "tom";
        
        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'h';
        //value = v2;Cannot assign a value to final variable 'value',不可以修改value地址
    }
}

创建String对象的两种方式

1）方式一：直接赋值 String s1 = "pero";

先从常量池里查看是否有"pero"数据空间，如果有，直接指向；如果没有则重新创建，然后指向；s1最终指向的是常量池的空间地址。

2）方式二：调用构造器 String s2 = new String("pero");

先在堆中创建空间，里面维护了value属性，指向常量池的"pero"空间，如果常量池没有"pero"，重新创建；如果有，直接通过value指向。最终指向的是堆中空间地址。

package com.pero.string_;

/**
 * @author Pero
 * @version 1.0
 */
public class String02 {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        System.out.println(a.equals(b));//true
        System.out.println(a==b);//true
    }
}

package com.pero.string_;

/**
 * @author Pero
 * @version 1.0
 */
public class String03 {
    public static void main(String[] args) {
        String a = "pero";  //指向常量池
        String b = new String("pero");  //指向堆空间
        System.out.println(a.equals(b));  //true
        System.out.println(a==b);       //false
        System.out.println(a==b.intern());  //true
        System.out.println(b==b.intern());  //false
        //当调用intern()方法时，如果常量池已经包含一个等于此String对象的字符串（
        // equals（Object）方法确定）则返回池中的字符串；否则，将此String对象添加到池中
        // 返回此String对象的引用
        //b.intern()方法最终返回的是常量池中的地址（对象）；
    }
}

字符串的特性

1）String是一个final类，代表不可变的字符序列

2）字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的。

String s1 = "hello";

s1 = "haha";

//创建了两个对象，将常量池中的"haha"空间地址指向s1

3）String s = "hello" + "haha";

底层，判断创建的常量池对象，是否有引用指向，优化等价于String s = "hellohaha"；

4）String a = "hello";

String b = "haha";

String s = a + b;

package com.pero.string_;

/**
 * @author Pero
 * @version 1.0
 */
public class String04 {
    public static void main(String[] args) {
        String a = "hello";
        String b = "haha";
        
        //1.创建一个StringBuilder sb = new StringBuilder();
        //2.执行sb.append("hello");
        //3.sb.append("abc");
        //4.String c = sb.toString();
        //最后其实是c指向堆中的String类对象value[] -> 池中"helloabc"
        String s = a + b;
        String d = "helloabc";
        System.out.println(c==d);  //false
    }
}

底层是： StringBuilder sb = new StringBuilder(); sb.append(a);sb.append(b);sb是在堆中，并且append是在原来字符串的基础上追加的。

String c1 = "ab" +"cd"；常量相加，是在池中;

String c2 = a+b；变量相加，是在堆中；

package com.pero.string_;

/**
 * @author Pero
 * @version 1.0
 */
public class String05 {
    public static void main(String[] args) {
        Test01 test01 = new Test01();
        test01.change(test01.str,test01.ch);
        System.out.print(test01.str+"and");
        System.out.println(test01.ch);
    }
}
class Test01{
    String str = new String("pero");
    final char[] ch = {'j','a','v','a'};
    public void change(String str,char[] ch){
        str = "java";
        ch[0] = 'h';
    }
}

String类的常见方法

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder和StringBuffer来增强String的功能，并提高效率。

package com.pero.string_;

import java.util.Locale;

/**
 * String常用方法
 *
 * @author Pero
 * @version 1.0
 */
public class String06 {
    public static void main(String[] args) {
        //1.equals()方法，区分大小写对对象的内容进行判断是否相同
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));

        //2.equalsIgnoreCase()方法，忽略大小写的判断内容是否相等
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
            System.out.println("Success");
        } else {
            System.out.println("Failure");
        }

        //3.length()方法，获取字符的个数，字符串的长度
        System.out.println("pero".length());

        //4.indexOf()方法，获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到返回-1
        String s1 = "we@terewe@g";
        int index = s1.indexOf("@");
        System.out.println(index);
        System.out.println(s1.indexOf("we"));

        //5.lastIndexOf()方法，获取字符在字符串对象中最后一次出现的索引，索引从0开始，如果找不到则返回-1
        String s2 = "we@terew@g";
        int index01 = s2.lastIndexOf("@");
        System.out.println(index01);
        System.out.println(s2.lastIndexOf("ter"));

        //6.subString()方法，截取指定范围的子串
        String name = "hello,pero";
        //从索引6开始截取后面的所有内容
        System.out.println(name.substring(6));
        //从索引2开始截取，截取到索引5-1=4的位置
        System.out.println(name.substring(2, 5));

        //7.toUpperCase()方法，将字符串转换成大写
        String s = "hello";
        System.out.println(s.toUpperCase());

        //8.toLowerCase()方法，将字符串转换成小写
        System.out.println(s.toLowerCase());

        //9.concat()方法，拼接字符串
        String s3 = "jake";
        s3 = s3.concat("lucy").concat("smith").concat("together");
        System.out.println(s3);

        //10.replace()方法，替换字符串中的字符
        String s4 = "my name is jake";
        s4 = s4.replace("jake", "smith");
        System.out.println(s4);

        //11.split()方法，分割字符串，对于某些分割字符我们需要转义"\"，比如“|和\\”等；
        String poem = "锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦";
        String[] split = poem.split("，");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

        String poem01 = "E:\\aaa\\bbb";
        String[] split01 = poem01.split("\\\\");
        for (int i = 0; i < split01.length; i++) {
            System.out.println(split01[i]);
        }


        //12.toCharArray()方法，将字符串转换成字符数组
        String s6 = "happy";
        char[] chars = s6.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        //13.compareTo()方法，比较两个字符串大小，如果前者大，则返回正数；
        // 如果后者大，则返回负数；如果相等，则返回0；
        String a = "john";
        String b = "jake";
        System.out.println(a.compareTo(b));  //返回值是'o'-'a' = 14 的值
        String c = "joh";
        System.out.println(a.compareTo(c));  //返回值是1，前面的字符串长度减去后面的字符串长度

        //14.format()方法，格式字符串
        //1.%s、%d、%.2f、%c 称为占位符
        //2.这些占位符后面有对应的变量来替换
        //3.%s 表示由字符串来替换
        //4.%d 表示由整数来替换
        //5.%.2f 表示由小数来替换，并且保留两位小数，并且进行四舍五入进行处理
        //6.%c 表示由字符来替换
        String studentName = "john";
        int age = 18;
        double score = 98.3 / 3;
        char gender = '男';
        String info = "我的名字是：" + studentName + "年龄是：" + age +
                "成绩是：" + score + "性别是：" + gender;
        System.out.println(info);

        String info01 = String.format("我的名字是：%s年龄是：%d成绩是：%.2f性别是：%c", studentName, age, score, gender);
        System.out.println(info01);

        String formatStr = "我的名字是：%s年龄是：%d成绩是：%.2f性别是：%c";
        String info02 = String.format(formatStr,studentName,age,score,gender);
        System.out.println(info02);
    }
}