Typos and small issues in Numbers and Strings -> Characters, Strings tutorial pages

[willy-b]

Hello dev.java team!

Just reporting a few typos and small content issues in the Characters and Strings pages of the Numbers and Strings introductory tutorial, in case they are of interest to fix. Thanks!

---

In the latest version of https://dev.java/learn/numbers-strings/characters/ (archived as is at https://web.archive.org/web/20260428024508/https://dev.java/learn/numbers-strings/characters/ ),

• In the sentence

  This feature is called _autoboxing_—or unboxing, if the conversion goes the other way.

  It seems "_autoboxing_" was intended to be formatted rather than having literal underscores, maybe italicized or something.

• FWIW, the escape sequences table is missing "\s" and "\ LineTerminator (line continuation, no Unicode representation)" despite the title implying it is a complete list of Java escape sequences:

  The following table shows the Java escape sequences:
  Escape Sequence Description
  \t Insert a tab in the text at this point.
  \b Insert a backspace in the text at this point.
  \n Insert a newline in the text at this point.
  \r Insert a carriage return in the text at this point.
  \f Insert a form feed in the text at this point.
  ' Insert a single quote character in the text at this point.
  " Insert a double quote character in the text at this point.
  \ Insert a backslash character in the text at this point.

  See https://docs.oracle.com/javase/specs/jls/se26/html/jls-3.html#jls-3.10.7 to see that "\s" (and "\ LineTerminator (line continuation, no Unicode representation)")) might be included for completeness.

---

In the latest https://dev.java/learn/numbers-strings/strings/ (archived as is at https://web.archive.org/web/20260503024147/https://dev.java/learn/numbers-strings/strings/ ) ,

