当前位置：网站首页>On CompareTo method in string

On CompareTo method in string

2022-07-29 10:58:00 【51CTO】

I read an article today gitchat The article , The title is Chat Java String Source sorting algorithm , From which I have some insights and thoughts , So I'm going to sum up what I gained in the process of watching

One ,java.lang.Comparable Interface

Comparable The interface forces the sorting of the list of class objects . The order is called natural order , Its compareTo Method , It's called natural comparison

       
       public 
       
       interface 
       
       Comparable
       
       <
       
       T
       
       > {
       
       public 
       
       int 
       
       compareTo(
       
       T 
       
       o);
       
}
      
1.
2.
3.

If you use this Represents the current call to this compareTo Object of method ,obj Is the method passing in parameters
be ：

       
       this  
       
       <  
       
       obj   
       
       ---- 
       
        Return negative 
       
       this  =  
       
       obj   
       
       ---- 
       
        return  
       
       0
       
       this  
       
       >  obj   ----  Return positive number 
      
1.
2.
3.

Comparable Interface compareTo It is an internal comparison , That is, it supports comparison with the current object

Two ,java.util.Comparator Interface

Comparator It can be considered as an external comparator , An object does not support comparing itself with itself （ It didn't come true Comparable Interface ）, But I want to compare the two objects

       
       public 
       
       interface 
       
       Comparator
       
       <
       
       T
       
       > {
       
       int 
       
       compare(
       
       T 
       
       o1, 
       
       T 
       
       o2);
       
       // Omit ...........
       
}
      
1.
2.
3.
4.

Comparative logic

       
       o1  
       
       <  
       
       o2   
       
       ---- 
       
        Return negative 
       
       o1  =  
       
       o2   
       
       ---- 
       
        return  
       
       0
       
       o1  
       
       >  o2   ----  Return positive number 
      
1.
2.
3.

3、 ... and , Chat string Medium compareTo Method

String What is realized in is Comparable Interface for String Object to make comparison logic

       
       public 
       
       final 
       
       class 
       
       String
       
       implements 
       
       java.
       
       io.
       
       Serializable, 
       
       Comparable
       
       <
       
       String
       
       >, 
       
       CharSequence{
       
       //........
       
    }
      
1.
2.
3.
4.

