compareTo（）的内部是否有遍历的存在？

技术小菜鸟

本人新手，最近在看compareTo（）方法时在想compareTo（）的内部也是有遍历的存在呢？可是在网上找不到这个，求高手讲讲其中的内部实现

ddd010

1. //android的String类
   
2. /*
   
3. * public int compareTo(String s)
   
4. */
   
5. bool javaLangString_compareTo(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
   
6.     JValue* pResult)
   
7. {
   
8.     /*
   
9.      * Null reference check on "this".  Normally this is performed during
   
10.      * the setup of the virtual method call.  We need to do it before
    
11.      * anything else.  While we're at it, check out the other string,
    
12.      * which must also be non-null.
    
13.      */
    
14.     if ((Object*) arg0 == NULL || (Object*) arg1 == NULL) {
    
15.         dvmThrowNullPointerException(NULL);
    
16.         return false;
    
17.     }
    
18. 
    
19.     /* quick test for comparison with itself */
    
20.     if (arg0 == arg1) {
    
21.         pResult->i = 0;
    
22.         return true;
    
23.     }
    
24. 
    
25.     /*
    
26.      * This would be simpler and faster if we promoted StringObject to
    
27.      * a full representation, lining up the C structure fields with the
    
28.      * actual object fields.
    
29.      */
    
30.     int thisCount, thisOffset, compCount, compOffset;
    
31.     ArrayObject* thisArray;
    
32.     ArrayObject* compArray;
    
33.     const u2* thisChars;
    
34.     const u2* compChars;
    
35.     int minCount, countDiff;
    
36. 
    
37.     thisCount = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_COUNT);
    
38.     compCount = dvmGetFieldInt((Object*) arg1, STRING_FIELDOFF_COUNT);
    
39.     countDiff = thisCount - compCount;
    
40.     minCount = (countDiff < 0) ? thisCount : compCount;
    
41.     thisOffset = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_OFFSET);
    
42.     compOffset = dvmGetFieldInt((Object*) arg1, STRING_FIELDOFF_OFFSET);
    
43.     thisArray = (ArrayObject*)
    
44.         dvmGetFieldObject((Object*) arg0, STRING_FIELDOFF_VALUE);
    
45.     compArray = (ArrayObject*)
    
46.         dvmGetFieldObject((Object*) arg1, STRING_FIELDOFF_VALUE);
    
47.     thisChars = ((const u2*)(void*)thisArray->contents) + thisOffset;
    
48.     compChars = ((const u2*)(void*)compArray->contents) + compOffset;
    
49. 
    
50. #ifdef HAVE__MEMCMP16
    
51.     /*
    
52.      * Use assembly version, which returns the difference between the
    
53.      * characters.  The annoying part here is that 0x00e9 - 0xffff != 0x00ea,
    
54.      * because the interpreter converts the characters to 32-bit integers
    
55.      * *without* sign extension before it subtracts them (which makes some
    
56.      * sense since "char" is unsigned).  So what we get is the result of
    
57.      * 0x000000e9 - 0x0000ffff, which is 0xffff00ea.
    
58.      */
    
59.     int otherRes = __memcmp16(thisChars, compChars, minCount);
    
60. # ifdef CHECK_MEMCMP16
    
61.     int i;
    
62.     for (i = 0; i < minCount; i++) {
    
63.         if (thisChars[i] != compChars[i]) {
    
64.             pResult->i = (s4) thisChars[i] - (s4) compChars[i];
    
65.             if (pResult->i != otherRes) {
    
66.                 badMatch((StringObject*) arg0, (StringObject*) arg1,
    
67.                     pResult->i, otherRes, "compareTo");
    
68.             }
    
69.             return true;
    
70.         }
    
71.     }
    
72. # endif
    
73.     if (otherRes != 0) {
    
74.         pResult->i = otherRes;
    
75.         return true;
    
76.     }
    
77. 
    
78. #else
    
79.     /*
    
80.      * Straightforward implementation, examining 16 bits at a time.  Compare
    
81.      * the characters that overlap, and if they're all the same then return
    
82.      * the difference in lengths.
    
83.      */
    
84.     int i;
    
85.     for (i = 0; i < minCount; i++) {
    
86.         if (thisChars[i] != compChars[i]) {
    
87.             pResult->i = (s4) thisChars[i] - (s4) compChars[i];
    
88.             return true;
    
89.         }
    
90.     }
    
91. #endif
    
92. 
    
93.     pResult->i = countDiff;
    
94.     return true;
    
95. }
    

复制代码

ddd010

1. //openjdk6 的实现
   
