JRE Emulation

GWT includes a library that emulates a subset of the Java runtime library. The list below shows the set of JRE packages, types and methods that GWT can translate automatically. Note that in some cases, only a subset of methods is supported for a given type.

To see the differences between GWT emulation and standard JRE classes check Missing parts of JRE Emulation.

java.beans
java.io
java.lang
java.lang.annotation
java.lang.reflect
java.math
java.nio.charset
java.security
java.sql
java.text
java.util
java.util.concurrent
java.util.concurrent.atomic
java.util.function
java.util.logging
java.util.stream

Package java.beans

Beans: Constructors: Beans(); Methods: isDesignTime()

Package java.io

BufferedWriter: Constructors: BufferedWriter(Writer), BufferedWriter(Writer, int); Methods: close(), flush(), newLine(), write(char[], int, int), write(int), write(String, int, int)
ByteArrayInputStream: Fields: buf, pos, mark, count; Constructors: ByteArrayInputStream(byte[]), ByteArrayInputStream(byte[], int, int); Methods: available(), close(), mark(int), markSupported(), read(), read(byte[], int, int), reset(), skip(long)
ByteArrayOutputStream: Fields: buf, count; Constructors: ByteArrayOutputStream(), ByteArrayOutputStream(int); Methods: close(), reset(), size(), toByteArray(), toString(), toString(int), toString(String), toString(Charset), write(byte[], int, int), writeBytes(byte[]), write(int), writeTo(OutputStream)
Closeable: Methods: close()
Externalizable
FilterInputStream: Fields: in; Constructors: FilterInputStream(InputStream); Methods: available(), close(), mark(int), markSupported(), read(), read(byte[], int, int), reset(), skip(long)
FilterOutputStream: Fields: out; Constructors: FilterOutputStream(OutputStream); Methods: close(), flush(), write(byte[], int, int), write(int)
Flushable: Methods: flush()
IOException: Constructors: IOException(), IOException(String), IOException(String, Throwable), IOException(Throwable)
InputStream: Constructors: InputStream(); Methods: available(), close(), mark(int), markSupported(), read(), read(byte[]), read(byte[], int, int), reset(), skip(long)
OutputStream: Constructors: OutputStream(); Methods: close(), flush(), write(byte[]), write(byte[], int, int), write(int), nullOutputStream()
OutputStreamWriter: Constructors: OutputStreamWriter(OutputStream, String), OutputStreamWriter(OutputStream, Charset); Methods: close(), flush(), getEncoding(), write(char[], int, int)
PrintStream: Constructors: PrintStream(OutputStream); Methods: print(boolean), print(char), print(char[]), print(double), print(float), print(int), print(long), print(Object), print(String), println(), println(boolean), println(char), println(char[]), println(double), println(float), println(int), println(long), println(Object), println(String), flush(), close(), write(byte[], int, int), write(int), checkError(), setError(), clearError()
Reader: Constructors: Reader(); Methods: close(), mark(int), markSupported(), read(), read(char[]), read(char[], int, int), ready(), reset(), skip(long)
Serializable
StringReader: Constructors: StringReader(String); Methods: close(), read(char[], int, int), markSupported(), mark(int), reset()
UncheckedIOException: Constructors: UncheckedIOException(String, IOException), UncheckedIOException(IOException); Methods: getCause()
UnsupportedEncodingException: Constructors: UnsupportedEncodingException(), UnsupportedEncodingException(String)
Writer: Constructors: Writer(), Writer(Object); Methods: close(), flush(), write(char[]), write(char[], int, int), write(int), write(String), write(String, int, int), append(char), append(CharSequence), append(CharSequence, int, int), nullWriter()

Package java.lang

