精华内容
下载资源
问答
  • String字符串 char类型只能表示一个...在Java中,可以将字符串直接量赋给String类型变量,也可以采用new String(parameter)形式来创建字符串。 String str = "This is String”; //用字符串直接量赋值String...

    String字符串

    char类型只能表示一个字符,而String可以表示字符串,也就是一个字符序列。但String不是基本类型,而是一个定义好的类,是一个引用类型。在Java中,可以将字符串直接量赋给String类型变量,也可以采用new String(parameter)的形式来创建字符串。

    String str = "This is String”; //用字符串直接量赋值
    String str = new String("Create a String through the Constructor"); //String的构造器来创建字符串

    这里表示引用变量str,引用一个内容为This is String 的字符串对象。 但通常情况下,可直接称str变量是一个字符串,无须过于强调细节。

    字符串特点:String类是不可变类,并且被final修饰,无法继承。 字符串对象都是不可变对象,所以对字符串进行操作时,都是返回新的字符串对象,原有字符串不会改变。

    字符串在程序设计中用得非常频繁,所以掌握String字符串的常用方法是很有必要的。例如:

    String普通方法

    length()        //返回字符串中的字符数,即字符串长度。
    charAt(int index) //根据索引位置,返回对应字符。
    toLowerCase()    //把字符串中所有字母字符变成小写。
    toUpperCase()     //把字符串中所有字母字符变成大写。
    toCharArray()     //把字符串转成字符数组,即一个字符对应一个字符数组元素。
    trim()            //消除字符串的两边空白字符。
            String s = "ABCDEF";
            System.out.println(s.length());  //6
            System.out.println(s.charAt(0)); //索引位置0是 A
            String lowerCase = s.toLowerCase();
            System.out.println(lowerCase); //abcdef
            char[] ch = s.toCharArray();
            System.out.println(ch[0]); // A
            System.out.println("  ABC ".trim()); //ABC

     String比较方法

    equals(Object anObject)           //判断当前字符串对象与指定对象是否相等。
    
    equalsIgnoreCase(String anotherString) //判断当前字符串对象与指定String 对象是否相等,忽略大小写。
    
    compareTo(String anotherString)        //按字典顺序比较两个字符串。
    
    compareToIgnoreCase(String str)     //按字典顺序比较两个字符串,忽略大小写 
    
    boolean startsWith(String prefix)    //判断是否以指定字符串作为前缀
    
    boolean startsWith(String prefix, int toffset) //从指定的索引处开始,判断是否以指定字符串作为前缀
    
    boolean endsWith(String suffix)     //当前字符串是否以指定字符串作为后缀。
    
    contains(CharSequence s)         //如果包含指定字符串,则返回 true。否则false

    注意:比较两个字符串内容是否相等时,很多人都会用 ==操作符来比较,但这是错的,下面说一下它们的区别。

    ==操作符和equals方法的区别

    操作符==比较的是变量值是否相同,因为字符串是引用类型,所以操作符==只能检测两个字符串是否指向同一个引用(对象地址),但无法检测字符串对象的内容。操作符==只能用于判断基本类型以及引用类型是否为null。

    要判断两个字符串变量是否相同,应该使用equals()方法来判断。两个对象指向同一引用,则说明内容相等。否则开始循环比较字符串内容。String的equals()方法实现细节:

        public boolean equals(Object anObject) {
            if (this == anObject) {
                return true;
            }
            if (anObject instanceof String) {
                String anotherString = (String)anObject;
                int n = value.length;
                if (n == anotherString.value.length) {
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {
                        if (v1[i] != v2[i])
                            return false;
                        i++;
                    }
                    return true;
                }
            }
            return false;
        }
            String s = "This is String";
            String s1 = s + ""; //产生一个新字符串
            System.out.println(s == s1); //两个字符串对象非同一个引用,返回false
            System.out.println(s.equals(s1)); //两个字符串对象的内容相等,返回true

    总结一下就是:操作符==是直接比较变量的值。若是引用类型变量,则比较引用地址是否相同。而equals()方法是比较引用对象中的内容。

    演示其他比较方法

            String s = "hello world";
            System.out.println(s.equalsIgnoreCase("HELLO WORLD")); //忽略大小写,比较字符串内容。true
            //轮流比较字符,字符不相等时,返回字符相减结果:e - a = 4 [69- 65]
            System.out.println(s.compareTo("hallo world")); 
            //判断前缀
            System.out.println(s.startsWith("hello")); //true
            //判断后缀
            System.out.println(s.endsWith("worlds")); // false
            //是否包含指定字符串
            System.out.println(s.contains("lo wor")); //空白字符串也属于字符,别忽略了

    除此之外,还有截取子字符串substring()、切割字符串split()、根据索引找字符串indexOf()、lastIndexOf()以及替换相应字符串replace()等等方法。若要了解更多方法,可查阅API。

     

    转换字符串 

    有时候,我们需要将某个类型转成字符串来进行操作。例如将数值类型转成字符串,可以很快判断是几位数,可以快速判断是否是回文数。

    方式有两种:采用操作符+拼接成字符串;通过静态方法valueOf(parameter)将相关类型转成对应字符串。

            String s1 = String.valueOf(123);
            String s2 = 123 +"";

    采用操作符+直接转成字符串是最简洁、最方便的。

     

     字符串直接量与new String()的区别

            String s1 = "ABC";
            String s2 = new String(s1); //等价于 new String("ABC");
            String s3 = s1 + "";
            System.out.println(s1 == s2); //false
            System.out.println(s1 == s3); //false

    字符串直接量是一个字符串对象,而new String(s1)会构建一个同类型但不同内存空间的字符串对象。简单来说就是,两者没有指向同一个引用。所以操作符==判断为false。

    s3 = s1 + ""; 这一段是运行时对字符串变量s1进行拼接,所以会产生一个新的字符串对象。所以为false。

    关于对字符串直接量拼接是否相等同内容字符串

    如果直接对字符串直接量进行拼接,而非采用变量形式拼接字符串,比较结果又会不同。

            String c = "C";
            String s1 = "ABC";
            String s2 = "AB" + c; 
            String s3 = "A" + "B" + "C";
            System.out.println(s1 == s2); //false
            System.out.println(s1 == s3); //true

    因为字符串是常量,所以创建“ABC”这个字符串时,会放在常量池中。 但s2指向的字符串对象引用是到运行时才会确定, 所以会导致创建一个新字符串对象。而s3是以字符串直接量来进行拼接,这些字符串在编译时就能确定下来,编译器就在常量池查找是否存在相同的字符串。若已存在,指向同一个字符串对象,否则,另外创建字符串。

     

    除了操作符==判断引用地址外,可以使用System.identityHashcode() 查看内存地址是否相同,identityHashcode() 是根据内存地址生成的哈希值。

     

    可变字符串StringBuilder、StringBuffer

    String是不可变类,字符串都是常量,例如“ABC”会被存储在常量池中。对字符串进行任何更改操作都会产生新的String对象。而StringBuilder与StringBuffer是可变类,它们的字符串对象可以更改,对可变字符串的操作不会生成新的对象,即对同一个字符串对象操作。

    StringBuilder、StringBuffer创建字符串

            StringBuilder sb = new StringBuilder(); //空字符串
            StringBuilder sb1 = new StringBuilder("字符串"); //以String对象作为参数构建字符串

    StringBuilder与StringBuffer构建可变字符串对象都是通过new操作符调用构造方法,不能直接像String一样接收字符串直接量。

    StringBuilder和StringBuffer的使用方式一模一样,两者只需要修改一下类名就可以无缝切换。两者的区别是StringBuilder应用于单线程环境,而StringBuffer应用于多线程环境。所以接下来只以StringBuilder作为示例。 

    可变字符串的常用方法(增删改查)

            append(data)        //将给定数据作为字符串追加到可变字符串尾部
            insert(offset, data)      //将给定数据作为字符串追加到指定的偏移位置
            delete(start, end);       //删除start 到 end -1 的字符
            replace(start, end, str)  //替换start 到 end -1 的字符
            reverse();            //将该字符串进行倒置
            sb.setCharAt(index, ch);; //设置 index 处的字符为给定字符
            StringBuilder sb = new StringBuilder(); //构建空的可变字符串
            sb.append("String is changed");
            System.out.println(sb); //原字符串对象内容被改变 String is changed
            //在下标0处插入123
            sb.insert(0, 123);
            System.out.println(sb); //123String is changed
            //删除 sb字符串的后面7位字符
            sb.delete(sb.length() - 7, sb.length());
            System.out.println(sb); //123String is 
            //替换前三位字符
            sb.replace(0, 3, "!!!");
            System.out.println(sb); //!!!String is 
            //翻转sb字符串
            sb.reverse();
            System.out.println(sb); // si gnirtS!!!
            //设置某个下标的字符内容
            sb.setCharAt(0,'A');
            System.out.println(sb); //Asi gnirtS!!!

    可以看到,对可变字符串作出任何更改操作,都会对其字符串对象进行操作。 相比于String,若是需要大量使用字符串的场景,建议采用可变字符串,可以节省很多内存空间。

    使用可变字符串的场景

    1.将数组内容转成字符串

        public static String toStringWithArray(int[] arr) {
            StringBuilder sb = new StringBuilder("[");
            for(int i = 0; i < arr.length; i++) {
                if(i != arr.length -1) {
                    sb.append(arr[i] + ", ");
                }else {
                    sb.append(arr[i] + "]");
                }
            }
            return sb.toString();
        }

    如果不采用可变字符串,那么在拼接字符串过程中,会产生很多用不到的字符串对象,很浪费内存空间。

     

    凡是需要大量拼接字符串的地方,都应该尽量使用可变字符串来完成,因为效率高,而且不占内存空间。

     

    转载于:https://www.cnblogs.com/fwnboke/p/8529453.html

    展开全文
  • 对String字符串的操作实际上是对其副本(原始拷贝)的操作,原来的字符串一点都没有改变。比如: String s ="a"; 创建了一个字符串 s = s+"b"; 实际上原来的"a"字符串对象已经丢弃了,现在又产生了另一个字符串s+...

    String使用的陷阱

          String一经初始化后,就不会再改变其内容了。对String字符串的操作实际上是对其副本(原始拷贝)的操作,原来的字符串一点都没有改变。比如:

          String s ="a"; 创建了一个字符串

          s = s+"b"; 实际上原来的"a"字符串对象已经丢弃了,现在又产生了另一个字符串s+"b"(也就是"ab")。 如果多次执行这些改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响程序的时间和空间性能,甚至会造成服务器的崩溃。

          相反,StringBuilder和StringBuffer类是对原字符串本身操作的,可以对字符串进行修改而不产生副本拷贝或者产生少量的副本。因此可以在循环中使用。

    【示例8-13】String和StringBuilder在频繁字符串修改时效率测试

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    public class Test {

        public static void main(String[] args) {

            /**使用String进行字符串的拼接*/

            String str8 = "";

            //本质上使用StringBuilder拼接, 但是每次循环都会生成一个StringBuilder对象

            long num1 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间

            long time1 = System.currentTimeMillis();//获取系统的当前时间

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

                str8 = str8 + i;//相当于产生了10000个对象

            }

            long num2 = Runtime.getRuntime().freeMemory();

            long time2 = System.currentTimeMillis();

            System.out.println("String占用内存 : " + (num1 - num2));

            System.out.println("String占用时间 : " + (time2 - time1));

            /**使用StringBuilder进行字符串的拼接*/

            StringBuilder sb1 = new StringBuilder("");

            long num3 = Runtime.getRuntime().freeMemory();

            long time3 = System.currentTimeMillis();

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

                sb1.append(i);

            }

            long num4 = Runtime.getRuntime().freeMemory();

            long time4 = System.currentTimeMillis();

            System.out.println("StringBuilder占用内存 : " + (num3 - num4));

            System.out.println("StringBuilder占用时间 : " + (time4 - time3));

        }

    }

          执行结果如图8-12所示:

    图8-12 示例8-13运行效果图.png

    图8-12 示例8-13运行效果图

    要点:

          1. String:不可变字符序列。

          2. StringBuffer:可变字符序列,并且线程安全,但是效率低。

          3. StringBuilder:可变字符序列,线程不安全,但是效率高(一般用它)。

    展开全文
  • 不变字符序列:String声明是不可变的对象,当修改对象时候就会创建一个新对象 可变字符序列:StringBuffer StringBuilder则可以在原对象上进行修改,不会创建对象 实例分析: /**使用String进行字符串的...

    不变字符序列与可变字符序列

    不变字符序列:String声明的是不可变的对象,当修改对象的时候就会创建一个新的对象
    可变字符序列:StringBuffer StringBuilder则可以在原对象上进行修改,不会创建新的对象

    实例分析:

    /**使用String进行字符串的拼接**/
      String str8="";
      //本质上使用String拼接,但是每次循环都会生成一个String的对象
      long num1=Runtime.getRuntime().freeMemory();//获取系统剩余的内存空间
      long time1=System.currentTimeMillis();//获取系统当前的时间
      for(int i=0;i<5000;i++) {
       str8=str8+i;//相当于产生10000个对象
      }
      long num2=Runtime.getRuntime().freeMemory();//获取系统剩余的内存空间
      long time2=System.currentTimeMillis();//获取系统当前的时间
      System.out.println("String占用的内存:"+(num2-num1));
      System.out.println("String占用的时间:"+(time2-time1));
      
      
      
      
      /**使用StringBuilder进行字符串的拼接**/
      StringBuilder sb1 = new StringBuilder("");
      long num3=Runtime.getRuntime().freeMemory();//获取系统剩余的内存空间
      long time3=System.currentTimeMillis();//获取系统当前的时间
      for(int i=0;i<5000;i++) {
       sb1.append(i);
      }
      long num4=Runtime.getRuntime().freeMemory();//获取系统剩余的内存空间
      long time4=System.currentTimeMillis();//获取系统当前的时间
      System.out.println("StringBuilder占用的内存:"+(num4-num3));
      System.out.println("StringBuilder占用的时间:"+(time4-time3));

    实例结果:

    String占用的内存:-66813416
    String占用的时间:34
    StringBuilder占用的内存:-539648
    StringBuilder占用的时间:0

    总结:
    StringBuilder线程不安全,效率高;
    StringBuffer线程安全,效率低
    String适用于字符串较少并较少对字符串进行操作(例如:追加)的情况

    展开全文
  •   python中字符串是不可变的,所以我们无法更改原字符,但如果非要修改,可以把字符串的一部分复制到新的字符串上,达到修改的功能。   *python中单独的字符也是作为一个字符串使用的。 字符串的编码   python...

    字符串的特点

      字符串的本质是字符序列。
      python中字符串是不可变的,所以我们无法更改原字符,但如果非要修改,可以把字符串的一部分复制到新的字符串上,达到修改的功能。
      *python中单独的字符也是作为一个字符串使用的。

    字符串的编码

      python3直接支持Unicode,可以表示世界上任何书面语言的字符。
      Python3 的字符默认就是16位Unicode编码,ASCII码是Unicode编码的子集。
      使用内置函数ord(可以把字符转换成对应的Unicode码;
      使用内置函数chr0可以把十进制数字转换成对应的字符。
    在这里插入图片描述

    创建字符串

    使用引号创建字符串

      我们可以通过单引号或双引号创建字符串。例如: a=’ abc’ ; b=" sxt"
       使用两种引号的好处是可以创建本身就包含引号的字符串,而不用使用转义字符。例如:
    在这里插入图片描述
      连续三个单引号或三个双引号,可以帮助我们创建多行字符串。如:
    在这里插入图片描述

    空字符串创建

      python允许空字符串的存在,不包含任何字符且长度为零。如:
    在这里插入图片描述

    展开全文
  • String:  String 类代表字符串...字符串缓冲区支持可变的字符串。因为 String 对象是不可变的,所以可以共享。 StringBuilder/StringBuffer:  一个可变的字符序列。Stringbuilder不安全,但速度快(常用),Str...
  • Python的字符串序列

    2019-10-23 20:01:18
    python的字符串是不可变的。我们无法对原字符串进行任何修改,只能将字符串的一部分复制到新建的字符串使用内置函数ord()可以把字符转化成对应的Unicode码 使用内置函数char()可以把十进制数字转化成对应的...
  • 字符串的使用

    2021-06-08 20:49:43
    字符串的本质是:字符序列。 及Python的字符串是不可变的,我们无法对原字符串进行任何的修改。 一,字符串的创建 我们可以通过单双yi
  • NSMutableString的使用 NSString类是不可变的类,一旦别...NSMutableString对象则代表一个字符串序列可变的字符串 1.字符串尾部添加 使用alloc在内存中创建字符串对象后边可以动态的操作这个字符串,修改与添...
  • python字符串创建

    千次阅读 2018-11-04 14:40:22
    python的字符串是不可变的。我们无法对原字符串进行 任何修改,只能将字符串的一部分复制到新建的字符串。 pyhton不支持单字符类型,单字符也是作为一个字符串使用 字符串的编码 python3直接支持Unicode,可以表示...
  • 上一篇介绍了序列类型中的字符串,列表和元组很像,只不过元组是不可变的,可以理解为只读,而列表是可变的。所以本片列表和元组一并总结了(主要还是比较懒)。 列表 创建 用赋值语句创建使用工厂函数list()...
  • NSMutableString对象则代表一个字符序列可变的字符串,而且NSMutableString是NSString的子类,NSString类所包含的方法,NSMutableString都可直接使用,NSMutableString对象也可直接当成NSString对象使
  •   仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串的驻留池中, Python的驻留机制对相同的字符串只保留一份拷贝,后续创建相同字符串时,不会开辟新空间,而是把该字符串的地址赋给新创建的变量。...
  • 第 2 章(2) 字符串 字符串基本特点 很多人初学编程时,总是担心自己数学不行,潜意识里认为数学好才能编程。...Python 不支持单字符类型,单字符也是作为一个长度为1的字符串使用,例如"a"。 ..
  • 序列之一:字符串 (python) 字符串类型是Python中最常见的类型。...字符串是不可变类型,改变一个字符串的元素需要新建一个字符串字符串是由独立的字符组成,并且这些字符可以通过切片操作顺序地访问。 1操
  • python里面有一种重要的数据类型字符串,今天来练习字符串的使用。...这也意味着python取字符串子串花费的时间为常数时间,也意味着python的字符串是不可变的。 我们可以通过双引号或者单引号创建字符...
  • 字符串

    2020-11-04 23:20:49
    字符串字符串基本特点字符串的编码引号创建字符串空字符串和len()函数转义字符字符串连接字符串复制不换行打印从控制台取字符串str()实现数字转型字符串()...Python 的字符串是不可变的,无法对原字符串做任 何修改
  • J2SE 5.0 新增了可变的字符序列 String-Buider 类,提高了增加字符串的效率。 // 创建 String-Buider 类对象 StringBuider beider = new StringBuider(String s); 常用方法: 方法 作用 append() 将任意...
  • 1. 创建并初始化字符串: 1). 使用字符串常量直接初始化 String s="...//利用已存在的字符串常量创建一个新的对象 String (char[] value);//利用一个字符数组创建一个字符串 String(char[] va...
  • 在Python中,字符串属于不可变对象,不支持原地修改,如果需要修改其中的值,只能创建的字符串对象。但确实需要原地修改字符串时,可以使用io.StringIO对象或array模块。 >>> import io
  • 我们先要记住三者特征: String 字符串常量 StringBuffer 字符串变量(线程安全) StringBuilder 字符串变量(非线程安全) ...StringBuffer:是一个可变字符串序列,它与String一样,在内存中保存都是一..
  • 字符串是 Python 中最常用数据类型,不可以改变字符串(不可变对象)。我们可以使用引号( ' 或 " )来创建字符串。 a = "learn" b = 'study' print(a[1]) print(b[1:4:2) 上面learn和study就是两个字符串 可以用...
  • 字符串类型

    2018-12-24 01:50:00
    字符串(Str) 字符串是Python中最常用的数据类型之一,使用单引号或双引号来创建...字符串是不可变序列数据类型,不能直接修改字符串本身,和数字类型一样。Python全面支持Unicode编码,所有的字符串都是Unicode字...
  • 字符串的基本操作

    2019-10-08 13:00:19
    1 #字符串是Python中最常见数据类型。我们可以使用引号('obj')创建字符串创建字符串很简单,只要为变量分配一个值即可。示例如下: 2 >>>target='hello' #创建字符串...不过字符串是不可变的,所以...
  • 字符串

    2018-11-18 18:52:00
    常量对象,使用双引号括起来的字符序列字符串一旦创建,不能改变 字符串的字符使用Unicode字符编码,一个字符占两个字节 可以简单理解为是一个字符数组 String是一个Final类,代表不可变的字符序列 new和+等产生新...
  • 字符串属于有序不可变序列 字符串的创建: x = "我是一个字符串" print(x) 分割字符串 字符串是有序序列因此可以通过索引值取出某个字符, 字符串对象可以通过使用索引值来获取字符,在Python中索引值从0开始 x =...
  • python的字符串是不可变的,我们无法对原字符串做任何修改。但可以将字符串的一部分复制到新字符串达到看起来是修改的结果。 Python不提供单字符类型,也就是char类型,单字符同样是作为字符串使用的。 字符串的编码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 761
精华内容 304
关键字:

创建可变序列的字符串使用