亚洲中字慕日产2020,大陆极品少妇内射AAAAAA,无码av大香线蕉伊人久久,久久精品国产亚洲av麻豆网站

資訊專欄INFORMATION COLUMN

JDK源碼解析之String二

liangdas / 694人閱讀

摘要：如果起始地址小于或者起始地址所比較對(duì)象長(zhǎng)度大于自身對(duì)象長(zhǎng)度，返回假?gòu)乃容^對(duì)象的末尾開(kāi)始比較起始比較和末尾比較都是比較經(jīng)常用得到的方法，例如在判斷一個(gè)字符串是不是協(xié)議的，或者初步判斷一個(gè)文件是不是文件，都可以采用這個(gè)方法進(jìn)行比較。

(28) 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.
      //如果起始地址小于0或者（起始地址+所比較對(duì)象長(zhǎng)度）大于自身對(duì)象長(zhǎng)度，返回假
      if ((toffset < 0) || (toffset > value.length - pc)) {
          return false;
      }
      //從所比較對(duì)象的末尾開(kāi)始比較
      while (--pc >= 0) {
          if (ta[to++] != pa[po++]) {
              return false;
          }
      }
      return true;
  }

(29) public boolean startsWith(String prefix) {

      return startsWith(prefix, 0);
  }

(30) public boolean endsWith(String suffix) {

      return startsWith(suffix, value.length - suffix.value.length);
  }
 起始比較和末尾比較都是比較經(jīng)常用得到的方法，例如在判斷一個(gè)字符串是不是http協(xié)議的，
 或者初步判斷一個(gè)文件是不是mp3文件，都可以采用這個(gè)方法進(jìn)行比較。

(31) public native String intern();

intern方法是Native調(diào)用，它的作用是在方法區(qū)中的常量池里通過(guò)equals方法尋找等值的對(duì)象，
如果沒(méi)有找到則在常量池中開(kāi)辟一片空間存放字符串并返回該對(duì)應(yīng)String的引用，
否則直接返回常量池中已存在String對(duì)象的引用

(32) public String toLowerCase() {

    return toLowerCase(Locale.getDefault());
 }

(33) 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);
}
將字符串的大寫(xiě)轉(zhuǎn)換為小寫(xiě)，將字符串小寫(xiě)轉(zhuǎn)換為大寫(xiě)

（34）public char[] toCharArray() {

      char result[] = new char[value.length];
      System.arraycopy(value, 0, result, 0, value.length);
      return result;
  }
將字符串轉(zhuǎn)化為數(shù)組，由于本身就是數(shù)組的形式，只需將其拷貝即可。