Appendable: Methods: append(char), append(CharSequence), append(CharSequence, int, int)
ArithmeticException: Constructors: ArithmeticException(String), ArithmeticException()
ArrayIndexOutOfBoundsException: Constructors: ArrayIndexOutOfBoundsException(), ArrayIndexOutOfBoundsException(int), ArrayIndexOutOfBoundsException(String)
ArrayStoreException: Constructors: ArrayStoreException(), ArrayStoreException(String)
AssertionError: Constructors: AssertionError(), AssertionError(boolean), AssertionError(char), AssertionError(double), AssertionError(float), AssertionError(int), AssertionError(long), AssertionError(Object), AssertionError(String, Throwable)
AutoCloseable: Methods: close()
Boolean: Fields: FALSE, TRUE, TYPE; Constructors: Boolean(boolean), Boolean(String); Methods: compare(boolean, boolean), hashCode(boolean), logicalAnd(boolean, boolean), logicalOr(boolean, boolean), logicalXor(boolean, boolean), parseBoolean(String), toString(boolean), valueOf(boolean), valueOf(String), booleanValue(), compareTo(Boolean), equals(Object), hashCode(), toString()
Byte: Fields: MIN_VALUE, MAX_VALUE, SIZE, BYTES, TYPE; Constructors: Byte(byte), Byte(String); Methods: compare(byte, byte), decode(String), hashCode(byte), parseByte(String), parseByte(String, int), toString(byte), valueOf(byte), valueOf(String), valueOf(String, int), byteValue(), compareTo(Byte), doubleValue(), equals(Object), floatValue(), hashCode(), intValue(), longValue(), shortValue(), toString()
CharSequence: Methods: charAt(int), length(), subSequence(int, int), toString(), chars(), codePoints(), isEmpty(), compare(CharSequence, CharSequence)
Character: Fields: TYPE, MIN_RADIX, MAX_RADIX, MIN_VALUE, MAX_VALUE, MIN_SURROGATE, MAX_SURROGATE, MIN_LOW_SURROGATE, MAX_LOW_SURROGATE, MIN_HIGH_SURROGATE, MAX_HIGH_SURROGATE, MIN_SUPPLEMENTARY_CODE_POINT, MIN_CODE_POINT, MAX_CODE_POINT, SIZE, BYTES; Constructors: Character(char); Methods: charCount(int), codePointAt(char[], int), codePointAt(char[], int, int), codePointAt(CharSequence, int), codePointBefore(char[], int), codePointBefore(char[], int, int), codePointBefore(CharSequence, int), codePointCount(char[], int, int), codePointCount(CharSequence, int, int), compare(char, char), digit(char, int), forDigit(int, int), hashCode(char), isBmpCodePoint(int), isDigit(char), isHighSurrogate(char), isLetter(char), isLetterOrDigit(char), isLowerCase(char), isLowSurrogate(char), isSpace(char), isWhitespace(char), isWhitespace(int), isSupplementaryCodePoint(int), isSurrogatePair(char, char), isTitleCase(char), isUpperCase(char), isValidCodePoint(int), offsetByCodePoints(char[], int, int, int, int), offsetByCodePoints(CharSequence, int, int), toChars(int), toChars(int, char[], int), toCodePoint(char, char), toLowerCase(char), toString(char), toUpperCase(char), valueOf(char), charValue(), compareTo(Character), equals(Object), hashCode(), toString()
Class: Methods: isClassMetadataEnabled(), desiredAssertionStatus(), getCanonicalName(), getComponentType(), getEnumConstants(), getName(), getSimpleName(), getSuperclass(), isArray(), isEnum(), isInterface(), isPrimitive(), toString()
ClassCastException: Constructors: ClassCastException(), ClassCastException(String)
CloneNotSupportedException: Constructors: CloneNotSupportedException(), CloneNotSupportedException(String)
Cloneable
Comparable: Methods: compareTo(T)
Double: Fields: MAX_VALUE, MIN_VALUE, MIN_NORMAL, MAX_EXPONENT, MIN_EXPONENT, NaN, NEGATIVE_INFINITY, POSITIVE_INFINITY, SIZE, BYTES, TYPE; Constructors: Double(double), Double(String); Methods: compare(double, double), doubleToLongBits(double), hashCode(double), isFinite(double), isInfinite(double), isNaN(double), longBitsToDouble(long), max(double, double), min(double, double), parseDouble(String), sum(double, double), toString(double), valueOf(double), valueOf(String), byteValue(), compareTo(Double), doubleValue(), equals(Object), floatValue(), hashCode(), intValue(), isInfinite(), isNaN(), longValue(), shortValue(), toString()
Enum: Constructors: Enum(String, int); Methods: valueOf(Class, String), createValueOfMap(T[]), valueOf(JavaScriptObject, String), compareTo(E), equals(Object), getDeclaringClass(), hashCode(), name(), ordinal(), toString()
Error: Constructors: Error(), Error(String, Throwable), Error(String), Error(Throwable)
Exception: Constructors: Exception(), Exception(String), Exception(String, Throwable), Exception(Throwable), Exception(String, Throwable, boolean, boolean)
Float: Fields: MAX_VALUE, MIN_VALUE, MAX_EXPONENT, MIN_EXPONENT, MIN_NORMAL, NaN, NEGATIVE_INFINITY, POSITIVE_INFINITY, SIZE, BYTES, TYPE; Constructors: Float(double), Float(float), Float(String); Methods: compare(float, float), floatToIntBits(float), hashCode(float), intBitsToFloat(int), isFinite(float), isInfinite(float), isNaN(float), max(float, float), min(float, float), parseFloat(String), sum(float, float), toString(float), valueOf(float), valueOf(String), byteValue(), compareTo(Float), doubleValue(), equals(Object), floatValue(), hashCode(), intValue(), isInfinite(), isNaN(), longValue(), shortValue(), toString()
IllegalArgumentException: Constructors: IllegalArgumentException(), IllegalArgumentException(String), IllegalArgumentException(String, Throwable), IllegalArgumentException(Throwable)
IllegalStateException: Constructors: IllegalStateException(), IllegalStateException(String), IllegalStateException(String, Throwable), IllegalStateException(Throwable)
IndexOutOfBoundsException: Constructors: IndexOutOfBoundsException(), IndexOutOfBoundsException(String)
Integer: Fields: MAX_VALUE, MIN_VALUE, SIZE, BYTES, TYPE; Constructors: Integer(int), Integer(String); Methods: bitCount(int), compare(int, int), decode(String), hashCode(int), highestOneBit(int), lowestOneBit(int), max(int, int), min(int, int), numberOfLeadingZeros(int), numberOfTrailingZeros(int), parseInt(String), parseInt(String, int), reverse(int), reverseBytes(int), rotateLeft(int, int), rotateRight(int, int), signum(int), sum(int, int), toBinaryString(int), toHexString(int), toOctalString(int), toString(int), toString(int, int), valueOf(int), valueOf(String), valueOf(String, int), byteValue(), compareTo(Integer), doubleValue(), equals(Object), floatValue(), hashCode(), intValue(), longValue(), shortValue(), toString()
InterruptedException: Constructors: InterruptedException(), InterruptedException(String)
Iterable: Methods: iterator(), forEach(Consumer), spliterator()
Long: Fields: MAX_VALUE, MIN_VALUE, SIZE, BYTES, TYPE; Constructors: Long(long), Long(String); Methods: bitCount(long), compare(long, long), decode(String), hashCode(long), highestOneBit(long), lowestOneBit(long), max(long, long), min(long, long), numberOfLeadingZeros(long), numberOfTrailingZeros(long), parseLong(String), parseLong(String, int), reverse(long), reverseBytes(long), rotateLeft(long, int), rotateRight(long, int), signum(long), sum(long, long), toBinaryString(long), toHexString(long), toOctalString(long), toString(long), toString(long, int), valueOf(long), valueOf(String), valueOf(String, int), byteValue(), compareTo(Long), doubleValue(), equals(Object), floatValue(), hashCode(), intValue(), longValue(), shortValue(), toString()
Math: Fields: E, PI; Constructors: Math(); Methods: abs(double), abs(float), abs(int), abs(long), absExact(int), absExact(long), acos(double), asin(double), addExact(int, int), addExact(long, long), atan(double), atan2(double, double), cbrt(double), ceil(double), copySign(double, double), copySign(float, float), cos(double), cosh(double), decrementExact(int), decrementExact(long), exp(double), expm1(double), floor(double), floorDiv(int, int), floorDiv(long, long), floorDiv(long, int), floorMod(int, int), floorMod(long, long), floorMod(long, int), IEEEremainder(double, double), getExponent(double), getExponent(float), ulp(double), ulp(float), hypot(double, double), incrementExact(int), incrementExact(long), log(double), log10(double), log1p(double), max(double, double), max(float, float), max(int, int), max(long, long), min(double, double), min(float, float), min(int, int), min(long, long), multiplyFull(int, int), multiplyExact(int, int), multiplyExact(long, int), multiplyExact(long, long), negateExact(int), negateExact(long), pow(double, double), random(), rint(double), round(double), round(float), subtractExact(int, int), subtractExact(long, long), scalb(double, int), scalb(float, int), signum(double), signum(float), sin(double), sinh(double), sqrt(double), tan(double), tanh(double), toDegrees(double), toIntExact(long), toRadians(double), nextAfter(double, double), nextAfter(float, double), nextUp(double), nextUp(float), nextDown(double), nextDown(float)
NegativeArraySizeException: Constructors: NegativeArraySizeException(), NegativeArraySizeException(String)
NullPointerException: Constructors: NullPointerException(), NullPointerException(String)
Number: Constructors: Number(); Methods: byteValue(), doubleValue(), floatValue(), intValue(), longValue(), shortValue()
NumberFormatException: Constructors: NumberFormatException(), NumberFormatException(String)
Object: Constructors: Object(); Methods: equals(Object), getClass(), hashCode(), toString(), finalize()
Record: Constructors: Record(); Methods: hashCode(), equals(Object), toString()
Runnable: Methods: run()
RuntimeException: Constructors: RuntimeException(), RuntimeException(String), RuntimeException(String, Throwable), RuntimeException(Throwable), RuntimeException(String, Throwable, boolean, boolean)
SecurityException
Short: Fields: MIN_VALUE, MAX_VALUE, SIZE, BYTES, TYPE; Constructors: Short(short), Short(String); Methods: compare(short, short), decode(String), hashCode(short), parseShort(String), parseShort(String, int), reverseBytes(short), toString(short), valueOf(short), valueOf(String), valueOf(String, int), byteValue(), compareTo(Short), doubleValue(), equals(Object), floatValue(), hashCode(), intValue(), longValue(), shortValue(), toString()
StackTraceElement: Constructors: StackTraceElement(), StackTraceElement(String, String, String, int); Methods: getClassName(), getFileName(), getLineNumber(), getMethodName(), equals(Object), hashCode(), toString()
StrictMath: Fields: E, PI; Constructors: StrictMath(); Methods: abs(double), abs(float), abs(int), acos(double), addExact(int, int), addExact(long, long), asin(double), atan(double), atan2(double, double), ceil(double), copySign(double, double), copySign(float, float), cos(double), cosh(double), exp(double), expm1(double), floor(double), floorDiv(int, int), floorDiv(long, long), floorMod(int, int), floorMod(long, long), hypot(double, double), log(double), log10(double), log1p(double), max(double, double), max(float, float), max(int, int), max(long, long), min(double, double), min(float, float), min(int, int), min(long, long), multiplyExact(int, int), multiplyExact(long, long), pow(double, double), random(), rint(double), round(double), round(float), scalb(double, int), scalb(float, int), signum(double), signum(float), sin(double), sinh(double), sqrt(double), subtractExact(int, int), subtractExact(long, long), tan(double), tanh(double), toDegrees(double), toIntExact(long), toRadians(double), abs(long), decrementExact(int), decrementExact(long), incrementExact(int), incrementExact(long), multiplyExact(long, int), negateExact(long), negateExact(int), getExponent(float), getExponent(double), floorMod(long, int), cbrt(double), IEEEremainder(double, double), floorDiv(long, int), multiplyFull(int, int), absExact(int), absExact(long), ulp(double), ulp(float), nextAfter(double, double), nextAfter(float, double), nextUp(double), nextUp(float), nextDown(double), nextDown(float)
String: Fields: CASE_INSENSITIVE_ORDER; Constructors: String(), String(byte[]), String(byte[], int, int), String(byte[], int, int, String), String(byte[], int, int, Charset), String(byte[], String), String(byte[], Charset), String(char[]), String(char[], int, int), String(int[], int, int), String(String), String(StringBuffer), String(StringBuilder); Methods: copyValueOf(char[]), copyValueOf(char[], int, int), join(CharSequence, CharSequence[]), join(CharSequence, Iterable), valueOf(boolean), valueOf(char), valueOf(char[], int, int), valueOf(char[]), valueOf(double), valueOf(float), valueOf(int), valueOf(long), valueOf(Object), charAt(int), codePointAt(int), codePointBefore(int), codePointCount(int, int), compareTo(String), compareToIgnoreCase(String), concat(String), contains(CharSequence), contentEquals(CharSequence), contentEquals(StringBuffer), endsWith(String), equals(Object), equalsIgnoreCase(String), getBytes(), getBytes(String), getBytes(Charset), getChars(int, int, char[], int), hashCode(), indexOf(int), indexOf(int, int), indexOf(String), indexOf(String, int), intern(), lastIndexOf(int), lastIndexOf(int, int), lastIndexOf(String), lastIndexOf(String, int), length(), matches(String), offsetByCodePoints(int, int), regionMatches(boolean, int, String, int, int), regionMatches(int, String, int, int), replace(char, char), replace(CharSequence, CharSequence), replaceAll(String, String), replaceFirst(String, String), split(String), split(String, int), startsWith(String), startsWith(String, int), subSequence(int, int), substring(int), substring(int, int), toCharArray(), toLowerCase(), toLowerCase(Locale), toUpperCase(), toUpperCase(Locale), toString(), trim(), strip(), stripLeading(), stripTrailing(), isBlank(), lines(), repeat(int), transform(Function), indent(int), stripIndent(), translateEscapes()
StringBuffer: Constructors: StringBuffer(), StringBuffer(CharSequence), StringBuffer(int), StringBuffer(String); Methods: append(boolean), append(char), append(char[]), append(char[], int, int), append(CharSequence), append(CharSequence, int, int), append(double), append(float), append(int), append(long), append(Object), append(String), append(StringBuffer), appendCodePoint(int), delete(int, int), deleteCharAt(int), insert(int, boolean), insert(int, char), insert(int, char[]), insert(int, char[], int, int), insert(int, CharSequence), insert(int, CharSequence, int, int), insert(int, double), insert(int, float), insert(int, int), insert(int, long), insert(int, Object), insert(int, String), replace(int, int, String), reverse()
StringBuilder: Constructors: StringBuilder(), StringBuilder(CharSequence), StringBuilder(int), StringBuilder(String); Methods: append(boolean), append(char), append(char[]), append(char[], int, int), append(CharSequence), append(CharSequence, int, int), append(double), append(float), append(int), append(long), append(Object), append(String), append(StringBuffer), appendCodePoint(int), delete(int, int), deleteCharAt(int), insert(int, boolean), insert(int, char), insert(int, char[]), insert(int, char[], int, int), insert(int, CharSequence), insert(int, CharSequence, int, int), insert(int, double), insert(int, float), insert(int, int), insert(int, long), insert(int, Object), insert(int, String), replace(int, int, String), reverse()
StringIndexOutOfBoundsException: Constructors: StringIndexOutOfBoundsException(), StringIndexOutOfBoundsException(String), StringIndexOutOfBoundsException(int)
System: Fields: err, out; Constructors: System(); Methods: arraycopy(Object, int, Object, int, int), currentTimeMillis(), nanoTime(), gc(), getProperty(String), getProperty(String, String), identityHashCode(Object), setErr(PrintStream), setOut(PrintStream)
ThreadLocal: Constructors: ThreadLocal(); Methods: get(), set(T), remove(), withInitial(Supplier)
Throwable: Constructors: Throwable(), Throwable(String), Throwable(String, Throwable), Throwable(Throwable), Throwable(String, Throwable, boolean, boolean); Methods: getBackingJsObject(), addSuppressed(Throwable), fillInStackTrace(), getCause(), getLocalizedMessage(), getMessage(), getStackTrace(), getSuppressed(), initCause(Throwable), printStackTrace(), printStackTrace(PrintStream), setStackTrace(StackTraceElement[]), toString(), of(Object)
UnsupportedOperationException: Constructors: UnsupportedOperationException(), UnsupportedOperationException(String), UnsupportedOperationException(String, Throwable), UnsupportedOperationException(Throwable)
Void: Fields: TYPE

