常用类-String类（2）

常用方法（3）

    • 源码

      public String trim() {
    int len = value.length;
  int st = 0;
    char[] val = value;    /* avoid getfield opcode */

    while ((st < len) && (val[st] <= ' ')) {
        st++;
    }
    while ((st < len) && (val[len - 1] <= ' ')) {
        len--;
    }
    return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}

  • 大小写转换

    • 转换成大写

    • 源码，啊，这！太长了吧，分析后面再做···

      //toUpperCase()
public String toUpperCase() {
    return toUpperCase(Locale.getDefault());
}
//toUpperCase(Locale locale)
public String toUpperCase(Locale locale) {
    if (locale == null) {
        throw new NullPointerException();
    }

    int firstLower;
    final int len = value.length;

    /* Now check if there are any characters that need to be changed. */
    scan: {
        for (firstLower = 0 ; firstLower < len; ) {
            int c = (int)value[firstLower];
            int srcCount;
            if ((c >= Character.MIN_HIGH_SURROGATE)
                    && (c <= Character.MAX_HIGH_SURROGATE)) {
                c = codePointAt(firstLower);
                srcCount = Character.charCount(c);
            } else {
                srcCount = 1;
            }
            int upperCaseChar = Character.toUpperCaseEx(c);
            if ((upperCaseChar == Character.ERROR)
                    || (c != upperCaseChar)) {
                break scan;
            }
            firstLower += srcCount;
        }
        return this;
    }

    /* result may grow, so i+resultOffset is the write location in result */
    int resultOffset = 0;
    char[] result = new char[len]; /* may grow */

    /* Just copy the first few upperCase characters. */
    System.arraycopy(value, 0, result, 0, firstLower);

    String lang = locale.getLanguage();
    boolean localeDependent =
            (lang == "tr" || lang == "az" || lang == "lt");
    char[] upperCharArray;
    int upperChar;
    int srcChar;
    int srcCount;
    for (int i = firstLower; i < len; i += srcCount) {
        srcChar = (int)value[i];
        if ((char)srcChar >= Character.MIN_HIGH_SURROGATE &&
            (char)srcChar <= Character.MAX_HIGH_SURROGATE) {
            srcChar = codePointAt(i);
            srcCount = Character.charCount(srcChar);
        } else {
            srcCount = 1;
        }
        if (localeDependent) {
            upperChar = ConditionalSpecialCasing.toUpperCaseEx(this, i, locale);
        } else {
            upperChar = Character.toUpperCaseEx(srcChar);
        }
        if ((upperChar == Character.ERROR)
                || (upperChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
            if (upperChar == Character.ERROR) {
                if (localeDependent) {
                    upperCharArray =
                            ConditionalSpecialCasing.toUpperCaseCharArray(this, i, locale);
                } else {
                    upperCharArray = Character.toUpperCaseCharArray(srcChar);
                }
            } else if (srcCount == 2) {
                resultOffset += Character.toChars(upperChar, result, i + resultOffset) - srcCount;
                continue;
            } else {
                upperCharArray = Character.toChars(upperChar);
            }

            /* Grow result if needed */
            int mapLen = upperCharArray.length;
            if (mapLen > srcCount) {
                char[] result2 = new char[result.length + mapLen - srcCount];
                System.arraycopy(result, 0, result2, 0, i + resultOffset);
                result = result2;
            }
            for (int x = 0; x < mapLen; ++x) {
                result[i + resultOffset + x] = upperCharArray[x];
            }
            resultOffset += (mapLen - srcCount);
        } else {
            result[i + resultOffset] = (char)upperChar;
        }
    }
    return new String(result, 0, len + resultOffset);
}

    • 转换成小写

    • 源码，和上个方法类似，这里就不展示完全了

      public String toLowerCase() {
    return toLowerCase(Locale.getDefault());
}

  • 是否以指定前缀开始或指定元素后缀结束

    • 是否以指定前缀开始

    • 源码

      //startsWith(String prefix)
public boolean startsWith(String prefix) {
    return startsWith(prefix, 0);
}
//startsWith(String prefix, int toffset)
public boolean startsWith(String prefix, int toffset) {
    char ta[] = value;
    int to = toffset;
    char pa[] = prefix.value;
    int po = 0;
    int pc = prefix.value.length;
    // Note: toffset might be near -1>>>1.
    if ((toffset < 0) || (toffset > value.length - pc)) {
        return false;
    }
    while (--pc >= 0) {
        if (ta[to++] != pa[po++]) {
            return false;
        }
    }
    return true;
}

    • 是否以指点后缀结束

    • 源码，调用的方法实质是前缀的方法

      public boolean endsWith(String suffix) {
    return startsWith(suffix, value.length - suffix.value.length);
}

  • 例子

    String str1 = "  Hello Yay!  ";
//1 trim(),去掉字符串两边的空格
System.out.println(str1.trim());//输出"Hello Yay!"
//2.1 toUpperCase(),将所有字符转换成大写
System.out.println(str1.toUpperCase());//输出"  HELLO YAY!  "
//2.2 totoLowerCase(),将所有字符转换成小写
System.out.println(str1.toLowerCase());//输出"  hello yay!  "
String str2 = "index.html";
//3.1 startsWith(String prefix)，是否以指定前缀开头
System.out.println(str1.startsWith("index"));//判断是否以"index"开头，输出为true
//3.2 endsWith(String prefix)，是否以指定后缀结尾
System.out.println(str1.endsWith(".html"));//判断是否以".html"开头，输出为true

常用方法（4）

  • 截取字符串

    • 源码

      //substring(int beginIndex)
public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}
//substring(int beginIndex, int endIndex)
public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}

  • 替换字符

    • 源码

      public String replace(CharSequence target, CharSequence replacement) {
    return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
            this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}
