- improve formatting

- add notes

Author: Vinh Nguyen

common-validator/docs/verhoeff.md

@@ -15,28 +15,28 @@ Apache Commons provides the class `VerhoeffCheckDigit`.
 ```java
 @Test
 public void calculateChecksum()throws CheckDigitException{
-        // given
-        String companyCode="90368002";
-        String expectedChecksum="3";
-
-        // when
-        String actual=VerhoeffCheckDigit.VERHOEFF_CHECK_DIGIT.calculate(companyCode);
-        logger.info("Checksum for {} is {}",companyCode,actual);
-        //then
-        assertEquals(expectedChecksum,actual);
-        }
+    // given
+    String companyCode="90368002";
+    String expectedChecksum="3";
+
+    // when
+    String actual=VerhoeffCheckDigit.VERHOEFF_CHECK_DIGIT.calculate(companyCode);
+    logger.info("Checksum for {} is {}",companyCode,actual);
+    //then
+    assertEquals(expectedChecksum,actual);
+}
 ```
 
 ## Validate a code
 
 ```java
 @Test
 public void validateChecksum(){
-        // given
-        String code="903680023";
-        String faultyCode="1256369654";
-        // when && then
-        assertTrue(VerhoeffCheckDigit.VERHOEFF_CHECK_DIGIT.isValid(code));
-        assertFalse(VerhoeffCheckDigit.VERHOEFF_CHECK_DIGIT.isValid(faultyCode));
-        }
+    // given
+    String code="903680023";
+    String faultyCode="1256369654";
+    // when && then
+    assertTrue(VerhoeffCheckDigit.VERHOEFF_CHECK_DIGIT.isValid(code));
+    assertFalse(VerhoeffCheckDigit.VERHOEFF_CHECK_DIGIT.isValid(faultyCode));
+}
 ```

docs/basics/lang/String.md

@@ -4,6 +4,147 @@ Back to [Main](../../../README.md) ⇒ [Base](../index.md)
 
 * [Java 11 Doc](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html)
 
+## Comparing Strings
+
+```java
+String s1 = "a";
+String s2 = "A";
+String s3 = "B";
+
+// Check if identical
+boolean b = s1.equals(s2);           // false
+
+// Check if identical ignoring case
+b = s1.equalsIgnoreCase(s2);         // true
+
+// Check order of two strings
+int i = s1.compareTo(s2);            // 32; lowercase follows uppercase
+if (i < 0) {
+    // s1 precedes s2
+} else if (i > 0) {
+    // s1 follows s2
+} else {
+    // s1 equals s2
+}
+
+// Check order of two strings ignoring case
+i = s1.compareToIgnoreCase(s3);      // -1
+if (i < 0) {
+    // s1 precedes s3
+} else if (i > 0) {
+    // s1 follows s3
+} else {
+    // s1 equals s3
+}
+
+// A string can also be compared with a StringBuffer;
+// see Constructing a String
+StringBuffer sbuf = new StringBuffer("a");
+b = s1.contentEquals(sbuf);          // true
+```
+
+## Constructing a String
+
+If you are constructing a string with several appends, it may be more efficient to construct it using a `StringBuffer` (synchronized), `StringBuilder` (non-synchronized)  and then convert it to an immutable `String` object.
+
+```java
+StringBuffer buf = new StringBuffer("Java");
+
+// Append
+buf.append(" Almanac v1/");      // Java Almanac v1/
+buf.append(3);                   // Java Almanac v1/3
+
+// Set
+int index = 15;
+buf.setCharAt(index, '.');       // Java Almanac v1.3
+
+// Insert
+index = 5;
+buf.insert(index, "Developers ");// Java Developers Almanac v1.3
+
+// Replace
+int start = 27;
+int end = 28;
+buf.replace(start, end, "4");    // Java Developers Almanac v1.4
+
+// Delete
+start = 24;
+end = 25;
+buf.delete(start, end);          // Java Developers Almanac 1.4
+
+// Convert to string
+String s = buf.toString();
+```
+
+## Converting a Primitive Type Value to a String
+
+There are two ways to convert a primitive type value into a string. 
+The explicit way is to call `String.valueOf()`. 
+The implicit way is to use the string concatenation operator `+`.
+
+```java
+// Use String.valueOf()
+String s = String.valueOf(true);     // true
+s = String.valueOf((byte)0x12);      // 18
+s = String.valueOf((byte)0xFF);      // -1
+s = String.valueOf('a');             // a
+s = String.valueOf((short)123);      // 123
+s = String.valueOf(123);             // 123
+s = String.valueOf(123L);            // 123
+s = String.valueOf(1.23F);           // 1.23
+s = String.valueOf(1.23D);           // 1.23
+
+// Use +
+s = ""+true;                         // true
+s = ""+((byte)0x12);                 // 18
+s = ""+((byte)0xFF);                 // -1
+s = ""+'a';                          // a
+s = ""+((short)123);                 // 123
+s = ""+123;                          // 123
+s = ""+123L;                         // 123
+s = ""+1.23F;                        // 1.23
+s = ""+1.23D;                        // 1.23
+```
+
+## Converting a String to Upper or Lower Case
+
+```java
+// Convert to upper case
+String upper = string.toUpperCase();
+
+// Convert to lower case
+String lower = string.toLowerCase();
+```
+
+## Converting Between Unicode and UTF-8
+
+```java
+try {
+    // Convert from Unicode to UTF-8
+    String string = "abc\u5639\u563b";
+    byte[] utf8 = string.getBytes("UTF-8");
+
+    // Convert from UTF-8 to Unicode
+    string = new String(utf8, "UTF-8");
+} catch (UnsupportedEncodingException e) {
+    
+}
+```
+
+## Determining a Character's Unicode Block
+
+## Determining If a String Contains a Substring
+
+## Determining If a String Is a Legal Java Identifier
+
+## Getting a Substring from a String
+
+## Replacing Characters in a String
+
+## Replacing Substrings in a String
+
+## Searching a String for a Character or a Substring
+
 ## Split Contents
 
 Two methods are available