精华内容
下载资源
问答
  • String类

    千次阅读 2015-06-01 18:11:44
    String类 String类获取方法 String类构造方法 String类操作方法 StringBuffer与StringBuilder String类的类型转换

    String类

    • String类获取方法
    • String类构造方法
    • String类操作方法
    • StringBuffer与StringBuilder
    • String类的类型转换

    1.String类获取方法
    String类封装了一系列方法用于操作字符串对象,首先是获取一类的方法,以下部分方法是常用的:
    int    lenght():返回字符串长度
    char charAt(int index):返回指定索引值的字符
    int indexOf(int ch):返回ch在字符串中首次出现的位置(当搜索无结果时返回值为-1)
    boolean endsWith(String str):判断字符串是否以str结尾
    boolean startsWith(String str):判断字符串是否以str开头
    boolean contains(Charsquare s):判断字符串中是否存在s
    boolean equalsIgnoreCase(String str):判断字符串是否与str相同(忽略大小写)


    2.String类构造方法
    常用的构造方法:
    String(char[] ch)
    String(char[] ch,int start,int end)

    char[] ch = new char[]{'a','b','c','d','e','f'};
    String str1 = new String(ch);
    String str2 = new String(ch,0,3);

    3.String类操作方法

    1. 替换
    2. 切割
    3. 子串
    4. 转换

    替换
    String  replace(Charsquare oldstr,Charsquare newstr):将原先的字符串中oldstr替换为newstr,并返回替换后的字符串

    String str1 = "abcd";
    String str2;
    str2 = str1.replace("a","b");
    //str1:abcd
    //str2:bbcd
    String str1 = "abcd";
    String str2;
    str2 = str1.replace("e","b");
    //str1:abcd
    //str2:abcd

    切割
    String  split(String str):切割对象(有连续的有切割标志时会出现空字符串成员)

    子串
    String  substring(int begin,int end):获取指定角标界的子串

    转换
    String  toUpperCase():将字符串全部转换为大写
    String  toLowerCase():将字符串全部转换为小写
    String  trim():去除字符串两端的空格


    4.StringBuffer与StringBuilder
    StringBuffer:字符串缓冲区

    1. 长度可变
    2. 可操作多种数据类型
    3. 通过toString()变为字符串

    添加
    StringBuffer  append(数据):将数据添加入原数据尾部

    插入
    StringBuffer  insert(int index,数据):将数据插入指定角标位置

    删除
    StringBuffer  delete(int strart,int end):删除指定位置的字符串(不包含结束角标字符)

    修改
    StringBuffer  replace(int strart,int end,String str):跟换指定位置的字符串(不包含结束角标字符)
    void  setCharAt(int index,String str):跟换指定位置的字符

    反转
    StringBuffer  reverse(t):反转StringBuffer对象的顺序

    StringBuuffer与StringBuilder的区别
    StringBuffer线程安全,适合多线程使用
    StringBuilder线程不安全,适合单线程使用(也可自行加锁保证线程安全)


    String类的类型转换
    其他数据类型转变为String类型:
    toString()

    String类型转变为整型:
    int  ParseInt(String str)
    int  ParseInt(String str,int 进制数)


    String类是操作字符串类型数据的一个工具类,而字符串的操作也十分常用,因此能够熟练使用String类可以大大方便程序的编写与功能的实现。

    展开全文
  • 深入理解Java String类

    万次阅读 多人点赞 2018-06-28 21:15:55
    在Java语言了中,所有类似“ABC”的字面值,都是String类的实例;String类位于java.lang包下,是Java语言的核心类,提供了字符串的比较、查找、截取、大小写转换等操作;Java语言为“+”连接符(字符串连接符)以及...

    在Java语言中,所有类似“ABC”的字面值,都是String类的实例;String类位于java.lang包下,是Java语言的核心类,提供了字符串的比较、查找、截取、大小写转换等操作;Java语言为“+”连接符(字符串连接符)以及对象转换为字符串提供了特殊的支持,字符串对象可以使用“+”连接其他对象。String类的部分源码如下

    public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence {
        /** The value is used for character storage. */
        private final char value[];
    
        /** Cache the hash code for the string */
        private int hash; // Default to 0
        ...
    }
    

    从上面可以看出
    1)String类被final关键字修饰,意味着String类不能被继承,并且它的成员方法都默认为final方法;字符串一旦创建就不能再修改。
    2)String类实现了Serializable、CharSequence、 Comparable接口。
    3)String实例的值是通过字符数组实现字符串存储的。


    1. “+”连接符

    1.1 “+”连接符的实现原理

    Java语言为“+”连接符以及对象转换为字符串提供了特殊的支持,字符串对象可以使用“+”连接其他对象。其中字符串连接是通过 StringBuilder(或 StringBuffer)类及其append 方法实现的,对象转换为字符串是通过 toString 方法实现的,该方法由 Object 类定义,并可被 Java 中的所有类继承。有关字符连接和转换的更多信息,可以参阅 Gosling、Joy 和 Steele 合著的 《The Java Language Specification》

    我们可以通过反编译验证一下

    /**
     * 测试代码
     */
    public class Test {
        public static void main(String[] args) {
            int i = 10;
            String s = "abc";
            System.out.println(s + i);
        }
    }
    
    /**
     * 反编译后
     */
    public class Test {
        public static void main(String args[]) {    //删除了默认构造函数和字节码
            byte byte0 = 10;      
            String s = "abc";      
            System.out.println((new StringBuilder()).append(s).append(byte0).toString());
        }
    }
    

    由上可以看出,Java中使用"+"连接字符串对象时,会创建一个StringBuilder()对象,并调用append()方法将数据拼接,最后调用toString()方法返回拼接好的字符串。由于append()方法的各种重载形式会调用String.valueOf方法,所以我们可以认为:

    //以下两者是等价的
    s = i + ""
    s = String.valueOf(i);
     
    //以下两者也是等价的
    s = "abc" + i;
    s = new StringBuilder("abc").append(i).toString();
    

    1.2 “+”连接符的效率

    使用“+”连接符时,JVM会隐式创建StringBuilder对象,这种方式在大部分情况下并不会造成效率的损失,不过在进行大量循环拼接字符串时则需要注意。

    String s = "abc";
    for (int i=0; i<10000; i++) {
        s += "abc";
    }
    
    /**
     * 反编译后
     */
    String s = "abc";
    for(int i = 0; i < 1000; i++) {
         s = (new StringBuilder()).append(s).append("abc").toString();    
    }
    

    这样由于大量StringBuilder创建在堆内存中,肯定会造成效率的损失,所以在这种情况下建议在循环体外创建一个StringBuilder对象调用append()方法手动拼接(如上面例子如果使用手动拼接运行时间将缩小到1/200左右)。

    /**
     * 循环中使用StringBuilder代替“+”连接符
     */
    StringBuilder sb = new StringBuilder("abc");
    for (int i = 0; i < 1000; i++) {
        sb.append("abc");
    }
    sb.toString();
    

    与此之外还有一种特殊情况,也就是当"+"两端均为编译期确定的字符串常量时,编译器会进行相应的优化,直接将两个字符串常量拼接好,例如:

    System.out.println("Hello" + "World");
    
    /**
     * 反编译后
     */
    System.out.println("HelloWorld");
    
    /**
     * 编译期确定
     * 对于final修饰的变量,它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。
     * 所以此时的"a" + s1和"a" + "b"效果是一样的。故结果为true。
     */
    String s0 = "ab"; 
    final String s1 = "b"; 
    String s2 = "a" + s1;  
    System.out.println((s0 == s2)); //result = true
    
    /**
     * 编译期无法确定
     * 这里面虽然将s1用final修饰了,但是由于其赋值是通过方法调用返回的,那么它的值只能在运行期间确定
     * 因此s0和s2指向的不是同一个对象,故上面程序的结果为false。
     */
    String s0 = "ab"; 
    final String s1 = getS1(); 
    String s2 = "a" + s1; 
    System.out.println((s0 == s2)); //result = false 
     
    public String getS1() {  
        return "b";   
    }
    

    综上,“+”连接符对于直接相加的字符串常量效率很高,因为在编译期间便确定了它的值,也就是说形如"I"+“love”+“java”; 的字符串相加,在编译期间便被优化成了"Ilovejava"。对于间接相加(即包含字符串引用,且编译期无法确定值的),形如s1+s2+s3; 效率要比直接相加低,因为在编译器不会对引用变量进行优化。

    2. 字符串常量池

    在Java的内存分配中,总共3种常量池,分别是Class常量池运行时常量池字符串常量池

    字符串的分配和其他对象分配一样,是需要消耗高昂的时间和空间的,而且字符串使用的非常多。JVM为了提高性能和减少内存的开销,在实例化字符串的时候进行了一些优化:使用字符串常量池。每当创建字符串常量时,JVM会首先检查字符串常量池,如果该字符串已经存在常量池中,那么就直接返回常量池中的实例引用。如果字符串不存在常量池中,就会实例化该字符串并且将其放到常量池中。由于String字符串的不可变性,常量池中一定不存在两个相同的字符串

    /**
     * 字符串常量池中的字符串只存在一份!
     * 运行结果为true
     */
    String s1 = "hello world!";
    String s2 = "hello world!";
    System.out.println(s1 == s2);
    

    2.1 内存区域

    在HotSpot VM中字符串常量池是通过一个StringTable类实现的,它是一个Hash表,默认值大小长度是1009;这个StringTable在每个HotSpot VM的实例中只有一份,被所有的类共享;字符串常量由一个一个字符组成,放在了StringTable上。要注意的是,如果放进String Pool的String非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降(因为要一个一个找)。

    在JDK6及之前版本,字符串常量池是放在Perm Gen区(也就是方法区)中的,StringTable的长度是固定的1009;在JDK7版本中,字符串常量池被移到了堆中,StringTable的长度可以通过**-XX:StringTableSize=66666**参数指定。至于JDK7为什么把常量池移动到堆上实现,原因可能是由于方法区的内存空间太小且不方便扩展,而堆的内存空间比较大且扩展方便。

    2.2 存放的内容

    在JDK6及之前版本中,String Pool里放的都是字符串常量;在JDK7.0中,由于String.intern()发生了改变,因此String Pool中也可以存放放于堆内的字符串对象的引用。

    /**
     * 运行结果为true false
     */
    String s1 = "AB";
    String s2 = "AB";
    String s3 = new String("AB");
    System.out.println(s1 == s2);
    System.out.println(s1 == s3);
    

    由于常量池中不存在两个相同的对象,所以s1和s2都是指向JVM字符串常量池中的"AB"对象。new关键字一定会产生一个对象,并且这个对象存储在堆中。所以String s3 = new String(“AB”);产生了两个对象:保存在栈中的s3和保存堆中的String对象。
    这里写图片描述

    当执行String s1 = "AB"时,JVM首先会去字符串常量池中检查是否存在"AB"对象,如果不存在,则在字符串常量池中创建"AB"对象,并将"AB"对象的地址返回给s1;如果存在,则不创建任何对象,直接将字符串常量池中"AB"对象的地址返回给s1。

    3. intern方法

    直接使用双引号声明出来的String对象会直接存储在字符串常量池中,如果不是用双引号声明的String对象,可以使用String提供的intern方法。intern 方法是一个native方法,intern方法会从字符串常量池中查询当前字符串是否存在,如果存在,就直接返回当前字符串;如果不存在就会将当前字符串放入常量池中,之后再返回。

    JDK1.7的改动:

    1. 将String常量池 从 Perm 区移动到了 Java Heap区
    2. String.intern() 方法时,如果存在堆中的对象,会直接保存对象的引用,而不会重新创建对象。
    /**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in section 3.10.5 of the
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     *          guaranteed to be from a pool of unique strings.
     */
    public native String intern();
    

    3.1 intern的用法

    static final int MAX = 1000 * 10000;
    static final String[] arr = new String[MAX];
    
    public static void main(String[] args) throws Exception {
        Integer[] DB_DATA = new Integer[10];
        Random random = new Random(10 * 10000);
        for (int i = 0; i < DB_DATA.length; i++) {
            DB_DATA[i] = random.nextInt();
        }
        long t = System.currentTimeMillis();
        for (int i = 0; i < MAX; i++) {
            //arr[i] = new String(String.valueOf(DB_DATA[i % DB_DATA.length]));
             arr[i] = new String(String.valueOf(DB_DATA[i % DB_DATA.length])).intern();
        }
    
        System.out.println((System.currentTimeMillis() - t) + "ms");
        System.gc();
    }
    

    运行的参数是:-Xmx2g -Xms2g -Xmn1500M 上述代码是一个演示代码,其中有两条语句不一样,一条是未使用 intern,一条是使用 intern。结果如下图

    未使用intern,耗时826ms:
    这里写图片描述
    使用intern,耗时2160ms:
    这里写图片描述
    通过上述结果,我们发现不使用 intern 的代码生成了1000w 个字符串,占用了大约640m 空间。 使用了 intern 的代码生成了1345个字符串,占用总空间 133k 左右。其实通过观察程序中只是用到了10个字符串,所以准确计算后应该是正好相差100w 倍。虽然例子有些极端,但确实能准确反应出 intern 使用后产生的巨大空间节省。

    细心的同学会发现使用了 intern 方法后时间上有了一些增长。这是因为程序中每次都是用了 new String 后,然后又进行 intern 操作的耗时时间,这一点如果在内存空间充足的情况下确实是无法避免的,但我们平时使用时,内存空间肯定不是无限大的,不使用 intern 占用空间导致 jvm 垃圾回收的时间是要远远大于这点时间的。 毕竟这里使用了1000w次intern 才多出来1秒钟多的时间。

    4. String、StringBuilder和StringBuffer

    4.1 继承结构

    这里写图片描述

    4.2 主要区别

    1)String是不可变字符序列,StringBuilder和StringBuffer是可变字符序列。
    2)执行速度StringBuilder > StringBuffer > String。
    3)StringBuilder是非线程安全的,StringBuffer是线程安全的。

    5. 总结

    String类是我们使用频率最高的类之一,也是面试官经常考察的题目,下面是一个小测验。

    public static void main(String[] args) {
        String s1 = "AB";
        String s2 = new String("AB");
        String s3 = "A";
        String s4 = "B";
        String s5 = "A" + "B";
        String s6 = s3 + s4;
        System.out.println(s1 == s2);
        System.out.println(s1 == s5);
        System.out.println(s1 == s6);
        System.out.println(s1 == s6.intern());
        System.out.println(s2 == s2.intern());
    }
    

    运行结果:
    这里写图片描述

    解析:真正理解此题目需要清楚以下三点
    1)直接使用双引号声明出来的String对象会直接存储在常量池中;
    2)String对象的intern方法会得到字符串对象在常量池中对应的引用,如果常量池中没有对应的字符串,则该字符串将被添加到常量池中,然后返回常量池中字符串的引用;
    3) 字符串的+操作其本质是创建了StringBuilder对象进行append操作,然后将拼接后的StringBuilder对象用toString方法处理成String对象,这一点可以用javap -c命令获得class文件对应的JVM字节码指令就可以看出来。
    这里写图片描述

    参考文献
    https://docs.oracle.com/javase/8/docs/api/
    https://blog.csdn.net/sinat_19425927/article/details/38663461
    https://www.cnblogs.com/xiaoxi/p/6036701.html
    https://tech.meituan.com/in_depth_understanding_string_intern.html

    展开全文
  • C++中的string类用法简介

    万次阅读 多人点赞 2019-08-21 17:21:17
    本文主要介绍C++中的string类的常见用法。 1. 概述 string是C++标准库的一个重要的部分,主要用于字符串处理。可以使用输入输出流方式直接进行string操作,也可以通过文件等手段进行string操作。同时,C++的算法库...

    本文主要介绍C++中的string类的常见用法。

    1. 概述

    string是C++标准库的一个重要的部分,主要用于字符串处理。可以使用输入输出流方式直接进行string操作,也可以通过文件等手段进行string操作。同时,C++的算法库对string类也有着很好的支持,并且string类还和c语言的字符串之间有着良好的接口。

    2. 常见用法

    2.1 string转换为char*

    方法一:使用 c_str() 方法,代码(stringsimple.cpp)如下:

    #include <string>
    #include <iostream>
    #include <stdio.h>
    
    using namespace std;
    
    int main()
    {
        string strOutput = "Hello World";
    
        cout << "[cout] strOutput is: " << strOutput << endl;
    
        // string 转换为 char*
        const char* pszOutput = strOutput.c_str();
        
        printf("[printf] strOutput is: %s\n", pszOutput);
    
        return 0;
    }
    
    

    编译并执行上述代码,结果如下:

    上述代码执行结果说明:

    • cout 可直接输出 string 类的对象的内容;
    • 使用 c_str() 方法转换 string 类型到 char* 类型时,需要为char*添加 const 关键字;
    • printf() 函数不能直接打印 string 类的对象的内容,可以通过将 string 转换为 char* 类型,再使用 printf() 函数打印。

    2.1.1 data()方法与c_str()方法

    data()方法与c_str()方法相似,都返回 const char* 类型。两者区别和联系如下:

    • 在C++98版本中,c_str()返回 const char* 类型,返回的字符串会以空字符(null character)结尾;
    • 在C++98版本中,data()返回 const char* 类型,返回的字符串不以空字符(null character)结尾;
    • 在C++11版本中,c_str()与data()用法相同(Both string::data and string::c_str are synonyms and return the same value.)

    2.2 计算string长度、string字符串比较

    示例代码如下:

    #include <string>
    #include <iostream>
    
    #define HELLOSTR "Hello World"
    
    using namespace std;
    
    int main()
    {
        string strOutput = "Hello World";
    
        int nLen = strOutput.length();
    
        cout << "the length of strOutput is: " << nLen << endl;
    
        if (0 == strOutput.compare(HELLOSTR))
        {
            cout << "strOutput equal with macro HELLOSTR" << endl;
        }
    
        return 0;
    }

    编译并执行上述代码,结果如下:

    [root@node1 /opt/liitdar/mydemos/simples]# ./stringsimple2 
    the length of strOutput is: 11
    strOutput equal with macro HELLOSTR
    [root@node1 /opt/liitdar/mydemos/simples]# 

    上述代码执行结果说明:

    • string类型可直接使用 length() 方法计算字符串长度,该方法计算结果为字符串的实际长度,如本例中"Hello World"字符串的长度为11;
    • string类型可使用 compare(const string& str) 方法进行字符串比较。

    2.3 string对象判空

    可使用 empty() 方法对string类型的对象进行判空,如下:

        if (str2.empty())
        {
            cout << "str2 is empty." << endl;
        }
    

    2.4 char*、char[]转换为string

    将 char*、char[] 转换为 string 类型时,直接进行赋值操作,将 char*、char[] 的变量赋值给 string 对象即可。

    说明:这里所说的“赋值”操作,实际上是将 char*、char[] 定义的字符串的首地址赋值给 string 对象了。

    示例代码(stringtochar.cpp)如下:

    #include <string>
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        const char* pszName = "liitdar";
        char pszCamp[] = "alliance";
    
        string strName;
        string strCamp;
    
        strName = pszName;
        strCamp = pszCamp;
    
        cout << "strName is: " << strName << endl;
        cout << "strCamp is: " << strCamp << endl;
    
        return 0;
    }

    编译并执行上述代码,结果如下:

    2.5 string类的find方法

    使用string类的find方法,在字符串中检索自字符串是否存在。

    2.5.1 用法

    用法如下:

    size_t find (const string& str, size_t pos = 0) const;
    size_t find (const char* s, size_t pos = 0) const;
    size_t find (const char* s, size_t pos, size_t n) const;
    size_t find (char c, size_t pos = 0) const;

    2.5.2 返回值

    find函数返回值:

    The position of the first character of the first match. If no matches were found, the function returns string::npos.

    size_t is an unsigned integral type (the same as member type string::size_type).

    2.5.3 示例代码

    find方法的示例代码(string_find_test1.cpp)如下:

    #include <string>
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        // 待检索的字符串
        string strOutput = "|0|1|2|";
        // 需要检索的子串
        string strObj = "|1|";
    
        // 子串位于字符串中的位置
        size_t nLoc = strOutput.find(strObj);
        // 如果检索到子串在字符串中,则打印子串的位置
        if (nLoc != string::npos)
        {
            cout << "nLoc is: " << nLoc << endl;
        }
    
        return 0;
    }
    
    

    编译并执行上述代码,结果如下:

    2.6 string类的insert方法

    使用string类的insert方法,向字符串中插入字符(串)。官方的定义如下:

    Inserts additional characters into the string right before the character indicated by pos (or p).

    2.6.1 用法

    string (1) string& insert (size_t pos, const string& str);
    substring (2) string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);
    c-string (3) string& insert (size_t pos, const char* s);
    buffer (4) string& insert (size_t pos, const char* s, size_t n);
    fill (5)

    string& insert (size_t pos, size_t n, char c);

    void insert (iterator p, size_t n, char c);

    single character (6) iterator insert (iterator p, char c);
    range (7)

    template <class InputIterator>

        void insert (iterator p, InputIterator first, InputIterator last);

    2.6.2 示例代码

    insert方法的示例代码(string_insert_test1.cpp)如下:

    #include <iostream>
    #include <string>
    
    using namespace std;
    
    int main()
    {
        string strDemo = "I am";
    
        strDemo.insert(4, " good.");
    
        cout << "strDemo is: " << strDemo << endl;
    
        return 0;
    }
    
    

    编译并执行上述代码,结果如下:

    2.7 int类型转为string类的方法

    这里介绍两种常见的 int 类型转换为 string 类的方法,示例代码如下:

    #include <string>
    #include <iostream>
    #include <sstream>
    
    using namespace std;
    
    int main()
    {
        // 方法1
        int nNum1 = 123;
        stringstream ss;
    
        ss << nNum1;
        string strTest1 = ss.str();
        cout << "strTest1 is: " << strTest1 << endl;
    
        /*
        string strTest2;
        strTest2 << ss;     // stringstream 未定义 << 操作符,故此句报错
        cout << "strTest2 is: " << strTest2 << endl;
        */
    
        string strTest3;
        ss >> strTest3;
        cout << "strTest3 is: " << strTest3 << endl;
    
        // 方法2
        int nNum2 = 456;
        string strTest4;
        strTest4 = to_string(nNum2);    // C++11 标准
        cout << "strTest4 is: " << strTest4 << endl;
    
        return 0;
    }
    
    

    编译并执行上述代码,结果如下:

     

    展开全文
  • String类中split()方法的使用

    万次阅读 多人点赞 2018-09-25 16:24:45
    String类中split()方法的使用 今天在在使用split方法时,发现split()方法很怪异的现象,查询了官方文档和各种资料,总结如下 官方文档是这么介绍的: 大致意思就是 在给定的正则表达式来分割该字符串.此方法...

    String类中split()方法的使用

          今天在在使用split方法时,发现split()方法很怪异的现象,查询了官方文档和各种资料,总结如下

     

          官方文档是这么介绍的:

         大致意思就是 在给定的正则表达式来分割该字符串.此方法返回的数组包含此字符串的子字符串,每个子字符串都由另一个匹配给定表达式的子字符串终止,或者由此字符串末尾终止。数组中的子字符串按它们在此字符串中出现的顺序排列。如果表达式不匹配输入的任何部分,那么所得数组只具有一个元素,即此字符串。.哒哒一大堆,看着拗口又难懂.

         咱们简单来说就是通过使用split()方法,给定一个正则,会根据该正则来将字符串切割,并且返回String类型的数组,这个大家应该都知道,但是在他的重载方法split(String regex,int limit) 中,第二个参数是有点门道的,

         第一个regex是正则,我们都清楚,需要注意如果是要按照"|" "."之类的特殊符号分割,需要加上转义,比如"\\|",不然切割的会不准确

         第二个参数int limit 是要输入一个数值,这个数值n如果 >0 则会执行切割 n-1次,也就是说执行的次数不会超过输入的数值次.数组长度不会大于切割次数,比如下面代码:

    输入limit为数字1,切割执行1-1次 ,也就是0次,所以切割后的数组长度仍然是1,也就是原来的字符串

     

       第二个规则: 如果输入的limit数值是非正数,则执行切割到无限次,数组长度也可以是任何数值,比如下面代码:

     输出结果如下:

    也就是说如果limit为非正数,那么会将字符串所有匹配该正则的全部切割,但是我们也发现没有内容的","变成了空字符串,数组的有效大小并不需要这些空字符串

     

    第三个规则  : 如果输入limit数值等于0,则会执行切割无限次并且去掉该数组最后的所有空字符串

     

    我们可以看到,数组 最后的空字符串被去掉了,但是前方和中间的仍然存在.以后使用split()会不会更加得心应手了呢?

    展开全文
  • String类介绍

    千次阅读 多人点赞 2018-09-17 01:09:42
    一、String类介绍:  String是一个引用数据类型默认为null;  String 为final类型不可更改,不能被继承;  基本类型与String结合都会转换为String类型; 二、String两种赋值方式: 1)直接赋值:String str = ...
  • 深入分析String类

    千次阅读 热门讨论 2020-10-16 22:41:29
    String类代表字符串,Java程序中的所有字符串文字(例如"abc")都被实现为此类实例,例如: String string = "abc"; //相当于: char[] data = {'a','b','c'}; String str = new String(data); 那为什么说String...
  • String类详解

    千次阅读 2019-04-03 22:33:18
    1.String类:即字符串类,其主要构造方法为:  String(String Original),把字符串封装成字符串对象;  举例:String s1 = new String(“hello”);  String(char[] value),把字符数组的数据封装成字符串对象;  ...
  • C++——String类超详细介绍

    万次阅读 多人点赞 2019-06-01 17:32:56
    STL的含义:标准模板库 STL的内容: 容器:数据的仓库 算法:与数据结构相关的算法、通用的算法(和数据结构无关) ...string: array:C11静态顺序表 vector:动态顺序表 list:带头节点的双向循环链表 ...
  • String类中的compareTo方法总结

    万次阅读 多人点赞 2016-12-25 16:09:39
    (尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/53870329冷血之心的博客) ...在此,我总结下关于String类中的compareTo方法,以备应对以后的笔试面试。 String类...
  • Java技术——你真的了解String类的intern()方法吗

    万次阅读 多人点赞 2016-08-23 16:40:53
    String str1 = new String("SEU")+ new String("Calvin"); System.out.println(str1.intern() == str1); System.out.println(str1 == "SEUCalvin"); 本人JDK版本1.8,输出结果为...
  • String类与StringBuffer类区别

    千次阅读 2019-01-26 12:11:26
    在上一篇博客中我讲了String类的特点,其中有一点就是String类的常量一旦声明,不可改变,如果改变对象内容,改变的只是其引用指向而已,通常来讲,String类的操作比较简单,但是由于String类的不可更改特性,就使得...
  • C++string类常用接口说明,深浅拷贝

    万次阅读 多人点赞 2018-11-17 22:55:01
    标准库中的string类 string是表示字符串的字符串类 该类的接口与常规容器的接口基本相同,再添加了一些专门用来操作string的常规操作。 string在底层实际是:basic_string模板类的别名,typedef basic_string&...
  • Android-String类

    千次阅读 2019-02-17 13:38:24
    String类创建的字符串对象是不可修改的,也就是说,String字符串不能修改、删除或者替换字符中的某个字符,即String对象一旦创建,那么实体是不可以发生变化的,例如: String s = new String(“我喜欢散步”) String...
  • C++string类常用函数 c++中的string常用函数用法总结

    万次阅读 多人点赞 2018-06-02 16:55:42
    string类的构造函数: string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 此外,string类还支持默认构造函数和复制构造函数,如string s1;string s2="hello";都是...
  • Java中String类的常用方法

    千次阅读 多人点赞 2019-10-28 14:59:15
    Java中String类的常用方法 1,String类的介绍 String类在java.lang包中,java使用String类创建一个字符串变量,字符串变量属于对象。 String类是所有语言最常用的一个类,用于描述字符串事物。 String类在Java中被...
  • Java的常用类—String类与Object类

    千次阅读 2018-08-06 23:21:47
    在java编程中,字符串类String可以说用得非常普遍,基本所有java程序都会或多或少的用到String类;而Object类,作为Java中所有类的父类,即使不常直接使用,也会经常使用到其中的方法。下面就讲一讲这两个常用类的...
  • 《C++ string类

    千次阅读 2018-06-08 17:51:26
    C++标准库中string类以类型的形式对字符串进行封装,使得它除了像一个存储字符的容器外,更加包含了字符序列的处理操作。   string类所有函数 string类的所有成员函数 函数名称 实现功能 构造函数 ...
  • String类函数成员

    千次阅读 2018-05-22 14:36:46
    整理一下string类 使用时需要包含头文件 #include<string> 使用std命名空间 using std::string using std::wstring 或者 using namespace std; string常用方法 1)构造函数 string str1 = ...
  • String 的常用方法

    千次阅读 2019-04-18 13:58:42
    String 的常用方法 equals 字符串是否相同 equalsIgnoreCase 忽略大小写后字符串是否相同 compareTo 根据字符串中每个字符的Unicode编码进行比较 compareToIgnoreCase 根据字符串中每个字符的...
  • c++string类默认函数实现

    千次阅读 2020-08-28 22:09:57
    c++ string类默认几种函数实现。 //构造函数传const指针 //参数都是取引用 /*class String { public: String(const char *str = NULL);//普通构造函数 String(const String &other);//拷贝构造函数,参数为...
  • String类和StringBuffer类的区别?

    千次阅读 2019-07-30 13:01:00
    String类和StringBuffer类的区别? String类代表字符串类,字符串是常量,它们的值在创建之后不能更改。如果你修改了String的值,就相当于创建了一个新的对象,为不可变类。 StringBuffer类指的是String的字符串...
  • 二、String 1、字符串定义方式: 2、String 常用构造方法 3、String 的字符串的长度 4、String 其他方法 三、StringBuffer 1、StringBuffer 常用方法使用 四、StringBuilder 一、Object ...
  • String类的常用方法

    万次阅读 2017-11-02 21:18:06
    implements Serializable, Comparable<String>, CharSequenceString类不能被继承字符串是常量,它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的,所以可以共享。例如: ...
  • 深入了解String类

    千次阅读 2017-08-24 08:37:09
    一、String类 想要了解一个类,最好的办法就是看这个类的实现源代码,来看一下String类的源码: public final class String implements java.io.Serializable, Comparable, CharSequence { /** The value ...
  • String类常用方法

    千次阅读 2018-07-30 14:21:47
    String在所有的项目开发中都一定要使用到,那么在String类里面提供了一系列的功能操作方法,本次学习其中大部分的操作方法,而对于有一些操作,需要等待全部的知识掌握之后才可以进行后续的学习。 对于系统类的方法...
  • Java String类源码分析

    万次阅读 多人点赞 2016-08-29 22:11:50
    String类介绍 String 类是日常开发中使用最频繁的类之一, String类源码 一 String类 String类被final所修饰,也就是说String对象是不可变量,并发程序最喜欢不可变量了。String类实现了Serializable, ...
  • C# 之 String类常用方法汇总

    千次阅读 多人点赞 2020-06-13 00:11:00
    C# 之 String类常用方法汇总 14个String类的常用方法,字符串比较,字符串截取,字符串连接,字符串转换
  • 简单说明String类为什么是final的

    万次阅读 2020-07-28 10:14:45
    声明为final类的目的 ...下面看String类源码如何保证是不可变的: public final class String implements java.io.Serializable, Comparable<String>, CharSequence { /** The value is used for
  • java String类用法

    千次阅读 2016-07-02 18:50:28
    查看源码就会发现String类为final型的(当然也不可被继承),而且通过查看JDK文档会发现几乎每一个修改String对象的操作,实际上都是创建了一个全新的String对象。  字符串为对象,那么在初始化之前,它的值为null...
  • 程序代码: #include #include ...class String//定义String类 { public: String( );//默认构造函数 String(char *s);//构造函数 String(String &str);//构造函数 ~String();//析构函数 void displ

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 271,489
精华内容 108,595
关键字:

string类