Package java.lang.annotation

Annotation: Methods: annotationType(), equals(Object), hashCode(), toString()
AnnotationFormatError: Constructors: AnnotationFormatError()
ElementType: Fields: ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, MODULE, PACKAGE, PARAMETER, RECORD_COMPONENT, TYPE, TYPE_PARAMETER, TYPE_USE; Methods: values(), valueOf(String)
IncompleteAnnotationException: Fields: annotationType, elementName; Constructors: IncompleteAnnotationException(Class, String); Methods: annotationType(), elementName()
RetentionPolicy: Fields: CLASS, RUNTIME, SOURCE; Methods: values(), valueOf(String)

Package java.lang.reflect

Array: Methods: get(Object, int), getBoolean(Object, int), getByte(Object, int), getChar(Object, int), getDouble(Object, int), getFloat(Object, int), getInt(Object, int), getLength(Object), getLong(Object, int), getShort(Object, int), set(Object, int, Object), setBoolean(Object, int, boolean), setByte(Object, int, byte), setChar(Object, int, char), setDouble(Object, int, double), setFloat(Object, int, float), setInt(Object, int, int), setLong(Object, int, long), setShort(Object, int, short)
Type

Package java.math

BigDecimal: Fields: ONE, ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_UNNECESSARY, ROUND_UP, TEN, ZERO; Constructors: BigDecimal(BigInteger), BigDecimal(BigInteger, int), BigDecimal(BigInteger, int, MathContext), BigDecimal(BigInteger, MathContext), BigDecimal(char[]), BigDecimal(char[], int, int), BigDecimal(char[], int, int, MathContext), BigDecimal(char[], MathContext), BigDecimal(double), BigDecimal(double, MathContext), BigDecimal(int), BigDecimal(int, MathContext), BigDecimal(long), BigDecimal(long, MathContext), BigDecimal(String), BigDecimal(String, MathContext); Methods: valueOf(double), valueOf(long), valueOf(long, int), abs(), abs(MathContext), add(BigDecimal), add(BigDecimal, MathContext), byteValueExact(), compareTo(BigDecimal), divide(BigDecimal), divide(BigDecimal, int), divide(BigDecimal, int, int), divide(BigDecimal, int, RoundingMode), divide(BigDecimal, MathContext), divide(BigDecimal, RoundingMode), divideAndRemainder(BigDecimal), divideAndRemainder(BigDecimal, MathContext), divideToIntegralValue(BigDecimal), divideToIntegralValue(BigDecimal, MathContext), doubleValue(), equals(Object), floatValue(), hashCode(), intValue(), intValueExact(), longValue(), longValueExact(), max(BigDecimal), min(BigDecimal), movePointLeft(int), movePointRight(int), multiply(BigDecimal), multiply(BigDecimal, MathContext), negate(), negate(MathContext), plus(), plus(MathContext), pow(int), pow(int, MathContext), precision(), remainder(BigDecimal), remainder(BigDecimal, MathContext), round(MathContext), scale(), scaleByPowerOfTen(int), setScale(int), setScale(int, int), setScale(int, RoundingMode), shortValueExact(), signum(), stripTrailingZeros(), subtract(BigDecimal), subtract(BigDecimal, MathContext), toBigInteger(), toBigIntegerExact(), toEngineeringString(), toPlainString(), toString(), ulp(), unscaledValue()
BigInteger: Fields: ONE, TEN, TWO, ZERO; Constructors: BigInteger(byte[]), BigInteger(byte[], int, int), BigInteger(int, byte[]), BigInteger(int, byte[], int, int), BigInteger(int, int, Random), BigInteger(int, Random), BigInteger(String), BigInteger(String, int); Methods: probablePrime(int, Random), valueOf(long), abs(), add(BigInteger), and(BigInteger), andNot(BigInteger), bitCount(), bitLength(), byteValueExact(), clearBit(int), compareTo(BigInteger), divide(BigInteger), divideAndRemainder(BigInteger), doubleValue(), equals(Object), flipBit(int), floatValue(), gcd(BigInteger), getLowestSetBit(), hashCode(), intValue(), intValueExact(), isProbablePrime(int), longValue(), longValueExact(), max(BigInteger), min(BigInteger), mod(BigInteger), modInverse(BigInteger), modPow(BigInteger, BigInteger), multiply(BigInteger), negate(), nextProbablePrime(), not(), or(BigInteger), pow(int), remainder(BigInteger), setBit(int), shiftLeft(int), shiftRight(int), shortValueExact(), signum(), subtract(BigInteger), testBit(int), toByteArray(), toString(), toString(int), xor(BigInteger)
MathContext: Fields: DECIMAL128, DECIMAL32, DECIMAL64, UNLIMITED; Constructors: MathContext(int), MathContext(int, RoundingMode), MathContext(String); Methods: equals(Object), getPrecision(), getRoundingMode(), hashCode(), toString()
RoundingMode: Fields: UP, DOWN, CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UNNECESSARY; Methods: values(), valueOf(String), valueOf(int)

Package java.nio.charset

Charset: Constructors: Charset(String, String[]); Methods: availableCharsets(), defaultCharset(), forName(String), name(), compareTo(Charset), hashCode(), equals(Object), toString()
IllegalCharsetNameException: Constructors: IllegalCharsetNameException(String); Methods: getCharsetName()
StandardCharsets: Fields: ISO_8859_1, UTF_8
UnsupportedCharsetException: Constructors: UnsupportedCharsetException(String); Methods: getCharsetName()