2.     /**
   
3.      * Compares two strings lexicographically.
   
4.      * The comparison is based on the Unicode value of each character in
   
5.      * the strings. The character sequence represented by this
   
6.      * <code>String</code> object is compared lexicographically to the
   
7.      * character sequence represented by the argument string. The result is
   
8.      * a negative integer if this <code>String</code> object
   
9.      * lexicographically precedes the argument string. The result is a
   
10.      * positive integer if this <code>String</code> object lexicographically
    
11.      * follows the argument string. The result is zero if the strings
    
12.      * are equal; <code>compareTo</code> returns <code>0</code> exactly when
    
13.      * the {@link #equals(Object)} method would return <code>true</code>.
    
14.      * <p>
    
15.      * This is the definition of lexicographic ordering. If two strings are
    
16.      * different, then either they have different characters at some index
    
17.      * that is a valid index for both strings, or their lengths are different,
    
18.      * or both. If they have different characters at one or more index
    
19.      * positions, let <i>k</i> be the smallest such index; then the string
    
20.      * whose character at position <i>k</i> has the smaller value, as
    
21.      * determined by using the &lt; operator, lexicographically precedes the
    
22.      * other string. In this case, <code>compareTo</code> returns the
    
23.      * difference of the two character values at position <code>k</code> in
    
24.      * the two string -- that is, the value:
    
25.      * <blockquote><pre>
    
26.      * this.charAt(k)-anotherString.charAt(k)
    
27.      * </pre></blockquote>
    
28.      * If there is no index position at which they differ, then the shorter
    
29.      * string lexicographically precedes the longer string. In this case,
    
30.      * <code>compareTo</code> returns the difference of the lengths of the
    
31.      * strings -- that is, the value:
    
32.      * <blockquote><pre>
    
33.      * this.length()-anotherString.length()
    
34.      * </pre></blockquote>
    
35.      *
    
36.      * @param   anotherString   the <code>String</code> to be compared.
    
37.      * @return  the value <code>0</code> if the argument string is equal to
    
38.      *          this string; a value less than <code>0</code> if this string
    
39.      *          is lexicographically less than the string argument; and a
    
40.      *          value greater than <code>0</code> if this string is
    
41.      *          lexicographically greater than the string argument.
    
42.      */
    
43.     public int compareTo(String anotherString) {
    
44.         int len1 = count;
    
45.         int len2 = anotherString.count;
    
46.         int n = Math.min(len1, len2);
    
47.         char v1[] = value;
    
48.         char v2[] = anotherString.value;
    
49.         int i = offset;
    
50.         int j = anotherString.offset;
    
51. 
    
52.         if (i == j) {
    
53.             int k = i;
    
54.             int lim = n + i;
    
55.             while (k < lim) {
    
56.                 char c1 = v1[k];
    
57.                 char c2 = v2[k];
    
58.                 if (c1 != c2) {
    
59.                     return c1 - c2;
    
60.                 }
    
61.                 k++;
    
62.             }
    
63.         } else {
    
64.             while (n-- != 0) {
    
65.                 char c1 = v1[i++];
    
66.                 char c2 = v2[j++];
    
67.                 if (c1 != c2) {
    
68.                     return c1 - c2;
    
69.                 }
    
70.             }
    
71.         }
    
72.         return len1 - len2;
    
73.     }
    

复制代码

ddd010

1. //openjdk6 的实现
   
2.     /**
   
3.      * Compares two strings lexicographically.
   
4.      * The comparison is based on the Unicode value of each character in
   
5.      * the strings. The character sequence represented by this
   
6.      * <code>String</code> object is compared lexicographically to the
   
7.      * character sequence represented by the argument string. The result is
   
8.      * a negative integer if this <code>String</code> object
   
9.      * lexicographically precedes the argument string. The result is a
   
10.      * positive integer if this <code>String</code> object lexicographically
    
11.      * follows the argument string. The result is zero if the strings
    
12.      * are equal; <code>compareTo</code> returns <code>0</code> exactly when
    
13.      * the {@link #equals(Object)} method would return <code>true</code>.
    
14.      * <p>
    
15.      * This is the definition of lexicographic ordering. If two strings are
    
16.      * different, then either they have different characters at some index
    
17.      * that is a valid index for both strings, or their lengths are different,
    
18.      * or both. If they have different characters at one or more index
    
19.      * positions, let <i>k</i> be the smallest such index; then the string
    
20.      * whose character at position <i>k</i> has the smaller value, as
    
21.      * determined by using the &lt; operator, lexicographically precedes the
    
22.      * other string. In this case, <code>compareTo</code> returns the
    
23.      * difference of the two character values at position <code>k</code> in
    
24.      * the two string -- that is, the value:
    
25.      * <blockquote><pre>
    
26.      * this.charAt(k)-anotherString.charAt(k)
    
27.      * </pre></blockquote>
    
28.      * If there is no index position at which they differ, then the shorter
    
29.      * string lexicographically precedes the longer string. In this case,
    
30.      * <code>compareTo</code> returns the difference of the lengths of the
    
31.      * strings -- that is, the value:
    
32.      * <blockquote><pre>
    
33.      * this.length()-anotherString.length()
    
34.      * </pre></blockquote>
    
35.      *
    
36.      * @param   anotherString   the <code>String</code> to be compared.
    
37.      * @return  the value <code>0</code> if the argument string is equal to
    
38.      *          this string; a value less than <code>0</code> if this string
    
39.      *          is lexicographically less than the string argument; and a
    
40.      *          value greater than <code>0</code> if this string is
    
41.      *          lexicographically greater than the string argument.
    
42.      */
    
43.     public int compareTo(String anotherString) {
    
44.         int len1 = count;
    
45.         int len2 = anotherString.count;
    
46.         int n = Math.min(len1, len2);
    
47.         char v1[] = value;
    
48.         char v2[] = anotherString.value;
    
49.         int i = offset;
    
50.         int j = anotherString.offset;
    
51. 
    
52.         if (i == j) {
    
53.             int k = i;
    
54.             int lim = n + i;
    
55.             while (k < lim) {
    
56.                 char c1 = v1[k];
    
57.                 char c2 = v2[k];
    
58.                 if (c1 != c2) {
    
59.                     return c1 - c2;
    
60.                 }
    
61.                 k++;
    
62.             }
    
63.         } else {
    
64.             while (n-- != 0) {
    
65.                 char c1 = v1[i++];
    
66.                 char c2 = v2[j++];
    
67.                 if (c1 != c2) {
    
68.                     return c1 - c2;
    
69.                 }
    
70.             }
    
71.         }
    
72.         return len1 - len2;
    
73.     }
    

复制代码

ddd010

网络问题，发重了。版主删除掉一个。