//replaceAll(String replacement)
public String replaceAll(String replacement) {
    reset();
    boolean result = find();
    if (result) {
        StringBuffer sb = new StringBuffer();
        do {
            appendReplacement(sb, replacement);
            result = find();
        } while (result);
        appendTail(sb);
        return sb.toString();
    }
    return text.toString();
}

  • 分割字符串

    • 源码

      //split(String regex)
public String[] split(String regex) {
    return split(regex, 0);
}
//split(String regex, int limit)
public String[] split(String regex, int limit) {
    /* fastpath if the regex is a
     (1)one-char String and this character is not one of the
        RegEx's meta characters ".$|()[{^?*+\\", or
     (2)two-char String and the first char is the backslash and
        the second is not the ascii digit or ascii letter.
     */
    char ch = 0;
    if (((regex.value.length == 1 &&
         ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
         (regex.length() == 2 &&
          regex.charAt(0) == '\\' &&
          (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
          ((ch-'a')|('z'-ch)) < 0 &&
          ((ch-'A')|('Z'-ch)) < 0)) &&
        (ch < Character.MIN_HIGH_SURROGATE ||
         ch > Character.MAX_LOW_SURROGATE))
    {
        int off = 0;
        int next = 0;
        boolean limited = limit > 0;
        ArrayList<String> list = new ArrayList<>();
        while ((next = indexOf(ch, off)) != -1) {
            if (!limited || list.size() < limit - 1) {
                list.add(substring(off, next));
                off = next + 1;
            } else {    // last one
                //assert (list.size() == limit - 1);
                list.add(substring(off, value.length));
                off = value.length;
                break;
            }
        }
        // If no match was found, return this
        if (off == 0)
            return new String[]{this};

        // Add remaining segment
        if (!limited || list.size() < limit)
            list.add(substring(off, value.length));

        // Construct result
        int resultSize = list.size();
        if (limit == 0) {
            while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
                resultSize--;
            }
        }
        String[] result = new String[resultSize];
        return list.subList(0, resultSize).toArray(result);
    }
    return Pattern.compile(regex).split(this, limit);
}

  • 例子

    String str = "Java是世界上最好的编程语言，Java真香，就好Java，别的咳嗽！";
//1.substring(int beginIndex)与其重载方法substring(int beginIndex, int endIndex)
//System.out.println(str.substring(-12));//不能小于零，否则抛出异常
System.out.println(str.substring(23));//从头开始截掉23个字符，输出"就好Java，别的咳嗽！"
System.out.println(str.substring(0,15));//从开头截取到第15个字符，输出"Java是世界上最好的编程语言"
//2.replace(CharSequence target, CharSequence replacement)，用新字符或字符串替换掉旧字符或字符串
System.out.println(str.replace("Java","php"));//输出"php是世界上最好的编程语言,php真香，就好php，别的咳嗽！"
//split(String regex)，分割成数组，用正则表达式来表示规则
String[] arr = str.split("，");//注意判断中英文符号
System.out.println(arr.length);//打印数组长度，输出为4
for (String string : arr) {
    System.out.println(string);//遍历数组
}

常用方法（5）

  • 内容是否相同

    • 源码

      //equals(Object anObject)
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;
}
//equalsIgnoreCase(String anotherString),忽略大小写
public boolean equalsIgnoreCase(String anotherString) {
    return (this == anotherString) ? true
            : (anotherString != null)
            && (anotherString.value.length == value.length)
            && regionMatches(true, 0, anotherString, 0, value.length);
}

  • 比较两个字符串

    • 源码，

      public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

  • 例子

    //1.equals(Object anObject)、equalsIgnoreCase(String anotherString)判断两个字符串值是否相同
String str1 = "abc";
String str2 = "Abc";
System.out.println(str1.equals(str2));//输出false
System.out.println(str1.equalsIgnoreCase(str2));//忽略大小写，输出true
//2.compareTo(String anotherString),比较字典顺序
//从第一位开始比，比完长度较短的字符串，有不同则返回差值，停止比较
//若长度一样且对应字符相同，则返回0，否则返回长度差
String s1 = "abc";
String s2 = "xbcde";
String s3 = "abc";
String s4 = "abcdef";
System.out.println(s1.compareTo(s2));//第一位就不同，直接输出a与x的差值：-23
System.out.println(s1.compareTo(s3));//长度相同，对应字符也相同，输出0
System.out.println(s1.compareTo(s4));//长度不同，比完较短字符串的所有字符，都相同，返回长度差：-3

