【String类】String的介绍

 

1.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)

 

package com.cn.string_;

/**
 * @author xxx
 * @version 1.0
 */
public class string_ {
    public static void main(String[] args) {
        //1.String 对象用于保存字符串，也就是一种字符序列
        //2."jack" 字符串常量，双引号扩起来的字符序列
        //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 s5 = new String(byte[] b);

        //5. String 类实现了接口 Serializable【String 可以串行化：可以网络传输】
        //                 接口 Comparable【String 对象可以比较大小】

        //6.String 是final类，不能被其他类继承
        //7.String 有属性 private final cahr value[];用于存放字符串内容
        //8.一定要注意：value是一个final类型，不可以修改；即value不能指向
        //新的地址，但是单个字符内容是可以变化

        String name = "jack";
        name = "tom";
        System.out.println(name);

        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'H';
        System.out.println(value);


    }
}

2.创建 String 对象的两种方式

方式一：直接复值 String s = "jack"；

方式二：调用构造器 String s = new String("jack")；

3.两种创建 String 对象的区别

方式一：直接赋值String s = "jack";

方式二：调用构造器 String s = new String("jack")；

1.方式一：先从常量池查看是否有"jack"数据空间，如有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址

2.方式二：先在堆中创建空间，里面有 value属性，指向常量池的jack空间。，如果常量池没有"jack"，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。

3画出两种方式的内存分布图：

 4.课堂练习

package com.cn.string_;

/**
 * @author xxx
 * @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.cn.string_;



/**
 * @author xxx
 * @version 1.0
 */
public class String03 {
    public static void main(String[] args) {
        String a = new String("jack");
        String b = new String("jack");
        System.out.println(a.equals(b));//true
        System.out.println(a == b);//false
    }
}

 

 

package com.cn.string_;

/**
 * @author xxx
 * @version 1.0
 */
public class String04 {
    public static void main(String[] args) {
        String a = "jack";
        String b = new String("jack");
        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()方法最终返回的是常量池的地址(对象)
    }
}

5.字符串的特性

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

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

1.以下语句创建了几个对象？ 画出内存图

String s1= "hello"；

s1 = "haha";

6.面试题

1）题一

String a = "hello"+"abc"；

创建了几个对象？只有一个对象

//解读：String a = "hello"+"abc"；//优先等价 String a = "helloabc"；

//分析：

//1.编译器做了一个优化，判断创建的常量池对象，是否有引用指向

//2.String a = "hello"+"abc"；=》String a = "helloabc"

2）题2

package com.cn.string_;

/**
 * @author xxx
 * @version 1.0
 */
public class String05 {
    public static void main(String[] args) {
        String a = "hello";
        String b = "abc";
        String c = a + b ;//创建了几个对象？画出内存图
        System.out.println(c);
        //关键要分析String c = a + b;到底是如何热执行的
        //一共有三个对象
        //小结：
        //底层是StringBuilder sb = new StringBuilder();
        //sb.append(a);sb.append(b);sb是在堆中，并且append在原来字符串的基础上追加的
        //重要规则：String c = "ab"+"cd";常量相加，看的是池。
        //String c1 = a + b;是变量相加，是在堆中


    }
}

package com.cn.string_;

/**
 * @author xxx
 * @version 1.0
 */
public class String06 {
    public static void main(String[] args) {
        String a = "hello"; //指向池中 hello
        String b = "abc";//指向池中 abc
        String c = "helloabc";//指向池中helloabc
        String d = (a+b).intern();//指向池中helloabc
        System.out.println(c.equals(d)); //true
        System.out.println(c == d);//true

    }
}

 

7.说明

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

//看看这段代码

String s = new String("");

for(int i = 0; i < 80000;i++){

s += "hello";

}

8.String类的常见方法

equals	区分大小写，判断内容是否相等
equalslgnoreCase	忽略大小写的判断内容是否相等
length	获取字符串个数，字符串的长度
indexOf	获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到返回-1
lastIndesOf	获取字符在字符串最后一次出现的索引，索引从0开始，如果找不到，返回-1
substring	截取指定范围的子串
trim	去前后空格
charAt	获取某索引的字符，注意不能使用Str[index]这种方式

package com.cn.string_;

/**
 * @author xxx
 * @version 1.0
 */
public class String07 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        //区分大小，比较内容是否相等
        System.out.println(s1.equals(s2));//true
        String str1 = "Hello";
        //忽略大小写，比较内容是否相等
        System.out.println(s1.equalsIgnoreCase(str1));//true

        //获取字符在字符串第一次出现的索引，如果找不到，返回-1
        System.out.println(s1.indexOf('l'));//2

        //获取字符在字符串最后一次出现的索引，如果找不到，返回-1
        System.out.println(s1.lastIndexOf('l'));//3

        //截取指定的范围子串
        System.out.println(s1.substring(2));//llo

        String str2 = " HELLO ";
        //去掉前后空格
        System.out.println(str2.trim());//HELLO

        //获取字符串的长度
        System.out.println(s1.length());//5

        //获取某索引的字符
        System.out.println(s1.charAt(0));//l


    }
}

 

 

 

toUpperCase	将所有字符更换为大写
toLowerCase	将所有字符更换为小写
concat	将指定字符串连接到此字符串的结尾。
replace	替换字符串中的字符
split	分割字符串【对某些分割字符，我们需要转义字符】
compareTo	比较两个字符串的大小
toCharArray	转换成字符数组
format	格式字符创，%s 字符串 ，%c代表字符，%d整数，%.2f浮点型

package com.cn.string_;

import java.util.Locale;

/**
 * @author xxx
 * @version 1.0
 */
public class String08 {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "HeLLo";
        //将所有字符转成大写
        System.out.println(str1.toUpperCase());
        //将所有转成小写
        System.out.println(str2.toLowerCase());

        //在字符串后面拼接
        System.out.println(str1.concat("world").concat("java"));//helloworldjava

        String s1 = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        //字符串分割
        String[] s2 = s1.split(",");
        for (int i = 0; i < s2.length;i++) {
            System.out.println(s2[i]);

        }

        //比较两个字符串的大小，如果前者大，
        // 则返回正数，后者大，则返回负数，如果相等，返回 0
        // 解读
        // (1) 如果长度相同，并且每个字符也相同，就返回 0
        // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
        // 就返回 if (c1 != c2) { // return c1 - c2; // }
        // (3) 如果前面的部分都相同，就返回 str1.len - str2.len
        System.out.println(str1.compareTo(str2));

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

        String name = "安子轩";
        int age = 18;
        char gender = '男';
        double score = 99.5;
        //解读
        // 1. %s , %d , %.2f %c 称为占位符
        // 2. 这些占位符由后面变量来替换
        // 3. %s 表示后面由 字符串来替换
        // 4. %d 是整数来替换
        // 5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
        // 6. %c 使用 char 类型来替换
        String formatStr=("姓名是%s年龄时%d性别是%c分数是%.2f");
        String str3 = String.format(formatStr,name,age,gender,score);
        System.out.println(str3);

    }
}