Package java.security

DigestException: Constructors: DigestException(), DigestException(String)
GeneralSecurityException: Constructors: GeneralSecurityException(), GeneralSecurityException(String)
MessageDigest: Constructors: MessageDigest(String); Methods: getInstance(String), isEqual(byte[], byte[]), digest(), digest(byte[]), digest(byte[], int, int), getAlgorithm(), getDigestLength(), reset(), update(byte), update(byte[]), update(byte[], int, int)
MessageDigestSpi: Constructors: MessageDigestSpi(); Methods: engineDigest(), engineDigest(byte[], int, int), engineGetDigestLength(), engineReset(), engineUpdate(byte), engineUpdate(byte[], int, int)
NoSuchAlgorithmException: Constructors: NoSuchAlgorithmException(), NoSuchAlgorithmException(String)

Package java.sql

Date: Constructors: Date(int, int, int), Date(long); Methods: valueOf(String), getHours(), getMinutes(), getSeconds(), setHours(int), setMinutes(int), setSeconds(int), toString()
Time: Constructors: Time(int, int, int), Time(long); Methods: valueOf(String), getDate(), getDay(), getMonth(), getYear(), setDate(int), setMonth(int), setYear(int), toString()
Timestamp: Constructors: Timestamp(int, int, int, int, int, int, int), Timestamp(long); Methods: valueOf(String), after(Timestamp), before(Timestamp), compareTo(Date), compareTo(Timestamp), equals(Object), equals(Timestamp), getNanos(), getTime(), hashCode(), setNanos(int), setTime(long), toString()

Package java.text

Normalizer: Constructors: Normalizer(); Methods: normalize(CharSequence, Normalizer.Form), isNormalized(CharSequence, Normalizer.Form)
Normalizer.Form: Fields: NFD, NFC, NFKD, NFKC; Methods: values(), valueOf(String)
ParseException: Constructors: ParseException(String, int); Methods: getErrorOffset()

Package java.util

