* k >= Math.min(fromIndex, str.length()) && * this.toString().startsWith(str, k) @@ -1418,7 +1418,7 @@ public abstract String toString(); /** - * Needed by String for the contentEquals method. + * Needed by {@code String} for the contentEquals method. */ final char[] getValue() { return value; --- old/src/share/classes/java/lang/String.java 2012-12-28 16:48:01.041469215 -0500 +++ new/src/share/classes/java/lang/String.java 2012-12-28 16:48:00.865472200 -0500 @@ -615,10 +615,10 @@ } /** - * Returns true if, and only if, {@link #length()} is 0. + * Returns {@code true} if, and only if, {@link #length()} is {@code 0}. * - * @return true if {@link #length()} is 0, otherwise - * false + * @return {@code true} if {@link #length()} is {@code 0}, otherwise + * {@code false} * * @since 1.6 */ @@ -1229,23 +1229,23 @@ /** * Tests if two string regions are equal. *- * A substring of this String object is compared to a substring + * A substring of this {@code String} object is compared to a substring * of the argument other. The result is true if these substrings * represent identical character sequences. The substring of this - * String object to be compared begins at index toffset - * and has length len. The substring of other to be compared - * begins at index ooffset and has length len. The - * result is false if and only if at least one of the following + * {@code String} object to be compared begins at index {@code toffset} + * and has length {@code len}. The substring of other to be compared + * begins at index {@code ooffset} and has length {@code len}. The + * result is {@code false} if and only if at least one of the following * is true: - *
- toffset is negative. - *
- ooffset is negative. - *
- toffset+len is greater than the length of this - * String object. - *
- ooffset+len is greater than the length of the other + *
* * @param toffset the starting offset of the subregion in this string. @@ -1280,28 +1280,28 @@ /** * Tests if two string regions are equal. *
- {@code toffset} is negative. + *
- {@code ooffset} is negative. + *
- {@code toffset+len} is greater than the length of this + * {@code String} object. + *
- {@code ooffset+len} is greater than the length of the other * argument. - *
- There is some nonnegative integer k less than len + *
- There is some nonnegative integer k less than {@code len} * such that: - * this.charAt(toffset+k) != other.charAt(ooffset+k) + *
this.charAt(toffset+k) != other.charAt(ooffset+k)*- * A substring of this String object is compared to a substring - * of the argument other. The result is true if these + * A substring of this {@code String} object is compared to a substring + * of the argument {@code other}. The result is {@code true} if these * substrings represent character sequences that are the same, ignoring - * case if and only if ignoreCase is true. The substring of - * this String object to be compared begins at index - * toffset and has length len. The substring of - * other to be compared begins at index ooffset and - * has length len. The result is false if and only if + * case if and only if {@code ignoreCase} is true. The substring of + * this {@code String} object to be compared begins at index + * {@code toffset} and has length {@code len}. The substring of + * {@code other} to be compared begins at index {@code ooffset} and + * has length {@code len}. The result is {@code false} if and only if * at least one of the following is true: - *
- toffset is negative. - *
- ooffset is negative. - *
- toffset+len is greater than the length of this - * String object. - *
- ooffset+len is greater than the length of the other + *
- * + * * The hash value will never be zero. * * @return a hash code value for this object. --- old/src/share/classes/java/lang/StringBuffer.java 2012-12-28 16:48:01.717457742 -0500 +++ new/src/share/classes/java/lang/StringBuffer.java 2012-12-28 16:48:01.553460527 -0500 @@ -57,7 +57,7 @@ *
- {@code toffset} is negative. + *
- {@code ooffset} is negative. + *
- {@code toffset+len} is greater than the length of this + * {@code String} object. + *
- {@code ooffset+len} is greater than the length of the other * argument. - *
- ignoreCase is false and there is some nonnegative - * integer k less than len such that: + *
- {@code ignoreCase} is {@code false} and there is some nonnegative + * integer k less than {@code len} such that: *
- ** this.charAt(toffset+k) != other.charAt(ooffset+k) *- ignoreCase is true and there is some nonnegative - * integer k less than len such that: + *
- {@code ignoreCase} is {@code true} and there is some nonnegative + * integer k less than {@code len} such that: *
* Character.toLowerCase(this.charAt(toffset+k)) != Character.toLowerCase(other.charAt(ooffset+k)) @@ -1500,12 +1500,12 @@ * of {@code ch} in the range from 0 to 0xFFFF (inclusive), * this is the smallest value k such that: ** is true. For other values of {@code ch}, it is the * smallest value k such that: *- * (this.charAt(k) == ch) && (k >= fromIndex) + * (this.charAt(k) == ch) {@code &&} (k >= fromIndex) ** is true. In either case, if no such character occurs in this * string at or after position {@code fromIndex}, then @@ -1604,12 +1604,12 @@ * from 0 to 0xFFFF (inclusive), the index returned is the largest * value k such that: *- * (this.codePointAt(k) == ch) && (k >= fromIndex) + * (this.codePointAt(k) == ch) {@code &&} (k >= fromIndex) ** is true. For other values of {@code ch}, it is the * largest value k such that: *- * (this.charAt(k) == ch) && (k <= fromIndex) + * (this.charAt(k) == ch) {@code &&} (k <= fromIndex) ** is true. In either case, if no such character occurs in this * string at or before position {@code fromIndex}, then @@ -1690,7 +1690,7 @@ * *- * (this.codePointAt(k) == ch) && (k <= fromIndex) + * (this.codePointAt(k) == ch) {@code &&} (k <= fromIndex) *The returned index is the smallest value k for which: *
* If no such value of k exists, then {@code -1} is returned. * @@ -1799,7 +1799,7 @@ * *- * k >= fromIndex && this.startsWith(str, k) + * k >= fromIndex {@code &&} this.startsWith(str, k) *The returned index is the largest value k for which: *
* If no such value of k exists, then {@code -1} is returned. * @@ -2080,17 +2080,18 @@ * href="../util/regex/Pattern.html#sum">regular expression. * *- * k <= fromIndex && this.startsWith(str, k) + * k {@code <=} fromIndex {@code &&} this.startsWith(str, k) *An invocation of this method of the form - * str.matches(regex) yields exactly the + * str{@code .matches(}regex{@code )} yields exactly the * same result as the expression * - *
{@link java.util.regex.Pattern}.{@link - * java.util.regex.Pattern#matches(String,CharSequence) - * matches}(regex, str)+ *+ * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#matches(String,CharSequence) + * matches(regex, str)} + ** * @param regex * the regular expression to which this string is to be matched * - * @return true if, and only if, this string matches the + * @return {@code true} if, and only if, this string matches the * given regular expression * * @throws PatternSyntaxException @@ -2124,18 +2125,20 @@ * given replacement. * *An invocation of this method of the form - * str.replaceFirst(regex, repl) + * str{@code .replaceFirst(}regex{@code ,} repl{@code )} * yields exactly the same result as the expression * - *
- * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile - * compile}(regex).{@link - * java.util.regex.Pattern#matcher(java.lang.CharSequence) - * matcher}(str).{@link java.util.regex.Matcher#replaceFirst - * replaceFirst}(repl)+ *+ ** *+ * {@link java.util.regex.Pattern}.{@link + * java.util.regex.Pattern#compile compile}(regex).{@link + * java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(str).{@link + * java.util.regex.Matcher#replaceFirst replaceFirst}(repl) + *+ *- * Note that backslashes (\) and dollar signs ($) in the + * Note that backslashes ({@code \}) and dollar signs ({@code $}) in the * replacement string may cause the results to be different than if it were * being treated as a literal replacement string; see * {@link java.util.regex.Matcher#replaceFirst}. @@ -2147,7 +2150,7 @@ * @param replacement * the string to be substituted for the first match * - * @return The resulting String + * @return The resulting {@code String} * * @throws PatternSyntaxException * if the regular expression's syntax is invalid @@ -2167,18 +2170,20 @@ * given replacement. * *
An invocation of this method of the form - * str.replaceAll(regex, repl) + * str{@code .replaceAll(}regex{@code ,} repl{@code )} * yields exactly the same result as the expression * - *
- * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile - * compile}(regex).{@link - * java.util.regex.Pattern#matcher(java.lang.CharSequence) - * matcher}(str).{@link java.util.regex.Matcher#replaceAll - * replaceAll}(repl)+ *+ ** *+ * {@link java.util.regex.Pattern}.{@link + * java.util.regex.Pattern#compile compile}(regex).{@link + * java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(str).{@link + * java.util.regex.Matcher#replaceAll replaceAll}(repl) + *+ *- * Note that backslashes (\) and dollar signs ($) in the + * Note that backslashes ({@code \}) and dollar signs ({@code $}) in the * replacement string may cause the results to be different than if it were * being treated as a literal replacement string; see * {@link java.util.regex.Matcher#replaceAll Matcher.replaceAll}. @@ -2190,7 +2195,7 @@ * @param replacement * the string to be substituted for each match * - * @return The resulting String + * @return The resulting {@code String} * * @throws PatternSyntaxException * if the regular expression's syntax is invalid @@ -2234,7 +2239,7 @@ * expression does not match any part of the input then the resulting array * has just one element, namely this string. * - *
The limit parameter controls the number of times the + *
The {@code limit} parameter controls the number of times the * pattern is applied and therefore affects the length of the resulting * array. If the limit n is greater than zero then the pattern * will be applied at most n - 1 times, the array's @@ -2245,7 +2250,7 @@ * the pattern will be applied as many times as possible, the array can * have any length, and trailing empty strings will be discarded. * - *
The string "boo:and:foo", for example, yields the + *
The string {@code "boo:and:foo"}, for example, yields the * following results with these parameters: * *
* *@@ -2256,33 +2261,34 @@ * *
+ * : *2 - *{ "boo", "and:foo" } {@code { "boo", "and:foo" }} *+ * : *5 - *{ "boo", "and", "foo" } {@code { "boo", "and", "foo" }} *+ * : *-2 - *{ "boo", "and", "foo" } {@code { "boo", "and", "foo" }} *+ * o *5 - *{ "b", "", ":and:f", "", "" } {@code { "b", "", ":and:f", "", "" }} *+ * o *-2 - *{ "b", "", ":and:f", "", "" } {@code { "b", "", ":and:f", "", "" }} *+ * o *0 - *{ "b", "", ":and:f" } {@code { "b", "", ":and:f" }} *An invocation of this method of the form - * str.split(regex, n) + * str.{@code split(}regex{@code ,} n{@code )} * yields the same result as the expression * *
- * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile - * compile}(regex).{@link - * java.util.regex.Pattern#split(java.lang.CharSequence,int) - * split}(str, n) + ** * @@ -2364,7 +2370,7 @@ * argument of zero. Trailing empty strings are therefore not included in * the resulting array. * - *+ * {@link java.util.regex.Pattern}.{@link + * java.util.regex.Pattern#compile compile}(regex).{@link + * java.util.regex.Pattern#split(java.lang.CharSequence,int) split}(str, n) + **The string "boo:and:foo", for example, yields the following + *
The string {@code "boo:and:foo"}, for example, yields the following * results with these expressions: * *
* * @@ -2815,7 +2821,7 @@ * limited by the maximum dimension of a Java array as defined by * The Java™ Virtual Machine Specification. * The behaviour on a - * null argument depends on the conversion. * * @throws java.util.IllegalFormatException @@ -2828,7 +2834,7 @@ * formatter class specification. * * @throws NullPointerException - * If the format is null + * If the {@code format} is {@code null} * * @return A formatted string * @@ -2845,7 +2851,7 @@ * * @param l * The {@linkplain java.util.Locale locale} to apply during - * formatting. If l is null then no localization + * formatting. If {@code l} is {@code null} then no localization * is applied. * * @param format @@ -2859,7 +2865,7 @@ * limited by the maximum dimension of a Java array as defined by * The Java™ Virtual Machine Specification. * The behaviour on a - * null argument depends on the conversion. * * @throws java.util.IllegalFormatException @@ -2872,7 +2878,7 @@ * formatter class specification * * @throws NullPointerException - * If the format is null + * If the {@code format} is {@code null} * * @return A formatted string * @@ -3143,7 +3149,7 @@ * programmer should be aware that producing distinct integer results * for unequal objects may improve the performance of hash tables. *@@ -2373,9 +2379,9 @@ *
Result * *+ * : - *{ "boo", "and", "foo" } {@code { "boo", "and", "foo" }} *+ * o - *{ "b", "", ":and:f" } {@code { "b", "", ":and:f" }} ** In general, if sb refers to an instance of a {@code StringBuffer}, * then {@code sb.append(x)} has the same effect as - * {@code sb.insert(sb.length(), x)}. + * {@code sb.insert(sb.length(), x)}. *
* Whenever an operation occurs involving a source sequence (such as * appending or inserting from a source sequence), this class synchronizes @@ -80,7 +80,7 @@ * * As of release JDK 5, this class has been supplemented with an equivalent * class designed for use by a single thread, {@link StringBuilder}. The - * StringBuilder class should generally be used in preference to + * {@code StringBuilder} class should generally be used in preference to * this one, as it supports all of the same operations but it is faster, as * it performs no synchronization. * @@ -262,17 +262,17 @@ } /** - * Appends the specified StringBuffer to this sequence. + * Appends the specified {@code StringBuffer} to this sequence. *
- * The characters of the StringBuffer argument are appended, - * in order, to the contents of this StringBuffer, increasing the - * length of this StringBuffer by the length of the argument. - * If sb is null, then the four characters - * "null" are appended to this StringBuffer. + * The characters of the {@code StringBuffer} argument are appended, + * in order, to the contents of this {@code StringBuffer}, increasing the + * length of this {@code StringBuffer} by the length of the argument. + * If {@code sb} is {@code null}, then the four characters + * {@code "null"} are appended to this {@code StringBuffer}. *
* Let n be the length of the old character sequence, the one - * contained in the StringBuffer just prior to execution of the - * append method. Then the character at index k in + * contained in the {@code StringBuffer} just prior to execution of the + * {@code append} method. Then the character at index k in * the new character sequence is equal to the character at index k * in the old character sequence, if k is less than n; * otherwise, it is equal to the character at index k-n in the @@ -281,7 +281,7 @@ * This method synchronizes on {@code this}, the destination * object, but does not synchronize on the source ({@code sb}). * - * @param sb the StringBuffer to append. + * @param sb the {@code StringBuffer} to append. * @return a reference to this object. * @since 1.4 */ --- old/src/share/classes/java/lang/StringBuilder.java 2012-12-28 16:48:02.285448104 -0500 +++ new/src/share/classes/java/lang/StringBuilder.java 2012-12-28 16:48:02.113451023 -0500 @@ -28,39 +28,39 @@ /** * A mutable sequence of characters. This class provides an API compatible - * with
StringBuffer, but with no guarantee of synchronization. + * with {@code StringBuffer}, but with no guarantee of synchronization. * This class is designed for use as a drop-in replacement for - *StringBufferin places where the string buffer was being + * {@code StringBuffer} in places where the string buffer was being * used by a single thread (as is generally the case). Where possible, * it is recommended that this class be used in preference to - *StringBufferas it will be faster under most implementations. + * {@code StringBuffer} as it will be faster under most implementations. * - *The principal operations on a
StringBuilderare the - *appendandinsertmethods, which are + *The principal operations on a {@code StringBuilder} are the + * {@code append} and {@code insert} methods, which are * overloaded so as to accept data of any type. Each effectively * converts a given datum to a string and then appends or inserts the * characters of that string to the string builder. The - *
appendmethod always adds these characters at the end - * of the builder; theinsertmethod adds the characters at + * {@code append} method always adds these characters at the end + * of the builder; the {@code insert} method adds the characters at * a specified point. *- * For example, if
zrefers to a string builder object - * whose current contents are "start", then - * the method callz.append("le")would cause the string - * builder to contain "startle", whereas - *z.insert(4, "le")would alter the string builder to - * contain "starlet". + * For example, if {@code z} refers to a string builder object + * whose current contents are "{@code start}", then + * the method call {@code z.append("le")} would cause the string + * builder to contain "{@code startle}", whereas + * {@code z.insert(4, "le")} would alter the string builder to + * contain "{@code starlet}". + *+ * In general, if sb refers to an instance of a {@code StringBuilder}, + * then {@code sb.append(x)} has the same effect as + * {@code sb.insert(sb.length(), x)}. *
- * In general, if sb refers to an instance of a
StringBuilder, - * thensb.append(x)has the same effect as - *sb.insert(sb.length(), x). - * * Every string builder has a capacity. As long as the length of the * character sequence contained in the string builder does not exceed * the capacity, it is not necessary to allocate a new internal * buffer. If the internal buffer overflows, it is automatically made larger. * - *Instances of
StringBuilderare not safe for + *Instances of {@code StringBuilder} are not safe for * use by multiple threads. If such synchronization is required then it is * recommended that {@link java.lang.StringBuffer} be used. * @@ -87,11 +87,11 @@ /** * Constructs a string builder with no characters in it and an - * initial capacity specified by the
capacityargument. + * initial capacity specified by the {@code capacity} argument. * * @param capacity the initial capacity. - * @throws NegativeArraySizeException if thecapacity- * argument is less than0. + * @throws NegativeArraySizeException if the {@code capacity} + * argument is less than {@code 0}. */ public StringBuilder(int capacity) { super(capacity); @@ -100,10 +100,10 @@ /** * Constructs a string builder initialized to the contents of the * specified string. The initial capacity of the string builder is - *16plus the length of the string argument. + * {@code 16} plus the length of the string argument. * * @param str the initial contents of the buffer. - * @throws NullPointerException ifstrisnull+ * @throws NullPointerException if {@code str} is {@code null} */ public StringBuilder(String str) { super(str.length() + 16); @@ -112,12 +112,12 @@ /** * Constructs a string builder that contains the same characters - * as the specifiedCharSequence. The initial capacity of - * the string builder is16plus the length of the - *CharSequenceargument. + * as the specified {@code CharSequence}. The initial capacity of + * the string builder is {@code 16} plus the length of the + * {@code CharSequence} argument. * * @param seq the sequence to copy. - * @throws NullPointerException ifseqisnull+ * @throws NullPointerException if {@code seq} is {@code null} */ public StringBuilder(CharSequence seq) { this(seq.length() + 16); @@ -136,22 +136,22 @@ } /** - * Appends the specified StringBuffer to this sequence. + * Appends the specified {@code StringBuffer} to this sequence. *- * The characters of the StringBuffer argument are appended, + * The characters of the {@code StringBuffer} argument are appended, * in order, to this sequence, increasing the * length of this sequence by the length of the argument. - * If sb is null, then the four characters - * "null" are appended to this sequence. + * If {@code sb} is {@code null}, then the four characters + * {@code "null"} are appended to this sequence. *
* Let n be the length of this character sequence just prior to - * execution of the append method. Then the character at index + * execution of the {@code append} method. Then the character at index * k in the new character sequence is equal to the character at * index k in the old character sequence, if k is less than * n; otherwise, it is equal to the character at index k-n - * in the argument
sb. + * in the argument {@code sb}. * - * @param sb the StringBuffer to append. + * @param sb the {@code StringBuffer} to append. * @return a reference to this object. */ public StringBuilder append(StringBuffer sb) { @@ -418,13 +418,13 @@ } /** - * Save the state of the StringBuilder instance to a stream + * Save the state of the {@code StringBuilder} instance to a stream * (that is, serialize it). * * @serialData the number of characters currently stored in the string - * builder (int), followed by the characters in the - * string builder (char[]). The length of the - * char array may be greater than the number of + * builder ({@code int}), followed by the characters in the + * string builder ({@code char[]}). The length of the + * {@code char} array may be greater than the number of * characters currently stored in the string builder, in which * case extra characters are ignored. */ --- old/src/share/classes/java/lang/StringIndexOutOfBoundsException.java 2012-12-28 16:48:02.845438598 -0500 +++ new/src/share/classes/java/lang/StringIndexOutOfBoundsException.java 2012-12-28 16:48:02.681441385 -0500 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,7 +26,7 @@ package java.lang; /** - * Thrown byStringmethods to indicate that an index + * Thrown by {@code String} methods to indicate that an index * is either negative or greater than the size of the string. For * some methods such as the charAt method, this exception also is * thrown when the index is equal to the size of the string. @@ -40,7 +40,7 @@ private static final long serialVersionUID = -6762910422159637258L; /** - * Constructs aStringIndexOutOfBoundsExceptionwith no + * Constructs a {@code StringIndexOutOfBoundsException} with no * detail message. * * @since JDK1.0. @@ -50,7 +50,7 @@ } /** - * Constructs aStringIndexOutOfBoundsExceptionwith + * Constructs a {@code StringIndexOutOfBoundsException} with * the specified detail message. * * @param s the detail message. @@ -60,7 +60,7 @@ } /** - * Constructs a newStringIndexOutOfBoundsException+ * Constructs a new {@code StringIndexOutOfBoundsException} * class with an argument indicating the illegal index. * * @param index the illegal index.