• There is a missing closing parenthesis at the end of "(Byte, Integer, Double, Float, Long, and Short":

  The Number subclasses that wrap primitive numeric types (Byte, Integer, Double, Float, Long, and Short each provide a class method named valueOf() that converts a string to an object of that type.

• An absent figure is referenced ("shown in the following figure", where?) and StringIndexOutOfBoundsException is warned for the wrong method (should be the filename() method, NOT "extension method"/extension() that can throw an exception when there is no extension separator found):

  As shown in the following figure, our extension method uses lastIndexOf() to locate the last occurrence of the period (.) in the file name. Then substring uses the return value of lastIndexOf() to extract the file name extension — that is, the substring from the period to the end of the string. This code assumes that the file name has a period in it; if the file name does not have a period, lastIndexOf() returns -1, and the substring method throws a StringIndexOutOfBoundsException.

  No such Exception will be thrown for extension(), as long as the entire filename (fullPath) is not empty, as fullPath.lastIndexOf(extensionSeparator) will be -1 and so fullPath.substring(dot+1) will be fullPath.substring(0) which is just fullPath:

  public String extension() {
         int dot = fullPath.lastIndexOf(extensionSeparator);
         return fullPath.substring(dot + 1);
     }
  

  However, the filename() method WILL (unlike extension()) throw an Exception when called on a filename without an instance of extensionSeparator,
  as dot will be -1 and fullPath.substring(sep _+ 1, -1) will be called:

  public String filename() {
         int dot = fullPath.lastIndexOf(extensionSeparator);
         int sep = fullPath.lastIndexOf(pathSeparator);
         return fullPath.substring(sep + 1, dot);
     }
  

• There is a missing closing parenthesis at the end of "(for example, append(), insert(), or setLength()":

  A number of operations (for example, append(), insert(), or setLength() can increase the length of the character sequence in the string builder so that the resultant length() would be greater than the current capacity(). When this happens, the capacity is automatically increased.

---

Thanks very much!

[JosePaumard]

Thank you again for your report! I justed a fix.

[willy-b]

Excellent!

---

For https://dev.java/learn/numbers-strings/characters/ ,

comparing the current version (archived as is at https://web.archive.org/web/20260505193647/https://dev.java/learn/numbers-strings/characters/?cache=false ) with the version the issue was based on https://web.archive.org/web/20260428024508/https://dev.java/learn/numbers-strings/characters/ :

• The sentence which showed explicit underscores around "autoboxing" in the previous version

This feature is called _autoboxing_—or unboxing, if the conversion goes the other way.

has been fixed to italicize the word.

• The escape sequences table which was missing "\s" and "\ LineTerminator (line continuation, no Unicode representation)" despite the title implying it was a complete list of Java escape sequences, now includes "\s" but still excludes "\ LineTerminator (line continuation, no Unicode representation)" (if you ACK "won't fix/intentional" I will close with this).

---

For https://dev.java/learn/numbers-strings/strings/ ,
Comparing the current version (archived as is at https://web.archive.org/web/20260505193906/https://dev.java/learn/numbers-strings/strings/?cache=false ) with the version this issue was based on https://web.archive.org/web/20260503024147/https://dev.java/learn/numbers-strings/strings/ ,

• The previously missing closing parenthesis at the end of "(Byte, Integer, Double, Float, Long, and Short" has been fixed

• For the Filename example showing "The String Class in Action"

  • "As shown in the following figure" when introducing the extension method in the text has been removed as there was no associated figure

  • the extension() and filename() methods have been updated to have defined safe behaviors for when there is no extension separator in the path/filename

    • extension() previously did not throw any IndexOutOfBoundsException in this case and still doesn't but returns an empty string instead of the full path which is an appropriate behavior as there is no extension in that case:

      (previously, in https://web.archive.org/web/20260503024147/https://dev.java/learn/numbers-strings/strings/ )

      public String extension() {
      int dot = fullPath.lastIndexOf(extensionSeparator);
      return fullPath.substring(dot + 1);
      }
      

      has been updated by you/your team to

      (in https://web.archive.org/web/20260505193906/https://dev.java/learn/numbers-strings/strings/?cache=false )

      public String extension() {
        int dot = fullPath.lastIndexOf(extensionSeparator);
        if (dot == -1) {
              return ""; // no dot found, we return an empty extension
          } else {
              return fullPath.substring(dot + 1);
          }
      }
      

    • filename() previously threw a StringIndexOutOfBoundsException when there was no extension separator, but now returns the last part of the path:

      (previously, in https://web.archive.org/web/20260503024147/https://dev.java/learn/numbers-strings/strings/ )

      public String filename() {
       int dot = fullPath.lastIndexOf(extensionSeparator);
       int sep = fullPath.lastIndexOf(pathSeparator);
       return fullPath.substring(sep + 1, dot);
      }
      

      has been updated by you/your team to

      (in https://web.archive.org/web/20260505193906/https://dev.java/learn/numbers-strings/strings/?cache=false )

      // gets filename without extension
      public String filename() {
        int dot = fullPath.lastIndexOf(extensionSeparator);
        int sep = fullPath.lastIndexOf(pathSeparator);
        if (dot == -1) { // no extension
          return fullPath.substring(sep + 1);
        } else {
          return fullPath.substring(sep + 1, dot);
        }
      }
      

  • the text has been updated to describe extension() properly (including the new behavior)

---

For https://dev.java/learn/numbers-strings/string-builders/ ,

• the missing closing parenthesis at the end of "(for example, append(), insert(), or setLength()" has been fixed by you/your team in the latest version archived at https://web.archive.org/web/20260506004102/https://dev.java/learn/numbers-strings/string-builders/?cache=false .

---

• The example used to demonstrate that the "format() method allows you to create a formatted string that you can reuse" seems to be missing the common use case
  of reusing the format string (1st method parameter which abstractly describes the format of the output and can be used multiple times with different values, "A format string as described in Format string syntax"),
  instead simply putting the formatted output string (which cannot be reused with new values), into a variable and printing it.
  The current example is:

  Using String's static format() method allows you to create a formatted string that you can reuse, as opposed to a one-time print statement. For example, instead of

  System.out.printf("The value of the float " +
                   "variable is %f, while " +
                   "the value of the " +
                   "integer variable is %d, " +
                   "and the string is %s",
                   floatVar, intVar, stringVar);
  

  you can write

  String fs;
  fs = String.format("The value of the float " +
                    "variable is %f, while " +
                    "the value of the " +
                    "integer variable is %d, " +
                    " and the string is %s",
                    floatVar, intVar, stringVar);
  IO.println(fs);
  

  Note that "fs" above hardcodes the particular values floatVar, intVar, and stringVar into it, and cannot be reused with new floats,ints, strings (it seems a mistake that the output of String.format was saved into the attended to variable here rather than the format string itself (1st parameter)).

  I would suggest the 2nd part be considered to be changed to:

  String fs = "The value of the float " +
                    "variable is %f, while " +
                    "the value of the " +
                    "integer variable is %d, " +
                    " and the string is %s";
  IO.println(String.format(fs, floatVar1, intVar1, stringVar1)); // could still save output of String.format into a variable but point is that the format string (template) is reused with multiple substitution values
  IO.println(String.format(fs, floatVar2, intVar2, stringVar2));
  

  Thus showing how the format string can be re-used with different substitution values to produce different formatted strings.

---

Thanks very much!

[willy-b]

(P.S. The remaining issue reported above at the end about the discussion of String.format above
is re: https://dev.java/learn/numbers-strings/strings/#creating-format , on the latest, archived as is at https://web.archive.org/web/20260505193906/https://dev.java/learn/numbers-strings/strings/?cache=false#creating-format .)

[JosePaumard]

Thank you again for your report!

[willy-b]

Thanks very much!

Confirmed:

• you added the missing item to the escape sequences table in https://dev.java/learn/numbers-strings/characters/ (as of https://web.archive.org/web/20260507174605/https://dev.java/learn/numbers-strings/characters/ )

  \ followed by a line terminator Does not insert the line terminator in the text at this point.

• and updated the String.format example at https://dev.java/learn/numbers-strings/strings/ (as of version archived at https://web.archive.org/web/20260507174855/https://dev.java/learn/numbers-strings/strings/ ).

I found just a couple of more items (a missing hyperlink and an out of date statement about Unicode support) on the characters page:

---

In the latest version of https://dev.java/learn/numbers-strings/characters/ (archived as is at https://web.archive.org/web/20260507174605/https://dev.java/learn/numbers-strings/characters/ ):

• The sentence

  Java SE 15 supports Unicode 13.0.

  is out of date; Java SE 26 (latest) supports Unicode 17.0 (see https://docs.oracle.com/en/java/javase/26/docs/api/java.base/java/lang/Character.html ).
  The full table of supported values by version (copied from Oracle's document linked above) is:

  Java release	Unicode version
  Java SE 26	Unicode 17.0
  Java SE 24	Unicode 16.0
  Java SE 22	Unicode 15.1
  Java SE 20	Unicode 15.0
  Java SE 19	Unicode 14.0
  Java SE 15	Unicode 13.0
  Java SE 13	Unicode 12.1
  Java SE 12	Unicode 11.0
  Java SE 11	Unicode 10.0
  Java SE 9	Unicode 8.0
  Java SE 8	Unicode 6.2
  Java SE 7	Unicode 6.0
  Java SE 5.0	Unicode 4.0
  Java SE 1.4	Unicode 3.0
  JDK 1.1	Unicode 2.0
  JDK 1.0.2	Unicode 1.1.5

• In

  see the section Autoboxing and Unboxing.

  "Autoboxing and Unboxing" should probably be hyperlinked (to https://dev.java/learn/numbers-strings/autoboxing/ )

---

Thanks!

[JosePaumard]

Thank you again for your report! I just pushed a fix.

[willy-b]

Thanks very much!

As of https://web.archive.org/web/20260508171759/https://dev.java/learn/numbers-strings/characters/ , the other issues mentioned above were resolved, there is just one typo around escape sequences, with an unescaped quotation mark.

In the sentence

For example, if you want to put quotes within quotes you must use the escape sequence, ", on the interior quotes.

The backslash was not escaped in the article and so does not show but it should show "\"" with the backslash. I admit that is an easy mistake to make and it happened to me above in Github issue comments quoting the article that extra backslashes have disappeared in the quoted content, but above it is missing in the article so should be fixed.

Also the flexible Octal Escape pattern might also be considered to be included in the escape sequence list ( https://docs.oracle.com/en/java/javase/26/docs/specs/jls/jls-3.html#jls-OctalEscape ) though there are many places that omit that - I would not block this issue on it (it is a pattern, not a fixed escape, but since there was another typo above, you might include it).

Thanks - very close!

[JosePaumard]

Thank you again for your report! I just pushed a fix.
As for the octal escape... I'm not sure we need to go that far.

[willy-b]

Confirmed: The last issue reported above is fixed as of https://web.archive.org/web/20260511181756/https://dev.java/learn/numbers-strings/characters/ .

I am ready to close this as resolved, but should the "Last update: September 14, 2021" text be updated as Java 26 is now mentioned which was not released until 2026, to avoid confusion?

Thanks!

[JosePaumard]

Thank you again for your report! I updated the date for that page.

[willy-b]

Confirmed:
The issues reported above are fixed as of:
https://web.archive.org/web/20260512175907/https://dev.java/learn/numbers-strings/characters/
https://web.archive.org/web/20260512180016/https://dev.java/learn/numbers-strings/strings/

(plus one typo also fixed in the subsequent page, as of https://web.archive.org/web/20260506004102/https://dev.java/learn/numbers-strings/string-builders/?cache=false , as part of this ticket),

and

That the "Last update" date has been updated for the Characters page where it would be confusing not to update it as recent versions of Java are mentioned (e.g. mentioning Java 26 released in 2026 but having a "Last update" date of 2021 would be impossible).

Thanks very much!