AbstractCollection: Constructors: AbstractCollection(); Methods: add(E), addAll(Collection), clear(), contains(Object), containsAll(Collection), isEmpty(), remove(Object), removeAll(Collection), retainAll(Collection), toArray(), toArray(T[]), toString()
AbstractList: Fields: modCount; Constructors: AbstractList(); Methods: add(E), add(int, E), addAll(int, Collection), clear(), equals(Object), hashCode(), indexOf(Object), iterator(), lastIndexOf(Object), listIterator(), listIterator(int), remove(int), set(int, E), subList(int, int), removeRange(int, int)
AbstractMap: Constructors: AbstractMap(); Methods: clear(), containsKey(Object), containsValue(Object), equals(Object), get(Object), hashCode(), isEmpty(), keySet(), put(K, V), putAll(Map), remove(Object), size(), toString(), values()
AbstractMap.SimpleEntry: Constructors: SimpleEntry(K, V), SimpleEntry(Map.Entry)
AbstractMap.SimpleImmutableEntry: Constructors: SimpleImmutableEntry(K, V), SimpleImmutableEntry(Map.Entry); Methods: setValue(V)
AbstractQueue: Constructors: AbstractQueue(); Methods: add(E), addAll(Collection), clear(), element(), remove()
AbstractSequentialList: Constructors: AbstractSequentialList(); Methods: add(int, E), addAll(int, Collection), get(int), iterator(), remove(int), set(int, E)
AbstractSet: Constructors: AbstractSet(); Methods: equals(Object), hashCode(), removeAll(Collection)
ArrayDeque: Constructors: ArrayDeque(), ArrayDeque(int), ArrayDeque(Collection); Methods: add(E), addFirst(E), addLast(E), clear(), clone(), contains(Object), descendingIterator(), element(), getFirst(), getLast(), isEmpty(), iterator(), offer(E), offerFirst(E), offerLast(E), peek(), peekFirst(), peekLast(), poll(), pollFirst(), pollLast(), pop(), push(E), remove(), remove(Object), removeFirst(), removeFirstOccurrence(Object), removeLast(), removeLastOccurrence(Object), size(), spliterator(), toArray(T[])
ArrayList: Constructors: ArrayList(), ArrayList(Collection), ArrayList(int); Methods: add(E), add(int, E), addAll(Collection), addAll(int, Collection), clear(), clone(), contains(Object), ensureCapacity(int), get(int), indexOf(Object), iterator(), forEach(Consumer), isEmpty(), lastIndexOf(Object), remove(int), remove(Object), removeIf(Predicate), replaceAll(UnaryOperator), set(int, E), size(), sort(Comparator), toArray(), toArray(T[]), trimToSize(), removeRange(int, int)
Arrays: Methods: asList(T[]), binarySearch(byte[], int, int, byte), binarySearch(byte[], byte), binarySearch(char[], int, int, char), binarySearch(char[], char), binarySearch(double[], int, int, double), binarySearch(double[], double), binarySearch(float[], int, int, float), binarySearch(float[], float), binarySearch(int[], int, int, int), binarySearch(int[], int), binarySearch(long[], int, int, long), binarySearch(long[], long), binarySearch(Object[], int, int, Object), binarySearch(Object[], Object), binarySearch(short[], int, int, short), binarySearch(short[], short), binarySearch(T[], int, int, T, Comparator), binarySearch(T[], T, Comparator), copyOf(boolean[], int), copyOf(byte[], int), copyOf(char[], int), copyOf(double[], int), copyOf(float[], int), copyOf(int[], int), copyOf(long[], int), copyOf(short[], int), copyOf(T[], int), copyOfRange(boolean[], int, int), copyOfRange(byte[], int, int), copyOfRange(char[], int, int), copyOfRange(double[], int, int), copyOfRange(float[], int, int), copyOfRange(int[], int, int), copyOfRange(long[], int, int), copyOfRange(short[], int, int), copyOfRange(T[], int, int), deepEquals(Object[], Object[]), deepHashCode(Object[]), deepToString(Object[]), equals(boolean[], boolean[]), equals(byte[], byte[]), equals(char[], char[]), equals(double[], double[]), equals(float[], float[]), equals(int[], int[]), equals(long[], long[]), equals(Object[], Object[]), equals(short[], short[]), fill(boolean[], boolean), fill(boolean[], int, int, boolean), fill(byte[], byte), fill(byte[], int, int, byte), fill(char[], char), fill(char[], int, int, char), fill(double[], double), fill(double[], int, int, double), fill(float[], float), fill(float[], int, int, float), fill(int[], int), fill(int[], int, int, int), fill(long[], int, int, long), fill(long[], long), fill(Object[], int, int, Object), fill(Object[], Object), fill(short[], int, int, short), fill(short[], short), hashCode(boolean[]), hashCode(byte[]), hashCode(char[]), hashCode(double[]), hashCode(float[]), hashCode(int[]), hashCode(long[]), hashCode(Object[]), hashCode(short[]), parallelPrefix(double[], DoubleBinaryOperator), parallelPrefix(double[], int, int, DoubleBinaryOperator), parallelPrefix(int[], IntBinaryOperator), parallelPrefix(int[], int, int, IntBinaryOperator), parallelPrefix(long[], LongBinaryOperator), parallelPrefix(long[], int, int, LongBinaryOperator), parallelPrefix(T[], BinaryOperator), parallelPrefix(T[], int, int, BinaryOperator), setAll(T[], IntFunction), setAll(double[], IntToDoubleFunction), setAll(int[], IntUnaryOperator), setAll(long[], IntToLongFunction), parallelSetAll(T[], IntFunction), parallelSetAll(double[], IntToDoubleFunction), parallelSetAll(int[], IntUnaryOperator), parallelSetAll(long[], IntToLongFunction), sort(byte[]), sort(byte[], int, int), sort(char[]), sort(char[], int, int), sort(double[]), sort(double[], int, int), sort(float[]), sort(float[], int, int), sort(int[]), sort(int[], int, int), sort(long[]), sort(long[], int, int), sort(Object[]), sort(Object[], int, int), sort(short[]), sort(short[], int, int), sort(T[], Comparator), sort(T[], int, int, Comparator), parallelSort(byte[]), parallelSort(byte[], int, int), parallelSort(char[]), parallelSort(char[], int, int), parallelSort(double[]), parallelSort(double[], int, int), parallelSort(float[]), parallelSort(float[], int, int), parallelSort(int[]), parallelSort(int[], int, int), parallelSort(long[]), parallelSort(long[], int, int), parallelSort(short[]), parallelSort(short[], int, int), parallelSort(T[]), parallelSort(T[], Comparator), parallelSort(T[], int, int), parallelSort(T[], int, int, Comparator), spliterator(double[]), spliterator(double[], int, int), spliterator(int[]), spliterator(int[], int, int), spliterator(long[]), spliterator(long[], int, int), spliterator(T[]), spliterator(T[], int, int), stream(double[]), stream(double[], int, int), stream(int[]), stream(int[], int, int), stream(long[]), stream(long[], int, int), stream(T[]), stream(T[], int, int), toString(boolean[]), toString(byte[]), toString(char[]), toString(double[]), toString(float[]), toString(int[]), toString(long[]), toString(Object[]), toString(short[])
BitSet: Constructors: BitSet(), BitSet(int); Methods: and(BitSet), andNot(BitSet), cardinality(), clear(), clear(int), clear(int, int), clone(), equals(Object), flip(int), flip(int, int), get(int), get(int, int), hashCode(), intersects(BitSet), isEmpty(), length(), nextClearBit(int), nextSetBit(int), stream(), previousClearBit(int), previousSetBit(int), or(BitSet), set(int), set(int, boolean), set(int, int), set(int, int, boolean), size(), toString(), xor(BitSet), toByteArray(), toLongArray(), valueOf(byte[]), valueOf(long[])
Collection: Methods: add(E), addAll(Collection), clear(), contains(Object), containsAll(Collection), isEmpty(), parallelStream(), remove(Object), removeAll(Collection), removeIf(Predicate), retainAll(Collection), size(), spliterator(), stream(), toArray(), toArray(T[]), toArray(IntFunction)
Collections: Fields: EMPTY_LIST, EMPTY_MAP, EMPTY_SET; Methods: synchronizedCollection(Collection), synchronizedList(List), synchronizedMap(Map), synchronizedNavigableMap(NavigableMap), synchronizedNavigableSet(NavigableSet), synchronizedSet(Set), synchronizedSortedMap(SortedMap), synchronizedSortedSet(SortedSet), addAll(Collection, T[]), asLifoQueue(Deque), binarySearch(List, T), binarySearch(List, T, Comparator), copy(List, List), disjoint(Collection, Collection), emptyIterator(), emptyList(), emptyListIterator(), emptyMap(), emptySet(), enumeration(Collection), fill(List, T), frequency(Collection, Object), list(Enumeration), max(Collection), max(Collection, Comparator), min(Collection), min(Collection, Comparator), newSetFromMap(Map), nCopies(int, T), replaceAll(List, T, T), reverse(List), reverseOrder(), reverseOrder(Comparator), rotate(List, int), shuffle(List), shuffle(List, Random), singleton(T), singletonList(T), singletonMap(K, V), sort(List), sort(List, Comparator), swap(List, int, int), unmodifiableCollection(Collection), unmodifiableList(List), unmodifiableMap(Map), unmodifiableSet(Set), unmodifiableSortedMap(SortedMap), unmodifiableSortedSet(SortedSet)
Comparator: Methods: compare(T, T), equals(Object), reversed(), thenComparing(Comparator), thenComparing(Function, Comparator), thenComparing(Function), thenComparingInt(ToIntFunction), thenComparingLong(ToLongFunction), thenComparingDouble(ToDoubleFunction), comparing(Function, Comparator), comparing(Function), comparingDouble(ToDoubleFunction), comparingInt(ToIntFunction), comparingLong(ToLongFunction), naturalOrder(), nullsFirst(Comparator), nullsLast(Comparator), reverseOrder()
ConcurrentModificationException: Constructors: ConcurrentModificationException(), ConcurrentModificationException(String), ConcurrentModificationException(Throwable), ConcurrentModificationException(String, Throwable)
Date: Constructors: Date(), Date(int, int, int), Date(int, int, int, int, int), Date(int, int, int, int, int, int), Date(long), Date(String); Methods: parse(String), UTC(int, int, int, int, int, int), padTwo(int), after(Date), before(Date), clone(), compareTo(Date), equals(Object), getDate(), getDay(), getHours(), getMinutes(), getMonth(), getSeconds(), getTime(), getTimezoneOffset(), getYear(), hashCode(), setDate(int), setHours(int), setMinutes(int), setMonth(int), setSeconds(int), setTime(long), setYear(int), toGMTString(), toLocaleString(), toString()
Deque: Methods: addFirst(E), addLast(E), descendingIterator(), getFirst(), getLast(), offerFirst(E), offerLast(E), peekFirst(), peekLast(), pollFirst(), pollLast(), pop(), push(E), removeFirst(), removeFirstOccurrence(Object), removeLast(), removeLastOccurrence(Object)
DoubleSummaryStatistics: Constructors: DoubleSummaryStatistics(); Methods: accept(double), combine(DoubleSummaryStatistics), getAverage(), getCount(), getMin(), getMax(), getSum(), toString()
EmptyStackException: Constructors: EmptyStackException()
EnumMap: Constructors: EnumMap(Class), EnumMap(EnumMap), EnumMap(Map); Methods: clear(), clone(), containsKey(Object), containsValue(Object), entrySet(), get(Object), put(K, V), remove(Object), size()
EnumSet: Methods: allOf(Class), complementOf(EnumSet), copyOf(Collection), copyOf(EnumSet), noneOf(Class), of(E), of(E, E[]), range(E, E), clone()
Enumeration: Methods: hasMoreElements(), nextElement(), asIterator()
EventListener
EventObject: Fields: source; Constructors: EventObject(Object); Methods: getSource()
HashMap: Constructors: HashMap(), HashMap(int), HashMap(int, float), HashMap(Map); Methods: clone()
HashSet: Constructors: HashSet(), HashSet(Collection), HashSet(int), HashSet(int, float), HashSet(HashMap); Methods: add(E), clear(), clone(), contains(Object), isEmpty(), iterator(), remove(Object), size()
IdentityHashMap: Constructors: IdentityHashMap(), IdentityHashMap(int), IdentityHashMap(Map); Methods: clone(), equals(Object), hashCode()
IntSummaryStatistics: Constructors: IntSummaryStatistics(); Methods: accept(int), combine(IntSummaryStatistics), getAverage(), getCount(), getMin(), getMax(), getSum(), toString()
Iterator: Methods: hasNext(), next(), forEachRemaining(Consumer), remove()
LinkedHashMap: Constructors: LinkedHashMap(), LinkedHashMap(int), LinkedHashMap(int, float), LinkedHashMap(int, float, boolean), LinkedHashMap(Map); Methods: clear(), clone(), containsKey(Object), containsValue(Object), entrySet(), get(Object), put(K, V), remove(Object), size(), removeEldestEntry(Map.Entry)
LinkedHashSet: Constructors: LinkedHashSet(), LinkedHashSet(Collection), LinkedHashSet(int), LinkedHashSet(int, float); Methods: clone()
LinkedList: Constructors: LinkedList(), LinkedList(Collection); Methods: add(E), addFirst(E), addLast(E), clear(), clone(), descendingIterator(), element(), getFirst(), getLast(), listIterator(int), offer(E), offerFirst(E), offerLast(E), peek(), peekFirst(), peekLast(), poll(), pollFirst(), pollLast(), pop(), push(E), remove(), removeFirst(), removeFirstOccurrence(Object), removeLast(), removeLastOccurrence(Object), size()
List: Methods: of(), of(E), of(E, E), of(E, E, E), of(E, E, E, E), of(E, E, E, E, E), of(E, E, E, E, E, E), of(E, E, E, E, E, E, E), of(E, E, E, E, E, E, E, E), of(E, E, E, E, E, E, E, E, E), of(E, E, E, E, E, E, E, E, E, E), of(E[]), add(int, E), addAll(int, Collection), get(int), indexOf(Object), lastIndexOf(Object), listIterator(), listIterator(int), remove(int), replaceAll(UnaryOperator), set(int, E), sort(Comparator), spliterator(), subList(int, int), copyOf(Collection)
ListIterator: Methods: add(E), hasPrevious(), nextIndex(), previous(), previousIndex(), remove(), set(E)
Locale: Fields: ROOT, ENGLISH, US; Methods: getDefault()
LongSummaryStatistics: Constructors: LongSummaryStatistics(); Methods: accept(int), accept(long), combine(LongSummaryStatistics), getAverage(), getCount(), getMin(), getMax(), getSum(), toString()
Map: Methods: of(), of(K, V), of(K, V, K, V), of(K, V, K, V, K, V), of(K, V, K, V, K, V, K, V), of(K, V, K, V, K, V, K, V, K, V), of(K, V, K, V, K, V, K, V, K, V, K, V), of(K, V, K, V, K, V, K, V, K, V, K, V, K, V), of(K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V), of(K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V), of(K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V), entry(K, V), ofEntries(Map.Entry[]), clear(), compute(K, BiFunction), computeIfAbsent(K, Function), computeIfPresent(K, BiFunction), containsKey(Object), containsValue(Object), entrySet(), forEach(BiConsumer), get(Object), getOrDefault(Object, V), isEmpty(), keySet(), merge(K, V, BiFunction), put(K, V), putIfAbsent(K, V), putAll(Map), remove(Object), remove(Object, Object), replace(K, V), replace(K, V, V), replaceAll(BiFunction), size(), values(), copyOf(Map)
Map.Entry: Methods: equals(Object), getKey(), getValue(), hashCode(), setValue(V), comparingByKey(), comparingByKey(Comparator), comparingByValue(), comparingByValue(Comparator), copyOf(Map.Entry)
MissingResourceException: Constructors: MissingResourceException(String, String, String); Methods: getClassName(), getKey()
NavigableMap: Methods: ceilingEntry(K), ceilingKey(K), descendingKeySet(), descendingMap(), firstEntry(), floorEntry(K), floorKey(K), headMap(K, boolean), higherEntry(K), higherKey(K), lastEntry(), lowerEntry(K), lowerKey(K), navigableKeySet(), pollFirstEntry(), pollLastEntry(), subMap(K, boolean, K, boolean), tailMap(K, boolean)
NavigableSet: Methods: ceiling(E), descendingIterator(), descendingSet(), floor(E), headSet(E, boolean), higher(E), lower(E), pollFirst(), pollLast(), subSet(E, boolean, E, boolean), tailSet(E, boolean)
NoSuchElementException: Constructors: NoSuchElementException(), NoSuchElementException(String)
Objects: Methods: compare(T, T, Comparator), deepEquals(Object, Object), equals(Object, Object), equals(String, String), hashCode(Object), hash(Object[]), isNull(Object), nonNull(Object), requireNonNull(T), requireNonNull(T, String), requireNonNull(T, Supplier), requireNonNullElse(T, T), requireNonNullElseGet(T, Supplier), checkIndex(int, int), checkFromToIndex(int, int, int), checkFromIndexSize(int, int, int), toString(Object), toString(Object, String)
Optional: Methods: empty(), of(T), ofNullable(T), isPresent(), isEmpty(), get(), ifPresent(Consumer), ifPresentOrElse(Consumer, Runnable), filter(Predicate), map(Function), flatMap(Function), or(Supplier), stream(), orElse(T), orElseGet(Supplier), orElseThrow(), orElseThrow(Supplier), equals(Object), hashCode(), toString()
OptionalDouble: Methods: empty(), of(double), isPresent(), isEmpty(), getAsDouble(), ifPresent(DoubleConsumer), ifPresentOrElse(DoubleConsumer, Runnable), stream(), orElse(double), orElseGet(DoubleSupplier), orElseThrow(), orElseThrow(Supplier), equals(Object), hashCode(), toString()
OptionalInt: Methods: empty(), of(int), isPresent(), isEmpty(), getAsInt(), ifPresent(IntConsumer), ifPresentOrElse(IntConsumer, Runnable), stream(), orElse(int), orElseGet(IntSupplier), orElseThrow(), orElseThrow(Supplier), equals(Object), hashCode(), toString()
OptionalLong: Methods: empty(), of(long), isPresent(), isEmpty(), getAsLong(), ifPresent(LongConsumer), ifPresentOrElse(LongConsumer, Runnable), stream(), orElse(long), orElseGet(LongSupplier), orElseThrow(), orElseThrow(Supplier), equals(Object), hashCode(), toString()
PrimitiveIterator: Methods: forEachRemaining(C)
PrimitiveIterator.OfDouble: Methods: nextDouble(), next(), forEachRemaining(DoubleConsumer), forEachRemaining(Consumer)
PrimitiveIterator.OfInt: Methods: nextInt(), next(), forEachRemaining(IntConsumer), forEachRemaining(Consumer)
PrimitiveIterator.OfLong: Methods: nextLong(), next(), forEachRemaining(LongConsumer), forEachRemaining(Consumer)
PriorityQueue: Constructors: PriorityQueue(), PriorityQueue(Collection), PriorityQueue(int), PriorityQueue(int, Comparator), PriorityQueue(Comparator), PriorityQueue(PriorityQueue), PriorityQueue(SortedSet); Methods: addAll(Collection), clear(), comparator(), contains(Object), iterator(), offer(E), peek(), poll(), remove(Object), removeAll(Collection), retainAll(Collection), size(), spliterator(), toArray(), toArray(T[])
Queue: Methods: element(), offer(E), peek(), poll(), remove()
Random: Constructors: Random(), Random(long); Methods: nextBoolean(), nextBytes(byte[]), nextDouble(), nextFloat(), nextGaussian(), nextInt(), nextInt(int), nextLong(), setSeed(long), next(int)
RandomAccess
Set: Methods: of(), of(E), of(E, E), of(E, E, E), of(E, E, E, E), of(E, E, E, E, E), of(E, E, E, E, E, E), of(E, E, E, E, E, E, E), of(E, E, E, E, E, E, E, E), of(E, E, E, E, E, E, E, E, E), of(E, E, E, E, E, E, E, E, E, E), of(E[]), spliterator(), copyOf(Collection)
SortedMap: Methods: comparator(), firstKey(), headMap(K), lastKey(), subMap(K, K), tailMap(K)
SortedSet: Methods: comparator(), first(), headSet(E), last(), subSet(E, E), tailSet(E), spliterator()
Spliterator: Fields: DISTINCT, ORDERED, NONNULL, CONCURRENT, SORTED, SIZED, IMMUTABLE, SUBSIZED; Methods: characteristics(), estimateSize(), forEachRemaining(Consumer), getComparator(), getExactSizeIfKnown(), hasCharacteristics(int), tryAdvance(Consumer), trySplit()
Spliterator.OfDouble: Methods: tryAdvance(Consumer), forEachRemaining(Consumer)
Spliterator.OfInt: Methods: tryAdvance(Consumer), forEachRemaining(Consumer)
Spliterator.OfLong: Methods: tryAdvance(Consumer), forEachRemaining(Consumer)
Spliterator.OfPrimitive: Methods: tryAdvance(C), trySplit(), forEachRemaining(C)
Spliterators: Methods: emptySpliterator(), emptyDoubleSpliterator(), emptyIntSpliterator(), emptyLongSpliterator(), spliterator(Object[], int), spliterator(Object[], int, int, int), spliterator(int[], int), spliterator(int[], int, int, int), spliterator(long[], int), spliterator(long[], int, int, int), spliterator(double[], int), spliterator(double[], int, int, int), spliterator(Collection, int), spliterator(Iterator, long, int), spliteratorUnknownSize(Iterator, int), spliterator(PrimitiveIterator.OfInt, long, int), spliteratorUnknownSize(PrimitiveIterator.OfInt, int), spliterator(PrimitiveIterator.OfLong, long, int), spliteratorUnknownSize(PrimitiveIterator.OfLong, int), spliterator(PrimitiveIterator.OfDouble, long, int), spliteratorUnknownSize(PrimitiveIterator.OfDouble, int), iterator(Spliterator), iterator(Spliterator.OfDouble), iterator(Spliterator.OfInt), iterator(Spliterator.OfLong)
Spliterators.AbstractDoubleSpliterator: Constructors: AbstractDoubleSpliterator(long, int)
Spliterators.AbstractIntSpliterator: Constructors: AbstractIntSpliterator(long, int)
Spliterators.AbstractLongSpliterator: Constructors: AbstractLongSpliterator(long, int)
Spliterators.AbstractSpliterator: Constructors: AbstractSpliterator(long, int)
Stack: Constructors: Stack(); Methods: clone(), empty(), peek(), pop(), push(E), search(Object)
StringJoiner: Constructors: StringJoiner(CharSequence), StringJoiner(CharSequence, CharSequence, CharSequence); Methods: add(CharSequence), length(), merge(StringJoiner), setEmptyValue(CharSequence), toString()
TooManyListenersException: Constructors: TooManyListenersException(), TooManyListenersException(String)
TreeMap: Constructors: TreeMap(), TreeMap(Comparator), TreeMap(Map), TreeMap(SortedMap); Methods: clear(), clone(), comparator(), entrySet(), headMap(K, boolean), put(K, V), remove(Object), size(), subMap(K, boolean, K, boolean), tailMap(K, boolean)
TreeSet: Constructors: TreeSet(), TreeSet(Collection), TreeSet(Comparator), TreeSet(SortedSet); Methods: add(E), ceiling(E), clear(), clone(), comparator(), contains(Object), descendingIterator(), descendingSet(), first(), floor(E), headSet(E), headSet(E, boolean), higher(E), iterator(), last(), lower(E), pollFirst(), pollLast(), remove(Object), size(), subSet(E, boolean, E, boolean), subSet(E, E), tailSet(E), tailSet(E, boolean)
Vector: Constructors: Vector(), Vector(Collection), Vector(int), Vector(int, int); Methods: add(E), add(int, E), addAll(Collection), addAll(int, Collection), addElement(E), capacity(), clear(), clone(), contains(Object), containsAll(Collection), copyInto(Object[]), elementAt(int), elements(), ensureCapacity(int), firstElement(), forEach(Consumer), get(int), indexOf(Object), indexOf(Object, int), insertElementAt(E, int), isEmpty(), iterator(), lastElement(), lastIndexOf(Object), lastIndexOf(Object, int), remove(int), removeAll(Collection), removeAllElements(), removeElement(Object), removeElementAt(int), removeIf(Predicate), replaceAll(UnaryOperator), set(int, E), setElementAt(E, int), setSize(int), size(), sort(Comparator), subList(int, int), toArray(), toArray(T[]), toString(), trimToSize(), removeRange(int, int)

