Comparison operations (instance methods) on Strings

Previously discussed: character encoding method

String:

Representating characters by numbers:

The characters are represented (encoded) using the Unicode encoding method
The first 128 codes in the Unicode table are used to represent English characters
The first 128 codes in the Unicode encoding scheme is in fact the ASCII code

The ASCII code table:

0 NUL 1 SOH 2 STX 3 ETX 4 EOT 5 ENQ 6 ACK 7 BEL 8 BS 9 HT 10 NL 11 VT 12 NP 13 CR 14 SO 15 SI 16 DLE 17 DC1 18 DC2 19 DC3 20 DC4 21 NAK 22 SYN 23 ETB 24 CAN 25 EM 26 SUB 27 ESC 28 FS 29 GS 30 RS 31 US 32 SP 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 DEL

The meaning of the == operator in Java

Important fact:

Example:

int x, y; x = ...; y = ...; x == y evaluates to true if the value stored in variable x is equal to the value stored in variable y

Meaning of x == y for String variables x and y:

String x, y; x = ...; y = ...; x == y evaluates to true if the value stored in variable x is equal to the value stored in variable y

What is the value that is stored in a String typed variable ?

Answer: the location of the (text) string !!!
Example:

In other words:

String x, y; x = ...; y = ...; x == y evaluates to true if x and y point to the same location in memory

More specifically:

x == y tests if x and y both point to the same string object !!!
Example:
x == y evaluates to true.
The test x == y does not test whether the strings stored in x and y are equal to one another
Example:
The test x == y will evaluates to false, even when the strings are equal:
But they are different string objects because they are stored in different locations !!!

Java program that illustrates the above:

public class StringEq1 { public static void main( String[] args ) { String a, b, c; a = "Hello"; a = a + " World"; // a = "Hello World" b = a; // b points to the same string as a System.out.println("a = " + a); System.out.println("b = " + b); if ( a == b ) System.out.println("a == b"); else System.out.println("a != b"); /* ============================================================ */ c = "Hello World"; // c contains the same string as a // But: c does not point to the same string System.out.println("a = " + a); System.out.println("c = " + c); if ( a == c ) System.out.println("a == c"); else System.out.println("a != c"); } }

Output of program:

a = Hello World b = Hello World a == b a = Hello World c = Hello World a != c

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Comparing if strings are equal based on their content

The instance method used to compare equality of two strings s1 and s2 based on their content:

s1.equals( s2 ) returns: true if string s1 and s2 contains the same characters false otherwise

Example:

public class StringEq1 { public static void main( String[] args ) { String a, b, c; a = "Hello"; a = a + " World"; // a = "Hello World" b = a; // b points to the same string as a System.out.println("a = " + a); System.out.println("b = " + b); if ( a.equals(b) ) System.out.println("a EQUALS b"); else System.out.println("a NOT EQUALS b"); /* ============================================================ */ c = "Hello World"; // c contains the same string as a // But: c does not point to the same string System.out.println("a = " + a); System.out.println("c = " + c); if ( a.equals(c) ) System.out.println("a EQUALS c"); else System.out.println("a NOT EQUALS c"); } }

Output:

a = Hello World b = Hello World a EQUALS b a = Hello World c = Hello World a EQUALS c (because c contains the same characters as a !!!)

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Comparing if strings are equal without considering upper/lower case difference

The instance method used to compare equality of two strings s1 and s2 without considering upper/lower case difference:

s1.equalsIgnoreCase( s2 ) returns: true if string s1 and s2 contains the same characters when ignoring case difference false otherwise

Examples:

"abc".equalsIgnoreCase( "ABC" ) returns true

Java program that illustrates this fact:

public class StringEq3 { public static void main( String[] args ) { System.out.println( " \"abc\".equals( \"ABC\" ) = " + "abc".equals( "ABC" ) ) ; System.out.println( " \"abc\".equalsIgnoreCase( \"ABC\" ) = " + "abc".equalsIgnoreCase( "ABC" ) ) ; } }

Output:

"abc".equals( "ABC" ) = false "abc".equalsIgnoreCase( "ABC" ) = true

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Ranking 2 strings: compareTo()

The instance method used to rank of two strings s1 and s2 in alpha-numerical order:

s1.compareTo( s2 ) returns: 0 if s1.equals(s2) < 0 if s1 lexicographically preceeds s2 > 0 if s1 lexicographically succeeds s2

The lexicographical ordering of the characters are defined by the ordering of the characters in the ASCII table:

In other words, a partial lexicographical ordering is:

'A' < 'B' < 'C' < ... < 'Z' < '[' < '\' < ... < 'a' < 'b' < ... < 'z' ...

Example:

"abc".compareTo( "abc" ) returns 0 "abc".compareTo( "xyz" ) returns < 0 "abc".compareTo( "ABC" ) returns > 0

Java program:

public class StringComp1 { public static void main( String[] args ) { System.out.println(" \"abc\".compareTo( \"abc\" ) = " + "abc".compareTo( "abc" ) ); System.out.println(" \"abc\".compareTo( \"xyz\" ) = " + "abc".compareTo( "xyz" ) ); System.out.println(" \"abc\".compareTo( \"ABC\" ) = " + "abc".compareTo( "ABC" ) ); } }

Output:

"abc".compareTo( "abc" ) = 0 (so: "abc" is equals to "abc") "abc".compareTo( "xyz" ) = -23 (so: "abc" < "xyz") "abc".compareTo( "ABC" ) = 32 (so: "abc" > "ABC")

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Ranking 2 strings without considering case: compareToIgnoreCase()

The instance method used to rank of two strings s1 and s2 without considering upper/lower case in alpha-numerical order:

s1.compareToIgnoreCase( s2 ) returns: 0 if s1.equals(s2) ignoring upper/lower case < 0 if s1 lexicographically preceeds s2 ignoring upper/lower case > 0 if s1 lexicographically succeeds s2 ignoring upper/lower case

Example:

"abc".compareToIgnoreCase( "abc" ) returns 0 "abc".compareToIgnoreCase( "xyz" ) returns < 0 "abc".compareToIgnoreCase( "ABC" ) returns 0 !!!

Java program:

public class StringComp1 { public static void main( String[] args ) { System.out.println(" \"abc\".compareToIgnoreCase( \"abc\" ) = " + "abc".compareToIgnoreCase( "abc" ) ); System.out.println(" \"abc\".compareToIgnoreCase( \"xyz\" ) = " + "abc".compareToIgnoreCase( "xyz" ) ); System.out.println(" \"abc\".compareToIgnoreCase( \"ABC\" ) = " + "abc".compareToIgnoreCase( "ABC" ) ); } }

Output:

"abc".compareToIgnoreCase( "abc" ) = 0 (so: "abc" is equals to "abc") "abc".compareToIgnoreCase( "xyz" ) = -23 (so: "abc" < "xyz") "abc".compareToIgnoreCase( "ABC" ) = 0 (so: "abc" is now equal to "ABC")

Example Program: (Demo above code)
- Prog file: click here
How to run the program: