C# String.charAt方法代码示例

 /*
 public void writeFloat(float v) {
 writeInt(Float.floatToIntBits(v));
 }
 public void writeDouble(double v) {
 writeLong(Double.doubleToLongBits(v));
 }
 */
 public void writeBytes(String s)
 {
     int len = s.length();
     for (int i = 0 ; i < len ; i++) {
     @out.write((byte)s.charAt(i));
     }
     incCount(len);
 }

 public static String quoteReplacement(String s)
 {
     if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
     return s;
     StringBuilder sb = new StringBuilder();
     for (int i=0; i<s.length(); i++) {
     char c = s.charAt(i);
     if (c == '\\' || c == '$') {
         sb.append('\\');
     }
     sb.append(c);
     }
     return sb.toString();
 }

 public Matcher appendReplacement(StringBuffer sb, String replacement)
 {
     // If no match, return error
     if (first < 0)
     throw new InvalidOperationException("No match available");
     // Process substitution string to replace group references with groups
     int cursor = 0;
     StringBuilder result = new StringBuilder();
     while (cursor < replacement.length()) {
     char nextChar = replacement.charAt(cursor);
     if (nextChar == '\\') {
         cursor++;
         nextChar = replacement.charAt(cursor);
         result.append(nextChar);
         cursor++;
     } else if (nextChar == '$') {
         // Skip past $
         cursor++;
         // A StringIndexOutOfBoundsException is thrown if
         // this "$" is the last character in replacement
         // string in current implementation, a IAE might be
         // more appropriate.
         nextChar = replacement.charAt(cursor);
         int refNum = -1;
         if (nextChar == '{') {
             cursor++;
             StringBuilder gsb = new StringBuilder();
             while (cursor < replacement.length()) {
                 nextChar = replacement.charAt(cursor);
                 if (ASCII.isLower(nextChar) ||
                     ASCII.isUpper(nextChar) ||
                     ASCII.isDigit(nextChar)) {
                     gsb.append(nextChar);
                     cursor++;
                 } else {
                     break;
                 }
             }
             if (gsb.length() == 0)
                 throw new IllegalArgumentException(
                     "named capturing group has 0 length name");
             if (nextChar != '}')
                 throw new IllegalArgumentException(
                     "named capturing group is missing trailing '}'");
             String gname = gsb.toString();
             if (ASCII.isDigit(gname.charAt(0)))
                 throw new IllegalArgumentException(
                     "capturing group name {" + gname +
                     "} starts with digit character");
             if (!parentPattern.namedGroups().containsKey(gname))
                 throw new IllegalArgumentException(
                     "No group with name {" + gname + "}");
             refNum = parentPattern.namedGroups().get(gname);
             cursor++;
         } else {
             // The first number is always a group
             refNum = (int)nextChar - '0';
             if ((refNum < 0)||(refNum > 9))
                 throw new IllegalArgumentException(
                     "Illegal group reference");
             cursor++;
             // Capture the largest legal group string
             boolean done = false;
             while (!done) {
                 if (cursor >= replacement.length()) {
                     break;
                 }
                 int nextDigit = replacement.charAt(cursor) - '0';
                 if ((nextDigit < 0)||(nextDigit > 9)) { // not a number
                     break;
                 }
                 int newRefNum = (refNum * 10) + nextDigit;
                 if (groupCount() < newRefNum) {
                     done = true;
                 } else {
                     refNum = newRefNum;
                     cursor++;
                 }
             }
         }
         // Append group
         if (start(refNum) != -1 && end(refNum) != -1)
             result.append(text, start(refNum), end(refNum));
     } else {
         result.append(nextChar);
         cursor++;
     }
     }
     // Append the intervening text
     sb.append(text, lastAppendPosition, first);
     // Append the match substitution
     sb.append(result);
     lastAppendPosition = last;
     return this;
 }

 public void writeChars(String s)
 {
     int len = s.length();
     for (int i = 0 ; i < len ; i++) {
     int v = s.charAt(i);
     @out.write((int)(((uint)v) >> 8) & 0xFF);
     @out.write((int)(((uint)v) >> 0) & 0xFF);
     }
     incCount(len * 2);
 }

 static int writeUTF(String str, DataOutputStream @out)
 {
     int strlen = str.length();
     int utflen = 0;
     int c, count = 0;
     /* use charAt instead of copying String to char array */
     int i;
     for (i = 0; i < strlen; i++) {
     c = str.charAt(i);
     if ((c >= 0x0001) && (c <= 0x007F)) {
         utflen++;
     } else if (c > 0x07FF) {
         utflen += 3;
     } else {
         utflen += 2;
     }
     }
     if (utflen > 65535)
     throw new Exception(
         "encoded string too long: " + utflen + " bytes");
     byte[] bytearr = null;
     if (@out is DataOutputStream) {
     DataOutputStream dos = (DataOutputStream)@out;
     if(dos.bytearr == null || (dos.bytearr.Length < (utflen+2)))
         dos.bytearr = new byte[(utflen*2) + 2];
     bytearr = dos.bytearr;
     } else {
     bytearr = new byte[utflen+2];
     }
     bytearr[count++] = (byte) ((int)(((uint)utflen) >> 8) & 0xFF);
     bytearr[count++] = (byte) ((int)(((uint)utflen) >> 0) & 0xFF);
     i=0;
     for (i=0; i<strlen; i++) {
        c = str.charAt(i);
        if (!((c >= 0x0001) && (c <= 0x007F))) break;
        bytearr[count++] = (byte) c;
     }
     for (;i < strlen; i++){
     c = str.charAt(i);
     if ((c >= 0x0001) && (c <= 0x007F)) {
         bytearr[count++] = (byte) c;
     } else if (c > 0x07FF) {
         bytearr[count++] = (byte) (0xE0 | ((c >> 12) & 0x0F));
         bytearr[count++] = (byte) (0x80 | ((c >>  6) & 0x3F));
         bytearr[count++] = (byte) (0x80 | ((c >>  0) & 0x3F));
     } else {
         bytearr[count++] = (byte) (0xC0 | ((c >>  6) & 0x1F));
         bytearr[count++] = (byte) (0x80 | ((c >>  0) & 0x3F));
     }
     }
     @out.write(bytearr, 0, utflen+2);
     return utflen + 2;
 }