Package java.util.concurrent

Callable: Methods: call()
CancellationException: Constructors: CancellationException(), CancellationException(String)
ConcurrentHashMap: Constructors: ConcurrentHashMap(), ConcurrentHashMap(int), ConcurrentHashMap(int, float), ConcurrentHashMap(Map); Methods: putIfAbsent(K, V), remove(Object, Object), replace(K, V, V), replace(K, V), containsKey(Object), get(Object), put(K, V), containsValue(Object), remove(Object), entrySet(), contains(Object), elements(), keys(), newKeySet()
ConcurrentMap: Methods: putIfAbsent(K, V), remove(Object, Object), replace(K, V), replace(K, V, V)
Delayed: Methods: getDelay(TimeUnit)
ExecutionException: Constructors: ExecutionException(), ExecutionException(String), ExecutionException(String, Throwable), ExecutionException(Throwable)
Executor: Methods: execute(Runnable)
ExecutorService: Methods: shutdown(), shutdownNow(), isShutdown(), isTerminated(), submit(Callable), submit(Runnable, T), submit(Runnable), invokeAll(Collection), invokeAll(Collection, long, TimeUnit), invokeAny(Collection), invokeAny(Collection, long, TimeUnit)
Executors: Methods: callable(Runnable, T), callable(Runnable)
Flow: Methods: defaultBufferSize()
Flow.Processor
Flow.Publisher: Methods: subscribe(Flow.Subscriber)
Flow.Subscriber: Methods: onSubscribe(Flow.Subscription), onNext(T), onError(Throwable), onComplete()
Flow.Subscription: Methods: request(long), cancel()
Future: Methods: cancel(boolean), isCancelled(), isDone(), get(), get(long, TimeUnit)
RejectedExecutionException: Constructors: RejectedExecutionException(), RejectedExecutionException(String), RejectedExecutionException(String, Throwable), RejectedExecutionException(Throwable)
RunnableFuture
ScheduledExecutorService: Methods: schedule(Runnable, long, TimeUnit), schedule(Callable, long, TimeUnit), scheduleAtFixedRate(Runnable, long, long, TimeUnit), scheduleWithFixedDelay(Runnable, long, long, TimeUnit)
ScheduledFuture
TimeUnit: Fields: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS; Methods: values(), valueOf(String), convert(long, TimeUnit), toNanos(long), toMicros(long), toMillis(long), toSeconds(long), toMinutes(long), toHours(long), toDays(long)
TimeoutException: Constructors: TimeoutException(), TimeoutException(String)

