String类的学习总结

1，String的概述

在API中是这样描述：

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

String：字符串，使用一对”“引起来使用，声明为final的，不可被继承，实现了Serializable接口，表示字符串是支持序列化的，也实现了Comparable接口，表示字符串可以比较大小

2，创建字符串对象方式

第一种：直接赋值方式，也叫字面量方式，创建的对象放在方法区的常量池中

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

第二种：通过构造方法创建，创建的对象放在堆内存中

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

俩种方式的比较：==比较的是内存地址，s1,s2是字面量的声明方式，字符串常量池中不能有俩个相同地址的值，所以s1和s2是相同的，而new的方式在堆空间中，new一个对象就是一个对象的地址，不通用，所以结果就是true，false，false

@Test
    public void test2(){

        //此时s1和s2的数据javaEE声明在方法娶中的字符串常量池中
        String s1 = "javaEE";
        String s2 = "javaEE";

        //通过new+ 构造器的方式：此时s3和s4保存的地址值，是数据在堆空间中开辟空间对应的地址值
        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

    }

接下来是字符串拼接时的情况，s4是使用的字面量拼接方法，所以和s3是一样的，而s5这种有变量参与，也就被认为时new的方法，也就是在堆空间中存放，所以地址值和s3就不相同了，剩下的也就明了了，只要是new的情况，就会有一个新的对象，s5和s6也就不相同了

@Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + 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(s5 == s6);//false
    }

总结：

1，通过字面量（区别new的方式）给一个字符串赋值时，此时的字符值声明在字符串常量池中

2，字符串常量池中不会储存相同内容的字符串的

3，String代表不可变的字符序列，简称不可变性，主要体现在以下三点

　　①，当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值

　　②，当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

　　③，当调用String的replace()方法时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

3，字符串中的常用方法

　　Sting的判断

　  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()：把字符串转换为大写字符串 123

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]); 
    } 
}

4，StringBuffer和StringBulider

StringBuilder 是一个可变的字符序列。它继承于AbstractStringBuilder，实现了CharSequence接口。StringBuffffer 也是继承于AbstractStringBuilder的子类；但是，StringBuilder和StringBuffer不同，前者

是非线程安全的，后者是线程安全的。

常用方法

insert

private static void testInsertAPIs(){
    StringBuilder sbuilder = new StringBuilder();
    // 在位置0处插入字符数组
    sbuilder.insert(0, new char[]{'a', 'b', 'c', 'd', 'e'});

    // 在位置0处插入字符数组。0表示字符数组起始位置，3表示长度
    sbuilder.insert(0, new char[]{'A', 'B', 'C', 'D', 'E'}, 0, 3);

    // 在位置0处插入StringBuilder对象
    sbuilder.insert(0, new StringBuilder("StringBuilder"));

    // 在位置0处插入Object对象。此处以HashMap为例
    HashMap map = new HashMap(); 
    map.put("1", "one"); 
    map.put("2", "two"); 
    map.put("3", "three");
    sbuilder.insert(0, map);

    System.out.printf("%s\n\n", sbuilder); 
}

append

private static void testAppendAPIs() {
    StringBuilder sbuilder = new StringBuilder();
    // 追加字符数组 
    sbuilder.append(new char[]{'a','b','c','d','e'});

    // 追加字符数组。0表示字符数组起始位置，3表示长度 
    sbuilder.append(new char[]{'A','B','C','D','E'}, 0, 3);

    // 追加StringBuilder对象 
    sbuilder.append(new StringBuilder("StringBuilder"));

    // 追加Object对象。此处以HashMap为例 
    HashMap map = new HashMap(); 
    map.put("1", "one"); map.put("2", "two"); 
    map.put("3", "three"); 
    sbuilder.append(map); 
    sbuilder.append('\n');

    System.out.printf("%s\n\n", sbuilder);
}

replace

private static void testReplaceAPIs() {
    StringBuilder sbuilder;
    
    sbuilder = new StringBuilder("0123456789"); 
    sbuilder.replace(0, 3, "ABCDE"); 
    System.out.printf("sbuilder=%s\n", sbuilder);

    sbuilder = new StringBuilder("0123456789"); 
    sbuilder.reverse(); 
    System.out.printf("sbuilder=%s\n", sbuilder);

    sbuilder = new StringBuilder("0123456789"); 
    sbuilder.setCharAt(0, 'M'); 
    System.out.printf("sbuilder=%s\n", sbuilder);

    System.out.println();
}

index

private static void testIndexAPIs() {
    StringBuilder sbuilder = new StringBuilder("abcAbcABCabCaBcAbCaBCabc");             
    System.out.printf("sbuilder=%s\n", sbuilder); 
    
    // 1. 从前往后，找出"bc"第一次出现的位置 
    System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\")",   sbuilder.indexOf("bc"));

    // 2. 从位置5开始，从前往后，找出"bc"第一次出现的位置 
    System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\", 5)", sbuilder.indexOf("bc", 5));

    // 3. 从后往前，找出"bc"第一次出现的位置 
    System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\")", sbuilder.lastIndexOf("bc"));

    // 4. 从位置4开始，从后往前，找出"bc"第一次出现的位置 
    System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\", 4)", sbuilder.lastIndexOf("bc", 4)); System.out.println(); 
}

5，小结：

String是字符串常量

StringBuffer是字符串变量（线程安全，效率低）

StringBuilder是字符串变量（线程不安全，效率高）

在大多数情况下三者在执行速度方面的比较：StringBuilder > StringBuffffer > String

解释：

String 类型和 StringBuffffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

而如果是使用 StringBuffffer 类则结果就不一样了，每次结果都会对 StringBuffffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffffer ，特别是字符串对

象经常改变的情况下。为什么是大多数情况呢？

在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffffer 对象慢，而特别是以下的字符串对象生成中，String 效率是远要比 StringBuffffer 快的：

String S1 = “This is only a” + “ simple” + “ test”; 
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个String S1 = “This is only a” + “ simple” + “test”;其实就是：String S1 = “This is only a simple test”;所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：

String S2 = “This is only a”;

String S3 = “ simple”;

String S4 = “ test”;

大部分情况下StringBuilder的速度要大于StringBuffffer：java.lang.StringBuilder一个可变的字符序列是5.0新增的。（大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffffer的）此类提供一个与 StringBuffffer兼容的 API，但不保证同步。该类被设计用作 StringBuffffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffffer 要快。两者的方法基本相同。

对于三者使用的总结：

1）如果要操作少量的数据用 = String

2）单线程操作字符串缓冲区下操作大量数据 = StringBuilder

3）多线程操作字符串缓冲区下操作大量数据 = StringBuffffer

posted @ 2020-11-22 19:51 苏打的博客阅读(198) 评论(0) 收藏举报

刷新页面返回顶部

String类的学习总结

1，String的概述

2，创建字符串对象方式

3，字符串中的常用方法

Sting的判断

String的截取

String的转换

其他方法

4，StringBuffer和StringBulider

常用方法

insert

append

replace

index

5，小结：

公告

　　Sting的判断

　　String的截取

　　String的转换

　　其他方法