案例演示

  • 需求

    • 已知String str = "this is a text";
    • 1.将str中的单词单独提取出来
    • 2.将str中的text替换为practice
    • 3.在text前面插入一个easy
    • 4.将每个单词的首字母改为大写

  • 解答

    //- 已知`String str = "this is a text";`
String str = "this is a text";
//- 1.将`str`中的单词单独提取出来
System.out.println("================1.将`str`中的单词单独提取出来===============");
String[] arr = str.split(" ");//提取出来放到数组中
for (String s : arr
     ) {
    System.out.println(s);//遍历输出
}
//- 2.将`str`中的`text`替换为`practice`
System.out.println("================2.将`str`中的`text`替换为`practice`===============");
System.out.println(str.replace("text","practice"));
//- 3.在`text`前面插入一个`easy`
System.out.println("================3.在`text`前面插入一个`easy`===============");
String[] arr3 = str.split(" ");//提取出来放到数组中
String newStr3 = "";//创建一个新变量以存放新字符串
for(int i = 0;i < arr3.length;i++){//遍历数组
    if(arr3[i].equals("text")){//如果遍历到"text"，则在其前面添加一个"easy"
        newStr3 += " easy" + " "+arr3[i];//字符串拼接，接收处理后的字符串
        continue;//不执行之后的命令
    }
    newStr3 += " "+arr3[i];//字符串拼接
}
newStr3 = newStr3.trim();//去掉两边的空格
System.out.println(newStr3);
//- 4.将每个单词的首字母改为大写
System.out.println("================4.将每个单词的首字母改为大写===============");
String[] arr4 = str.split(" ");//提取出来放到数组中
String newStr4 = "";//创建一个新变量以存放新字符串
for(int i = 0;i < arr4.length;i++){//遍历数组
    String firstWord = arr4[i].substring(0,1);//提取每个单词的首字母
    String upperFirstWord = firstWord.toUpperCase();//将提取的字母大写
    arr4[i] = arr4[i].replaceFirst(firstWord,upperFirstWord);//将每个单词首字母替换成大写的
    newStr4 += " "+arr4[i];//字符串拼接，接收处理后的字符串
}
newStr4 = newStr4.trim();//去两边空格
System.out.println(newStr4);

可变字符串

  • StringBuffer与StringBuilder，在创建对象时会在内存中预先开辟一片空间，操作数据直接在这片空间内完成，无需再开辟空间，节省资源，运行效率比String快

    • StringBuffer，JDK1.0提供，运行效率较慢、线程安全
    • StringBuilder，JDK5.0提供，运行效率较快、线程不安全

  • 常用方法

    • 追加，有很多重载的方法

    • 添加，同样有很多重载的方法

    • 替换

    • 删除

  • 例子，StringBuffer与StringBuilder的方法一样，将本例中的StringBuffer替换成StringBuilder即可测试

    //创建实例
StringBuffer sb = new StringBuffer();
//1.append(String str)，追加,在原有实例上追加字符或字符串
sb.append("Java真好用");
sb.append(",Java真香");
sb.append(",Java真强大");
System.out.println(sb);//输出"Java很好用,Java真香,Java真强大"
//2.insert(int offset, String str)，添加
String str =  "第一个参数为0表示在最前面添加。";
sb.insert(0,str);//第一个参数表示在第几个字符后插入
System.out.println(sb);//输出"第一个参数为0表示在最前面添加。Java真好用,Java真香,Java真强大"
//3.delete(int start, int end)，删除
sb.delete(0,str.length());//从第几个后的字符开始到底几个字符结束
System.out.println(sb);//输出"Java真好用,Java真香,Java真强大"
//4.replace(int start, int end, String str)，替换
sb.replace(0,4,"php");//替换掉从第几个后的字符开始到底几个字符结束的字符串
System.out.println(sb);//输出"php真好用,Java真香,Java真强大"

  • 字符速度比较

    从1开始往实例中追加，追加到99999，计算所用时间

    //String
long startTime = System.currentTimeMillis();//记录开始时间
String str = "";//创建实例
for(int i = 0;i < 99999;i++){
    str += i;//拼接字符串
}
long endTime = System.currentTimeMillis();//记录结束时间
System.out.println(endTime-startTime);//输出时间差为31338
//StringBuffer 
long startTime = System.currentTimeMillis();//记录开始时间
StringBuffer sb = new StringBuffer();//创建实例
for(int i = 0;i < 99999;i++){
    sb.append(i);//追加
}
long endTime = System.currentTimeMillis();//记录结束时间
System.out.println(endTime-startTime);//输出时间差为15~17之间
//StringBuilder
long startTime = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for(int i = 0;i < 99999;i++){
    sb.append(i);
}
long endTime = System.currentTimeMillis();//记录结束时间
System.out.println(endTime-startTime);//输出时间差为15~17之间

    在本例中，所用时间：String>>StringBuffer≈StringBuilder

posted on 2020-09-13 16:25  C1ao  阅读(85)  评论(0)    收藏  举报

博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3