Package java.util.concurrent.atomic

AtomicBoolean: Constructors: AtomicBoolean(boolean), AtomicBoolean(); Methods: get(), compareAndSet(boolean, boolean), weakCompareAndSet(boolean, boolean), set(boolean), lazySet(boolean), getAndSet(boolean), toString()
AtomicInteger: Constructors: AtomicInteger(int), AtomicInteger(); Methods: get(), set(int), lazySet(int), getAndSet(int), compareAndSet(int, int), getAndIncrement(), getAndDecrement(), getAndAdd(int), incrementAndGet(), decrementAndGet(), addAndGet(int), toString(), intValue(), longValue(), floatValue(), doubleValue()
AtomicLong: Constructors: AtomicLong(long), AtomicLong(); Methods: get(), set(long), lazySet(long), getAndSet(long), compareAndSet(long, long), getAndIncrement(), getAndDecrement(), getAndAdd(long), incrementAndGet(), decrementAndGet(), addAndGet(long), toString(), intValue(), longValue(), floatValue(), doubleValue()
AtomicReference: Constructors: AtomicReference(), AtomicReference(V); Methods: compareAndSet(V, V), get(), getAndSet(V), lazySet(V), set(V), weakCompareAndSet(V, V), toString()
AtomicReferenceArray: Constructors: AtomicReferenceArray(V[]), AtomicReferenceArray(int); Methods: compareAndSet(int, V, V), get(int), getAndSet(int, V), lazySet(int, V), length(), set(int, V), weakCompareAndSet(int, V, V), toString()

Package java.util.function

BiConsumer: Methods: accept(T, U), andThen(BiConsumer)
BiFunction: Methods: apply(T, U), andThen(Function)
BiPredicate: Methods: test(T, U), negate(), and(BiPredicate), or(BiPredicate)
BinaryOperator: Methods: maxBy(Comparator), minBy(Comparator)
BooleanSupplier: Methods: getAsBoolean()
Consumer: Methods: accept(T), andThen(Consumer)
DoubleBinaryOperator: Methods: applyAsDouble(double, double)
DoubleConsumer: Methods: accept(double), andThen(DoubleConsumer)
DoubleFunction: Methods: apply(double)
DoublePredicate: Methods: test(double), negate(), and(DoublePredicate), or(DoublePredicate)
DoubleSupplier: Methods: getAsDouble()
DoubleToIntFunction: Methods: applyAsInt(double)
DoubleToLongFunction: Methods: applyAsLong(double)
DoubleUnaryOperator: Methods: identity(), applyAsDouble(double), andThen(DoubleUnaryOperator), compose(DoubleUnaryOperator)
Function: Methods: identity(), apply(T), andThen(Function), compose(Function)
IntBinaryOperator: Methods: applyAsInt(int, int)
IntConsumer: Methods: accept(int), andThen(IntConsumer)
IntFunction: Methods: apply(int)
IntPredicate: Methods: test(int), negate(), and(IntPredicate), or(IntPredicate)
IntSupplier: Methods: getAsInt()
IntToDoubleFunction: Methods: applyAsDouble(int)
IntToLongFunction: Methods: applyAsLong(int)
IntUnaryOperator: Methods: identity(), applyAsInt(int), andThen(IntUnaryOperator), compose(IntUnaryOperator)
LongBinaryOperator: Methods: applyAsLong(long, long)
LongConsumer: Methods: accept(long), andThen(LongConsumer)
LongFunction: Methods: apply(long)
LongPredicate: Methods: test(long), negate(), and(LongPredicate), or(LongPredicate)
LongSupplier: Methods: getAsLong()
LongToDoubleFunction: Methods: applyAsDouble(long)
LongToIntFunction: Methods: applyAsInt(long)
LongUnaryOperator: Methods: identity(), applyAsLong(long), andThen(LongUnaryOperator), compose(LongUnaryOperator)
ObjDoubleConsumer: Methods: accept(T, double)
ObjIntConsumer: Methods: accept(T, int)
ObjLongConsumer: Methods: accept(T, long)
Predicate: Methods: isEqual(Object), test(T), negate(), and(Predicate), or(Predicate), not(Predicate)
Supplier: Methods: get()
ToDoubleBiFunction: Methods: applyAsDouble(T, U)
ToDoubleFunction: Methods: applyAsDouble(T)
ToIntBiFunction: Methods: applyAsInt(T, U)
ToIntFunction: Methods: applyAsInt(T)
ToLongBiFunction: Methods: applyAsLong(T, U)
ToLongFunction: Methods: applyAsLong(T)
UnaryOperator: Methods: identity()

Package java.util.logging