（35） public String[] split(String regex, int limit) {

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

（36）public String[] split(String regex) {

    return split(regex, 0);
 }

對(duì)于字符串 "boo:and:foo",regex為o,limit為5時(shí)，
splite方法首先去字符串里查找regex——o，然后把o做為分隔符，
逐個(gè)把o去掉并且把字符串分開(kāi)，比如，發(fā)現(xiàn)b后面有一個(gè)o，于是把這個(gè)o去掉，
并且把字符串拆成"b", "o:and:foo"兩個(gè)字符串（注意：b后面的兩個(gè)o已經(jīng)去掉了一個(gè)），
接下來(lái)看"o:and:foo"這個(gè)字符串，第一個(gè)字符就是o，
于是o前面相當(dāng)于一個(gè)空串，把這個(gè)o去掉，"o:and:foo"被分開(kāi)成"", ":and:foo"這樣兩個(gè)字符串，
以此類推循環(huán)5次就是splite("o", 5)方法的作用

(37) public static String join(CharSequence delimiter, CharSequence... elements) {

    Objects.requireNonNull(delimiter);
    Objects.requireNonNull(elements);
    // Number of elements not likely worth Arrays.stream overhead.
    StringJoiner joiner = new StringJoiner(delimiter);
    for (CharSequence cs: elements) {
        joiner.add(cs);
    }
    return joiner.toString();
 }

(38) public static String join(CharSequence delimiter,

        Iterable elements) {
    Objects.requireNonNull(delimiter);
    Objects.requireNonNull(elements);
    StringJoiner joiner = new StringJoiner(delimiter);
    for (CharSequence cs: elements) {
        joiner.add(cs);
    }
    return joiner.toString();
}
將已給的數(shù)組用給定的字符進(jìn)行分開(kāi)，返回一個(gè)特定的字符串，例如
String [] strings = {"a","b","c","d"};
 info =  String.join( "a",strings );
 System.out.println( info );
打印的結(jié)果為 aabacad

（39） public static String format(String format, Object... args) {

    return new Formatter().format(format, args).toString();
  }

（40） public static String format(Locale l, String format, Object... args) {

    return new Formatter(l).format(format, args).toString();
  }
  將字符串串格式化為一定格式的形式返回給

（41） 各種各樣的 valueOf(Object obj) 方法

  作用就是將相應(yīng)格式的對(duì)象轉(zhuǎn)換為你字符串的格式

文章版權(quán)歸作者所有，未經(jīng)允許請(qǐng)勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請(qǐng)注明本文地址：http://www.ezyhdfw.cn/yun/77345.html

相關(guān)文章

  • JDK源碼解析系列之object

    摘要：在應(yīng)用程序的一次執(zhí)行到另外一次執(zhí)行，同一對(duì)象的返回的哈希碼無(wú)須保持一致。則是以對(duì)象的哈希碼為實(shí)參，以進(jìn)制無(wú)符號(hào)整數(shù)形式返回此哈希碼的字符串表示形式。 JDK源碼之Object類 1 private static native void registerNatives(); Java中，用native關(guān)鍵字修飾的函數(shù)表明該方法的實(shí)現(xiàn)并不是在Java中去完成，而是由C++去完成，并被編譯成...

    binaryTree 評(píng)論0 收藏0

  • java源碼

    摘要：集合源碼解析回歸基礎(chǔ)，集合源碼解析系列，持續(xù)更新和源碼分析與是兩個(gè)常用的操作字符串的類。這里我們從源碼看下不同狀態(tài)都是怎么處理的。 Java 集合深入理解：ArrayList 回歸基礎(chǔ)，Java 集合深入理解系列，持續(xù)更新~ JVM 源碼分析之 System.currentTimeMillis 及 nanoTime 原理詳解 JVM 源碼分析之 System.currentTimeMi...

    Freeman 評(píng)論0 收藏0

  • dubbo源碼解析（二）Dubbo擴(kuò)展機(jī)制SPI

    摘要：二注解該注解為了保證在內(nèi)部調(diào)用具體實(shí)現(xiàn)的時(shí)候不是硬編碼來(lái)指定引用哪個(gè)實(shí)現(xiàn)，也就是為了適配一個(gè)接口的多種實(shí)現(xiàn)，這樣做符合模塊接口設(shè)計(jì)的可插拔原則，也增加了整個(gè)框架的靈活性，該注解也實(shí)現(xiàn)了擴(kuò)展點(diǎn)自動(dòng)裝配的特性。 Dubbo擴(kuò)展機(jī)制SPI 前一篇文章《dubbo源碼解析（一）Hello,Dubbo》是對(duì)dubbo整個(gè)項(xiàng)目大體的介紹，而從這篇文章開(kāi)始，我將會(huì)從源碼來(lái)解讀dubbo再各個(gè)模塊的實(shí)...

    DirtyMind 評(píng)論0 收藏0

  • 我的阿里之路+Java面經(jīng)考點(diǎn)

    摘要：我的是忙碌的一年，從年初備戰(zhàn)實(shí)習(xí)春招，年三十都在死磕源碼，三月份經(jīng)歷了阿里五次面試，四月順利收到實(shí)習(xí)。因?yàn)槲倚睦砗芮宄?，我的目?biāo)是阿里。所以在收到阿里之后的那晚，我重新規(guī)劃了接下來(lái)的學(xué)習(xí)計(jì)劃，將我的短期目標(biāo)更新成拿下阿里轉(zhuǎn)正。 我的2017是忙碌的一年，從年初備戰(zhàn)實(shí)習(xí)春招，年三十都在死磕JDK源碼，三月份經(jīng)歷了阿里五次面試，四月順利收到實(shí)習(xí)offer。然后五月懷著忐忑的心情開(kāi)始了螞蟻金...

    姘擱『 評(píng)論0 收藏0

發(fā)表評(píng)論

0條評(píng)論

最新活動(dòng)
閱讀需要支付1元查看
<