Let's start with an example

       
       /**
       
       *  String comparison case 
       
       */
       
       public 
       
       class 
       
       StringComparisonDemo {
       
       public 
       
       static 
       
       void 
       
       main(
       
       String[] 
       
       args) {
       
       String 
       
       foo 
       
       = 
       
       "ABC";
       
       //  Every character before and after is exactly the same , return  0
       
       String 
       
       bar01 
       
       = 
       
       "ABC";
       
       System.
       
       out.
       
       println(
       
       foo.
       
       compareTo(
       
       bar01));
       
       //  Every character in front is exactly the same , return ： After that is the string length difference 
       
       String 
       
       bar02 
       
       = 
       
       "ABCD";
       
       String 
       
       bar03 
       
       = 
       
       "ABCDE";
       
       System.
       
       out.
       
       println(
       
       foo.
       
       compareTo(
       
       bar02)); 
       
       // -1 ( The front is equal ,foo  The length is small  1)
       
       System.
       
       out.
       
       println(
       
       foo.
       
       compareTo(
       
       bar03)); 
       
       // -2 ( The front is equal ,foo  The length is small  2)
       
       //  Each character before is not exactly the same , return ： Different characters appear  ASCII  Bad 
       
       String 
       
       bar04 
       
       = 
       
       "ABD";
       
       String 
       
       bar05 
       
       = 
       
       "aABCD";
       
       System.
       
       out.
       
       println(
       
       foo.
       
       compareTo(
       
       bar04)); 
       
       // -1 (foo  Of  'C'  character  ASCII  The code value is  67,bar04  Of  'D'  character  ASCII  The code value is  68. return  67 - 68 = -1)
       
       System.
       
       out.
       
       println(
       
       foo.
       
       compareTo(
       
       bar05)); 
       
       // -32 (foo  Of  'A'  character  ASCII  The code value is  65,bar04  Of  'a'  character  ASCII  The code value is  97. return  65 - 97 = -32)
       
       String 
       
       bysocket01 
       
       = 
       
       " mason ";
       
       String 
       
       bysocket02 
       
       = 
       
       " Bricklayer ";
       
       System.
       
       out.
       
       println(
       
       bysocket01.
       
       compareTo(
       
       bysocket02));
       
       // -2049 （ mud   and   Tile  Unicode  Difference value ）
       
    }
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

result ：

Combined with the above example String Chinese vs compareTo Method implementation

       
       public 
       
       int 
       
       compareTo(
       
       String 
       
       anotherString) {
       
       //len1： Current string length 
       
       int 
       
       len1 
       
       = 
       
       value.
       
       length;
       
       //len2： Parameter string length 
       
       int 
       
       len2 
       
       = 
       
       anotherString.
       
       value.
       
       length;
       
       //len1 and len2 The minimum of both 
       
       int 
       
       lim 
       
       = 
       
       Math.
       
       min(
       
       len1, 
       
       len2);
       
       // Respectively into character arrays 
       
       char 
       
       v1[] 
       
       = 
       
       value;
       
       char 
       
       v2[] 
       
       = 
       
       anotherString.
       
       value;
       
       int 
       
       k 
       
       = 
       
       0;
       
       // Comparative logic 
       
       while (
       
       k 
       
       < 
       
       lim) {
       
       char 
       
       c1 
       
       = 
       
       v1[
       
       k];
       
       char 
       
       c2 
       
       = 
       
       v2[
       
       k];
       
       // The characters are different , Two character ASCII  Code difference 
       
       if (
       
       c1 
       
       != 
       
       c2) {
       
       return 
       
       c1 
       
       - 
       
       c2;
       
            }
       
       k
       
       ++;
       
        }
       
       // If it is the same, the difference between the length of two characters is returned 
       
       return 
       
       len1 
       
       - 
       
       len2;
       
    }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

So you can see from the source code above ,string Medium compareTo Logic can be roughly sorted into

Each character in the front of the string is exactly the same , return ： The length difference between the last two strings ;
Each character in the front of the string is different , return ： Different characters appear ASCII Code difference .
Every character in a string is exactly the same , return 0;

stay String There is also a static inner class CaseInsensitiveComparator This interface is also implemented

       
       private 
       
       static 
       
       class 
       
       CaseInsensitiveComparator
       
       implements 
       
       Comparator
       
       <
       
       String
       
       >, 
       
       java.
       
       io.
       
       Serializable{
       
       //.................
       
            }
      
1.
2.
3.
4.

The rewritten interface method is String Object case insensitive comparison method

       
       public 
       
       int 
       
       compare(
       
       String 
       
       s1, 
       
       String 
       
       s2) {
       
       int 
       
       n1 
       
       = 
       
       s1.
       
       length();
       
       int 
       
       n2 
       
       = 
       
       s2.
       
       length();
       
       int 
       
       min 
       
       = 
       
       Math.
       
       min(
       
       n1, 
       
       n2);
       
       for (
       
       int 
       
       i 
       
       = 
       
       0; 
       
       i 
       
       < 
       
       min; 
       
       i
       
       ++) {
       
       char 
       
       c1 
       
       = 
       
       s1.
       
       charAt(
       
       i);
       
       char 
       
       c2 
       
       = 
       
       s2.
       
       charAt(
       
       i);
       
       // Turn capitalization 
       
       if (
       
       c1 
       
       != 
       
       c2) {
       
       c1 
       
       = 
       
       Character.
       
       toUpperCase(
       
       c1);
       
       c2 
       
       = 
       
       Character.
       
       toUpperCase(
       
       c2);
       
       // If not, turn to lowercase 
       
       if (
       
       c1 
       
       != 
       
       c2) {
       
       c1 
       
       = 
       
       Character.
       
       toLowerCase(
       
       c1);
       
       c2 
       
       = 
       
       Character.
       
       toLowerCase(
       
       c2);
       
       // Not the same ： Return different characters ASCII  Code difference .
       
       if (
       
       c1 
       
       != 
       
       c2) {
       
       // No overflow because of numeric promotion
       
       return 
       
       c1 
       
       - 
       
       c2;
       
                        }
       
                    }
       
                }
       
            }
       
       return 
       
       n1 
       
       - 
       
       n2;
       
        }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.