Formatter: Constructors: Formatter(); Methods: format(LogRecord), formatMessage(LogRecord)
Handler: Constructors: Handler(); Methods: close(), flush(), getFormatter(), getLevel(), isLoggable(LogRecord), publish(LogRecord), setFormatter(Formatter), setLevel(Level)
Level: Fields: ALL, CONFIG, FINE, FINER, FINEST, INFO, OFF, SEVERE, WARNING; Constructors: Level(); Methods: parse(String), getName(), intValue(), toString()
LogManager: Constructors: LogManager(); Methods: getLogManager(), addLogger(Logger), getLogger(String), getLoggerNames()
LogRecord: Constructors: LogRecord(Level, String), LogRecord(); Methods: getLevel(), getLoggerName(), getMessage(), getMillis(), getThrown(), setLevel(Level), setLoggerName(String), setMessage(String), setMillis(long), setThrown(Throwable)
Logger: Fields: GLOBAL_LOGGER_NAME; Constructors: Logger(String, String); Methods: getGlobal(), getLogger(String), addHandler(Handler), config(String), config(Supplier), fine(String), fine(Supplier), finer(String), finer(Supplier), finest(String), finest(Supplier), info(String), info(Supplier), warning(String), warning(Supplier), severe(String), severe(Supplier), getHandlers(), getLevel(), getName(), getParent(), getUseParentHandlers(), isLoggable(Level), log(Level, String), log(Level, Supplier), log(Level, String, Throwable), log(Level, Throwable, Supplier), log(LogRecord), removeHandler(Handler), setLevel(Level), setParent(Logger), setUseParentHandlers(boolean)

Package java.util.stream

BaseStream: Methods: iterator(), spliterator(), isParallel(), sequential(), parallel(), unordered(), onClose(Runnable), close()
Collector: Methods: of(Supplier, BiConsumer, BinaryOperator, Function, Collector.Characteristics[]), of(Supplier, BiConsumer, BinaryOperator, Collector.Characteristics[]), supplier(), accumulator(), characteristics(), combiner(), finisher()
Collector.Characteristics: Fields: CONCURRENT, IDENTITY_FINISH, UNORDERED; Methods: values(), valueOf(String)
Collectors: Methods: averagingDouble(ToDoubleFunction), averagingInt(ToIntFunction), averagingLong(ToLongFunction), collectingAndThen(Collector, Function), teeing(Collector, Collector, BiFunction), counting(), groupingBy(Function), groupingBy(Function, Collector), groupingBy(Function, Supplier, Collector), joining(), joining(CharSequence), joining(CharSequence, CharSequence, CharSequence), mapping(Function, Collector), flatMapping(Function, Collector), filtering(Predicate, Collector), maxBy(Comparator), minBy(Comparator), partitioningBy(Predicate), partitioningBy(Predicate, Collector), reducing(BinaryOperator), reducing(T, BinaryOperator), reducing(U, Function, BinaryOperator), summarizingDouble(ToDoubleFunction), summarizingInt(ToIntFunction), summarizingLong(ToLongFunction), summingDouble(ToDoubleFunction), summingInt(ToIntFunction), summingLong(ToLongFunction), toCollection(Supplier), toList(), toUnmodifiableList(), toMap(Function, Function), toMap(Function, Function, BinaryOperator), toUnmodifiableMap(Function, Function), toUnmodifiableMap(Function, Function, BinaryOperator), toMap(Function, Function, BinaryOperator, Supplier), toSet(), toUnmodifiableSet()
DoubleStream: Methods: builder(), concat(DoubleStream, DoubleStream), empty(), generate(DoubleSupplier), iterate(double, DoubleUnaryOperator), iterate(double, DoublePredicate, DoubleUnaryOperator), of(double[]), of(double), allMatch(DoublePredicate), anyMatch(DoublePredicate), average(), boxed(), collect(Supplier, ObjDoubleConsumer, BiConsumer), count(), distinct(), dropWhile(DoublePredicate), filter(DoublePredicate), findAny(), findFirst(), flatMap(DoubleFunction), forEach(DoubleConsumer), forEachOrdered(DoubleConsumer), iterator(), limit(long), map(DoubleUnaryOperator), mapToInt(DoubleToIntFunction), mapToLong(DoubleToLongFunction), mapToObj(DoubleFunction), max(), min(), noneMatch(DoublePredicate), parallel(), peek(DoubleConsumer), reduce(DoubleBinaryOperator), reduce(double, DoubleBinaryOperator), sequential(), skip(long), sorted(), spliterator(), sum(), summaryStatistics(), takeWhile(DoublePredicate), mapMulti(DoubleStream.DoubleMapMultiConsumer), toArray()
DoubleStream.Builder: Methods: accept(double), add(double), build()
DoubleStream.DoubleMapMultiConsumer: Methods: accept(double, DoubleConsumer)
IntStream: Methods: builder(), concat(IntStream, IntStream), empty(), generate(IntSupplier), iterate(int, IntUnaryOperator), iterate(int, IntPredicate, IntUnaryOperator), of(int[]), of(int), range(int, int), rangeClosed(int, int), allMatch(IntPredicate), anyMatch(IntPredicate), asDoubleStream(), asLongStream(), average(), boxed(), collect(Supplier, ObjIntConsumer, BiConsumer), count(), distinct(), dropWhile(IntPredicate), filter(IntPredicate), findAny(), findFirst(), flatMap(IntFunction), forEach(IntConsumer), forEachOrdered(IntConsumer), iterator(), limit(long), map(IntUnaryOperator), mapToDouble(IntToDoubleFunction), mapToLong(IntToLongFunction), mapToObj(IntFunction), max(), min(), noneMatch(IntPredicate), parallel(), peek(IntConsumer), reduce(IntBinaryOperator), reduce(int, IntBinaryOperator), sequential(), skip(long), sorted(), spliterator(), sum(), summaryStatistics(), takeWhile(IntPredicate), mapMulti(IntStream.IntMapMultiConsumer), toArray()
IntStream.Builder: Methods: accept(int), add(int), build()
IntStream.IntMapMultiConsumer: Methods: accept(int, IntConsumer)
LongStream: Methods: builder(), concat(LongStream, LongStream), empty(), generate(LongSupplier), iterate(long, LongUnaryOperator), iterate(long, LongPredicate, LongUnaryOperator), of(long[]), of(long), range(long, long), rangeClosed(long, long), allMatch(LongPredicate), anyMatch(LongPredicate), asDoubleStream(), average(), boxed(), collect(Supplier, ObjLongConsumer, BiConsumer), count(), distinct(), dropWhile(LongPredicate), filter(LongPredicate), findAny(), findFirst(), flatMap(LongFunction), forEach(LongConsumer), forEachOrdered(LongConsumer), iterator(), limit(long), map(LongUnaryOperator), mapToDouble(LongToDoubleFunction), mapToInt(LongToIntFunction), mapToObj(LongFunction), max(), min(), noneMatch(LongPredicate), parallel(), peek(LongConsumer), reduce(LongBinaryOperator), reduce(long, LongBinaryOperator), sequential(), skip(long), sorted(), spliterator(), sum(), summaryStatistics(), takeWhile(LongPredicate), mapMulti(LongStream.LongMapMultiConsumer), toArray()
LongStream.Builder: Methods: accept(long), add(long), build()
LongStream.LongMapMultiConsumer: Methods: accept(long, LongConsumer)
Stream: Methods: builder(), concat(Stream, Stream), empty(), generate(Supplier), iterate(T, UnaryOperator), iterate(T, Predicate, UnaryOperator), of(T), of(T[]), ofNullable(T), allMatch(Predicate), anyMatch(Predicate), collect(Collector), collect(Supplier, BiConsumer, BiConsumer), count(), distinct(), dropWhile(Predicate), toList(), filter(Predicate), findAny(), findFirst(), flatMap(Function), flatMapToDouble(Function), flatMapToInt(Function), flatMapToLong(Function), forEach(Consumer), forEachOrdered(Consumer), limit(long), map(Function), mapToDouble(ToDoubleFunction), mapToInt(ToIntFunction), mapToLong(ToLongFunction), max(Comparator), min(Comparator), noneMatch(Predicate), peek(Consumer), reduce(BinaryOperator), reduce(T, BinaryOperator), reduce(U, BiFunction, BinaryOperator), skip(long), sorted(), sorted(Comparator), takeWhile(Predicate), mapMulti(BiConsumer), mapMultiToDouble(BiConsumer), mapMultiToInt(BiConsumer), mapMultiToLong(BiConsumer), toArray(), toArray(IntFunction)
Stream.Builder: Methods: accept(T), add(T), build()
StreamSupport: Methods: doubleStream(Spliterator.OfDouble, boolean), doubleStream(Supplier, int, boolean), intStream(Spliterator.OfInt, boolean), intStream(Supplier, int, boolean), longStream(Spliterator.OfLong, boolean), longStream(Supplier, int, boolean), stream(Spliterator, boolean), stream(Supplier, int, boolean)