Haxe Java 官方文档

java.util

  • AbstractCollection
  • AbstractCollection.add()
  • AbstractCollection.addAll()
  • AbstractCollection.clear()
  • AbstractCollection.contains()
  • AbstractCollection.containsAll()
  • AbstractCollection.isEmpty()
  • AbstractCollection.iterator()
  • AbstractCollection.remove()
  • AbstractCollection.removeAll()
  • AbstractCollection.retainAll()
  • AbstractCollection.size()
  • AbstractCollection.toArray()
  • AbstractCollection.toString()
  • AbstractSet
  • AbstractSet.equals()
  • AbstractSet.hashCode()
  • Calendar
  • Calendar.add()
  • Calendar.after()
  • Calendar.ALL_STYLES
  • Calendar.AM
  • Calendar.AM_PM
  • Calendar.APRIL
  • Calendar.AUGUST
  • Calendar.before()
  • Calendar.clear()
  • Calendar.clone()
  • Calendar.compareTo()
  • Calendar.DATE
  • Calendar.DAY_OF_MONTH
  • Calendar.DAY_OF_WEEK
  • Calendar.DAY_OF_WEEK_IN_MONTH
  • Calendar.DAY_OF_YEAR
  • Calendar.DECEMBER
  • Calendar.DST_OFFSET
  • Calendar.equals()
  • Calendar.ERA
  • Calendar.FEBRUARY
  • Calendar.FIELD_COUNT
  • Calendar.FRIDAY
  • Calendar.get()
  • Calendar.getActualMaximum()
  • Calendar.getActualMinimum()
  • Calendar.getAvailableLocales()
  • Calendar.getDisplayName()
  • Calendar.getDisplayNames()
  • Calendar.getFirstDayOfWeek()
  • Calendar.getGreatestMinimum()
  • Calendar.getInstance()
  • Calendar.getLeastMaximum()
  • Calendar.getMaximum()
  • Calendar.getMinimalDaysInFirstWeek()
  • Calendar.getMinimum()
  • Calendar.getTime()
  • Calendar.getTimeInMillis()
  • Calendar.getTimeZone()
  • Calendar.getWeeksInWeekYear()
  • Calendar.getWeekYear()
  • Calendar.hashCode()
  • Calendar.HOUR
  • Calendar.HOUR_OF_DAY
  • Calendar.isLenient()
  • Calendar.isSet()
  • Calendar.isWeekDateSupported()
  • Calendar.JANUARY
  • Calendar.JULY
  • Calendar.JUNE
  • Calendar.LONG
  • Calendar.MARCH
  • Calendar.MAY
  • Calendar.MILLISECOND
  • Calendar.MINUTE
  • Calendar.MONDAY
  • Calendar.MONTH
  • Calendar.NOVEMBER
  • Calendar.OCTOBER
  • Calendar.PM
  • Calendar.roll()
  • Calendar.SATURDAY
  • Calendar.SECOND
  • Calendar.SEPTEMBER
  • Calendar.set()
  • Calendar.setFirstDayOfWeek()
  • Calendar.setLenient()
  • Calendar.setMinimalDaysInFirstWeek()
  • Calendar.setTime()
  • Calendar.setTimeInMillis()
  • Calendar.setTimeZone()
  • Calendar.setWeekDate()
  • Calendar.SHORT
  • Calendar.SUNDAY
  • Calendar.THURSDAY
  • Calendar.toString()
  • Calendar.TUESDAY
  • Calendar.UNDECIMBER
  • Calendar.WEDNESDAY
  • Calendar.WEEK_OF_MONTH
  • Calendar.WEEK_OF_YEAR
  • Calendar.YEAR
  • Calendar.ZONE_OFFSET
  • Calendar_CalendarAccessControlContext
  • Collection
  • Collection.add()
  • Collection.addAll()
  • Collection.clear()
  • Collection.contains()
  • Collection.containsAll()
  • Collection.isEmpty()
  • Collection.iterator()
  • Collection.remove()
  • Collection.removeAll()
  • Collection.retainAll()
  • Collection.size()
  • Collection.toArray()
  • Date
  • Date.after()
  • Date.before()
  • Date.clone()
  • Date.compareTo()
  • Date.equals()
  • Date.getDate()
  • Date.getDay()
  • Date.getHours()
  • Date.getMinutes()
  • Date.getMonth()
  • Date.getSeconds()
  • Date.getTime()
  • Date.getTimezoneOffset()
  • Date.getYear()
  • Date.hashCode()
  • Date.parse()
  • Date.setDate()
  • Date.setHours()
  • Date.setMinutes()
  • Date.setMonth()
  • Date.setSeconds()
  • Date.setTime()
  • Date.setYear()
  • Date.toGMTString()
  • Date.toLocaleString()
  • Date.toString()
  • Date.UTC()
  • Dictionary
  • Dictionary.elements()
  • Dictionary.get()
  • Dictionary.isEmpty()
  • Dictionary.keys()
  • Dictionary.put()
  • Dictionary.remove()
  • Dictionary.size()
  • Enumeration
  • Enumeration.hasMoreElements()
  • Enumeration.nextElement()
  • Hashtable
  • Hashtable.clear()
  • Hashtable.clone()
  • Hashtable.contains()
  • Hashtable.containsKey()
  • Hashtable.containsValue()
  • Hashtable.entrySet()
  • Hashtable.equals()
  • Hashtable.hashCode()
  • Hashtable.keySet()
  • Hashtable.putAll()
  • Hashtable.toString()
  • Hashtable.values()
  • Hashtable_1
  • Hashtable_Entry
  • Hashtable_Entry.equals()
  • Hashtable_Entry.getKey()
  • Hashtable_Entry.getValue()
  • Hashtable_Entry.hashCode()
  • Hashtable_Entry.setValue()
  • Hashtable_Entry.toString()
  • Hashtable_EntrySet
  • Hashtable_Enumerator
  • Hashtable_Enumerator.hasMoreElements()
  • Hashtable_Enumerator.hasNext()
  • Hashtable_Enumerator.next()
  • Hashtable_Enumerator.nextElement()
  • Hashtable_Enumerator.remove()
  • Hashtable_Holder
  • Hashtable_KeySet
  • Hashtable_ValueCollection
  • InvalidPropertiesFormatException
  • Iterator
  • Iterator.hasNext()
  • Iterator.next()
  • Iterator.remove()
  • List
  • List.add()
  • List.addAll()
  • List.clear()
  • List.contains()
  • List.containsAll()
  • List.get()
  • List.indexOf()
  • List.isEmpty()
  • List.iterator()
  • List.lastIndexOf()
  • List.listIterator()
  • List.remove()
  • List.removeAll()
  • List.retainAll()
  • List.set()
  • List.size()
  • List.subList()
  • List.toArray()
  • ListIterator
  • ListIterator.add()
  • ListIterator.hasNext()
  • ListIterator.hasPrevious()
  • ListIterator.next()
  • ListIterator.nextIndex()
  • ListIterator.previous()
  • ListIterator.previousIndex()
  • ListIterator.remove()
  • ListIterator.set()
  • Locale
  • Locale.CANADA
  • Locale.CANADA_FRENCH
  • Locale.CHINA
  • Locale.CHINESE
  • Locale.clone()
  • Locale.ENGLISH
  • Locale.equals()
  • Locale.forLanguageTag()
  • Locale.FRANCE
  • Locale.FRENCH
  • Locale.GERMAN
  • Locale.GERMANY
  • Locale.getAvailableLocales()
  • Locale.getCountry()
  • Locale.getDefault()
  • Locale.getDisplayCountry()
  • Locale.getDisplayLanguage()
  • Locale.getDisplayName()
  • Locale.getDisplayScript()
  • Locale.getDisplayVariant()
  • Locale.getExtension()
  • Locale.getExtensionKeys()
  • Locale.getISO3Country()
  • Locale.getISO3Language()
  • Locale.getISOCountries()
  • Locale.getISOLanguages()
  • Locale.getLanguage()
  • Locale.getScript()
  • Locale.getUnicodeLocaleAttributes()
  • Locale.getUnicodeLocaleKeys()
  • Locale.getUnicodeLocaleType()
  • Locale.getVariant()
  • Locale.hashCode()
  • Locale.ITALIAN
  • Locale.ITALY
  • Locale.JAPAN
  • Locale.JAPANESE
  • Locale.KOREA
  • Locale.KOREAN
  • Locale.PRC
  • Locale.PRIVATE_USE_EXTENSION
  • Locale.ROOT
  • Locale.setDefault()
  • Locale.SIMPLIFIED_CHINESE
  • Locale.TAIWAN
  • Locale.toLanguageTag()
  • Locale.toString()
  • Locale.TRADITIONAL_CHINESE
  • Locale.UK
  • Locale.UNICODE_LOCALE_EXTENSION
  • Locale.US
  • Locale_1
  • Locale_Builder
  • Locale_Builder.addUnicodeLocaleAttribute()
  • Locale_Builder.build()
  • Locale_Builder.clear()
  • Locale_Builder.clearExtensions()
  • Locale_Builder.removeUnicodeLocaleAttribute()
  • Locale_Builder.setExtension()
  • Locale_Builder.setLanguage()
  • Locale_Builder.setLanguageTag()
  • Locale_Builder.setLocale()
  • Locale_Builder.setRegion()
  • Locale_Builder.setScript()
  • Locale_Builder.setUnicodeLocaleKeyword()
  • Locale_Builder.setVariant()
  • Locale_Cache
  • Locale_Category
  • Locale_Category.DISPLAY
  • Locale_Category.FORMAT
  • Locale_LocaleKey
  • Locale_LocaleKey.equals()
  • Locale_LocaleKey.hashCode()
  • Locale_LocaleNameGetter
  • Locale_LocaleNameGetter.getObject()
  • Map
  • Map.clear()
  • Map.containsKey()
  • Map.containsValue()
  • Map.entrySet()
  • Map.get()
  • Map.isEmpty()
  • Map.keySet()
  • Map.put()
  • Map.putAll()
  • Map.remove()
  • Map.size()
  • Map.values()
  • Map_Entry
  • Map_Entry.getKey()
  • Map_Entry.getValue()
  • Map_Entry.setValue()
  • MissingResourceException
  • MissingResourceException.getClassName()
  • MissingResourceException.getKey()
  • Properties
  • Properties.getProperty()
  • Properties.list()
  • Properties.load()
  • Properties.loadFromXML()
  • Properties.propertyNames()
  • Properties.save()
  • Properties.setProperty()
  • Properties.store()
  • Properties.storeToXML()
  • Properties.stringPropertyNames()
  • Properties_LineReader
  • Random
  • Random.nextBoolean()
  • Random.nextBytes()
  • Random.nextDouble()
  • Random.nextFloat()
  • Random.nextGaussian()
  • Random.nextInt()
  • Random.nextLong()
  • Random.setSeed()
  • ResourceBundle
  • ResourceBundle.clearCache()
  • ResourceBundle.containsKey()
  • ResourceBundle.getBundle()
  • ResourceBundle.getKeys()
  • ResourceBundle.getLocale()
  • ResourceBundle.getObject()
  • ResourceBundle.getString()
  • ResourceBundle.getStringArray()
  • ResourceBundle.keySet()
  • ResourceBundle_BundleReference
  • ResourceBundle_BundleReference.getCacheKey()
  • ResourceBundle_CacheKey
  • ResourceBundle_CacheKey.clone()
  • ResourceBundle_CacheKey.equals()
  • ResourceBundle_CacheKey.hashCode()
  • ResourceBundle_CacheKey.toString()
  • ResourceBundle_CacheKeyReference
  • ResourceBundle_CacheKeyReference.getCacheKey()
  • ResourceBundle_Control
  • ResourceBundle_Control.FORMAT_CLASS
  • ResourceBundle_Control.FORMAT_DEFAULT
  • ResourceBundle_Control.FORMAT_PROPERTIES
  • ResourceBundle_Control.getCandidateLocales()
  • ResourceBundle_Control.getControl()
  • ResourceBundle_Control.getFallbackLocale()
  • ResourceBundle_Control.getFormats()
  • ResourceBundle_Control.getNoFallbackControl()
  • ResourceBundle_Control.getTimeToLive()
  • ResourceBundle_Control.needsReload()
  • ResourceBundle_Control.newBundle()
  • ResourceBundle_Control.toBundleName()
  • ResourceBundle_Control.toResourceName()
  • ResourceBundle_Control.TTL_DONT_CACHE
  • ResourceBundle_Control.TTL_NO_EXPIRATION_CONTROL
  • ResourceBundle_Control_CandidateListCache
  • ResourceBundle_LoaderReference
  • ResourceBundle_LoaderReference.getCacheKey()
  • ResourceBundle_NoFallbackControl
  • ResourceBundle_RBClassLoader
  • ResourceBundle_SingleFormatControl
  • Set
  • Set.add()
  • Set.addAll()
  • Set.clear()
  • Set.contains()
  • Set.containsAll()
  • Set.isEmpty()
  • Set.iterator()
  • Set.remove()
  • Set.removeAll()
  • Set.retainAll()
  • Set.size()
  • Set.toArray()
  • Timer
  • Timer.cancel()
  • Timer.purge()
  • Timer.schedule()
  • Timer.scheduleAtFixedRate()
  • TimerTask
  • TimerTask.cancel()
  • TimerTask.run()
  • TimerTask.scheduledExecutionTime()
  • TimeZone
  • TimeZone.clone()
  • TimeZone.getAvailableIDs()
  • TimeZone.getDefault()
  • TimeZone.getDisplayName()
  • TimeZone.getDSTSavings()
  • TimeZone.getID()
  • TimeZone.getOffset()
  • TimeZone.getRawOffset()
  • TimeZone.getTimeZone()
  • TimeZone.hasSameRules()
  • TimeZone.inDaylightTime()
  • TimeZone.LONG
  • TimeZone.observesDaylightTime()
  • TimeZone.setDefault()
  • TimeZone.setID()
  • TimeZone.setRawOffset()
  • TimeZone.SHORT
  • TimeZone.useDaylightTime()
  • TimeZone_DisplayNames

    • java.lang

  • AbstractStringBuilder
  • AbstractStringBuilder.append()
  • AbstractStringBuilder.appendCodePoint()
  • AbstractStringBuilder.capacity()
  • AbstractStringBuilder.charAt()
  • AbstractStringBuilder.codePointAt()
  • AbstractStringBuilder.codePointBefore()
  • AbstractStringBuilder.codePointCount()
  • AbstractStringBuilder.delete()
  • AbstractStringBuilder.deleteCharAt()
  • AbstractStringBuilder.ensureCapacity()
  • AbstractStringBuilder.getChars()
  • AbstractStringBuilder.indexOf()
  • AbstractStringBuilder.insert()
  • AbstractStringBuilder.lastIndexOf()
  • AbstractStringBuilder.length()
  • AbstractStringBuilder.offsetByCodePoints()
  • AbstractStringBuilder.replace()
  • AbstractStringBuilder.reverse()
  • AbstractStringBuilder.setCharAt()
  • AbstractStringBuilder.setLength()
  • AbstractStringBuilder.subSequence()
  • AbstractStringBuilder.substring()
  • AbstractStringBuilder.toString()
  • AbstractStringBuilder.trimToSize()
  • Appendable
  • Appendable.append()
  • AutoCloseable
  • AutoCloseable.close()
  • Boolean
  • Boolean.fromBool()
  • Boolean.toBool()
  • BooleanClass
  • BooleanClass.booleanValue()
  • BooleanClass.compare()
  • BooleanClass.compareTo()
  • BooleanClass.equals()
  • BooleanClass.FALSE
  • BooleanClass.getBoolean()
  • BooleanClass.hashCode()
  • BooleanClass.parseBoolean()
  • BooleanClass.toString()
  • BooleanClass.TRUE
  • BooleanClass.TYPE
  • BooleanClass.valueOf()
  • BooleanClass._toString()
  • Byte
  • Byte.fromByte()
  • Byte.toByte()
  • ByteClass
  • ByteClass.compare()
  • ByteClass.compareTo()
  • ByteClass.decode()
  • ByteClass.equals()
  • ByteClass.hashCode()
  • ByteClass.MAX_VALUE
  • ByteClass.MIN_VALUE
  • ByteClass.parseByte()
  • ByteClass.SIZE
  • ByteClass.toString()
  • ByteClass.TYPE
  • ByteClass.valueOf()
  • ByteClass._toString()
  • Byte_ByteCache
  • Character
  • Character.fromCharacter()
  • Character.toCharacter()
  • CharacterClass
  • CharacterClass.charCount()
  • CharacterClass.charValue()
  • CharacterClass.codePointAt()
  • CharacterClass.codePointBefore()
  • CharacterClass.codePointCount()
  • CharacterClass.COMBINING_SPACING_MARK
  • CharacterClass.compare()
  • CharacterClass.compareTo()
  • CharacterClass.CONNECTOR_PUNCTUATION
  • CharacterClass.CONTROL
  • CharacterClass.CURRENCY_SYMBOL
  • CharacterClass.DASH_PUNCTUATION
  • CharacterClass.DECIMAL_DIGIT_NUMBER
  • CharacterClass.digit()
  • CharacterClass.DIRECTIONALITY_ARABIC_NUMBER
  • CharacterClass.DIRECTIONALITY_BOUNDARY_NEUTRAL
  • CharacterClass.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
  • CharacterClass.DIRECTIONALITY_EUROPEAN_NUMBER
  • CharacterClass.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
  • CharacterClass.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
  • CharacterClass.DIRECTIONALITY_LEFT_TO_RIGHT
  • CharacterClass.DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
  • CharacterClass.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
  • CharacterClass.DIRECTIONALITY_NONSPACING_MARK
  • CharacterClass.DIRECTIONALITY_OTHER_NEUTRALS
  • CharacterClass.DIRECTIONALITY_PARAGRAPH_SEPARATOR
  • CharacterClass.DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
  • CharacterClass.DIRECTIONALITY_RIGHT_TO_LEFT
  • CharacterClass.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
  • CharacterClass.DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
  • CharacterClass.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
  • CharacterClass.DIRECTIONALITY_SEGMENT_SEPARATOR
  • CharacterClass.DIRECTIONALITY_UNDEFINED
  • CharacterClass.DIRECTIONALITY_WHITESPACE
  • CharacterClass.ENCLOSING_MARK
  • CharacterClass.END_PUNCTUATION
  • CharacterClass.equals()
  • CharacterClass.FINAL_QUOTE_PUNCTUATION
  • CharacterClass.forDigit()
  • CharacterClass.FORMAT
  • CharacterClass.getDirectionality()
  • CharacterClass.getName()
  • CharacterClass.getNumericValue()
  • CharacterClass.getType()
  • CharacterClass.hashCode()
  • CharacterClass.highSurrogate()
  • CharacterClass.INITIAL_QUOTE_PUNCTUATION
  • CharacterClass.isAlphabetic()
  • CharacterClass.isBmpCodePoint()
  • CharacterClass.isDefined()
  • CharacterClass.isDigit()
  • CharacterClass.isHighSurrogate()
  • CharacterClass.isIdentifierIgnorable()
  • CharacterClass.isIdeographic()
  • CharacterClass.isISOControl()
  • CharacterClass.isJavaIdentifierPart()
  • CharacterClass.isJavaIdentifierStart()
  • CharacterClass.isJavaLetter()
  • CharacterClass.isJavaLetterOrDigit()
  • CharacterClass.isLetter()
  • CharacterClass.isLetterOrDigit()
  • CharacterClass.isLowerCase()
  • CharacterClass.isLowSurrogate()
  • CharacterClass.isMirrored()
  • CharacterClass.isSpace()
  • CharacterClass.isSpaceChar()
  • CharacterClass.isSupplementaryCodePoint()
  • CharacterClass.isSurrogate()
  • CharacterClass.isSurrogatePair()
  • CharacterClass.isTitleCase()
  • CharacterClass.isUnicodeIdentifierPart()
  • CharacterClass.isUnicodeIdentifierStart()
  • CharacterClass.isUpperCase()
  • CharacterClass.isValidCodePoint()
  • CharacterClass.isWhitespace()
  • CharacterClass.LETTER_NUMBER
  • CharacterClass.LINE_SEPARATOR
  • CharacterClass.LOWERCASE_LETTER
  • CharacterClass.lowSurrogate()
  • CharacterClass.MATH_SYMBOL
  • CharacterClass.MAX_CODE_POINT
  • CharacterClass.MAX_HIGH_SURROGATE
  • CharacterClass.MAX_LOW_SURROGATE
  • CharacterClass.MAX_RADIX
  • CharacterClass.MAX_SURROGATE
  • CharacterClass.MAX_VALUE
  • CharacterClass.MIN_CODE_POINT
  • CharacterClass.MIN_HIGH_SURROGATE
  • CharacterClass.MIN_LOW_SURROGATE
  • CharacterClass.MIN_RADIX
  • CharacterClass.MIN_SUPPLEMENTARY_CODE_POINT
  • CharacterClass.MIN_SURROGATE
  • CharacterClass.MIN_VALUE
  • CharacterClass.MODIFIER_LETTER
  • CharacterClass.MODIFIER_SYMBOL
  • CharacterClass.NON_SPACING_MARK
  • CharacterClass.offsetByCodePoints()
  • CharacterClass.OTHER_LETTER
  • CharacterClass.OTHER_NUMBER
  • CharacterClass.OTHER_PUNCTUATION
  • CharacterClass.OTHER_SYMBOL
  • CharacterClass.PARAGRAPH_SEPARATOR
  • CharacterClass.PRIVATE_USE
  • CharacterClass.reverseBytes()
  • CharacterClass.SIZE
  • CharacterClass.SPACE_SEPARATOR
  • CharacterClass.START_PUNCTUATION
  • CharacterClass.SURROGATE
  • CharacterClass.TITLECASE_LETTER
  • CharacterClass.toChars()
  • CharacterClass.toCodePoint()
  • CharacterClass.toLowerCase()
  • CharacterClass.toString()
  • CharacterClass.toTitleCase()
  • CharacterClass.toUpperCase()
  • CharacterClass.TYPE
  • CharacterClass.UNASSIGNED
  • CharacterClass.UPPERCASE_LETTER
  • CharacterClass.valueOf()
  • CharacterClass._toString()
  • Character_CharacterCache
  • Character_Subset
  • Character_Subset.equals()
  • Character_Subset.hashCode()
  • Character_Subset.toString()
  • Character_UnicodeBlock
  • Character_UnicodeBlock.AEGEAN_NUMBERS
  • Character_UnicodeBlock.ALCHEMICAL_SYMBOLS
  • Character_UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS
  • Character_UnicodeBlock.ANCIENT_GREEK_MUSICAL_NOTATION
  • Character_UnicodeBlock.ANCIENT_GREEK_NUMBERS
  • Character_UnicodeBlock.ANCIENT_SYMBOLS
  • Character_UnicodeBlock.ARABIC
  • Character_UnicodeBlock.ARABIC_PRESENTATION_FORMS_A
  • Character_UnicodeBlock.ARABIC_PRESENTATION_FORMS_B
  • Character_UnicodeBlock.ARABIC_SUPPLEMENT
  • Character_UnicodeBlock.ARMENIAN
  • Character_UnicodeBlock.ARROWS
  • Character_UnicodeBlock.AVESTAN
  • Character_UnicodeBlock.BALINESE
  • Character_UnicodeBlock.BAMUM
  • Character_UnicodeBlock.BAMUM_SUPPLEMENT
  • Character_UnicodeBlock.BASIC_LATIN
  • Character_UnicodeBlock.BATAK
  • Character_UnicodeBlock.BENGALI
  • Character_UnicodeBlock.BLOCK_ELEMENTS
  • Character_UnicodeBlock.BOPOMOFO
  • Character_UnicodeBlock.BOPOMOFO_EXTENDED
  • Character_UnicodeBlock.BOX_DRAWING
  • Character_UnicodeBlock.BRAHMI
  • Character_UnicodeBlock.BRAILLE_PATTERNS
  • Character_UnicodeBlock.BUGINESE
  • Character_UnicodeBlock.BUHID
  • Character_UnicodeBlock.BYZANTINE_MUSICAL_SYMBOLS
  • Character_UnicodeBlock.CARIAN
  • Character_UnicodeBlock.CHAM
  • Character_UnicodeBlock.CHEROKEE
  • Character_UnicodeBlock.CJK_COMPATIBILITY
  • Character_UnicodeBlock.CJK_COMPATIBILITY_FORMS
  • Character_UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
  • Character_UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT
  • Character_UnicodeBlock.CJK_RADICALS_SUPPLEMENT
  • Character_UnicodeBlock.CJK_STROKES
  • Character_UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
  • Character_UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
  • Character_UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
  • Character_UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
  • Character_UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C
  • Character_UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D
  • Character_UnicodeBlock.COMBINING_DIACRITICAL_MARKS
  • Character_UnicodeBlock.COMBINING_DIACRITICAL_MARKS_SUPPLEMENT
  • Character_UnicodeBlock.COMBINING_HALF_MARKS
  • Character_UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS
  • Character_UnicodeBlock.COMMON_INDIC_NUMBER_FORMS
  • Character_UnicodeBlock.CONTROL_PICTURES
  • Character_UnicodeBlock.COPTIC
  • Character_UnicodeBlock.COUNTING_ROD_NUMERALS
  • Character_UnicodeBlock.CUNEIFORM
  • Character_UnicodeBlock.CUNEIFORM_NUMBERS_AND_PUNCTUATION
  • Character_UnicodeBlock.CURRENCY_SYMBOLS
  • Character_UnicodeBlock.CYPRIOT_SYLLABARY
  • Character_UnicodeBlock.CYRILLIC
  • Character_UnicodeBlock.CYRILLIC_EXTENDED_A
  • Character_UnicodeBlock.CYRILLIC_EXTENDED_B
  • Character_UnicodeBlock.CYRILLIC_SUPPLEMENTARY
  • Character_UnicodeBlock.DESERET
  • Character_UnicodeBlock.DEVANAGARI
  • Character_UnicodeBlock.DEVANAGARI_EXTENDED
  • Character_UnicodeBlock.DINGBATS
  • Character_UnicodeBlock.DOMINO_TILES
  • Character_UnicodeBlock.EGYPTIAN_HIEROGLYPHS
  • Character_UnicodeBlock.EMOTICONS
  • Character_UnicodeBlock.ENCLOSED_ALPHANUMERICS
  • Character_UnicodeBlock.ENCLOSED_ALPHANUMERIC_SUPPLEMENT
  • Character_UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS
  • Character_UnicodeBlock.ENCLOSED_IDEOGRAPHIC_SUPPLEMENT
  • Character_UnicodeBlock.ETHIOPIC
  • Character_UnicodeBlock.ETHIOPIC_EXTENDED
  • Character_UnicodeBlock.ETHIOPIC_EXTENDED_A
  • Character_UnicodeBlock.ETHIOPIC_SUPPLEMENT
  • Character_UnicodeBlock.forName()
  • Character_UnicodeBlock.GENERAL_PUNCTUATION
  • Character_UnicodeBlock.GEOMETRIC_SHAPES
  • Character_UnicodeBlock.GEORGIAN
  • Character_UnicodeBlock.GEORGIAN_SUPPLEMENT
  • Character_UnicodeBlock.GLAGOLITIC
  • Character_UnicodeBlock.GOTHIC
  • Character_UnicodeBlock.GREEK
  • Character_UnicodeBlock.GREEK_EXTENDED
  • Character_UnicodeBlock.GUJARATI
  • Character_UnicodeBlock.GURMUKHI
  • Character_UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS
  • Character_UnicodeBlock.HANGUL_COMPATIBILITY_JAMO
  • Character_UnicodeBlock.HANGUL_JAMO
  • Character_UnicodeBlock.HANGUL_JAMO_EXTENDED_A
  • Character_UnicodeBlock.HANGUL_JAMO_EXTENDED_B
  • Character_UnicodeBlock.HANGUL_SYLLABLES
  • Character_UnicodeBlock.HANUNOO
  • Character_UnicodeBlock.HEBREW
  • Character_UnicodeBlock.HIGH_PRIVATE_USE_SURROGATES
  • Character_UnicodeBlock.HIGH_SURROGATES
  • Character_UnicodeBlock.HIRAGANA
  • Character_UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS
  • Character_UnicodeBlock.IMPERIAL_ARAMAIC
  • Character_UnicodeBlock.INSCRIPTIONAL_PAHLAVI
  • Character_UnicodeBlock.INSCRIPTIONAL_PARTHIAN
  • Character_UnicodeBlock.IPA_EXTENSIONS
  • Character_UnicodeBlock.JAVANESE
  • Character_UnicodeBlock.KAITHI
  • Character_UnicodeBlock.KANA_SUPPLEMENT
  • Character_UnicodeBlock.KANBUN
  • Character_UnicodeBlock.KANGXI_RADICALS
  • Character_UnicodeBlock.KANNADA
  • Character_UnicodeBlock.KATAKANA
  • Character_UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS
  • Character_UnicodeBlock.KAYAH_LI
  • Character_UnicodeBlock.KHAROSHTHI
  • Character_UnicodeBlock.KHMER
  • Character_UnicodeBlock.KHMER_SYMBOLS
  • Character_UnicodeBlock.LAO
  • Character_UnicodeBlock.LATIN_1_SUPPLEMENT
  • Character_UnicodeBlock.LATIN_EXTENDED_A
  • Character_UnicodeBlock.LATIN_EXTENDED_ADDITIONAL
  • Character_UnicodeBlock.LATIN_EXTENDED_B
  • Character_UnicodeBlock.LATIN_EXTENDED_C
  • Character_UnicodeBlock.LATIN_EXTENDED_D
  • Character_UnicodeBlock.LEPCHA
  • Character_UnicodeBlock.LETTERLIKE_SYMBOLS
  • Character_UnicodeBlock.LIMBU
  • Character_UnicodeBlock.LINEAR_B_IDEOGRAMS
  • Character_UnicodeBlock.LINEAR_B_SYLLABARY
  • Character_UnicodeBlock.LISU
  • Character_UnicodeBlock.LOW_SURROGATES
  • Character_UnicodeBlock.LYCIAN
  • Character_UnicodeBlock.LYDIAN
  • Character_UnicodeBlock.MAHJONG_TILES
  • Character_UnicodeBlock.MALAYALAM
  • Character_UnicodeBlock.MANDAIC
  • Character_UnicodeBlock.MATHEMATICAL_ALPHANUMERIC_SYMBOLS
  • Character_UnicodeBlock.MATHEMATICAL_OPERATORS
  • Character_UnicodeBlock.MEETEI_MAYEK
  • Character_UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A
  • Character_UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B
  • Character_UnicodeBlock.MISCELLANEOUS_SYMBOLS
  • Character_UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_ARROWS
  • Character_UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS
  • Character_UnicodeBlock.MISCELLANEOUS_TECHNICAL
  • Character_UnicodeBlock.MODIFIER_TONE_LETTERS
  • Character_UnicodeBlock.MONGOLIAN
  • Character_UnicodeBlock.MUSICAL_SYMBOLS
  • Character_UnicodeBlock.MYANMAR
  • Character_UnicodeBlock.MYANMAR_EXTENDED_A
  • Character_UnicodeBlock.NEW_TAI_LUE
  • Character_UnicodeBlock.NKO
  • Character_UnicodeBlock.NUMBER_FORMS
  • Character_UnicodeBlock.of()
  • Character_UnicodeBlock.OGHAM
  • Character_UnicodeBlock.OLD_ITALIC
  • Character_UnicodeBlock.OLD_PERSIAN
  • Character_UnicodeBlock.OLD_SOUTH_ARABIAN
  • Character_UnicodeBlock.OLD_TURKIC
  • Character_UnicodeBlock.OL_CHIKI
  • Character_UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION
  • Character_UnicodeBlock.ORIYA
  • Character_UnicodeBlock.OSMANYA
  • Character_UnicodeBlock.PHAGS_PA
  • Character_UnicodeBlock.PHAISTOS_DISC
  • Character_UnicodeBlock.PHOENICIAN
  • Character_UnicodeBlock.PHONETIC_EXTENSIONS
  • Character_UnicodeBlock.PHONETIC_EXTENSIONS_SUPPLEMENT
  • Character_UnicodeBlock.PLAYING_CARDS
  • Character_UnicodeBlock.PRIVATE_USE_AREA
  • Character_UnicodeBlock.REJANG
  • Character_UnicodeBlock.RUMI_NUMERAL_SYMBOLS
  • Character_UnicodeBlock.RUNIC
  • Character_UnicodeBlock.SAMARITAN
  • Character_UnicodeBlock.SAURASHTRA
  • Character_UnicodeBlock.SHAVIAN
  • Character_UnicodeBlock.SINHALA
  • Character_UnicodeBlock.SMALL_FORM_VARIANTS
  • Character_UnicodeBlock.SPACING_MODIFIER_LETTERS
  • Character_UnicodeBlock.SPECIALS
  • Character_UnicodeBlock.SUNDANESE
  • Character_UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS
  • Character_UnicodeBlock.SUPPLEMENTAL_ARROWS_A
  • Character_UnicodeBlock.SUPPLEMENTAL_ARROWS_B
  • Character_UnicodeBlock.SUPPLEMENTAL_MATHEMATICAL_OPERATORS
  • Character_UnicodeBlock.SUPPLEMENTAL_PUNCTUATION
  • Character_UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_A
  • Character_UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_B
  • Character_UnicodeBlock.SURROGATES_AREA
  • Character_UnicodeBlock.SYLOTI_NAGRI
  • Character_UnicodeBlock.SYRIAC
  • Character_UnicodeBlock.TAGALOG
  • Character_UnicodeBlock.TAGBANWA
  • Character_UnicodeBlock.TAGS
  • Character_UnicodeBlock.TAI_LE
  • Character_UnicodeBlock.TAI_THAM
  • Character_UnicodeBlock.TAI_VIET
  • Character_UnicodeBlock.TAI_XUAN_JING_SYMBOLS
  • Character_UnicodeBlock.TAMIL
  • Character_UnicodeBlock.TELUGU
  • Character_UnicodeBlock.THAANA
  • Character_UnicodeBlock.THAI
  • Character_UnicodeBlock.TIBETAN
  • Character_UnicodeBlock.TIFINAGH
  • Character_UnicodeBlock.TRANSPORT_AND_MAP_SYMBOLS
  • Character_UnicodeBlock.UGARITIC
  • Character_UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS
  • Character_UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED
  • Character_UnicodeBlock.VAI
  • Character_UnicodeBlock.VARIATION_SELECTORS
  • Character_UnicodeBlock.VARIATION_SELECTORS_SUPPLEMENT
  • Character_UnicodeBlock.VEDIC_EXTENSIONS
  • Character_UnicodeBlock.VERTICAL_FORMS
  • Character_UnicodeBlock.YIJING_HEXAGRAM_SYMBOLS
  • Character_UnicodeBlock.YI_RADICALS
  • Character_UnicodeBlock.YI_SYLLABLES
  • Character_UnicodeScript
  • Character_UnicodeScript.ARABIC
  • Character_UnicodeScript.ARMENIAN
  • Character_UnicodeScript.AVESTAN
  • Character_UnicodeScript.BALINESE
  • Character_UnicodeScript.BAMUM
  • Character_UnicodeScript.BATAK
  • Character_UnicodeScript.BENGALI
  • Character_UnicodeScript.BOPOMOFO
  • Character_UnicodeScript.BRAHMI
  • Character_UnicodeScript.BRAILLE
  • Character_UnicodeScript.BUGINESE
  • Character_UnicodeScript.BUHID
  • Character_UnicodeScript.CANADIAN_ABORIGINAL
  • Character_UnicodeScript.CARIAN
  • Character_UnicodeScript.CHAM
  • Character_UnicodeScript.CHEROKEE
  • Character_UnicodeScript.COMMON
  • Character_UnicodeScript.COPTIC
  • Character_UnicodeScript.CUNEIFORM
  • Character_UnicodeScript.CYPRIOT
  • Character_UnicodeScript.CYRILLIC
  • Character_UnicodeScript.DESERET
  • Character_UnicodeScript.DEVANAGARI
  • Character_UnicodeScript.EGYPTIAN_HIEROGLYPHS
  • Character_UnicodeScript.ETHIOPIC
  • Character_UnicodeScript.GEORGIAN
  • Character_UnicodeScript.GLAGOLITIC
  • Character_UnicodeScript.GOTHIC
  • Character_UnicodeScript.GREEK
  • Character_UnicodeScript.GUJARATI
  • Character_UnicodeScript.GURMUKHI
  • Character_UnicodeScript.HAN
  • Character_UnicodeScript.HANGUL
  • Character_UnicodeScript.HANUNOO
  • Character_UnicodeScript.HEBREW
  • Character_UnicodeScript.HIRAGANA
  • Character_UnicodeScript.IMPERIAL_ARAMAIC
  • Character_UnicodeScript.INHERITED
  • Character_UnicodeScript.INSCRIPTIONAL_PAHLAVI
  • Character_UnicodeScript.INSCRIPTIONAL_PARTHIAN
  • Character_UnicodeScript.JAVANESE
  • Character_UnicodeScript.KAITHI
  • Character_UnicodeScript.KANNADA
  • Character_UnicodeScript.KATAKANA
  • Character_UnicodeScript.KAYAH_LI
  • Character_UnicodeScript.KHAROSHTHI
  • Character_UnicodeScript.KHMER
  • Character_UnicodeScript.LAO
  • Character_UnicodeScript.LATIN
  • Character_UnicodeScript.LEPCHA
  • Character_UnicodeScript.LIMBU
  • Character_UnicodeScript.LINEAR_B
  • Character_UnicodeScript.LISU
  • Character_UnicodeScript.LYCIAN
  • Character_UnicodeScript.LYDIAN
  • Character_UnicodeScript.MALAYALAM
  • Character_UnicodeScript.MANDAIC
  • Character_UnicodeScript.MEETEI_MAYEK
  • Character_UnicodeScript.MONGOLIAN
  • Character_UnicodeScript.MYANMAR
  • Character_UnicodeScript.NEW_TAI_LUE
  • Character_UnicodeScript.NKO
  • Character_UnicodeScript.OGHAM
  • Character_UnicodeScript.OLD_ITALIC
  • Character_UnicodeScript.OLD_PERSIAN
  • Character_UnicodeScript.OLD_SOUTH_ARABIAN
  • Character_UnicodeScript.OLD_TURKIC
  • Character_UnicodeScript.OL_CHIKI
  • Character_UnicodeScript.ORIYA
  • Character_UnicodeScript.OSMANYA
  • Character_UnicodeScript.PHAGS_PA
  • Character_UnicodeScript.PHOENICIAN
  • Character_UnicodeScript.REJANG
  • Character_UnicodeScript.RUNIC
  • Character_UnicodeScript.SAMARITAN
  • Character_UnicodeScript.SAURASHTRA
  • Character_UnicodeScript.SHAVIAN
  • Character_UnicodeScript.SINHALA
  • Character_UnicodeScript.SUNDANESE
  • Character_UnicodeScript.SYLOTI_NAGRI
  • Character_UnicodeScript.SYRIAC
  • Character_UnicodeScript.TAGALOG
  • Character_UnicodeScript.TAGBANWA
  • Character_UnicodeScript.TAI_LE
  • Character_UnicodeScript.TAI_THAM
  • Character_UnicodeScript.TAI_VIET
  • Character_UnicodeScript.TAMIL
  • Character_UnicodeScript.TELUGU
  • Character_UnicodeScript.THAANA
  • Character_UnicodeScript.THAI
  • Character_UnicodeScript.TIBETAN
  • Character_UnicodeScript.TIFINAGH
  • Character_UnicodeScript.UGARITIC
  • Character_UnicodeScript.UNKNOWN
  • Character_UnicodeScript.VAI
  • Character_UnicodeScript.YI
  • CharSequence
  • Class
  • Class.asSubclass()
  • Class.desiredAssertionStatus()
  • Class.forName()
  • Class.getAnnotation()
  • Class.getAnnotations()
  • Class.getCanonicalName()
  • Class.getClasses()
  • Class.getClassLoader()
  • Class.getComponentType()
  • Class.getConstructor()
  • Class.getConstructors()
  • Class.getDeclaredAnnotations()
  • Class.getDeclaredClasses()
  • Class.getDeclaredConstructor()
  • Class.getDeclaredConstructors()
  • Class.getDeclaredField()
  • Class.getDeclaredFields()
  • Class.getDeclaredMethod()
  • Class.getDeclaredMethods()
  • Class.getDeclaringClass()
  • Class.getEnclosingClass()
  • Class.getEnclosingConstructor()
  • Class.getEnclosingMethod()
  • Class.getEnumConstants()
  • Class.getField()
  • Class.getFields()
  • Class.getGenericInterfaces()
  • Class.getGenericSuperclass()
  • Class.getInterfaces()
  • Class.getMethod()
  • Class.getMethods()
  • Class.getModifiers()
  • Class.getName()
  • Class.getPackage()
  • Class.getProtectionDomain()
  • Class.getResource()
  • Class.getResourceAsStream()
  • Class.getSigners()
  • Class.getSimpleName()
  • Class.getSuperclass()
  • Class.getTypeParameters()
  • Class.isAnnotation()
  • Class.isAnnotationPresent()
  • Class.isAnonymousClass()
  • Class.isArray()
  • Class.isAssignableFrom()
  • Class.isEnum()
  • Class.isInstance()
  • Class.isInterface()
  • Class.isLocalClass()
  • Class.isMemberClass()
  • Class.isPrimitive()
  • Class.isSynthetic()
  • Class.newInstance()
  • Class.toString()
  • Class._cast()
  • ClassFormatError
  • ClassLoader
  • ClassLoader.clearAssertionStatus()
  • ClassLoader.getParent()
  • ClassLoader.getResource()
  • ClassLoader.getResourceAsStream()
  • ClassLoader.getResources()
  • ClassLoader.getSystemClassLoader()
  • ClassLoader.getSystemResource()
  • ClassLoader.getSystemResourceAsStream()
  • ClassLoader.getSystemResources()
  • ClassLoader.setClassAssertionStatus()
  • ClassLoader.setDefaultAssertionStatus()
  • ClassLoader.setPackageAssertionStatus()
  • ClassLoader_NativeLibrary
  • ClassLoader_ParallelLoaders
  • ClassNotFoundException
  • ClassNotFoundException.getException()
  • Class_EnclosingMethodInfo
  • Class_MethodArray
  • Cloneable
  • CloneNotSupportedException
  • Comparable
  • Comparable.compareTo()
  • Double
  • Double.fromFloat()
  • Double.toFloat()
  • DoubleClass
  • DoubleClass.compare()
  • DoubleClass.compareTo()
  • DoubleClass.doubleToLongBits()
  • DoubleClass.doubleToRawLongBits()
  • DoubleClass.equals()
  • DoubleClass.hashCode()
  • DoubleClass.isInfinite()
  • DoubleClass.isNaN()
  • DoubleClass.longBitsToDouble()
  • DoubleClass.MAX_EXPONENT
  • DoubleClass.MAX_VALUE
  • DoubleClass.MIN_EXPONENT
  • DoubleClass.MIN_NORMAL
  • DoubleClass.MIN_VALUE
  • DoubleClass.NaN
  • DoubleClass.NEGATIVE_INFINITY
  • DoubleClass.parseDouble()
  • DoubleClass.POSITIVE_INFINITY
  • DoubleClass.SIZE
  • DoubleClass.toHexString()
  • DoubleClass.toString()
  • DoubleClass.TYPE
  • DoubleClass.valueOf()
  • DoubleClass._isInfinite()
  • DoubleClass._isNaN()
  • DoubleClass._toString()
  • Enum
  • Enum.compareTo()
  • Enum.equals()
  • Enum.getDeclaringClass()
  • Enum.hashCode()
  • Enum.name()
  • Enum.ordinal()
  • Enum.toString()
  • Enum.valueOf()
  • Error
  • Exception
  • Float
  • Float.fromFloat()
  • Float.toFloat()
  • FloatClass
  • FloatClass.compare()
  • FloatClass.compareTo()
  • FloatClass.equals()
  • FloatClass.floatToIntBits()
  • FloatClass.floatToRawIntBits()
  • FloatClass.hashCode()
  • FloatClass.intBitsToFloat()
  • FloatClass.isInfinite()
  • FloatClass.isNaN()
  • FloatClass.MAX_EXPONENT
  • FloatClass.MAX_VALUE
  • FloatClass.MIN_EXPONENT
  • FloatClass.MIN_NORMAL
  • FloatClass.MIN_VALUE
  • FloatClass.NaN
  • FloatClass.NEGATIVE_INFINITY
  • FloatClass.parseFloat()
  • FloatClass.POSITIVE_INFINITY
  • FloatClass.SIZE
  • FloatClass.toHexString()
  • FloatClass.toString()
  • FloatClass.TYPE
  • FloatClass.valueOf()
  • FloatClass._isInfinite()
  • FloatClass._isNaN()
  • FloatClass._toString()
  • IllegalAccessException
  • IllegalArgumentException
  • InstantiationException
  • Integer
  • Integer.fromInt()
  • Integer.toInt()
  • IntegerClass
  • IntegerClass.bitCount()
  • IntegerClass.compare()
  • IntegerClass.compareTo()
  • IntegerClass.decode()
  • IntegerClass.equals()
  • IntegerClass.getInteger()
  • IntegerClass.hashCode()
  • IntegerClass.highestOneBit()
  • IntegerClass.lowestOneBit()
  • IntegerClass.MAX_VALUE
  • IntegerClass.MIN_VALUE
  • IntegerClass.numberOfLeadingZeros()
  • IntegerClass.numberOfTrailingZeros()
  • IntegerClass.parseInt()
  • IntegerClass.reverse()
  • IntegerClass.reverseBytes()
  • IntegerClass.rotateLeft()
  • IntegerClass.rotateRight()
  • IntegerClass.signum()
  • IntegerClass.SIZE
  • IntegerClass.toBinaryString()
  • IntegerClass.toHexString()
  • IntegerClass.toOctalString()
  • IntegerClass.toString()
  • IntegerClass.TYPE
  • IntegerClass.valueOf()
  • IntegerClass._toString()
  • Integer_IntegerCache
  • InterruptedException
  • Iterable
  • Iterable.iterator()
  • LinkageError
  • Long
  • Long.fromLong()
  • Long.toLong()
  • LongClass
  • LongClass.bitCount()
  • LongClass.compare()
  • LongClass.compareTo()
  • LongClass.decode()
  • LongClass.equals()
  • LongClass.getLong()
  • LongClass.hashCode()
  • LongClass.highestOneBit()
  • LongClass.lowestOneBit()
  • LongClass.MAX_VALUE
  • LongClass.MIN_VALUE
  • LongClass.numberOfLeadingZeros()
  • LongClass.numberOfTrailingZeros()
  • LongClass.parseLong()
  • LongClass.reverse()
  • LongClass.reverseBytes()
  • LongClass.rotateLeft()
  • LongClass.rotateRight()
  • LongClass.signum()
  • LongClass.SIZE
  • LongClass.toBinaryString()
  • LongClass.toHexString()
  • LongClass.toOctalString()
  • LongClass.toString()
  • LongClass.TYPE
  • LongClass.valueOf()
  • LongClass._toString()
  • Long_LongCache
  • Math
  • Math.abs()
  • Math.acos()
  • Math.asin()
  • Math.atan()
  • Math.atan2()
  • Math.cbrt()
  • Math.ceil()
  • Math.copySign()
  • Math.cos()
  • Math.cosh()
  • Math.E
  • Math.exp()
  • Math.expm1()
  • Math.floor()
  • Math.getExponent()
  • Math.hypot()
  • Math.IEEEremainder()
  • Math.log()
  • Math.log10()
  • Math.log1p()
  • Math.max()
  • Math.min()
  • Math.nextAfter()
  • Math.nextUp()
  • Math.PI
  • Math.pow()
  • Math.random()
  • Math.rint()
  • Math.round()
  • Math.scalb()
  • Math.signum()
  • Math.sin()
  • Math.sinh()
  • Math.sqrt()
  • Math.tan()
  • Math.tanh()
  • Math.toDegrees()
  • Math.toRadians()
  • Math.ulp()
  • NoSuchFieldException
  • NoSuchMethodException
  • Number
  • Number.byteValue()
  • Number.doubleValue()
  • Number.floatValue()
  • Number.intValue()
  • Number.longValue()
  • Number.shortValue()
  • NumberFormatException
  • Object
  • Object.equals()
  • Object.getClass()
  • Object.hashCode()
  • Object.notify()
  • Object.notifyAll()
  • Object.toString()
  • Object.wait()
  • Package
  • Package.getAnnotation()
  • Package.getAnnotations()
  • Package.getDeclaredAnnotations()
  • Package.getImplementationTitle()
  • Package.getImplementationVendor()
  • Package.getImplementationVersion()
  • Package.getName()
  • Package.getPackage()
  • Package.getPackages()
  • Package.getSpecificationTitle()
  • Package.getSpecificationVendor()
  • Package.getSpecificationVersion()
  • Package.hashCode()
  • Package.isAnnotationPresent()
  • Package.isCompatibleWith()
  • Package.isSealed()
  • Package.toString()
  • Process
  • Process.destroy()
  • Process.exitValue()
  • Process.getErrorStream()
  • Process.getInputStream()
  • Process.getOutputStream()
  • Process.waitFor()
  • ProcessBuilder
  • ProcessBuilder.command()
  • ProcessBuilder.directory()
  • ProcessBuilder.environment()
  • ProcessBuilder.inheritIO()
  • ProcessBuilder.redirectError()
  • ProcessBuilder.redirectErrorStream()
  • ProcessBuilder.redirectInput()
  • ProcessBuilder.redirectOutput()
  • ProcessBuilder.start()
  • ProcessBuilder_1
  • ProcessBuilder_NullInputStream
  • ProcessBuilder_NullOutputStream
  • ProcessBuilder_Redirect
  • ProcessBuilder_Redirect.appendTo()
  • ProcessBuilder_Redirect.equals()
  • ProcessBuilder_Redirect.file()
  • ProcessBuilder_Redirect.from()
  • ProcessBuilder_Redirect.hashCode()
  • ProcessBuilder_Redirect.INHERIT
  • ProcessBuilder_Redirect.PIPE
  • ProcessBuilder_Redirect.to()
  • ProcessBuilder_Redirect.type()
  • ProcessBuilder_Redirect_Type
  • ProcessBuilder_Redirect_Type.APPEND
  • ProcessBuilder_Redirect_Type.INHERIT
  • ProcessBuilder_Redirect_Type.PIPE
  • ProcessBuilder_Redirect_Type.READ
  • ProcessBuilder_Redirect_Type.WRITE
  • Readable
  • Readable.read()
  • ReflectiveOperationException
  • Runnable
  • Runnable.run()
  • Runtime
  • Runtime.addShutdownHook()
  • Runtime.availableProcessors()
  • Runtime.exec()
  • Runtime.exit()
  • Runtime.freeMemory()
  • Runtime.gc()
  • Runtime.getLocalizedInputStream()
  • Runtime.getLocalizedOutputStream()
  • Runtime.getRuntime()
  • Runtime.halt()
  • Runtime.load()
  • Runtime.loadLibrary()
  • Runtime.maxMemory()
  • Runtime.removeShutdownHook()
  • Runtime.runFinalization()
  • Runtime.runFinalizersOnExit()
  • Runtime.totalMemory()
  • Runtime.traceInstructions()
  • Runtime.traceMethodCalls()
  • RuntimeException
  • SecurityException
  • SecurityManager
  • SecurityManager.checkAccept()
  • SecurityManager.checkAccess()
  • SecurityManager.checkAwtEventQueueAccess()
  • SecurityManager.checkConnect()
  • SecurityManager.checkCreateClassLoader()
  • SecurityManager.checkDelete()
  • SecurityManager.checkExec()
  • SecurityManager.checkExit()
  • SecurityManager.checkLink()
  • SecurityManager.checkListen()
  • SecurityManager.checkMemberAccess()
  • SecurityManager.checkMulticast()
  • SecurityManager.checkPackageAccess()
  • SecurityManager.checkPackageDefinition()
  • SecurityManager.checkPermission()
  • SecurityManager.checkPrintJobAccess()
  • SecurityManager.checkPropertiesAccess()
  • SecurityManager.checkPropertyAccess()
  • SecurityManager.checkRead()
  • SecurityManager.checkSecurityAccess()
  • SecurityManager.checkSetFactory()
  • SecurityManager.checkSystemClipboardAccess()
  • SecurityManager.checkTopLevelWindow()
  • SecurityManager.checkWrite()
  • SecurityManager.getInCheck()
  • SecurityManager.getSecurityContext()
  • SecurityManager.getThreadGroup()
  • Short
  • Short.fromShort()
  • Short.toShort()
  • ShortClass
  • ShortClass.compare()
  • ShortClass.compareTo()
  • ShortClass.decode()
  • ShortClass.equals()
  • ShortClass.hashCode()
  • ShortClass.MAX_VALUE
  • ShortClass.MIN_VALUE
  • ShortClass.parseShort()
  • ShortClass.reverseBytes()
  • ShortClass.SIZE
  • ShortClass.toString()
  • ShortClass.TYPE
  • ShortClass.valueOf()
  • ShortClass._toString()
  • Short_ShortCache
  • StackTraceElement
  • StackTraceElement.equals()
  • StackTraceElement.getClassName()
  • StackTraceElement.getFileName()
  • StackTraceElement.getLineNumber()
  • StackTraceElement.getMethodName()
  • StackTraceElement.hashCode()
  • StackTraceElement.isNativeMethod()
  • StackTraceElement.toString()
  • StringBuffer
  • StringBuilder
  • System
  • System.arraycopy()
  • System.clearProperty()
  • System.console()
  • System.currentTimeMillis()
  • System.err
  • System.exit()
  • System.gc()
  • System.getenv()
  • System.getProperties()
  • System.getProperty()
  • System.getSecurityManager()
  • System.identityHashCode()
  • System.inheritedChannel()
  • System.lineSeparator()
  • System.load()
  • System.loadLibrary()
  • System.mapLibraryName()
  • System.nanoTime()
  • System.out
  • System.runFinalization()
  • System.runFinalizersOnExit()
  • System.setErr()
  • System.setIn()
  • System.setOut()
  • System.setProperties()
  • System.setProperty()
  • System.setSecurityManager()
  • System._in
  • Thread
  • Thread.activeCount()
  • Thread.checkAccess()
  • Thread.countStackFrames()
  • Thread.currentThread()
  • Thread.destroy()
  • Thread.dumpStack()
  • Thread.enumerate()
  • Thread.getAllStackTraces()
  • Thread.getContextClassLoader()
  • Thread.getDefaultUncaughtExceptionHandler()
  • Thread.getId()
  • Thread.getName()
  • Thread.getPriority()
  • Thread.getStackTrace()
  • Thread.getState()
  • Thread.getThreadGroup()
  • Thread.getUncaughtExceptionHandler()
  • Thread.holdsLock()
  • Thread.interrupt()
  • Thread.interrupted()
  • Thread.isAlive()
  • Thread.isDaemon()
  • Thread.isInterrupted()
  • Thread.join()
  • Thread.MAX_PRIORITY
  • Thread.MIN_PRIORITY
  • Thread.NORM_PRIORITY
  • Thread.resume()
  • Thread.run()
  • Thread.setContextClassLoader()
  • Thread.setDaemon()
  • Thread.setDefaultUncaughtExceptionHandler()
  • Thread.setName()
  • Thread.setPriority()
  • Thread.setUncaughtExceptionHandler()
  • Thread.sleep()
  • Thread.start()
  • Thread.stop()
  • Thread.suspend()
  • Thread.toString()
  • Thread.yield()
  • ThreadGroup
  • ThreadGroup.activeCount()
  • ThreadGroup.activeGroupCount()
  • ThreadGroup.allowThreadSuspension()
  • ThreadGroup.checkAccess()
  • ThreadGroup.destroy()
  • ThreadGroup.enumerate()
  • ThreadGroup.getMaxPriority()
  • ThreadGroup.getName()
  • ThreadGroup.getParent()
  • ThreadGroup.interrupt()
  • ThreadGroup.isDaemon()
  • ThreadGroup.isDestroyed()
  • ThreadGroup.list()
  • ThreadGroup.parentOf()
  • ThreadGroup.resume()
  • ThreadGroup.setDaemon()
  • ThreadGroup.setMaxPriority()
  • ThreadGroup.stop()
  • ThreadGroup.suspend()
  • ThreadGroup.toString()
  • ThreadGroup.uncaughtException()
  • ThreadLocal
  • ThreadLocal.get()
  • ThreadLocal.remove()
  • ThreadLocal.set()
  • ThreadLocal_1
  • ThreadLocal_ThreadLocalMap
  • ThreadLocal_ThreadLocalMap_Entry
  • Thread_Caches
  • Thread_State
  • Thread_State.BLOCKED
  • Thread_State.NEW
  • Thread_State.RUNNABLE
  • Thread_State.TERMINATED
  • Thread_State.TIMED_WAITING
  • Thread_State.WAITING
  • Thread_UncaughtExceptionHandler
  • Thread_UncaughtExceptionHandler.uncaughtException()
  • Thread_WeakClassKey
  • Thread_WeakClassKey.equals()
  • Thread_WeakClassKey.hashCode()
  • Throwable
  • Throwable.addSuppressed()
  • Throwable.fillInStackTrace()
  • Throwable.getCause()
  • Throwable.getLocalizedMessage()
  • Throwable.getMessage()
  • Throwable.getStackTrace()
  • Throwable.getSuppressed()
  • Throwable.initCause()
  • Throwable.printStackTrace()
  • Throwable.setStackTrace()
  • Throwable.toString()
  • Throwable_1
  • Throwable_PrintStreamOrWriter
  • Throwable_SentinelHolder
  • Throwable_SentinelHolder.STACK_TRACE_ELEMENT_SENTINEL
  • Throwable_SentinelHolder.STACK_TRACE_SENTINEL
  • Throwable_WrappedPrintStream
  • Throwable_WrappedPrintWriter

    • java.lang.annotation

  • annotation.Annotation
  • annotation.Annotation.annotationType()

    • java.sql

  • Array
  • Array.free()
  • Array.getArray()
  • Array.getBaseType()
  • Array.getBaseTypeName()
  • Array.getResultSet()
  • Blob
  • Blob.free()
  • Blob.getBinaryStream()
  • Blob.getBytes()
  • Blob.length()
  • Blob.position()
  • Blob.setBinaryStream()
  • Blob.setBytes()
  • Blob.truncate()
  • CallableStatement
  • CallableStatement.addBatch()
  • CallableStatement.cancel()
  • CallableStatement.clearBatch()
  • CallableStatement.clearParameters()
  • CallableStatement.clearWarnings()
  • CallableStatement.close()
  • CallableStatement.closeOnCompletion()
  • CallableStatement.execute()
  • CallableStatement.executeBatch()
  • CallableStatement.executeQuery()
  • CallableStatement.executeUpdate()
  • CallableStatement.getArray()
  • CallableStatement.getBigDecimal()
  • CallableStatement.getBlob()
  • CallableStatement.getBoolean()
  • CallableStatement.getByte()
  • CallableStatement.getBytes()
  • CallableStatement.getCharacterStream()
  • CallableStatement.getClob()
  • CallableStatement.getConnection()
  • CallableStatement.getDate()
  • CallableStatement.getDouble()
  • CallableStatement.getFetchDirection()
  • CallableStatement.getFetchSize()
  • CallableStatement.getFloat()
  • CallableStatement.getGeneratedKeys()
  • CallableStatement.getInt()
  • CallableStatement.getLong()
  • CallableStatement.getMaxFieldSize()
  • CallableStatement.getMaxRows()
  • CallableStatement.getMetaData()
  • CallableStatement.getMoreResults()
  • CallableStatement.getNCharacterStream()
  • CallableStatement.getNClob()
  • CallableStatement.getNString()
  • CallableStatement.getObject()
  • CallableStatement.getParameterMetaData()
  • CallableStatement.getQueryTimeout()
  • CallableStatement.getRef()
  • CallableStatement.getResultSet()
  • CallableStatement.getResultSetConcurrency()
  • CallableStatement.getResultSetHoldability()
  • CallableStatement.getResultSetType()
  • CallableStatement.getRowId()
  • CallableStatement.getShort()
  • CallableStatement.getSQLXML()
  • CallableStatement.getString()
  • CallableStatement.getTime()
  • CallableStatement.getTimestamp()
  • CallableStatement.getUpdateCount()
  • CallableStatement.getURL()
  • CallableStatement.getWarnings()
  • CallableStatement.isClosed()
  • CallableStatement.isCloseOnCompletion()
  • CallableStatement.isPoolable()
  • CallableStatement.isWrapperFor()
  • CallableStatement.registerOutParameter()
  • CallableStatement.setArray()
  • CallableStatement.setAsciiStream()
  • CallableStatement.setBigDecimal()
  • CallableStatement.setBinaryStream()
  • CallableStatement.setBlob()
  • CallableStatement.setBoolean()
  • CallableStatement.setByte()
  • CallableStatement.setBytes()
  • CallableStatement.setCharacterStream()
  • CallableStatement.setClob()
  • CallableStatement.setCursorName()
  • CallableStatement.setDate()
  • CallableStatement.setDouble()
  • CallableStatement.setEscapeProcessing()
  • CallableStatement.setFetchDirection()
  • CallableStatement.setFetchSize()
  • CallableStatement.setFloat()
  • CallableStatement.setInt()
  • CallableStatement.setLong()
  • CallableStatement.setMaxFieldSize()
  • CallableStatement.setMaxRows()
  • CallableStatement.setNCharacterStream()
  • CallableStatement.setNClob()
  • CallableStatement.setNString()
  • CallableStatement.setNull()
  • CallableStatement.setObject()
  • CallableStatement.setPoolable()
  • CallableStatement.setQueryTimeout()
  • CallableStatement.setRef()
  • CallableStatement.setRowId()
  • CallableStatement.setShort()
  • CallableStatement.setSQLXML()
  • CallableStatement.setString()
  • CallableStatement.setTime()
  • CallableStatement.setTimestamp()
  • CallableStatement.setUnicodeStream()
  • CallableStatement.setURL()
  • CallableStatement.unwrap()
  • CallableStatement.wasNull()
  • ClientInfoStatus
  • ClientInfoStatus.REASON_UNKNOWN
  • ClientInfoStatus.REASON_UNKNOWN_PROPERTY
  • ClientInfoStatus.REASON_VALUE_INVALID
  • ClientInfoStatus.REASON_VALUE_TRUNCATED
  • Clob
  • Clob.free()
  • Clob.getAsciiStream()
  • Clob.getCharacterStream()
  • Clob.getSubString()
  • Clob.length()
  • Clob.position()
  • Clob.setAsciiStream()
  • Clob.setCharacterStream()
  • Clob.setString()
  • Clob.truncate()
  • Connection
  • Connection.abort()
  • Connection.clearWarnings()
  • Connection.close()
  • Connection.commit()
  • Connection.createArrayOf()
  • Connection.createBlob()
  • Connection.createClob()
  • Connection.createNClob()
  • Connection.createSQLXML()
  • Connection.createStatement()
  • Connection.createStruct()
  • Connection.getAutoCommit()
  • Connection.getCatalog()
  • Connection.getClientInfo()
  • Connection.getHoldability()
  • Connection.getMetaData()
  • Connection.getNetworkTimeout()
  • Connection.getSchema()
  • Connection.getTransactionIsolation()
  • Connection.getTypeMap()
  • Connection.getWarnings()
  • Connection.isClosed()
  • Connection.isReadOnly()
  • Connection.isValid()
  • Connection.isWrapperFor()
  • Connection.nativeSQL()
  • Connection.prepareCall()
  • Connection.prepareStatement()
  • Connection.releaseSavepoint()
  • Connection.rollback()
  • Connection.setAutoCommit()
  • Connection.setCatalog()
  • Connection.setClientInfo()
  • Connection.setHoldability()
  • Connection.setNetworkTimeout()
  • Connection.setReadOnly()
  • Connection.setSavepoint()
  • Connection.setSchema()
  • Connection.setTransactionIsolation()
  • Connection.setTypeMap()
  • Connection.unwrap()
  • Connection_Statics
  • Connection_Statics.TRANSACTION_NONE
  • Connection_Statics.TRANSACTION_READ_COMMITTED
  • Connection_Statics.TRANSACTION_READ_UNCOMMITTED
  • Connection_Statics.TRANSACTION_REPEATABLE_READ
  • Connection_Statics.TRANSACTION_SERIALIZABLE
  • DatabaseMetaData
  • DatabaseMetaData.allProceduresAreCallable()
  • DatabaseMetaData.allTablesAreSelectable()
  • DatabaseMetaData.autoCommitFailureClosesAllResultSets()
  • DatabaseMetaData.dataDefinitionCausesTransactionCommit()
  • DatabaseMetaData.dataDefinitionIgnoredInTransactions()
  • DatabaseMetaData.deletesAreDetected()
  • DatabaseMetaData.doesMaxRowSizeIncludeBlobs()
  • DatabaseMetaData.generatedKeyAlwaysReturned()
  • DatabaseMetaData.getAttributes()
  • DatabaseMetaData.getBestRowIdentifier()
  • DatabaseMetaData.getCatalogs()
  • DatabaseMetaData.getCatalogSeparator()
  • DatabaseMetaData.getCatalogTerm()
  • DatabaseMetaData.getClientInfoProperties()
  • DatabaseMetaData.getColumnPrivileges()
  • DatabaseMetaData.getColumns()
  • DatabaseMetaData.getConnection()
  • DatabaseMetaData.getCrossReference()
  • DatabaseMetaData.getDatabaseMajorVersion()
  • DatabaseMetaData.getDatabaseMinorVersion()
  • DatabaseMetaData.getDatabaseProductName()
  • DatabaseMetaData.getDatabaseProductVersion()
  • DatabaseMetaData.getDefaultTransactionIsolation()
  • DatabaseMetaData.getDriverMajorVersion()
  • DatabaseMetaData.getDriverMinorVersion()
  • DatabaseMetaData.getDriverName()
  • DatabaseMetaData.getDriverVersion()
  • DatabaseMetaData.getExportedKeys()
  • DatabaseMetaData.getExtraNameCharacters()
  • DatabaseMetaData.getFunctionColumns()
  • DatabaseMetaData.getFunctions()
  • DatabaseMetaData.getIdentifierQuoteString()
  • DatabaseMetaData.getImportedKeys()
  • DatabaseMetaData.getIndexInfo()
  • DatabaseMetaData.getJDBCMajorVersion()
  • DatabaseMetaData.getJDBCMinorVersion()
  • DatabaseMetaData.getMaxBinaryLiteralLength()
  • DatabaseMetaData.getMaxCatalogNameLength()
  • DatabaseMetaData.getMaxCharLiteralLength()
  • DatabaseMetaData.getMaxColumnNameLength()
  • DatabaseMetaData.getMaxColumnsInGroupBy()
  • DatabaseMetaData.getMaxColumnsInIndex()
  • DatabaseMetaData.getMaxColumnsInOrderBy()
  • DatabaseMetaData.getMaxColumnsInSelect()
  • DatabaseMetaData.getMaxColumnsInTable()
  • DatabaseMetaData.getMaxConnections()
  • DatabaseMetaData.getMaxCursorNameLength()
  • DatabaseMetaData.getMaxIndexLength()
  • DatabaseMetaData.getMaxProcedureNameLength()
  • DatabaseMetaData.getMaxRowSize()
  • DatabaseMetaData.getMaxSchemaNameLength()
  • DatabaseMetaData.getMaxStatementLength()
  • DatabaseMetaData.getMaxStatements()
  • DatabaseMetaData.getMaxTableNameLength()
  • DatabaseMetaData.getMaxTablesInSelect()
  • DatabaseMetaData.getMaxUserNameLength()
  • DatabaseMetaData.getNumericFunctions()
  • DatabaseMetaData.getPrimaryKeys()
  • DatabaseMetaData.getProcedureColumns()
  • DatabaseMetaData.getProcedures()
  • DatabaseMetaData.getProcedureTerm()
  • DatabaseMetaData.getPseudoColumns()
  • DatabaseMetaData.getResultSetHoldability()
  • DatabaseMetaData.getRowIdLifetime()
  • DatabaseMetaData.getSchemas()
  • DatabaseMetaData.getSchemaTerm()
  • DatabaseMetaData.getSearchStringEscape()
  • DatabaseMetaData.getSQLKeywords()
  • DatabaseMetaData.getSQLStateType()
  • DatabaseMetaData.getStringFunctions()
  • DatabaseMetaData.getSuperTables()
  • DatabaseMetaData.getSuperTypes()
  • DatabaseMetaData.getSystemFunctions()
  • DatabaseMetaData.getTablePrivileges()
  • DatabaseMetaData.getTables()
  • DatabaseMetaData.getTableTypes()
  • DatabaseMetaData.getTimeDateFunctions()
  • DatabaseMetaData.getTypeInfo()
  • DatabaseMetaData.getUDTs()
  • DatabaseMetaData.getURL()
  • DatabaseMetaData.getUserName()
  • DatabaseMetaData.getVersionColumns()
  • DatabaseMetaData.insertsAreDetected()
  • DatabaseMetaData.isCatalogAtStart()
  • DatabaseMetaData.isReadOnly()
  • DatabaseMetaData.isWrapperFor()
  • DatabaseMetaData.locatorsUpdateCopy()
  • DatabaseMetaData.nullPlusNonNullIsNull()
  • DatabaseMetaData.nullsAreSortedAtEnd()
  • DatabaseMetaData.nullsAreSortedAtStart()
  • DatabaseMetaData.nullsAreSortedHigh()
  • DatabaseMetaData.nullsAreSortedLow()
  • DatabaseMetaData.othersDeletesAreVisible()
  • DatabaseMetaData.othersInsertsAreVisible()
  • DatabaseMetaData.othersUpdatesAreVisible()
  • DatabaseMetaData.ownDeletesAreVisible()
  • DatabaseMetaData.ownInsertsAreVisible()
  • DatabaseMetaData.ownUpdatesAreVisible()
  • DatabaseMetaData.storesLowerCaseIdentifiers()
  • DatabaseMetaData.storesLowerCaseQuotedIdentifiers()
  • DatabaseMetaData.storesMixedCaseIdentifiers()
  • DatabaseMetaData.storesMixedCaseQuotedIdentifiers()
  • DatabaseMetaData.storesUpperCaseIdentifiers()
  • DatabaseMetaData.storesUpperCaseQuotedIdentifiers()
  • DatabaseMetaData.supportsAlterTableWithAddColumn()
  • DatabaseMetaData.supportsAlterTableWithDropColumn()
  • DatabaseMetaData.supportsANSI92EntryLevelSQL()
  • DatabaseMetaData.supportsANSI92FullSQL()
  • DatabaseMetaData.supportsANSI92IntermediateSQL()
  • DatabaseMetaData.supportsBatchUpdates()
  • DatabaseMetaData.supportsCatalogsInDataManipulation()
  • DatabaseMetaData.supportsCatalogsInIndexDefinitions()
  • DatabaseMetaData.supportsCatalogsInPrivilegeDefinitions()
  • DatabaseMetaData.supportsCatalogsInProcedureCalls()
  • DatabaseMetaData.supportsCatalogsInTableDefinitions()
  • DatabaseMetaData.supportsColumnAliasing()
  • DatabaseMetaData.supportsConvert()
  • DatabaseMetaData.supportsCoreSQLGrammar()
  • DatabaseMetaData.supportsCorrelatedSubqueries()
  • DatabaseMetaData.supportsDataDefinitionAndDataManipulationTransactions()
  • DatabaseMetaData.supportsDataManipulationTransactionsOnly()
  • DatabaseMetaData.supportsDifferentTableCorrelationNames()
  • DatabaseMetaData.supportsExpressionsInOrderBy()
  • DatabaseMetaData.supportsExtendedSQLGrammar()
  • DatabaseMetaData.supportsFullOuterJoins()
  • DatabaseMetaData.supportsGetGeneratedKeys()
  • DatabaseMetaData.supportsGroupBy()
  • DatabaseMetaData.supportsGroupByBeyondSelect()
  • DatabaseMetaData.supportsGroupByUnrelated()
  • DatabaseMetaData.supportsIntegrityEnhancementFacility()
  • DatabaseMetaData.supportsLikeEscapeClause()
  • DatabaseMetaData.supportsLimitedOuterJoins()
  • DatabaseMetaData.supportsMinimumSQLGrammar()
  • DatabaseMetaData.supportsMixedCaseIdentifiers()
  • DatabaseMetaData.supportsMixedCaseQuotedIdentifiers()
  • DatabaseMetaData.supportsMultipleOpenResults()
  • DatabaseMetaData.supportsMultipleResultSets()
  • DatabaseMetaData.supportsMultipleTransactions()
  • DatabaseMetaData.supportsNamedParameters()
  • DatabaseMetaData.supportsNonNullableColumns()
  • DatabaseMetaData.supportsOpenCursorsAcrossCommit()
  • DatabaseMetaData.supportsOpenCursorsAcrossRollback()
  • DatabaseMetaData.supportsOpenStatementsAcrossCommit()
  • DatabaseMetaData.supportsOpenStatementsAcrossRollback()
  • DatabaseMetaData.supportsOrderByUnrelated()
  • DatabaseMetaData.supportsOuterJoins()
  • DatabaseMetaData.supportsPositionedDelete()
  • DatabaseMetaData.supportsPositionedUpdate()
  • DatabaseMetaData.supportsResultSetConcurrency()
  • DatabaseMetaData.supportsResultSetHoldability()
  • DatabaseMetaData.supportsResultSetType()
  • DatabaseMetaData.supportsSavepoints()
  • DatabaseMetaData.supportsSchemasInDataManipulation()
  • DatabaseMetaData.supportsSchemasInIndexDefinitions()
  • DatabaseMetaData.supportsSchemasInPrivilegeDefinitions()
  • DatabaseMetaData.supportsSchemasInProcedureCalls()
  • DatabaseMetaData.supportsSchemasInTableDefinitions()
  • DatabaseMetaData.supportsSelectForUpdate()
  • DatabaseMetaData.supportsStatementPooling()
  • DatabaseMetaData.supportsStoredFunctionsUsingCallSyntax()
  • DatabaseMetaData.supportsStoredProcedures()
  • DatabaseMetaData.supportsSubqueriesInComparisons()
  • DatabaseMetaData.supportsSubqueriesInExists()
  • DatabaseMetaData.supportsSubqueriesInIns()
  • DatabaseMetaData.supportsSubqueriesInQuantifieds()
  • DatabaseMetaData.supportsTableCorrelationNames()
  • DatabaseMetaData.supportsTransactionIsolationLevel()
  • DatabaseMetaData.supportsTransactions()
  • DatabaseMetaData.supportsUnion()
  • DatabaseMetaData.supportsUnionAll()
  • DatabaseMetaData.unwrap()
  • DatabaseMetaData.updatesAreDetected()
  • DatabaseMetaData.usesLocalFilePerTable()
  • DatabaseMetaData.usesLocalFiles()
  • DatabaseMetaData_Statics
  • DatabaseMetaData_Statics.attributeNoNulls
  • DatabaseMetaData_Statics.attributeNullable
  • DatabaseMetaData_Statics.attributeNullableUnknown
  • DatabaseMetaData_Statics.bestRowNotPseudo
  • DatabaseMetaData_Statics.bestRowPseudo
  • DatabaseMetaData_Statics.bestRowSession
  • DatabaseMetaData_Statics.bestRowTemporary
  • DatabaseMetaData_Statics.bestRowTransaction
  • DatabaseMetaData_Statics.bestRowUnknown
  • DatabaseMetaData_Statics.columnNoNulls
  • DatabaseMetaData_Statics.columnNullable
  • DatabaseMetaData_Statics.columnNullableUnknown
  • DatabaseMetaData_Statics.functionColumnIn
  • DatabaseMetaData_Statics.functionColumnInOut
  • DatabaseMetaData_Statics.functionColumnOut
  • DatabaseMetaData_Statics.functionColumnResult
  • DatabaseMetaData_Statics.functionColumnUnknown
  • DatabaseMetaData_Statics.functionNoNulls
  • DatabaseMetaData_Statics.functionNoTable
  • DatabaseMetaData_Statics.functionNullable
  • DatabaseMetaData_Statics.functionNullableUnknown
  • DatabaseMetaData_Statics.functionResultUnknown
  • DatabaseMetaData_Statics.functionReturn
  • DatabaseMetaData_Statics.functionReturnsTable
  • DatabaseMetaData_Statics.importedKeyCascade
  • DatabaseMetaData_Statics.importedKeyInitiallyDeferred
  • DatabaseMetaData_Statics.importedKeyInitiallyImmediate
  • DatabaseMetaData_Statics.importedKeyNoAction
  • DatabaseMetaData_Statics.importedKeyNotDeferrable
  • DatabaseMetaData_Statics.importedKeyRestrict
  • DatabaseMetaData_Statics.importedKeySetDefault
  • DatabaseMetaData_Statics.importedKeySetNull
  • DatabaseMetaData_Statics.procedureColumnIn
  • DatabaseMetaData_Statics.procedureColumnInOut
  • DatabaseMetaData_Statics.procedureColumnOut
  • DatabaseMetaData_Statics.procedureColumnResult
  • DatabaseMetaData_Statics.procedureColumnReturn
  • DatabaseMetaData_Statics.procedureColumnUnknown
  • DatabaseMetaData_Statics.procedureNoNulls
  • DatabaseMetaData_Statics.procedureNoResult
  • DatabaseMetaData_Statics.procedureNullable
  • DatabaseMetaData_Statics.procedureNullableUnknown
  • DatabaseMetaData_Statics.procedureResultUnknown
  • DatabaseMetaData_Statics.procedureReturnsResult
  • DatabaseMetaData_Statics.sqlStateSQL
  • DatabaseMetaData_Statics.sqlStateSQL99
  • DatabaseMetaData_Statics.sqlStateXOpen
  • DatabaseMetaData_Statics.tableIndexClustered
  • DatabaseMetaData_Statics.tableIndexHashed
  • DatabaseMetaData_Statics.tableIndexOther
  • DatabaseMetaData_Statics.tableIndexStatistic
  • DatabaseMetaData_Statics.typeNoNulls
  • DatabaseMetaData_Statics.typeNullable
  • DatabaseMetaData_Statics.typeNullableUnknown
  • DatabaseMetaData_Statics.typePredBasic
  • DatabaseMetaData_Statics.typePredChar
  • DatabaseMetaData_Statics.typePredNone
  • DatabaseMetaData_Statics.typeSearchable
  • DatabaseMetaData_Statics.versionColumnNotPseudo
  • DatabaseMetaData_Statics.versionColumnPseudo
  • DatabaseMetaData_Statics.versionColumnUnknown
  • Date
  • Date.valueOf()
  • Driver
  • Driver.acceptsURL()
  • Driver.connect()
  • Driver.getMajorVersion()
  • Driver.getMinorVersion()
  • Driver.getParentLogger()
  • Driver.getPropertyInfo()
  • Driver.jdbcCompliant()
  • DriverManager
  • DriverManager.deregisterDriver()
  • DriverManager.getConnection()
  • DriverManager.getDriver()
  • DriverManager.getDrivers()
  • DriverManager.getLoginTimeout()
  • DriverManager.getLogStream()
  • DriverManager.getLogWriter()
  • DriverManager.println()
  • DriverManager.registerDriver()
  • DriverManager.setLoginTimeout()
  • DriverManager.setLogStream()
  • DriverManager.setLogWriter()
  • DriverPropertyInfo
  • DriverPropertyInfo.choices
  • DriverPropertyInfo.description
  • DriverPropertyInfo.name
  • DriverPropertyInfo.required
  • DriverPropertyInfo.value
  • NClob
  • NClob.free()
  • NClob.getAsciiStream()
  • NClob.getCharacterStream()
  • NClob.getSubString()
  • NClob.length()
  • NClob.position()
  • NClob.setAsciiStream()
  • NClob.setCharacterStream()
  • NClob.setString()
  • NClob.truncate()
  • ParameterMetaData
  • ParameterMetaData.getParameterClassName()
  • ParameterMetaData.getParameterCount()
  • ParameterMetaData.getParameterMode()
  • ParameterMetaData.getParameterType()
  • ParameterMetaData.getParameterTypeName()
  • ParameterMetaData.getPrecision()
  • ParameterMetaData.getScale()
  • ParameterMetaData.isNullable()
  • ParameterMetaData.isSigned()
  • ParameterMetaData.isWrapperFor()
  • ParameterMetaData.unwrap()
  • ParameterMetaData_Statics
  • ParameterMetaData_Statics.parameterModeIn
  • ParameterMetaData_Statics.parameterModeInOut
  • ParameterMetaData_Statics.parameterModeOut
  • ParameterMetaData_Statics.parameterModeUnknown
  • ParameterMetaData_Statics.parameterNoNulls
  • ParameterMetaData_Statics.parameterNullable
  • ParameterMetaData_Statics.parameterNullableUnknown
  • PreparedStatement
  • PreparedStatement.addBatch()
  • PreparedStatement.cancel()
  • PreparedStatement.clearBatch()
  • PreparedStatement.clearParameters()
  • PreparedStatement.clearWarnings()
  • PreparedStatement.close()
  • PreparedStatement.closeOnCompletion()
  • PreparedStatement.execute()
  • PreparedStatement.executeBatch()
  • PreparedStatement.executeQuery()
  • PreparedStatement.executeUpdate()
  • PreparedStatement.getConnection()
  • PreparedStatement.getFetchDirection()
  • PreparedStatement.getFetchSize()
  • PreparedStatement.getGeneratedKeys()
  • PreparedStatement.getMaxFieldSize()
  • PreparedStatement.getMaxRows()
  • PreparedStatement.getMetaData()
  • PreparedStatement.getMoreResults()
  • PreparedStatement.getParameterMetaData()
  • PreparedStatement.getQueryTimeout()
  • PreparedStatement.getResultSet()
  • PreparedStatement.getResultSetConcurrency()
  • PreparedStatement.getResultSetHoldability()
  • PreparedStatement.getResultSetType()
  • PreparedStatement.getUpdateCount()
  • PreparedStatement.getWarnings()
  • PreparedStatement.isClosed()
  • PreparedStatement.isCloseOnCompletion()
  • PreparedStatement.isPoolable()
  • PreparedStatement.isWrapperFor()
  • PreparedStatement.setArray()
  • PreparedStatement.setAsciiStream()
  • PreparedStatement.setBigDecimal()
  • PreparedStatement.setBinaryStream()
  • PreparedStatement.setBlob()
  • PreparedStatement.setBoolean()
  • PreparedStatement.setByte()
  • PreparedStatement.setBytes()
  • PreparedStatement.setCharacterStream()
  • PreparedStatement.setClob()
  • PreparedStatement.setCursorName()
  • PreparedStatement.setDate()
  • PreparedStatement.setDouble()
  • PreparedStatement.setEscapeProcessing()
  • PreparedStatement.setFetchDirection()
  • PreparedStatement.setFetchSize()
  • PreparedStatement.setFloat()
  • PreparedStatement.setInt()
  • PreparedStatement.setLong()
  • PreparedStatement.setMaxFieldSize()
  • PreparedStatement.setMaxRows()
  • PreparedStatement.setNCharacterStream()
  • PreparedStatement.setNClob()
  • PreparedStatement.setNString()
  • PreparedStatement.setNull()
  • PreparedStatement.setObject()
  • PreparedStatement.setPoolable()
  • PreparedStatement.setQueryTimeout()
  • PreparedStatement.setRef()
  • PreparedStatement.setRowId()
  • PreparedStatement.setShort()
  • PreparedStatement.setSQLXML()
  • PreparedStatement.setString()
  • PreparedStatement.setTime()
  • PreparedStatement.setTimestamp()
  • PreparedStatement.setUnicodeStream()
  • PreparedStatement.setURL()
  • PreparedStatement.unwrap()
  • Ref
  • Ref.getBaseTypeName()
  • Ref.getObject()
  • Ref.setObject()
  • ResultSet
  • ResultSet.absolute()
  • ResultSet.afterLast()
  • ResultSet.beforeFirst()
  • ResultSet.cancelRowUpdates()
  • ResultSet.clearWarnings()
  • ResultSet.close()
  • ResultSet.deleteRow()
  • ResultSet.findColumn()
  • ResultSet.first()
  • ResultSet.getArray()
  • ResultSet.getAsciiStream()
  • ResultSet.getBigDecimal()
  • ResultSet.getBinaryStream()
  • ResultSet.getBlob()
  • ResultSet.getBoolean()
  • ResultSet.getByte()
  • ResultSet.getBytes()
  • ResultSet.getCharacterStream()
  • ResultSet.getClob()
  • ResultSet.getConcurrency()
  • ResultSet.getCursorName()
  • ResultSet.getDate()
  • ResultSet.getDouble()
  • ResultSet.getFetchDirection()
  • ResultSet.getFetchSize()
  • ResultSet.getFloat()
  • ResultSet.getHoldability()
  • ResultSet.getInt()
  • ResultSet.getLong()
  • ResultSet.getMetaData()
  • ResultSet.getNCharacterStream()
  • ResultSet.getNClob()
  • ResultSet.getNString()
  • ResultSet.getObject()
  • ResultSet.getRef()
  • ResultSet.getRow()
  • ResultSet.getRowId()
  • ResultSet.getShort()
  • ResultSet.getSQLXML()
  • ResultSet.getStatement()
  • ResultSet.getString()
  • ResultSet.getTime()
  • ResultSet.getTimestamp()
  • ResultSet.getType()
  • ResultSet.getUnicodeStream()
  • ResultSet.getURL()
  • ResultSet.getWarnings()
  • ResultSet.insertRow()
  • ResultSet.isAfterLast()
  • ResultSet.isBeforeFirst()
  • ResultSet.isClosed()
  • ResultSet.isFirst()
  • ResultSet.isLast()
  • ResultSet.isWrapperFor()
  • ResultSet.last()
  • ResultSet.moveToCurrentRow()
  • ResultSet.moveToInsertRow()
  • ResultSet.next()
  • ResultSet.previous()
  • ResultSet.refreshRow()
  • ResultSet.relative()
  • ResultSet.rowDeleted()
  • ResultSet.rowInserted()
  • ResultSet.rowUpdated()
  • ResultSet.setFetchDirection()
  • ResultSet.setFetchSize()
  • ResultSet.unwrap()
  • ResultSet.updateArray()
  • ResultSet.updateAsciiStream()
  • ResultSet.updateBigDecimal()
  • ResultSet.updateBinaryStream()
  • ResultSet.updateBlob()
  • ResultSet.updateBoolean()
  • ResultSet.updateByte()
  • ResultSet.updateBytes()
  • ResultSet.updateCharacterStream()
  • ResultSet.updateClob()
  • ResultSet.updateDate()
  • ResultSet.updateDouble()
  • ResultSet.updateFloat()
  • ResultSet.updateInt()
  • ResultSet.updateLong()
  • ResultSet.updateNCharacterStream()
  • ResultSet.updateNClob()
  • ResultSet.updateNString()
  • ResultSet.updateNull()
  • ResultSet.updateObject()
  • ResultSet.updateRef()
  • ResultSet.updateRow()
  • ResultSet.updateRowId()
  • ResultSet.updateShort()
  • ResultSet.updateSQLXML()
  • ResultSet.updateString()
  • ResultSet.updateTime()
  • ResultSet.updateTimestamp()
  • ResultSet.wasNull()
  • ResultSetMetaData
  • ResultSetMetaData.getCatalogName()
  • ResultSetMetaData.getColumnClassName()
  • ResultSetMetaData.getColumnCount()
  • ResultSetMetaData.getColumnDisplaySize()
  • ResultSetMetaData.getColumnLabel()
  • ResultSetMetaData.getColumnName()
  • ResultSetMetaData.getColumnType()
  • ResultSetMetaData.getColumnTypeName()
  • ResultSetMetaData.getPrecision()
  • ResultSetMetaData.getScale()
  • ResultSetMetaData.getSchemaName()
  • ResultSetMetaData.getTableName()
  • ResultSetMetaData.isAutoIncrement()
  • ResultSetMetaData.isCaseSensitive()
  • ResultSetMetaData.isCurrency()
  • ResultSetMetaData.isDefinitelyWritable()
  • ResultSetMetaData.isNullable()
  • ResultSetMetaData.isReadOnly()
  • ResultSetMetaData.isSearchable()
  • ResultSetMetaData.isSigned()
  • ResultSetMetaData.isWrapperFor()
  • ResultSetMetaData.isWritable()
  • ResultSetMetaData.unwrap()
  • ResultSetMetaData_Statics
  • ResultSetMetaData_Statics.columnNoNulls
  • ResultSetMetaData_Statics.columnNullable
  • ResultSetMetaData_Statics.columnNullableUnknown
  • ResultSet_Statics
  • ResultSet_Statics.CLOSE_CURSORS_AT_COMMIT
  • ResultSet_Statics.CONCUR_READ_ONLY
  • ResultSet_Statics.CONCUR_UPDATABLE
  • ResultSet_Statics.FETCH_FORWARD
  • ResultSet_Statics.FETCH_REVERSE
  • ResultSet_Statics.FETCH_UNKNOWN
  • ResultSet_Statics.HOLD_CURSORS_OVER_COMMIT
  • ResultSet_Statics.TYPE_FORWARD_ONLY
  • ResultSet_Statics.TYPE_SCROLL_INSENSITIVE
  • ResultSet_Statics.TYPE_SCROLL_SENSITIVE
  • RowId
  • RowId.getBytes()
  • RowIdLifetime
  • RowIdLifetime.ROWID_UNSUPPORTED
  • RowIdLifetime.ROWID_VALID_FOREVER
  • RowIdLifetime.ROWID_VALID_OTHER
  • RowIdLifetime.ROWID_VALID_SESSION
  • RowIdLifetime.ROWID_VALID_TRANSACTION
  • Savepoint
  • Savepoint.getSavepointId()
  • Savepoint.getSavepointName()
  • SQLClientInfoException
  • SQLClientInfoException.getFailedProperties()
  • SQLException
  • SQLException.getErrorCode()
  • SQLException.getNextException()
  • SQLException.getSQLState()
  • SQLException.iterator()
  • SQLException.setNextException()
  • SQLFeatureNotSupportedException
  • SQLNonTransientException
  • SQLWarning
  • SQLWarning.getNextWarning()
  • SQLWarning.setNextWarning()
  • SQLXML
  • SQLXML.free()
  • SQLXML.getBinaryStream()
  • SQLXML.getCharacterStream()
  • SQLXML.getSource()
  • SQLXML.getString()
  • SQLXML.setBinaryStream()
  • SQLXML.setCharacterStream()
  • SQLXML.setResult()
  • SQLXML.setString()
  • Statement
  • Statement.addBatch()
  • Statement.cancel()
  • Statement.clearBatch()
  • Statement.clearWarnings()
  • Statement.close()
  • Statement.closeOnCompletion()
  • Statement.execute()
  • Statement.executeBatch()
  • Statement.executeQuery()
  • Statement.executeUpdate()
  • Statement.getConnection()
  • Statement.getFetchDirection()
  • Statement.getFetchSize()
  • Statement.getGeneratedKeys()
  • Statement.getMaxFieldSize()
  • Statement.getMaxRows()
  • Statement.getMoreResults()
  • Statement.getQueryTimeout()
  • Statement.getResultSet()
  • Statement.getResultSetConcurrency()
  • Statement.getResultSetHoldability()
  • Statement.getResultSetType()
  • Statement.getUpdateCount()
  • Statement.getWarnings()
  • Statement.isClosed()
  • Statement.isCloseOnCompletion()
  • Statement.isPoolable()
  • Statement.isWrapperFor()
  • Statement.setCursorName()
  • Statement.setEscapeProcessing()
  • Statement.setFetchDirection()
  • Statement.setFetchSize()
  • Statement.setMaxFieldSize()
  • Statement.setMaxRows()
  • Statement.setPoolable()
  • Statement.setQueryTimeout()
  • Statement.unwrap()
  • Statement_Statics
  • Statement_Statics.CLOSE_ALL_RESULTS
  • Statement_Statics.CLOSE_CURRENT_RESULT
  • Statement_Statics.EXECUTE_FAILED
  • Statement_Statics.KEEP_CURRENT_RESULT
  • Statement_Statics.NO_GENERATED_KEYS
  • Statement_Statics.RETURN_GENERATED_KEYS
  • Statement_Statics.SUCCESS_NO_INFO
  • Struct
  • Struct.getAttributes()
  • Struct.getSQLTypeName()
  • Time
  • Time.valueOf()
  • Timestamp
  • Timestamp.getNanos()
  • Timestamp.setNanos()
  • Timestamp.valueOf()
  • Types
  • Types.ARRAY
  • Types.BIGINT
  • Types.BINARY
  • Types.BIT
  • Types.BLOB
  • Types.BOOLEAN
  • Types.CHAR
  • Types.CLOB
  • Types.DATALINK
  • Types.DATE
  • Types.DECIMAL
  • Types.DISTINCT
  • Types.DOUBLE
  • Types.FLOAT
  • Types.INTEGER
  • Types.JAVA_OBJECT
  • Types.LONGNVARCHAR
  • Types.LONGVARBINARY
  • Types.LONGVARCHAR
  • Types.NCHAR
  • Types.NCLOB
  • Types.NULL
  • Types.NUMERIC
  • Types.NVARCHAR
  • Types.OTHER
  • Types.REAL
  • Types.REF
  • Types.ROWID
  • Types.SMALLINT
  • Types.SQLXML
  • Types.STRUCT
  • Types.TIME
  • Types.TIMESTAMP
  • Types.TINYINT
  • Types.VARBINARY
  • Types.VARCHAR
  • Wrapper
  • Wrapper.isWrapperFor()
  • Wrapper.unwrap()

    • java.vm

  • AtomicList
  • AtomicList.add()
  • AtomicList.peek()
  • AtomicList.peekLast()
  • AtomicList.pop()
  • AtomicNode
  • AtomicNode.value
  • Deque
  • Deque.add()
  • Deque.pop()
  • Deque.push()
  • Gc
  • Gc.run()
  • Gc.stats()
  • Lock
  • Lock.release()
  • Lock.wait()
  • Mutex
  • Mutex.acquire()
  • Mutex.release()
  • Mutex.tryAcquire()
  • Node
  • Node.next
  • Node.value
  • Thread
  • Thread.create()
  • Thread.current()
  • Thread.readMessage()
  • Thread.sendMessage()
  • Tls
  • Tls.value

    • java.math

  • BigDecimal
  • BigDecimal.abs()
  • BigDecimal.add()
  • BigDecimal.byteValueExact()
  • BigDecimal.compareTo()
  • BigDecimal.divide()
  • BigDecimal.divideAndRemainder()
  • BigDecimal.divideToIntegralValue()
  • BigDecimal.equals()
  • BigDecimal.hashCode()
  • BigDecimal.intValueExact()
  • BigDecimal.longValueExact()
  • BigDecimal.max()
  • BigDecimal.min()
  • BigDecimal.movePointLeft()
  • BigDecimal.movePointRight()
  • BigDecimal.multiply()
  • BigDecimal.negate()
  • BigDecimal.ONE
  • BigDecimal.plus()
  • BigDecimal.pow()
  • BigDecimal.precision()
  • BigDecimal.remainder()
  • BigDecimal.round()
  • BigDecimal.ROUND_CEILING
  • BigDecimal.ROUND_DOWN
  • BigDecimal.ROUND_FLOOR
  • BigDecimal.ROUND_HALF_DOWN
  • BigDecimal.ROUND_HALF_EVEN
  • BigDecimal.ROUND_HALF_UP
  • BigDecimal.ROUND_UNNECESSARY
  • BigDecimal.ROUND_UP
  • BigDecimal.scale()
  • BigDecimal.scaleByPowerOfTen()
  • BigDecimal.setScale()
  • BigDecimal.shortValueExact()
  • BigDecimal.signum()
  • BigDecimal.stripTrailingZeros()
  • BigDecimal.subtract()
  • BigDecimal.TEN
  • BigDecimal.toBigInteger()
  • BigDecimal.toBigIntegerExact()
  • BigDecimal.toEngineeringString()
  • BigDecimal.toPlainString()
  • BigDecimal.toString()
  • BigDecimal.ulp()
  • BigDecimal.unscaledValue()
  • BigDecimal.valueOf()
  • BigDecimal.ZERO
  • BigDecimal_LongOverflow
  • BigDecimal_LongOverflow.check()
  • BigDecimal_StringBuilderHelper
  • BigInteger
  • BigInteger.abs()
  • BigInteger.add()
  • BigInteger.and()
  • BigInteger.andNot()
  • BigInteger.bitCount()
  • BigInteger.bitLength()
  • BigInteger.clearBit()
  • BigInteger.compareTo()
  • BigInteger.divide()
  • BigInteger.divideAndRemainder()
  • BigInteger.equals()
  • BigInteger.flipBit()
  • BigInteger.gcd()
  • BigInteger.getLowestSetBit()
  • BigInteger.hashCode()
  • BigInteger.isProbablePrime()
  • BigInteger.max()
  • BigInteger.min()
  • BigInteger.mod()
  • BigInteger.modInverse()
  • BigInteger.modPow()
  • BigInteger.multiply()
  • BigInteger.negate()
  • BigInteger.nextProbablePrime()
  • BigInteger.not()
  • BigInteger.ONE
  • BigInteger.or()
  • BigInteger.pow()
  • BigInteger.probablePrime()
  • BigInteger.remainder()
  • BigInteger.setBit()
  • BigInteger.shiftLeft()
  • BigInteger.shiftRight()
  • BigInteger.signum()
  • BigInteger.subtract()
  • BigInteger.TEN
  • BigInteger.testBit()
  • BigInteger.toByteArray()
  • BigInteger.toString()
  • BigInteger.valueOf()
  • BigInteger.xor()
  • BigInteger.ZERO
  • MathContext
  • MathContext.DECIMAL128
  • MathContext.DECIMAL32
  • MathContext.DECIMAL64
  • MathContext.equals()
  • MathContext.getPrecision()
  • MathContext.getRoundingMode()
  • MathContext.hashCode()
  • MathContext.toString()
  • MathContext.UNLIMITED
  • RoundingMode
  • RoundingMode.CEILING
  • RoundingMode.DOWN
  • RoundingMode.FLOOR
  • RoundingMode.HALF_DOWN
  • RoundingMode.HALF_EVEN
  • RoundingMode.HALF_UP
  • RoundingMode.UNNECESSARY
  • RoundingMode.UP

    • java.nio

  • Buffer
  • Buffer.array()
  • Buffer.arrayOffset()
  • Buffer.capacity()
  • Buffer.clear()
  • Buffer.flip()
  • Buffer.hasArray()
  • Buffer.hasRemaining()
  • Buffer.isDirect()
  • Buffer.isReadOnly()
  • Buffer.limit()
  • Buffer.mark()
  • Buffer.position()
  • Buffer.remaining()
  • Buffer.reset()
  • Buffer.rewind()
  • ByteBuffer
  • ByteBuffer.allocate()
  • ByteBuffer.allocateDirect()
  • ByteBuffer.asCharBuffer()
  • ByteBuffer.asDoubleBuffer()
  • ByteBuffer.asFloatBuffer()
  • ByteBuffer.asIntBuffer()
  • ByteBuffer.asLongBuffer()
  • ByteBuffer.asReadOnlyBuffer()
  • ByteBuffer.asShortBuffer()
  • ByteBuffer.compact()
  • ByteBuffer.compareTo()
  • ByteBuffer.duplicate()
  • ByteBuffer.equals()
  • ByteBuffer.get()
  • ByteBuffer.getChar()
  • ByteBuffer.getDouble()
  • ByteBuffer.getFloat()
  • ByteBuffer.getInt()
  • ByteBuffer.getLong()
  • ByteBuffer.getShort()
  • ByteBuffer.hashCode()
  • ByteBuffer.order()
  • ByteBuffer.put()
  • ByteBuffer.putChar()
  • ByteBuffer.putDouble()
  • ByteBuffer.putFloat()
  • ByteBuffer.putInt()
  • ByteBuffer.putLong()
  • ByteBuffer.putShort()
  • ByteBuffer.slice()
  • ByteBuffer.toString()
  • ByteBuffer.wrap()
  • ByteOrder
  • ByteOrder.BIG_ENDIAN
  • ByteOrder.LITTLE_ENDIAN
  • ByteOrder.nativeOrder()
  • ByteOrder.toString()
  • CharBuffer
  • CharBuffer.allocate()
  • CharBuffer.append()
  • CharBuffer.asReadOnlyBuffer()
  • CharBuffer.charAt()
  • CharBuffer.compact()
  • CharBuffer.compareTo()
  • CharBuffer.duplicate()
  • CharBuffer.equals()
  • CharBuffer.get()
  • CharBuffer.hashCode()
  • CharBuffer.length()
  • CharBuffer.order()
  • CharBuffer.put()
  • CharBuffer.read()
  • CharBuffer.slice()
  • CharBuffer.subSequence()
  • CharBuffer.toString()
  • CharBuffer.wrap()
  • DoubleBuffer
  • DoubleBuffer.allocate()
  • DoubleBuffer.asReadOnlyBuffer()
  • DoubleBuffer.compact()
  • DoubleBuffer.compareTo()
  • DoubleBuffer.duplicate()
  • DoubleBuffer.equals()
  • DoubleBuffer.get()
  • DoubleBuffer.hashCode()
  • DoubleBuffer.order()
  • DoubleBuffer.put()
  • DoubleBuffer.slice()
  • DoubleBuffer.toString()
  • DoubleBuffer.wrap()
  • FloatBuffer
  • FloatBuffer.allocate()
  • FloatBuffer.asReadOnlyBuffer()
  • FloatBuffer.compact()
  • FloatBuffer.compareTo()
  • FloatBuffer.duplicate()
  • FloatBuffer.equals()
  • FloatBuffer.get()
  • FloatBuffer.hashCode()
  • FloatBuffer.order()
  • FloatBuffer.put()
  • FloatBuffer.slice()
  • FloatBuffer.toString()
  • FloatBuffer.wrap()
  • IntBuffer
  • IntBuffer.allocate()
  • IntBuffer.asReadOnlyBuffer()
  • IntBuffer.compact()
  • IntBuffer.compareTo()
  • IntBuffer.duplicate()
  • IntBuffer.equals()
  • IntBuffer.get()
  • IntBuffer.hashCode()
  • IntBuffer.order()
  • IntBuffer.put()
  • IntBuffer.slice()
  • IntBuffer.toString()
  • IntBuffer.wrap()
  • LongBuffer
  • LongBuffer.allocate()
  • LongBuffer.asReadOnlyBuffer()
  • LongBuffer.compact()
  • LongBuffer.compareTo()
  • LongBuffer.duplicate()
  • LongBuffer.equals()
  • LongBuffer.get()
  • LongBuffer.hashCode()
  • LongBuffer.order()
  • LongBuffer.put()
  • LongBuffer.slice()
  • LongBuffer.toString()
  • LongBuffer.wrap()
  • MappedByteBuffer
  • MappedByteBuffer.force()
  • MappedByteBuffer.isLoaded()
  • MappedByteBuffer.load()
  • ShortBuffer
  • ShortBuffer.allocate()
  • ShortBuffer.asReadOnlyBuffer()
  • ShortBuffer.compact()
  • ShortBuffer.compareTo()
  • ShortBuffer.duplicate()
  • ShortBuffer.equals()
  • ShortBuffer.get()
  • ShortBuffer.hashCode()
  • ShortBuffer.order()
  • ShortBuffer.put()
  • ShortBuffer.slice()
  • ShortBuffer.toString()
  • ShortBuffer.wrap()

    • java.io

  • ByteArrayOutputStream
  • ByteArrayOutputStream.reset()
  • ByteArrayOutputStream.size()
  • ByteArrayOutputStream.toByteArray()
  • ByteArrayOutputStream.toString()
  • ByteArrayOutputStream.writeTo()
  • Closeable
  • Closeable.close()
  • Console
  • Console.flush()
  • Console.format()
  • Console.printf()
  • Console.reader()
  • Console.readLine()
  • Console.readPassword()
  • Console.writer()
  • Console_LineReader
  • DataInput
  • DataInput.readBoolean()
  • DataInput.readByte()
  • DataInput.readChar()
  • DataInput.readDouble()
  • DataInput.readFloat()
  • DataInput.readFully()
  • DataInput.readInt()
  • DataInput.readLine()
  • DataInput.readLong()
  • DataInput.readShort()
  • DataInput.readUnsignedByte()
  • DataInput.readUnsignedShort()
  • DataInput.readUTF()
  • DataInput.skipBytes()
  • DataOutput
  • DataOutput.write()
  • DataOutput.writeBoolean()
  • DataOutput.writeByte()
  • DataOutput.writeBytes()
  • DataOutput.writeChar()
  • DataOutput.writeChars()
  • DataOutput.writeDouble()
  • DataOutput.writeFloat()
  • DataOutput.writeInt()
  • DataOutput.writeLong()
  • DataOutput.writeShort()
  • DataOutput.writeUTF()
  • EOFException
  • File
  • File.canExecute()
  • File.canRead()
  • File.canWrite()
  • File.compareTo()
  • File.createNewFile()
  • File.createTempFile()
  • File.delete()
  • File.deleteOnExit()
  • File.equals()
  • File.exists()
  • File.getAbsoluteFile()
  • File.getAbsolutePath()
  • File.getCanonicalFile()
  • File.getCanonicalPath()
  • File.getFreeSpace()
  • File.getName()
  • File.getParent()
  • File.getParentFile()
  • File.getPath()
  • File.getTotalSpace()
  • File.getUsableSpace()
  • File.hashCode()
  • File.isAbsolute()
  • File.isDirectory()
  • File.isFile()
  • File.isHidden()
  • File.lastModified()
  • File.length()
  • File.list()
  • File.listFiles()
  • File.listRoots()
  • File.mkdir()
  • File.mkdirs()
  • File.pathSeparator
  • File.pathSeparatorChar
  • File.renameTo()
  • File.separator
  • File.separatorChar
  • File.setExecutable()
  • File.setLastModified()
  • File.setReadable()
  • File.setReadOnly()
  • File.setWritable()
  • File.toPath()
  • File.toString()
  • File.toURI()
  • File.toURL()
  • FileDescriptor
  • FileDescriptor.err
  • FileDescriptor.out
  • FileDescriptor.sync()
  • FileDescriptor.valid()
  • FileDescriptor._in
  • FileFilter
  • FileFilter.accept()
  • FilenameFilter
  • FilenameFilter.accept()
  • FileNotFoundException
  • File_TempDirectory
  • FilterOutputStream
  • Flushable
  • Flushable.flush()
  • InputStream
  • InputStream.available()
  • InputStream.close()
  • InputStream.mark()
  • InputStream.markSupported()
  • InputStream.read()
  • InputStream.reset()
  • InputStream.skip()
  • IOException
  • NativeInput
  • NativeOutput
  • ObjectStreamException
  • OutputStream
  • OutputStream.close()
  • OutputStream.flush()
  • OutputStream.write()
  • PrintStream
  • PrintStream.append()
  • PrintStream.checkError()
  • PrintStream.format()
  • PrintStream.print()
  • PrintStream.printf()
  • PrintStream.println()
  • PrintWriter
  • PrintWriter.checkError()
  • PrintWriter.format()
  • PrintWriter.print()
  • PrintWriter.printf()
  • PrintWriter.println()
  • RandomAccessFile
  • RandomAccessFile.close()
  • RandomAccessFile.getChannel()
  • RandomAccessFile.getFD()
  • RandomAccessFile.getFilePointer()
  • RandomAccessFile.length()
  • RandomAccessFile.read()
  • RandomAccessFile.readBoolean()
  • RandomAccessFile.readByte()
  • RandomAccessFile.readChar()
  • RandomAccessFile.readDouble()
  • RandomAccessFile.readFloat()
  • RandomAccessFile.readFully()
  • RandomAccessFile.readInt()
  • RandomAccessFile.readLine()
  • RandomAccessFile.readLong()
  • RandomAccessFile.readShort()
  • RandomAccessFile.readUnsignedByte()
  • RandomAccessFile.readUnsignedShort()
  • RandomAccessFile.readUTF()
  • RandomAccessFile.seek()
  • RandomAccessFile.setLength()
  • RandomAccessFile.skipBytes()
  • RandomAccessFile.write()
  • RandomAccessFile.writeBoolean()
  • RandomAccessFile.writeByte()
  • RandomAccessFile.writeBytes()
  • RandomAccessFile.writeChar()
  • RandomAccessFile.writeChars()
  • RandomAccessFile.writeDouble()
  • RandomAccessFile.writeFloat()
  • RandomAccessFile.writeInt()
  • RandomAccessFile.writeLong()
  • RandomAccessFile.writeShort()
  • RandomAccessFile.writeUTF()
  • Reader
  • Reader.close()
  • Reader.mark()
  • Reader.markSupported()
  • Reader.read()
  • Reader.ready()
  • Reader.reset()
  • Reader.skip()
  • Serializable
  • SyncFailedException
  • UnsupportedEncodingException
  • Writer
  • Writer.append()
  • Writer.close()
  • Writer.flush()
  • Writer.write()

    • java.security.cert

  • cert.Certificate
  • cert.Certificate.equals()
  • cert.Certificate.getEncoded()
  • cert.Certificate.getPublicKey()
  • cert.Certificate.getType()
  • cert.Certificate.hashCode()
  • cert.Certificate.toString()
  • cert.Certificate.verify()
  • cert.CertificateEncodingException
  • cert.CertificateException
  • cert.Certificate_CertificateRep
  • cert.CertPath
  • cert.CertPath.equals()
  • cert.CertPath.getCertificates()
  • cert.CertPath.getEncoded()
  • cert.CertPath.getEncodings()
  • cert.CertPath.getType()
  • cert.CertPath.hashCode()
  • cert.CertPath.toString()
  • cert.CertPath_CertPathRep

    • java.nio.channels

  • channels.AsynchronousChannel
  • channels.AsynchronousChannel.close()
  • channels.AsynchronousChannel.isOpen()
  • channels.AsynchronousCloseException
  • channels.AsynchronousFileChannel
  • channels.AsynchronousFileChannel.close()
  • channels.AsynchronousFileChannel.force()
  • channels.AsynchronousFileChannel.isOpen()
  • channels.AsynchronousFileChannel.lock()
  • channels.AsynchronousFileChannel.open()
  • channels.AsynchronousFileChannel.read()
  • channels.AsynchronousFileChannel.size()
  • channels.AsynchronousFileChannel.truncate()
  • channels.AsynchronousFileChannel.tryLock()
  • channels.AsynchronousFileChannel.write()
  • channels.ByteChannel
  • channels.ByteChannel.close()
  • channels.ByteChannel.isOpen()
  • channels.ByteChannel.read()
  • channels.ByteChannel.write()
  • channels.Channel
  • channels.Channel.close()
  • channels.Channel.isOpen()
  • channels.ClosedChannelException
  • channels.CompletionHandler
  • channels.CompletionHandler.completed()
  • channels.CompletionHandler.failed()
  • channels.DatagramChannel
  • channels.DatagramChannel.bind()
  • channels.DatagramChannel.connect()
  • channels.DatagramChannel.disconnect()
  • channels.DatagramChannel.getLocalAddress()
  • channels.DatagramChannel.getOption()
  • channels.DatagramChannel.getRemoteAddress()
  • channels.DatagramChannel.isConnected()
  • channels.DatagramChannel.join()
  • channels.DatagramChannel.open()
  • channels.DatagramChannel.read()
  • channels.DatagramChannel.receive()
  • channels.DatagramChannel.send()
  • channels.DatagramChannel.setOption()
  • channels.DatagramChannel.socket()
  • channels.DatagramChannel.supportedOptions()
  • channels.DatagramChannel.write()
  • channels.FileChannel
  • channels.FileChannel.force()
  • channels.FileChannel.lock()
  • channels.FileChannel.map()
  • channels.FileChannel.open()
  • channels.FileChannel.position()
  • channels.FileChannel.read()
  • channels.FileChannel.size()
  • channels.FileChannel.transferFrom()
  • channels.FileChannel.transferTo()
  • channels.FileChannel.truncate()
  • channels.FileChannel.tryLock()
  • channels.FileChannel.write()
  • channels.FileChannel_MapMode
  • channels.FileChannel_MapMode.PRIVATE
  • channels.FileChannel_MapMode.READ_ONLY
  • channels.FileChannel_MapMode.READ_WRITE
  • channels.FileChannel_MapMode.toString()
  • channels.FileLock
  • channels.FileLock.acquiredBy()
  • channels.FileLock.channel()
  • channels.FileLock.close()
  • channels.FileLock.isShared()
  • channels.FileLock.isValid()
  • channels.FileLock.overlaps()
  • channels.FileLock.position()
  • channels.FileLock.release()
  • channels.FileLock.size()
  • channels.FileLock.toString()
  • channels.GatheringByteChannel
  • channels.GatheringByteChannel.close()
  • channels.GatheringByteChannel.isOpen()
  • channels.GatheringByteChannel.write()
  • channels.InterruptibleChannel
  • channels.InterruptibleChannel.close()
  • channels.InterruptibleChannel.isOpen()
  • channels.MembershipKey
  • channels.MembershipKey.block()
  • channels.MembershipKey.channel()
  • channels.MembershipKey.drop()
  • channels.MembershipKey.group()
  • channels.MembershipKey.isValid()
  • channels.MembershipKey.networkInterface()
  • channels.MembershipKey.sourceAddress()
  • channels.MembershipKey.unblock()
  • channels.MulticastChannel
  • channels.MulticastChannel.bind()
  • channels.MulticastChannel.close()
  • channels.MulticastChannel.getLocalAddress()
  • channels.MulticastChannel.getOption()
  • channels.MulticastChannel.isOpen()
  • channels.MulticastChannel.join()
  • channels.MulticastChannel.setOption()
  • channels.MulticastChannel.supportedOptions()
  • channels.NetworkChannel
  • channels.NetworkChannel.bind()
  • channels.NetworkChannel.close()
  • channels.NetworkChannel.getLocalAddress()
  • channels.NetworkChannel.getOption()
  • channels.NetworkChannel.isOpen()
  • channels.NetworkChannel.setOption()
  • channels.NetworkChannel.supportedOptions()
  • channels.Pipe
  • channels.Pipe.open()
  • channels.Pipe.sink()
  • channels.Pipe.source()
  • channels.Pipe_SinkChannel
  • channels.Pipe_SinkChannel.write()
  • channels.Pipe_SourceChannel
  • channels.Pipe_SourceChannel.read()
  • channels.ReadableByteChannel
  • channels.ReadableByteChannel.close()
  • channels.ReadableByteChannel.isOpen()
  • channels.ReadableByteChannel.read()
  • channels.ScatteringByteChannel
  • channels.ScatteringByteChannel.close()
  • channels.ScatteringByteChannel.isOpen()
  • channels.ScatteringByteChannel.read()
  • channels.SeekableByteChannel
  • channels.SeekableByteChannel.close()
  • channels.SeekableByteChannel.isOpen()
  • channels.SeekableByteChannel.position()
  • channels.SeekableByteChannel.read()
  • channels.SeekableByteChannel.size()
  • channels.SeekableByteChannel.truncate()
  • channels.SeekableByteChannel.write()
  • channels.SelectableChannel
  • channels.SelectableChannel.blockingLock()
  • channels.SelectableChannel.configureBlocking()
  • channels.SelectableChannel.isBlocking()
  • channels.SelectableChannel.isRegistered()
  • channels.SelectableChannel.keyFor()
  • channels.SelectableChannel.provider()
  • channels.SelectableChannel.register()
  • channels.SelectableChannel.validOps()
  • channels.SelectionKey
  • channels.SelectionKey.attach()
  • channels.SelectionKey.attachment()
  • channels.SelectionKey.cancel()
  • channels.SelectionKey.channel()
  • channels.SelectionKey.interestOps()
  • channels.SelectionKey.isAcceptable()
  • channels.SelectionKey.isConnectable()
  • channels.SelectionKey.isReadable()
  • channels.SelectionKey.isValid()
  • channels.SelectionKey.isWritable()
  • channels.SelectionKey.OP_ACCEPT
  • channels.SelectionKey.OP_CONNECT
  • channels.SelectionKey.OP_READ
  • channels.SelectionKey.OP_WRITE
  • channels.SelectionKey.readyOps()
  • channels.SelectionKey.selector()
  • channels.Selector
  • channels.Selector.close()
  • channels.Selector.isOpen()
  • channels.Selector.keys()
  • channels.Selector.open()
  • channels.Selector.provider()
  • channels.Selector.select()
  • channels.Selector.selectedKeys()
  • channels.Selector.selectNow()
  • channels.Selector.wakeup()
  • channels.ServerSocketChannel
  • channels.ServerSocketChannel.accept()
  • channels.ServerSocketChannel.bind()
  • channels.ServerSocketChannel.getLocalAddress()
  • channels.ServerSocketChannel.getOption()
  • channels.ServerSocketChannel.open()
  • channels.ServerSocketChannel.setOption()
  • channels.ServerSocketChannel.socket()
  • channels.ServerSocketChannel.supportedOptions()
  • channels.SocketChannel
  • channels.SocketChannel.bind()
  • channels.SocketChannel.connect()
  • channels.SocketChannel.finishConnect()
  • channels.SocketChannel.getLocalAddress()
  • channels.SocketChannel.getOption()
  • channels.SocketChannel.getRemoteAddress()
  • channels.SocketChannel.isConnected()
  • channels.SocketChannel.isConnectionPending()
  • channels.SocketChannel.open()
  • channels.SocketChannel.read()
  • channels.SocketChannel.setOption()
  • channels.SocketChannel.shutdownInput()
  • channels.SocketChannel.shutdownOutput()
  • channels.SocketChannel.socket()
  • channels.SocketChannel.supportedOptions()
  • channels.SocketChannel.write()
  • channels.spi.AbstractInterruptibleChannel
  • channels.spi.AbstractInterruptibleChannel.close()
  • channels.spi.AbstractInterruptibleChannel.isOpen()
  • channels.spi.AbstractSelectableChannel
  • channels.spi.AbstractSelectionKey
  • channels.spi.AbstractSelector
  • channels.spi.SelectorProvider
  • channels.spi.SelectorProvider.inheritedChannel()
  • channels.spi.SelectorProvider.openDatagramChannel()
  • channels.spi.SelectorProvider.openPipe()
  • channels.spi.SelectorProvider.openSelector()
  • channels.spi.SelectorProvider.openServerSocketChannel()
  • channels.spi.SelectorProvider.openSocketChannel()
  • channels.spi.SelectorProvider.provider()
  • channels.WritableByteChannel
  • channels.WritableByteChannel.close()
  • channels.WritableByteChannel.isOpen()
  • channels.WritableByteChannel.write()

    • java.types

  • Char16
  • Int16
  • Int8

    • java

  • Char16
  • Int16
  • Int64
  • Int64.add()
  • Int64.addI()
  • Int64.and()
  • Int64.andI()
  • Int64.bneg()
  • Int64.div()
  • Int64.divI()
  • Int64.gt()
  • Int64.gte()
  • Int64.lt()
  • Int64.lte()
  • Int64.mod()
  • Int64.modI()
  • Int64.mul()
  • Int64.mulI()
  • Int64.neg()
  • Int64.or()
  • Int64.orI()
  • Int64.postDecrement()
  • Int64.postIncrement()
  • Int64.preDecrement()
  • Int64.preIncrement()
  • Int64.shl()
  • Int64.shlI()
  • Int64.shr()
  • Int64.shrI()
  • Int64.sub()
  • Int64.subI()
  • Int64.ushr()
  • Int64.ushrI()
  • Int64.xor()
  • Int64.xorI()
  • Int8
  • Lib
  • Lib.array()
  • Lib.arrayAlloc()
  • Lib.array_Bool()
  • Lib.array_Float()
  • Lib.array_haxe_Int64()
  • Lib.array_Int()
  • Lib.array_java_Char16()
  • Lib.array_java_Int16()
  • Lib.array_java_Int8()
  • Lib.array_Single()
  • Lib.fromNativeType()
  • Lib.getNativeType()
  • Lib.lock()
  • Lib.nativeArray()
  • Lib.nativeType()
  • Lib.toNativeEnum()
  • Lib.toNativeType()
  • NativeArray
  • NativeArray.length
  • NativeArray.make()

    • java.internal

  • Closure
  • Closure.equals()
  • Closure.hashCode()
  • DynamicObject
  • DynamicObject.toString()
  • EmptyObject
  • EmptyObject.EMPTY
  • Exceptions
  • Exceptions.currentException()
  • Function
  • HxEnum
  • HxEnum.getParams()
  • HxEnum.getTag()
  • HxEnum.toString()
  • IEquatable
  • IEquatable.equals()
  • IHxObject
  • Runtime
  • Runtime.callField()
  • Runtime.closure()
  • Runtime.compare()
  • Runtime.eq()
  • Runtime.getField()
  • Runtime.getField_f()
  • Runtime.isDouble()
  • Runtime.isFinite()
  • Runtime.isInt()
  • Runtime.plus()
  • Runtime.refEq()
  • Runtime.setField()
  • Runtime.setField_f()
  • Runtime.slowCallField()
  • Runtime.slowGetField()
  • Runtime.slowHasField()
  • Runtime.slowSetField()
  • Runtime.toBool()
  • Runtime.toDouble()
  • Runtime.toInt()
  • Runtime.toLong()
  • Runtime.toString()
  • Runtime.undefined
  • Runtime.valEq()
  • VarArgsFunction

    • java.security

  • CodeSigner
  • CodeSigner.equals()
  • CodeSigner.getSignerCertPath()
  • CodeSigner.getTimestamp()
  • CodeSigner.hashCode()
  • CodeSigner.toString()
  • CodeSource
  • CodeSource.equals()
  • CodeSource.getCertificates()
  • CodeSource.getCodeSigners()
  • CodeSource.getLocation()
  • CodeSource.hashCode()
  • CodeSource.implies()
  • CodeSource.toString()
  • GeneralSecurityException
  • Guard
  • Guard.checkGuard()
  • InvalidKeyException
  • Key
  • Key.getAlgorithm()
  • Key.getEncoded()
  • Key.getFormat()
  • KeyException
  • Key_Statics
  • Key_Statics.serialVersionUID
  • NoSuchAlgorithmException
  • NoSuchProviderException
  • Permission
  • Permission.checkGuard()
  • Permission.equals()
  • Permission.getActions()
  • Permission.getName()
  • Permission.hashCode()
  • Permission.implies()
  • Permission.newPermissionCollection()
  • Permission.toString()
  • PermissionCollection
  • PermissionCollection.add()
  • PermissionCollection.elements()
  • PermissionCollection.implies()
  • PermissionCollection.isReadOnly()
  • PermissionCollection.setReadOnly()
  • PermissionCollection.toString()
  • Principal
  • Principal.getName()
  • ProtectionDomain
  • ProtectionDomain.getClassLoader()
  • ProtectionDomain.getCodeSource()
  • ProtectionDomain.getPermissions()
  • ProtectionDomain.getPrincipals()
  • ProtectionDomain.implies()
  • ProtectionDomain.toString()
  • ProtectionDomain_Key
  • PublicKey
  • PublicKey.getAlgorithm()
  • PublicKey.getEncoded()
  • PublicKey.getFormat()
  • PublicKey_Statics
  • PublicKey_Statics.serialVersionUID
  • SignatureException
  • Timestamp
  • Timestamp.equals()
  • Timestamp.getSignerCertPath()
  • Timestamp.getTimestamp()
  • Timestamp.hashCode()
  • Timestamp.toString()

    • java.util.concurrent

  • concurrent.atomic.AtomicInteger
  • concurrent.atomic.AtomicInteger.addAndGet()
  • concurrent.atomic.AtomicInteger.compareAndSet()
  • concurrent.atomic.AtomicInteger.decrementAndGet()
  • concurrent.atomic.AtomicInteger.get()
  • concurrent.atomic.AtomicInteger.getAndAdd()
  • concurrent.atomic.AtomicInteger.getAndDecrement()
  • concurrent.atomic.AtomicInteger.getAndIncrement()
  • concurrent.atomic.AtomicInteger.getAndSet()
  • concurrent.atomic.AtomicInteger.incrementAndGet()
  • concurrent.atomic.AtomicInteger.lazySet()
  • concurrent.atomic.AtomicInteger.set()
  • concurrent.atomic.AtomicInteger.toString()
  • concurrent.atomic.AtomicInteger.weakCompareAndSet()
  • concurrent.atomic.AtomicReference
  • concurrent.atomic.AtomicReference.compareAndSet()
  • concurrent.atomic.AtomicReference.get()
  • concurrent.atomic.AtomicReference.getAndSet()
  • concurrent.atomic.AtomicReference.lazySet()
  • concurrent.atomic.AtomicReference.set()
  • concurrent.atomic.AtomicReference.toString()
  • concurrent.atomic.AtomicReference.weakCompareAndSet()
  • concurrent.Callable
  • concurrent.Callable.call()
  • concurrent.ExecutionException
  • concurrent.Executor
  • concurrent.Executor.execute()
  • concurrent.ExecutorService
  • concurrent.ExecutorService.awaitTermination()
  • concurrent.ExecutorService.execute()
  • concurrent.ExecutorService.invokeAll()
  • concurrent.ExecutorService.invokeAny()
  • concurrent.ExecutorService.isShutdown()
  • concurrent.ExecutorService.isTerminated()
  • concurrent.ExecutorService.shutdown()
  • concurrent.ExecutorService.shutdownNow()
  • concurrent.ExecutorService.submit()
  • concurrent.Future
  • concurrent.Future.cancel()
  • concurrent.Future.get()
  • concurrent.Future.isCancelled()
  • concurrent.Future.isDone()
  • concurrent.locks.AbstractOwnableSynchronizer
  • concurrent.locks.AbstractQueuedSynchronizer
  • concurrent.locks.AbstractQueuedSynchronizer.acquire()
  • concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly()
  • concurrent.locks.AbstractQueuedSynchronizer.acquireShared()
  • concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly()
  • concurrent.locks.AbstractQueuedSynchronizer.getExclusiveQueuedThreads()
  • concurrent.locks.AbstractQueuedSynchronizer.getFirstQueuedThread()
  • concurrent.locks.AbstractQueuedSynchronizer.getQueuedThreads()
  • concurrent.locks.AbstractQueuedSynchronizer.getQueueLength()
  • concurrent.locks.AbstractQueuedSynchronizer.getSharedQueuedThreads()
  • concurrent.locks.AbstractQueuedSynchronizer.getWaitingThreads()
  • concurrent.locks.AbstractQueuedSynchronizer.getWaitQueueLength()
  • concurrent.locks.AbstractQueuedSynchronizer.hasContended()
  • concurrent.locks.AbstractQueuedSynchronizer.hasQueuedPredecessors()
  • concurrent.locks.AbstractQueuedSynchronizer.hasQueuedThreads()
  • concurrent.locks.AbstractQueuedSynchronizer.hasWaiters()
  • concurrent.locks.AbstractQueuedSynchronizer.isQueued()
  • concurrent.locks.AbstractQueuedSynchronizer.owns()
  • concurrent.locks.AbstractQueuedSynchronizer.release()
  • concurrent.locks.AbstractQueuedSynchronizer.releaseShared()
  • concurrent.locks.AbstractQueuedSynchronizer.toString()
  • concurrent.locks.AbstractQueuedSynchronizer.tryAcquireNanos()
  • concurrent.locks.AbstractQueuedSynchronizer.tryAcquireSharedNanos()
  • concurrent.locks.AbstractQueuedSynchronizer_ConditionObject
  • concurrent.locks.AbstractQueuedSynchronizer_ConditionObject.await()
  • concurrent.locks.AbstractQueuedSynchronizer_ConditionObject.awaitNanos()
  • concurrent.locks.AbstractQueuedSynchronizer_ConditionObject.awaitUninterruptibly()
  • concurrent.locks.AbstractQueuedSynchronizer_ConditionObject.awaitUntil()
  • concurrent.locks.AbstractQueuedSynchronizer_ConditionObject.signal()
  • concurrent.locks.AbstractQueuedSynchronizer_ConditionObject.signalAll()
  • concurrent.locks.AbstractQueuedSynchronizer_Node
  • concurrent.locks.Condition
  • concurrent.locks.Condition.await()
  • concurrent.locks.Condition.awaitNanos()
  • concurrent.locks.Condition.awaitUninterruptibly()
  • concurrent.locks.Condition.awaitUntil()
  • concurrent.locks.Condition.signal()
  • concurrent.locks.Condition.signalAll()
  • concurrent.locks.Lock
  • concurrent.locks.Lock.lock()
  • concurrent.locks.Lock.lockInterruptibly()
  • concurrent.locks.Lock.newCondition()
  • concurrent.locks.Lock.tryLock()
  • concurrent.locks.Lock.unlock()
  • concurrent.locks.ReentrantLock
  • concurrent.locks.ReentrantLock.getHoldCount()
  • concurrent.locks.ReentrantLock.getQueueLength()
  • concurrent.locks.ReentrantLock.getWaitQueueLength()
  • concurrent.locks.ReentrantLock.hasQueuedThread()
  • concurrent.locks.ReentrantLock.hasQueuedThreads()
  • concurrent.locks.ReentrantLock.hasWaiters()
  • concurrent.locks.ReentrantLock.isFair()
  • concurrent.locks.ReentrantLock.isHeldByCurrentThread()
  • concurrent.locks.ReentrantLock.isLocked()
  • concurrent.locks.ReentrantLock.lock()
  • concurrent.locks.ReentrantLock.lockInterruptibly()
  • concurrent.locks.ReentrantLock.newCondition()
  • concurrent.locks.ReentrantLock.toString()
  • concurrent.locks.ReentrantLock.tryLock()
  • concurrent.locks.ReentrantLock.unlock()
  • concurrent.locks.ReentrantLock_FairSync
  • concurrent.locks.ReentrantLock_NonfairSync
  • concurrent.locks.ReentrantLock_Sync
  • concurrent.TimeoutException
  • concurrent.TimeUnit
  • concurrent.TimeUnit.DAYS
  • concurrent.TimeUnit.HOURS
  • concurrent.TimeUnit.MICROSECONDS
  • concurrent.TimeUnit.MILLISECONDS
  • concurrent.TimeUnit.MINUTES
  • concurrent.TimeUnit.NANOSECONDS
  • concurrent.TimeUnit.SECONDS

    • java.net

  • ContentHandler
  • ContentHandler.getContent()
  • ContentHandlerFactory
  • ContentHandlerFactory.createContentHandler()
  • DatagramPacket
  • DatagramPacket.getAddress()
  • DatagramPacket.getData()
  • DatagramPacket.getLength()
  • DatagramPacket.getOffset()
  • DatagramPacket.getPort()
  • DatagramPacket.getSocketAddress()
  • DatagramPacket.setAddress()
  • DatagramPacket.setData()
  • DatagramPacket.setLength()
  • DatagramPacket.setPort()
  • DatagramPacket.setSocketAddress()
  • DatagramSocket
  • DatagramSocket.bind()
  • DatagramSocket.close()
  • DatagramSocket.connect()
  • DatagramSocket.disconnect()
  • DatagramSocket.getBroadcast()
  • DatagramSocket.getChannel()
  • DatagramSocket.getInetAddress()
  • DatagramSocket.getLocalAddress()
  • DatagramSocket.getLocalPort()
  • DatagramSocket.getLocalSocketAddress()
  • DatagramSocket.getPort()
  • DatagramSocket.getReceiveBufferSize()
  • DatagramSocket.getRemoteSocketAddress()
  • DatagramSocket.getReuseAddress()
  • DatagramSocket.getSendBufferSize()
  • DatagramSocket.getSoTimeout()
  • DatagramSocket.getTrafficClass()
  • DatagramSocket.isBound()
  • DatagramSocket.isClosed()
  • DatagramSocket.isConnected()
  • DatagramSocket.receive()
  • DatagramSocket.send()
  • DatagramSocket.setBroadcast()
  • DatagramSocket.setDatagramSocketImplFactory()
  • DatagramSocket.setReceiveBufferSize()
  • DatagramSocket.setReuseAddress()
  • DatagramSocket.setSendBufferSize()
  • DatagramSocket.setSoTimeout()
  • DatagramSocket.setTrafficClass()
  • DatagramSocketImpl
  • DatagramSocketImpl.getOption()
  • DatagramSocketImpl.setOption()
  • DatagramSocketImplFactory
  • DatagramSocketImplFactory.createDatagramSocketImpl()
  • FileNameMap
  • FileNameMap.getContentTypeFor()
  • InetAddress
  • InetAddress.equals()
  • InetAddress.getAddress()
  • InetAddress.getAllByName()
  • InetAddress.getByAddress()
  • InetAddress.getByName()
  • InetAddress.getCanonicalHostName()
  • InetAddress.getHostAddress()
  • InetAddress.getHostName()
  • InetAddress.getLocalHost()
  • InetAddress.getLoopbackAddress()
  • InetAddress.hashCode()
  • InetAddress.isAnyLocalAddress()
  • InetAddress.isLinkLocalAddress()
  • InetAddress.isLoopbackAddress()
  • InetAddress.isMCGlobal()
  • InetAddress.isMCLinkLocal()
  • InetAddress.isMCNodeLocal()
  • InetAddress.isMCOrgLocal()
  • InetAddress.isMCSiteLocal()
  • InetAddress.isMulticastAddress()
  • InetAddress.isReachable()
  • InetAddress.isSiteLocalAddress()
  • InetAddress.toString()
  • InetAddress_Cache
  • InetAddress_Cache.get()
  • InetAddress_Cache.put()
  • InetAddress_CacheEntry
  • InetAddress_Cache_Type
  • InetAddress_Cache_Type.Negative
  • InetAddress_Cache_Type.Positive
  • InetSocketAddress
  • InetSocketAddress.createUnresolved()
  • InetSocketAddress.equals()
  • InetSocketAddress.getAddress()
  • InetSocketAddress.getHostName()
  • InetSocketAddress.getHostString()
  • InetSocketAddress.getPort()
  • InetSocketAddress.hashCode()
  • InetSocketAddress.isUnresolved()
  • InetSocketAddress.toString()
  • InetSocketAddress_1
  • InetSocketAddress_InetSocketAddressHolder
  • InetSocketAddress_InetSocketAddressHolder.equals()
  • InetSocketAddress_InetSocketAddressHolder.hashCode()
  • InetSocketAddress_InetSocketAddressHolder.toString()
  • InterfaceAddress
  • InterfaceAddress.equals()
  • InterfaceAddress.getAddress()
  • InterfaceAddress.getBroadcast()
  • InterfaceAddress.getNetworkPrefixLength()
  • InterfaceAddress.hashCode()
  • InterfaceAddress.toString()
  • MalformedURLException
  • NetworkInterface
  • NetworkInterface.equals()
  • NetworkInterface.getByIndex()
  • NetworkInterface.getByInetAddress()
  • NetworkInterface.getByName()
  • NetworkInterface.getDisplayName()
  • NetworkInterface.getHardwareAddress()
  • NetworkInterface.getIndex()
  • NetworkInterface.getInetAddresses()
  • NetworkInterface.getInterfaceAddresses()
  • NetworkInterface.getMTU()
  • NetworkInterface.getName()
  • NetworkInterface.getNetworkInterfaces()
  • NetworkInterface.getParent()
  • NetworkInterface.getSubInterfaces()
  • NetworkInterface.hashCode()
  • NetworkInterface.isLoopback()
  • NetworkInterface.isPointToPoint()
  • NetworkInterface.isUp()
  • NetworkInterface.isVirtual()
  • NetworkInterface.supportsMulticast()
  • NetworkInterface.toString()
  • ProtocolFamily
  • ProtocolFamily.name()
  • Proxy
  • Proxy.address()
  • Proxy.equals()
  • Proxy.hashCode()
  • Proxy.NO_PROXY
  • Proxy.toString()
  • Proxy.type()
  • Proxy_Type
  • Proxy_Type.DIRECT
  • Proxy_Type.HTTP
  • Proxy_Type.SOCKS
  • ServerSocket
  • ServerSocket.accept()
  • ServerSocket.bind()
  • ServerSocket.close()
  • ServerSocket.getChannel()
  • ServerSocket.getInetAddress()
  • ServerSocket.getLocalPort()
  • ServerSocket.getLocalSocketAddress()
  • ServerSocket.getReceiveBufferSize()
  • ServerSocket.getReuseAddress()
  • ServerSocket.getSoTimeout()
  • ServerSocket.isBound()
  • ServerSocket.isClosed()
  • ServerSocket.setPerformancePreferences()
  • ServerSocket.setReceiveBufferSize()
  • ServerSocket.setReuseAddress()
  • ServerSocket.setSocketFactory()
  • ServerSocket.setSoTimeout()
  • ServerSocket.toString()
  • Socket
  • Socket.bind()
  • Socket.close()
  • Socket.connect()
  • Socket.getChannel()
  • Socket.getInetAddress()
  • Socket.getInputStream()
  • Socket.getKeepAlive()
  • Socket.getLocalAddress()
  • Socket.getLocalPort()
  • Socket.getLocalSocketAddress()
  • Socket.getOOBInline()
  • Socket.getOutputStream()
  • Socket.getPort()
  • Socket.getReceiveBufferSize()
  • Socket.getRemoteSocketAddress()
  • Socket.getReuseAddress()
  • Socket.getSendBufferSize()
  • Socket.getSoLinger()
  • Socket.getSoTimeout()
  • Socket.getTcpNoDelay()
  • Socket.getTrafficClass()
  • Socket.isBound()
  • Socket.isClosed()
  • Socket.isConnected()
  • Socket.isInputShutdown()
  • Socket.isOutputShutdown()
  • Socket.sendUrgentData()
  • Socket.setKeepAlive()
  • Socket.setOOBInline()
  • Socket.setPerformancePreferences()
  • Socket.setReceiveBufferSize()
  • Socket.setReuseAddress()
  • Socket.setSendBufferSize()
  • Socket.setSocketImplFactory()
  • Socket.setSoLinger()
  • Socket.setSoTimeout()
  • Socket.setTcpNoDelay()
  • Socket.setTrafficClass()
  • Socket.shutdownInput()
  • Socket.shutdownOutput()
  • Socket.toString()
  • SocketAddress
  • SocketException
  • SocketImpl
  • SocketImpl.getOption()
  • SocketImpl.setOption()
  • SocketImpl.toString()
  • SocketImplFactory
  • SocketImplFactory.createSocketImpl()
  • SocketOption
  • SocketOption.name()
  • SocketOption.type()
  • SocketOptions
  • SocketOptions.getOption()
  • SocketOptions.setOption()
  • SocketOptions_Statics
  • SocketOptions_Statics.IP_MULTICAST_IF
  • SocketOptions_Statics.IP_MULTICAST_IF2
  • SocketOptions_Statics.IP_MULTICAST_LOOP
  • SocketOptions_Statics.IP_TOS
  • SocketOptions_Statics.SO_BINDADDR
  • SocketOptions_Statics.SO_BROADCAST
  • SocketOptions_Statics.SO_KEEPALIVE
  • SocketOptions_Statics.SO_LINGER
  • SocketOptions_Statics.SO_OOBINLINE
  • SocketOptions_Statics.SO_RCVBUF
  • SocketOptions_Statics.SO_REUSEADDR
  • SocketOptions_Statics.SO_SNDBUF
  • SocketOptions_Statics.SO_TIMEOUT
  • SocketOptions_Statics.TCP_NODELAY
  • SslSocket
  • UnknownHostException
  • URI
  • URI.compareTo()
  • URI.create()
  • URI.equals()
  • URI.getAuthority()
  • URI.getFragment()
  • URI.getHost()
  • URI.getPath()
  • URI.getPort()
  • URI.getQuery()
  • URI.getRawAuthority()
  • URI.getRawFragment()
  • URI.getRawPath()
  • URI.getRawQuery()
  • URI.getRawSchemeSpecificPart()
  • URI.getRawUserInfo()
  • URI.getScheme()
  • URI.getSchemeSpecificPart()
  • URI.getUserInfo()
  • URI.hashCode()
  • URI.isAbsolute()
  • URI.isOpaque()
  • URI.normalize()
  • URI.parseServerAuthority()
  • URI.relativize()
  • URI.resolve()
  • URI.toASCIIString()
  • URI.toString()
  • URI.toURL()
  • URISyntaxException
  • URISyntaxException.getIndex()
  • URISyntaxException.getInput()
  • URISyntaxException.getReason()
  • URI_Parser
  • URL
  • URL.equals()
  • URL.getAuthority()
  • URL.getContent()
  • URL.getDefaultPort()
  • URL.getFile()
  • URL.getHost()
  • URL.getPath()
  • URL.getPort()
  • URL.getProtocol()
  • URL.getQuery()
  • URL.getRef()
  • URL.getUserInfo()
  • URL.hashCode()
  • URL.openConnection()
  • URL.openStream()
  • URL.sameFile()
  • URL.setURLStreamHandlerFactory()
  • URL.toExternalForm()
  • URL.toString()
  • URL.toURI()
  • URLConnection
  • URLConnection.addRequestProperty()
  • URLConnection.connect()
  • URLConnection.getAllowUserInteraction()
  • URLConnection.getConnectTimeout()
  • URLConnection.getContent()
  • URLConnection.getContentEncoding()
  • URLConnection.getContentLength()
  • URLConnection.getContentLengthLong()
  • URLConnection.getContentType()
  • URLConnection.getDate()
  • URLConnection.getDefaultAllowUserInteraction()
  • URLConnection.getDefaultRequestProperty()
  • URLConnection.getDefaultUseCaches()
  • URLConnection.getDoInput()
  • URLConnection.getDoOutput()
  • URLConnection.getExpiration()
  • URLConnection.getFileNameMap()
  • URLConnection.getHeaderField()
  • URLConnection.getHeaderFieldDate()
  • URLConnection.getHeaderFieldInt()
  • URLConnection.getHeaderFieldKey()
  • URLConnection.getHeaderFieldLong()
  • URLConnection.getHeaderFields()
  • URLConnection.getIfModifiedSince()
  • URLConnection.getInputStream()
  • URLConnection.getLastModified()
  • URLConnection.getOutputStream()
  • URLConnection.getPermission()
  • URLConnection.getReadTimeout()
  • URLConnection.getRequestProperties()
  • URLConnection.getRequestProperty()
  • URLConnection.getURL()
  • URLConnection.getUseCaches()
  • URLConnection.guessContentTypeFromName()
  • URLConnection.guessContentTypeFromStream()
  • URLConnection.setAllowUserInteraction()
  • URLConnection.setConnectTimeout()
  • URLConnection.setContentHandlerFactory()
  • URLConnection.setDefaultAllowUserInteraction()
  • URLConnection.setDefaultRequestProperty()
  • URLConnection.setDefaultUseCaches()
  • URLConnection.setDoInput()
  • URLConnection.setDoOutput()
  • URLConnection.setFileNameMap()
  • URLConnection.setIfModifiedSince()
  • URLConnection.setReadTimeout()
  • URLConnection.setRequestProperty()
  • URLConnection.setUseCaches()
  • URLConnection.toString()
  • URLEncoder
  • URLEncoder.encode()
  • URLStreamHandler
  • URLStreamHandlerFactory
  • URLStreamHandlerFactory.createURLStreamHandler()

    • java.nio.file

  • file.AccessMode
  • file.AccessMode.EXECUTE
  • file.AccessMode.READ
  • file.AccessMode.WRITE
  • file.attribute.AttributeView
  • file.attribute.AttributeView.name()
  • file.attribute.BasicFileAttributes
  • file.attribute.BasicFileAttributes.creationTime()
  • file.attribute.BasicFileAttributes.fileKey()
  • file.attribute.BasicFileAttributes.isDirectory()
  • file.attribute.BasicFileAttributes.isOther()
  • file.attribute.BasicFileAttributes.isRegularFile()
  • file.attribute.BasicFileAttributes.isSymbolicLink()
  • file.attribute.BasicFileAttributes.lastAccessTime()
  • file.attribute.BasicFileAttributes.lastModifiedTime()
  • file.attribute.BasicFileAttributes.size()
  • file.attribute.FileAttribute
  • file.attribute.FileAttribute.name()
  • file.attribute.FileAttribute.value()
  • file.attribute.FileAttributeView
  • file.attribute.FileAttributeView.name()
  • file.attribute.FileStoreAttributeView
  • file.attribute.FileStoreAttributeView.name()
  • file.attribute.FileTime
  • file.attribute.FileTime.compareTo()
  • file.attribute.FileTime.equals()
  • file.attribute.FileTime.from()
  • file.attribute.FileTime.fromMillis()
  • file.attribute.FileTime.hashCode()
  • file.attribute.FileTime.to()
  • file.attribute.FileTime.toMillis()
  • file.attribute.FileTime.toString()
  • file.attribute.FileTime_1
  • file.attribute.FileTime_DaysAndNanos
  • file.attribute.FileTime_DaysAndNanos.compareTo()
  • file.attribute.FileTime_DaysAndNanos.equals()
  • file.attribute.FileTime_DaysAndNanos.hashCode()
  • file.attribute.GroupPrincipal
  • file.attribute.GroupPrincipal.getName()
  • file.attribute.UserPrincipal
  • file.attribute.UserPrincipal.getName()
  • file.attribute.UserPrincipalLookupService
  • file.attribute.UserPrincipalLookupService.lookupPrincipalByGroupName()
  • file.attribute.UserPrincipalLookupService.lookupPrincipalByName()
  • file.CopyOption
  • file.DirectoryStream
  • file.DirectoryStream.close()
  • file.DirectoryStream.iterator()
  • file.DirectoryStream_Filter
  • file.DirectoryStream_Filter.accept()
  • file.FileStore
  • file.FileStore.getAttribute()
  • file.FileStore.getFileStoreAttributeView()
  • file.FileStore.getTotalSpace()
  • file.FileStore.getUnallocatedSpace()
  • file.FileStore.getUsableSpace()
  • file.FileStore.isReadOnly()
  • file.FileStore.name()
  • file.FileStore.supportsFileAttributeView()
  • file.FileStore.type()
  • file.FileSystem
  • file.FileSystem.close()
  • file.FileSystem.getFileStores()
  • file.FileSystem.getPath()
  • file.FileSystem.getPathMatcher()
  • file.FileSystem.getRootDirectories()
  • file.FileSystem.getSeparator()
  • file.FileSystem.getUserPrincipalLookupService()
  • file.FileSystem.isOpen()
  • file.FileSystem.isReadOnly()
  • file.FileSystem.newWatchService()
  • file.FileSystem.provider()
  • file.FileSystem.supportedFileAttributeViews()
  • file.LinkOption
  • file.LinkOption.NOFOLLOW_LINKS
  • file.OpenOption
  • file.Path
  • file.Path.compareTo()
  • file.Path.endsWith()
  • file.Path.getFileName()
  • file.Path.getFileSystem()
  • file.Path.getName()
  • file.Path.getNameCount()
  • file.Path.getParent()
  • file.Path.getRoot()
  • file.Path.isAbsolute()
  • file.Path.iterator()
  • file.Path.normalize()
  • file.Path.register()
  • file.Path.relativize()
  • file.Path.resolve()
  • file.Path.resolveSibling()
  • file.Path.startsWith()
  • file.Path.subpath()
  • file.Path.toAbsolutePath()
  • file.Path.toFile()
  • file.Path.toRealPath()
  • file.Path.toUri()
  • file.PathMatcher
  • file.PathMatcher.matches()
  • file.spi.FileSystemProvider
  • file.spi.FileSystemProvider.checkAccess()
  • file.spi.FileSystemProvider.copy()
  • file.spi.FileSystemProvider.createDirectory()
  • file.spi.FileSystemProvider.createLink()
  • file.spi.FileSystemProvider.createSymbolicLink()
  • file.spi.FileSystemProvider.delete()
  • file.spi.FileSystemProvider.deleteIfExists()
  • file.spi.FileSystemProvider.getFileAttributeView()
  • file.spi.FileSystemProvider.getFileStore()
  • file.spi.FileSystemProvider.getFileSystem()
  • file.spi.FileSystemProvider.getPath()
  • file.spi.FileSystemProvider.getScheme()
  • file.spi.FileSystemProvider.installedProviders()
  • file.spi.FileSystemProvider.isHidden()
  • file.spi.FileSystemProvider.isSameFile()
  • file.spi.FileSystemProvider.move()
  • file.spi.FileSystemProvider.newAsynchronousFileChannel()
  • file.spi.FileSystemProvider.newByteChannel()
  • file.spi.FileSystemProvider.newDirectoryStream()
  • file.spi.FileSystemProvider.newFileChannel()
  • file.spi.FileSystemProvider.newFileSystem()
  • file.spi.FileSystemProvider.newInputStream()
  • file.spi.FileSystemProvider.newOutputStream()
  • file.spi.FileSystemProvider.readAttributes()
  • file.spi.FileSystemProvider.readSymbolicLink()
  • file.spi.FileSystemProvider.setAttribute()
  • file.Watchable
  • file.Watchable.register()
  • file.WatchEvent
  • file.WatchEvent.context()
  • file.WatchEvent.count()
  • file.WatchEvent.kind()
  • file.WatchEvent_Kind
  • file.WatchEvent_Kind.name()
  • file.WatchEvent_Kind.type()
  • file.WatchEvent_Modifier
  • file.WatchEvent_Modifier.name()
  • file.WatchKey
  • file.WatchKey.cancel()
  • file.WatchKey.isValid()
  • file.WatchKey.pollEvents()
  • file.WatchKey.reset()
  • file.WatchKey.watchable()
  • file.WatchService
  • file.WatchService.close()
  • file.WatchService.poll()
  • file.WatchService.take()

    • java.db

  • Jdbc
  • Jdbc.create()

    • java.util.logging

  • logging.ErrorManager
  • logging.Filter
  • logging.Filter.isLoggable()
  • logging.Formatter
  • logging.Formatter.format()
  • logging.Formatter.formatMessage()
  • logging.Formatter.getHead()
  • logging.Formatter.getTail()
  • logging.Handler
  • logging.Handler.close()
  • logging.Handler.flush()
  • logging.Handler.getEncoding()
  • logging.Handler.getErrorManager()
  • logging.Handler.getFilter()
  • logging.Handler.getFormatter()
  • logging.Handler.getLevel()
  • logging.Handler.isLoggable()
  • logging.Handler.publish()
  • logging.Handler.setEncoding()
  • logging.Handler.setErrorManager()
  • logging.Handler.setFilter()
  • logging.Handler.setFormatter()
  • logging.Handler.setLevel()
  • logging.Level
  • logging.Level.ALL
  • logging.Level.CONFIG
  • logging.Level.equals()
  • logging.Level.FINE
  • logging.Level.FINER
  • logging.Level.FINEST
  • logging.Level.getLocalizedName()
  • logging.Level.getName()
  • logging.Level.getResourceBundleName()
  • logging.Level.hashCode()
  • logging.Level.INFO
  • logging.Level.intValue()
  • logging.Level.OFF
  • logging.Level.parse()
  • logging.Level.SEVERE
  • logging.Level.toString()
  • logging.Level.WARNING
  • logging.Level_KnownLevel
  • logging.Logger
  • logging.Logger.addHandler()
  • logging.Logger.config()
  • logging.Logger.entering()
  • logging.Logger.exiting()
  • logging.Logger.fine()
  • logging.Logger.finer()
  • logging.Logger.finest()
  • logging.Logger.getAnonymousLogger()
  • logging.Logger.getFilter()
  • logging.Logger.getGlobal()
  • logging.Logger.getHandlers()
  • logging.Logger.getLevel()
  • logging.Logger.getLogger()
  • logging.Logger.getName()
  • logging.Logger.getParent()
  • logging.Logger.getResourceBundle()
  • logging.Logger.getResourceBundleName()
  • logging.Logger.getUseParentHandlers()
  • logging.Logger.global
  • logging.Logger.GLOBAL_LOGGER_NAME
  • logging.Logger.info()
  • logging.Logger.isLoggable()
  • logging.Logger.log()
  • logging.Logger.logp()
  • logging.Logger.logrb()
  • logging.Logger.removeHandler()
  • logging.Logger.setFilter()
  • logging.Logger.setLevel()
  • logging.Logger.setParent()
  • logging.Logger.setUseParentHandlers()
  • logging.Logger.severe()
  • logging.Logger.throwing()
  • logging.Logger.warning()
  • logging.Logger_SystemLoggerHelper
  • logging.LogRecord
  • logging.LogRecord.getLevel()
  • logging.LogRecord.getLoggerName()
  • logging.LogRecord.getMessage()
  • logging.LogRecord.getMillis()
  • logging.LogRecord.getParameters()
  • logging.LogRecord.getResourceBundle()
  • logging.LogRecord.getResourceBundleName()
  • logging.LogRecord.getSequenceNumber()
  • logging.LogRecord.getSourceClassName()
  • logging.LogRecord.getSourceMethodName()
  • logging.LogRecord.getThreadID()
  • logging.LogRecord.getThrown()
  • logging.LogRecord.setLevel()
  • logging.LogRecord.setLoggerName()
  • logging.LogRecord.setMessage()
  • logging.LogRecord.setMillis()
  • logging.LogRecord.setParameters()
  • logging.LogRecord.setResourceBundle()
  • logging.LogRecord.setResourceBundleName()
  • logging.LogRecord.setSequenceNumber()
  • logging.LogRecord.setSourceClassName()
  • logging.LogRecord.setSourceMethodName()
  • logging.LogRecord.setThreadID()
  • logging.LogRecord.setThrown()

    • java.lang.ref

  • ref.Reference
  • ref.Reference.clear()
  • ref.Reference.enqueue()
  • ref.Reference.get()
  • ref.Reference.isEnqueued()
  • ref.ReferenceQueue
  • ref.ReferenceQueue.poll()
  • ref.ReferenceQueue.remove()
  • ref.ReferenceQueue_1
  • ref.ReferenceQueue_Lock
  • ref.ReferenceQueue_Null
  • ref.Reference_1
  • ref.Reference_Lock
  • ref.Reference_ReferenceHandler
  • ref.SoftReference
  • ref.WeakReference

    • java.lang.reflect

  • reflect.AccessibleObject
  • reflect.AccessibleObject.getAnnotation()
  • reflect.AccessibleObject.getAnnotations()
  • reflect.AccessibleObject.getDeclaredAnnotations()
  • reflect.AccessibleObject.isAccessible()
  • reflect.AccessibleObject.isAnnotationPresent()
  • reflect.AccessibleObject.setAccessible()
  • reflect.AccessibleObject._setAccessible()
  • reflect.AnnotatedElement
  • reflect.AnnotatedElement.getAnnotation()
  • reflect.AnnotatedElement.getAnnotations()
  • reflect.AnnotatedElement.getDeclaredAnnotations()
  • reflect.AnnotatedElement.isAnnotationPresent()
  • reflect.Constructor
  • reflect.Constructor.equals()
  • reflect.Constructor.getDeclaringClass()
  • reflect.Constructor.getExceptionTypes()
  • reflect.Constructor.getGenericExceptionTypes()
  • reflect.Constructor.getGenericParameterTypes()
  • reflect.Constructor.getModifiers()
  • reflect.Constructor.getName()
  • reflect.Constructor.getParameterAnnotations()
  • reflect.Constructor.getParameterTypes()
  • reflect.Constructor.getTypeParameters()
  • reflect.Constructor.hashCode()
  • reflect.Constructor.isSynthetic()
  • reflect.Constructor.isVarArgs()
  • reflect.Constructor.newInstance()
  • reflect.Constructor.toGenericString()
  • reflect.Constructor.toString()
  • reflect.Field
  • reflect.Field.equals()
  • reflect.Field.get()
  • reflect.Field.getBoolean()
  • reflect.Field.getByte()
  • reflect.Field.getChar()
  • reflect.Field.getDeclaringClass()
  • reflect.Field.getDouble()
  • reflect.Field.getFloat()
  • reflect.Field.getGenericType()
  • reflect.Field.getInt()
  • reflect.Field.getLong()
  • reflect.Field.getModifiers()
  • reflect.Field.getName()
  • reflect.Field.getShort()
  • reflect.Field.getType()
  • reflect.Field.hashCode()
  • reflect.Field.isEnumConstant()
  • reflect.Field.isSynthetic()
  • reflect.Field.set()
  • reflect.Field.setBoolean()
  • reflect.Field.setByte()
  • reflect.Field.setChar()
  • reflect.Field.setDouble()
  • reflect.Field.setFloat()
  • reflect.Field.setInt()
  • reflect.Field.setLong()
  • reflect.Field.setShort()
  • reflect.Field.toGenericString()
  • reflect.Field.toString()
  • reflect.GenericDeclaration
  • reflect.GenericDeclaration.getTypeParameters()
  • reflect.InvocationTargetException
  • reflect.InvocationTargetException.getTargetException()
  • reflect.Member
  • reflect.Member.getDeclaringClass()
  • reflect.Member.getModifiers()
  • reflect.Member.getName()
  • reflect.Member.isSynthetic()
  • reflect.Member_Statics
  • reflect.Member_Statics.DECLARED
  • reflect.Member_Statics.PUBLIC
  • reflect.Method
  • reflect.Method.equals()
  • reflect.Method.getDeclaringClass()
  • reflect.Method.getDefaultValue()
  • reflect.Method.getExceptionTypes()
  • reflect.Method.getGenericExceptionTypes()
  • reflect.Method.getGenericParameterTypes()
  • reflect.Method.getGenericReturnType()
  • reflect.Method.getModifiers()
  • reflect.Method.getName()
  • reflect.Method.getParameterAnnotations()
  • reflect.Method.getParameterTypes()
  • reflect.Method.getReturnType()
  • reflect.Method.getTypeParameters()
  • reflect.Method.hashCode()
  • reflect.Method.invoke()
  • reflect.Method.isBridge()
  • reflect.Method.isSynthetic()
  • reflect.Method.isVarArgs()
  • reflect.Method.toGenericString()
  • reflect.Method.toString()
  • reflect.Type
  • reflect.TypeVariable
  • reflect.TypeVariable.getBounds()
  • reflect.TypeVariable.getGenericDeclaration()
  • reflect.TypeVariable.getName()

    • java.util.regex

  • regex.Matcher
  • regex.Matcher.appendReplacement()
  • regex.Matcher.appendTail()
  • regex.Matcher.end()
  • regex.Matcher.find()
  • regex.Matcher.group()
  • regex.Matcher.groupCount()
  • regex.Matcher.hasAnchoringBounds()
  • regex.Matcher.hasTransparentBounds()
  • regex.Matcher.hitEnd()
  • regex.Matcher.lookingAt()
  • regex.Matcher.matches()
  • regex.Matcher.pattern()
  • regex.Matcher.quoteReplacement()
  • regex.Matcher.region()
  • regex.Matcher.regionEnd()
  • regex.Matcher.regionStart()
  • regex.Matcher.replaceAll()
  • regex.Matcher.replaceFirst()
  • regex.Matcher.requireEnd()
  • regex.Matcher.reset()
  • regex.Matcher.start()
  • regex.Matcher.toMatchResult()
  • regex.Matcher.toString()
  • regex.Matcher.useAnchoringBounds()
  • regex.Matcher.usePattern()
  • regex.Matcher.useTransparentBounds()
  • regex.MatchResult
  • regex.MatchResult.end()
  • regex.MatchResult.group()
  • regex.MatchResult.groupCount()
  • regex.MatchResult.start()
  • regex.Pattern
  • regex.Pattern.CANON_EQ
  • regex.Pattern.CASE_INSENSITIVE
  • regex.Pattern.COMMENTS
  • regex.Pattern.compile()
  • regex.Pattern.DOTALL
  • regex.Pattern.flags()
  • regex.Pattern.LITERAL
  • regex.Pattern.matcher()
  • regex.Pattern.matches()
  • regex.Pattern.MULTILINE
  • regex.Pattern.pattern()
  • regex.Pattern.quote()
  • regex.Pattern.split()
  • regex.Pattern.toString()
  • regex.Pattern.UNICODE_CASE
  • regex.Pattern.UNICODE_CHARACTER_CLASS
  • regex.Pattern.UNIX_LINES
  • regex.Pattern._compile()
  • regex.Pattern_All
  • regex.Pattern_BackRef
  • regex.Pattern_Begin
  • regex.Pattern_Behind
  • regex.Pattern_BehindS
  • regex.Pattern_BitClass
  • regex.Pattern_Block
  • regex.Pattern_BmpCharProperty
  • regex.Pattern_BnM
  • regex.Pattern_BnMS
  • regex.Pattern_Bound
  • regex.Pattern_Branch
  • regex.Pattern_BranchConn
  • regex.Pattern_Caret
  • regex.Pattern_Category
  • regex.Pattern_CharProperty
  • regex.Pattern_CharPropertyNames
  • regex.Pattern_CharPropertyNames_CharPropertyFactory
  • regex.Pattern_CharPropertyNames_CloneableProperty
  • regex.Pattern_CharPropertyNames_CloneableProperty.clone()
  • regex.Pattern_CIBackRef
  • regex.Pattern_Conditional
  • regex.Pattern_Ctype
  • regex.Pattern_Curly
  • regex.Pattern_Dollar
  • regex.Pattern_Dot
  • regex.Pattern_End
  • regex.Pattern_First
  • regex.Pattern_GroupCurly
  • regex.Pattern_GroupHead
  • regex.Pattern_GroupRef
  • regex.Pattern_GroupTail
  • regex.Pattern_LastMatch
  • regex.Pattern_LastNode
  • regex.Pattern_LazyLoop
  • regex.Pattern_Loop
  • regex.Pattern_Neg
  • regex.Pattern_Node
  • regex.Pattern_NotBehind
  • regex.Pattern_NotBehindS
  • regex.Pattern_Pos
  • regex.Pattern_Prolog
  • regex.Pattern_Ques
  • regex.Pattern_Script
  • regex.Pattern_Single
  • regex.Pattern_SingleI
  • regex.Pattern_SingleS
  • regex.Pattern_SingleU
  • regex.Pattern_Slice
  • regex.Pattern_SliceI
  • regex.Pattern_SliceIS
  • regex.Pattern_SliceNode
  • regex.Pattern_SliceS
  • regex.Pattern_SliceU
  • regex.Pattern_SliceUS
  • regex.Pattern_Start
  • regex.Pattern_StartS
  • regex.Pattern_TreeInfo
  • regex.Pattern_UnixCaret
  • regex.Pattern_UnixDollar
  • regex.Pattern_UnixDot
  • regex.Pattern_Utype

    • java.util.spi

  • spi.LocaleNameProvider
  • spi.LocaleNameProvider.getDisplayCountry()
  • spi.LocaleNameProvider.getDisplayLanguage()
  • spi.LocaleNameProvider.getDisplayScript()
  • spi.LocaleNameProvider.getDisplayVariant()
  • spi.LocaleServiceProvider
  • spi.LocaleServiceProvider.getAvailableLocales()

    • java.sun.util

  • util.locale.BaseLocale
  • util.locale.BaseLocale.createInstance()
  • util.locale.BaseLocale.equals()
  • util.locale.BaseLocale.getInstance()
  • util.locale.BaseLocale.getLanguage()
  • util.locale.BaseLocale.getRegion()
  • util.locale.BaseLocale.getScript()
  • util.locale.BaseLocale.getVariant()
  • util.locale.BaseLocale.hashCode()
  • util.locale.BaseLocale.SEP
  • util.locale.BaseLocale.toString()
  • util.locale.BaseLocale_1
  • util.locale.BaseLocale_Cache
  • util.locale.BaseLocale_Key
  • util.locale.BaseLocale_Key.compareTo()
  • util.locale.BaseLocale_Key.equals()
  • util.locale.BaseLocale_Key.hashCode()
  • util.locale.BaseLocale_Key.normalize()
  • util.locale.LocaleObjectCache
  • util.locale.LocaleObjectCache.get()
  • util.locale.LocaleObjectCache_CacheEntry
  • util.LocaleServiceProviderPool
  • util.LocaleServiceProviderPool.getAllAvailableLocales()
  • util.LocaleServiceProviderPool.getAvailableLocales()
  • util.LocaleServiceProviderPool.getLocalizedObject()
  • util.LocaleServiceProviderPool.getPool()
  • util.LocaleServiceProviderPool.hasProviders()
  • util.LocaleServiceProviderPool_AllAvailableLocales
  • util.LocaleServiceProviderPool_LocalizedObjectGetter
  • util.LocaleServiceProviderPool_LocalizedObjectGetter.getObject()
  • util.LocaleServiceProviderPool_NullProvider
  • util.resources.OpenListResourceBundle
  • util.resources.OpenListResourceBundle.getParent()
  • util.resources.OpenListResourceBundle.handleGetKeys()

    • java.util.zip

  • zip.DataFormatException
  • zip.Deflater
  • zip.Deflater.BEST_COMPRESSION
  • zip.Deflater.BEST_SPEED
  • zip.Deflater.DEFAULT_COMPRESSION
  • zip.Deflater.DEFAULT_STRATEGY
  • zip.Deflater.deflate()
  • zip.Deflater.DEFLATED
  • zip.Deflater.end()
  • zip.Deflater.FILTERED
  • zip.Deflater.finish()
  • zip.Deflater.finished()
  • zip.Deflater.FULL_FLUSH
  • zip.Deflater.getAdler()
  • zip.Deflater.getBytesRead()
  • zip.Deflater.getBytesWritten()
  • zip.Deflater.getTotalIn()
  • zip.Deflater.getTotalOut()
  • zip.Deflater.HUFFMAN_ONLY
  • zip.Deflater.needsInput()
  • zip.Deflater.NO_COMPRESSION
  • zip.Deflater.NO_FLUSH
  • zip.Deflater.reset()
  • zip.Deflater.setDictionary()
  • zip.Deflater.setInput()
  • zip.Deflater.setLevel()
  • zip.Deflater.setStrategy()
  • zip.Deflater.SYNC_FLUSH
  • zip.Inflater
  • zip.Inflater.end()
  • zip.Inflater.finished()
  • zip.Inflater.getAdler()
  • zip.Inflater.getBytesRead()
  • zip.Inflater.getBytesWritten()
  • zip.Inflater.getRemaining()
  • zip.Inflater.getTotalIn()
  • zip.Inflater.getTotalOut()
  • zip.Inflater.inflate()
  • zip.Inflater.needsDictionary()
  • zip.Inflater.needsInput()
  • zip.Inflater.reset()
  • zip.Inflater.setDictionary()
  • zip.Inflater.setInput()

    • Index

  • index

    • Copyright©2021 w3cschool编程狮 闽ICP备15016281号-3 闽公网安备35020302033924号