首页 > 其他 > 详细

String类的学习总结

时间:2020-11-22 22:27:34      阅读:32      评论:0      收藏:0      [点我收藏+]

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

String类的学习总结

原文:https://www.cnblogs.com/xuan24/p/14020920.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!