JSSE Reference Guide for Java SE 6

JavaTM Secure Socket Extension (JSSE)

Reference Guide

for JavaTM Platform Standard Edition 6

Introduction
Features and Benefits
JSSE Standard API
SunJSSE Provider
Related Documentation
Terms and Definitions
Secure Sockets Layer (SSL) Protocol Overview
Why Use SSL?
How SSL Works
Key Classes
Relationship Between Classes
Core Classes and Interfaces
SocketFactory and ServerSocketFactory Classes
SSLSocketFactory and SSLServerSocketFactory Classes
SSLSocket and SSLServerSocket Classes
Non-blocking I/O with SSLEngine
SSLSession Interface
HttpsURLConnection Class
Support Classes and Interfaces
SSLContext Class
TrustManager Interface
TrustManagerFactory Class
X509TrustManager Interface
KeyManager Interface
KeyManagerFactory Class
X509KeyManager Interface
Relationships between TrustManagers and KeyManagers
Secondary Support Classes and Interfaces
SSLSessionContext Interface
SSLSessionBindingListener Interface
SSLSessionBindingEvent Class
HandShakeCompletedListener Interface
HandShakeCompletedEvent Class
HostnameVerifier Interface
X509Certificate Class
Previous (JSSE 1.0.x) Implementation Classes and Interfaces
Customizing JSSE
The Installation Directory <java-home>
Customization
JCE and Hardware Acceleration/Smartcard Support
Use of JCE
Hardware Accelerators
Configure JSSE to use Smartcards as Keystore and Trust Stores
Multiple and Dynamic Keystores

Kerberos Cipher Suites
Kerberos Requirements
Peer Identity Information
Security Manager

Additional Keystore Formats (PKCS12)

Troubleshooting
Configuration Problems
Debugging Utilities
Code Examples
Converting an Unsecure Socket to a Secure Socket
Running the JSSE Sample Code
Creating a Keystore to Use with JSSE
Appendix A: Standard Names

Appendix B: Provider Pluggability

Introduction

Data that travels across a network can easily be accessed by someone who is not the intended recipient. When the data includes private information, such as passwords and credit card numbers, steps must be taken to make the data unintelligible to unauthorized parties. It is also important to ensure the data has not been modified, either intentionally or unintentionally, during transport. The Secure Sockets Layer (SSL) and Transport Layer Security (TLS) protocols were designed to help protect the privacy and integrity of data while it is transferred across a network.

The Java Secure Socket Extension (JSSE) enables secure Internet communications. It provides a framework and an implementation for a Java version of the SSL and TLS protocols and includes functionality for data encryption, server authentication, message integrity, and optional client authentication. Using JSSE, developers can provide for the secure passage of data between a client and a server running any application protocol, such as Hypertext Transfer Protocol (HTTP), Telnet, or FTP, over TCP/IP. (For an introduction to SSL, see Secure Sockets Layer (SSL) Protocol Overview.)

By abstracting the complex underlying security algorithms and "handshaking" mechanisms, JSSE minimizes the risk of creating subtle, but dangerous security vulnerabilities. Furthermore, it simplifies application development by serving as a building block which developers can integrate directly into their applications.

JSSE was previously an an optional package to the JavaTM 2 SDK, Standard Edition (J2SDK), v 1.3. JSSE was integrated into the Java TM Standard Edition Development Kit starting with J2SDK 1.4.

JSSE provides both an application programming interface (API) framework and an implementation of that API. The JSSE API supplements the "core" network and cryptographic services defined by the java.security and java.net packages by providing extended networking socket classes, trust managers, key managers, SSLContexts, and a socket factory framework for encapsulating socket creation behavior. Because the socket APIs were based on a blocking I/O model, in JDK 5.0, a non-blocking SSLEngineAPI was introduced to allow implementations to choose their own I/O methods.

The JSSE API is capable of supporting SSL versions 2.0 and 3.0 and Transport Layer Security (TLS) 1.0. These security protocols encapsulate a normal bidirectional stream socket and the JSSE API adds transparent support for authentication, encryption, and integrity protection. The JSSE implementation shipped with Sun's JRE supports SSL 3.0 and TLS 1.0. It does not implement SSL 2.0.

As mentioned above, JSSE is a security component of the Java SE 6 platform, and is based on the same design principles found elsewhere in the Java Cryptography Architecture (JCA) framework. This framework for cryptography-related security components allows them to have implementation independence and, whenever possible, algorithm independence. JSSE uses the same "provider" architecture defined in the JCA.

Other security components in the Java SE 6 platform include the Java Cryptography Extension (JCE), the Java Authentication and Authorization Service (JAAS), and the Java Security Tools. JSSE encompasses many of the same concepts and algorithms as those in JCE but automatically applies them underneath a simple stream socket API.

The JSSE APIs were designed to allow other SSL/TLS protocol and Public Key Infrastructure (PKI) implementations to be plugged in seamlessly. Developers can also provide alternate logic for determining if remote hosts should be trusted or what authentication key material should be sent to a remote host.

Features and Benefits

JSSE includes the following important features:

  • Included as a standard component of JRE 1.4 and later

  • Extensible, provider based architecture

  • Implemented in 100% Pure Java

  • Provides API support for SSL versions 2.0 and 3.0, TLS 1.0 and later; and an implementation of SSL 3.0 and TLS 1.0

  • Includes classes that can be instantiated to create secure channels (SSLSocket, SSLServerSocket, and SSLEngine)

  • Provides support for cipher suite negotiation, which is part of the SSL handshaking used to initiate or verify secure communications

  • Provides support for client and server authentication, which is part of the normal SSL handshaking

  • Provides support for Hypertext Transfer Protocol (HTTP) encapsulated in the SSL protocol (HTTPS), which allows access to data such as web pages using HTTPS

  • Provides server session management APIs to manage memory-resident SSL sessions

  • Provides support for several cryptographic algorithms commonly used in cipher suites, including those listed in the following table:

Cryptographic Functionality Available With JSSE

Cryptographic Algorithm *

Cryptographic Process

Key Lengths (Bits)

RSA

Authentication and key exchange

512 and larger

RC4

Bulk encryption

128
128 (40 effective)

DES

Bulk encryption

64 (56 effective)
64 (40 effective)

Triple DES

Bulk encryption

192 (112 effective)

AES

Bulk encryption

256
128

Diffie-Hellman

Key agreement

1024
512

DSA

Authentication

1024

* Note: The SunJSSE implementation uses the JavaTM Cryptography Extension (JCE) for all of its cryptographic algorithms.

JSSE Standard API

The JSSE standard API, available in the javax.net and javax.net.ssl packages, covers:

  • Secure (SSL) sockets and server sockets.

  • A non-blocking engine for producing and consuming streams of SSL/TLS data (SSLEngine).

  • Factories for creating sockets, server sockets, SSL sockets, and SSL server sockets. Using socket factories you can encapsulate socket creation and configuration behavior.

  • A class representing a secure socket context that acts as a factory for secure socket factories and engines.

  • Key and trust manager interfaces (including X.509-specific key and trust managers), and factories that can be used for creating them.

  • A class for secure HTTP URL connections (HTTPS).

SunJSSE Provider

Sun's implementation of Java SE includes a JSSE provider named "SunJSSE", which comes pre-installed and pre-registered with the JCA. This provider supplies the following cryptographic services:

  • An implementation of the SSL 3.0 and TLS 1.0 security protocols.

  • An implementation of the most common SSL and TLS cipher suites which encompass a combination of authentication, key agreement, encryption and integrity protection.

  • An implementation of an X.509-based key manager which chooses appropriate authentication keys from a standard JCA KeyStore.

  • An implementation of an X.509-based trust manager which implements rules for certificate chain path validation.

  • An implementation of PKCS12 as JCA keystore type "pkcs12". Storing trusted anchors in PKCS12 is not supported. Users should store trust anchors in JKS format and save private keys in PKCS12 format.

More information about this provider is available in the SunJSSE section.

Related Documentation

Java Secure Socket Extension Documentation

  • The JSSE home page, with links to JavaOneSM conference slides, the JSSE FAQ, legal issues, etc.:
    http://java.sun.com/products/jsse/

  • Archive of API-related questions and answers posted to Sun's Java Security team through java-security@sun.com:
    http://archives.java.sun.com/archives/java-security.html

    Note: The above mailing list is not a subscription list or a support mechanism. It is simply a one-way channel that you can use to send comments to the Java SE 6 Standard Edition security team.

  • JSSE API documentation:
    • javax.net package
    • javax.net.ssl package
    • javax.security.cert package

Java Platform Security Documentation

  • Java security homepage:
    http://java.sun.com/security/

  • The JavaTM Certification Path API Programmer's Guide:
    http://java.sun.com/javase/6/docs/technotes/guides/security/certpath/CertPathProgGuide.html

  • Links to more Java SE 6 platform security documents:
    http://java.sun.com/javase/6/docs/technotes/guides/security/

  • Tutorial for Java platform security:
    http://java.sun.com/docs/books/tutorial/security/

  • Book on Java SE platform security:
    Inside Java 2 Platform Security: Architecture, API Design, and Implementation by Li Gong. Addison Wesley Longman, Inc., 1999. ISBN: 0201310007. http://java.sun.com/docs/books/security/index.html

Export Issues Related to Cryptography

For information on U.S. encryption policies, refer to these Web sites:

  • U.S. Department of Commerce:
    http://www.commerce.gov

  • Export Policy Resource Page:
    http://www.crypto.com/

  • Computer Systems Public Policy:
    http://www.cspp.org/

  • Federal Information Processing Standards Publications (FIPS PUBS) homepage, which has links to the Data Encryption Standard (DES):
    http://www.itl.nist.gov/fipspubs/

  • Revised U.S. Encryption Export Control Regulations:
    http://www.epic.org/crypto/export_controls/regs_1_00.html

Cryptography Documentation

Online resources:

  • Dr. Rivest's Cryptography and Security page:
    http://theory.lcs.mit.edu/~rivest/crypto-security.html

Books:

  • Applied Cryptography, Second Edition by Bruce Schneier. John Wiley and Sons, Inc., 1996.

  • Cryptography Theory and Practice by Doug Stinson. CRC Press, Inc., 1995.

  • Cryptography & Network Security: Principles & Practice by William Stallings. Prentice Hall, 1998.

Secure Sockets Layer Documentation

Online resources:

  • Introduction to SSL from Sun™ ONE Software:
    http://docs.sun.com/source/816-6156-10/contents.htm

  • The SSL Protocol version 3.0 Internet Draft:
    http://wp.netscape.com/eng/ssl3/ssl-toc.html

  • The TLS Protocol version 1.0 RFC:
    http://www.ietf.org/rfc/rfc2246.txt

  • "HTTP Over TLS" Information RFC:
    http://www.ietf.org/rfc/rfc2818.txt

Books:

  • SSL and TLS: Designing and Building Secure Systems by Eric Rescorla. Addison Wesley Professional, 2000.

  • SSL and TLS Essentials: Securing the Web by Stephen Thomas. John Wiley and Sons, Inc., 2000.

  • Java 2 Network Security, Second Edition, by Marco Pistoia, Duane F Reller, Deepak Gupta, Milind Nagnur, and Ashok K Ramani. Prentice Hall, 1999. Copyright 1999 International Business Machines.

Terms and Definitions

There are several terms relating to cryptography that are used within this document. This section defines some of these terms.

Authentication

Authentication is the process of confirming the identity of a party with whom one is communicating.

Cipher Suite

A cipher suite is a combination of cryptographic parameters that define the security algorithms and key sizes used for authentication, key agreement, encryption, and integrity protection.

Certificate

A certificate is a digitally signed statement vouching for the identity and public key of an entity (person, company, etc.). Certificates can either be self-signed or issued by a Certification Authority (CA). Certification Authorities are entities that are trusted to issue valid certificates for other entities. Well-known CAs include VeriSign, Entrust, and GTE CyberTrust. X509 is a common certificate format, and they can be managed by the JDK's keytool.

Cryptographic Hash Function

A cryptographic hash function is similar to a checksum. Data is processed with an algorithm that produces a relatively small string of bits called a hash. A cryptographic hash function has three primary characteristics: it is a one-way function, meaning that it is not possible to produce the original data from the hash; a small change in the original data produces a large change in the resulting hash; and it does not require a cryptographic key.

Cryptographic Service Provider

In the JCA, implementations for various cryptographic algorithms are provided by cryptographic service providers, or "providers" for short. Providers are essentially packages that implement one or more engine classes for specific algorithms. An engine class defines a cryptographic service in an abstract fashion without a concrete implementation.

Digital Signature

A digital signature is the digital equivalent of a handwritten signature. It is used to ensure that data transmitted over a network was sent by whoever claims to have sent it and that the data has not been modified in transit. For example, an RSA-based digital signature is calculated by first computing a cryptographic hash of the data and then encrypting the hash with the sender's private key.

Encryption and Decryption

Encryption is the process of using a complex algorithm to convert an original message, or cleartext, to an encoded message, called ciphertext, that is unintelligible unless it is decrypted. Decryption is the inverse process of producing cleartext from ciphertext. The algorithms used to encrypt and decrypt data typically come in two categories: secret key (symmetric) cryptography and public key (asymmetric) cryptography.

Handshake Protocol

The negotiation phase during which the two socket peers agree to use a new or existing session. The handshake protocol is a series of messages exchanged over the record protocol. At the end of the handshake new connection-specific encryption and integrity protection keys are generated based on the key agreement secrets in the session.

Key Agreement

Key agreement is a method by which two parties cooperate to establish a common key. Each side generates some data which is exchanged. These two pieces of data are then combined to generate a key. Only those holding the proper private initialization data will be able to obtain the final key. Diffie-Hellman (DH) is the most common example of a key agreement algorithm.

Key Exchange

One side generates a symmetric key and encrypts it using the peer's public key (typcially RSA). The data is then transmitted to the peer, who then decrypts the key using its corresponding private key.

Key Managers and Trust Managers

Key managers and trust managers use keystores for their key material. A key manager manages a keystore and supplies public keys to others as needed, e.g., for use in authenticating the user to others. A trust manager makes decisions about who to trust based on information in the truststore it manages.

Keystores and Truststores

A keystore is a database of key material. Key material is used for a variety of purposes, including authentication and data integrity. There are various types of keystores available, including "PKCS12" and Sun's "JKS."

Generally speaking, keystore information can be grouped into two different categories: key entries and trusted certificate entries. A key entry consists of an entity's identity and its private key, and can be used for a variety of cryptographic purposes. In contrast, a trusted certificate entry only contains a public key in addition to the entity's identity. Thus, a trusted certificate entry can not be used where a private key is required, such as in a javax.net.ssl.KeyManager. In the JDK implementation of "JKS", a keystore may contain both key entries and trusted certificate entries.

A truststore is a keystore which is used when making decisions about what to trust. If you receive some data from an entity that you already trust, and if you can verify that the entity is the one it claims to be, then you can assume that the data really came from that entity.

An entry should only be added to a truststore if the user makes a decision to trust that entity. By either generating a keypair or by importing a certificate, the user has given trust to that entry, and thus any entry in the keystore is considered a trusted entry.

It may be useful to have two different keystore files: one containing just your key entries, and the other containing your trusted certificate entries, including Certification Authority (CA) certificates. The former contains private information, while the latter does not. Using two different files instead of a single keystore file provides for a cleaner separation of the logical distinction between your own certificates (and corresponding private keys) and others' certificates. You could provide more protection for your private keys if you store them in a keystore with restricted access, while providing the trusted certificates in a more publicly accessible keystore if needed.

Message Authentication Code

A Message Authentication Code (MAC) provides a way to check the integrity of information transmitted over or stored in an unreliable medium, based on a secret key. Typically, MACs are used between two parties that share a secret key in order to validate information transmitted between these parties.

A MAC mechanism that is based on cryptographic hash functions is referred to as HMAC. HMAC can be used with any cryptographic hash function, such as Message Digest 5 (MD5) and Secure Hash Algorithm (SHA), in combination with a secret shared key. HMAC is specified in RFC 2104.

Public Key Cryptography

Public key cryptography uses an encryption algorithm in which two keys are produced. One key is made public while the other is kept private. The public key and the private key are cryptographic inverses; what one key encrypts only the other key can decrypt. Public key cryptography is also called asymmetric cryptography.

Record Protocol

The record protocol packages all data whether application-level or as part of the handshake process into discrete records of data much like a TCP stream socket converts an application byte stream into network packets. The individual records are then protected by the current encryption and integrity protection keys.

Secret Key Cryptography

Secret key cryptography uses an encryption algorithm in which the same key is used both to encrypt and decrypt the data. Secret key cryptography is also called symmetric cryptography.

Session

A session is a named collection of state information including authenticated peer identity, cipher suite, and key agreement secrets which are negotiated through a secure socket handshake and which can be shared among multiple secure socket instances.

Trust Managers

See Key Managers and Trust Managers.

Truststore

See Keystores and Truststores.

Secure Sockets Layer (SSL) Protocol Overview

Secure Sockets Layer (SSL) is the most widely used protocol for implementing cryptography on the Web. SSL uses a combination of cryptographic processes to provide secure communication over a network. This section provides an introduction to SSL and the cryptographic processes it uses.

SSL provides a secure enhancement to the standard TCP/IP sockets protocol used for Internet communications. As shown in the "TCP/IP Protocol Stack With SSL" figure below, the secure sockets layer is added between the transport layer and the application layer in the standard TCP/IP protocol stack. The application most commonly used with SSL is Hypertext Transfer Protocol (HTTP), the protocol for Internet Web pages. Other applications, such as Net News Transfer Protocol (NNTP), Telnet, Lightweight Directory Access Protocol (LDAP), Interactive Message Access Protocol (IMAP), and File Transfer Protocol (FTP), can be used with SSL as well.

Note: There is currently no standard for secure FTP.

TCP/IP Protocol Stack With SSL

TCP/IP Layer

Protocol

Application Layer

HTTP, NNTP, Telnet, FTP, etc.

Secure Sockets Layer

SSL

Transport Layer

TCP

Internet Layer

IP

SSL was developed by Netscape in 1994, and with input from the Internet community, has evolved to become a standard. It is now under the control of the international standards organization, the Internet Engineering Task Force (IETF). The IETF has renamed SSL to Transport Layer Security (TLS), and released the first specification, version 1.0, in January 1999. TLS 1.0 is a modest upgrade to the most recent version of SSL, version 3.0. The differences between SSL 3.0 and TLS 1.0 are minor.

Why Use SSL?

Transferring sensitive information over a network can be risky due to the following three issues:
  • You cannot always be sure that the entity with whom you are communicating is really who you think it is.

  • Network data can be intercepted, so it is possible that it can be read by an unauthorized third party, sometimes known as an attacker.

  • If an attacker can intercept the data, the attacker may be able to modify the data before sending it on to the receiver.

SSL addresses each of these issues. It addresses the first issue by optionally allowing each of two communicating parties to ensure the identity of the other party in a process called authentication. Once the parties are authenticated, SSL provides an encrypted connection between the two parties for secure message transmission. Encrypting the communication between the two parties provides privacy and therefore addresses the second issue. The encryption algorithms used with SSL include a secure hash function, which is similar to a checksum. This ensures that data is not modified in transit. The secure hash function addresses the third issue of data integrity.

Note, both authentication and encryption are optional, and depend on the the negotiated cipher suites between the two entities.

The most obvious example of when you would use SSL is in an e-commerce transaction. In an e-commerce transaction, it would be foolish to assume that you can guarantee the identity of the server with whom you are communicating. It would be easy enough for someone to create a phony Web site promising great services if only you enter your credit card number. SSL allows you, the client, to authenticate the identity of the server. It also allows the server to authenticate the identity of the client, although in Internet transactions, this is seldom done.

Once the client and the server are comfortable with each other's identity, SSL provides privacy and data integrity through the encryption algorithms it uses. This allows sensitive information, such as credit card numbers, to be transmitted securely over the Internet.

While SSL provides authentication, privacy, and data integrity, it does not provide non-repudiation services. Non-repudiation means that an entity that sends a message cannot later deny that they sent it. When the digital equivalent of a signature is associated with a message, the communication can later be proved. SSL alone does not provide non-repudiation.

How SSL Works

One of the reasons SSL is effective is that it uses several different cryptographic processes. SSL uses public key cryptography to provide authentication, and secret key cryptography and digital signatures to provide for privacy and data integrity. Before you can understand SSL, it is helpful to understand these cryptographic processes.

Cryptographic Processes

The primary purpose of cryptography is to make it difficult for an unauthorized third party to access and understand private communication between two parties. It is not always possible to restrict all unauthorized access to data, but private data can be made unintelligible to unauthorized parties through the process of encryption. Encryption uses complex algorithms to convert the original message, or cleartext, to an encoded message, called ciphertext. The algorithms used to encrypt and decrypt data that is transferred over a network typically come in two categories: secret key cryptography and public key cryptography. These forms of cryptography are explained in the following subsections.

Both secret key cryptography and public key cryptography depend on the use of an agreed-upon cryptographic key or pair of keys. A key is a string of bits that is used by the cryptographic algorithm or algorithms during the process of encrypting and decrypting the data. A cryptographic key is like a key for a lock: only with the right key can you open the lock.

Safely transmitting a key between two communicating parties is not a trivial matter. A public key certificate allows a party to safely transmit its public key, while ensuring the receiver of the authenticity of the public key. Public key certificates are described in a later section.

In the descriptions of the cryptographic processes that follow, we use the conventions used by the security community: we label the two communicating parties with the names Alice and Bob. We call the unauthorized third party, also known as the attacker, Charlie.

Secret Key Cryptography

With secret key cryptography, both communicating parties, Alice and Bob, use the same key to encrypt and decrypt the messages. Before any encrypted data can be sent over the network, both Alice and Bob must have the key and must agree on the cryptographic algorithm that they will use for encryption and decryption.

One of the major problems with secret key cryptography is the logistical issue of how to get the key from one party to the other without allowing access to an attacker. If Alice and Bob are securing their data with secret key cryptography, and if Charlie gains access to their key, Charlie can understand any secret messages he intercepts between Alice and Bob. Not only can Charlie decrypt Alice's and Bob's messages, but he can also pretend that he is Alice and send encrypted data to Bob. Bob will not know that the message came from Charlie, not Alice.

Once the problem of secret key distribution is solved, secret key cryptography can be a valuable tool. The algorithms provide excellent security and encrypt data relatively quickly. The majority of the sensitive data sent in an SSL session is sent using secret key cryptography.

Secret key cryptography is also called symmetric cryptography because the same key is used to both encrypt and decrypt the data. Well-known secret key cryptographic algorithms include the Data Encryption Standard (DES), triple-strength DES (3DES), Rivest Cipher 2 (RC2), and Rivest Cipher 4 (RC4).

Public Key Cryptography

Public key cryptography solves the logistical problem of key distribution by using both a public key and a private key. The public key can be sent openly through the network while the private key is kept private by one of the communicating parties. The public and the private keys are cryptographic inverses of each other; what one key encrypts, the other key will decrypt.

Let's assume that Bob wants to send a secret message to Alice using public key cryptography. Alice has both a public key and a private key, so she keeps her private key in a safe place and sends her public key to Bob. Bob encrypts the secret message to Alice using Alice's public key. Alice can later decrypt the message with her private key.

If Alice encrypts a message using her private key and sends the encrypted message to Bob, Bob can be sure that the data he receives comes from Alice; if Bob can decrypt the data with Alice's public key, the message must have been encrypted by Alice with her private key, and only Alice has Alice's private key. The problem is that anybody else can read the message as well because Alice's public key is public. While this scenario does not allow for secure data communication, it does provide the basis for digital signatures. A digital signature is one of the components of a public key certificate, and is used in SSL to authenticate a client or a server. Public key certificates and digital signatures are described in later sections.

Public key cryptography is also called asymmetric cryptography because different keys are used to encrypt and decrypt the data. A well known public key cryptographic algorithm often used with SSL is the Rivest Shamir Adleman (RSA) algorithm. Another public key algorithm used with SSL that is designed specifically for secret key exchange is the Diffie-Hellman (DH) algorithm. Public key cryptography requires extensive computations, making it very slow. It is therefore typically used only for encrypting small pieces of data, such as secret keys, rather than for the bulk of encrypted data communications.

A Comparison Between Secret Key and Public Key Cryptography

Both secret key cryptography and public key cryptography have strengths and weaknesses. With secret key cryptography, data can be encrypted and decrypted quickly, but since both communicating parties must share the same secret key information, the logistics of exchanging the key can be a problem. With public key cryptography, key exchange is not a problem since the public key does not need to be kept secret, but the algorithms used to encrypt and decrypt data require extensive computations, and are therefore very slow.

Public Key Certificates

A public key certificate provides a safe way for an entity to pass on its public key to be used in asymmetric cryptography. The public key certificate avoids the following situation: if Charlie creates his own public key and private key, he can claim that he is Alice and send his public key to Bob. Bob will be able to communicate with Charlie, but Bob will think that he is sending his data to Alice.

A public key certificate can be thought of as the digital equivalent of a passport. It is issued by a trusted organization and provides identification for the bearer. A trusted organization that issues public key certificates is known as a certificate authority (CA). The CA can be likened to a notary public. To obtain a certificate from a CA, one must provide proof of identity. Once the CA is confident that the applicant represents the organization it says it represents, the CA signs the certificate attesting to the validity of the information contained within the certificate.

A public key certificate contains several fields, including:

  • Issuer - The issuer is the CA that issued the certificate. If a user trusts the CA that issues a certificate, and if the certificate is valid, the user can trust the certificate.

  • Period of validity - A certificate has an expiration date, and this date is one piece of information that should be checked when verifying the validity of a certificate.

  • Subject - The subject field includes information about the entity that the certificate represents.

  • Subject's public key - The primary piece of information that the certificate provides is the subject's public key. All the other fields are provided to ensure the validity of this key.

  • Signature - The certificate is digitally signed by the CA that issued the certificate. The signature is created using the CA's private key and ensures the validity of the certificate. Because only the certificate is signed, not the data sent in the SSL transaction, SSL does not provide for non-repudiation.

If Bob only accepts Alice's public key as valid when she sends it in a public key certificate, Bob will not be fooled into sending secret information to Charlie when Charlie masquerades as Alice.

Multiple certificates may be linked in a certificate chain. When a certificate chain is used, the first certificate is always that of the sender. The next is the certificate of the entity that issued the sender's certificate. If there are more certificates in the chain, each is that of the authority that issued the previous certificate. The final certificate in the chain is the certificate for a root CA. A root CA is a public certificate authority that is widely trusted. Information for several root CAs is typically stored in the client's Internet browser. This information includes the CA's public key. Well-known CAs include VeriSign, Entrust, and GTE CyberTrust.

Cryptographic Hash Functions

When sending encrypted data, SSL typically uses a cryptographic hash function to ensure data integrity. The hash function prevents Charlie from tampering with data that Alice sends to Bob.

A cryptographic hash function is similar to a checksum. The main difference is that while a checksum is designed to detect accidental alterations in data, a cryptographic hash function is designed to detect deliberate alterations. When data is processed by a cryptographic hash function, a small string of bits, known as a hash, is generated. The slightest change to the message typically makes a large change in the resulting hash. A cryptographic hash function does not require a cryptographic key. Two hash functions often used with SSL are Message Digest 5 (MD5) and Secure Hash Algorithm (SHA). SHA was proposed by the U.S. National Institute of Science and Technology (NIST).

Message Authentication Code

A message authentication code (MAC) is similar to a cryptographic hash, except that it is based on a secret key. When secret key information is included with the data that is processed by a cryptographic hash function, the resulting hash is known as an HMAC.

If Alice wants to be sure that Charlie does not tamper with her message to Bob, she can calculate an HMAC for her message and append the HMAC to her original message. She can then encrypt the message plus the HMAC using a secret key she shares with Bob. When Bob decrypts the message and calculates the HMAC, he will be able to tell if the message was modified in transit. With SSL, an HMAC is used with the transmission of secure data.

Digital Signatures

Once a cryptographic hash is created for a message, the hash is encrypted with the sender's private key. This encrypted hash is called a digital signature.

The SSL Process

Communication using SSL begins with an exchange of information between the client and the server. This exchange of information is called the SSL handshake.

The three main purposes of the SSL handshake are:

  • Negotiate the cipher suite

  • Authenticate identity (optional)

  • Establish information security by agreeing on encryption mechanisms

Negotiating the Cipher Suite

The SSL session begins with a negotiation between the client and the server as to which cipher suite they will use. A cipher suite is a set of cryptographic algorithms and key sizes that a computer can use to encrypt data. The cipher suite includes information about the public key exchange algorithms or key agreement algorithms, and cryptographic hash functions. The client tells the server which cipher suites it has available, and the server chooses the best mutually acceptable cipher suite.

Authenticating the Server

In SSL, the authentication step is optional, but in the example of an e-commerce transaction over the Web, the client will generally want to authenticate the server. Authenticating the server allows the client to be sure that the server represents the entity that the client believes the server represents.

To prove that a server belongs to the organization that it claims to represent, the server presents its public key certificate to the client. If this certificate is valid, the client can be sure of the identity of the server.

The client and server exchange information that allows them to agree on the same secret key. For example, with RSA, the client uses the server's public key, obtained from the public key certificate, to encrypt the secret key information. The client sends the encrypted secret key information to the server. Only the server can decrypt this message since the server's private key is required for this decryption.

Sending the Encrypted Data

Both the client and the server now have access to the same secret key. With each message, they use the cryptographic hash function, chosen in the first step of this process, and shared secret information, to compute an HMAC that they append to the message. They then use the secret key and the secret key algorithm negotiated in the first step of this process to encrypt the secure data and the HMAC. The client and server can now communicate securely using their encrypted and hashed data.

The SSL Protocol

The previous section provides a high-level description of the SSL handshake, which is the exchange of information between the client and the server prior to sending the encrypted message. This section provides more detail.

The "SSL Messages" figure below shows the sequence of messages that are exchanged in the SSL handshake. Messages that are only sent in certain situations are noted as optional. Each of the SSL messages is described in the following figure:

Sequence of messages exchanged in SSL handshake.

The SSL messages are sent in the following order:

  1. Client hello - The client sends the server information including the highest version of SSL it supports and a list of the cipher suites it supports. (TLS 1.0 is indicated as SSL 3.1.) The cipher suite information includes cryptographic algorithms and key sizes.

  2. Server hello - The server chooses the highest version of SSL and the best cipher suite that both the client and server support and sends this information to the client.

  3. Certificate - The server sends the client a certificate or a certificate chain. A certificate chain typically begins with the server's public key certificate and ends with the certificate authority's root certificate. This message is optional, but is used whenever server authentication is required.

  4. Certificate request - If the server needs to authenticate the client, it sends the client a certificate request. In Internet applications, this message is rarely sent.

  5. Server key exchange - The server sends the client a server key exchange message when the public key information sent in 3) above is not sufficient for key exchange.

  6. Server hello done - The server tells the client that it is finished with its initial negotiation messages.

  7. Certificate - If the server requests a certificate from the client in Message 4, the client sends its certificate chain, just as the server did in Message 3.

    Note: Only a few Internet server applications ask for a certificate from the client.

  8. Client key exchange - The client generates information used to create a key to use for symmetric encryption. For RSA, the client then encrypts this key information with the server's public key and sends it to the server.

  9. Certificate verify - This message is sent when a client presents a certificate as above. Its purpose is to allow the server to complete the process of authenticating the client. When this message is used, the client sends information that it digitally signs using a cryptographic hash function. When the server decrypts this information with the client's public key, the server is able to authenticate the client.

  10. Change cipher spec - The client sends a message telling the server to change to encrypted mode.

  11. Finished - The client tells the server that it is ready for secure data communication to begin.

  12. Change cipher spec - The server sends a message telling the client to change to encrypted mode.

  13. Finished - The server tells the client that it is ready for secure data communication to begin. This is the end of the SSL handshake.

  14. Encrypted data - The client and the server communicate using the symmetric encryption algorithm and the cryptographic hash function negotiated in Messages 1 and 2, and using the secret key that the client sent to the server in Message 8.

  15. Close Messages - At the end of the connection, each side will send a close_notify message to inform the peer that the connection is closed.

If the parameters generated during an SSL session are saved, these parameters can sometimes be re-used for future SSL sessions. Saving SSL session parameters allows encrypted communication to begin much more quickly.

Cipher Suite Choice and Remote Entity Verification

The SSL/TLS protocols define a specific series of steps to ensure a "protected" connection. However, the choice of cipher suite will directly impact the type of security the connection enjoys. For example, if an anonymous cipher suite is selected, the application will have no way to verify the remote peer's identity. If a suite with no encryption is selected, then the privacy of the data can not be protected. Additionally, the SSL/TLS protocols do not specify that the credentials received must match those that peer might be expected to send. If the connection were somehow redirected to a rogue peer, but the rogue's credentials presented were acceptable based on the current trust material, the connection would be considered valid.

When using raw SSLSockets/SSLEngines you should always check the peer's credentials before sending any data. The SSLSocket and SSLEngine classes do not automatically verify that the hostname in a URL matches the hostname in the peer's credentials. An application could be exploited with URL spoofing if the hostname is not verified.

Protocols such as https do require hostname verification. Applications can use HostnameVerifier to override the default HTTPS hostname rules. See HttpsURLConnection for more information.

SSL and TLS References

For a list of resources containing more information about SSL, see Secure Sockets Layer Documentation .

Key Classes

Relationship Between Classes

To communicate securely, both sides of the connection must be SSL-enabled. In the JSSE API, the endpoint classes of the connection is the SSLSocket and SSLEngine. In the diagram below, the major classes used to create SSLSocket/SSLEngines are laid out in a logical ordering.

diagram of classes used to create SSLSockets/SSLEngines

An SSLSocket is created either by an SSLSocketFactory or by an SSLServerSocket accepting an in-bound connection. (In turn, an SSLServerSocket is created by an SSLServerSocketFactory.) Both SSLSocketFactory and SSLServerSocketFactory objects are created by an SSLContext. An SSLEngine is created directly by the SSLContext, and relies on the application to handle all I/O.

IMPORTANT NOTE: When using raw SSLSockets/SSLEngines you should always check the peer's credentials before sending any data. The SSLSocket/SSLEngine classes do not automatically verify, for example, that the hostname in a URL matches the hostname in the peer's credentials. An application could be exploited with URL spoofing if the hostname is not verified.

There are two ways to obtain and initialize an SSLContext:

  • The simplest is to call the static getDefault method on either the SSLSocketFactory or SSLServerSocketFactory class. These methods create a default SSLContext with a default KeyManager, TrustManager, and a secure random number generator. (A default KeyManagerFactory and TrustManagerFactory are used to create the KeyManager and TrustManager, respectively.) The key material used is found in the default keystore/truststore, as determined by system properties described in Customizing the Default Key and Trust Stores, Store Types, and Store Passwords.

  • The approach that gives the caller the most control over the behavior of the created context is to call the static method getInstance on the SSLContext class, then initialize the context by calling the instance's proper init method. One variant of the init method takes three arguments: an array of KeyManager objects, an array of TrustManager objects, and a SecureRandom random number generator. The KeyManager and TrustManager objects are created by either implementing the appropriate interface(s) or using the KeyManagerFactory and TrustManagerFactory classes to generate implementations. The KeyManagerFactory and TrustManagerFactory can then each be initialized with key material contained in the KeyStore passed as an argument to the TrustManagerFactory/KeyManagerFactory init method. Finally, the getTrustManagers method (in TrustManagerFactory) and getKeyManagers method (in KeyManagerFactory) can be called to obtain the array of trust or key managers, one for each type of trust or key material.

Once an SSL connection is established, an SSLSession is created which contains various information, such as identities established, cipher suite used, etc. The SSLSession is then used to describe an ongoing relationship and state information between two entities. Each SSL connection involves one session at a time, but that session may be used on many connections between those entities, simultaneously or sequentially.

Core Classes and Interfaces

The core JSSE classes are part of the javax.net and javax.net.ssl packages.

SocketFactory and ServerSocketFactory Classes

The abstract javax.net.SocketFactory class is used to create sockets. It must be subclassed by other factories, which create particular subclasses of sockets and thus provide a general framework for the addition of public socket-level functionality. (See, for example, SSLSocketFactory.)

The javax.net.ServerSocketFactory class is analogous to the SocketFactory class, but is used specifically for creating server sockets.

Socket factories are a simple way to capture a variety of policies related to the sockets being constructed, producing such sockets in a way which does not require special configuration of the code which asks for the sockets:

  • Due to polymorphism of both factories and sockets, different kinds of sockets can be used by the same application code just by passing different kinds of factories.

  • Factories can themselves be customized with parameters used in socket construction. So for example, factories could be customized to return sockets with different networking timeouts or security parameters already configured.

  • The sockets returned to the application can be subclasses of java.net.Socket (or javax.net.ssl.SSLSocket), so that they can directly expose new APIs for features such as compression, security, record marking, statistics collection, or firewall tunneling.

SSLSocketFactory and SSLServerSocketFactory Classes

A javax.net.ssl.SSLSocketFactory acts as a factory for creating secure sockets. This class is an abstract subclass of javax.net.SocketFactory.

Secure socket factories encapsulate the details of creating and initially configuring secure sockets. This includes authentication keys, peer certificate validation, enabled cipher suites and the like.

The javax.net.ssl.SSLServerSocketFactory class is analogous to the SSLSocketFactory class, but is used specifically for creating server sockets.

Obtaining an SSLSocketFactory

There are three primary ways of obtaining an SSLSocketFactory:

  • Get the default factory by calling the SSLSocketFactory.getDefault static method.

  • Receive a factory as an API parameter. That is, code which needs to create sockets but which doesn't care about the details of how the sockets are configured can include a method with an SSLSocketFactory parameter that can be called by clients to specify which SSLSocketFactory to use when creating sockets. (For example, javax.net.ssl.HttpsURLConnection.)

  • Construct a new factory with specifically configured behavior.

The default factory is typically configured to support server authentication only so that sockets created by the default factory do not leak any more information about the client than a normal TCP socket would.

Many classes which create and use sockets do not need to know the details of socket creation behavior. Creating sockets through a socket factory passed in as a parameter is a good way of isolating the details of socket configuration, and increases the reusability of classes which create and use sockets.

You can create new socket factory instances either by implementing your own socket factory subclass or by using another class which acts as a factory for socket factories. One example of such a class is SSLContext, which is provided with the JSSE implementation as a provider-based configuration class.

SSLSocket and SSLServerSocket Classes

The javax.net.ssl.SSLSocket class is a subclass of the standard Java java.net.Socket class. It supports all of the standard socket methods and adds additional methods specific to secure sockets. Instances of this class encapsulate the SSLContext under which they were created. There are APIs to control the creation of secure socket sessions for a socket instance but trust and key management are not directly exposed.

The javax.net.ssl.SSLServerSocket class is analogous to the SSLSocket class, but is used specifically for creating server sockets.

To prevent peer spoofing, you should always verify the credentials presented to a SSLSocket.

Implementation note: Due to the complexity of the SSL and TLS protocols, it is difficult to predict whether incoming bytes on a connection are handshake or application data, and how that data might affect the current connection state (even causing the process to block). In the Sun JSSE implementation, the available() method on the object obtained by SSLSocket.getInputStream() returns a count of the number of application data bytes successfully decrypted from the SSL connection but not yet read by the application.

Obtaining an SSLSocket

Instances of SSLSocket can be obtained in two ways. First, an SSLSocket can be created by an instance of SSLSocketFactory via one of the several createSocket methods on that class. The second way to obtain SSLSockets is through the accept method on the SSLServerSocket class.

Non-blocking I/O with SSLEngine

SSL/TLS is becoming increasingly popular. It is being used in a wide variety of applications across a wide range of computing platforms and devices. Along with this popularity comes demands to use it with different I/O and threading models in order to satisfy the applications' performance, scalability, footprint, and other requirements. There are demands to use it with blocking and non-blocking I/O channels, asynchronous I/O, arbitrary input and output streams, and byte buffers. There are demands to use it in highly scalable, performance-critical environments, requiring management of thousands of network connections.

Prior to Java SE 5, the JSSE API supported only a single transport abstraction: stream-based sockets via SSLSocket. While this was adequate for many applications, it did not meet the needs of applications that need to use different I/O or threading models. In 1.6.0, a new abstraction was introduced to allow applications to use the SSL/TLS protocols in a transport independent way, and thus freeing applications to choose transport and computing models that best meet their needs. Not only does this new abstraction allow applications to use non-blocking I/O channels and other I/O models, it also accommodates different threading models. This effectively leaves the I/O and threading decisions up to the application. Because of this flexibility, the application must now manage I/O and threading (complex topics in and of themselves), as well as have some understanding of the SSL/TLS protocols. The new abstraction is therefore an advanced API: beginners should continue to use SSLSocket.

Newcomers to the API may wonder "Why not just have an SSLSocketChannel which extends java.nio.channels.SocketChannel?" There are two main reasons:

  • There were a lot of very difficult questions about what a SSLSocketChannel should be, including its class hierarchy and how it should interoperate with Selectors and other types of SocketChannels. Each proposal brought up more questions than answers. It was noted that any new API abstraction extended to work with SSL/TLS would require the same significant analysis and could result in large and complex APIs.

  • Any JSSE implementation of a new API would be free to choose the "best" I/O & compute strategy, but hiding any of these details is inappropriate for those applications needing full control. Any specific implementation would be inappropriate for some application segment.
By abstracting the I/O and treating data as streams of bytes, these issues are resolved and the new API could be used with any existing or future I/O model. While this solution makes I/O and CPU handling the developers' responsibility, JSSE implementations are prevented from being unusable due to some unconfigurable and/or unchangeable internal detail.

Users of other Java programming language APIs such as JGSS and SASL will notice similarities in that the application is also responsible for transporting data.

SSLEngine

The core class in this new abstraction is javax.net.ssl.SSLEngine. It encapsulates an SSL/TLS state machine and operates on inbound and outbound byte buffers supplied by the user of the SSLEngine. The following diagram illustrates the flow of data from the application, to the SSLEngine, to the transport mechanism, and back.

The application, shown on the left, supplies application (plaintext) data in an application buffer and passes it to the SSLEngine. The SSLEngine processes the data contained in the buffer, or any handshaking data, to produce SSL/TLS encoded data and places it the network buffer supplied by the application. The application is then responsible for using an appropriate transport (shown on the right) to send the contents of the network buffer to its peer. Upon receiving SSL/TLS encoded data from its peer (via the transport), the application places the data into a network buffer and passes it to SSLEngine. The SSLEngine processes the network buffer's contents to produce handshaking data or application data.

In all, SSLEngine can be in one of five states.

  1. Creation - ready to be configured.
  2. Initial handshaking - perform authentication and negotiate communication parameters.
  3. Application data - ready for application exchange.
  4. Rehandshaking - renegotiate communications parameters/authentication; handshaking data may be mixed with application data.
  5. Closure - ready to shut down connection.
These five states are decribed in more detail in the SSLEngine class documentation.

Getting Started

To create an SSLEngine, you use the SSLContext.createSSLEngine() methods. You must then configure the engine to act as a client or a server, as well as set other configuration parameters such as which cipher suites to use and whether to require client authentication.

Here is an example that creates an SSLEngine. Note that the server name and port number are not used for communicating with the server--all transport is the responsibility of the application. They are hints to the JSSE provider to use for SSL session caching, and for Kerberos-based cipher suite implementations to determine which server credentials should be obtained.

import javax.net.ssl.*;
import java.security.*;

// Create/initialize the SSLContext with key material

char[] passphrase = "passphrase".toCharArray();

// First initialize the key and trust material.
KeyStore ksKeys = KeyStore.getInstance("JKS");
ksKeys.load(new FileInputStream("testKeys"), passphrase);
KeyStore ksTrust = KeyStore.getInstance("JKS");
ksTrust.load(new FileInputStream("testTrust"), passphrase);

// KeyManager's decide which key material to use.
KeyManagerFactory kmf =
    KeyManagerFactory.getInstance("SunX509");
kmf.init(ksKeys, passphrase);

// TrustManager's decide whether to allow connections.
TrustManagerFactory tmf =
    TrustManagerFactory.getInstance("SunX509");
tmf.init(ksTrust);

sslContext = SSLContext.getInstance("TLS");
sslContext.init(
    kmf.getKeyManagers(), tmf.getTrustManagers(), null);

// We're ready for the engine.
SSLEngine engine = sslContext.createSSLengine(hostname, port);

// Use as client
engine.setUseClientMode(true);

Generating and Processing SSL/TLS data

The two main SSLEngine methods wrap() and unwrap() are responsible for generating and consuming network data respectively. Depending on the state of the SSLEngine, this data might be handshake or application data.

Each SSLEngine has several phases during its lifetime. Before application data can be sent/received, the SSL/TLS protocol requires a handshake to establish cryptographic parameters. This handshake requires a series of back-and-forth steps by the SSLEngine. The SSL Process can provide more details about the handshake itself.

During the initial handshaking, wrap() and unwrap() generate and consume handshake data, and the application is responsible for transporting the data. The wrap()/unwrap() sequence is repeated until the handshake is finished. Each SSLEngine operation generates a SSLEngineResult, of which the SSLEngineResult.HandshakeStatus field is used to determine what operation needs to occur next to move the handshake along.

A typical handshake might look like this:

client | SSL/TLS message | HSStatus
wrap() | ClientHello | NEED_UNWRAP
unwrap() | ServerHello/Cert/ServerHelloDone | NEED_WRAP
wrap() | ClientKeyExchange | NEED_WRAP
wrap() | ChangeCipherSpec | NEED_WRAP
wrap() | Finished | NEED_UNWRAP
unwrap() | ChangeCipherSpec | NEED_UNWRAP
unwrap() | Finished | FINISHED
Now that handshaking is complete, further calls to wrap() will attempt to consume application data and packages it for transport. unwrap() attempts the opposite.

To send data to the peer, the application first supplies the data that it wants to send to SSLEngine via SSLEngine.wrap() to obtain the corresponding SSL/TLS encoded data. The application then sends the encoded data to the peer using its chosen transport mechanism. When the application receives the SSL/TLS encoded data from the peer via the transport mechanism, it supplies this data to the SSLEngine via SSLEngine.unwrap() to obtain the plaintext data sent by the peer.

Here is an example of an SSL application that is using a non-blocking SocketChannel to communicate with its peer. (It can be made more robust and scalable by using a Selector with the non-blocking SocketChannel.) The following sample code sends the string "hello" to its peer, by encoding it using the SSLEngine created in the previous example. It uses information from the SSLSession to determine how large to make the byte buffers.

// Create a non-blocking socket channel
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress(hostname, port));

// Complete connection
while (!socketChannel.finishedConnect()) {
    // do something until connect completed
}

// Create byte buffers to use for holding application and encoded data
SSLSession session = engine.getSession();
ByteBuffer myAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
ByteBuffer myNetData = ByteBuffer.allocate(session.getPacketBufferSize());
ByteBuffer peerAppData = ByteBuffer.allocate(session.getApplicationBufferSize());
ByteBuffer peerNetData = ByteBuffer.allocate(session.getPacketBufferSize());

// Do initial handshake
doHandshake(socketChannel, engine, myNetData, peerNetData);

myAppData.put("hello".getBytes());
myAppData.flip();

while (myAppData.hasRemaining()) {
    // Generate SSL/TLS encoded data (handshake or application data)
    SSLEngineResult res = engine.wrap(myAppData, myNetData);

    // Process status of call
    if (res.getStatus() == SSLEngineResult.Status.OK) {
        myAppData.compact();

        // Send SSL/TLS encoded data to peer
        while(myNetData.hasRemaining()) {
            int num = socketChannel.write(myNetData);
        if (num == -1) {
            // handle closed channel
        } else if (num == 0) {
            // no bytes written; try again later
        }
        }
    }

    // Handle other status:  BUFFER_OVERFLOW, CLOSED
    ...
}
The following code reads data from the same non-blocking SocketChannel and extracts the plaintext data from it by using the SSLEngine created previously. Each iteration of this code may or may not produce any plaintext data, depending on whether handshaking is in progress.
// Read SSL/TLS encoded data from peer
int num = socketChannel.read(peerNetData);
if (num == -1) {
    // Handle closed channel
} else if (num == 0) {
    // No bytes read; try again ...
} else {
    // Process incoming data
    peerNetData.flip();
    res = engine.unwrap(peerNetData, peerAppData);

    if (res.getStatus() == SSLEngineResult.Status.OK) {
        peerNetData.compact();

        if (peerAppData.hasRemaining()) {
            // Use peerAppData
        }
    }
    // Handle other status:  BUFFER_OVERFLOW, BUFFER_UNDERFLOW, CLOSED
    ...
}

Status of Operations

To indicate the status of the engine and what action(s) the application should take, the SSLEngine.wrap() and SSLEngine.unwrap() methods return an SSLEngineResult instance, as shown in the previous examples. The SSLEngineResult contains two pieces of status information: the overall status of the engine and the handshaking status.

The possible overall statuses are represented by the SSLEngineResult.Status enum. Some examples of this status include OK, which means that there was no error, and BUFFER_UNDERFLOW, which means that the input buffer had insufficient data, indicating that the application needs to obtain more data from the peer (for example, by reading more data from the network), and BUFFER_OVERFLOW, which means that the output buffer had insufficient space to hold the result, indicating that the application needs to clear or enlarge the destination buffer.

Here is an example of how to handle BUFFER_UNDERFLOW
and BUFFER_OVERFLOW statuses of SSLEngine.unwrap().
It uses SSLSession.getApplicationBufferSize() and
SSLSession.getPacketBufferSize() to determine how
large to make the byte buffers.

SSLEngineResult res = engine.unwrap(peerNetData, peerAppData);
switch (res.getStatus()) {

case BUFFER_OVERFLOW:
  // Maybe need to enlarge the peer application data buffer.
  if (engine.getSession().getApplicationBufferSize() >
          peerAppData.capacity()) {
      // enlarge the peer application data buffer
  } else {
        // compact or clear the buffer
  }
  // retry the operation
  break;

case BUFFER_UNDERFLOW:
  // Maybe need to enlarge the peer network packet buffer
  if (engine.getSession().getPacketBufferSize() >
          peerNetData.capacity()) {
      // enlarge the peer network packet buffer
  } else {
        // compact or clear the buffer
  }
  // obtain more inbound network data and then retry the operation
  break;

// Handle other status: CLOSED, OK
...
}

The possible handshaking statuses are represented by the SSLEngineResult.HandshakeStatus enum. They represent whether handshaking has completed, whether the caller needs to obtain more handshaking data from the peer, send more handshaking data to the peer, and so on.

Having two statuses per result allows the engine to indicate that the application must take two actions: one in response to the handshaking and one representing the overall status of the wrap()/unwrap() method. For example, the engine might, as the result of a single SSLEngine.unwrap() call, return SSLEngineResult.Status.OK to indicate that the input data was processed successfully and SSLEngineResult.HandshakeStatus.NEED_UNWRAP to indicate that the application should obtain more SSL/TLS encoded data from the peer and supply it to SSLEngine.unwrap() again so that handshaking can continue. As you can see, the previous examples were greatly simplified; they would need to be expanded significantly to properly handle all of these statuses.

Here is an example of how to process handshaking data by checking handshaking status and the overall status of the wrap()/unwrap() method.

void doHandshake(SocketChannel socketChannel, SSLEngine engine,
        ByteBuffer myNetData, ByteBuffer peerNetData) throws Exception {

    // Create byte buffers to use for holding application data
    int appBufferSize = engine.getSession().getApplicationBufferSize();
    ByteBuffer myAppData = ByteBuffer.allocate(appBufferSize);
    ByteBuffer peerAppData = ByteBuffer.allocate(appBufferSize);

    // Begin handshake
    engine.beginHandshake();
    SSLEngineResult.HandshakeStatus hs = engine.getHandshakeStatus();

    // Process handshaking message
    while (hs != SSLEngineResult.HandshakeStatus.FINISHED &&
        hs != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING) {

        switch (hs) {

        case NEED_UNWRAP:
            // Receive handshaking data from peer
            if (socketChannel.read(peerNetData) < 0) {
                // Handle closed channel
            }

            // Process incoming handshaking data
            peerNetData.flip();
            SSLEngineResult res = engine.unwrap(peerNetData, peerAppData);
            peerNetData.compact();
            hs = res.getHandshakeStatus();

            // Check status
            switch (res.getStatus()) {
            case OK :
                // Handle OK status
                break;

            // Handle other status: BUFFER_UNDERFLOW, BUFFER_OVERFLOW, CLOSED
            ...
            }
            break;

        case NEED_WRAP :
            // Empty the local network packet buffer.
            myNetData.clear();

            // Generate handshaking data
            res = engine.wrap(myAppData, myNetData);
            hs = res.getHandshakeStatus();

            // Check status
            switch (res.getStatus()) {
            case OK :
                myNetData.flip();

                // Send the handshaking data to peer
                while (myNetData.hasRemaining()) {
                    if (socketChannel.write(myNetData) < 0) {
                        // Handle closed channel
                    }
                }
                break;

            // Handle other status:  BUFFER_OVERFLOW, BUFFER_UNDERFLOW, CLOSED
            ...
            }
            break;

        case NEED_TASK :
        // Handle blocking tasks
            break;

        // Handle other status:  // FINISHED or NOT_HANDSHAKING
        ...
        }
    }

    // Processes after handshaking
    ...
}

Blocking Tasks

During handshaking, the SSLEngine might encounter tasks that might block or take a long time. For example, a TrustManager may need to connect to a remote certificate validation service, or a KeyManager might need to prompt a user to determine which certificate to use as part of client authentication. To preserve the non-blocking nature of SSLEngine, when the engine encounters such a task, it will return SSLEngineResult.HandshakeStatus.NEED_TASK. Upon receiving this status, the application should invoke SSLEngine.getDelegatedTask() to get the task, and then, using the threading model appropriate for its requirements, process the task. The application might, for example, obtain thread(s) from a thread pool to process the task(s), while the main thread goes about handling other I/O.

Here is an example that executes each task in a newly created thread.

if (res.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_TASK) {
    Runnable task;
    while ((task=engine.getDelegatedTask()) != null) {
        new Thread(task).start();
    }
}
The engine will block future wrap/unwrap calls until all of the outstanding tasks are completed.

Shutting Down

For an orderly shutdown of an SSL/TLS connection, the SSL/TLS protocols require transmission of close messages. Therefore, when an application is done with the SSL/TLS connection, it should first obtain the close messages from the SSLEngine, then transmit them to the peer using its transport mechanism, and finally shut down the transport mechanism. Here is an example.
// Indicate that application is done with engine
engine.closeOutbound();

while (!engine.isOutboundDone()) {
    // Get close message
    SSLEngineResult res = engine.wrap(empty, myNetData);

    // Check res statuses

    // Send close message to peer
    while(myNetData().hasRemaining()) {
        int num = socketChannel.write(myNetData);
    if (num == -1) {
        // handle closed channel
    } else if (num == 0) {
        // no bytes written; try again later
    }
    myNetData().compact();
    }
}

// Close transport
socketChannel.close();
In addition to an application explicitly closing the SSLEngine, the SSLEngine might be closed by the peer (via receipt of a close message while it is processing handshake data), or by the SSLEngine encountering an error while processing application or handshake data, indicated by throwing an SSLException. In such cases, the application should invoke SSLEngine.wrap() to get the close message and send it to the peer until SSLEngine.isOutboundDone() returns true, as shown in the previous example, or the SSLEngineResult.getStatus() returns CLOSED.

In addition to orderly shutdowns, there can also be unorderly shutdowns in which the transport link is severed before close messages are exchanged. In the previous examples, the application might get -1 when trying to read or write to the non-blocking SocketChannel. When you get to the end of your input data, you should call engine.closeInbound(), which will verify with the SSLEngine that the remote peer has closed cleanly from the SSL/TLS perspective, and then the application should still try to shutdown cleanly by using the procedure above. Obviously, unlike SSLSocket, the application using SSLEngine must deal with more state transitions, statuses and programming than when using SSLEngine. Please see the NIO-based HTTPS server for more information on writing a SSLEngine-based application.

SSLSession Interface

A javax.net.ssl.SSLSession represents a security context negotiated between the two peers of an SSLSocket/SSLEngine connection. Once a session has been arranged, it can be shared by future SSLSocket/Engines connected between the same two peers. The session contains the cipher suite which will be used for communications over a secure socket as well as a non-authoritative hint as to the network address of the remote peer, and management information such as the time of creation and last use. A session also contains a shared master secret negotiated between the peers that is used to create cryptographic keys for encrypting and guaranteeing the integrity of the communications over an SSLSocket/SSLEngine. The value of this master secret is known only to the underlying secure socket implementation and is not exposed through the SSLSession API.

Calls to SSLSession.getPacketBufferSize() and SSLSession.getApplicationBufferSize() also are used to determine the appropriate buffer sizes used by SSLEngine.

Note: The SSL/TLS protocols specify implementations are to produce packets containing at most 16KB of plaintext. However, some implementations violate the specification and generate large records up to 32KB. If the SSLEngine.unwrap() code detects large inbound packets, the buffer sizes returned by SSLSession will be updated dynamically. Applications should always check the BUFFER_OVERFLOW/BUFFER_UNDERFLOW statuses and enlarge the corresponding buffers if necessary. SunJSSE will always send standard compliant 16k records even if we allow incoming 32k records. (Also see the System property jsse.SSLEngine.acceptLargeFragments in Customization for a workaround.)

HttpsURLConnection Class

The https protocol is similar to http, but https first establishes a secure channel via SSL/TLS sockets and then verifies the identity of the peer before requesting/receiving data. javax.net.ssl.HttpsURLConnection extends the java.net.HttpsURLConnection class, and adds support for https-specific features. See the java.net.URL, java.net.URLConnection, java.net.HttpURLConnection, and javax.net.ssl.HttpURLConnection classes for more information about how https URLs are constructed and used.

Upon obtaining a HttpsURLConnection, you can configure a number of http/https parameters before actually initiating the network connection via the method URLConnection.connect. Of particular interest are:

  • Setting the Assigned SSLSocketFactory
  • Setting the Assigned HostnameVerifier

Setting the Assigned SSLSocketFactory

In some situations, it is desirable to specify the SSLSocketFactory that an HttpsURLConnection instance uses. For example, you may wish to tunnel through a proxy type that isn't supported by the default implementation. The new SSLSocketFactory could return sockets that have already performed all necessary tunneling, thus allowing HttpsURLConnection to use additional proxies.

The HttpsURLConnection class has a default SSLSocketFactory which is assigned when the class is loaded. (In particular it is the factory returned by the method SSLSocketFactory.getDefault.) Future instances of HttpsURLConnection will inherit the current default SSLSocketFactory until a new default SSLSocketFactory is assigned to the class via the static method HttpsURLConnection.setDefaultSSLSocketFactory. Once an instance of HttpsURLConnection has been created, the inherited SSLSocketFactory on this instance can be overriden with a call to the setSSLSocketFactory method.

Note that changing the default static SSLSocketFactory has no effect on existing instances of HttpsURLConnections, a call to the setSSLSocketFactory method is necessary to change the existing instance.

One can obtain the per-instance or per-class SSLSocketFactory by making a call to the getSSLSocketFactory/getDefaultSSLSocketFactory methods, respectively.

Setting the Assigned HostnameVerifier

If the hostname of the URL does not match the hostname in the credentials received as part of the SSL/TLS handshake, it's possible that URL spoofing has occured. If the implementation cannot determine a hostname match with reasonable certainty, the SSL implementation will perform a callback to the instance's assigned HostnameVerifier for futher checking. The hostname verifier can perform whatever steps are necessary to make the determination, such as performing alternate hostname pattern matching or perhaps popping up an interactive dialog box. An unsuccessful verification by the hostname verifier will close the connection. (See RFC 2818 for more information regarding hostname verification.)

The setHostnameVerifier/setDefaultHostnameVerifier methods operate in a similar manner to the setSSLSocketFactory/setDefaultSSLSocketFactory methods, in that there are HostnameVerifiers assigned on a per-instance and per-class basis, and the current values can be obtained by a call to the getHostnameVerifier/getDefaultHostnameVerifier methods.

Support Classes and Interfaces

The classes and interfaces in this section are provided to support the creation and initialization of SSLContext objects, which are used to create SSLSocketFactory, SSLServerSocketFactory, and SSLEngine objects. The support classes and interfaces are part of the javax.net.ssl package.

Three of the classes described in this section ( SSLContext, KeyManagerFactory, and TrustManagerFactory) are engine classes. An engine class is an API class for specific algorithms (or protocols, in the case of SSLContext), for which implementations may be provided in one or more Cryptographic Service Provider (provider) packages. For more information on providers and engine classes, see the "Design Principles" and "Concepts" sections of the JavaTM Cryptography Architecture Reference Guide.

The SunJSSE provider that comes standard with JSSE provides SSLContext, KeyManagerFactory, and TrustManagerFactory implementations, as well as implementations for engine classes in the standard Java security (java.security) API. The implementations supplied by SunJSSE are:

Engine Class        Algorithm or
Implemented           Protocol

KeyStore              "PKCS12"

KeyManagerFactory     "SunX509", "NewSunX509"

TrustManagerFactory   "PKIX" (aka "X509"/"SunPKIX"), "SunX509"

SSLContext            "SSLv3" (aka "SSL"), "TLSv1" (aka "TLS")

SSLContext Class

javax.net.ssl.SSLContext is an engine class for an implementation of a secure socket protocol. An instance of this class acts as a factory for SSL socket factories and SSL engines. An SSLContext holds all of the state information shared across all objects created under that context. For example, session state is associated with the SSLContext when it is negotiated through the handshake protocol by sockets created by socket factories provided by the context. These cached sessions can be reused and shared by other sockets created under the same context.

Each instance is configured through its init method with the keys, certificate chains, and trusted root CA certificates that it needs to perform authentication. This configuration is provided in the form of key and trust managers. These managers provide support for the authentication and key agreement aspects of the cipher suites supported by the context.

Currently, only X.509-based managers are supported.

Creating an SSLContext Object

Like other JCA provider-based "engine" classes, SSLContext objects are created using the getInstance factory methods of the SSLContext class. These static methods each return an instance that implements at least the requested secure socket protocol. The returned instance may implement other protocols too. For example, getInstance("SSLv3") may return a instance which implements "SSLv3" and "TLSv1". The getSupportedProtocols method returns a list of supported protocols when an SSLSocket, SSLServerSocket or SSLEngine is created from this context. You can control which protocols are actually enabled for an SSL connection by using the method setEnabledProtocols(String[] protocols).

Note: An SSLContext object is automatically created, initialized, and statically assigned to the SSLSocketFactory class when you call SSLSocketFactory.getDefault. Therefore, you don't have to directly create and initialize an SSLContext object (unless you want to override the default behavior).

To create an SSLContext object by calling a getInstance factory method, you must specify the protocol name. You may also specify which provider you want to supply the implementation of the requested protocol:

public static SSLContext getInstance(String protocol);

public static SSLContext getInstance(String protocol,
                                     String provider);

public static SSLContext getInstance(String protocol,
                                     Provider provider);

If just a protocol name is specified, the system will determine if there is an implementation of the requested protocol available in the environment, and if there is more than one, if there is a preferred one.

If both a protocol name and a provider are specified, the system will determine if there is an implementation of the requested protocol in the provider requested, and throw an exception if there is not.

A protocol is a string (such as "SSL") that describes the secure socket protocol desired. Common protocol names for SSLContext objects are defined in Appendix A.

Here is an example of obtaining an SSLContext:

SSLContext sc = SSLContext.getInstance("SSL");

A newly-created SSLContext should be initialized by calling the init method:

public void init(KeyManager[] km, TrustManager[] tm,
                   SecureRandom random);

If the KeyManager[] paramater is null, then an empty KeyManager will be defined for this context. If the TrustManager[] parameter is null, the installed security providers will be searched for the highest-priority implementation of the TrustManagerFactory, from which an appropriate TrustManager will be obtained. Likewise, the SecureRandom parameter may be null, in which case a default implementation will be used.

If the internal default context is used, (e.g. a SSLContext is created by SSLSocketFactory.getDefault() or SSLServerSocketFactory.getDefault()), a default KeyManager and a TrustManager are created. The default SecureRandom implementation is also chosen.

TrustManager Interface

The primary responsibility of the TrustManager is to determine whether the presented authentication credentials should be trusted. If the credentials are not trusted, the connection will be terminated. To authenticate the remote identity of a secure socket peer, you need to initialize an SSLContext object with one or more TrustManagers. You need to pass one TrustManager for each authentication mechanism that is supported. If null is passed into the SSLContext initialization, a trust manager will be created for you. Typically, there is a single trust manager that supports authentication based on X.509 public key certificates (e.g. X509TrustManager). Some secure socket implementations may also support authentication based on shared secret keys, Kerberos, or other mechanisms.

TrustManagers are created either by a TrustManagerFactory, or by providing a concrete implementation of the interface.

TrustManagerFactory Class

The javax.net.ssl.TrustManagerFactory is an engine class for a provider-based service that acts as a factory for one or more types of TrustManager objects. Because it is provider-based, additional factories can be implemented and configured that provide additional or alternate trust managers that provide more sophisticated services or that implement installation-specific authentication policies.

Creating a TrustManagerFactory

You create an instance of this class in a similar manner to SSLContext, except for passing an algorithm name string instead of a protocol name to the getInstance method:
public static TrustManagerFactory
                  getInstance(String algorithm);

public static TrustManagerFactory
                  getInstance(String algorithm,
                              String provider);

public static TrustManagerFactory
                  getInstance(String algorithm,
                              Provider provider);

A sample algorithm name string is:

"PKIX"

A sample call is the following:

TrustManagerFactory tmf =
    TrustManagerFactory.getInstance("PKIX", "SunJSSE");

The above call will create an instance of the SunJSSE provider's PKIX trust manager factory. This factory can then be used to create trust managers which provide X.509 PKIX-based certification path validity checking.

When initializing a SSLContext, you can use trust managers created from a trust manager factory, or you can write your own trust manager, perhaps using the CertPath API. (See the JavaTM Certification Path API Programmer's Guide for details.) You don't need to use a trust manager factory at all if you implement a trust manager using the X509TrustManager interface.

A newly-created factory should be initialized by calling one of the init methods:

public void init(KeyStore ks);
public void init(ManagerFactoryParameters spec);

You should call whichever init method is appropriate for the TrustManagerFactory you are using. (Ask the provider vendor.)

For many factories, such as the "SunX509" TrustManagerFactory from the SunJSSE provider, the KeyStore is the only information required in order to initialize the TrustManagerFactory and thus the first init method is the appropriate one to call. The TrustManagerFactory will query the KeyStore for information on which remote certificates should be trusted during authorization checks.

In some cases, initialization parameters other than a KeyStore may be needed by a provider. Users of that particular provider are expected to pass an implementation of the appropriate ManagerFactoryParameters as defined by the provider. The provider can then call the specified methods in the ManagerFactoryParameters implementation to obtain the needed information.

For example, suppose the TrustManagerFactory provider requires initialization parameters B, R, and S from any application that wishes to use that provider. Like all providers that require initialization parameters other than a KeyStore, the provider will require that the application provide an instance of a class that implements a particular ManagerFactoryParameters sub-interface. In our example, suppose the provider requires that the calling application implement and create an instance of MyTrustManagerFactoryParams and pass it to the second init. Here is what MyTrustManagerFactoryParams may look like:

public interface MyTrustManagerFactoryParams extends
       ManagerFactoryParameters {
    public boolean getBValue();
    public float getRValue();
    public String getSValue():
}

Some trustmanagers are capable of making trust decisions without having to be explicitly initialized with a KeyStore object or any other parameters. For example, they may access trust material from a local directory service via LDAP, may use a remote online certificate status checking server, or may access default trust material from a standard local location.

PKIX TrustManager Support

The default trust manager algorithm is "PKIX". The default can be changed by editing the ssl.TrustManagerFactory.algorithm property in the java.security file.

The PKIX trust manager factory uses the CertPath PKIX implementation from an installed security provider; a "SUN" CertPath provider is supplied with the Java SE Development Kit 6. The trust manager factory can be initialized using the normal init(KeyStore ks) method, or by passing CertPath parameters to the the PKIX trust manager using the newly introduced class javax.net.ssl.CertPathTrustManagerParameters.

Here is an example of how to get the trust manager to use a particular LDAP certificate store and enable revocation checking.

import javax.net.ssl.*;
import java.security.cert.*;
import java.security.KeyStore;
...

// Create PKIX parameters
KeyStore anchors = KeyStore.getInstance("JKS");
anchors.load(new FileInputStream(anchorsFile));
CertPathParameters pkixParams = new PKIXBuilderParameters(anchors,
    new X509CertSelector());

// Specify LDAP certificate store to use
LDAPCertStoreParameters lcsp = new LDAPCertStoreParameters("ldap.imc.org", 389);
pkixParams.addCertStore(CertStore.getInstance("LDAP", lcsp));

// Specify that revocation checking is to be enabled
pkixParams.setRevocationEnabled(true);

// Wrap them as trust manager parameters
ManagerFactoryParameters trustParams =
    new CertPathTrustManagerParameters(pkixParams);

// Create TrustManagerFactory for PKIX-compliant trust managers
TrustManagerFactory factory = TrustManagerFactory.getInstance("PKIX");

// Pass parameters to factory to be passed to CertPath implementation
factory.init(trustParams);

// Use factory
SSLContext ctx = SSLContext.getInstance("TLS");
ctx.init(null, factory.getTrustManagers(), null);

If the init(KeyStore ks) method is used, default PKIXParameters are used with the exception that revocation checking is disabled. It can be enabled by setting the system property com.sun.net.ssl.checkRevocation to true. Note that this setting requires that the CertPath implementation can locate revocation information by itself. The PKIX implementation in the SUN provider can do this in many cases but requires that the system property com.sun.security.enableCRLDP be set to true.

More information about PKIX and the CertPath API can be found in the Java Certificate Path API Programming Guide.

X509TrustManager Interface

The javax.net.ssl.X509TrustManager interface extends the general TrustManager interface. This interface must be implemented by a trust manager when using X.509-based authentication.

In order to support X.509 authentication of remote socket peers through JSSE, an instance of this interface must be passed to the init method of an SSLContext object.

Creating an X509TrustManager

You can either implement this interface directly yourself or obtain one from a provider-based TrustManagerFactory (such as that supplied by the SunJSSE provider). You could also implement your own that delegates to a factory-generated trust manager. For example, you might do this in order to filter the resulting trust decisions and query an end-user through a graphical user interface.

Note: If a null KeyStore parameter is passed to the SunJSSE "PKIX" or "SunX509" TrustManagerFactory, the factory uses the following steps to try to find trust material:

  1. If the system property:
    javax.net.ssl.trustStore
    is defined, then the TrustManagerFactory attempts to find a file using the filename specified by that system property, and uses that file for the KeyStore. If the javax.net.ssl.trustStorePassword system property is also defined, its value is used to check the integrity of the data in the truststore before opening it.

    If javax.net.ssl.trustStore is defined but the specified file does not exist, then a default TrustManager using an empty keystore is created.

  2. If the javax.net.ssl.trustStore system property was not specified, then if the file
    <java-home>/lib/security/jssecacerts
    exists, that file is used. (See The Installation Directory <java-home> for information about what <java-home> refers to.) Otherwise,

  3. If the file
    <java-home>/lib/security/cacerts
    exists, that file is used.

(If none of these files exists, that may be okay because there are SSL cipher suites which are anonymous, that is, which don't do any authentication and thus don't need a truststore.)

The factory looks for a file specified via the security property javax.net.ssl.trustStore or for the jssecacerts file before checking for a cacerts file so that you can provide a JSSE-specific set of trusted root certificates separate from ones that might be present in cacerts for code-signing purposes.

Creating Your Own X509TrustManager

If the supplied X509TrustManager behavior isn't suitable for your situation, you can create your own X509TrustManager by either creating and registering your own TrustManagerFactory or by implementing the X509TrustManager interface directly.

The following MyX509TrustManager class enhances the default SunJSSE X509 TrustManager behavior by providing alternative authentication logic when the default SunJSSE X509 TrustManager fails.

class MyX509TrustManager implements X509TrustManager {

     /*
      * The default PKIX X509TrustManager9.  We'll delegate
      * decisions to it, and fall back to the logic in this class if the
      * default X509TrustManager doesn't trust it.
      */
     X509TrustManager pkixTrustManager;

     MyX509TrustManager() throws Exception {
         // create a "default" JSSE X509TrustManager.

         KeyStore ks = KeyStore.getInstance("JKS");
         ks.load(new FileInputStream("trustedCerts"),
             "passphrase".toCharArray());

         TrustManagerFactory tmf =
        TrustManagerFactory.getInstance("PKIX");
         tmf.init(ks);

         TrustManager tms [] = tmf.getTrustManagers();

         /*
          * Iterate over the returned trustmanagers, look
          * for an instance of X509TrustManager.  If found,
          * use that as our "default" trust manager.
          */
         for (int i = 0; i < tms.length; i++) {
             if (tms[i] instanceof X509TrustManager) {
                 pkixTrustManager = (X509TrustManager) tms[i];
                 return;
             }
         }

         /*
          * Find some other way to initialize, or else we have to fail the
          * constructor.
          */
         throw new Exception("Couldn't initialize");
     }

     /*
      * Delegate to the default trust manager.
      */
     public void checkClientTrusted(X509Certificate[] chain, String authType)
                 throws CertificateException {
         try {
             pkixTrustManager.checkClientTrusted(chain, authType);
         } catch (CertificateException excep) {
             // do any special handling here, or rethrow exception.
         }
     }

     /*
      * Delegate to the default trust manager.
      */
     public void checkServerTrusted(X509Certificate[] chain, String authType)
                 throws CertificateException {
         try {
             pkixTrustManager.checkServerTrusted(chain, authType);
         } catch (CertificateException excep) {
             /*
              * Possibly pop up a dialog box asking whether to trust the
              * cert chain.
              */
         }
     }

     /*
      * Merely pass this through.
      */
     public X509Certificate[] getAcceptedIssuers() {
         return pkixTrustManager.getAcceptedIssuers();
     }
}
Once you have created such a trust manager, assign it to an SSLContext via the init method. Future SocketFactories created from this SSLContext will use your new TrustManager when making trust decisions.
TrustManager[] myTMs = new TrustManager [] {
                          new MyX509TrustManager() };
SSLContext ctx = SSLContext.getInstance("TLS");
ctx.init(null, myTMs, null);

Updating the keyStore Dynamically

You can enhance MyX509TrustManager to handle dynamic keystore updates. When a checkClientTrusted or checkServerTrusted test fails and does not establish a trusted certificate chain, you can add the required trusted certificate to the keystore. You need to create a new pkixTrustManager from the TrustManagerFactory initialized with the updated keystore. When you establish a new connection (using the previously initialized SSLContext), the newly added certificate will be called to make the trust decisions.

KeyManager Interface

The primary responsibility of the KeyManager is to select the authentication credentials that will eventually be sent to the remote host. To authenticate yourself (a local secure socket peer) to a remote peer, you need to initialize an SSLContext object with one or more KeyManagers. You need to pass one KeyManager for each different authentication mechanism that will be supported. If null is passed into the SSLContext initialization, an empty KeyManager will be created. If the internal default context is used (e.g. a SSLContext created by SSLSocketFactory.getDefault() or SSLServerSocketFactory.getDefault()), a default KeyManager is created. Typically, there is a single key manager that supports authentication based on X.509 public key certificates. Some secure socket implementations may also support authentication based on shared secret keys, Kerberos, or other mechanisms.

KeyManagers are created either by a KeyManagerFactory, or by providing a concrete implementation of the interface.

KeyManagerFactory Class

javax.net.ssl.KeyManagerFactory is an engine class for a provider-based service that acts as a factory for one or more types of KeyManager objects. The SunJSSE provider implements a factory which can return a basic X.509 key manager. Because it is provider-based, additional factories can be implemented and configured to provide additional or alternate key managers.

Creating a KeyManagerFactory

You create an instance of this class in a similar manner to SSLContext, except for passing an algorithm name string instead of a protocol name to the getInstance method:
public static KeyManagerFactory
                  getInstance(String algorithm);

public static KeyManagerFactory
                  getInstance(String algorithm,
                              String provider);

public static KeyManagerFactory
                  getInstance(String algorithm,
                              Provider provider);

A sample algorithm name string is:

"SunX509"

A sample call is the following:

KeyManagerFactory kmf =
    KeyManagerFactory.getInstance("SunX509", "SunJSSE");

The above call will create an instance of the SunJSSE provider's default key manager factory, which provides basic X.509-based authentication keys.

A newly-created factory should be initialized by calling one of the init methods:

public void init(KeyStore ks, char[] password);
public void init(ManagerFactoryParameters spec);

You should call whichever init method is appropriate for the KeyManagerFactory you are using. (Ask the provider vendor.)

For many factories, such as the default "SunX509" KeyManagerFactory from the SunJSSE provider, the KeyStore and password are the only information required in order to initialize the KeyManagerFactory and thus the first init method is the appropriate one to call. The KeyManagerFactory will query the KeyStore for information on which private key and matching public key certificates should be used for authenticating to a remote socket peer. The password parameter specifies the password that will be used with the methods for accessing keys from the KeyStore. All keys in the KeyStore must be protected by the same password.

In some cases, initialization parameters other than a KeyStore and password may be needed by a provider. Users of that particular provider are expected to pass an implementation of the appropriate ManagerFactoryParameters as defined by the provider. The provider can then call the specified methods in the ManagerFactoryParameters implementation to obtain the needed information.

Some factories are capable of providing access to authentication material without having to be initialized with a KeyStore object or any other parameters. For example, they may access key material as part of a login mechanism such as one based on JAAS, the Java Authentication and Authorization Service.

As indicated above, the SunJSSE provider supports a "SunX509" factory that must be initialized with a KeyStore parameter.

X509KeyManager Interface

The javax.net.ssl.X509KeyManager interface extends the general KeyManager interface. It must be implemented by a key manager for X.509-based authentication. In order to support X.509 authentication to remote socket peers through JSSE, an instance of this interface must be passed to the init method of an SSLContext object.

Creating an X509KeyManager

You can either implement this interface directly yourself or obtain one from a provider-based KeyManagerFactory (such as those supplied by the SunJSSE provider). You could also implement your own that delegates to a factory-generated key manager. For example, you might do this in order to filter the resulting keys and query an end-user through a graphical user interface.

Creating Your Own X509KeyManager

If the default X509KeyManager behavior isn't suitable for your situation, you can create your own X509KeyManager in a way similiar to that shown in Creating Your Own X509TrustManager.

Relationships between TrustManagers and KeyManagers

Historically there has been confusion regarding the jobs of TrustManagers and KeyManagers. In summary, here are the primary responsibilities of each manager type:
Type | Function
TrustManager | Determines whether the remote authentication credentials (and thus the connection) should be trusted.
KeyManager | Determines which authentication credentials to send to the remote host.

Secondary Support Classes and Interfaces

These classes are provided as part of the JSSE API to support the creation, use, and management of secure sockets. They are less likely to be used by secure socket applications than are the core and support classes. The secondary support classes and interfaces are part of the javax.net.ssl and javax.security.cert packages.

SSLSessionContext Interface

A javax.net.ssl.SSLSessionContext is a grouping of SSLSessions associated with a single entity. For example, it could be associated with a server or client that participates in many sessions concurrently. The methods on this interface enable the enumeration of all sessions in a context and allow lookup of specific sessions via their session ids.

An SSLSessionContext may optionally be obtained from an SSLSession by calling the SSLSession getSessionContext method. The context may be unavailable in some environments, in which case the getSessionContext method returns null.

SSLSessionBindingListener Interface

javax.net.ssl.SSLSessionBindingListener is an interface implemented by objects which want to be notified when they are being bound or unbound from an SSLSession.

SSLSessionBindingEvent Class

A javax.net.ssl.SSLSessionBindingEvent is the event communicated to an SSLSessionBindingListener when it is bound or unbound from an SSLSession.

HandShakeCompletedListener Interface

javax.net.ssl.HandShakeCompletedListener is an interface implemented by any class which wants to receive notification of the completion of an SSL protocol handshake on a given SSLSocket connection.

HandShakeCompletedEvent Class

A javax.net.ssl.HandShakeCompletedEvent is the event communicated to a HandShakeCompletedListener upon completion of an SSL protocol handshake on a given SSLSocket connection.

HostnameVerifier Interface

If the SSL/TLS implementation's standard hostname verification logic fails, the implementation will call the verify method of the class which implements this interface and is assigned to this HttpsURLConnection instance. If the callback class can determine that the hostname is acceptable given the parameters, it should report that the connection should be allowed. An unacceptable response will cause the connection to be terminated.

For example:

public class MyHostnameVerifier implements HostnameVerifier {

    public boolean verify(String hostname, SSLSession session) {
        // pop up an interactive dialog box
        // or insert additional matching logic
        if (good_address) {
            return true;
        } else {
            return false;
        }
    }
}

//...deleted...

HttpsURLConnection urlc = (HttpsURLConnection)
  (new URL("https://www.sun.com/")).openConnection();
urlc.setHostnameVerifier(new MyHostnameVerifier());
See HttpsURLConnection Class for more information on how to assign the HostnameVerifier to the HttpsURLConnection.

X509Certificate Class

Many secure socket protocols perform authentication using public key certificates, also called X.509 certificates. This is the default authentication mechanism for the SSL and TLS protocols.

The java.security.cert.X509Certificate abstract class provides a standard way to access the attributes of X.509 certificates.

Note: The javax.security.cert.X509Certificate class is supported only for backward compatibility with previous (1.0.x and 1.1.x) versions of JSSE. New applications should use java.security.cert.X509Certificate, not javax.security.cert.X509Certificate.

Previous (JSSE 1.0.x) Implementation Classes and Interfaces

In previous (1.0.x) versions of JSSE, there was a reference implementation whose classes and interfaces were provided in the com.sun.net.ssl package.

As of v1.4, JSSE has been integrated into the J2SDK. The classes formerly in com.sun.net.ssl have been promoted to the javax.net.ssl package and are now a part of the standard JSSE API.

For compatibility purposes the com.sun.net.ssl classes and interfaces still exist, but have been deprecated. Applications written using them can run in the J2SDK v1.4 and later without being recompiled. This may change in a future release; these classes/interfaces may be removed. Thus, all new applications should be written using the javax classes/interfaces.

For now, applications written using the com.sun.net.ssl API can utilize either JSSE 1.0.2 providers (ones using com.sun.net.ssl) or JSSE providers written for the J2SDK v1.4 and later (ones using the javax API). However, applications written using the JSSE API in the J2SDK 1.4 and later can only utilize JSSE providers written for the J2SDK 1.4 and later. There more recent releases contain some new functionality and attempting to access such functionality on a provider that doesn't supply it wouldn't work. SunJSSE, provided with the JDK from Sun Microsystems, is a provider written using the javax API.

You can still obtain a com.sun.net.ssl.HttpsURLConnection if you update the URL search path by setting the java.protocol.handler.pkgs System property as you did when using JSSE 1.0.2. For more information, see Code Using HttpsURLConnection Class... in the Troubleshooting section.

Customizing JSSE

The Installation Directory <java-home>

The term <java-home> is used throughout this document to refer to the directory where the Java SE 6 Runtime Environment (JRE) is installed. It is determined based on whether you are running JSSE on a JRE with or without the JavaTM SDK installed. Java SE 6 SDK includes the JRE, but it is located in a different level in the file hierarchy.

The following are some examples of which directories <java-home> refers to:

  • On Solaris, if the Java SE 6 SDK is installed in /home/user1/jdk1.6.0, then <java-home> is
    /home/user1/jdk1.6.0/jre

  • On Solaris, if JRE is installed in /home/user1/jre1.6.0 and the Java 2 SDK is not installed, then <java-home> is
    /home/user1/jre1.6.0

  • On Microsoft Windows platforms, if the Java SE 6 SDK is installed in C:\jdk1.6.0, then <java-home> is
    C:\j2k1.6.0\jre

  • On Microsoft Windows platforms, if the JRE is installed in C:\jre1.6.0 and the Java SE 6 SDK is not installed, then <java-home> is
    C:\jre1.6.0

Customization

JSSE includes an implementation that all users can utilize. If desired, it is also possible to customize a number of aspects of JSSE, plugging in different implementations or specifying the default keystore, etc. The table below summarizes which aspects can be customized, what the defaults are, and which mechanisms are used to provide customization. The first column of the table provides links to more detailed descriptions of each designated aspect and how to customize it.

Some of the customizations are done by setting system property or security property values. Sections following the table explain how to set such property values.

IMPORTANT NOTE: Many of the properties shown in this table are currently utilized by the JSSE implementation, but there is no guarantee that they will continue to have the same names and types (system or security) or even that they will exist at all in future releases. All such properties are flagged with an "*". They are documented here for your convenience for use with the JSSE implementation.
JSSE Customization

Customizable Item

Default

How To Customize
X509Certificate implementation

X509Certificate implementation from Sun Microsystems

cert.provider.x509v1 security property
HTTPS protocol implementation

Implementation from Sun Microsystems

java.protocol.handler.pkgs system property
provider implementation

SunJSSE

A security.provider.n= line in security properties file. See description.

default SSLSocketFactory implementation

SSLSocketFactory implementation from Sun Microsystems.

** ssl.SocketFactory.provider security property
default SSLServerSocketFactory implementation

SSLServerSocketFactory implementation from Sun Microsystems.

** ssl.ServerSocketFactory.provider security property
default keystore

No default.

* javax.net.ssl.keyStore system property
Note that the value NONE may be specified. This setting is appropriate if the keystore is not file-based (for example, it resides in a hardware token).

default keystore password

No default.

* javax.net.ssl.keyStorePassword system property
default keystore provider

No default.

* javax.net.ssl.keyStoreProvider system property
default keystore type

KeyStore.getDefaultType()

* javax.net.ssl.keyStoreType system property
default truststore

jssecacerts, if it exists. Otherwise, cacerts

* javax.net.ssl.trustStore system property
default truststore password

No default.

* javax.net.ssl.trustStorePassword system property
default truststore provider

No default.

* javax.net.ssl.trustStoreProvider system property
default truststore type

KeyStore.getDefaultType()

* javax.net.ssl.trustStoreType system property
Note that the value NONE may be specified. This setting is appropriate if the truststore is not file-based (for example, it resides in a hardware token.)

default key manager factory algorithm name

SunX509

 ssl.KeyManagerFactory.algorithm security property
default trust manager factory algorithm name

PKIX

 ssl.TrustManagerFactory.algorithm security property
default proxy host

No default.

 * https.proxyHost system property
default proxy port

80

 * https.proxyPort system property
default ciphersuites

Determined by the socket factory.

 * https.cipherSuites system property. This contains a comma-separated list of cipher suite names specifying which cipher suites to enable for use on this HttpsURLConnection. See the SSLSocket setEnabledCipherSuites(String[]) method.
default handshaking protocols

Determined by the socket factory

 * https.protocols system property. This contains a comma-separated list of protocol suite names specifying which protocol suites to enable on this HttpsURLConnection. See the SSLSocket setEnabledProtocols(String[]) method.
default https port

443

 * Customize via port field in the https URL.
JCE encryption algorithms used by SunJSSE provider

SunJCE implementations

 Give alternate JCE algorithm provider(s) a higher preference order than the SunJCE provider
defaultly sizing buffers for large SSL/TLS packets

No default.

* jsse.SSLEngine.acceptLargeFragments system property
By setting this system property to true, SSLSession will size buffers to handle large data packets by default. This may cause applications to allocate unnecessarily large SSLEngine buffers. Instead, applications should dynamically check for buffer overflow conditions and resize buffers as appropriate.

.

* This property is currently used by the JSSE implementation. It is not guaranteed to be examined and used by other implementations. If it is examined by another implementation, that implementation should handle it in the same manner as the JSSE implementation does. There is no guarantee the property will continue to exist or be of the same type (system or security) in future releases.

Note that some items are customized by setting java.lang.system properties while others are customized by setting java.security.Security properties. The following sections explain how to set values for both types of properties.

How to Specify a java.lang.system Property

Some aspects of JSSE may be customized by setting system properties. You can set a system property either statically or dynamically:

  • To set a system property statically, use the -D option of the java command. For example, to run an application named MyApp and set the javax.net.ssl.trustStore system property to specify a truststore named "MyCacertsFile", type the following:
    java -Djavax.net.ssl.trustStore=MyCacertsFile MyApp

  • To set a system property dynamically, call the java.lang.System.setProperty method in your code:
    System.setProperty(propertyName,
        "propertyValue");
    substituting the appropriate property name and value. For example, a setProperty call corresponding to the previous example for setting the javax.net.ssl.trustStore system property to specify a truststore named "MyCacertsFile" would be:
    System.setProperty("javax.net.ssl.trustStore",
        "MyCacertsFile");

How to Specify a java.security.Security Property

Some aspects of JSSE may be customized by setting security properties. You can set a security property either statically or dynamically:

  • To set a security property statically, add a line to the security properties file. The security properties file is located at:
    <java-home>/lib/security/java.security
    where <java-home> refers to the directory where the JRE runtime software is installed, as described in The Installation Directory <java-home>.

    To specify a security property value in the security properties file, you add a line of the following form:

    propertyName=propertyValue

    For example, suppose you want to specify a different key manager factory algorithm name than the "SunX509" default. You do this by specifying the algorithm name as the value of a security property named ssl.KeyManagerFactory.algorithm. Suppose you want to set the value to "MyX509". To do so, place the following in the security properties file:

    ssl.KeyManagerFactory.algorithm=MyX509

  • To set a security property dynamically, call the java.security.Security.setProperty method in your code:
    Security.setProperty(propertyName,
        "propertyValue");
    substituting the appropriate property name and value. For example, a setProperty call corresponding to the previous example for specifying the key manager factory algorithm name would be:
    Security.setProperty("ssl.KeyManagerFactory.algorithm",
        "MyX509");

Customizing the X509Certificate Implementation

The X509Certificate implementation returned by the X509Certificate.getInstance method is by default the implementation from the JSSE implementation.

You can optionally cause a different implementation to be returned. To do so, specify the name (and package) of the alternate implementation's class as the value of a security property named cert.provider.x509v1. For example, if the class is called MyX509CertificateImpl and it appears in the com.cryptox package, you should place the following in the security properties file:

cert.provider.x509v1=com.cryptox.MyX509CertificateImpl

Specifying an Alternate HTTPS Protocol Implementation

You can communicate securely with an SSL-enabled web server by using the "https" URL scheme for the java.net.URL class. The JDK provides a default https URL implementation.

If you want an alternate https protocol implementation to be used, set the java.protocol.handler.pkgs system property to include the new class name. This action causes the specified classes to be found and loaded before the JDK default classes. See the java.net.URL class documentation for details.

Note to previous JSSE users: In past Sun JSSE releases, you had to set the java.protocol.handler.pkgs system property during JSSE installation. This step is no longer required unless you wish to obtain an instance of com.sun.net.ssl.HttpsURLConnection. For more information, see Code Using HttpsURLConnection Class... in the Troubleshooting section.

Customizing the Provider Implementation

The J2SDK 1.4 and later releases come standard with a JSSE Cryptographic Service Provider, or provider for short, named "SunJSSE". Providers are essentially packages that implement one or more engine classes for specific cryptographic algorithms. The JSSE engine classes are SSLContext, KeyManagerFactory, and TrustManagerFactory. For more information on providers and engine classes, see the "Design Principles" and "Concepts" sections of the JavaTM Cryptography Architecture Reference Guide.

In order to be used, a provider must be registered, either statically or dynamically. You do not need to register the "SunJSSE" provider because it is pre-registered. If you want to use other providers, read the following sections to see how to register them.

Registering the Cryptographic Service Provider Statically

You register a provider statically by adding a line of the following form to the security properties file:
security.provider.n=providerClassName

This declares a provider, and specifies its preference order "n". The preference order is the order in which providers are searched for requested algorithms (when no specific provider is requested). The order is 1-based; 1 is the most preferred, followed by 2, and so on.

The providerClassName is the fully qualified name of the provider class. You get this name from the provider vendor.

To register a provider, add the above line to the security properties file, replacing providerClassName with the fully qualified name of the provider class and substituting n with the priority that you would like to assign to the provider.

The standard security provider and the SunJSSE provider shipped with the Java SE 6 platform are automatically registered for you; the following lines appear in the java.security security properties file to register the SunJCE security provider with preference order 5 and the SunJSSE provider with preference order 4:

      security.provider.1=sun.security.pkcs11.SunPKCS11 \
          ${java.home}/lib/security/sunpkcs11-solaris.cfg
      security.provider.2=sun.security.provider.Sun
      security.provider.3=sun.security.rsa.SunRsaSign
      security.provider.4=com.sun.net.ssl.internal.ssl.Provider
      security.provider.5=com.sun.crypto.provider.SunJCE
      security.provider.6=sun.security.jgss.SunProvider
      security.provider.7=com.sun.security.sasl.Provider

To utilize another JSSE provider, add a line registering the alternate provider, giving it whatever preference order you prefer.

You can have more than one JSSE provider registered at the same time. They may include different implementations for different algorithms for different engine classes, or they may have support for some or all of the same types of algorithms and engine classes. When a particular engine class implementation for a particular algorithm is searched for, if no specific provider is specified for the search, the providers are searched in preference order and the implementation from the first provider that supplies an implementation for the specified algorithm is used.

Registering the Cryptographic Service Provider Dynamically

Instead of registering a provider statically, you can add the provider dynamically at runtime by calling the Security.addProvider method at the beginning of your program. For example, to dynamically add a provider whose Provider class name is MyProvider and whose MyProvider class resides in the com.ABC package, you would call:

Security.addProvider(
  new com.ABC.MyProvider());

The Security.addProvider method adds the specified provider to the next available preference position.

This type of registration is not persistent and can only be done by a program with sufficient permissions.

Customizing the Default Key and Trust Stores, Store Types, and Store Passwords

Whenever a default SSLSocketFactory or SSLServerSocketFactory is created (via a call to SSLSocketFactory.getDefault or SSLServerSocketFactory.getDefault), and this default SSLSocketFactory (or SSLServerSocketFactory) comes from the JSSE reference implementation, a default SSLContext is associated with the socket factory. (The default socket factory will come from the JSSE implementation.)

This default SSLContext is initialized with a default KeyManager and a TrustManager. If a keystore is specified by the javax.net.ssl.keyStore system property and an appropriate javax.net.ssl.keyStorePassword system property, then the KeyManager created by the default SSLContext will be a KeyManager implementation for managing the specified keystore. (The actual implementation will be as specified in Customizing the Default Key and Trust Managers.) If no such system property is specified, then the keystore managed by the KeyManager will be a new empty keystore.

Generally, the peer acting as the server in the handshake will need a keystore for its KeyManager in order to obtain credentials for authentication to the client. However, if one of the anonymous cipher suites is selected, the server's KeyManager keystore is not necessary. And, unless the server requires client authentication, the peer acting as the client will not need a KeyManager keystore. Thus, in these situations it may be okay if there is no javax.net.ssl.keyStore system property value defined.

Similarly, if a truststore is specified by the javax.net.ssl.trustStore system property, then the TrustManager created by the default SSLContext will be a TrustManager implementation for managing the specified truststore. In this case, if such a property exists but the file it specifies doesn't, then no truststore is utilized. If no javax.net.ssl.trustStore property exists, then a default truststore is searched for. If a truststore named <java-home>/lib/security/jssecacerts is found, it is used. If not, then a truststore named <java-home>/lib/security/cacerts is searched for and used (if it exists). See The Installation Directory <java-home> for information as to what <java-home> refers to. Finally, if a truststore is still not found, then the truststore managed by the TrustManager will be a new empty truststore.

IMPORTANT NOTE: The JDK ships with a limited number of trusted root certificates in the <java-home>/lib/security/cacerts file. As documented in keytool, it is your responsibility to maintain (that is, add/remove) the certificates contained in this file if you use this file as a truststore.

Depending on the certificate configuration of the servers you contact, you may need to add additional root certificate(s). Obtain the needed specific root certificate(s) from the appropriate vendor.

If system properties javax.net.ssl.keyStoreType and/or javax.net.ssl.keyStorePassword are also specified, they are treated as the default KeyManager keystore type and password, respectively. If there is no type specified, the default type is that returned by KeyStore.getDefaultType(), which is the value of the keystore.type security property, or "jks" if no such security property is specified. If there is no keystore password specified, it is assumed to be "".

Similarly, if system properties javax.net.ssl.trustStoreType and/or javax.net.ssl.trustStorePassword are also specified, they are treated as the default truststore type and password, respectively. If there is no type specified, the default type is that returned by KeyStore.getDefaultType(). If there is no truststore password specified, it is assumed to be "".

Important Note: This section describes the current JSSE reference implementation behavior. The system properties described in this section are not guaranteed to continue to have the same names and types (system or security) or even to exist at all in future releases. They are also not guaranteed to be examined and used by any other JSSE implementations. If they are examined by an implementation, that implementation should handle them in the same manner as the JSSE reference implementation does, as described herein.

Customizing the Default Key and Trust Managers

As noted in Customizing the Default Key and Trust Stores, Store Types, and Store Passwords, whenever a default SSLSocketFactory or SSLServerSocketFactory is created, and this default SSLSocketFactory (or SSLServerSocketFactory) comes from the JSSE reference implementation, a default SSLContext is associated with the socket factory.

This default SSLContext is initialized with a KeyManager and a TrustManager. The KeyManager and/or TrustManager supplied to the default SSLContext will be a KeyManager/TrustManager implementation for managing the specified keystore/truststore, as described in the aforementioned section.

The KeyManager implementation chosen is determined by first examining the

ssl.KeyManagerFactory.algorithm
security property. If such a property value is specified, a KeyManagerFactory implementation for the specified algorithm is searched for. The implementation from the first provider that supplies an implementation is used. Its getKeyManagers method is called to determine the KeyManager to supply to the default SSLContext. (Technically, getKeyManagers returns an array of KeyManagers, one KeyManager for each type of key material.) If there is no such security property value specified, the default value of "SunX509" is used to perform the search. Note: A KeyManagerFactory implementation for the "SunX509" algorithm is supplied by the SunJSSE provider. The KeyManager it specifies is a javax.net.ssl.X509KeyManager implementation.

Similarly, the TrustManager implementation chosen is determined by first examining the

ssl.TrustManagerFactory.algorithm
security property. If such a property value is specified, a TrustManagerFactory implementation for the specified algorithm is searched for. The implementation from the first provider that supplies an implementation is used. Its getTrustManagers method is called to determine the TrustManager to supply to the default SSLContext. (Technically, getTrustManagers returns an array of TrustManagers, one TrustManager for each type of trust material.) If there is no such security property value specified, the default value of "PKIX" is used to perform the search. Note: A TrustManagerFactory implementation for the "PKIX" algorithm is supplied by the SunJSSE provider. The TrustManager it specifies is a javax.net.ssl.X509TrustManager implementation.

Important Note: This section describes the current JSSE reference implementation behavior. The system properties described in this section are not guaranteed to continue to have the same names and types (system or security) or even to exist at all in future releases. They are also not guaranteed to be examined and used by any other JSSE implementations. If they are examined by an implementation, that implementation should handle them in the same manner as the JSSE reference implementation does, as described herein.

Customizing the Encryption Algorithm Providers

As of the Java SE 5 release, the SunJSSE provider uses the SunJCE implementation for all its cryptographic needs. While it is recommended that you leave the Sun provider at its regular position, you can use implementations from other JCA/JCE providers by registering them before the SunJCE provider. The standard JCA mechanism can be used to configure providers, either statically via the security properties file

<java-home>/lib/security/java.security
or dynamically via the addProvider or insertProviderAt method in the java.security.Security class. (See The Installation Directory <java-home> for information about what <java-home> refers to.)

Note for People Implementing Providers

The transformation strings used when SunJSSE calls Cipher.getInstance() are "RSA/ECB/PKCS1Padding", "RC4", "DES/CBC/NoPadding", and "DESede/CBC/NoPadding". For further information on the Cipher class and transformation strings see the Cryptography Specification.

JCE and Hardware Acceleration/Smartcard Support

Use of JCE

The Java Cryptography Extension (JCE) is a set of packages that provides a framework and implementations for encryption, key generation and key agreement, and Message Authentication Code (MAC) algorithms. Prior to Java SE 5, the SunJSSE provider could make use of JCE providers when configured to do so, but it still contained internal cryptographic code that did not use JCE. In Java SE 6, the SunJSSE provider uses JCE exclusively for all of its cryptographic operations and hence, is able to automatically take advantage of JCE features and enhancements, including JCE's newly added support for PKCS#11. This allows the SunJSSE provider in Java SE 6 to be able to use hardware cryptographic accelerators for significant performance improvements and to use Smartcards as keystores for greater flexibility in key and trust management.

Hardware Accelerators

Use of hardware cryptographic accelerators is automatic if JCE has been configured to use the Sun PKCS#11 provider, which in turn has been configured to use the underlying accelerator hardware. The provider must be configured before any other JCE/JCA providers in the provider list. See the PKCS#11 Guide for details on how to configure the Sun PKCS#11 provider.

Configuring JSSE to use Smartcards as Keystores and Trust Stores

Support in JCE for PKCS#11 also enables access to Smartcards as a keystore. See the Customization section for details on how to configure the type and location of the keystores to be used by JSSE. To use a Smartcard as a keystore or trust store, set the javax.net.ssl.keyStoreType and javax.net.ssl.trustStoreType system properties, respectively, to "pkcs11", and set the javax.net.ssl.keyStore and javax.net.ssl.trustStore system properties, respectively, to NONE. To specify the use of a specific provider, use the javax.net.ssl.keyStoreProvider and javax.net.ssl.trustStoreProvider system properties (e.g., "SunPKCS11-joe"). By using these properties, you can configure an application that previously depended on these properties to access a file-based keystore to use a Smartcard keystore with no changes to the application.

Some applications request the use of keystores programmatically. These applications can continue to use the existing APIs to instantiate a Keystore and pass it to its key manager and trust manager. If the Keystore instance refers to a PKCS#11 keystore backed by a Smartcard, then the JSSE application will have access to the keys on the Smartcard.

Multiple and Dynamic Keystores

Smartcards (and other removable tokens) have additional requirements for an X509KeyManager. Different Smartcards may be present in a Smartcard reader during the lifetime of a Java application and they may protected using different passwords. The pre-J2SE 5 APIs and the SunX509 key manager do not accomodate these requirements well. As a result, in Java SE 5, new APIs were introduced and a new X509KeyManager implementation was added to the SunJSSE provider.

The java.security.KeyStore.Builder class abstracts the construction and initialization of a KeyStore object. It supports the use of CallbackHandlers for password prompting and can be subclassed to support additional features as desired by an application. For example, it is possible to implement a Builder that allows individual KeyStore entries to be protected with different passwords. The javax.net.ssl.KeyStoreBuilderParameters class then can be used to initialize a KeyManagerFactory using one or more of these Builder objects.

A new X509KeyManager implementation in the SunJSSE provider called "NewSunX509" supports these parameters. If multiple certificates are available, it also makes the effort to pick a certificate with the appropriate key usage and prefers valid to expired certificates

Here is an example of how to tell JSSE to use both a PKCS#11 keystore (which might in turn use a Smartcard) and a PKCS#12 file-based keystore.

import javax.net.ssl.*;
import java.security.KeyStore.*;
...

// Specify keystore builder parameters for PKCS#11 keystores
Builder scBuilder = Builder.newInstance("PKCS11", null,
    new CallbackHandlerProtection(myGuiCallbackHandler));

// Specify keystore builder parameters for a specific PKCS#12 keystore
Builder fsBuilder = Builder.newInstance("PKCS12", null,
    new File(pkcsFileName), new PasswordProtection(pkcsKsPassword));

// Wrap them as key manager parameters
ManagerFactoryParameters ksParams =
    new KeyStoreBuilderParameters(
    Arrays.asList(new Builder[] { scBuilder, fsBuilder }));

// Create KeyManagerFactory
KeyManagerFactory factory = KeyManagerFactory.getInstance("NewSunX509");

// Pass builder parameters to factory
factory.init(ksParams);

// Use factory
SSLContext ctx = SSLContext.getInstance("TLS");
ctx.init(factory.getKeyManagers(), null, null);

Kerberos Cipher Suites

In Java SE 6, the SunJSSE provider has support for Kerberos cipher suites, as described in RFC 2712. The following cipher suites are supported but not enabled by default.
TLS_KRB5_WITH_RC4_128_SHA
TLS_KRB5_WITH_RC4_128_MD5
TLS_KRB5_WITH_3DES_EDE_CBC_SHA
TLS_KRB5_WITH_3DES_EDE_CBC_MD5
TLS_KRB5_WITH_DES_CBC_SHA
TLS_KRB5_WITH_DES_CBC_MD5
TLS_KRB5_EXPORT_WITH_RC4_40_SHA
TLS_KRB5_EXPORT_WITH_RC4_40_MD5
TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA
TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5
To enable use of these cipher suites, you must do so explicitly. See SSLEngine.setEnabledCipherSuites() and SSLSocket.setEnabledCipherSuites() for more information. As with all other SSL/TLS cipher suites, if a cipher suite is not supported by the peer, then it won't be selected during cipher negotiation. Furthermore, if the application and/or server cannot acquire the necessary Kerberos credentials, then the Kerberos cipher suites also will not be selected.

Here is an example of a TLS client that wants to use only the TLS_KRB5_WITH_DES_CBC_SHA cipher suite.

// Create socket
SSLSocketFactory sslsf = (SSLSocketFactory) SSLSocketFactory.getDefault();
SSLSocket sslSocket = (SSLSocket) sslsf.createSocket(tlsServer, serverPort);

// Enable only one cipher suite
String enabledSuites[] = { "TLS_KRB5_WITH_DES_CBC_SHA" };
sslSocket.setEnabledCipherSuites(enabledSuites);

Kerberos Requirements

You must have the Kerberos infrastructure set up in your deployment environment before you can use the Kerberos cipher suites with JSSE. In particular, both the TLS client and server must have accounts set up with the Kerberos Key Distribution Center (KDC). At runtime, if one or more of the Kerberos cipher suites have been enabled, the TLS client and server will acquire their Kerberos credentials associated with their respective account from the KDC. For example, a TLS server running on the machine mach1.imc.org in the Kerberos realm IMC.ORG must have an account with the name host/mach1.imc.org@IMC.ORG and be configured to use the KDC for IMC.ORG. See the Kerberos Requirements document for information about using Kerberos with Java SE .

An application can acquire its Kerberos credentials by using the Java Authentication and Authorization Service (JAAS) and a Kerberos login module. Java SE Development Kit 6 comes with a Kerberos login module. You can use the Kerberos cipher suites with JSSE with, or without JAAS programming, similar to how you can use the Java Generic Security Services (Java GSS) with, or without JAAS programming.

To use it without JAAS programming, you must use the index names "com.sun.net.ssl.server" or "other" for the TLS server JAAS configuration entry and "com.sun.net.ssl.client" or "other" for the TLS client, and set the system property javax.security.auth.useSubjectCredsOnly to false. For example, a TLS server that is not using JAAS programming might have the following JAAS configuration file.

com.sun.net.ssl.server {
  com.sun.security.auth.module.Krb5LoginModule required
        principal="host/mach1.imc.org@IMC.ORG"
        useKeyTab=true
        keyTab=mach1.keytab
    storeKey=true;
};
An example of how to Java GSS and Kerberos without JAAS programming is described in the Java GSS Tutorial. You can adapt it to use JSSE by replacing Java GSS calls with JSSE calls.

To use the Kerberos cipher suites with JAAS programming, you can use any index name because your application is responsible for creating the JAAS LoginContext using the index name, and then wrapping the JSSE calls inside of a Subject.doAs() or Subject.doAsPrivileged() call. An example of how to use JAAS with Java GSS and Kerberos is described in the Java GSS Tutorial. You can adapt it to use JSSE by replacing Java GSS calls with JSSE calls.

If you have trouble using or configuring the JSSE application to use Kerberos, see the Troubleshooting section of the Java GSS Tutorial.

Peer Identity Information

To determine the identity of the peer of an SSL connection, use the getPeerPrincipal() method in the following classes: javax.net.ssl.SSLSession, javax.net.ssl.HttpsURLConnection, and javax.net.HandshakeCompletedEvent. Similarly, to get the identity that was sent to the peer (to identify the local entity), use getLocalPrincipal() in these classes. For X509-based cipher suites, these methods will return an instance of javax.security.auth.x500.X500Principal; for Kerberos cipher suites, these methods will return an instance of javax.security.auth.kerberos.KerberosPrincipal.

Prior to Java SE 5, JSSE applications used getPeerCertificates() and similar methods in javax.net.ssl.SSLSession, javax.net.ssl.HttpsURLConnection, and javax.net.HandshakeCompletedEvent to obtain information about the peer. When the peer does not have any certificates, SSLPeerUnverifiedException is thrown. The behavior of these methods remain unchanged in Java SE 6, which means that if the connection was secured using a Kerberos cipher suite, these methods will throw SSLPeerUnverifiedException.

If the application needs to determine only the identity of the peer or identity sent to the peer, it should use the getPeerPrincipal() and getLocalPrincipal() methods, respectively. It should use getPeerCertificates() and getLocalCertificates() only if it needs to examine the contents of those certificates. Furthermore, it must be prepared to handle the case where an authenticated peer might not have any certificate.

Security Manager

When the security manager has been enabled, in addition to the SocketPermissions needed to communicate with the peer, a TLS client application that uses the Kerberos cipher suites also needs the following permission.
javax.security.auth.kerberos.ServicePermission(serverPrincipal, "initiate");
where serverPrincipal is the Kerberos principal name of the TLS server that the TLS client will be communicating with, such as host/mach1.imc.org@IMC.ORG. A TLS server application needs the following permission.
javax.security.auth.kerberos.ServicePermission(serverPrincipal, "accept");
where serverPrincipal is the Kerberos principal name of the TLS server, such as host/mach1.imc.org@IMC.ORG. If the server or client needs to contact the KDC (for example, if its credentials are not cached locally), it also needs the following permission.
javax.security.auth.kerberos.ServicePermission(tgtPrincipal, "initiate");
where tgtPrincipal is principal name of the KDC, such as krbtgt/IMC.ORG@IMC.ORG.

Additional Keystore Formats (PKCS12)

The PKCS#12 (Personal Information Exchange Syntax Standard) specifies a portable format for storage and/or transport of a user's private keys, certificates, miscellaneous secrets, and other items. The SunJSSE provider supplies a complete implementation of the PKCS12 java.security.KeyStore format for reading and write pkcs12 files. This format is also supported by other toolkits and applications for importing and exporting keys and certificates, such as Netscape/Mozilla, Microsoft's Internet Explorer, and OpenSSL. For example, these implementations can export client certificates and keys into a file using the ".p12" filename extension.

With the SunJSSE provider, you can access PKCS12 keys through the KeyStore API with a keystore type of "pkcs12" (or "PKCS12", the name is case-insensitive). In addition, you can list the installed keys and associated certificates using the keytool command with the -storetype option set to pkcs12. (See Security Tools for information about keytool.)

Troubleshooting

Configuration Problems

CertificateException: (while handshaking)

Problem: When negotiating an SSL connection, the client or server throws a CertificateException.

Cause 1: This is generally caused by the remote side sending a certificate that is unknown to the local side.

Solution 1: The best way to debug this type of problem is to turn on debugging (see Debugging Utilities) and watch as certificates are loaded and when certificates are received via the network connection. Most likely, the received certificate is unknown to the trust mechanism because the wrong trust file was loaded. Refer the following sections for more information:

  • Relationship Between Classes
  • TrustManager Interface
  • KeyManager Interface

Cause 2: The system clock is not set correctly.

Solution 2: If the clock is not set correctly, the perceived time may be outside the validity period on one of the certificates, and unless the certificate can be replaced with a valid one from a truststore, the system must assume that the certificate is invalid, and therefore throw the exception.

java.security.KeyStoreException: TrustedCertEntry not supported

Problem: Attempt to store trusted certificates in PKCS12 keystore throws java.security.KeyStoreException: TrustedCertEntry not supported.

Cause 1: We do not support storing trusted certificates in pkcs12 keystore. PKCS12 is mainly used to deliver private keys with the associated cert chains. It does not have any notion of "trusted" certificates. Note that in terms of interoperability, other pkcs12 vendors have the same restriction. Browsers such as Mozilla and Internet Explorer do not accept a pkcs12 file with only trusted certs.

Solution 1: Use JKS (or JCEKS) keystore for storing trusted certificates.

Runtime Exception: SSL Service Not Available

Problem: When running a program that uses JSSE, an exception occurs indicating that an SSL service is not available. For example, an exception similar to one of the following occurs:

    Exception in thread "main"
        java.net.SocketException: no SSL Server Sockets

    Exception in thread "main":
        SSL implementation not available

Cause: There was a problem with SSLContext initialization, for example due to an incorrect password on a keystore or a corrupted keystore. (Note: A JDK vendor once shipped a keystore in an unknown format, and that caused this type of error.)

Solution: Check initialization parameters. Ensure any keystores specified are valid and that the passwords specified are correct. (One way you can check these things is by trying to use the keytool to examine the keystore(s) and the relevant contents.)

Exception, "No available certificate corresponding to the SSL cipher suites which are enabled"

Problem: When I try to run a simple SSL Server program, the following exception is thrown:

Exception in thread "main" javax.net.ssl.SSLException:
No available certificate corresponding to the SSL
cipher suites which are enabled...

Cause: Various cipher suites require certain types of key material. For example, if an RSA cipher suite is enabled, an RSA keyEntry must be available in the keystore. If no such key is available, this cipher suite cannot be used. If there are no available key entries for all of the cipher suites enabled, this exception is thrown.

Solution: Create key entries for the various cipher suite types, or use an anonymous suite. (Be aware that anonymous ciphersuites are inherently dangerous because they are vulnerable to "man-in-the-middle" attacks, see RFC 2246.) Refer to the following sections to learn how to pass the correct keystore and certificates:

  • Relationship Between Classes
  • Customizing the Default Key and Trust Stores, Store Types, and Store Passwords
  • Additional Keystore Formats

Runtime Exception: No Cipher Suites in Common

Problem 1: When handshaking, the client and/or server throw this exception.

Cause 1: Both sides of an SSL connection must agree on a common ciphersuite. If the intersection of the client's ciphersuite set with the server's ciphersuite set is empty, then you will see this exception.

Solution 1: Configure the enabled cipher suites to include common ciphersuites, and be sure to provide an appropriate keyEntry for asymmetric ciphersuites. (See Exception, "No available certificate..." in this section.)

Problem 2: When using Netscape Navigator or Microsoft Internet Explorer (IE) to access files on a server that only has DSA-based certificates, a runtime exception occurs indicating that there are no cipher suites in common.

Cause 2: By default, keyEntries created with keytool use DSA public keys. If only DSA keyEntries exist in the keystore, only DSA-based ciphersuites can be used. By default, Navigator and IE send only RSA-based ciphersuites. Since the intersection of client and server ciphersuite sets is empty, this exception is thrown.

Solution 2: To interact with Navigator or IE, you should create certificates that use RSA-based keys. To do this, you need to specify the -keyalg RSA option when using keytool. For example:

    keytool -genkeypair -alias duke \
    -keystore testkeys -keyalg rsa

Slowness of the First JSSE Access

Problem: JSSE seems to stall on the first access.

Cause: JSSE must have a secure source of random numbers. The initialization takes a while.

Solution: Provide an alternate generator of random numbers, or initialize ahead of time when the overhead won't be noticed:

SecureRandom sr = new SecureRandom();
sr.nextInt();
SSLContext.init(..., ..., sr);
The <java-home>/lib/security/java.security file also provides a way to specify the source of seed data for SecureRandom: see the file for more information.

Code Using HttpsURLConnection Class Throws ClassCastException in JSSE 1.0.x

Problem: The following code snippet was written using JSSE 1.0.x's com.sun.net.ssl.HttpsURLConnection.

import com.sun.net.ssl.*;
...deleted...
HttpsURLConnection urlc = new URL("https://foo.com/").openConnection();
When running under this release, this code returns a javax.net.ssl.HttpsURLConnection and throws a ClassCastException.

Cause: By default, opening an "https" URL will create a javax.net.ssl.HttpsURLConnection.

Solution: Previous releases of the JDK (now known as the Java SE 6 SDK) did not ship with an "https" URL implemention. The JSSE 1.0.x implementation did provide such an "https" URL handler, and the installation guide described how to set the URL handler search path to obtain a JSSE 1.0.x com.sun.net.ssl.HttpsURLConnection implementation.

In this release, there is now an "https" handler in the default URL handler search path. It returns an instance of javax.net.ssl.HttpsURLConnection. By prepending the old JSSE 1.0.x implementation path to the URL search path via the java.protocol.handler.pkgs variable, you can still obtain a com.sun.net.ssl.HttpsURLConnection, and the code will no longer throw cast exceptions.

% java -Djava.protocol.handler.pkgs=\
  com.sun.net.ssl.internal.www.protocol YourClass
or
System.setProperty("java.protocol.handler.pkgs",
                   "com.sun.net.ssl.internal.www.protocol");

Socket Disconnected after Sending ClientHello Message

Problem: A socket attempts to connect, sends a ClientHello message, and is immediately disconnected.

Cause: Some SSL/TLS servers will disconnect if a ClientHello message is received in a format it doesn't understand or with a protocol version number that it doesn't support.

Solution: Try adjusting the protocols in SSLSocket.setEnabledProtocols. For example, some older server implementations speak only SSLv3 and do not understand TLS. Ideally, these implementations should negotiate to SSLv3, but some simply hangup. For backwards compatibility, some server implementations (such as SunJSSE) send SSLv3/TLS ClientHellos encapsulated in a SSLv2 ClientHello packet. Some servers do not accept this format, in these cases use setEnabledProtocols to disable the sending of encapsulated SSLv2 ClientHellos.

SunJSSE can not find a JCA/JCE provider which supports a required algorithm and causes NoSuchAlgorithmException

Problem: A handshake is attempted, and fails when it can not find a required algorithm. Examples might include:

Exception in thread ...deleted...
     ...deleted...
     Caused by java.security.NoSuchAlgorithmException: Cannot find any
provider supporting RSA/ECB/PKCS1Padding
or
     Caused by java.security.NoSuchAlgorithmException: Cannot find any
provider supporting AES/CBC/NoPadding

Cause: SunJSSE uses JCE for all of its cryptographic algorithms. By default, the Sun JDK will use the Standard Extension ClassLoader to load the SunJCE provider located in <java-home>/lib/ext/sunjce_provider.jar. If the file can't be found or loaded, or if the SunJCE provider has been deregistered from the Provider mechanism and an alternate implementation from JCE isn't available, this exception will be seen.

Solution: Ensure the SunJCE is available by checking the file is loadable and that the provider is registered with the Provider interface. Try to run the following code in the context of your SSL connection.

    import javax.crypto.*;

    System.out.println("=====Where did you get AES=====");
    Cipher c = Cipher.getInstance("AES/CBC/NoPadding");
    System.out.println(c.getProvider());

Debugging Utilities

JSSE provides dynamic debug tracing support. This is similar to the support used for debugging access control failures in the Java SE 6 platform. The generic Java dynamic debug tracing support is accessed with the system property java.security.debug, while the JSSE-specific dynamic debug tracing support is accessed with the system property javax.net.debug.

Note: The debug utility is not an officially supported feature of JSSE.

To view the options of the JSSE dynamic debug utility, use the following command-line option on the java command:

    -Djavax.net.debug=help

Note: If you specify the value help with either dynamic debug utility when running a program that does not use any classes that the utility was designed to debug, you will not get the debugging options.

Here is a complete example of how to get a list of the debug options:

    java -Djavax.net.debug=help MyApp
where MyApp is an application that uses some of the JSSE classes. MyApp will not run after the debug help information is printed, as the help code causes the application to exit.

Here are the current options:

        all        turn on all debugging
        ssl        turn on ssl debugging

        The following can be used with ssl:
            record          enable per-record tracing
            handshake       print each handshake message
            keygen          print key generation data
            session         print session activity
            defaultctx      print default SSL initialization
            sslctx          print SSLContext tracing
            sessioncache    print session cache tracing
            keymanager      print key manager tracing
            trustmanager    print trust manager tracing

        handshake debugging can be widened with:
            data            hex dump of each handshake message
            verbose         verbose handshake message printing

        record debugging can be widened with:
            plaintext       hex dump of record plaintext
            packet          print raw SSL/TLS packets
The javax.net.debug property value must specify either all or ssl, optionally followed by debug specifiers. You can use one or more options. You do not have to have a separator between options, although a separator such as ":" or "," helps readability. It doesn't matter what separators you use, and the ordering of the option keywords is also not important.

For an introduction on reading this debug information, please refer to the guide, Debugging SSL/TLS Connections.

Examples

  • To view all debugging messages:
        java -Djavax.net.debug=all MyApp

  • To view the hexadecimal dumps of each handshake message, you can type the following, where the colons are optional:
        java -Djavax.net.debug=ssl:handshake:data MyApp

  • To view the hexadecimal dumps of each handshake message, and to print trust manager tracing, you can type the following, where the commas are optional:
        java -Djavax.net.debug=SSL,handshake,data,trustmanager MyApp

Code Examples

The sections below describe the following code examples:

  • Converting an Unsecure Socket to a Secure Socket
    • Socket Example Without SSL
    • Socket Example With SSL

  • Running the JSSE Sample Code
    • Sample Code Illustrating a Secure Socket Connection Between a Client and a Server
      • Configuration Requirements
      • Running SSLSocketClient
      • Running SSLSocketClientWithTunneling
      • Running SSLSocketClientWithClientAuth
      • Running ClassFileServer
      • Running SSLSocketClientWithClientAuth With ClassFileServer
    • Sample Code Illustrating HTTPS Connections
      • Running URLReader
      • Running URLReaderWithOptions
    • Sample Code Illustrating a Secure RMI Connection
    • Sample Code Illustrating the Use of an SSLEngine
      • Running SSLEngineSimpleDemo
      • Running the NIO-based server

  • Creating a Keystore to Use with JSSE
    • Creating a Simple Keystore and Truststore

Converting an Unsecure Socket to a Secure Socket

This section provides examples of source code that illustrate how to use JSSE to convert an unsecure socket connection to a secure socket connection. The code in this section is excerpted from the book Java SE 6 Network Security by Marco Pistoia, et. al.

First, "Socket Example Without SSL" shows sample code that can be used to set up communication between a client and a server using unsecure sockets. This code is then modified in "Socket Example With SSL" to use JSSE to set up secure socket communication.

Socket Example Without SSL

Server Code for Unsecure Socket Communications

When writing a Java program that acts as a server and communicates with a client using sockets, the socket communication is set up with code similar to the following:

import java.io.*;
import java.net.*;

. . .

int port = availablePortNumber;

ServerSocket s;

try {
    s = new ServerSocket(port);
    Socket c = s.accept();

    OutputStream out = c.getOutputStream();
    InputStream in = c.getInputStream();

    // Send messages to the client through
    // the OutputStream
    // Receive messages from the client
    // through the InputStream
}

catch (IOException e) {
}

Client Code for Unsecure Socket Communications

The client code to set up communication with a server using sockets is similar to the following:

import java.io.*;
import java.net.*;

. . .

int port = availablePortNumber;
String host = "hostname";

try {
    s = new Socket(host, port);

    OutputStream out = s.getOutputStream();
    InputStream in = s.getInputStream();

    // Send messages to the server through
    // the OutputStream
    // Receive messages from the server
    // through the InputStream
}

catch (IOException e) {
}

Socket Example With SSL

Server Code for Secure Socket Communications

When writing a Java program that acts as a server and communicates with a client using secure sockets, the socket communication is set up with code similar to the following. Differences between this program and the one for communication using unsecure sockets are highlighted in bold.

import java.io.*;
import javax.net.ssl.*;

. . .

int port = availablePortNumber;

SSLServerSocket s;

try {
    SSLServerSocketFactory sslSrvFact =
        (SSLServerSocketFactory)
        SSLServerSocketFactory.getDefault();
    s =(SSLServerSocket)sslSrvFact.createServerSocket(port);

    SSLSocket c = (SSLSocket)s.accept();

    OutputStream out = c.getOutputStream();
    InputStream in = c.getInputStream();

    // Send messages to the client through
    // the OutputStream
    // Receive messages from the client
    // through the InputStream
}

catch (IOException e) {
}

Client Code for Secure Socket Communications

The client code to set up communication with a server using secure sockets is similar to the following, where differences with the unsecure version are highlighted in bold:

import java.io.*;
import javax.net.ssl.*;

. . .

int port = availablePortNumber;
String host = "hostname";

try {
    SSLSocketFactory sslFact =
      (SSLSocketFactory)SSLSocketFactory.getDefault();
    SSLSocket s =
      (SSLSocket)sslFact.createSocket(host, port);

    OutputStream out = s.getOutputStream();
    InputStream in = s.getInputStream();

    // Send messages to the server through
    // the OutputStream
    // Receive messages from the server
    // through the InputStream
}

catch (IOException e) {
}

Running the JSSE Sample Code

The JSSE sample programs illustrate how to use JSSE to:

  • Create a secure socket connection between a client and a server

  • Create a secure connection to an HTTPS Web site

  • Use secure communications with RMI

  • Illustrate SSLEngine usage

When using the sample code, be aware that the sample programs are designed to illustrate how to use JSSE. They are not designed to be robust applications.

Note: Setting up secure communications involves complex algorithms. The sample programs provide no feedback during the setup process. When running the programs, be patient: you may not see any output for a while. If you run the programs with the system property javax.net.debug set to all, you will see more feedback. For an introduction on reading this debug information, refer to the guide, Debugging SSL/TLS Connections.

Where to Find the Sample Code

Most of the sample code is located in the samples subdirectory of the same directory as that containing the document you are reading. Follow that link to see a listing of all the samples files and to link to the text files. That page also has a zip file you can download to obtain all the samples files, which is helpful if you are viewing this documentation from the web.

The sections below describe the samples. See the README for further information.

Sample Code Illustrating a Secure Socket Connection Between a Client and a Server

The sample programs in the samples/sockets directory illustrate how to set up a secure socket connection between a client and a server.

When running the sample client programs, you can communicate with an existing server, such as a commercial Web server, or you can communicate with the sample server program, ClassFileServer. You can run the sample client and the sample server programs on different machines connected to the same network, or you can run them both on one machine but from different terminal windows.

All the sample SSLSocketClient* programs in the samples/sockets/client directory (and URLReader* programs described in Sample Code Illustrating HTTPS Connections) can be run with the ClassFileServer sample server program. An example of how to do this is shown in Running SSLSocketClientWithClientAuth with ClassFileServer. You can make similar changes in order to run URLReader, SSLSocketClient or SSLSocketClientWithTunneling with ClassFileServer.

If an authentication error occurs while attempting to send messages between the client and the server (whether using a web server or ClassFileServer), it is most likely because the necessary keys are not in the truststore (trust key database). For example, the ClassFileServer uses a keystore called "testkeys" containing the private key for "localhost" as needed during the SSL handshake. ("testkeys" is included in the same samples/sockets/server directory as the ClassFileServer source.) If the client cannot find a certificate for the corresponding public key of "localhost" in the truststore it consults, an authentication error will occur. Be sure to use the samplecacerts truststore (which contains "localhost"s public key/cert), as described in the next section.

Configuration Requirements

When running the sample programs that create a secure socket connection between a client and a server, you will need to make the appropriate certificates file (truststore) available. For both the client and the server programs, you should use the certificates file samplecacerts from the samples directory. Using this certificates file will allow the client to authenticate the server. The file contains all the common Certification Authority certificates shipped with the JDK (in the cacerts file), plus a certificate for "localhost" needed by the client to authenticate "localhost" when communicating with the sample server ClassFileServer. (ClassFileServer uses a keystore containing the private key for "localhost" which corresponds to the public key in samplecacerts. )

To make the samplecacerts file available to both the client and the server, you can either copy it to the file <java-home>/lib/security/jssecacerts, rename it cacerts and use it to replace the <java-home>/lib/security/cacerts file, or add the following option to the command line when running the java command for both the client and the server:

-Djavax.net.ssl.trustStore=path_to_samplecacerts_file

(See The Installation Directory <java-home> for information about what <java-home> refers to.)

The password for the samplecacerts truststore is changeit. You can substitute your own certificates in the samples, using keytool.

If you use a browser, such as Netscape Navigator or Microsoft's Internet Explorer, to access the sample SSL server provided in the ClassFileServer example, a dialog box may pop up with the message that it does not recognize the certificate. This is normal because the certificate used with the sample programs is self-signed and is for testing only. You can accept the certificate for the current session. After testing the SSL server, you should exit the browser, which deletes the test certificate from the browser's namespace.

For client authentication, a separate "duke" certificate is available in the appropriate directories. The public key/certificate is also stored in the samplecacerts file.

Note: The "duke" certificate in the samples directory is different from the "duke" certificate available from the security example provided on http://java.sun.com/security/signExample12/. If you have both "duke" certificates installed, the sample code will not work properly. To view the certificates available in your certificate file, use the keytool command.

Running SSLSocketClient

The SSLSocketClient.java program demonstrates how to create a client to use an SSLSocket to send an HTTP request and to get a response from an HTTPS server. The output of this program is the HTML source for https://www.verisign.com/index.html.

You must not be behind a firewall to run this program as shipped. If you run it from behind a firewall, you will get an UnknownHostException because JSSE can't find a path through your firewall to www.verisign.com. To create an equivalent client that can run from behind a firewall, set up proxy tunneling as illustrated in the sample program SSLSocketClientWithTunneling.

Running SSLSocketClientWithTunneling

The SSLSocketClientWithTunneling.java program illustrates how to do proxy tunneling to access a secure web server from behind a firewall. To run this program, you must set the following Java system properties to the appropriate values:

java -Dhttps.proxyHost=webproxy
     -Dhttps.proxyPort=ProxyPortNumber
     SSLSocketClientWithTunneling

Note: Proxy specifications with the -D options (shown in blue) are optional. Also, be sure to replace webproxy with the name of your proxy host and ProxyPortNumber with the appropriate port number.

The program will return the HTML source file from https://www.verisign.com/index.html.

Running SSLSocketClientWithClientAuth

The SSLSocketClientWithClientAuth.java program shows how to set up a key manager to do client authentication if required by a server. This program also assumes that the client is not outside a firewall. You can modify the program to connect from inside a firewall by following the example in SSLSocketClientWithTunneling.

To run this program, you must specify three parameters: host, port, and requested file path. To mirror the previous examples, you can run this program without client authentication by setting the host to www.verisign.com, the port to 443, and the requested file path to https://www.verisign.com/. The output when using these parameters is the HTML for the Web site https://www.verisign.com/.

To run SSLSocketClientWithClientAuth to do client authentication, you must access a server that requests client authentication. You can use the sample program ClassFileServer as this server. This is described in the following sections.

Running ClassFileServer

The program referred to herein as ClassFileServer is made up of two files, ClassFileServer.java and ClassServer.java.

To execute them, run ClassFileServer.class, which requires the following parameters:

  • port - The port parameter can be any available unused port number, for example, you can use the number 2001.

  • docroot - This parameter indicates the directory on the server that contains the file you wish to retrieve. For example, on Solaris, you can use /home/userid/ (where userid refers to your particular user id), while on Microsoft Windows systems, you can use c:\.

  • TLS - This is an optional parameter. When used, it indicates that the server is to use SSL or TLS.

  • true - This is an optional parameter. When used, client authentication is required. This parameter is only consulted if the TLS parameter is set.

Note 1: The TLS and true parameters are optional. If you leave them off, indicating that just an ordinary (not TLS) file server should be used, without authentication, nothing happens. This is because one side (the client) is trying to negotiate with TLS, while the other (the server) isn't, so they can't communicate.

Note 2: The server expects GET requests in the form "GET /...", where "..." is the path to the file.

Running SSLSocketClientWithClientAuth With ClassFileServer

You can use the sample programs SSLSocketClientWithClientAuth and ClassFileServer to set up authenticated communication, where the client and server are authenticated to each other. You can run both sample programs on different machines connected to the same network, or you can run them both on one machine but from different terminal windows or command prompt windows. To set up both the client and the server, do the following:

  1. Run the program ClassFileServer from one machine or terminal window, as described in Running ClassFileServer.

  2. Run the program SSLSocketClientWithClientAuth on another machine or terminal window. SSLSocketClientWithClientAuth requires the following parameters:

    • host - This is the hostname of the machine you are using to run ClassFileServer.

    • port - This is the same port you specified for ClassFileServer.

    • requestedfilepath - This parameter indicates the path to the file you want to retrieve from the server. You must give this parameter as /filepath. Forward slashes are required in the file path because it is used as part of a GET statement, which requires forward slashes regardless of what type of operating system you are running. The statement is formed as
      "GET " + requestedfilepath + " HTTP/1.0"
NOTE: you can modify the other SSLClient* application's "GET" commands to connect to a local machine running ClassFileServer.

Sample Code Illustrating HTTPS Connections

There are two primary APIs for accessing secure communications through JSSE. One way is through a socket-level API which can be used for arbitrary secure communications, as illustrated by the SSLSocketClient, SSLSocketClientWithTunneling, and SSLSocketClientWithClientAuth (with and without ClassFileServer) sample programs.

A second, and often simpler way, is through the standard Java URL API. You can communicate securely with an SSL-enabled web server by using the "https" URL protocol or scheme using the java.net.URL class.

Support for "https" URL schemes is implemented in many of the common browsers, which allows access to secured communications without requiring the socket-level API provided with JSSE.

An example URL might be:

"https://www.verisign.com"

The trust and key management for the "https" URL implementation is environment-specific. The JSSE implementation provides an "https" URL implementation. If you want a different https protocol implementation to be used, you can set the java.protocol.handler.pkgs system property to the package name. See the java.net.URL class documentation for details.

The samples that you can download with JSSE include two sample programs that illustrate how to create an HTTPS connection. Both of these sample programs, URLReader.java and URLReaderWithOptions.java are in the urls directory.

Running URLReader

The URLReader.java program illustrates using the URL class to access a secure site. The output of this program is the HTML source for https://www.verisign.com/. By default, the HTTPS protocol implementation included with JSSE will be utilized. If you want to use a different implementation, you must set the system property java.protocol.handler.pkgs value to be the name of the package containing the implementation.

If you are running the sample code behind a firewall, you must set the system properties https.proxyHost and https.proxyPort. For example, to use the proxy host "webproxy" on port 8080, you can use the following options to the java command:

-Dhttps.proxyHost=webproxy

-Dhttps.proxyPort=8080

Alternatively, you can set the system properties within the source code with the java.lang.System method setProperty. For example, instead of using the command line options, you can include the following lines in your program:

System.setProperty("java.protocol.handler.pkgs",
    "com.ABC.myhttpsprotocol");

System.setProperty("https.proxyHost",
    "webproxy");

System.setProperty("https.proxyPort",
    "8080");

Note: When running on Windows 95 or Windows 98, the maximum number of characters allowed in an MS-DOS prompt may not be enough to include all the command-line options. If you encounter this problem, either create a .bat file with the entire command or add the system properties to the source code and recompile the source code.

Running URLReaderWithOptions

The URLReaderWithOptions.java program is essentially the same as URLReader, except that it allows you to optionally input any or all of the following system properties as arguments to the program when you run it:

  • java.protocol.handler.pkgs

  • https.proxyHost

  • https.proxyPort

  • https.cipherSuites

To run URLReaderWithOptions, type the following command (all on one line):

java URLReaderWithOptions
     [-h proxyhost -p proxyport]
     [-k protocolhandlerpkgs]
     [-c ciphersarray]
     myApp

Note: Multiple protocol handlers can be included in the protocolhandlerpkgs in a list with items separated by vertical bars. Multiple SSL cipher suite names can be included in the ciphersarray in a list with items separated by commas. The possible cipher suite names are the same as those returned by the call SSLSocket.getSupportedCipherSuites(). The suite names are taken from the SSL and TLS protocol specifications.

You only need a protocolhandlerpkgs argument if you want to use an HTTPS protocol handler implementation other than the default one provided by Sun Microsystems.

If you are running behind a firewall, you must include arguments for the proxy host and the proxy port. Additionally, you can include a list of cipher suites to enable.

Here is an example of running URLReaderWithOptions and specifying the proxy host "webproxy" on port 8080:

java URLReaderWithOptions
    -h webproxy -p 8080

Sample Code Illustrating a Secure RMI Connection

The sample code in the samples/rmi directory illustrates how to create a secure RMI connection. The sample code is based on an RMI example that is basically a "Hello World" example modified to install and use a custom RMI socket factory.

For more information about RMI, see the Java RMI documentation. This Web page points to RMI tutorials and other information about RMI.

Sample Code Illustrating the Use of an SSLEngine

SSLEngine was introduced in the Java SE 5 release of the Java 2 Platform to give application developers flexibility when choosing I/O and compute strategies. Rather than tie the SSL/TLS implementation to a specific I/O abstraction (such as single-threaded SSLSockets), SSLEngine removes the I/O and compute constraints from the SSL/TLS implementation.

As mentioned earlier, SSLEngine is an advanced API, and is not appropriate for casual use. Some introductary sample code is provided here that helps illustrate its use. The first demo removes most of the I/O and threading issues, and focuses on many of the SSLEngine methods. The second demo is a more realistic example showing how SSLEngine might be combined with Java NIO to create a rudimentary HTTP/HTTPS server.

Running SSLEngineSimpleDemo

The SSLEngineSimpleDemo is a very simple application that focuses on the operation of the SSLEngine while simplifying the I/O and threading issues. This application creates two SSLEngines which exchange SSL/TLS messages via common ByteBuffers. A single loop serially performs all of the engine operations and demonstrates how a secure connection is established (handshaking), how application data is transferred, and how the engine is closed.

The SSLEngineResult provides a great deal of information about the SSLEngine's current state. This example doesn't examine all of the states. It simplifies the I/O and threading issues to the point that this is not a good example for a production environment; nonetheless, it is useful to demonstrate the overall function of the SSLEngine.

Running the NIO-based Server

Note: The server example discussed in this section is included in the Java SE Development Kit 6. You can find the code bundled in the <jdk-home>/samples/nio/server directory.
To fully exploit the flexibility provided by SSLEngine, one must first understand complementary API's such as I/O and threading models.

An I/O model that large-scale application developers find of use is NIO SocketChannels. NIO was introduced in part to solve some of the scaling problem inherent in the java.net.Socket API. SocketChannels have many different modes of operation including:

  • blocking
  • non-blocking
  • non-blocking with Selectors
Sample code for a bare-bones HTTP server is provided that not only demonstrates many of the new NIO APIs, and also shows how SSLEngine can be employed to create a secure HTTPS server. The server is not production quality, but does show many of these new APIs in action.

Inside the sample directory is a README.txt file which introduces the server, explains how to build and configure, and provides a brief overview of the code layout. The files of most interest for SSLEngine users are ChannelIO.java and ChannelIOSecure.java.

Creating a Keystore to Use with JSSE

Creating a Simple Keystore and Truststore

In this section, we'll use keytool to create a simple JKS keystore suitable for use with JSSE. We'll make a keyEntry (with public/private keys) in the keystore, then make a corresponding trustedCertEntry (public keys only) in a truststore. (For client authentication, you'll need to do a similar process for the client's certificates.) Note: Storing trust anchors in PKCS12 is not supported. Users should use JKS for storing trust anchors and PKCS12 for private keys.
Note: It is beyond the scope of this example to explain each step in detail. If you need more information, please see the keytool documentation for Solaris or Microsoft Windows.
User input is shown in boldface font.
  1. Create a new keystore and self-signed certificate with corresponding public/private keys.
    % keytool -genkeypair -alias duke -keyalg RSA \
      -validity 7 -keystore keystore

 Enter keystore password:  password
 What is your first and last name?
 [Unknown]:  Duke
 What is the name of your organizational unit?
 [Unknown]:  Java Software
 What is the name of your organization?
 [Unknown]:  Sun Microsystems, Inc.
 What is the name of your City or Locality?
 [Unknown]:  Palo Alto
 What is the name of your State or Province?
 [Unknown]:  CA
 What is the two-letter country code for this unit?
 [Unknown]:  US
     Is CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.",
     L=Palo Alto, ST=CA, C=US correct?
     [no]:  yes

 Enter key password for <duke>
  (RETURN if same as keystore password):  <CR>
    This is the keystore that the server will use.

  2. Examine the keystore. Notice the entry type is keyEntry which means that this entry has a private key associated with it (shown in red).
    % keytool -list -v -keystore keystore
Enter keystore password:  password

Keystore type: jks
Keystore provider: SUN

Your keystore contains 1 entry

Alias name: duke
Creation date: Dec 20, 2001
Entry type: keyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.",
L=Palo Alto, ST=CA, C=US
Issuer: CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.", L=Palo Alto, ST=CA, C=US
Serial number: 3c22adc1
Valid from: Thu Dec 20 19:34:25 PST 2001 until: Thu Dec 27 19:34:25 PST 2001
Certificate fingerprints:
    MD5: F1:5B:9B:A1:F7:16:CF:25:CF:F4:FF:35:3F:4C:9C:F0
    SHA1: B2:00:50:DD:B6:CC:35:66:21:45:0F:96:AA:AF:6A:3D:E4:03:7C:74

  3. Export and examine the self-signed certificate.
    % keytool -export -alias duke -keystore keystore -rfc \
      -file duke.cer
Enter keystore password:  password
Certificate stored in file <duke.cer>
% cat duke.cer
-----BEGIN CERTIFICATE-----
MIICXjCCAccCBDwircEwDQYJKoZIhvcNAQEEBQAwdjELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNB
MRIwEAYDVQQHEwlQYWxvIEFsdG8xHzAdBgNVBAoTFlN1biBNaWNyb3N5c3RlbXMsIEluYy4xFjAU
BgNVBAsTDUphdmEgU29mdHdhcmUxDTALBgNVBAMTBER1a2UwHhcNMDExMjIxMDMzNDI1WhcNMDEx
MjI4MDMzNDI1WjB2MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExEjAQBgNVBAcTCVBhbG8gQWx0
bzEfMB0GA1UEChMWU3VuIE1pY3Jvc3lzdGVtcywgSW5jLjEWMBQGA1UECxMNSmF2YSBTb2Z0d2Fy
ZTENMAsGA1UEAxMERHVrZTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA1loObJzNXsi5aSr8
N4XzDksD6GjTHFeqG9DUFXKEOQetfYXvA8F9uWtz8WInrqskLTNzwXgmNeWkoM7mrPpK6Rf5M3G1
NXtYzvxyi473Gh1h9k7tjJvqSVKO7E1oFkQYeUPYifxmjbSMVirWZgvo2UmA1c76oNK+NhoHJ4qj
eCUCAwEAATANBgkqhkiG9w0BAQQFAAOBgQCRPoQYw9rWWvfLPQuPXowvFmuebsTc28qI7iFWm6BJ
TT/qdmzti7B5MHOt9BeVEft3mMeBU0CS2guaBjDpGlf+zsK/UUi1w9C4mnwGDZzqY/NKKWtLxabZ
5M+4MAKLZ92ePPKGpobM2CPLfM8ap4IgAzCbBKd8+CMp8yFmifze9Q==
-----END CERTIFICATE-----
    Alternatively, you could generate Certificate Signing Request (CSR) with -certreq and send that to a Certificate Authority (CA) for signing, but again, that's beyond the scope of this example.

  4. Import the certificate into a new truststore.
    % keytool -import -alias dukecert -file duke.cer \
      -keystore truststore
Enter keystore password:  trustword
Owner: CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.", L=Palo Alto, ST=CA, C=US
Issuer: CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.", L=Palo Alto, ST=CA, C=US
Serial number: 3c22adc1
Valid from: Thu Dec 20 19:34:25 PST 2001 until: Thu Dec 27 19:34:25 PST 2001
Certificate fingerprints:
    MD5: F1:5B:9B:A1:F7:16:CF:25:CF:F4:FF:35:3F:4C:9C:F0
    SHA1: B2:00:50:DD:B6:CC:35:66:21:45:0F:96:AA:AF:6A:3D:E4:03:7C:74
Trust this certificate? [no]:  yes
Certificate was added to keystore
  5. Examine the truststore. Note that the entry type is trustedCertEntry, which means that a private key is not available for this entry (shown in red). It also means that this file is not suitable as a KeyManager's keystore.
    % keytool -list -v -keystore truststore
    Enter keystore password:  trustword

Keystore type: jks
Keystore provider: SUN

Your keystore contains 1 entry

Alias name: dukecert
Creation date: Dec 20, 2001
Entry type: trustedCertEntry

Owner: CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.", L=Palo Alto, ST=CA, C=US
Issuer: CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.", L=Palo Alto, ST=CA, C=US
Serial number: 3c22adc1
Valid from: Thu Dec 20 19:34:25 PST 2001 until: Thu Dec 27 19:34:25 PST 2001
Certificate fingerprints:
    MD5: F1:5B:9B:A1:F7:16:CF:25:CF:F4:FF:35:3F:4C:9C:F0
    SHA1: B2:00:50:DD:B6:CC:35:66:21:45:0F:96:AA:AF:6A:3D:E4:03:7C:74
    Now run your applications with the appropriate key stores. This example assumes the default X509KeyManager and X509TrustManager are used, thus we will select the keystores using the system properties described in Customization.
    % java -Djavax.net.ssl.keyStore=keystore \
      -Djavax.net.ssl.keyStorePassword=password Server

    % java -Djavax.net.ssl.trustStore=truststore \
      -Djavax.net.ssl.trustStorePassword=trustword Client

Note: In this example, we authenticated the server only. If client authentication is desired, you will need to provide a similar keystore for the client's keys, and an appropriate truststore for the server.

Appendix A: Standard Names

The JDK Security API requires and uses a set of standard names for algorithms, certificate and keystore types. The specification names previously found here in Appendix A and in the other security specifications (JCA/CertPath/etc.) have been combined in the Standard Names document. Specific provider information can be found in the Sun Provider Documentation.

Appendix B: Provider Pluggability

JSSE in Java SE 6 is fully pluggable and does not restrict the use of third party JSSE providers in any way.

Copyright © 1998-2006, Sun Microsystems, Inc. 4150 Network Circle Santa Clara, California 95054 All Rights Reserved.

Please send comments to: java-security@sun.com. This is not a subscription list.


JSSE Samples

This samples directory contains subdirectories with JSSE sample files.

If you are viewing this page online, the best way to obtain all the samples files, including the binary keystore files, is to download this zip file:

jssesamples.zip

Below are lists of the directories and links to all the text files within the directories.

samples
README.txt
samplecacerts (binary)
rmi
Hello.java
HelloClient.java
HelloImpl.java
RMISSLClientSocketFactory.java
RMISSLServerSocketFactory.java
policy
readme.txt
testkeys (binary)

sockets
client
SSLSocketClient.java
SSLSocketClientWithClientAuth.java
SSLSocketClientWithTunneling.java
testkeys (binary)

server
ClassFileServer.java
ClassServer.java
testkeys (binary)

sslengine
SSLEngineSimpleDemo.java
testkeys (binary)

urls
URLReader.java
URLReaderWithOptions.java


Overview of Java SE Security

Java™ Security Overview

1 Introduction

The Java™ platform was designed with a strong emphasis on security. At its core, the Java language itself is type-safe and provides automatic garbage collection, enhancing the robustness of application code. A secure class loading and verification mechanism ensures that only legitimate Java code is executed.

The initial version of the Java platform created a safe environment for running potentially untrusted code, such as Java applets downloaded from a public network. As the platform has grown and widened its range of deployment, the Java security architecture has correspondingly evolved to support an increasing set of services. Today the architecture includes a large set of application programming interfaces (APIs), tools, and implementations of commonly-used security algorithms, mechanisms, and protocols. This provides the developer a comprehensive security framework for writing applications, and also provides the user or administrator a set of tools to securely manage applications.

The Java security APIs span a wide range of areas. Cryptographic and public key infrastructure (PKI) interfaces provide the underlying basis for developing secure applications. Interfaces for performing authentication and access control enable applications to guard against unauthorized access to protected resources.

The APIs allow for multiple interoperable implementations of algorithms and other security services. Services are implemented in providers, which are plugged into the Java platform via a standard interface that makes it easy for applications to obtain security services without having to know anything about their implementations. This allows developers to focus on how to integrate security into their applications, rather than on how to actually implement complex security mechanisms.

The Java platform includes a number of providers that implement a core set of security services. It also allows for additional custom providers to be installed. This enables developers to extend the platform with new security mechanisms.

This paper gives a broad overview of security in the Java platform, from secure language features to the security APIs, tools, and built-in provider services, highlighting key packages and classes where applicable. Note that this paper is based on Java™ SE version 6.

2 Java Language Security and Bytecode Verification

The Java language is designed to be type-safe and easy to use. It provides automatic memory management, garbage collection, and range-checking on arrays. This reduces the overall programming burden placed on developers, leading to fewer subtle programming errors and to safer, more robust code.

In addition, the Java language defines different access modifiers that can be assigned to Java classes, methods, and fields, enabling developers to restrict access to their class implementations as appropriate. Specifically, the language defines four distinct access levels: private, protected, public, and, if unspecified, package. The most open access specifier is public access is allowed to anyone. The most restrictive modifier is private access is not allowed outside the particular class in which the private member (a method, for example) is defined. The protected modifier allows access to any subclass, or to other classes within the same package. Package-level access only allows access to classes within the same package.

A compiler translates Java programs into a machine-independent bytecode representation. A bytecode verifier is invoked to ensure that only legitimate bytecodes are executed in the Java runtime. It checks that the bytecodes conform to the Java Language Specification and do not violate Java language rules or namespace restrictions. The verifier also checks for memory management violations, stack underflows or overflows, and illegal data typecasts. Once bytecodes have been verified, the Java runtime prepares them for execution.

3 Basic Security Architecture

The Java platform defines a set of APIs spanning major security areas, including cryptography, public key infrastructure, authentication, secure communication, and access control. These APIs allow developers to easily integrate security into their application code. They were designed around the following principles:

  1. Implementation independence
    Applications do not need to implement security themselves. Rather, they can request security services from the Java platform. Security services are implemented in providers (see below), which are plugged into the Java platform via a standard interface. An application may rely on multiple independent providers for security functionality.
  2. Implementation interoperability
    Providers are interoperable across applications. Specifically, an application is not bound to a specific provider, and a provider is not bound to a specific application.
  3. Algorithm extensibility
    The Java platform includes a number of built-in providers that implement a basic set of security services that are widely used today. However, some applications may rely on emerging standards not yet implemented, or on proprietary services. The Java platform supports the installation of custom providers that implement such services.

Security Providers

The java.security.Provider class encapsulates the notion of a security provider in the Java platform. It specifies the provider's name and lists the security services it implements. Multiple providers may be configured at the same time, and are listed in order of preference. When a security service is requested, the highest priority provider that implements that service is selected.

Applications rely on the relevant getInstance method to obtain a security service from an underlying provider. For example, message digest creation represents one type of service available from providers. (Section 4 discusses message digests and other cryptographic services.) An application invokes the getInstance method in the java.security.MessageDigest class to obtain an implementation of a specific message digest algorithm, such as MD5.

MessageDigest md = MessageDigest.getInstance("MD5");

The program may optionally request an implementation from a specific provider, by indicating the provider name, as in the following:

MessageDigest md =
    MessageDigest.getInstance("MD5", "ProviderC");

Figures 1 and 2 illustrate these options for requesting an MD5 message digest implementation. Both figures show three providers that implement message digest algorithms. The providers are ordered by preference from left to right (1-3). In Figure 1, an application requests an MD5 algorithm implementation without specifying a provider name. The providers are searched in preference order and the implementation from the first provider supplying that particular algorithm, ProviderB, is returned. In Figure 2, the application requests the MD5 algorithm implementation from a specific provider, ProviderC. This time the implementation from that provider is returned, even though a provider with a higher preference order, ProviderB, also supplies an MD5 implementation.

Figure 1 Provider searching | Figure 2 Specific provider requested

The Java platform implementation from Sun Microsystems includes a number of pre-configured default providers that implement a basic set of security services that can be used by applications. Note that other vendor implementations of the Java platform may include different sets of providers that encapsulate vendor-specific sets of security services. When this paper mentions built-in default providers, it is referencing those available in Sun's implementation.

The sections below on the various security areas (cryptography, authentication, etc.) each include descriptions of the relevant services supplied by the default providers. A table in Appendix C summarizes all of the default providers.

File Locations

Certain aspects of Java security mentioned in this paper, including the configuration of providers, may be customized by setting security properties. You may set security properties statically in the security properties file, which by default is the java.security file in the lib/security directory of the directory where the Java™ Runtime Environment (JRE) is installed. Security properties may also be set dynamically by calling appropriate methods of the Security class (in the java.security package).

The tools and commands mentioned in this paper are all in the ~jre/bin directory, where ~jre stands for the directory in which the JRE is installed. The cacerts file mentioned in Section 5 is in ~jre/lib/security.

4 Cryptography

The Java cryptography architecture is a framework for accessing and developing cryptographic functionality for the Java platform. It includes APIs for a large variety of cryptographic services, including

  • Message digest algorithms
  • Digital signature algorithms
  • Symmetric bulk encryption
  • Symmetric stream encryption
  • Asymmetric encryption
  • Password-based encryption (PBE)
  • Elliptic Curve Cryptography (ECC)
  • Key agreement algorithms
  • Key generators
  • Message Authentication Codes (MACs)
  • (Pseudo-)random number generators

For historical (export control) reasons, the cryptography APIs are organized into two distinct packages. The java.security package contains classes that are not subject to export controls (like Signature and MessageDigest). The javax.crypto package contains classes that are subject to export controls (like Cipher and KeyAgreement).

The cryptographic interfaces are provider-based, allowing for multiple and interoperable cryptography implementations. Some providers may perform cryptographic operations in software; others may perform the operations on a hardware token (for example, on a smartcard device or on a hardware cryptographic accelerator). Providers that implement export-controlled services must be digitally signed.

The Java platform includes built-in providers for many of the most commonly used cryptographic algorithms, including the RSA and DSA signature algorithms, the DES, AES, and ARCFOUR encryption algorithms, the MD5 and SHA-1 message digest algorithms, and the Diffie-Hellman key agreement algorithm. These default providers implement cryptographic algorithms in Java code.

The Java platform also includes a built-in provider that acts as a bridge to a native PKCS#11 (v2.x) token. This provider, named SunPKCS11, allows Java applications to seamlessly access cryptographic services located on PKCS#11-compliant tokens.

5 Public Key Infrastructure

Public Key Infrastructure (PKI) is a term used for a framework that enables secure exchange of information based on public key cryptography. It allows identities (of people, organizations, etc.) to be bound to digital certificates and provides a means of verifying the authenticity of certificates. PKI encompasses keys, certificates, public key encryption, and trusted Certification Authorities (CAs) who generate and digitally sign certificates.

The Java platform includes API and provider support for X.509 digital certificates and certificate revocation lists (CRLs), as well as PKIX-compliant certification path building and validation. The classes related to PKI are located in the java.security and java.security.cert packages.

Key and Certificate Storage

The Java platform provides for long-term persistent storage of cryptographic keys and certificates via key and certificate stores. Specifically, the java.security.KeyStore class represents a key store, a secure repository of cryptographic keys and/or trusted certificates (to be used, for example, during certification path validation), and the java.security.cert.CertStore class represents a certificate store, a public and potentially vast repository of unrelated and typically untrusted certificates. A CertStore may also store CRLs.

KeyStore and CertStore implementations are distinguished by types. The Java platform includes the standard PKCS11 and PKCS12 key store types (whose implementations are compliant with the corresponding PKCS specifications from RSA Security), as well as a proprietary file-based key store type called JKS (which stands for "Java Key Store").

The Java platform includes a special built-in JKS key store, cacerts, that contains a number of certificates for well-known, trusted CAs. The keytool documentation (see the security features documentation link in Section 9) lists the certificates included in cacerts.

The SunPKCS11 provider mentioned in the "Cryptography" section (Section 4) includes a PKCS11 KeyStore implementation. This means that keys and certificates residing in secure hardware (such as a smartcard) can be accessed and used by Java applications via the KeyStore API. Note that smartcard keys may not be permitted to leave the device. In such cases, the java.security.Key object reference returned by the KeyStore API may simply be a reference to the key (that is, it would not contain the actual key material). Such a Key object can only be used to perform cryptographic operations on the device where the actual key resides.

The Java platform also includes an LDAP certificate store type (for accessing certificates stored in an LDAP directory), as well as an in-memory Collection certificate store type (for accessing certificates managed in a java.util.Collection object).

PKI Tools

There are two built-in tools for working with keys, certificates, and key stores:

keytool is used to create and manage key stores. It can

  • Create public/private key pairs
  • Display, import, and export X.509 v1, v2, and v3 certificates stored as files
  • Create self-signed certificates
  • Issue certificate (PKCS#10) requests to be sent to CAs
  • Import certificate replies (obtained from the CAs sent certificate requests)
  • Designate public key certificates as trusted

The jarsigner tool is used to sign JAR files, or to verify signatures on signed JAR files. The Java ARchive (JAR) file format enables the bundling of multiple files into a single file. Typically a JAR file contains the class files and auxiliary resources associated with applets and applications. When you want to digitally sign code, you first use keytool to generate or import appropriate keys and certificates into your key store (if they are not there already), then use the jar tool to place the code in a JAR file, and finally use the jarsigner tool to sign the JAR file. The jarsigner tool accesses a key store to find any keys and certificates needed to sign a JAR file or to verify the signature of a signed JAR file. Note: jarsigner can optionally generate signatures that include a timestamp. Systems (such as Java Plug-in) that verify JAR file signatures can check the timestamp and accept a JAR file that was signed while the signing certificate was valid rather than requiring the certificate to be current. (Certificates typically expire annually, and it is not reasonable to expect JAR file creators to re-sign deployed JAR files annually.)

6 Authentication

Authentication is the process of determining the identity of a user. In the context of the Java runtime environment, it is the process of identifying the user of an executing Java program. In certain cases, this process may rely on the services described in the "Cryptography" section (Section 4).

The Java platform provides APIs that enable an application to perform user authentication via pluggable login modules. Applications call into the LoginContext class (in the javax.security.auth.login package), which in turn references a configuration. The configuration specifies which login module (an implementation of the javax.security.auth.spi.LoginModule interface) is to be used to perform the actual authentication.

Since applications solely talk to the standard LoginContext API, they can remain independent from the underlying plug-in modules. New or updated modules can be plugged in for an application without having to modify the application itself. Figure 3 illustrates the independence between applications and underlying login modules:

Figure 3 Authentication login modules plugging into the authentication framework

It is important to note that although login modules are pluggable components that can be configured into the Java platform, they are not plugged in via security Providers. Therefore, they do not follow the Provider searching model described in Section 3. Instead, as is shown in the above diagram, login modules are administered by their own unique configuration.

The Java platform provides the following built-in LoginModules, all in the com.sun.security.auth.module package:

  • Krb5LoginModule for authentication using Kerberos protocols
  • JndiLoginModule for username/password authentication using LDAP or NIS databases
  • KeyStoreLoginModule for logging into any type of key store, including a PKCS#11 token key store

Authentication can also be achieved during the process of establishing a secure communication channel between two peers. The Java platform provides implementations of a number of standard communication protocols, which are discussed in the following section.

7 Secure Communication

The data that travels across a network can be accessed by someone who is not the intended recipient. When the data includes private information, such as passwords and credit card numbers, steps must be taken to make the data unintelligible to unauthorized parties. It is also important to ensure that you are sending the data to the appropriate party, and that the data has not been modified, either intentionally or unintentionally, during transport.

Cryptography forms the basis required for secure communication, and that is described in Section 4. The Java platform also provides API support and provider implementations for a number of standard secure communication protocols.

SSL/TLS

The Java platform provides APIs and an implementation of the SSL and TLS protocols that includes functionality for data encryption, message integrity, server authentication, and optional client authentication. Applications can use SSL/TLS to provide for the secure passage of data between two peers over any application protocol, such as HTTP on top of TCP/IP.

The javax.net.ssl.SSLSocket class represents a network socket that encapsulates SSL/TLS support on top of a normal stream socket (java.net.Socket). Some applications might want to use alternate data transport abstractions (e.g., New-I/O); the javax.net.ssl.SSLEngine class is available to produce and consume SSL/TLS packets.

The Java platform also includes APIs that support the notion of pluggable (provider-based) key managers and trust managers. A key manager is encapsulated by the javax.net.ssl.KeyManager class, and manages the keys used to perform authentication. A trust manager is encapsulated by the TrustManager class (in the same package), and makes decisions about who to trust based on certificates in the key store it manages.

SASL

Simple Authentication and Security Layer (SASL) is an Internet standard that specifies a protocol for authentication and optional establishment of a security layer between client and server applications. SASL defines how authentication data is to be exchanged, but does not itself specify the contents of that data. It is a framework into which specific authentication mechanisms that specify the contents and semantics of the authentication data can fit. There are a number of standard SASL mechanisms defined by the Internet community for various security levels and deployment scenarios.

The Java SASL API defines classes and interfaces for applications that use SASL mechanisms. It is defined to be mechanism-neutral; an application that uses the API need not be hardwired into using any particular SASL mechanism. Applications can select the mechanism to use based on desired security features. The API supports both client and server applications. The javax.security.sasl.Sasl class is used to create SaslClient and SaslServer objects.

SASL mechanism implementations are supplied in provider packages. Each provider may support one or more SASL mechanisms and is registered and invoked via the standard provider architecture.

The Java platform includes a built-in provider that implements the following SASL mechanisms:

  • CRAM-MD5, DIGEST-MD5, EXTERNAL, GSSAPI, and PLAIN client mechanisms
  • CRAM-MD5, DIGEST-MD5, and GSSAPI server mechanisms

GSS-API and Kerberos

The Java platform contains an API with the Java language bindings for the Generic Security Service Application Programming Interface (GSS-API). GSS-API offers application programmers uniform access to security services atop a variety of underlying security mechanisms. The Java GSS-API currently requires use of a Kerberos v5 mechanism, and the Java platform includes a built-in implementation of this mechanism. At this time, it is not possible to plug in additional mechanisms. Note: The Krb5LoginModule mentioned in Section 6 can be used in conjunction with the GSS Kerberos mechanism.

Before two applications can use the Java GSS-API to securely exchange messages between them, they must establish a joint security context. The context encapsulates shared state information that might include, for example, cryptographic keys. Both applications create and use an org.ietf.jgss.GSSContext object to establish and maintain the shared information that makes up the security context. Once a security context has been established, it can be used to prepare secure messages for exchange.

The Java GSS APIs are in the org.ietf.jgss package. The Java platform also defines basic Kerberos classes, like KerberosPrincipal and KerberosTicket, which are located in the javax.security.auth.kerberos package.

8 Access Control

The access control architecture in the Java platform protects access to sensitive resources (for example, local files) or sensitive application code (for example, methods in a class). All access control decisions are mediated by a security manager, represented by the java.lang.SecurityManager class. A SecurityManager must be installed into the Java runtime in order to activate the access control checks.

Java applets and Java™ Web Start applications are automatically run with a SecurityManager installed. However, local applications executed via the java command are by default not run with a SecurityManager installed. In order to run local applications with a SecurityManager, either the application itself must programmatically set one via the setSecurityManager method (in the java.lang.System class), or java must be invoked with a -Djava.security.manager argument on the commandline.

Permissions

When Java code is loaded by a class loader into the Java runtime, the class loader automatically associates the following information with that code:

  • Where the code was loaded from
  • Who signed the code (if anyone)
  • Default permissions granted to the code

This information is associated with the code regardless of whether the code is downloaded over an untrusted network (e.g., an applet) or loaded from the filesystem (e.g., a local application). The location from which the code was loaded is represented by a URL, the code signer is represented by the signer's certificate chain, and default permissions are represented by java.security.Permission objects.

The default permissions automatically granted to downloaded code include the ability to make network connections back to the host from which it originated. The default permissions automatically granted to code loaded from the local filesystem include the ability to read files from the directory it came from, and also from subdirectories of that directory.

Note that the identity of the user executing the code is not available at class loading time. It is the responsibility of application code to authenticate the end user if necessary (for example, as described in Section 6). Once the user has been authenticated, the application can dynamically associate that user with executing code by invoking the doAs method in the javax.security.auth.Subject class.

Policy

As mentioned earlier, a limited set of default permissions are granted to code by class loaders. Administrators have the ability to flexibly manage additional code permissions via a security policy.

The Java platform encapsulates the notion of a security policy in the java.security.Policy class. There is only one Policy object installed into the Java runtime at any given time. The basic responsibility of the Policy object is to determine whether access to a protected resource is permitted to code (characterized by where it was loaded from, who signed it, and who is executing it). How a Policy object makes this determination is implementation-dependent. For example, it may consult a database containing authorization data, or it may contact another service.

The Java platform includes a default Policy implementation that reads its authorization data from one or more ASCII (UTF-8) files configured in the security properties file. These policy files contain the exact sets of permissions granted to code: specifically, the exact sets of permissions granted to code loaded from particular locations, signed by particular entities, and executing as particular users. The policy entries in each file must conform to a documented proprietary syntax, and may be composed via a simple text editor or the graphical policytool utility.

Access Control Enforcement

The Java runtime keeps track of the sequence of Java calls that are made as a program executes. When access to a protected resource is requested, the entire call stack, by default, is evaluated to determine whether the requested access is permitted.

As mentioned earlier, resources are protected by the SecurityManager. Security-sensitive code in the Java platform and in applications protects access to resources via code like the following:

SecurityManager sm = System.getSecurityManager();
if (sm != null) {
   sm.checkPermission(perm);
}

where perm is the Permission object that corresponds to the requested access. For example, if an attempt is made to read the file /tmp/abc, the permission may be constructed as follows:

Permission perm =
    new java.io.FilePermission("/tmp/abc", "read");

The default implementation of SecurityManager delegates its decision to the java.security.AccessController implementation. The AccessController traverses the call stack, passing to the installed security Policy each code element in the stack, along with the requested permission (for example, the FilePermission in the above example). The Policy determines whether the requested access is granted, based on the permissions configured by the administrator. If access is not granted, the AccessController throws a java.lang.SecurityException.

Figure 4 illustrates access control enforcement. In this particular example, there are initially two elements on the call stack, ClassA and ClassB. ClassA invokes a method in ClassB, which then attempts to access the file /tmp/abc by creating an instance of java.io.FileInputStream. The FileInputStream constructor creates a FilePermission, perm, as shown above, and then passes perm to the SecurityManager's checkPermission method. In this particular case, only the permissions for ClassA and ClassB need to be checked, because all system code, including FileInputStream, SecurityManager, and AccessController, automatically receives all permissions.

In this example, ClassA and ClassB have different code characteristics?they come from different locations and have different signers. Each may have been granted a different set of permissions. The AccessController only grants access to the requested file if the Policy indicates that both classes have been granted the required FilePermission.

Figure 4 Controlling access to resources

9 For More Information

Detailed documentation for all the Java SE 6 security features mentioned in this paper can be found at

http://java.sun.com/javase/6/docs/guide/security/index.html

Additional Java security documentation can be found online at

http://java.sun.com/security/

and in the book Inside Java 2 Platform Security, Second Edition (Addison-Wesley). See

http://java.sun.com/docs/books/security/index.html

Note: Historically, as new types of security services were added to the Java platform (sometimes initially as extensions), various acronymns were used to refer to them. Since these acronyms are still in use in the Java security documentation, here is an explanation of what they represent: JSSE (Java™ Secure Socket Extension) refers to the SSL-related services described in Section 7, JCE (Java™ Cryptography Extension) refers to cryptographic services (Section 4), and JAAS (Java™ Authentication and Authorization Service) refers to the authentication and user-based access control services described in Sections 6 and 8, respectively.

Appendix A Classes Summary

Table 1 summarizes the names, packages, and usage of the Java security classes and interfaces mentioned in this paper.

Table 1 Key Java security packages and classes

Package | Class/Interface Name | Usage
com.sun.security.auth.module | JndiLoginModule | Performs username/password authentication using LDAP or NIS database
 | KeyStoreLoginModule | Performs authentication based on key store login
 | Krb5LoginModule | Performs authentication using Kerberos protocols
java.lang | SecurityException | Indicates a security violation
 | SecurityManager | Mediates all access control decisions
 | System | Installs the SecurityManager
java.security | AccessController | Called by default implementation of SecurityManager to make access control decisions
 | Key | Represents a cryptographic key
 | KeyStore | Represents a repository of keys and trusted certificates
 | MessageDigest | Represents a message digest
 | Permission | Represents access to a particular resource
 | Policy | Encapsulates the security policy
 | Provider | Encapsulates security service implementations
 | Security | Manages security providers and security properties
 | Signature | Creates and verifies digital signatures
java.security.cert | Certificate | Represents a public key certificate
 | CertStore | Represents a repository of unrelated and typically untrusted certificates
javax.crypto | Cipher | Performs encryption and decryption
 | KeyAgreement | Performs a key exchange
javax.net.ssl | KeyManager | Manages keys used to perform SSL/TLS authentication
 | SSLEngine | Produces/consumes SSL/TLS packets, allowing the application freedom to choose a transport mechanism
 | SSLSocket | Represents a network socket that encapsulates SSL/TLS support on top of a normal stream socket
 | TrustManager | Makes decisions about who to trust in SSL/TLS interactions (for example, based on trusted certificates in key stores)
javax.security.auth | Subject | Represents a user
javax.security.auth.kerberos | KerberosPrincipal | Represents a Kerberos principal
 | KerberosTicket | Represents a Kerberos ticket
javax.security.auth.login | LoginContext | Supports pluggable authentication
javax.security.auth.spi | LoginModule | Implements a specific authentication mechanism
javax.security.sasl | Sasl | Creates SaslClient and SaslServer objects
 | SaslClient | Performs SASL authentication as a client
 | SaslServer | Performs SASL authentication as a server
org.ietf.jgss | GSSContext | Encapsulates a GSS-API security context and provides the security services available via the context

Appendix B Tools Summary

Table 2 summarizes the tools mentioned in this paper.

Table 2 Java security tools

Tool | Usage
jar | Creates Java Archive (JAR) files
jarsigner | Signs and verifies signatures on JAR files
keytool | Creates and manages key stores
policytool | Creates and edits policy files for use with default Policy implementation

There are also three Kerberos-related tools that are shipped with the Java platform for Windows. Equivalent functionality is provided in tools of the same name that are automatically part of the Solaris and Linux operating environments. Table 3 summarizes the Kerberos tools.

Table 3 Kerberos-related tools

Tool | Usage
kinit | Obtains and caches Kerberos ticket-granting tickets
klist | Lists entries in the local Kerberos credentials cache and key table
ktab | Manages the names and service keys stored in the local Kerberos key table

Appendix C Built-in Providers

The Java platform implementation from Sun Microsystems includes a number of built-in provider packages. For details, see the Java™ Cryptography Architecture Sun Providers Documentation.


Java SASL API

The Java SASL API
Programming and Deployment Guide

  1. Introduction
    • What is SASL
    • The Java SASL API
    • When to Use SASL
  2. API Overview
    • Creating the Mechanisms
    • Passing Input to the Mechanisms
    • Using the Mechanisms
    • Using the Negotiated Security Layer
  3. How SASL Mechanisms are Installed and Selected
  4. The SunSASL Provider
    • Client Mechanisms
    • Server Mechanisms
    • Debugging and Monitoring
  5. Implementing a SASL Security Provider

Introduction

What is SASL?

 Simple Authentication and Security Layer, or SASL, is an Internet standard (RFC 2222) that specifies a protocol for authentication and optional establishment of a security layer between client and server applications. SASL defines how authentication data is to be exchanged but does not itself specify the contents of that data. It is a framework into which specific authentication mechanisms that specify the contents and semantics of the authentication data can fit.

SASL is used by protocols, such as the Lightweight Directory Access Protocol, version 3 (LDAP v3), and the Internet Message Access Protocol, version 4 (IMAP v4) to enable pluggable authentication. Instead of hardwiring an authentication method into the protocol, LDAP v3 and IMAP v4 use SASL to perform authentication, thus enabling authentication via various SASL mechanisms.

There are a number of standard SASL mechanisms defined by the Internet community for various levels of security and deployment scenarios. These range from no security (e.g., anonymous authentication) to high security (e.g., Kerberos authentication) and levels in between.

The Java SASL API

The Java SASL API defines classes and interfaces for applications that use SASL mechanisms. It is defined to be mechanism-neutral: the application that uses the API need not be hardwired into using any particular SASL mechanism. The API supports both client and server applications. It allows applications to select the mechanism to use based on desired security features, such as whether they are susceptible to passive dictionary attacks or whether they accept anonymous authentication.

The Java SASL API also allows developers to use their own, custom SASL mechanisms. SASL mechanisms are installed by using the Java Cryptography Architecture (JCA).

When to Use SASL

SASL provides pluggable authentication and security layer for network applications. There are other features in the Java SE that provide similar functionality, including the Java Secure Socket Extension (JSSE), and Java Generic Security Service (Java GSS). JSSE provides a framework and an implementation for a Java language version of the SSL and TLS protocols. Java GSS is the Java language bindings for the Generic Security Service Application Programming Interface (GSS-API). The only mechanism currently supported underneath this API on Java SE is Kerberos v5.

When compared with JSSE and Java GSS, SASL is relatively lightweight and is popular among more recent protocols. It also has the advantage that several popular, lightweight (in terms infrastructure support) SASL mechanisms have been defined. Primary JSSE and Java GSS mechanisms, on the other hand, have relatively heavyweight mechanisms that require more elaborate infrastructures (Public Key Infrastructure and Kerberos, respectively).

SASL, JSSE, and Java GSS are often used together. For example, a common pattern is for an application to use JSSE for establishing a secure channel, and to use SASL for client, username/password-based authentication. There are also SASL mechanisms layered on top of GSS-API mechanisms; one popular example is a SASL GSS-API/Kerberos v5 mechanism that is used with LDAP.

Except when defining and building protocols from scratch, often the biggest factor determining which API to use is the protocol definition. For example, LDAP and IMAP are defined to use SASL, so software related to these protocols should use the Java SASL API. When building Kerberos applications and services, the API to use is Java GSS. When building applications and services that use SSL/TLS as their protocol, the API to use is JSSE. See the Java Security Documentation for further details about when to use JSSE versus Java GSS.

API Overview

SASL is a challenge-response protocol. The server issues a challenge to the client, and the client sends a response based on the challenge. This exchange continues until the server is satisfied and issues no further challenge. These challenges and responses are binary tokens of arbitrary length. The encapsulating protocol (such as LDAP or IMAP) specifies how these tokens are encoded and exchanged. For example, LDAP specifies how SASL tokens are encapsulated within LDAP bind requests and responses.

The Java SASL API is modeled according to this style of interaction and usage. It has interfaces, SaslClient and SaslServer, that represent client-side and server-side mechanisms, respectively. The application interacts with the mechanisms via byte arrays that represent the challenges and responses. The server-side mechanism iterates, issuing challenges and processing responses, until it is satisfied, while the client-side mechanism iterates, evaluating challenges and issuing responses, until the server is satisfied. The application that is using the mechanism drives each iteration. That is, it extracts the challenge or response from a protocol packet and supplies it to the mechanism, and then puts the response or challenge returned by the mechanism into a protocol packet and sends it to the peer.

Creating the Mechanisms

The client and server code that uses the SASL mechanisms are not hardwired to use specific mechanism(s). In many protocols that use SASL, the server advertises (either statically or dynamically) a list of SASL mechanisms that it supports. The client then selects one of these based on its security requirements.

The Sasl class is used for creating instances of SaslClient and SaslServer. Here is an example of how an application creates a SASL client mechanism using a list of possible SASL mechanisms.

String[] mechanisms = new String[]{"DIGEST-MD5", "PLAIN"};
SaslClient sc = Sasl.createSaslClient(mechanisms,
    authzid, protocol, serverName, props, callbackHandler);
Based on the availability of the mechanisms supported by the platform and other configuration information provided via the parameters, the Java SASL framework selects one of the listed mechanisms and return an instance of SaslClient.

The name of the selected mechanism is usually transmitted to the server via the application protocol. Upon receiving the mechanism name, the server creates a corresponding SaslServer object to process client-sent responses. Here is an example of how the server would create an instance of SaslServer.

SaslServer ss = Sasl.createSaslServer(mechanism,
    protocol, myName, props, callbackHandler);

Passing Input to the Mechanisms

Because the Java SASL API is a general framework, it must be able to accommodate many different types of mechanisms. Each mechanism needs to be initialized with input and may need input to make progress. The API provides three means by which an application gives input to a mechanism.

  1. Common input parameters. The application uses predefined parameters to supply information that are defined by the SASL specification and commonly required by mechanisms. For SASL client mechanisms, the input parameters are authorization id, protocol id, and server name. For SASL server mechanisms, the common input parameters are prototol id and (its own fully qualified) server name.

  2. Properties parameter. The application uses the properties parameter, a mapping of property names to (possibly non-string) property values, to supply configuration information. The Java SASL API defines some standard properties, such as quality-of-protection, cipher strength, and maximum buffer size. The parameter can also be used to pass in non-standard properties that are specific to particular mechanisms.

  3. Callbacks. The application uses the callback handler parameter to supply input that cannot be predetermined or might not be common across mechanisms. When a mechanism requires input data, it uses the callback handler supplied by the application to collect the data, possibly from the end-user of the application. For example, a mechanism might require the end-user of the application to supply a name and password.

    Mechanisms can use the callbacks defined in the javax.security.auth.callback package; these are generic callbacks useful for building applications that perform authentication. Mechanisms might also need SASL-specific callbacks, such as those for collecting realm and authorization information, or even (non-standardized) mechanism-specific callbacks. The application should be able to accommodate a variety of mechanisms. Consequently, its callback handler must be able to service all of the callbacks that the mechanisms might request. This is not possible in general for arbitrary mechanisms, but is usually feasible due to the limited number of mechanisms that are typically deployed and used.

Using the Mechanisms

 Once the application has created a mechanism, it uses the mechanism to obtain SASL tokens to exchange with the peer. The client typically indicates to the server via the application protocol which mechanism to use. Some protocols allows the client to accompany the request with an optional initial response for mechanisms that have an initial response. This feature can be used to lower the number of message exchanges required for authentication. Here is an example of how a client might use SaslClient for authentication.

// Get optional initial response
byte[] response =
    (sc.hasInitialResponse() ? sc.evaluateChallenge(new byte[]) : null);

String mechanism = sc.getName();

// Send selected mechanism name and optional initial response to server
send(mechanism, response);

// Read response
msg = receive();

while (!sc.isComplete() && (msg.status == CONTINUE || msg.status == SUCCESS)) {

    // Evaluate server challenge
    response = sc.evaluateChallenge(msg.contents);

    if (msg.status == SUCCESS) {
        // done; server doesn't expect any more SASL data
        if (response != null) {
           throw new IOException(
               "Protocol error: attempting to send response after completion");
        }
    break;
    } else {
        send(mechanism, response);
    msg = receive();
    }
}
The client application iterates through each step of the authentication by using the mechanism (sc) to evaluate the challenge gotten from the server and to get a response to send back to the server. It continues this cycle until either the mechanism or application-level protocol indicates that the authentication has completed, or if the mechanism cannot evaluate a challenge. If the mechanism cannot evaluate the challenge, it throws an exception to indicate the error and terminates the authentication. Disagreement between the mechanism and protocol about the completion state must be treated as an error because it might indicate a compromise of the authentication exchange.

Here is an example of how a server might use SaslServer.

// Read request that contains mechanism name and optional initial response
msg.receive();

// Obtain a SaslServer to perform authentication
SaslServer ss = Sasl.createSaslServer(msg.mechanism,
    protocol, myName, props, callbackHandler);

// Perform authentication steps until done
while (!ss.isComplete()) {

    try {
        // Process response
        byte[] challenge = sc.evaluateResponse(msg.contents);

        if (ss.isComplete()) {
            send(mechanism, challenge, SUCCESS);
        } else {
            send(mechanism, challenge, CONTINUE);
        msg.receive();
        }
    } catch (SaslException e) {
        send(ERROR);
    sc.dispose();
    break;
    }
}
The server application iterates through each step of the authentication by giving the client's response to the mechanism (ss) to process. If the response is incorrect, the mechanism indicates the error by throwing a SaslException so that the server can report the error and terminate the authentication. If the response is correct, the mechanism returns challenge data to be sent to the client and indicates whether the authentication is complete. Note that challenge data can accompany a "success" indication. This might be used, for example, to tell the client to finalize some negotiated state.

Using the Negotiated Security Layer

 Some SASL mechanisms support only authentication while others support use of a negotiated security layer after authentication. The security layer feature is often not used when the application uses some other means, such as SSL/TLS, to communicate securely with the peer.

When a security layer has been negotiated, all subsequent communication with the peer must take place using the security layer. To determine whether a security layer has been negotiated, get the negotiated quality-of-protection (QOP) from the mechanism. Here is an example of how to determine whether a security layer has been negotiated.

String qop = (String) sc.getNegotiatedProperty(Sasl.QOP);
boolean hasSecurityLayer = (qop != null &&
    (qop.equals("auth-int") || qop.equals("auth-conf")));
A security layer has been negotiated if the Sasl.QOP property indicates that either integrity and/or confidentiality has been negotiated.

To communicate with the peer using the negotiated layer, the application first uses the wrap method to encode the data to be sent to the peer to produce a "wrapped" buffer. It then transfers a length field representing the number of octets in the wrapped buffer followed by the contents of the wrapped buffer to the peer. The peer receiving the stream of octets passes the buffer (without the length field) to unwrap to obtain the decoded bytes sent by the peer. Details of this protocol are described in RFC 2222. Here is an example of how a client application sends and receives application data using a security layer.

// Send outgoing application data to peer
byte[] outgoing = ...;
byte[] netOut = sc.wrap(outgoing, 0, outgoing.length);

send(netOut.length, netOut);   // send to peer

// Receive incoming application data from peer
byte[] netIn = receive();      // read length and ensuing bytes from peer

byte[] incoming = sc.unwrap(netIn, 0, netIn.length);

How SASL Mechanisms are Installed and Selected

 SASL mechanism implementations are provided by SASL security providers. Each provider may support one or more SASL mechanisms and is registered with the Java Cryptography Architecture (JCA). By default, in J2SE 5, the SunSASL provider is automatically registered as a JCA provider. To remove it or reorder its priority as a JCA provider, change the line

security.provider.7=com.sun.security.sasl.Provider
in the Java Security Properties file ($JAVA_HOME/lib/security/java.security).

To add or remove a SASL provider, you add or remove the corresponding line in the Security Properties file. For example, if you want to add a SASL provider and have its mechanisms be chosen over the same ones implemented by the SunSASL provider, then you would add a line to the Security Properties file with a lower number.

security.provider.7=com.example.MyProvider
security.provider.8=com.sun.security.sasl.Provider

Alternatively, you can programmatically add your own provider using the java.security.Security class. For example, the following sample code registers the com.example.MyProvider to the list of available SASL security providers.

Security.addProvider(new com.example.MyProvider());
When an application requests a SASL mechanism by supplying one or more mechanism names, the SASL framework looks for registered SASL providers that support that mechanism by going through, in order, the list of registered providers. The providers must then determine whether the requested mechanism matches the selection policy properties and if so, return an implementation for the mechanism.

The selection policy properties specify the security aspects of a mechanism, such as its susceptibility to certain attacks. These are characteristics of the mechanism (definition), rather than its implementation so all providers should come to the same conclusion about a particular mechanism. For example, the PLAIN mechanism is susceptible to plaintext attacks regardless of how it is implemented. If no selection policy properties are supplied, there are no restrictions on the selected mechanism. Using these properties, an application can ensure that it does not use unsuitable mechanisms that might be deployed in the execution environment. For example, an application might use the following sample code if it does not want to allow the use of mechanisms susceptible to plaintext attacks.

Map props = new HashMap();
props.add(Sasl.POLICY_NOPLAINTEXT, "true");
SaslClient sc = Sasl.createSaslClient(mechanisms,
    authzid, protocol, serverName, props, callbackHandler);
See the Sasl class for descriptions of the selection policy properties.

The SunSASL Provider

 The SunSASL provider supports the following client and server mechanisms.
  • Client Mechanisms
    • PLAIN (RFC 2595). This mechanism supports cleartext username/password authentication.
    • CRAM-MD5 (RFC 2195). This mechanism supports a hashed username/password authentication scheme.
    • DIGEST-MD5 (RFC 2831). This mechanism defines how HTTP Digest Authentication can be used as a SASL mechanism.
    • GSSAPI (RFC 2222). This mechanism uses the GSSAPI for obtaining authentication information. It supports Kerberos v5 authentication.
    • EXTERNAL (RFC 2222). This mechanism obtains authentication information from an external channel (such as TLS or IPsec).

  • Server Mechanisms
    • CRAM-MD5
    • DIGEST-MD5
    • GSSAPI (Kerberos v5)

Client Mechanisms

 The SunSASL provider supports several SASL mechanisms used in popular protocols such as LDAP, IMAP, and SMTP. The following table summarizes the client mechanisms and their required input.

Client Mechanism Name | Parameters/Input | Callbacks | Configuration Properties | Selection Policy
CRAM-MD5 | authorization id (as default username) | NameCallback PasswordCallback |  | Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT
DIGEST-MD5 | authorization id protocol id server name | NameCallback PasswordCallback RealmCallback RealmChoiceCallback | Sasl.QOP Sasl.STRENGTH Sasl.MAX_BUFFER Sasl.SERVER_AUTH "javax.security.sasl.sendmaxbuffer" "com.sun.security.sasl.digest.cipher" | Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT
EXTERNAL | authorization id external channel |  |  | Sasl.POLICY_NOPLAINTEXT Sasl.POLICY_NOACTIVE Sasl.POLICY_NODICTIONARY
GSSAPI | JAAS Subject authorization id protocol id server name |  | Sasl.QOP Sasl.MAX_BUFFER Sasl.SERVER_AUTH "javax.security.sasl.sendmaxbuffer" | Sasl.POLICY_NOACTIVE Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT
PLAIN | authorization id | NameCallback PasswordCallback |  | Sasl.POLICY_NOANONYMOUS

An application that uses these mechanisms from the SunSASL provider must supply the required parameters, callbacks and properties. The properties have reasonable defaults and only need to be set if the application wants to override the defaults. Most of the parameters, callbacks, and properties are described in the API documentation. The following sections describe mechanism-specific behaviors and parameters not already covered by the API documentation.

Cram-MD5

The Cram-MD5 client mechanism uses the authorization id parameter, if supplied, as the default username in the NameCallback
to solicit the application/end-user for the authentication id. The authorization id is otherwise not used by the Cram-MD5 mechanism; only the authentication id is exchanged with the server.

Digest-MD5

The Digest-MD5 mechanism is used for digest authentication and optional establishment of a security layer. It specifies the following ciphers for use with the security layer: Triple DES, DES and RC4 (128, 56, and 40 bits). The Digest-MD5 mechanism can support only ciphers that are available on the platform. For example, if the platform does not support the RC4 ciphers, then the Digest-MD5 mechanism will not use those ciphers.

The Sasl.STRENGTH property supports "high", "medium", and "low" settings; its default is "high,medium,low". The ciphers are mapped to the strength settings as follows.

Strength | Cipher | Cipher Id
high | Triple DES RC4 128 bits | 3des rc4
medium | DES RC4 56 bits | des rc4-56
low | RC4 40 bits | rc4-40

When there is more than one choice for a particular strength, the cipher selected depends on the availability of the ciphers in the underlying platform. To explicitly name the cipher to use, set the "com.sun.security.sasl.digest.cipher" property to the corresponding cipher id. Note that this property setting must be compatible with Sasl.STRENGTH and the ciphers available in the underlying platform. For example, Sasl.STRENGTH being set to "low" and "com.sun.security.sasl.digest.cipher" being set to "3des" are incompatible. The "com.sun.security.sasl.digest.cipher" property has no default.

The "javax.security.sasl.sendmaxbuffer" property specifies (the string representation of) the maximum send buffer size in bytes. The default is 65536. The actual maximum number of bytes will be the minimum of this number and the peer's maximum receive buffer size.

GSSAPI

The GSSAPI mechanism is used for Kerberos v5 authentication and optional establishment of a security layer. The mechanism expects the calling thread's Subject to contain the client's Kerberos credentials or that the credentials could be obtained by implicitly logging in to Kerberos. To obtain the client's Kerberos credentials, use the Java Authentication and Authorization Service (JAAS) to log in using the Kerberos login module. See the Java GSS-API and JAAS Tutorials for Use with Kerberos for details and examples. After using JAAS authentication to obtain the Kerberos credentials, you put the code that uses the SASL GSSAPI mechanism within doAs or doAsPrivileged.

LoginContext lc = new LoginContext("JaasSample", new TextCallbackHandler());
lc.login();
lc.getSubject().doAs(new SaslAction());

class SaslAction implements java.security.PrivilegedAction {
   public class run() {
       ...
       String[] mechanisms = new String[]{"GSSAPI"};
       SaslClient sc = Sasl.createSaslClient(mechanisms,
           authzid, protocol, serverName, props, callbackHandler);
       ...
   }
}
To obtain Kerberos credentials without doing explicit JAAS programming, see the Java GSS-API and JAAS Tutorials for Use with Kerberos. When using this approach, there is no need to wrap the code within doAs or doAsPrivileged.

The "javax.security.sasl.sendmaxbuffer" property specifies (the string representation of) the maximum send buffer size in bytes. The default is 65536. The actual maximum number of bytes will be the minimum of this number and the peer's maximum receive buffer size.

Server Mechanisms

Here is a table that summarizes the server mechanisms and their required input.

Server Mechanism Name | Parameters/Input | Callbacks | Configuration Properties | Selection Policy
CRAM-MD5 | server name | AuthorizeCallback NameCallback PasswordCallback |  | Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT
DIGEST-MD5 | protocol id server name | AuthorizeCallback NameCallback PasswordCallback RealmCallback | Sasl.QOP Sasl.STRENGTH Sasl.MAX_BUFFER "javax.security.sasl.sendmaxbuffer" "com.sun.security.sasl.digest.realm" "com.sun.security.sasl.digest.utf8" | Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT
GSSAPI | JAAS Subject protocol id server name | AuthorizeCallback | Sasl.QOP Sasl.MAX_BUFFER "javax.security.sasl.sendmaxbuffer" | Sasl.POLICY_NOACTIVE Sasl.POLICY_NOANONYMOUS Sasl.POLICY_NOPLAINTEXT

An application that uses these mechanisms from the SunSASL provider must supply the required parameters, callbacks and properties. The properties have reasonable defaults and only need to be set if the application wants to override the defaults.

All users of server mechanisms must have a callback handler that deals with the AuthorizeCallback. This is used by the mechanisms to determine whether the authenticated user is allowed to act on behalf of the requested authorization id, and also to obtain the canonicalized name of the authorized user (if canonicalization is applicable).

Most of the parameters, callbacks, and properties are described in the API documentation. The following sections describe mechanism-specific behaviors and parameters not already covered by the API documentation.

Cram-MD5

The Cram-MD5 server mechanism uses the NameCallback and PasswordCallback to obtain the password required to verify the SASL client's response. The callback handler should use the NameCallback.getDefaultName() as the key to fetch the password.

Digest-MD5

The Digest-MD5 server mechanism uses the RealmCallback, NameCallback, and PasswordCallback to obtain the password required to verify the SASL client's response. The callback handler should use
RealmCallback.getDefaultText() and NameCallback.getDefaultName() as keys to fetch the password.

The "javax.security.sasl.sendmaxbuffer" property is described in the Digest-MD5 client section.

The "com.sun.security.sasl.digest.realm" property is used to specify a list of space-separated realm names that the server supports. The list is sent to the client as part of the challenge. If this property has not been set, the default realm is the server's name (supplied as a parameter).

The "com.sun.security.sasl.digest.utf8" property is used to specify the character encoding to use. "true" means to use UTF-8 encoding; "false" means to use ISO Latin 1 (ISO-8859-1). The default is "true".

GSSAPI

The GSSAPI server mechanism has the same requirements as the GSSAPI client mechanism in terms of Kerberos credentials and the "javax.security.sasl.sendmaxbuffer" property.

Debugging and Monitoring

 The SunSASL provider uses the Logging APIs to provide implementation logging output. This output can be controlled by using the logging configuration file and programmatic API (java.util.logging). The logger name used by the SunSASL provider is "javax.security.sasl". Here is a sample logging configuration file that enables the FINEST logging level for the SunSASL provider.

javax.security.sasl.level=FINEST
handlers=java.util.logging.ConsoleHandler
java.util.logging.ConsoleHandler.level=FINEST

The table below shows the mechanisms and the logging output that they generate.

Mechanism | Logging Level | Information Logged
CRAM-MD5 | FINE | Configuration properties; challenge/response messages
DIGEST-MD5 | INFO | Message discarded due to encoding problem (e.g., unmatched MACs, incorrect padding)
DIGEST-MD5 | FINE | Configuration properties; challenge/response messages
DIGEST-MD5 | FINER | More detailed information about challenge/response messages
DIGEST-MD5 | FINEST | Buffers exchanged at the security layer
GSSAPI | FINE | Configuration properties; challenge/response messages
GSSAPI | FINER | More detailed information about challenge/response messages
GSSAPI | FINEST | Buffers exchanged at the security layer

Implementing a SASL Security Provider

There are three basic steps in implementing a SASL security provider.
  1. Write a class that implements the SaslClient or SaslServer interface.
  2. Write a factory class (that implements SaslClientFactory or SaslServerFactory) that creates instances of the class.
  3. Write a JCA provider that registers the factory.

The first step involves providing an implementation for the SASL mechanism. To implement a client mechanism, you need to implement the methods declared in the SaslClient interface. Similarly, for a server mechanism, you need to implement the methods declared in the SaslServer interface. For the purposes of this discussion, suppose you are developing an implementation for the client mechanism "SAMPLE-MECH", implemented by the class, com.example.SampleMechClient. You must decide what input are needed by the mechanism and how the implementation is going to collect them. For example, if the mechanism is username/password-based, then the implementation would likely need to collect that information via the callback handler parameter.

The next step involves providing a factory class that will create instances of com.example.SampleMechClient. The factory needs to determine the characteristics of the mechanism that it supports (as described by the Sasl.POLICY_* properties) so that it can return an instance of the mechanism when the API user requests it using compatible policy properties. The factory may also check for validity of the parameters before creating the mechanism. For the purposes of this discussion, suppose the factory class is named com.example.MySampleClientFactory. Although our sample factory is responsible for only one mechanism, a single factory can be responsible for any number of mechanisms.

The final step involves creating a JCA provider. The steps for creating a JCA provider is described in detail in the document, How to Implement a Provider for the Java Cryptography Architecture. SASL client factories are registered using property names of the form

SaslClientFactory.mechName
while SASL server factories are registered using property names of the form
SaslServerFactory.mechName
mechName is the SASL mechanism's name. This is what's returned by SaslClient.getMechanismName() and SaslServer.getMechanismName(). Continuing with our example, here is how the provider would register the "SAMPLE-MECH" mechanism.

put("SaslClientFactory.SAMPLE-MECH",  "com.example.MySampleClientFactory");
A single SASL provider might be responsible for many mechanisms. Therefore, it might have many invocations of put to register the relevant factories. The completed SASL provider can then be made available to applications using the instructions given previously.

Copyright © 2004 Sun Microsystems, Inc. All rights reserved.


Contents

CONTENTS | PREV | NEXT

JavaTM 2 Platform Security Architecture

Author: Li Gong

Version 1.2

This document gives an overview of the motivation of the major security features that are being implemented for JavaTM 2 Platform Security, introduces the new classes and their usage, discusses the impact of this new architecture on existing code, and gives thoughts on writing security-sensitive code in the future.

CONTENTS | PREV | NEXT
Copyright © 1997-2002 Sun Microsystems, Inc. All Rights Reserved.


Contents

CONTENTS | PREV | NEXT

JavaTM 2 Platform Security Architecture

This document gives an overview of the motivation of the major security features that are being implemented for the Java 2 SDK, introduces the new classes and their usage, discusses the impact of this new architecture on existing code, and gives thoughts on writing security-sensitive code in the future.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


XML Digital Signature API

Overview and Tutorial

Table of Contents

Java XML Digital Signature API

XML Security Stack

Package Hierarchy

Service Providers

Introduction to XML Signatures

Example of an XML Signature

XML Digital Signature API Examples

validate Example

Validating an XML Signature

Instantiating the Document that Contains the Signature

Specifying the Signature Element to be Validated

Creating a Validation Context

Unmarshaling the XML Signature

Validating the XML Signature

What If the XML Signature Fails to Validate?

Using KeySelectors

genenveloped Example

Generating an XML Signature

Instantiating the Document to be Signed

Creating a Public Key Pair

Creating a Signing Context

Assembling the XML Signature

Generating the XML Signature

Printing or Displaying the Resulting Document

Java XML Digital Signature API

The Java XML Digital Signature API is a standard Java API for generating and validating XML Signatures. This API was defined under the Java Community Process as JSR 105 (see http://jcp.org/en/jsr/detail?id=105). This JSR is final and this release of Java SE contains an FCS access implementation of the Final version of the APIs.

XML Signatures can be applied to data of any type, XML or binary (see http://www.w3.org/TR/xmldsig-core/). The resulting signature is represented in XML. An XML Signature can be used to secure your data and provide data integrity, message authentication, and signer authentication.

After providing a brief overview of XML Signatures and the XML Digital Signature API, this document presents two examples that demonstrate how to use the API to validate and generate an XML Signature. This document assumes that you have a basic knowledge of cryptography and digital signatures.

The API is designed to support all of the required or recommended features of the W3C Recommendation for XML-Signature Syntax and Processing. The API is extensible and pluggable and is based on the Java Cryptography Service Provider Architecture. The API is designed for two types of developers:

  • Developers who want to use the XML Digital Signature API to generate and validate XML signatures
  • Developers who want to create a concrete implementation of the XML Digital Signature API and register it as a cryptographic service of a JCA provider

Package Hierarchy

The six packages listed below comprise the XML Digital Signature API:

  • javax.xml.crypto
  • javax.xml.crypto.dsig
  • javax.xml.crypto.dsig.keyinfo
  • javax.xml.crypto.dsig.spec
  • javax.xml.crypto.dom
  • javax.xml.crypto.dsig.dom

The javax.xml.crypto package contains common classes that are used to perform XML cryptographic operations, such as generating an XML signature or encrypting XML data. Two notable classes in this package are the KeySelector class, which allows developers to supply implementations that locate and optionally validate keys using the information contained in a KeyInfo object, and the URIDereferencer class, which allows developers to create and specify their own URI dereferencing implementations.

The javax.xml.crypto.dsig package includes interfaces that represent the core elements defined in the W3C XML digital signature specification. Of primary significance is the XMLSignature class, which allows you to sign and validate an XML digital signature. Most of the XML signature structures or elements are represented by a corresponding interface (except for the KeyInfo structures, which are included in their own package and are discussed in the next paragraph). These interfaces include: SignedInfo, CanonicalizationMethod, SignatureMethod, Reference, Transform, DigestMethod, XMLObject, Manifest, SignatureProperty, and SignatureProperties. The XMLSignatureFactory class is an abstract factory that is used to create objects that implement these interfaces.

The javax.xml.crypto.dsig.keyinfo package contains interfaces that represent most of the KeyInfo structures defined in the W3C XML digital signature recommendation, including KeyInfo, KeyName, KeyValue, X509Data, X509IssuerSerial, RetrievalMethod, and PGPData. The KeyInfoFactory class is an abstract factory that is used to create objects that implement these interfaces.

The javax.xml.crypto.dsig.spec package contains interfaces and classes representing input parameters for the digest, signature, transform, or canonicalization algorithms used in the processing of XML signatures.

Finally, the javax.xml.crypto.dom and javax.xml.crypto.dsig.dom packages contains DOM-specific classes for the javax.xml.crypto and javax.xml.crypto.dsig packages, respectively. Only developers and users who are creating or using a DOM-based XMLSignatureFactory or KeyInfoFactory implementation will need to make direct use of these packages.

Service Providers

A JSR 105 cryptographic service is a concrete implementation of the abstract XMLSignatureFactory and KeyInfoFactory classes and is responsible for creating objects and algorithms that parse, generate and validate XML Signatures and KeyInfo structures. A concrete implementation of XMLSignatureFactory must provide support for each of the required algorithms as specified by the W3C recommendation for XML Signatures. It can optionally support other algorithms as defined by the W3C recommendation or other specifications.

JSR 105 leverages the JCA provider model for registering and loading XMLSignatureFactory and KeyInfoFactory implementations.

Each concrete XMLSignatureFactory or KeyInfoFactory implementation supports a specific XML mechanism type that identifies the XML processing mechanism that an implementation uses internally to parse and generate XML signature and KeyInfo structures. This JSR supports one standard type, DOM. The XML Digital Signature provider implementation that is bundled with Java SE supports the DOM mechanism. Support for new standard types, such as JDOM, may be added in the future.

An XML Digital Signature API implementation should use underlying JCA engine classes, such as java.security.Signature and java.security.MessageDigest, to perform cryptographic operations.

In addition to the XMLSignatureFactory and KeyInfoFactory classes, JSR 105 supports a service provider interface for transform and canonicalization algorithms. The TransformService class allows you to develop and plug in an implementation of a specific transform or canonicalization algorithm for a particular XML mechanism type. The TransformService class uses the standard JCA provider model for registering and loading implementations. Each JSR 105 implementation should use the TransformService class to find a provider that supports transform and canonicalization algorithms in XML Signatures that it is generating or validating.

Introduction to XML Signatures

You can use an XML Signature to sign any arbitrary data, whether it is XML or binary. The data is identified via URIs in one or more Reference elements. XML Signatures are described in one or more of three forms: detached, enveloping, or enveloped. A detached signature is over data that is external, or outside of the signature element itself. Enveloping signatures are signatures over data that is inside the signature element, and an enveloped signature is a signature that is contained inside the data that it is signing.

Example of an XML Signature

The easiest way to describe the contents of an XML Signature is to show an actual sample and describe each component in more detail. The following is an example of an enveloped XML Signature generated over the contents of an XML document. The contents of the document before it is signed are:

<Envelope xmlns="urn:envelope">
</Envelope>

The resulting enveloped XML Signature, indented and formatted for readability, is as follows:

<?xml version="1.0" encoding="UTF-8"?>
<Envelope xmlns="urn:envelope">
  <Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
    <SignedInfo>
      <CanonicalizationMethod
        Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments"/>
      <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#dsa-sha1"/>
      <Reference URI="">
        <Transforms>
          <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
        </Transforms>
        <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
        <DigestValue>uooqbWYa5VCqcJCbuymBKqm17vY=</DigestValue>
      </Reference>
    </SignedInfo>
    <SignatureValue>
      KedJuTob5gtvYx9qM3k3gm7kbLBwVbEQRl26S2tmXjqNND7MRGtoew==
    </SignatureValue>
    <KeyInfo>
      <KeyValue>
        <DSAKeyValue>
          <P>
            /KaCzo4Syrom78z3EQ5SbbB4sF7ey80etKII864WF64B81uRpH5t9jQTxe
            Eu0ImbzRMqzVDZkVG9xD7nN1kuFw==
          </P>
          <Q>li7dzDacuo67Jg7mtqEm2TRuOMU=</Q>
          <G>
            Z4Rxsnqc9E7pGknFFH2xqaryRPBaQ01khpMdLRQnG541Awtx/
            XPaF5Bpsy4pNWMOHCBiNU0NogpsQW5QvnlMpA==
          </G>
          <Y>
            qV38IqrWJG0V/mZQvRVi1OHw9Zj84nDC4jO8P0axi1gb6d+475yhMjSc/
            BrIVC58W3ydbkK+Ri4OKbaRZlYeRA==
          </Y>
        </DSAKeyValue>
      </KeyValue>
    </KeyInfo>
  </Signature>
</Envelope>

The Signature element has been inserted inside the content that it is signing, thereby making it an enveloped signature. The required SignedInfo element contains the information that is actually signed:

<SignedInfo>
  <CanonicalizationMethod
    Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments"/>
  <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#dsa-sha1"/>
  <Reference URI="">
    <Transforms>
      <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
    </Transforms>
    <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
    <DigestValue>uooqbWYa5VCqcJCbuymBKqm17vY=</DigestValue>
  </Reference>
</SignedInfo>

The required CanonicalizationMethod element defines the algorithm used to canonicalize the SignedInfo element before it is signed or validated. Canonicalization is the process of converting XML content to a canonical form, to take into account changes that can invalidate a signature over that data. Canonicalization is necessary due to the nature of XML and the way it is parsed by different processors and intermediaries, which can change the data such that the signature is no longer valid but the signed data is still logically equivalent.

The required SignatureMethod element defines the digital signature algorithm used to generate the signature, in this case DSA with SHA-1.

One or more Reference elements identify the data that is digested. Each Reference element identifies the data via a URI. In this example, the value of the URI is the empty String (""), which indicates the root of the document. The optional Transforms element contains a list of one or more Transform elements, each of which describes a transformation algorithm used to transform the data before it is digested. In this example, there is one Transform element for the enveloped transform algorithm. The enveloped transform is required for enveloped signatures so that the signature element itself is removed before calculating the signature value. The required DigestMethod element defines the algorithm used to digest the data, in this case SHA1. Finally the required DigestValue element contains the actual base64-encoded digested value.

The required SignatureValue element contains the base64-encoded signature value of the signature over the SignedInfo element.

The optional KeyInfo element contains information about the key that is needed to validate the signature:

<KeyInfo>
  <KeyValue>
    <DSAKeyValue>
      <P>
        /KaCzo4Syrom78z3EQ5SbbB4sF7ey80etKII864WF64B81uRpH5t9jQTxe
        Eu0ImbzRMqzVDZkVG9xD7nN1kuFw==
      </P>
      <Q>li7dzDacuo67Jg7mtqEm2TRuOMU=</Q>
      <G>
        Z4Rxsnqc9E7pGknFFH2xqaryRPBaQ01khpMdLRQnG541Awtx/
        XPaF5Bpsy4pNWMOHCBiNU0NogpsQW5QvnlMpA==
      </G>
      <Y>
        qV38IqrWJG0V/mZQvRVi1OHw9Zj84nDC4jO8P0axi1gb6d+475yhMjSc/
        BrIVC58W3ydbkK+Ri4OKbaRZlYeRA==
      </Y>
    </DSAKeyValue>
  </KeyValue>
</KeyInfo>

This KeyInfo element contains a KeyValue element, which in turn contains a DSAKeyValue element consisting of the public key needed to validate the signature. KeyInfo can contain various content such as X.509 certificates and PGP key identifiers. See the KeyInfo section of the XML Signature Recommendation for more information on the different KeyInfo types.

XML Digital Signature API Examples

The following sections describe two examples that show how to use the XML Digital Signature API:

  • Validate example
  • Signing example

validate Example

You can find the code shown in this section in the Validate.java file in the docs/technotes/guides/security/xmldsig directory. The file on which it operates, envelopedSignature.xml, is in the same directory.

To compile and run the example, execute the following commands from the docs/technotes/guides/security/xmldsig directory:

$ javac Validate.java
$ java Validate signature.xml

The sample program will validate the signature in the file signature.xml in the current working directory.

Validating an XML Signature

This example shows you how to validate an XML Signature using the JSR 105 API. The example uses DOM (the Document Object Model) to parse an XML document containing a Signature element and a JSR 105 DOM implementation to validate the signature.

Instantiating the Document that Contains the Signature

First we use a JAXP DocumentBuilderFactory to parse the XML document containing the Signature. An application obtains the default implementation for DocumentBuilderFactory by calling the following line of code:

DocumentBuilderFactory dbf =
  DocumentBuilderFactory.newInstance();

We must also make the factory namespace-aware:

dbf.setNamespaceAware(true);

Next, we use the factory to get an instance of a DocumentBuilder, which is used to parse the document:

DocumentBuilder builder = dbf.newDocumentBuilder();
Document doc = builder.parse(new FileInputStream(argv[0]));

Specifying the Signature Element to be Validated

We need to specify the Signature element that we want to validate, since there could be more than one in the document. We use the DOM method Document.getElementsByTagNameNS, passing it the XML Signature namespace URI and the tag name of the Signature element, as shown:

NodeList nl = doc.getElementsByTagNameNS
  (XMLSignature.XMLNS, "Signature");
if (nl.getLength() == 0) {
  throw new Exception("Cannot find Signature element");
}

This returns a list of all Signature elements in the document. In this example, there is only one Signature element.

Creating a Validation Context

We create an XMLValidateContext instance containing input parameters for validating the signature. Since we are using DOM, we instantiate a DOMValidateContext instance (a subclass of XMLValidateContext), and pass it two parameters, a KeyValueKeySelector object and a reference to the Signature element to be validated (which is the first entry of the NodeList we generated earlier):

DOMValidateContext valContext = new DOMValidateContext
  (new KeyValueKeySelector(), nl.item(0));

The KeyValueKeySelector is explained in greater detail in Using KeySelectors.

Unmarshaling the XML Signature

We extract the contents of the Signature element into an XMLSignature object. This process is called unmarshalling. The Signature element is unmarshalled using an XMLSignatureFactory object. An application can obtain a DOM implementation of XMLSignatureFactory by calling the following line of code:

XMLSignatureFactory factory =
  XMLSignatureFactory.getInstance("DOM");

We then invoke the unmarshalXMLSignature method of the factory to unmarshal an XMLSignature object, and pass it the validation context we created earlier:

XMLSignature signature =
  factory.unmarshalXMLSignature(valContext);

Validating the XML Signature

Now we are ready to validate the signature. We do this by invoking the validate method on the XMLSignature object, and pass it the validation context as follows:

boolean coreValidity = signature.validate(valContext);

The validate method returns "true" if the signature validates successfully according to the core validation rules in the W3C XML Signature Recommendation, and false otherwise.

What If the XML Signature Fails to Validate?

If the XMLSignature.validate method returns false, we can try to narrow down the cause of the failure. There are two phases in core XML Signature validation:

  • Signature validation (the cryptographic verification of the signature)
  • Reference validation (the verification of the digest of each reference in the signature)

Each phase must be successful for the signature to be valid. To check if the signature failed to cryptographically validate, we can check the status, as follows:

boolean sv =
  signature.getSignatureValue().validate(valContext);
System.out.println("signature validation status: " + sv);

We can also iterate over the references and check the validation status of each one, as follows:

Iterator i =
  signature.getSignedInfo().getReferences().iterator();
for (int j=0; i.hasNext(); j++) {
  boolean refValid = ((Reference)
    i.next()).validate(valContext);
  System.out.println("ref["+j+"] validity status: " +
    refValid);
}

Using KeySelectors

KeySelectors are used to find and select keys that are needed to validate an XMLSignature. Earlier, when we created a DOMValidateContext object, we passed a KeySelector object as the first argument:

DOMValidateContext valContext = new DOMValidateContext
  (new KeyValueKeySelector(), nl.item(0));

Alternatively, we could have passed a PublicKey as the first argument if we already knew what key is needed to validate the signature. However, we often don't know.

The KeyValueKeySelector is a concrete implementation of the abstract KeySelector class. The KeyValueKeySelector implementation tries to find an appropriate validation key using the data contained in KeyValue elements of the KeyInfo element of an XMLSignature. It does not determine if the key is trusted. This is a very simple KeySelector implementation, designed for illustration rather than real-world usage. A more practical example of a KeySelector is one that searches a KeyStore for trusted keys that match X509Data information (for example, X509SubjectName, X509IssuerSerial, X509SKI, or X509Certificate elements) contained in a KeyInfo.

The implementation of the KeyValueKeySelector is as follows:

private static class KeyValueKeySelector extends KeySelector {

  public KeySelectorResult select(KeyInfo keyInfo,
      KeySelector.Purpose purpose,
      AlgorithmMethod method,
      XMLCryptoContext context)
    throws KeySelectorException {

    if (keyInfo == null) {
      throw new KeySelectorException("Null KeyInfo object!");
    }
    SignatureMethod sm = (SignatureMethod) method;
    List list = keyInfo.getContent();

    for (int i = 0; i < list.size(); i++) {
      XMLStructure xmlStructure = (XMLStructure) list.get(i);
      if (xmlStructure instanceof KeyValue) {
        PublicKey pk = null;
        try {
          pk = ((KeyValue)xmlStructure).getPublicKey();
        } catch (KeyException ke) {
          throw new KeySelectorException(ke);
        }
        // make sure algorithm is compatible with method
        if (algEquals(sm.getAlgorithm(),
            pk.getAlgorithm())) {
          return new SimpleKeySelectorResult(pk);
        }
      }
    }
    throw new KeySelectorException("No KeyValue element
found!");
  }

  static boolean algEquals(String algURI, String algName) {
    if (algName.equalsIgnoreCase("DSA") &&
        algURI.equalsIgnoreCase(SignatureMethod.DSA_SHA1)) {
      return true;
    } else if (algName.equalsIgnoreCase("RSA") &&
        algURI.equalsIgnoreCase(SignatureMethod.RSA_SHA1)) {
      return true;
    } else {
      return false;
    }
  }
}

genenveloped Example

The code discussed in this section is in the GenEnveloped.java file in the docs/technotes/guides/security/xmldsig directory. The file on which it operates, envelope.xml, is in the same directory. It generates the file envelopedSignature.xml.

To compile and run this sample, execute the following command from the docs/technotes/guides/security/xmldsig directory:

$ javac GenEnveloped.java
$ java GenEnveloped envelope.xml envelopedSignature.xml

The sample program will generate an enveloped signature of the document in the file envelope.xml and store it in the file envelopedSignature.xml in the current working directory.

Generating an XML Signature

This example shows you how to generate an XML Signature using the XML Digital Signature API. More specifically, the example generates an enveloped XML Signature of an XML document. An enveloped signature is a signature that is contained inside the content that it is signing. The example uses DOM (the Document Object Model) to parse the XML document to be signed and a JSR 105 DOM implementation to generate the resulting signature.

A basic knowledge of XML Signatures and their different components is helpful for understanding this section. See http://www.w3.org/TR/xmldsig-core/ for more information.

Instantiating the Document to be Signed

First, we use a JAXP DocumentBuilderFactory to parse the XML document that we want to sign. An application obtains the default implementation for DocumentBuilderFactory by calling the following line of code:

DocumentBuilderFactory dbf =
  DocumentBuilderFactory.newInstance();

We must also make the factory namespace-aware:

dbf.setNamespaceAware(true);

Next, we use the factory to get an instance of a DocumentBuilder, which is used to parse the document:

DocumentBuilder builder = dbf.newDocumentBuilder();
Document doc = builder.parse(new FileInputStream(argv[0]));

Creating a Public Key Pair

We generate a public key pair. Later in the example, we will use the private key to generate the signature. We create the key pair with a KeyPairGenerator. In this example, we will create a DSA KeyPair with a length of 512 bytes :

KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA");
kpg.initialize(512);
KeyPair kp = kpg.generateKeyPair();

In practice, the private key is usually previously generated and stored in a KeyStore file with an associated public key certificate.

Creating a Signing Context

We create an XML Digital Signature XMLSignContext containing input parameters for generating the signature. Since we are using DOM, we instantiate a DOMSignContext (a subclass of XMLSignContext), and pass it two parameters, the private key that will be used to sign the document and the root of the document to be signed:

DOMSignContext dsc = new DOMSignContext
  (kp.getPrivate(), doc.getDocumentElement());

Assembling the XML Signature

We assemble the different parts of the Signature element into an XMLSignature object. These objects are all created and assembled using an XMLSignatureFactory object. An application obtains a DOM implementation of XMLSignatureFactory by calling the following line of code:

XMLSignatureFactory fac =
  XMLSignatureFactory.getInstance("DOM");

We then invoke various factory methods to create the different parts of the XMLSignature object as shown below. We create a Reference object, passing to it the following:

  • The URI of the object to be signed (We specify a URI of "", which implies the root of the document.)
  • The DigestMethod (we use SHA1)
  • A single Transform, the enveloped Transform, which is required for enveloped signatures so that the signature itself is removed before calculating the signature value
    • Reference ref = fac.newReference
  ("", fac.newDigestMethod(DigestMethod.SHA1, null),
    Collections.singletonList
      (fac.newTransform(Transform.ENVELOPED,
        (TransformParameterSpec) null)), null, null);

Next, we create the SignedInfo object, which is the object that is actually signed, as shown below. When creating the SignedInfo, we pass as parameters:

  • The CanonicalizationMethod (we use inclusive and preserve comments)
  • The SignatureMethod (we use DSA)
  • A list of References (in this case, only one)
    • SignedInfo si = fac.newSignedInfo
  (fac.newCanonicalizationMethod
    (CanonicalizationMethod.INCLUSIVE_WITH_COMMENTS,
      (C14NMethodParameterSpec) null),
    fac.newSignatureMethod(SignatureMethod.DSA_SHA1, null),
    Collections.singletonList(ref));

Next, we create the optional KeyInfo object, which contains information that enables the recipient to find the key needed to validate the signature. In this example, we add a KeyValue object containing the public key. To create KeyInfo and its various subtypes, we use a KeyInfoFactory object, which can be obtained by invoking the getKeyInfoFactory method of the XMLSignatureFactory, as follows:

KeyInfoFactory kif = fac.getKeyInfoFactory();

We then use the KeyInfoFactory to create the KeyValue object and add it to a KeyInfo object:

KeyValue kv = kif.newKeyValue(kp.getPublic());
KeyInfo ki = kif.newKeyInfo(Collections.singletonList(kv));

Finally, we create the XMLSignature object, passing as parameters the SignedInfo and KeyInfo objects that we created earlier:

XMLSignature signature = fac.newXMLSignature(si, ki);

Notice that we haven't actually generated the signature yet; we'll do that in the next step.

Generating the XML Signature

Now we are ready to generate the signature, which we do by invoking the sign method on the XMLSignature object, and pass it the signing context as follows:

signature.sign(dsc);

The resulting document now contains a signature, which has been inserted as the last child element of the root element.

Printing or Displaying the Resulting Document

You can use the following code to print the resulting signed document to a file or standard output:

OutputStream os;
if (args.length > 1) {
  os = new FileOutputStream(args[1]);
} else {
  os = System.out;
}
TransformerFactory tf = TransformerFactory.newInstance();
Transformer trans = tf.newTransformer();
trans.transform(new DOMSource(doc), new StreamResult(os));


JavaTM XML Digital Signature API Specification (JSR 105)

Table of Contents

  • Introduction
  • Acknowledgements
  • Requirements
  • API Dependencies
  • Non-Goals
  • Package Overview
  • Service Providers
  • DOM Mechanism Requirements
  • Open API Issues
  • Examples

Introduction

This document describes the JavaTM XML Digital Signature API Specification (JSR 105). The purpose of this JSR is to define a standard JavaTM API for generating and validating XML signatures.

When this specification is final, there will be a Reference Implementation which will demonstrate the capabilities of this API and will provide an operational definition of this specification. A Technology Compatibility Kit (TCK) will also be available that will verify whether an implementation of the specification is compliant. These are required as per the Java Community Process SM 2.1.

The JSR 105 API is intended to target the following two types of users:

  • JavaTM programmers who want to use the JSR 105 API to generate and validate XML signatures.
  • JavaTM programmers who want to create a concrete implementation of the JSR 105 API and register it as a cryptographic service of a JCA provider.

Acknowledgements

The JSR 105 Expert Group:
  • Nicolas Catania, Hewlett-Packard
  • Donald E. Eastlake 3rd, Motorola
  • Christian Geuer-Pollmann, Apache Software Foundation
  • Hans Granqvist, VeriSign
  • Kazuyuki Harada, Fujitsu
  • Anthony Ho, DSTC
  • Merlin Hughes, Baltimore Technologies
  • Joyce Leung, IBM
  • Gregor Karlinger, IAIK
  • Serge Mister, Entrust Technologies
  • Takuya Mori, NEC Corporation
  • Sean Mullan, Sun Microsystems (co-specification lead)
  • Anthony Nadalin, IBM (co-specification lead)
  • Erwin van der Koogh, Apache Software Foundation
  • Chris Yeung, XML Asia
Also, special thanks to: Valerie Peng, Vincent Ryan, Sharon Liu, Chok Poh, K. Venugopal Rao., Paul Rank, Alexey Gavrilov, Bill Situ, Eric Jendrock, Andrew Fan, Manveen Kaur, Tom Amiro, Michael Mi, Dmitri Silaev, Roman Makarchuk, Vanitha Venkatraman, Arkadiy Sutchilin, and Scott Fordin from Sun Microsystems, Vishal Mahajan from Apache, and Martin Centner from IAIK.

Requirements

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.

  1. W3C Recommendation, XML-Signature Syntax and Processing.
    • The API MUST allow a programmer to generate and validate XML Signatures such that all of the SHOULD and MUST requirements specified by the W3C recommendation can be satisfied.
    • The API MUST allow an implementation of the API to be created such that all of the SHOULD and MUST requirements specified by the W3C recommendation can be satisfied.
  2. An implementation SHOULD support the W3C Recommendation, XML-Signature XPath Filter Transform 2.0.
  3. An implementation SHOULD support the W3C Recommendation, Exclusive XML Canonicalization Version 1.0.
  4. DOM-independent API. The API MUST NOT have dependencies on a specific XML representation, such as DOM. It MUST be possible to create implementations of the API for different XML processing and mechanism representations, such as DOM, JDOM or dom4j.
  5. Extensible, provider-based API. It MUST be possible for a third-party to create and plug in an implementation responsible for managing and creating cryptographic and transform algorithms, dereferencing URIs, and marshalling objects to/from XML.
  6. Support for a default XML mechanism type: DOM. An implementation MUST minimally support the default mechanism type: DOM. This ensures that all implementations of JSR 105 are guaranteed a minimal level of functionality. Implementations MAY support other mechanism types.
  7. Interoperability for the default XML mechanism type: DOM. The API SHOULD ensure that applications using a DOM implementation are portable and interoperable.
  8. J2SE requirements. Implementations of this technology MAY support J2SE 1.2 or later but MUST at a minimum support version 1.4 or later of J2SE.

API Dependencies

  • J2SE (JDK) 1.2 or higher
  • W3C DOM Level 2 API. This dependency is required by classes of the javax.xml.crypto.dom and javax.xml.crypto.dsig.dom packages.

Non-Goals

  1. Support for non-DOM implementations. While the API SHOULD allow non-DOM implementations to be created, it is beyond the scope of the first version to ensure interoperability between implementations other than DOM. Additional standard service provider types MAY be added in the future and necessary API enhancements MAY be considered for a maintenance revision of JSR 105.
  2. Support for a higher-level API. We expect that programmers MAY design high-level APIs which will be built on the JSR 105 API to hide low-level details, address common use-cases or apply profiling constraints. However, it is beyond the scope of the first version to support these requirements. A high-level API MAY be considered for a maintenance release of JSR 105.
  3. Support for user-pluggable algorithms (other than transform and canonicalization algorithms which is supported by the javax.xml.crypto.dsig.TransformService class): Allowing developers to plug in their own implementations of XML Signature algorithms without requiring them to create a complete JSR 105 implementation seems like a worthy goal but SHALL NOT be REQUIRED for this release of JSR 105. A solution we are investigating for a subsequent release of Java SE is to enhance the underlying JCA/JCE to add better support for registering, parsing and processing XML security algorithms, parameters, and key information.

Package Overview

The JSR 105 API consists of 6 packages:
  • javax.xml.crypto
  • javax.xml.crypto.dom
  • javax.xml.crypto.dsig
  • javax.xml.crypto.dsig.dom
  • javax.xml.crypto.dsig.keyinfo
  • javax.xml.crypto.dsig.spec
The javax.xml.crypto package contains common classes that are used to perform XML cryptographic operations, such as generating an XML signature or encrypting XML data. Two notable classes in this package are the KeySelector class, the purpose of which is to allow developers to supply implementations which locate and optionally validate keys using the information contained in a KeyInfo object, and the URIDereferencer class which allows developers to create and specify their own URI dereferencing implementations.

The javax.xml.crypto.dsig package includes interfaces that represent the core elements defined in the W3C XML digital signature specification. Of primary significance is the XMLSignature class, which allows you to sign and validate an XML digital signature. Most of the XML signature structures or elements are represented by a corresponding interface (except for the KeyInfo structures, which are included in their own package, and discussed in the next paragraph). These interfaces include: SignedInfo, CanonicalizationMethod, SignatureMethod, Reference, Transform, DigestMethod, XMLObject, Manifest, SignatureProperty, and SignatureProperties. The XMLSignatureFactory class is an abstract factory that is used to create objects that implement these interfaces.

The javax.xml.crypto.dsig.keyinfo package contains interfaces that represent most of the KeyInfo structures defined in the W3C XML digital signature recommendation, including KeyInfo, KeyName, KeyValue, X509Data, X509IssuerSerial, RetrievalMethod, and PGPData. The KeyInfoFactory class is an abstract factory that is used to create objects that implement these interfaces.

The javax.xml.crypto.dsig.spec package contains interfaces and classes representing input parameters for the digest, signature, transform, or canonicalization algorithms used in the processing of XML signatures.

Finally, the javax.xml.crypto.dom and javax.xml.crypto.dsig.dom packages contains DOM-specific classes for the javax.xml.crypto and javax.xml.crypto.dsig packages, respectively. Only developers and users who are creating or using a DOM-based XMLSignatureFactory or KeyInfoFactory implementation should need to make direct use of these packages.

Service Providers

A JSR 105 cryptographic service is a concrete implementation of the abstract XMLSignatureFactory and KeyInfoFactory classes and is responsible for creating objects and algorithms that parse, generate and validate XML Signatures and KeyInfo structures. A concrete implementation of XMLSignatureFactory MUST provide support for each of the REQUIRED algorithms as specified by the W3C recommendation for XML Signatures. It MAY support other algorithms as defined by the W3C recommendation or other specifications.

JSR 105 leverages the JCA provider model for registering and loading XMLSignatureFactory and KeyInfoFactory implementations.

Each concrete XMLSignatureFactory or KeyInfoFactory implementation supports a specific XML mechanism type that identifies the XML processing mechanism that an implementation uses internally to parse and generate XML signature and KeyInfo structures. This JSR supports one standard type: DOM. Support for new standard types (such as JDOM) MAY be added in the future.

A JSR 105 implementation SHOULD use underlying JCA engine classes, such as java.security.Signature and java.security.MessageDigest to perform cryptographic operations.

In addition to the XMLSignatureFactory and KeyInfoFactory classes, JSR 105 supports a service provider interface for transform and canonicalization algorithms. The TransformService class allows you to develop and plug in an implementation of a specific transform or canonicalization algorithm for a particular XML mechanism type. The TransformService class uses the standard JCA provider model for registering and loading implementations. Each JSR 105 implementation SHOULD use the TransformService class to find a provider that supports transform and canonicalization algorithms in XML Signatures that it is generating or validating.

DOM Mechanism Requirements

The following requirements MUST be abided by when implementing a DOM-based XMLSignatureFactory, KeyInfoFactory or TransformService in order to minimize interoperability problems:
  1. The unmarshalXMLSignature method of XMLSignatureFactory MUST support DOMValidateContext types. If the type is DOMValidateContext, it SHOULD contain an Element of type Signature. Additionally, the unmarshalXMLSignature method MAY populate the Id/Element mappings of the passed-in DOMValidateContext.
  2. The sign method of XMLSignatures produced by XMLSignatureFactory MUST support DOMSignContext types and the validate method MUST support DOMValidateContext types. This requirement also applies to the validate method of SignatureValue and the validate method of Reference.
  3. The implementation MUST support DOMStructures as the mechanism for the application to specify extensible content (any elements or mixed content).
  4. If the dereference method of user-specified URIDereferencers returns NodeSetData objects, the iterator method MUST return an iteration over objects of type org.w3c.dom.Node.
  5. URIReference objects passed to the dereference method of user-specified URIDereferencers MUST be of type DOMURIReference and XMLCryptoContext objects MUST implement DOMCryptoContext.
  6. The previous 2 requirements also apply to URIDereferencers returned by the getURIDereferencer method of XMLSignatureFactory and KeyInfoFactory.
  7. The unmarshalKeyInfo method of KeyInfoFactory MUST support DOMStructure types. If the type is DOMStructure, it SHOULD contain an Element of type KeyInfo.
  8. The transform method of Transform MUST support DOMCryptoContext context parameter types.
  9. The newtransform and newCanonicalizationMethod methods of XMLSignatureFactory MUST support DOMStructure parameter types.
  10. The init, and marshalParams methods of TransformService MUST support DOMStructure and DOMCryptoContext types.
  11. The unmarshalXMLSignature method of XMLSignatureFactory MUST support DOMStructure types. If the type is DOMStructure, it SHOULD contain an Element of type Signature.
  12. The marshal method of KeyInfo MUST support DOMStructure and DOMCryptoContext parameter types.
Note that a DOM implementation MAY internally use other XML parsing APIs other than DOM as long as it doesn't affect interoperability. For example, a DOM implementation of XMLSignatureFactory might use a SAX parser internally to canonicalize data.

Open API Issues

The following is a list of open API issues.
  1. ID attribute registration of external XML document references is not supported.
    Consider the following reference:

  <Reference URI="document.xml">
    <Transforms>
      <Transform Algorithm="http://www.w3.org/TR/1999/REC-xpath-19991116">
        <XPath>id("foo")</XPath>
      </Transform>
    </Transforms>
  </Reference>
    Dereferencing the external document results in an octet stream which is subsequently converted to a NodeSet by the JSR 105 implementation. But the API does not provide a mechanism for registering ID attributes of external documents and therefore the XPath Transform implementation may be unable to identify the "foo" ID.

Programming Examples

Examples 1-3 below demonstrate how to generate different types of simple XML Digital Signature using the JSR 105 API. Example 1 describes how to generate a detached signature using the DSA signature algorithm. Example 2 describes how to generate an enveloped signature. Example 3 decribes how to generate an enveloping signature. Example 4 describes how to validate an XML Signature.
  1. Generating a detached XML Digital Signature
  2. Generating an enveloped XML Digital Signature
  3. Generating an enveloping XML Digital Signature
  4. Validating an XML Digital Signature

Copyright © 2005, Sun Microsystems, Inc. 4150 Network Circle Santa Clara, California 95054 All Rights Reserved.

Please send comments to: java-security@sun.com. This is not a subscription list.


Object Serialization

 Documentation Contents
Object Serialization supports the encoding of objects and the objects reachable from them, into a stream of bytes. Serialization also supports the complementary reconstruction of the object graph from a stream. Serialization is used for lightweight persistence and for communication via sockets or Java Remote Method Invocation (Java RMI). The default encoding of objects protects private and transient data, and supports the evolution of the classes. A class may implement its own external encoding and is then solely responsible for the external format.

Serialization now includes an API that allows the serialized data of an object to be specified independently of the fields of the class and allows those serialized data fields to be written to and read from the stream using the existing protocol to ensure compatiblity with the default writing and reading mechanisms.

Enhancements

  • Enhancements in Java SETM 6 - Describes enhancements and improvements to Object Serialization in Java SE 6.
  • Previous Enhancements - Describes enhancements to Object Serialization made in previous releases of the Java SE Platform.

Specification

  • Specification - Describes the architecture of the Object Serialization system and the APIs.

API Specification

  • java.io Package - Documents all of the interfaces and classes.

More Information

  • FAQ - Answers the most frequently asked questions about Object Serialization.

Examples

  • Examples - Demonstrate different aspects of and uses for Object Serialization.

Tools

  • serialver - Explains the serialver command, which returns the serialVersionUID for a class.

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

Please send comments to: rmi-comments@java.sun.com 		Sun
Java Software


Serialization Enhancements in Previous Releases

Object Serialization Enhancements
in Previous Releases

 Documentation Contents
The following are enhancements to serialization prior to JavaTM SE Development Kit 6 (JDK). For enhancements in the current release, see Serialization Changes and Enhancements in JavaTM SE Development Kit 6.
Support for serialization of enumerated type instances (since 5.0)
Support has been added to serialization to handle enumerated types, which are new in version 5.0. The rules for serializing an enum instance differ from those for serializing an "ordinary" serializable object: the serialized form of an enum instance consists only of its enum constant name, along with information identifying its base enum type. Deserialization behavior differs as well--the class information is used to find the appropriate enum class, and the Enum.valueOf method is called with that class and the received constant name in order to obtain the enum constant to return.

Bug fix: java.io.StreamCorruptedException thrown due to java.lang.ClassNotFoundException (since 5.0)
In previous releases starting with version 1.4.0, a ClassNotFoundException thrown by the ObjectInputStream.readClassDescriptor method would be reflected to the top-level caller of ObjectInputStream.readObject as a StreamCorruptedException with an empty cause. It is now reflected to the top-level caller as an InvalidClassException with the original ClassNotFoundException as the cause.

Bug fix: thread waiting on a java.io.ObjectStreamClass$EntryFuture for notification from [sic] (since 5.0)
In previous releases starting with version 1.4.0, the ObjectStreamClass.lookup method could deadlock if called from within the static initializer of the class represented by the method's Class argument. Deadlock should no longer occur in this case.

Bug fix: no spec for serialVersionUID (since 5.0)
The javadoc for the Serializable interface has been expanded to more completely specify the role and usage of serialVersionUIDs, and to emphasize the need to specify explicit serialVersionUIDs for serializable classes.
Support for deserialization of unshared objects (since 1.4)
Serialization now provides extra support for deserialization of objects which are known to be unshared in the data-serialization stream. The new support is provided by the following API additions in package java.io:
ObjectInputStream.readUnshared()

ObjectOutputStream.writeUnshared(Object obj)

ObjectStreamField(String name, Class type, boolean unshared)

These APIs can be used to more efficiently read contained array objects in a secure fashion; for more information, see section A.6 of the Java Object Serialization Specification, "Guarding Unshared Deserialized Objects".

Security permissions now required to override putFields, readFields (since 1.4)
Beginning with J2SE 1.4.0, ObjectOutputStream's public one-argument constructor requires the "enableSubclassImplementation" SerializablePermission when invoked (either directly or indirectly) by a subclass which overrides ObjectOutputStream.putFields or ObjectOutputStream.writeUnshared.

Also beginning with J2SE 1.4.0, ObjectInputStream's public one-argument constructor requires the "enableSubclassImplementation" SerializablePermission when invoked (either directly or indirectly) by a subclass which overrides ObjectInputStream.readFields or ObjectInputStream.readUnshared.

These changes will not affect the great majority of applications. However, it will affect any ObjectInputStream/ObjectOutputStream subclasses which override the putFields or readFields methods without also overriding the rest of the serialization infrastructure.

Support for class-defined readObjectNoData method (since 1.4)
In addition to supporting class-defined writeObject() and readObject() methods, serialization now includes support for class-defined readObjectNoData() methods. Each class-defined readObjectNoData() method is required to have the following signature:
private void readObjectNoData() throws ObjectStreamException;
The readObjectNoData() method is analogous to the class-defined readObject() method, except that (if defined) it is called in cases where the class descriptor for a superclass of the object being deserialized (and hence the object data described by that class descriptor) is not present in the serialization stream. More formally:
If object O of class C is being deserialized, and S is a superclass of C in the VM which is deserializing O, then S.readObjectNoData() is invoked by ObjectInputStream during the deserialization of O if and only if the following conditions are true:
  1. S implements java.io.Serializable (directly or indirectly).
  2. S defines an readObjectNoData() method with the signature listed above.
  3. The serialization stream containing O does not include a class descriptor for S among its list of superclass descriptors for C.
Note that readObjectNoData() is never invoked in cases where a class-defined readObject() method could be called, though serializable class implementors can call readObjectNoData() from within readObject() as a means of consolidating initialization code.

See the class description in the API specification of ObjectInputStream for more information.

Bug fix: Deserialization fails for Class object of primitive type (since 1.4)
In previous releases, bug 4171142 caused attempts to deserialize Class objects of primitive types to fail with a ClassNotFoundException. The problem was that ObjectInputStream.resolveClass() did not work for ObjectStreamClass descriptors for primitive types. This bug is fixed in J2SE 1.4.0.

Bug fix: ObjectInputStream.resolveProxyClass can fail for non-public interface cases (since 1.4)
In previous releases, ObjectInputStream.resolveProxyClass would not always select the proper class loader to define the proxy class in if one or more of the proxy interfaces were non-public. In this release, if ObjectInputStream.resolveProxyClass detects a non-public interface, it attempts to define the implementing proxy class in the same class loader as the interface (barring conflicts, in which case an exception is thrown), which is necessary in order for the proxy to implement the interface.

Bug fix: Invalid serialPersistentFields field name causes NullPointerException (since 1.4)
In previous releases, bug 4387368 caused NullPointerExceptions to be thrown when serializing objects which used default serialization but also declared serialPersistentField entries which did not map to actual class fields. Serialization will now throw InvalidClassExceptions in such cases (since it is never necessary to define such "unbacked" serialPersistentFields when using default serialization).

Bug fix: ClassNotFoundException in skipped objects causes serialization to fail (since 1.4)
In previous releases, ClassNotFoundExceptions triggered by "skipped" objects--objects associated with fields not present in the classes loaded by the deserializing party--would cause deserialization of the entire object graph to fail, even though the skipped values would not be included in the graph. This release of serialization addresses this problem by ignoring ClassNotFoundExceptions associated with such skipped objects, thus eliminating a class of unnecessary deserialization errors. Other miscellaneous changes have also been made to improve the overall robustness of serialization with regards to ClassNotFoundExceptions encountered during deserialization.
Strings longer than 64K can now be serialized (since 1.3)
Prior to 1.3, an attempt to serialize a string longer than 64K would result in a java.io.UTFDataFormatException being thrown. In 1.3, the serialization protocol has been enhanced to allow strings longer than 64K to be serialized. Note that if a 1.2 (or earlier) JVM attempts to read a long string written from a 1.3-compatible JVM, the 1.2 (or earlier) JVM will receive a java.io.StreamCorruptedException.

Serialization performance enhancements (since 1.3)
Several changes have been made to serialization to improve overall performance:
  • UTF string reads/writes have been optimized to reduce unnecessary memory allocation and synchronization/method call overhead.
  • Code for reading and writing primitive data arrays has been streamlined. Float and double array reads/writes have been reimplemented to minimize the number of calls to native methods.
  • Internal buffering has been improved.
  • Reflective operations for getting/setting primitive field values have been batched to minimize the number of separate native method calls.

Improved exception reporting (since 1.3)
If a class cannot be found during the class resolution process of deserialization, the original java.lang.ClassNotFoundException is thrown instead of a generic one so that more information about the failure is available. Also, deserialization exception reporting now includes maintaining the name of the original class that could not be found instead of reporting a higher-level class that was being deserialized. For example, if (in an RMI call) the stub class can be found but the remote interface class cannot, the serialization mechanism will now report correctly that the interface class was the class that could not be found instead of erroneously reporting that the stub class could not be found.

java.io.ObjectOutputStream.writeClassDescriptor,
java.io.ObjectInputStream.readClassDescriptor (since 1.3)
The writeClassDescriptor and readClassDescriptor methods have been added to provide a means of customizing the serialized representation of java.io.ObjectStreamClass class descriptors. writeClassDescriptor is called when an instance of java.io.ObjectStreamClass needs to be serialized, and is responsible for writing the ObjectStreamClass to the serialization stream. Conversely, readClassDescriptor is called when the ObjectInputStream expects an ObjectStreamClass instance as the next item in the serialization stream. By overriding these methods, subclasses of ObjectOutputStream and ObjectInputStream can transmit class descriptors in an application-specific format. For more information, refer to sections 2.1 and 3.1 of the Java Object Serialization Specification.

java.io.ObjectOutputStream.annotateProxyClass,
java.io.ObjectInputStream.resolveProxyClass (since 1.3)
These methods are similar in purpose to ObjectOutputStream.annotateClass and ObjectInputStream.resolveClass, except that they apply to dynamic proxy classes (see java.lang.reflect.Proxy), as opposed to non-proxy classes. Subclasses of ObjectOutputStream may override annotateProxyClass to store custom data in the stream along with descriptors for dynamic proxy classes. ObjectInputStream subclasses may then override resolveProxyClass to make use of the custom data in selecting a local class to associate with the given proxy class descriptor. For details, see section 4 of the Java Object Serialization Specification.

The javadoc tool tags @serial, @serialField, and @serialData (since 1.2)
The javadoc tags @serial, @serialField, and @serialData have been added to provide a way to document the serialized form of a class. Javadoc generates a serialization specification based on the contents of these tags. For details, refer to section 1.6 of the Java Object Serialization Specification.

Protocol versioning (since 1.2)
Prior to 1.2, object serialization used a protocol that did not support skipping over objects implementing the java.io.Externalizable interface if the classes for those objects were not available. In 1.2, a new protocol version was added which addressed this deficiency. For backwards compatibility, ObjectOutputStream and ObjectInputStream can read and write serialization streams written in either protocol; the protocol version used can be selected by calling the ObjectOutputStream.useProtocolVersion method. For details and a discussion of compatibility issues, see section 6.3 of the Java Object Serialization Specification.

Class-defined writeReplace and readResolve methods (since 1.2)
Since 1.2, classes can define writeReplace and readResolve methods which allow instances of the given classes to nominate replacements for themselves during serialization and deserialization. The required signatures of these methods, along with further details, are described in sections 2.5 and 3.6 of the Java Object Serialization Specification.

java.io.ObjectOutputStream.writeObjectOverride, java.io.ObjectInputStream.readObjectOverride (since 1.2)
Since 1.2, subclasses of ObjectOutputStream and ObjectInputStream can implement a custom serialization protocol by overriding the writeObjectOverride and readObjectOverride methods. Note that these methods will only be called if the ObjectOutputStream/ObjectInputStream subclasses possess the permission java.io.SerializablePermission("enableSubclassImplementation"), and call the no-argument constructors of ObjectOutputStream/ObjectInputStream. See sections 2.1 and 3.1 of the Java Object Serialization Specification for more information.

Security permission checks (since 1.2)
Subclasses of ObjectOutputStream and ObjectInputStream may override inherited methods to obtain "hooks" into certain aspects of the serialization process. Since 1.2, object serialization uses the 1.2 security model to verify that subclasses possess adequate permissions to override certain hooks. The permissions java.io.SerializablePermission("enableSubclassImplementation") and java.io.SerializablePermission("enableSubstitution") govern whether or not the methods ObjectOutputStream.writeObjectOverride, ObjectOutputStream.replaceObject, ObjectInputStream.readObjectOverride, and ObjectInputStream.resolveObject will be called during the course of serialization. See sections 2.1 and 3.1 of the Java Object Serialization Specifications for more information.

Defining serializable fields for a class (since 1.2)
By default, the values of all non-static and non-transient fields of a serializable class are written when an instance of that class is serialized. In 1.2, a new mechanism was introduced to allow classes finer control of this process. By declaring a special field serialPersistentFields, serializable classes can dictate which fields will be written when instances of the class (or subclasses) are serialized. This feature also enables classes to "define" serializable fields which do not correspond directly to actual fields in the class. Used in conjunction with the serializable fields API (described below), this capability allows fields to be added or removed from a class without altering the serialized representation of the class. See sections 1.5 and 1.7 of the Java Object Serialization Specification for details.

Serializable fields API (since 1.2)
Introduced in 1.2, the serializable fields API allows class-defined writeObject/readObject methods to explicitly set and retrieve serializable field values by name and type. This API is particularly useful for classes that need to maintain backwards compatibility with older class versions; in some cases, the older version of the class may have defined a set of serializable fields that cannot be mapped directly to the fields of the current class. In this case, newer versions of the class can define custom writeObject and readObject methods that convert the internal state of a given instance of the (new) class into the "old" serialized form, and vice versa. For more information, see section 1.7 of the Java Object Serialization Specification.
*As used on this web site, the terms "Java virtual machine" or "JVM" mean a virtual machine for the Java platform.

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

Please send comments to: rmi-comments@java.sun.com 		Sun
Java Software


Serialization Release Notes

Serialization Changes and Enhancements
in JavaTM SE Development Kit 6

 Documentation Contents
The following are enhancements to serialization in Java SE Development Kit 6 (JDK). For a summary of enhancements in previous releases, see Enhancements in Previous Releases.

java.io.ObjectStreamClass.lookupAny
In previous releases, it was difficult to programmatically obtain an ObjectStreamClass instance for a non-serializable Class, although doing so can be desirable when customizing the stream format for class descriptors (see 4413615 for more information). The new method ObjectStreamClass.lookupAny can now be used for this purpose.

Bug fix: delayed garbage collection
In previous releases, bug 6232010 could cause serializable classes and subclasses of ObjectOutputStream and ObjectInputStream to be strongly referenced long after their use in a serialization operation, thus possibly delaying garbage collection of their defining class loaders indefinitely. Internal caches in the serialization implementation have been restructured to fix this bug.

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

Please send comments to: rmi-comments@java.sun.com 		Sun
Java Software


Object Serialization Examples

The following examples demonstrate different aspects of and uses for Object Serialization:

  • Using Serialization with Sockets
  • Using Serialization with a Custom Data Format
  • Using Serialization with SuperClasses:
    • Serialization with a NonSerializable Superclass
    • Externalization with an Externalizable Superclass
    • Externalization with a NonExternalizable Superclass
  • Using Serialization with Evolution:
    • Serialization and Evolution
    • Externalization and Evolution
    • Serialization, Evolution, and the addition of a new SuperClass
    • Serialization, Evolution, and the Serializable Fields API
  • Using Substitution by Serializable Class


serialver - The Serial Version Command

The serialver command returns the serialVersionUID.

SYNOPSIS

serialver [ options ]

DESCRIPTION

serialver returns the serialVersionUID for one or more classes in a form suitable for copying into an evolving class. When invoked with no arguments it prints a usage line.

OPTIONS
-show

Displays a simple user interface. Enter the full class name and press either the Enter key or the Show button to display the serialVersionUID.

SEE ALSO

java.io.ObjectStreamClass


Using Serialization and the Serializable Fields API

Using Serialization and the Serializable Fields API blue bar

Source Files

The following source files are provided:

OriginalClass.java, the Original Class
EvolvedClass.java, the Evolved Class

Additional Information

Running the Example
Abstract
List of Examples


Using Serialization and the Serializable Fields API

Abstract

This example shows how to use the Serializable Fields API with Serialization, demonstrating that the class can define fields other than those already in the class to be serializable. This differs from just rewriting the writeObject method to customize the data format (see the Custom Data Format example) because, in this example, versioning support still holds.

Using the Serializable Fields API, this example specifically changes the internal representation of a rectangle from x1,y1,x2,y2 implementation (see OriginalClass.java) to Point(x1,y1), Point(x2,y2) (see EvolvedClass.java) while the external representation still remains x1, y1, x2, y2. This ensures bidirectional compatibility between the original and evolved representations.

As with all examples dealing with evolution, here the evolved class (ARectangle) must define a serialVersionUID field that is obtained using the command serialver on the original class (ARectangle).

Additional Information

Source Files
Running the Example
List of Examples


Using Serialization and the Serializable Fields API

Running the Example

Complete the following procedure to compile and run this example:

  1. From yourbasedir/objectserializationexamples/AlternatePersistentFieldAPI, compile the Original Class using JDKTM 1.2 or higher:
      javac OriginalClass.java
  2. Run the Original Class with the serialization flag:
      java OriginalClass -s
  3. Compile the Evolved Class:
      javac EvolvedClass.java
  4. Run the Evolved Class with the deserialization flag:
      java EvolvedClass -d

This procedure tests compatibility in one direction only. To test bidirectional compatibility, perform the same procedure in the other direction (in steps 1-4, replace the original class name with the evolved class name, and vice versa).

Additional Information

Abstract
Sources
List of Examples


Using Serialization with a Custom Data Format

Source Files

The following source file is provided:

CustomDataExample.java

Additional Information:

Running the Example
Abstract
List of Examples


Using Serialization with a Custom Data Format

Abstract

Demonstrates how to use the writeObject and readObject methods to encode a custom data format. When there is a large amount of persistent data, that data should be stored in a convenient, condensed format, such as the one used in this example.

This example uses a triangular array, a symmetrical, 2-dimensional array. During serialization only half of the array is saved. This example serializes half of the array in writeObject, then restores the whole array in readObject by deserializing half of the array and copying to restore the other half of the array.

This example differs from the Using Serialization and the Serializable Fields API Example in that this example does not support versioning. In addition, because this example does not use an Externalizable interface, superclasses are not a consideration.

Additional Information

Source Files
Running the Example
List of Examples


Using Serialization with a Custom Data Format

Serialization and Custom Data Format

Running the Example

Complete the following procedure to compile and run the example:

  1. From yourbasedir/objectserializationexamples/CustomDataFormat, compile the file CustomDataExample.java using JDK TM 1.1 or higher:
      javac CustomDataExample.java
  2. Run the file you just compiled:
      java CustomDataExample

Two arrays are printed:

  • The first array shows the array before serialization.
  • The second array shows the array after deserialization.

Additional Information:

Abstract
Sources
List of Examples


Serialization, Evolution, and the Addition of a New SuperClass

Source Files

The following source files are provided:

OriginalClass.java
EvolvedClass.java

Additional Information

Running the Example
Abstract
List of Examples


Serialization, Evolution, and the Addition of a New SuperClass

Abstract

Shows how to use versioning in serialization to evolve the class to have a new superclass. For example, if the initial class structure was as follows:

  class A {...};
  class C extends A {...};

and the evolved class structure is as follows:

  class A {...};
  class B extends A {...};
  class C extends B {...};

then the new version of subclass C should be able to read the old version of subclass C, and vice versa. The example demonstrates this principle.

The evolved classses (ASuperClass and ASubClass) must define a serialVersionUID field that is obtained using the command serialver on the original classes (ASuperClass and ASubClass).

Note that in this example, the superclasses (A and B) implement the Serializable interface. If they did not, subclass C would be responsible for saving and restoring the fields of A and B. See Serialization with a NonSerializable Superclass for additional information about this topic.

Additional Information:

Source Files
Running the Example
List of Examples


Serialization, Evolution, and the Addition of a New SuperClass

Running the Example

Complete the following procedure to compile and run this example:

  1. From yourbasedir/objectserializationexamples/AddingNewSuperClassAndEvolution, compile the Original Class using JDKTM 1.2 or higher:
      javac OriginalClass.java
  2. Run the Original Class with the serialization flag:
      java OriginalClass -s
  3. Compile the Evolved Class:
      javac EvolvedClass.java
  4. Run the Evolved Class with the deserialization flag:
      java EvolvedClass -d

This procedure tests compatibility in one direction only. To test bidirectional compatibility, perform the same procedure in the other direction (in steps 1-4, replace the original class name with the evolved class name, and vice versa).

For more information:

Abstract
Sources
List of Examples


Using Serialization with Evolution

Source Files

The following source files are provided:

EvolutionExampleOriginalClass.java, the Original Class
EvolutionExampleEvolvedClass.java, the Evolved Class

Additional Information

Running the Example
Abstract
List of Examples


Using Serialization with Evolution

Abstract

Under certain circumstances, when Java objects use serialization to store objects, the version of the class reading the data could be different from the version of class that wrote that data.

This example demonstrates some of the compatible changes that Serialization handles without using class-specific methods.

As with all examples that deal with evolution, the evolved class (AClass) must define a serialVersionUID field that is obtained using the command serialver on the original class (AClass).

Additional Information

Source Files
Running the Example
List of Examples


Using Serialization with Evolution

Running the Example

Complete the following procedure to compile and run this example:

  1. From yourbasedir/objectserializationexamples/SerializationAndEvolution, compile the Original Class using JDKTM 1.2 or higher:
      javac EvolutionExampleOriginalClass.java
  2. Run the Original Class with the serialization flag:
      java EvolutionExampleOriginalClass -s
  3. Compile the Evolved Class:
      javac EvolutionExampleEvolvedClass.java
  4. Run the Evolved Class with the deserialization flag:
    java EvolutionExampleEvolvedClass -d

This procedure tests compatibility in one direction only. To test bidirectional compatibility, perform the same procedure in the other direction (in steps 1-4, replace the original class name with the evolved class name, and vice versa).

Additional Information

Abstract
Sources
List of Examples


Using Externalization and Evolution

Source Files

The following source files are provided:

ExternExampleOriginalClass.java, the Original Class
ExternExampleEvolvedClass.java, the Evolved Class

Additional Information

Running the Example
Abstract
List of Examples


Using Externalization and Evolution

Abstract

This example shows how to evolve a persistent format using the Externalizable interface. A class that uses the Externalizable interface is responsible for saving its own state, for saving the state of its supertype, and for versioning (including skipping over data).

This example specifically deals with versioning. For information about saving the state of the supertype, which may or may not be Externalizable, see the following examples:

  • Using Serialization with a NonSerializable Superclass
  • Using Externalization with an Externalizable Superclass
  • Using Externalization with a NonExternalizable Superclass

Additional Information

Running the Example
Sources
List of Examples


Using Externalization and Evolution

Running the Example

Complete the following procedure to compile and run this example:

  1. From yourbasedir/objectserializationexamples/ExternalizationandEvolution, compile the Original Class using JDKTM 1.2 or higher:
      javac ExternExampleOriginalClass.java
  2. Run the Original Class with the serialization flag:
      java ExternExampleOriginalClass -s
  3. Compile the Evolved Class:
      javac ExternExampleEvolvedClass.java
  4. Run the Evolved Class with the deserialization flag:
      java ExternExampleEvolvedClass -d

This procedure tests compatibility in one direction only. To test bidirectional compatibility, perform the same procedure in the other direction (in steps 1-4, replace the original class name with the evolved class name, and vice versa).

Additional Information

Abstract
Sources
List of Examples


Externalization with an Externalizable SuperClass

Source Files

The following source files are provided:

Savesuper.java
Book.java, tThe subclass book
ReadingMaterial.java, the superclass ReadingMaterial

Additional Information

Running the Example
Abstract
List of Examples


Externalization with an Externalizable SuperClass

Abstract

When using the Externalizable interface, an externalizable object must implement a writeExternal method to save the state of the object and a readExternal method to restore the state of the object. The externalizable object must also coordinate with its supertype to save and restore its state.

This example demonstrates how an object saves and restores the state of its externalizable supertype. When the supertype of an externalizable object is also externalizable, the subclass object calls the writeExternal and readExternal methods of its superclass in its own writeExternal and readExternal methods.

Additional Information:

Source Files
Running the Example
List of Examples


Externalization with an Externalizable SuperClass

Running the Example

Complete the following procedure to compile and run this example:

  1. From yourbasedir/objectserializationexamples/ExternalizableSuperclass, compile the Savesuper.java file using JDKTM 1.1 or higher:
      javac Savesuper.java
  2. Run the file you just compiled: java Savesuper

The original book object is printed (showing the object before serialization) and then the new book object is printed (showing the object after serialization).

Additional Information

Abstract
Sources
List of Examples

< blue bar


Externalization with an NonExternalizable SuperClass

Exernalization with an NonExternalizable SuperClass

Source Files

The following source files are provided:

Nonexternsuper.java
Book.java, the subclass book
ReadingMaterial.java, the superclass ReadingMaterial

Additional Information:

Running the Example
Abstract
List of Examples


Externalization with an NonExternalizable SuperClass

Exernalization with an NonExternalizable SuperClass

Abstract

When using the Externalizable interface, an externalizable object must implement a writeExternal method to save the state of the object and a readExternal method to restore the state of the object. The externalizable object must also coordinate with its supertype to save and restore its state.

This example demonstrates how an object saves and restores the state of its nonexternalizable supertype. When the supertype of an externalizable object is not externalizable, the subclass object must explicitly save and restore the state of the fields of the superclass in its own writeExternal and readExternal methods.

Additional Information:

Source Files
Running the Example
List of Examples


Externalization with an NonExternalizable SuperClass

Exernalization with an NonExternalizable SuperClass

Running the Example

Complete the following procedure to compile and run the example:

  1. From yourbasedir/objectserializationexamples/NonExternalizableSuperclass, compile the file Nonexternsuper.java using JDKTM 1.1 or higher:
      javac Nonexternsuper.java
  2. Run the compiled file:
      java Nonexternsuper

The book object prints out before and after serialization.

Additional Information

Abstract
Sources
List of Examples


Using Serialization with a NonSerializable Superclass

Source Files

The following source files are provided:

NonSerialSuperExample.java
Book.java, the subclass Book
ReadingMaterial.java, the superclass ReadingMaterial

Additional Information:

Running the Example
Abstract
List of Examples


Using Serialization with a NonSerializable Superclass

Abstract

Shows how to serialize a subclass which has a superclass that is not serializable.

When a superclass of a particular subclass is not serializable, the subclass must save and restore the state of the superclass.

Additional Information

Source Files
Running the Example
List of Examples


Using Serialization with a NonSerializable Superclass

Running the Example

Complete the following procedure to compile and run the two examples:

  1. From yourbasedir/objectserializationexamples/NonSerializableSuperClass, compile the files using JDKTM 1.1 or higher:
      javac NonSerialSuperExample.java
  javac Book.java
  javac ReadingMaterial.java
  2. Run the compiled file:
      java NonSerialSuperExample

The book object prints out before and after serialization.

Additional Information:

Abstract
Sources
List of Examples


Using Serialization with Sockets

Source Files

The following source files are provided:

  • Server.java
  • Client.java

Additional Information:

Running the Example
Abstract
List of Examples


Using Serialization with Sockets

Abstract

Shows how to use sockets and serialization for sending and receiving objects.

In this example, the current date is sent from the client to the server. The file Client.java provides the code for sending the date and the file Server.java provides the code for receiving the date. The Server is the local host machine.

Additional Information:

Source Files
Running the Example
List of Examples


Using Serialization with Sockets

Running the Example:

Complete the following procedure to compile and run the two examples:

  1. From yourbasedir/objectserializationexamples/UsingSockets, compile the files Server.java and Client.java using JDKTM1.1 or higher:
      javac Server.java
  javac Client.java
  2. Run the Server:
      java Server
  3. Suspend the Server, using Ctrl/Z on UNIX systems.
  4. Put the Server in the background, using the following command on UNIX systems:
      bg
  5. Run the Client:
      java Client

Using sockets and serialization, the current date is sent from the client to the server, which then prints out the date.

Additional Information:

Abstract
Sources
List of Examples


Substitution by Serializable Classes

Serialization and the writeReplace/readResolve Methods

Source Files

The following source file is provided:

Substitute.java

Additional Information

Running the Example
Abstract
List of Examples


Substitution by Serializable Classes

Serialization and the writeReplace/readResolve Methods

Abstract

This example demonstrates how to use the writeReplace/readResolve methods. The readResolve method resolves the object read from the stream before it is returned to the caller. The writeReplace method allows a Serializable class of an object to nominate its own replacement in the stream before the object is written.

This example creates a symbol class for which only one instance of each each symbol binding exists. The Symbol class defines the readResolve method. A symbol is created from outside using the symbollookup method. The symbollookup method finds and returns a symbol if one already and, if one does not already exist, creates one. This assures uniqueness within one VM. Then, when the readResolve method is called as the symbol is being read, a preexisting equivalent Symbol object is substituted from the hashtable to maintain the unique identity constraint, if such a symbol exists. If the symbol does not exist, the new symbol is added to the hashtable and returned. This assures uniqueness when dealing with more than one VM.

Additional Information

Source Files
Running the Example
List of Examples


Substitution by Serializable Classes

Serialization and the writeReplace/readResolve Methods

Running the Example

Complete the following procedure to compile and run the example:

  1. From yourbasedir/objectserialization/ReplaceableInterface, compile the file Substitute.java using JDKTM 1.2 or higher:
      javac Substitute.java
  2. Run the compiled file:
      java Substitute

Additional Information

Abstract
Sources
List of Examples


Java Sound Enhancements in JDK 5.0

Java

JavaTM Sound Enhancements in JDKTM 5.0

The following enhancements took effect at JDK 5.0.

  • Ports are available on all platforms (RFE 4782900).
  • MIDI device i/o is available on all platforms (RFE's 4812168, 4782924).
  • Optimized direct audio access is implemented on all platforms (RFEs 4908240 and 4908879). It is enabled by default on systems which offer native mixing (i.e. Linux ALSA with hardware mixing, Solaris Mixer enabled, Windows DirectSound).
  • The new real-time Sequencer works with all MIDI devices and allows unlimited Transmitters (RFE 4773012).
  • The sound.properties configuration file allows choice of default devices (RFE 4776511). For details, see MidiSystem and AudioSystem for details.
  • MidiDevices can query connected Receivers and Transmitters (RFE 4931387, methods MidiDevice.getReceiver and MidiDevice.getTransmitter).
  • AudioFormat, AudioFileFormat, and MidiFileFormat now have properties that allow further description and qualification of the format (RFEs 4925767 and 4666845).
  • A set of ease-of-use methods allow easier retrieval of lines from AudioSystem (RFE 4896221).
  • The Sequencer interface is extended with loop methods, for seamless looping of specific portions of a MIDI sequence (RFE 4204105).
  • Java Sound no longer prevents the VM from exiting (bug 4735740).


Java Sound Technology

Java

JavaTM Sound Technology

 Documentation Contents
The Java Platform includes a powerful API for capturing, processing, and playing back audio and MIDI (Musical Instrument Digital Interface) data. This API is supported by an efficient sound engine which guarantees high-quality audio mixing and MIDI synthesis capabilities for the platform.

The provided reference implementation of this API supports the following features:

  • Audio file formats: AIFF, AU and WAV
  • Music file formats: MIDI Type 0, MIDI Type 1, and Rich Music Format (RMF)
  • Sound formats: 8-bit and 16-bit audio data, in mono and stereo, with sample rates from 8 kHz to 48 kHz
  • Linear, a-law, and mu-law encoded data in any of the supported audio file formats
  • MIDI wavetable synthesis and sequencing in software, and access to hardware MIDI devices
  • An all-software mixer that can mix and render up to 64 total channels of digital audio and synthesized MIDI music

The above list describes the reference implementation, not the API itself. The API permits flexible configuration of the audio and MIDI system, including ways for applications to ask the system exactly what resources are installed and available.

API Reference

  • javax.sound.sampled Package
  • javax.sound.midi Package
  • javax.sound.sampled.spi Package
  • javax.sound.midi.spi Package

Tutorials and Programmer's Guides

  • Java Sound Programmer's Guide - A conceptual description of the Java Sound API, with code examples.

API Enhancements

  • Enhancements in JDKTM 5.0

More Information

  • The Java Sound Home Page

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

Feedback 		Sun
Java Software


Sound Architecture Overview

Design Goals

The Java Sound API is a low-level API for effecting and controlling input and output of audio media. It provides explicit control over the capabilities commonly required for audio input and output in a framework that promotes extensibility and flexibility.

Because sound is so fundamental, Java Sound fulfills the needs of a wide range of customers. Potential application areas include:

  • Communication frameworks, such as conferencing and telephony
  • End-user content delivery systems, such as media players and music using streamed content
  • Interactive applications, such as games and Web sites that use dynamic content
  • Content creation and editing
  • Tools, toolkits, and utilities

Java Sound enables applications to extend audio support with specialized capabilities, and integrates well with architectures that provide higher-level interfaces and integration with other media types.

Java Sound provides the lowest level of audio support on the Java platform. It provides a high degree of control over audio-specific functionality. For example, it provides mechanisms for installing, accessing, and manipulating system resources such as digital audio and MIDI (Musical Instrument Digital Interface) devices. It does not include sophisticated sound editors and GUI tools; rather, it provides a set of capabilities upon which such applications can be built. It emphasizes low-level control beyond that commonly expected by the end user, who benefits from higher-level interfaces built on top of Java Sound.

Note: Throughout this document, the word "application" refers generically to Java applets as well as Java applications.

Packages

The Java Sound API includes support for both digital audio and MIDI data. These two major modules of functionality are provided in separate packages:

javax.sound.sampled
This package specifies interfaces for capture, mixing, and playback of digital (sampled) audio.

javax.sound.midi
This package provides interfaces for MIDI synthesis, sequencing, and event transport.

Two other packages permit service providers (as opposed to application developers) to create custom components that can be installed on the system:

javax.sound.sampled.spi
javax.sound.midi.spi

The next section of this document discusses the sampled-audio system, including an overview of the javax.sound.sampled API. The final section covers the MIDI system and the javax.sound.midi API.

Sampled Audio

The javax.sound.sampled package handles digital audio data, also referred to as sampled audio. ("Samples" refer to successive snapshots of a signal, which in the case of digital audio is a sound wave. For example, the audio recorded for storage on compact discs is sampled 44100 times per second. Typically, sampled audio comes from a sound recording, but the sound could instead be synthetically generated. The term "sampled audio" refers to the type of data, not its origin. Sampled audio can be thought of as the sound itself, whereas MIDI data can be thought of as a recipe for creating musical sound.)

Java Sound does not assume a specific audio hardware configuration; it is designed to allow different sorts of audio components to be installed on a system and accessed by the API. Java Sound supports common functionality such as input and output from a sound card (for example, for recording and playback of sound files) as well as mixing of multiple streams of audio. Here is one example of a typical audio architecture for which Java Sound might be used:

The logic flows from the input device to the software mixer and finaly to the output device. Each device has various input and output ports.

A Typical Audio Architecture

In this example, a device such as a sound card has various input and output ports, and mixing is provided in software. The MIDI synthesizer shown as one of the mixer’s audio inputs might also be a feature of the sound card, or it might be implemented in software. (The javax.sound.midi package, discussed later, supplies a Java interface for synthesizers.)

The major concepts used in the javax.sound.sampled package are described in the sections below.

Lines

A line is an element of the digital audio "pipeline," such as an audio input or output port, a mixer, or an audio data path into or out of a mixer. The audio data flowing through a line can be mono or multichannel (for example, stereo). Each type of line will be described shortly, but first some of their functional relationships will be illustrated, showing the flow of audio through the "pipeline." The following diagram shows different types of lines in a simple audio-output system:

The following context describes this graphic.

A Possible Configuration of Lines for Audio Output

In this example, an application has asked a mixer for one or more available clips and source data lines. A clip is a mixer input into which you can load audio data prior to playback; a source data line is a mixer input that accepts a real-time stream of audio data. The application preloads audio data from a sound file into the clips, and then pushes other audio data into the source data lines. The mixer reads data from these lines, each of which may have its own reverberation, gain, and pan controls, and uses the reverb settings to mix the "dry" audio signals with the reverberated ("wet") mix. The mixer delivers its final output to one or more output ports, such as a speaker, a headphone jack, and a line-out jack.

Although the various lines are depicted as separate rectangles in the diagram, they are all "owned" by the mixer, and can be considered integral parts of the mixer. The reverb, gain, and pan rectangles represent processing controls (rather than lines) that can be applied by the mixer to data flowing through the lines. (Note that this is just one example of a possible audio system that is supported by the API. Not all audio configurations will have all the features illustrated. An individual source data line might not support panning, a mixer might not implement reverb, and so on.)

A simple audio-input system might be similar:

The following context describes this graphic.

A Possible Configuration of Lines for Audio Input

Here, data flows in to the mixer from one or more input ports, commonly the microphone or the line-in jack. Gain and pan are applied, and the mixer delivers the captured data to an application via the mixer's target data line. A target data line is a mixer output, containing the mixture of the streamed input sounds. The simplest mixer has just one target data line, but some mixers can deliver captured data to multiple target data lines simultaneously.

The different types of line will now be examined more closely. Several types of line are defined by subinterfaces of the basic Line interface. The interface hierarchy is shown below.

See long description [D]

The Line Interface Hierarchy

The base interface, Line, describes the minimal functionality common to all lines:

    • Routing

      A line has an information object (an instance of Line.Info) that indicates what mixer (if any) sends its mixed audio data as output directly to the line, and what mixer (if any) gets audio data as input directly from the line. Subinterfaces of Line may have corresponding subclasses of Line.Info that provide other kinds of information specific to the particular types of line.

    • Controls

      A line can have various types of controls, such as gain, pan, and reverb controls. Usually, a line has no more than one control of a given type, but this is not a necessary limitation. Controls are discussed in more detail below.

    • Open or closed status

      Opening and closing a line affects its resource allocation. Successful opening of a line guarantees that resources have been allocated to the line. Opening a mixer that has audio input and/or output ports normally involves acquiring the native platform hardware resource (sound card) and initializing any required software components. Opening a line that is a data path in or out of the mixer might involve device initialization as well as allocation of limited resources from the mixer. In other words, a mixer has a finite number of lines, so at some point multiple applications (or the same application) might vie for usage of the mixer.

      Closing a line indicates that any resources used by the line may now be released. To free up resources, applications should close lines whenever they are not in use, and must close all opened lines when exiting.

      Mixers are assumed to be shared system resources, and can be opened and closed repeatedly. Other lines may or may not support re-opening once they have been closed. Mechanisms for opening lines vary with the different sub-types and are documented where they are defined.

    • Events

      A line generates events when it opens or closes. The events are instances of the LineEvent class. Two types of LineEvent are OPEN and CLOSE, but subinterfaces of Line can introduce other types of events.

      When a line generates an OPEN or CLOSE event, the event is sent to all objects that have registered to "listen" for events on that line. Such objects must implement the LineListener interface. An application can create these objects, register them to listen for line events, and react to the events as desired.

Ports are simple lines for input or output of audio to or from audio devices. The Port interface has an inner class, Port.Info, that specifies the type of port. Some common types are the microphone, line input, CD-ROM drive, speaker, headphone, and line output.

The Mixer interface represents a hardware or software device that has one or more input lines and one or more output lines. This definition means that a mixer need not actually mix data; it might have only a single input. The Mixer API is intended to encompass a variety of devices, but the typical case supports mixing.

The Mixer interface provides methods for obtaining a mixer's lines. These can include target data lines, from which an application can read captured audio data, source data lines, to which an application can write audio data for playback (rendering), and clips, in which an application can preload sound data for playback. The mixer can lock these resources. For example, if the mixer has only one target data line and it is already in use, an attempt by an application to obtain a target data line will cause an exception to be thrown.

You can query a mixer for lines of different types, by passing the appropriate type of Line.Info. You can also ask the mixer how many lines of a particular type it supports.

A mixer maintains textual information about its specific device type in an inner class called Mixer.Info. This information include the product's name, version, and vendor, along with a textual description.

Notice that the generic Line interface does not provide a means to start and stop playback or recording. For that you need a data line. The DataLine interface supplies the following additional media-related features beyond those of a Line:
    • Audio format

      Each data line has an audio format associated with its data stream. The format (an instance of AudioFormat) specifies the arrangement of the bytes in the audio stream. Some of the format's properties are the number of channels, the sample rate, the sample size, and the encoding technique. Common encoding techniques include linear pulse-code modulation (PCM), mu-law encoding, and a-law encoding.

    • Media position

      A data line can report its current position in the media, expressed in sample frames. This represents the number of sample frames captured by or rendered from the data line since it was opened.

    • Buffer size

      This is the size of the data line’s internal buffer in sample frames. For a source data line, the internal buffer is one to which data can be written, and for a target data line it’s one from which data can be read.

    • Level

      The data line's level represents the current linear amplitude of the audio signal, from 0 to 1.

    • Start and stop playback or capture

    • Pause and resume

      Pausing a data line causes it to cease data I/O activity (capture or playback) without discarding data or releasing resources. Resuming the line enables it to continue data I/O activity. Pausing a data line can result in an audible discontinuity (such as a click) in playback or recording. To avoid overfilling the capture buffer, an application that is recording audio should pause the target data line from which it reads audio whenever it is not prepared to read captured data continuously. Resuming a paused source data line will play back the next samples from its queue, unless the data line has been flushed.

    • Flush

      Flushing a data line discards unprocessed data from the queue and returns. In some cases, not all queued data can be discarded. For example, a mixer can flush data from the buffers in its source data lines, but any unplayed data already in its internal buffer (which contains the mixed output data) will still be played.

    • Drain

      Draining a data line blocks until all unprocessed data has been drained from the queue, and the data line's buffer has become empty. If you attempt to drain a data line whose buffer is still being filled (either by the application or by a mixer), the draining might not complete.

    • Active status

      A data line is considered active if it is engaged in active presentation or capture of audio data to or from a mixer.

    • Events

      START and STOP events are produced when active presentation or capture of data from or to the data line starts or stops.

An application can obtain a data line from a mixer. If the data line cannot be allocated because of resource constraints (for example, if the mixer supports only one target data line and it is already in use), an exception is thrown.

A TargetDataLine receives audio data from a mixer. Commonly, the mixer has captured audio data from a port such as a microphone; it might process or mix this captured audio before placing the data in the target data line's buffer. The TargetDataLine interface provides methods for reading the data from the target data line's buffer and for determining how much data is currently available for reading. If an application attempts to read more data than is available, the read method blocks until the requested amount of data is available. This applies even if the amount of data requested is greater than the line's buffer size. The read method returns if the line is closed, paused, or flushed.

Applications recording audio should read data from the target data line fast enough to avoid overflow of the buffer, which results in discontinuities in the captured data. If the buffer does overflow, the oldest queued data is discarded and replaced by new data.

A SourceDataLine receives audio data for playback. It provides methods for writing data to the source data line's buffer for playback, and for determining how much data the line is prepared to receive without blocking. If an application attempts to write more data than is available, the read method blocks until the requested amount of data can be written. This applies even if the amount of data requested is greater than the line's buffer size. The write method also returns if the line is closed, paused, or flushed.

Applications playing audio should write data to the source data line fast enough to avoid underflow (emptying) of the buffer, which may result in discontinuities in audio playback. If audio playback stops due to underflow, a STOP event is generated. A START event is generated when presentation resumes.

A Clip is a data line into which audio data can be loaded prior to playback. Because the data is pre-loaded rather than streamed, the clip’s duration is known before playback, and you can choose any starting position in the media. Clips can be looped, meaning that upon playback, all the data between two specified loop points will repeat a specified number of times, or indefinitely.

A GroupLine is a synchronized group of data lines. If a mixer supports group lines, you can specify which data lines should be treated as a group. Then you can start, stop, or close all those data lines by sending a single message to the group, instead of having to control each line individually.

Controls

Data lines and ports often have a set of controls that affect the audio signal passing through the line. The way in which the signal is affected depends on the type of control. The Java Sound API defines the following subclasses of Control:

  • GainControl

    This control allows the signal's volume to be boosted or cut a specified number of decibels. A fade can be applied so that the volume increases or decreases gradually instead of instantly. The gain control includes a mute function to temporarily silence the line without altering its gain setting. A GainControl object can be queried for its resolution and for the minimum and maximum gain values it permits. The resolution is expressed as the number of increments over which the range of possible values is distributed.

    The types of gain control defined by the API include an overall gain control as well as gain controls for auxiliary send and return. The send and return typically control a line's contribution to a mixed and reverberated signal.

  • PanControl

    A pan control affects the sound's right-left positioning. For a stereo audio signal, the pan control affects the balance between the volumes of the left and right channels. An application can set the pan position and can query the control for its resolution. The resolution is expressed as the number of incremental values from "hard left" to "hard right."

  • ReverbControl

    This control gives access to any number of reverberation settings. Each setting might emulate a different time of room (small club, concert hall, cavern, etc.). The parameters used in constructing each setting consist of the delay time and intensity of early reflections, the delay time and intensity of late reflections, and an overall decay time.

  • SampleRateControl

    This control affects the rate of playback. Altering the audio sample rate changes the sound's pitch. As with GainControl, the change can be made gradually instead of immediately, and the control can be queried for its resolution and its minimum and maximum possible values.

Programmatically, you obtain a particular control object from a line through a reference to the control’s class. You can also obtain an array of all the controls for that line.

AudioSystem

The AudioSystem class serves as an application's entry point for accessing the installed sampled-audio resources. You can query the AudioSystem to learn what sorts of audio components have been installed, and then you can obtain access to them. For example, an application might start out by asking the AudioSystem class whether there is a mixer that has a certain configuration, such as one of the input or output configurations illustrated earlier in the discussion of lines. From the mixer, the application would then obtain data lines, and so on.

Here are some of the resources an application can obtain from the AudioSystem:

  • Mixers

    A mixer can be obtained by passing a specific Mixer.Info object. You can learn what mixers are available by invoking the getMixerInfo method, which returns an array of Mixer.Info objects.

  • Lines

    An application can get a target data line or source data line directly from the AudioSystem, without dealing explicitly with mixers.

  • Format conversions

    An application can use format conversions to translate audio data from one format to another. (See the discussion of AudioFormat above.) Format conversions are often used to compress and decompress audio data. An application can query the AudioSystem to learn what translations are supported. It can then pass the AudioSystem a stream of audio data and get back a translated stream in a particular format.

  • Files and streams

    An audio stream is an input stream with a specified audio data format (AudioFormat) and data length. The AudioInputStream class represents such a stream, from which you can read bytes. Some audio input streams permit you to remember positions in the stream and skip around in it. The AudioSystem class provides methods for translating between audio files and audio streams. The AudioSystem can also report the file format of a sound file and can write files in the different formats. A file format is represented by the AudioFileFormat class. An AudioFileFormat includes an AudioFormat, the file's length, and its type (WAV, AIFF, AU, etc.).

System configuration (SPI classes)

Service provider interfaces for the sampled audio system are defined in the javax.sound.sampled.spi package. Service providers can extend the classes defined here so that their own audio devices, sound file parsers and writers, and format converters can be installed and made available by a Java Sound implementation.

MIDI

Interfaces describing MIDI event transport, synthesis, and sequencing are defined in the javax.sound.midi package. The major concepts used in the package are described in the sections below.

Functional Overview

The diagram below illustrates the functional relationships between the major components in a typical Java Sound MIDI configuration. (Java Sound permits a variety of devices to be installed and interconnected. The system shown here is just one possible scenario.) The flow of data between components is indicated by arrows. The data can be in a standard file format, or (as indicated by the key in the lower right corner of the diagram), it can be audio, raw MIDI bytes, or Java Sound's MidiEvent objects.

The following context describes this graphic

A Typical MIDI Configuration

In this example, the application prepares a musical performance by loading a musical score that is stored as a Standard MIDI File on a disk (lower left corner of the diagram). Standard MIDI files contain tracks, each of which is a list of time-tagged MIDI events. This MIDI file is read into a Sequence object, whose data structure reflects the file. A Sequence contains a set of Track objects, each of which contains a set of MidiEvent objects. The Sequence is then "performed" by a Sequencer. A Sequencer performs its music by sending MidiEvents to some other device, such as an internal or external synthesizer.

As illustrated, MidiEvents must be translated into raw (non-time-tagged) MIDI before being sent through a MIDI output port to an external synthesizer. This conversion is accomplished by a a MIDI-output device called a StreamGenerator. Similarly, raw MIDI data coming into the computer from an external MIDI source is translated into MidiEvents by a StreamParser.

The internal synthesizer (the rectangle marked "Synthesizer" in the diagram) accepts MidiEvents directly from the Sequencer or StreamParser. It parses each event and usually dispatches a corresponding command (such as noteOn) to one of its MidiChannel objects, according to the MIDI channel number specified in the event. (The MIDI Specification calls for 16 MIDI channels, so a Synthesizer typically has 16 MidiChannel objects.)

The MidiChannel uses the note information in these messages to synthesize music. For example, a noteOn message specifies the note's pitch and "velocity" (volume). However, the note information is insufficient; the synthesizer also requires precise instructions on how to create the audio signal for each note. These instructions are represented by an Instrument. Each Instrument typically emulates a different real-world musical instrument or sound effect. The Instruments might come as presets with the synthesizer, or they might be loaded from soundbank files. In the synthesizer, the Instruments are arranged by bank number (the rows in the diagram) and program number (the columns). An Instrument can make use of stored digital audio, included as Sample objects in the soundbank. For example, to play the sound of a trumpet playing a 5-second-long note, the synthesizer might loop (cycle) through a half-second snippet of a recording of a trumpet.

Now that the components have been introduced from a functional perspective, we will take a brief look at the API from a programmatic perspective.

MidiEvent

A MidiEvent object specifies the type, data length, and status byte of the raw MIDI message for which it serves as a wrapper. In addition, it provides a tick value that is used by devices involved in MIDI timing, such as sequencers.

There are three categories of events, each represented by a MidiEvent subclass:

  • ShortEvents are the most common and have at most two data bytes following the status byte.
  • SysexEvents contain system-exclusive MIDI messages. They may have many bytes, and generally contain manufacturer-specific instructions.
  • MetaEvents occur in MIDI files, but not in raw MIDI data streams. Meta events contain data, such as lyrics or tempo settings, that might be useful to sequencers but are usually meaningless for synthesizers.

MidiDevice

The base interface for devices is MidiDevice. All devices provide methods for listing the set of MIDI modes that they support, and for querying and setting the current mode. (The mode is a combination of MIDI's Omni mode and Mono/Poly mode.) Devices can be opened and closed, and they provide descriptions of themselves through a MidiDevice.Info object.

The following diagram illustrates the MidiDevice interface hierarchy. Also depicted are two classes, connected by dashed lines to the MidiDevice interfaces they implement.

The following context describes this graphic

MidiDevice Hierarchy

Devices are generally either transmitters or receivers of MidiEvents. The Transmitter subinterface of MidiDevice includes methods for setting and querying the receivers to which the transmitter is sending MidiEvents. From the perspective of a transmitter, these receivers fall into two categories: MIDI Out and MIDI Thru. The transmitter sends events that it generates itself to its MIDI Out receivers. If the transmitter is itself also a receiver, it passes along events that it has received from elsewhere to its MIDI Thru receivers. The Receiver subinterface of MidiDevice consists of a single method for receiving MidiEvents. Typically, this method is invoked by a Transmitter.

Java Sound includes concrete classes for converting between MidiEvent objects and the raw byte stream used in MIDI wire protocol. A StreamGenerator is a Receiver that accepts MidiEvent objects from a Transmitter and writes out a raw MIDI byte stream. Similarly, a StreamParser is a Transmitter that accepts a raw MIDI byte stream and writes the corresponding MidiEvent objects to its Receiver.

Synthesis

A Synthesizer is a type of MidiDevice that generates sound. The Synthesizer interface extends both Receiver and Transmitter. It provides methods for manipulating soundbanks and instruments. In addition, it provides access to a set of MIDI channels through which sound is actually produced. A Synthesizer receives MidiEvents and invokes corresponding MidiChannel messages.

MidiChannels have methods representing the common MIDI voice messages such as "note on" and "control change." They also permit queries of the channel's current state.

Sequencing

Like Synthesizer, the Sequencer interface extends both Transmitter and Receiver (and therefore MidiDevice). Sequencer adds methods for basic MIDI sequencing operations. A sequencer can load and play back a sequence, query and set the tempo, and control the master and slave sync modes. An application can register to be notified when the sequencer processes MetaEvents and controller events. (A controller event occurs when a MIDI controller, such as a pitch-bend wheel or a data slider, changes its value. These events are not MidiEvents, but are created when the Sequencer encounters certain ShortEvents in the Sequence.)

The Sequence object represents a MIDI sequence as one or more tracks and associated timing information. A track contains a list of time-stamped MIDI events. Sequences can be read from MIDI files, or created from scratch and edited by adding Tracks to the Sequence (or removing them). Similarly, MidiEvents can be added to or removed from the Tracks.

A track contains a list of time-stamped MIDI events. Sequences can be read from MIDI files, or created from scratch and edited by adding Tracks to the Sequence (or removing them). Similarly, MidiEvents can be added to or removed from the Tracks.

It is not necessary to load a MIDI file into a Sequence object before playing the file. The setSequence(java.io.InputStream) method of Sequencer lets you read a MIDI file directly into a Sequencer, without creating a Sequence object first.

MidiSystem

MidiSystem acts as an application's entry point to the MIDI music system. It provides information about, and access to, the set of installed devices, including transmitters, receivers, synthesizers, and sequencers.

The MidiSystem class provides methods for reading MIDI files to create Sequence objects, and for writing Sequences to MIDI files. A MIDI Type 0 file contains only one track, while a Type 1 file may contain any number. MidiSystem also provides methods to create Soundbank objects by parsing soundbank files.

System configuration (SPI interfaces)

Configuration of the MIDI system is handled in the javax.sound.midi.spi package. The abstract classes in this package allow service providers to supply and install their own MIDI devices, MIDI file readers and writers, and soundbank file readers.

Copyright © 1999 Sun Microsystems, Inc. All Rights Reserved.

Please send comments to: mailto:javasound-comments@javamedia.eng.sun.com 		Sun
Java Software


Chapter 3: Accessing Audio System Resources

Notes

  1. The Port class was not available on all platforms before JDK 5.0.
  2. With version 5.0, the sound.properties file can be used to set default devices for Clip, Port, SourceDataLine, and TargetDataLine. For details, see the AudioSystem class in the API; for examples, see Appendix 2: sound.properties File in this guide.
  3. While the method for obtaining lines, as outlined below in Getting a Line of a Desired Type, is still valid, for 5.0 there are convenience methods for Clip, SourceDataLine, and TargetDataLine: AudioSystem.getClip(), AudioSystem.getSourceDataLine(), and AudioSystem.getTargetDataLine(). See the AudioSystem for details.

The JavaTM Sound API takes a flexible approach to system configuration. Different sorts of audio devices (mixers) can be installed on a computer. The API makes few assumptions about what devices have been installed and what their capabilities are. Instead, it provides ways for the system to report about the available audio components, and ways for your program to access them.

This section shows how your program can learn what sampled-audio resources have been installed on the computer, and how it can gain access to the available resources. Among other things, the resources include mixers and the various types of lines owned by the mixers.

The AudioSystem Class

The AudioSystem class acts as a clearinghouse for audio components, including built-in services and separately installed services from third-party providers. AudioSystem serves as an application program's entry point for accessing these installed sampled-audio resources. You can query the AudioSystem to learn what sorts of resources have been installed, and then you can obtain access to them. For example, an application program might start out by asking the AudioSystem class whether there is a mixer that has a certain configuration, such as one of the input or output configurations illustrated earlier in the discussion of lines. From the mixer, the program would then obtain data lines, and so on.

Here are some of the resources an application program can obtain from the AudioSystem:

  • Mixers
    A system typically has multiple mixers installed. There is usually at least one for audio input and one for audio output. There might also be mixers that don't have I/O ports but instead accept audio from an application program and deliver the mixed audio back to the program. The AudioSystem class provides a list of all of the installed mixers.
  • Lines
    Even though every line is associated with a mixer, an application program can get a line directly from the AudioSystem, without dealing explicitly with mixers.
  • Format conversions
    An application program can use format conversions to translate audio data from one format to another. Conversions are described in Chapter 7, "Using Files and Format Converters."
  • Files and streams
    The AudioSystem class provides methods for translating between audio files and audio streams. It can also report the file format of a sound file and can write files in different formats. These facilities are discussed in Chapter 7, "Using Files and Format Converters."

Information Objects

Several classes in the Java Sound API provide useful information about associated interfaces. For example, Mixer.Info provides details about an installed mixer, such as the mixer's vendor, name, description, and version. Line.Info obtains the class of a specific line. Subclasses of Line.Info include Port.Info and DataLine.Info, which obtain details relevant to a specific port and data line, respectively. Each of these classes is described further in the appropriate section below. It's important not to confuse the Info object with the mixer or line object that it describes.

Getting a Mixer

Usually, one of the first things a program that uses the Java Sound API needs to do is to obtain a mixer, or at least one line of a mixer, so that you can get sound into or out of the computer. Your program might need a specific kind of mixer, or you might want to display a list of all the available mixers so that the user can select one. In either case, you need to learn what kinds of mixers are installed. AudioSystem provides the following method:

    static Mixer.Info[] getMixerInfo()
Each Mixer.Info object returned by this method identifies one type of mixer that is installed. (Usually a system has at most one mixer of a given type. If there happens to be more than one of a given type, the returned array still only has one Mixer.Info for that type.) An application program can iterate over the Mixer.Info objects to find an appropriate one, according to its needs. The Mixer.Info includes the following strings to identify the kind of mixer:

  • Name
  • Version
  • Vendor
  • Description

These are arbitrary strings, so an application program that needs a specific mixer must know what to expect and what to compare the strings to. The company that provides the mixer should include this information in its documentation. Alternatively, and perhaps more typically, the application program will display all the Mixer.Info objects' strings to the user and let the user choose the corresponding mixer.

Once an appropriate mixer is found, the application program invokes the following AudioSystem method to obtain the desired mixer:

    static Mixer getMixer(Mixer.Info info)
What if your program needs a mixer that has certain capabilities, but it doesn't need a specific mixer made by a specific vendor? And what if you can't depend on the user's knowing which mixer should be chosen? In that case, the information in the Mixer.Info objects won't be of much use. Instead, you can iterate over all the Mixer.Info objects returned by getMixerInfo, get a mixer for each by invoking getMixer, and query each mixer for its capabilities. For example, you might need a mixer that can write its mixed audio data to a certain number of target data lines simultaneously. In that case, you would query each mixer using this Mixer method:

int getMaxLines(Line.Info info)

Here, the Line.Info would specify a TargetDataLine. The Line.Info class is discussed in the next section.

Getting a Line of a Desired Type

There are two ways to get a line:

  • Directly from the AudioSystem object
  • From a mixer that you have already obtained from the AudioSystem object (see "Getting a Mixer," in this chapter)

Getting a Line Directly from the AudioSystem

Let's assume you haven't obtained a mixer, and your program is a simple one that really only needs a certain kind of line; the details of the mixer don't matter to you. You can use the AudioSystem method:

    static Line getLine(Line.Info info)
which is analogous to the getMixer method discussed above. Unlike Mixer.Info, the Line.Info used as an argument doesn't store textual information to specify the desired line. Instead, it stores information about the class of line desired.

Line.Info is an abstract class, so you use one of its subclasses (Port.Info or DataLine.Info) to obtain a line. The following code excerpt uses the DataLine.Info subclass to obtain and open a target data line:

TargetDataLine line;
DataLine.Info info = new DataLine.Info(TargetDataLine.class,
    format); // format is an AudioFormat object
if (!AudioSystem.isLineSupported(info)) {
    // Handle the error.
    }
    // Obtain and open the line.
try {
    line = (TargetDataLine) AudioSystem.getLine(info);
    line.open(format);
} catch (LineUnavailableException ex) {
       // Handle the error.
    //...
}
This code obtains a TargetDataLine object without specifying any attributes other than its class and its audio format. You can use analogous code to obtain other kinds of lines. For a SourceDataLine or a Clip, just substitute that class for TargetDataLine as the class of the line variable, and also in the first argument to the DataLine.Info constructor.

For a Port, you can use static instances of Port.Info, in code like the following:

if (AudioSystem.isLineSupported(Port.Info.MICROPHONE)) {
    try {
        line = (Port) AudioSystem.getLine(
            Port.Info.MICROPHONE);
    }
}
Note the use of the method isLineSupported to see whether the mixer even has a line of the desired type.

Recall that a source line is an input to a mixer—namely, a Port object if the mixer represents an audio-input device, and a SourceDataLine or Clip object if the mixer represents an audio-output device. Similarly, a target line is an output of the mixer: a Port object for an audio-output mixer, and a TargetDataLine object for an audio-input mixer. What if a mixer doesn't connect to any external hardware device at all? For example, consider an internal or software-only mixer that gets audio from an application program and delivers its mixed audio back to the program. This kind of mixer has SourceDataLine or Clip objects for its input lines and TargetDataLine objects for its output lines.

You can also use the following AudioSystem methods to learn more about source and target lines of a specified type that are supported by any installed mixer:

    static Line.Info[] getSourceLineInfo(Line.Info info)
    static Line.Info[] getTargetLineInfo(Line.Info info)
Note that the array returned by each of these methods indicates unique types of lines, not necessarily all the lines. For example, if two of a mixer's lines, or two lines of different mixers, have identical Line.Info objects, the two lines will represented by only one Line.Info in the returned array.

Getting a Line from a Mixer

The Mixer interface includes variations on the AudioSystem access methods for source and target lines, described above. These Mixer methods include ones that take Line.Info arguments, just as AudioSystem's methods do. However, Mixer also includes these variants, which take no arguments:

    Line.Info[] getSourceLineInfo()
    Line.Info[] getTargetLineInfo()
These methods return arrays of all the Line.Info objects for the particular mixer. Once you've obtained the arrays, you can iterate over them, calling Mixer's getLine method to obtain each line, followed by Line's open method to reserve use of each line for your program.

Selecting Input and Output Ports

The previous section, regarding how to obtain a line of a desired type, applies to ports as well as other types of lines. You can obtain all of the source (i.e., input) and target (i.e, output) ports by passing a Port.Info object to the AudioSystem (or Mixer) methods getSourceLineInfo and getTargetLineInfo that take a Line.Info argument. You then iterate over the returned array of objects and invoke Mixer's getLine method to get each port.

You can then open each Port by invoking Line's open method. Opening a port means you turn it on—that is, you allow sound to come in or out the port. Similarly, you can close ports that you don't want sound to travel through, because some ports might already be open before you even obtain them. Some platforms leave all ports on by default; or a user or system administrator might have selected certain ports to be on or off, using another application program or operating-system software.

Warning: If you want to select a certain port and make sure that the sound is actually going in or out the port, you can open the port as described. However, this can be considered user-hostile behavior! For example, a user might have the speaker port turned off so as not to disturb her co-workers. She would be rather upset if your program suddenly overrode her wishes and started blaring music. As another example, a user might want to be assured that his computer's microphone is never turned on without his knowledge, to avoid eavesdropping. In general, it is recommended not to open or close ports unless your program is responding to the user's intentions, as expressed through the user interface. Instead, respect the settings that the user or the operating system has already selected.

It isn't necessary to open or close a port before the mixer it's attached to will function correctly. For example, you can start playing back sound into an audio-output mixer, even though all its output ports are closed. The data still flows into the mixer; the playback isn't blocked. The user just won't hear anything. As soon as the user opens an output port, the sound will be audible through that port, starting at whatever point in the media the playback has already reached.

Also, you don't need to access the ports to learn whether the mixer has certain ports. To learn whether a mixer is actually an audio-output mixer, for example, you can invoke getTargetLineInfo to see whether it has output ports. There's no reason to access the ports themselves unless you want to change their settings (such as their open-or-closed state, or the settings of any controls they might have).

Permission to Use Audio Resources

The Java Sound API includes an AudioPermission class that indicates what kinds of access an applet (or an application running with a security manager) can have to the sampled-audio system. Permission to record sound is controlled separately. This permission should be granted with care, to help prevent security risks such as unauthorized eavesdropping. By default, applets and applications are granted permissions as follows:

  • An applet running with the applet security manager can play, but not record, audio.
  • An application running with no security manager can both play and record audio.
  • An application running with the default security manager can play, but not record, audio.

In general, applets are run under the scrutiny of a security manager and aren't permitted to record sound. Applications, on the other hand, don't automatically install a security manager, and are able to record sound. (However, if the default security manager is invoked explicitly for an application, the application isn't permitted to record sound.)

Both applets and applications can record sound even when running with a security manager if they have been granted explicit permission to do so.

If your program doesn't have permission to record (or play) sound, an exception will be thrown when it attempts to open a line. There is nothing you can do about this in your program, other than to catch the exception and report the problem to the user, because permissions can't be changed through the API. (If they could, they would be pointless, because nothing would be secure!) Generally, permissions are set in one or more policy configuration files, which a user or system administrator can edit using a text editor or the Policy Tool program.

For more information on security and permissions, see "Security Architecture" and "Policy Permissions" in the Security guide and the specialized trail on security in the Java Tutorial.


Chapter 9: Accessing MIDI System Resources

Note

With version 5.0, the sound.properties file can be used to set default devices for Sequencer, Synthesizer, Transmitter, and Receiver. For details, see the MidiSystem class in the API; for examples, see Appendix 2: sound.properties File in this guide.

The JavaTM Sound API offers a flexible model for MIDI system configuration, just as it does for configuration of the sampled-audio system. An implementation of the Java Sound API can itself provide different sorts of MIDI devices, and additional ones can be supplied by service providers and installed by users. You can write your program in such a way that it makes few assumptions about which specific MIDI devices are installed on the computer. Instead, the program can take advantage of the MIDI system's defaults, or it can allow the user to select from whatever devices happen to be available.

This section shows how your program can learn what MIDI resources have been installed, and how to get access to the desired ones. After you've accessed and opened the devices, you can connect them to each other, as discussed in the next chapter, "Transmitting and Receiving MIDI Messages."

The MidiSystem Class

The role of the MidiSystem class in the Java Sound API's MIDI package is directly analogous to the role of AudioSystem in the sampled-audio package. MidiSystem acts as a clearinghouse for accessing the installed MIDI resources.

You can query the MidiSystem to learn what sorts of devices are installed, and then you can iterate over the available devices and obtain access to the desired ones. For example, an application program might start out by asking the MidiSystem what synthesizers are available, and then display a list of them, from which the user can select one. A simpler application program might just use the system's default synthesizer.

The MidiSystem class also provides methods for translating between MIDI files and Sequences. It can report the file format of a MIDI file and can write files of different types.

An application program can obtain the following resources from the MidiSystem:

  • Sequencers
  • Synthesizers
  • Transmitters (such as those associated with MIDI input ports)
  • Receivers (such as those associated with MIDI output ports)
  • Data from standard MIDI files
  • Data from soundbank files

This chapter focuses on the first four of these types of resource. The MidiSystem class's file-handling facilities are discussed in Chapter 11, "Playing, Recording, and Editing MIDI Sequences," and Chapter 12, "Synthesizing Sound." To understand how the MIDI system itself gets access to all these resources, see Part III of this guide, "Service Provider Interfaces."

Obtaining Default Devices

A typical MIDI application program that uses the Java Sound API begins by obtaining the devices it needs, which can consist of one or more sequencers, synthesizers, input ports, or output ports.

There is a default synthesizer device, a default sequencer device, a default transmitting device, and a default receiving device. The latter two devices normally represent the MIDI input and output ports, respectively, if there are any available on the system. (It's easy to get confused about the directionality here. Think of the ports' transmission or reception in relation to the software, not in relation to any external physical devices connected to the physical ports. A MIDI input port transmits data from an external device to a Java Sound API Receiver, and likewise a MIDI output port receives data from a software object and relays the data to an external device.)

A simple application program might just use the default instead of exploring all the installed devices. The MidiSystem class includes the following methods for retrieving default resources:

    static Sequencer getSequencer()
    static Synthesizer getSynthesizer()
    static Receiver getReceiver()
    static Transmitter getTransmitter()

The first two of these methods obtain the system's default sequencing and synthesis resources, which either represent physical devices or are implemented wholly in software. The getReceiver method obtains a Receiver object that takes MIDI messages sent to it and relays them to the default receiving device. Similarly, the getTransmitter method obtains a Transmitter object that can send MIDI messages to some receiver on behalf of the default transmitting device.

Learning What Devices Are Installed

Instead of using the default devices, a more thorough approach is to select the desired devices from the full set of devices that are installed on the system. An application program can select the desired devices programmatically, or it can display a list of available devices and let the user select which ones to use. The MidiSystem class provides a method for learning which devices are installed, and a corresponding method to obtain a device of a given type.

Here is the method for learning about the installed devices:

    static MidiDevice.Info[] getMidiDeviceInfo()

As you can see, it returns an array of information objects. Each of these returned MidiDevice.Info objects identifies one type of sequencer, synthesizer, port, or other device that is installed. (Usually a system has at most one instance of a given type. For example, a given model of synthesizer from a certain vendor will be installed only once. ) The MidiDevice.Info includes the following strings to describe the device:

  • Name
  • Version number
  • Vendor (the company that created the device)
  • A description of the device

You can display these strings in your user interface to let the user select from the list of devices.

However, to use the strings programmatically to select a device (as opposed to displaying the strings to the user), you need to know in advance what they might be. The company that provides each device should include this information in its documentation. An application program that requires or prefers a particular device can use this information to locate that device. This approach has the drawback of limiting the program to device implementations that it knows about in advance.

Another, more general, approach is to go ahead and iterate over the MidiDevice.Info objects, obtaining each corresponding device, and determining programmatically whether it's suitable to use (or at least suitable to include in a list from which the user can choose). The next section describes how to do this.

Obtaining a Desired Device

Once an appropriate device's info object is found, the application program invokes the following MidiSystem method to obtain the corresponding device itself:

    static MidiDevice getMidiDevice(MidiDevice.Info info)

You can use this method if you've already found the info object describing the device you need. However, if you can't interpret the info objects returned by getMidiDeviceInfo to determine which device you need, and if you don't want to display information about all the devices to the user, you might be able to do the following instead: Iterate over all the MidiDevice.Info objects returned by getMidiDeviceInfo, get the corresponding devices using the method above, and test each device to see whether it's suitable. In other words, you can query each device for its class and its capabilities before including it in the list that you display to the user, or as a way to decide upon a device programmatically without involving the user. For example, if your program needs a synthesizer, you can obtain each of the installed devices, see which are instances of classes that implement the Synthesizer interface, and then display them in a list from which the user can choose one, as follows:

// Obtain information about all the installed synthesizers.
Vector synthInfos;
MidiDevice device;
MidiDevice.Info[] infos = MidiSystem.getMidiDeviceInfo();
for (int i = 0; i < infos.length; i++) {
    try {
        device = MidiSystem.getMidiDevice(infos[i]);
    } catch (MidiUnavailableException e) {
          // Handle or throw exception...
    }
    if (device instanceof Synthesizer) {
        synthInfos.add(infos[i]);
    }
}
// Now, display strings from synthInfos list in GUI.

As another example, you might choose a device programmatically, without involving the user. Let's suppose you want to obtain the synthesizer that can play the most notes simultaneously. You iterate over all the MidiDevice.Info objects, as above, but after determining that a device is a synthesizer, you query its capabilities by invoking the getMaxPolyphony method of Synthesizer. You reserve the synthesizer that has the greatest polyphony, as described in the next section. Even though you're not asking the user to choose a synthesizer, you might still display strings from the chosen MidiDevice.Info object, just for the user's information.

Opening Devices

The previous section showed how to get an installed device. However, a device might be installed but unavailable. For example, another application program might have exclusive use of it. To actually reserve a device for your program, you need to use the MidiDevice method open:

if (!(device.isOpen())) {
    try {
      device.open();
  } catch (MidiUnavailableException e) {
          // Handle or throw exception...
  }
}

Once you've accessed a device and reserved it by opening it, you'll probably want to connect it to one or more other devices to let MIDI data flow between them. This procedure is described in Chapter 10, "Transmitting and Receiving MIDI Messages."

When done with a device, you release it for other programs' use by invoking the close method of MidiDevice.


AudioSystem.java

Appendix 1: Code Overview: AudioSystem.java

For the benefit of service providers and API implementers, a brief overview of the Java Sound source code is provided.

javax.sound.sampled.AudioSystem is the entry point to JavaSound for obtaining resources; i.e., mixers, lines, etc. And each method of AudioSystem involves getting the providers of some service—MixerProvider[], FormatConversionProvider[], AudioFileReader[], or AudioFileWriter[]. Then the method goes on to obtain some specific information or perform some task. There is much similarity in how these methods work. Let us take a look at how getMixerInfo() works.

The following is a sequence diagram of getMixerInfo() in AudioSystem.java:

getMixerInfo() in AudioSystem first calls getMixerProviders(), a private static method of AudioSystem. The first thing that getMixerProviders() does is attempt to load sun.misc.Service. If an exception is thrown, it means that a pre-1.3 JRE is in use and there is no service provider lookup mechanism present. If an exception is thrown, then sun.media.sound.DefaultServices is used to obtain service providers (not depicted in above diagram). If the 1.3 mechanims is present, then getJDK13Serives() is called (shown above) with "javax.sound.sampled.spi.MixerProvider" as the argument.

getJDK13Services() is another private static method of AudioSystem. It attempts to the load the class for "com.sun.media.sound.JDK13Services", and if it succeeds it set Class jdk13Services equal to it. A bit of trickery is then performed by using Class.getMethod() to get the getProviders() method of jdk13Services, which is returned as object Method m. The method is then invoked, which has the effect of invoking getProviders("javax.sound.sampled.spi.MixerProvider") on JDK13Services. This in turn uses the providers() method of sun.misc.Service to return a vector of mixer providers, MixerProvider[]. The getMixerInfo() method of MixerProvider is then called on each element of the vector to return info (Mixer.info) for all mixers of all mixer providers.

Other services are handled in a similar way. For instance, getTargetEncodings() calls getFormatConversionProviders(), getAudioFileFormat() calls getAudioFileReaders(), etc., which are similarly structured to getMixerProviders().


Chapter 5: Capturing Audio

Capturing refers to the process of obtaining a signal from outside the computer. A common application of audio capture is recording, such as recording the microphone input to a sound file. However, capturing isn't synonymous with recording, because recording implies that the application always saves the sound data that's coming in. An application that captures audio doesn't necessarily store the audio. Instead it might do something with the data as it's coming in—such as transcribe speech into text—but then discard each buffer of audio as soon as it's finished with that buffer.

As discussed in Chapter 2, "Overview of the Sampled Package," a typical audio-input system in an implementation of the JavaTM Sound API consists of:

  1. An input port, such as a microphone port or a line-in port, which feeds its incoming audio data into:
  2. A mixer, which places the input data in:
  3. One or more target data lines, from which an application can retrieve the data.

    Commonly, only one input port can be open at a time, but an audio-input mixer that mixes audio from multiple ports is also possible. Another scenario consists of a mixer that has no ports but instead gets its audio input over a network.

    The TargetDataLine interface was introduced briefly under "The Line Interface Hierarchy" in Chapter 2, "Overview of the Sampled Package." TargetDataLine is directly analogous to the SourceDataLine interface, which was discussed extensively in Chapter 4, "Playing Back Audio." Recall that the SourceDataLine interface consists of:

  • A write method to send audio to the mixer
  • An available method to determine how much data can be written to the buffer without blocking

Similarly, TargetDataLine consists of:

  • A read method to get audio from the mixer
  • An available method to determine how much data can be read from the buffer without blocking

Setting Up a TargetDataLine

The process of obtaining a target data line was described in Chapter 3, "Accessing Audio System Resources," but we repeat it here for convenience:

TargetDataLine line;
DataLine.Info info = new DataLine.Info(TargetDataLine.class,

    format); // format is an AudioFormat object
if (!AudioSystem.isLineSupported(info)) {
    // Handle the error ...
}
// Obtain and open the line.
try {

    line = (TargetDataLine) AudioSystem.getLine(info);
    line.open(format);
} catch (LineUnavailableException ex) {
    // Handle the error ...
}
You could instead invoke Mixer's getLine method, rather than AudioSystem's.

As shown in this example, once you've obtained a target data line, you reserve it for your application's use by invoking the DataLine method open, exactly as was described in the case of a source data line in Chapter 4, "Playing Back Audio." The single-parameter version of the open method causes the line's buffer to have the default size. You can instead set the buffer size according to your application's needs by invoking the two-parameter version:

    void open(AudioFormat format, int bufferSize)
When choosing a buffer size, keep in mind the tradeoff between the delays incurred by long buffers, on the one hand, and the risk of discontinuities in the audio if the buffers are so short that you can't retrieve the data fast enough, on the other hand. When capturing audio, you risk data overflow if you don't pull data from the filled buffers fast enough. If overflow occurs, some of the captured data will be discarded, which will probably cause audible clicks and skips in the sound. This is the opposite situation from playback, where you risk data underflow, which can result in gaps in the sound. (See Chapter 4, "Playing Back Audio," for more on choosing buffer sizes.)

Reading the Data from the TargetDataLine

Once the line is open, it is ready to start capturing data, but it isn't active yet. To actually commence the audio capture, use the DataLine method start. This begins delivering input audio data to the line's buffer for your application to read. Your application should invoke start only when it's ready to begin reading from the line; otherwise a lot of processing is wasted on filling the capture buffer, only to have it overflow (that is, discard data).

To start retrieving data from the buffer, invoke TargetDataLine's read method:

int read(byte[] b, int offset, int length)
This method attempts to read length bytes of data into the array b, starting at the byte position offset in the array. The method returns the number of bytes actually read.

As with SourceDataLine's write method, you can request more data than actually fits in the buffer, because the method blocks until the requested amount of data has been delivered, even if you request many buffers' worth of data.

To avoid having your application hang during recording, you can invoke the read method within a loop, until you've retrieved all the audio input, as in this example:

// Assume that the TargetDataLine, line, has already
// been obtained and opened.
ByteArrayOutputStream out  = new ByteArrayOutputStream();
int numBytesRead;
byte[] data = new byte[line.getBufferSize() / 5];

// Begin audio capture.
line.start();

// Here, stopped is a global boolean set by another thread.
while (!stopped) {
   // Read the next chunk of data from the TargetDataLine.
   numBytesRead =  line.read(data, 0, data.length);
   // Save this chunk of data.
   out.write(data, 0, numBytesRead);
}
Notice that in this example, the size of the byte array into which the data is read is set to be one-fifth the size of the line's buffer. If you instead make it as big as the line's buffer and try to read the entire buffer, you need to be very exact in your timing, because data will be dumped if the mixer needs to deliver data to the line while you are reading from it. By using some fraction of the line's buffer size, as shown here, your application will be more successful in sharing access to the line's buffer with the mixer.

The read method of TargetDataLine takes three arguments: a byte array, an offset into the array, and the number of bytes of input data that you would like to read. In this example, the third argument is simply the length of your byte array. The read method returns the number of bytes that were actually read into your array.

Typically, you read data from the line in a loop, as in this example. Within the while loop, each chunk of retrieved data is processed in whatever way is appropriate for the application—here, it's written to a ByteArrayOutputStream. Not shown here is the use of a separate thread to set the boolean stopped, which terminates the loop. This boolean's value might be set to true when the user clicks a Stop button, and also when a listener receives a CLOSE or STOP event from the line. The listener is necessary for CLOSE events and recommended for STOP events. Otherwise, if the line gets stopped somehow without stopped being set to true, the while loop will capture zero bytes on each iteration, running fast and wasting CPU cycles. A more thorough code example would show the loop being re-entered if capture becomes active again.

As with a source data line, it's possible to drain or flush a target data line. For example, if you're recording the input to a file, you'll probably want to invoke the drain method when the user clicks a Stop button. The drain method will cause the mixer's remaining data to get delivered to the target data line's buffer. If you don't drain the data, the captured sound might seem to be truncated prematurely at the end.

There might be some cases where you instead want to flush the data. In any case, if you neither flush nor drain the data, it will be left in the mixer. This means that when capture recommences, there will be some leftover sound at the beginning of the new recording, which might be undesirable. It can be useful, then, to flush the target data line before restarting the capture.

Monitoring the Line's Status

Because the TargetDataLine interface extends DataLine, target data lines generate events in the same way source data lines do. You can register an object to receive events whenever the target data line opens, closes, starts, or stops. For more information, see "Monitoring the Line's Status" in Chapter 4, "Playing Back Audio."

Processing the Incoming Audio

Like some source data lines, some mixers' target data lines have signal-processing controls, such as gain, pan, reverb, or sample-rate controls. The input ports might have similar controls, especially gain controls. For more information on how to determine whether a line has such controls, and how to use them if it does, see Chapter 6, "Processing Audio with Controls."


Chapter 1: Introduction to the Java Sound API

Design Goals

The JavaTM Sound API is a low-level API for effecting and controlling the input and output of sound media, including both audio and Musical Instrument Digital Interface (MIDI) data. The Java Sound API provides explicit control over the capabilities normally required for sound input and output, in a framework that promotes extensibility and flexibility.

Who is the Java Sound API For?

Because sound is so fundamental, the Java Sound API fulfills the needs of a wide range of application developers. Potential application areas include:

  • Communication frameworks, such as conferencing and telephony
  • End-user content delivery systems, such as media players and music using streamed content
  • Interactive application programs, such as games and Web sites that use dynamic content
  • Content creation and editing
  • Tools, toolkits, and utilities

How Does the Java Sound API Relate to Other Interfaces?

The Java Sound API provides the lowest level of sound support on the Java platform. It provides application programs with a great amount of control over sound operations, and it is extensible. For example, the Java Sound API supplies mechanisms for installing, accessing, and manipulating system resources such as audio mixers, MIDI synthesizers, other audio or MIDI devices, file readers and writers, and sound format converters. The Java Sound API does not include sophisticated sound editors or graphical tools, but it provides capabilities upon which such programs can be built. It emphasizes low-level control beyond that commonly expected by the end user.

There are other Java platform APIs that have sound-related elements. The Java Media Framework (JMF) is a higher-level API that is currently available as a Standard Extension to the Java platform. JMF specifies a unified architecture, messaging protocol, and programming interface for capturing and playing back time-based media. JMF provides a simpler solution for basic media-player application programs, and it enables synchronization between different media types, such as audio and video. On the other hand, programs that focus on sound can benefit from the Java Sound API, especially if they require more advanced features, such as the ability to carefully control buffered audio playback or directly manipulate a MIDI synthesizer. Other Java APIs with sound aspects include Java 3D and APIs for telephony and speech. An implementation of any of these APIs might use an implementation of the Java Sound API internally, but is not required to do so.

Packages

The Java Sound API includes support for both digital audio and MIDI data. These two major modules of functionality are provided in separate packages:

  • javax.sound.sampled
    This package specifies interfaces for capture, mixing, and playback of digital (sampled) audio.
  • javax.sound.midi
    This package provides interfaces for MIDI synthesis, sequencing, and event transport.

Two other packages permit service providers (as opposed to application developers) to create custom software components that extend the capabilities of an implementation of the Java Sound API:

  • javax.sound.sampled.spi
  • javax.sound.midi.spi

The rest of this chapter briefly discusses the sampled-audio system, the MIDI system, and the SPI packages. Each of these is then discussed in detail in a subsequent part of the guide.

Sampled Audio

What Is Sampled Audio?

The javax.sound.sampled package handles digital audio data, which the Java Sound API refers to as sampled audio. Samples are successive snapshots of a signal. In the case of audio, the signal is a sound wave. A microphone converts the acoustic signal into a corresponding analog electrical signal, and an analog-to-digital converter transforms that analog signal into a sampled digital form. The following figure shows a brief moment in a sound recording.

A sampled sound wave
A Sampled Sound Wave

This graph plots sound pressure (amplitude) on the vertical axis, and time on the horizontal axis. The amplitude of the analog sound wave is measured periodically at a certain rate, resulting in the discrete samples (the red data points in the figure) that comprise the digital audio signal. The center horizontal line indicates zero amplitude; points above the line are positive-valued samples, and points below are negative. The accuracy of the digital approximation of the analog signal depends on its resolution in time (the sampling rate) and its quantization, or resolution in amplitude (the number of bits used to represent each sample). As a point of reference, the audio recorded for storage on compact discs is sampled 44,100 times per second and represented with 16 bits per sample.

The term "sampled audio" is used here slightly loosely. A sound wave could be sampled at discrete intervals while being left in an analog form. For purposes of the Java Sound API, however, "sampled audio" is equivalent to "digital audio."

Typically, sampled audio on a computer comes from a sound recording, but the sound could instead be synthetically generated (for example, to create the sounds of a touch-tone telephone). The term "sampled audio" refers to the type of data, not its origin.

Further information about the structure of digital audio data is given under "What Is Formatted Audio Data?" in Chapter 2, "Overview of the Sampled Package."

Audio Configurations

The Java Sound API does not assume a specific audio hardware configuration; it is designed to allow different sorts of audio components to be installed on a system and accessed by the API. The Java Sound API supports common functionality such as input and output from a sound card (for example, for recording and playback of sound files) as well as mixing of multiple streams of audio. Here is one example of a typical audio architecture:

The following context describes this graphic

A Typical Audio Architecture

In this example, a device such as a sound card has various input and output ports, and mixing is provided in the software. The mixer might receive data that has been read from a file, streamed from a network, generated on the fly by an application program, or produced by a MIDI synthesizer. (The javax.sound.midi package, discussed next, supplies a Java language interface for synthesizers.) The mixer combines all its audio inputs into a single stream, which can be sent to an output device for rendering.

MIDI

The javax.sound.midi package contains APIs for transporting and sequencing MIDI events, and for synthesizing sound from those events.

What Is MIDI?

Whereas sampled audio is a direct representation of a sound itself, MIDI data can be thought of as a recipe for creating a sound, especially a musical sound. MIDI data, unlike audio data, does not describe sound directly. Instead, it describes events that affect the sound a synthesizer is making. MIDI data is analogous to a graphical user interface's keyboard and mouse events. In the case of MIDI, the events can be thought of as actions upon a musical keyboard, along with actions on various pedals, sliders, switches, and knobs on that musical instrument. These events need not actually originate with a hardware musical instrument; they can be simulated in software, and they can be stored in MIDI files. A program that can create, edit, and perform these files is called a sequencer. Many computer sound cards include MIDI-controllable music synthesizer chips to which sequencers can send their MIDI events. Synthesizers can also be implemented entirely in software. The synthesizers interpret the MIDI events that they receive and produce audio output. Usually the sound synthesized from MIDI data is musical sound (as opposed to speech, for example). MIDI synthesizers are also capable of generating various kinds of sound effects.

Some sound cards include MIDI input and output ports to which external MIDI hardware devices (such as keyboard synthesizers or other instruments) can be connected. From a MIDI input port, an application program can receive events generated by an external MIDI-equipped musical instrument. The program might play the musical performance using the computer's internal synthesizer, save it to disk as a MIDI file, or render it into musical notation. A program might use a MIDI output port to play an external instrument, or to control other external devices such as recording equipment.

More information about MIDI data is given in Chapter 8, "Overview of the MIDI Package," particularly in the section "A MIDI Refresher: Wires and Files."

MIDI Configurations

The diagram below illustrates the functional relationships between the major components in a possible MIDI configuration based on the Java Sound API. (As with audio, the Java Sound API permits a variety of MIDI software devices to be installed and interconnected. The system shown here is one potential scenario.) The flow of data between components is indicated by arrows. The data can be in a standard file format, or (as indicated by the key in the lower right corner of the diagram), it can be audio, raw MIDI bytes, or time-tagged MIDI messages.

The following context describes this graphic

A Possible MIDI Configuration

In this example, the application program prepares a musical performance by loading a musical score that's stored as a standard MIDI file on a disk (left side of the diagram). Standard MIDI files contain tracks, each of which is a list of time-tagged MIDI events. Most of the events represent musical notes (pitches and rhythms). This MIDI file is read and then "performed" by a software sequencer. A sequencer performs its music by sending MIDI messages to some other device, such as an internal or external synthesizer. The synthesizer itself may read a soundbank file containing instructions for emulating the sounds of certain musical instruments. If not, the synthesizer will play the notes stored in the MIDI file using whatever instrument sounds are already loaded into the synthesizer.

As illustrated, the MIDI events must be translated into raw (non-time-tagged) MIDI before being sent through a MIDI output port to an external synthesizer. Similarly, raw MIDI data coming into the computer from an external MIDI source (a keyboard instrument, in the diagram) is translated into time-tagged MIDI messages that can control a synthesizer, or that a sequencer can store for later use. All these aspects of MIDI data flow are explained in detail in the subsequent chapters on MIDI (see Part II of this guide).

Service Provider Interfaces

The javax.sound.sampled.spi and javax.sound.midi.spi packages contain APIs that let software developers create new audio or MIDI resources that can be provided separately to the user and "plugged in" to an existing implementation of the Java Sound API. Here are some examples of services (resources) that can be added in this way:

  • An audio mixer
  • A MIDI synthesizer
  • A file parser that can read or write a new type of audio or MIDI file
  • A converter that translates between different sound data formats

In some cases, services are software interfaces to the capabilities of hardware devices, such as sound cards, and the service provider might be the same as the vendor of the hardware. In other cases, the services exist purely in software. For example, a synthesizer or a mixer could be an interface to a chip on a sound card, or it could be implemented without any hardware support at all.

An implementation of the Java Sound API contains a basic set of services, but the service provider interface (SPI) packages allow third parties to create new services. These third-party services are integrated into the system in the same way as the built-in services. The AudioSystem class in the sampled package and the MidiSystem class in the midi package act as coordinators that let application programs access the services explicitly or implicitly. Often the existence of a service is completely transparent to an application program that uses it. The service-provider mechanism benefits users of application programs based on the Java Sound API, because new sound features can be added to a program without requiring a new release of the Java SDK or runtime environment, and, in many cases, without even requiring a new release of the application program itself.


Chapter 13: Introduction to the Service Provider Interfaces

Note

For version 5.0, new constructors for AudioFormat, AudioFileFormat, and MidiFileFormat allow the description of more advanced formats.

What Are Services?

Services are units of sound-handling functionality that are automatically available when an application program makes use of an implementation of the JavaTM Sound API. They consist of objects that do the work of reading, writing, mixing, processing, and converting audio and MIDI data. An implementation of the Java Sound API generally supplies a basic set of services, but mechanisms are also included in the API to support the development of new sound services by third-party developers (or by the vendor of the implementation itself). These new services can be "plugged into" an existing installed implementation to expand its functionality without requiring a new release. In the Java Sound API architecture, third-party services are integrated into the system in such a way that an application program's interface to them is the same as the interface to the "built-in" services. In some cases, application developers who use the javax.sound.sampled and javax.sound.midi packages might not even be aware that they are employing third-party services.

Examples of potential third-party, sampled-audio services include:

  • Sound file readers and writers
  • Converters that translate between different audio data formats
  • New audio mixers and input/output devices, whether implemented purely in software, or in hardware with a software interface
Third-party MIDI services might consist of:

  • MIDI file readers and writers
  • Readers for various types of soundbank files (which are often specific to particular synthesizers)
  • MIDI-controlled sound synthesizers, sequencers, and I/O ports, whether implemented purely in software, or in hardware with a software interface

How Services Work

The javax.sound.sampled and javax.sound.midi packages provide functionality to application developers who wish to include sound services in their application programs. These packages are for consumers of sound services, providing interfaces to get information about, control, and access audio and MIDI services. In addition, the Java Sound API also supplies two packages that define abstract classes to be used by providers of sound services: the javax.sound.sampled.spi and javax.sound.midi.spi packages.

Developers of new sound services implement concrete subclasses of the appropriate classes in the SPI packages. These subclasses, along with any additional classes required to support the new service, are placed in a JavaTM Archive (JAR) archive file with a description of the included service or services. When this JAR file is installed in the user's CLASSPATH, the runtime system automatically makes the new service available, extending the functionality of the JavaTM platform's runtime system.

Once the new service is installed, it can be accessed just like any previously installed service. Consumers of services can get information about the new service, or obtain instances of the new service class itself, by invoking methods of the AudioSystem and MidiSystem classes (in the javax.sound.sampled and javax.sound.midi packages, respectively) to return information about the new services, or to return instances of new or existing service classes themselves. Application programs need not—and should not—reference the classes in the SPI packages (and their subclasses) directly to make use of the installed services.

For example, suppose a hypothetical service provider called Acme Software, Inc. is interested in supplying a package that allows application programs to read a new format of sound file (but one whose audio data is in a standard data format). The SPI class AudioFileReader can be subclassed into a class called, say, AcmeAudioFileReader. In the new subclass, Acme would supply implementations of all the methods defined in AudioFileReader; in this case there are only two methods (with argument variants), getAudioFileFormat and getAudioInputStream. Then when an application program attempted to read a sound file that happened to be in Acme's file format, it would invoke methods of the AudioSystem class in javax.sound.sampled to access the file and information about it. The methods AudioSystem.getAudioInputStream and AudioSystem.getAudioFileFormat provide a standard API to read audio streams; with the AcmeAudioFileReader class installed, this interface is extended to support the new file type transparently. Application developers don't need direct access to the newly registered SPI classes: the AudioSystem object methods pass the query on to the installed AcmeAudioFileReader class.

What's the point of having these "factory" classes? Why not permit the application developer to get access directly to newly provided services? That is a possible approach, but having all management and instantiation of services pass through gatekeeper system objects shields the application developer from having to know anything about the identity of installed services. Application developers just use services of value to them, perhaps without even realizing it. At the same time this architecture permits service providers to effectively manage the available resources in their packages.

Often the use of new sound services is transparent to the application program. For example, imagine a situation where an application developer wants to read in a stream of audio from a file. Assuming that thePathName identifies an audio input file, the program does this:

    File theInFile = new File(thePathName);
    AudioInputStream theInStream = AudioSystem.getAudioInputStream(theInFile);
Behind the scenes, the AudioSystem determines what installed service can read the file and asks it to supply the audio data as an AudioInputStream object. The developer might not know or even care that the input audio file is in some new file format (such as Acme's), supported by installed third-party services. The program's first contact with the stream is through the AudioSystem object, and all its subsequent access to the stream and its properties are through the methods of AudioInputStream. Both of these are standard objects in the javax.sound.sampled API; the special handling that the new file format may require is completely hidden.

How Providers Prepare New Services

Service providers supply their new services in specially formatted JAR files, which are to be installed in a directory on the user's system where the Java runtime will find them. JAR files are archive files, each containing sets of files that might be organized in hierarchical directory structures within the archive. Details about the preparation of the class files that go into these archives are discussed in Chapters 14 and 15, which describe the specifics of the audio and MIDI SPI packages; here we'll just give an overview of the process of JAR file creation.

The JAR file for a new service or services should contain a class file for each service supported in the JAR file. Following the Java platform's convention, each class file has the name of the newly defined class, which is a concrete subclass of one of the abstract service provider classes. The JAR file also must include any supporting classes required by the new service implementation. So that the new service or services can be located by the runtime system's service provider mechanism, the JAR file must also contain special files (described below) that map the SPI class names to the new subclasses being defined.

To continue from our example above, say Acme Software, Inc. is distributing a package of new sampled-audio services. Let's suppose this package consists of two new services:

  • The AcmeAudioFileReader class, which was mentioned above, and which is a subclass of AudioFileReader
  • A subclass of AudioFileWriter called AcmeAudioFileWriter, which will write sound files in Acme's new format
Starting from an arbitrary directory—let's call it /devel—where we want to do the build, we create subdirectories and put the new class files in them, organized in such a manner as to give the desired pathname by which the new classes will be referenced:

    com/acme/AcmeAudioFileReader.class
    com/acme/AcmeAudioFileWriter.class
In addition, for each new SPI class being subclassed, we create a mapping file in a specially named directory META-INF/services. The name of the file is the name of the SPI class being subclassed, and the file contains the names of the new subclasses of that SPI abstract class.

We create the file

META-INF/services/javax.sound.sampled.spi.AudioFileReader, which consists of

    # Providers of sound file-reading services
    # (a comment line begins with a pound sign)
    com.acme.AcmeAudioFileReader

and also the file

META-INF/services/javax.sound.sampled.spi.AudioFileWriter, which consists of

   # Providers of sound file-writing services
    com.acme.AcmeAudioFileWriter

Now we run jar from any directory with the command line:

jar cvf acme.jar -C /devel .
The -C option causes jar to switch to the /devel directory, instead of using the directory in which the command is executed. The final period argument instructs jar to archive all the contents of that directory (namely, /devel), but not the directory itself.

This run will create the file acme.jar with the contents:

com/acme/AcmeAudioFileReader.class
com/acme/AcmeAudioFileWriter.class
META-INF/services/javax.sound.sampled.spi.AudioFileReader
META-INF/services/javax.sound.sampled.spi.AudioFileWriter
META-INF/Manifest.mf
The file Manifest.mf, which is generated by the jar utility itself, is a list of all the files contained in the archive.

How Users Install New Services

For end users (or system administrators) who wish to get access to a new service through their application programs, installation is simple. They place the provided JAR file in a directory in their CLASSPATH. Upon execution, the Java runtime will find the referenced classes when needed.

It's not an error to install more than one provider for the same service. For example, two different service providers might supply support for reading the same type of sound file. In such a case, the system arbitrarily chooses one of the providers. Users who care which provider is chosen should install only the desired one.


Java Sound Programmer Guide

JavaTM Sound Programmer Guide

Note: There are two ways to navigate this guide:

  • Search the guide
  • Select from the contents below

Introductory Material

Preface

For Whom This Guide Is Intended
What this Guide Describes
For More Information

Chapter: 1 Introduction to the Java Sound API

Design Goals
Who is the Java Sound API For?
How Does the Java Sound API Relate to Other Interfaces?
Packages
Sampled Audio
What Is Sampled Audio?
Audio Configurations
MIDI
What Is MIDI?
MIDI Configurations
Service Provider Interfaces

Part I: Sampled Audio

Chapter 2: Overview of the Sampled Package

Design Goals
A Focus on Data Transport
Buffered and Unbuffered Handling of Audio
The Essentials: Format, Mixer, and Line
What Is Formatted Audio Data?
What Is a Mixer?
What Is a Line?
Lines in an Audio-output Configuration
Lines in an Audio-input Configuration
The Line Interface Hierarchy

Chapter 3: Accessing Audio System Resources

The AudioSystem Class
Information Objects
Getting a Mixer
Getting a Line of a Desired Type
Getting a Line Directly from the AudioSystem
Getting a Line from a Mixer
Selecting Input and Output Ports
Permission to Use Audio Resources

Chapter 4: Playing Back Audio

Using a Clip
Setting Up the Clip for Playback
Starting and Stopping Playback
Using a SourceDataLine
Setting Up the SourceDataLine for Playback
Starting and Stopping Playback
Monitoring a Line's Status
Synchronizing Playback on Multiple Lines
Processing the Outgoing Audio

Chapter 5: Capturing Audio

Setting Up a TargetDataLine
Reading the Data from the TargetDataLine
Monitoring the Line's Status
Processing the Incoming Audio

Chapter 6: Processing Audio with Controls

Introduction to Controls
Getting a Line that Has the Desired Controls
Getting the Controls from the Line
Using a Control to Change the Audio Signal
Controlling a Line's Mute State
Changing a Line's Volume
Selecting among Various Reverberation Presets
Manipulating the Audio Data Directly

Chapter 7: Using Files and Format Converters

Reading Sound Files
Writing Sound Files
Converting File and Data Formats
Converting from One File Format to Another
Converting Audio between Different Data Formats
Learning What Conversions Are Available

Part II: MIDI

Chapter 8: Overview of the MIDI Package

A MIDI Refresher: Wires and Files
Streaming Data in the MIDI Wire Protocol
Sequenced Data in Standard MIDI Files
The Java Sound API's Representation of MIDI Data
MIDI Messages
MIDI Events
Sequences and Tracks
The Java Sound API's Representation of MIDI Devices
The MidiDevice Interface
Transmitters and Receivers
Sequencers
Synthesizers

Chapter 9: Accessing MIDI System Resources

The MidiSystem Class
Obtaining Default Devices
Learning What Devices Are Installed
Obtaining a Desired Device
Opening Devices

Chapter 10: Transmitting and Receiving MIDI Messages

Understanding Devices, Transmitters, and Receivers
Sending a Message to a Receiver without Using a Transmitter
Understanding Time Stamps
Time Stamps on Messages Sent to Devices
Connecting Transmitters to Receivers
Connecting to a Single Device
Connecting to More than One Device
Closing Connections

Chapter 11: Playing, Recording, and Editing MIDI Sequences

Introduction to Sequencers
When to Use a Sequencer
Understanding Sequence Data
Sequences and Tracks
MidiEvents and Ticks
Overview of Sequencer Methods
Obtaining a Sequencer
Loading a Sequence
Playing a Sequence
Recording and Saving Sequences
Editing a Sequence
Using Advanced Sequencer Features
Moving to an Arbitrary Position in the Sequence
Changing the Playback Speed
Muting or Soloing Individual
Tracks in the Sequence
Synchronizing with Other MIDI Devices
Specifying Special Event Listeners

Chapter 12: Synthesizing Sound

Understanding MIDI Synthesis
Instruments
Channels
Soundbanks and Patches
Voices
Managing Instruments and Soundbanks
Learning What Instruments Are Loaded
Loading Different Instruments
Unloading Instruments
Accessing Soundbank Resources
Querying the Synthesizer's Capabilities and Current State
Using Channels
Controlling the Synthesizer without
Using a Sequencer
Getting a Channel's Current State
Muting and Soloing a Channel
Permission to Play Synthesized Sound

Part III: Service Provider Interfaces

Chapter 13: Introduction to the Service Provider Interfaces

What Are Services?
How Services Work
How Providers Prepare New Services
How Users Install New Services

Chapter 14: Providing Sampled-Audio Services

Introduction
Providing Audio File-Writing Services
Providing Audio File-Reading Services
Providing Format-Conversion Services
Providing New Types of Mixers

Chapter 15: Providing MIDI Services

Introduction
Providing MIDI File-Writing Services
Providing MIDI File-Reading Services
Providing Particular MIDI Devices
Providing Soundbank File-Reading Services

Appendices

Appendix 1: Code Overview: AudioSystem.java

Appendix 2: sound.properties File


JavaSound API Programmer's Guide

Last Updated October 24, 2001


Chapter 8: Overview of the MIDI Package

Chapter 1,"Introduction to Java Sound," gave a glimpse into the MIDI capabilities of the JavaTM Sound API. The present chapter assumes you've read Chapter 1. The discussion here provides a more detailed introduction to the Java Sound API's MIDI architecture, which is accessed through the javax.sound.midi package. Some basic features of MIDI itself are explained, as a refresher or introduction, to place the Java Sound API's MIDI features in context. The chapter then goes on to discuss the Java Sound API's approach to MIDI, as a preparation for the programming tasks that are explained in subsequent chapters. This chapter's discussion of the MIDI API is divided into two main areas: data and devices.

A MIDI Refresher: Wires and Files

The Musical Instrument Digital Interface (MIDI) standard defines a communication protocol for electronic music devices, such as electronic keyboard instruments and personal computers. MIDI data can be transmitted over special cables during a live performance, and can also be stored in a standard type of file for later playback or editing.

This section reviews some MIDI basics, without reference to the Java Sound API. The discussion is intended as a refresher for readers acquainted with MIDI, and as a brief introduction for those who are not, to provide background for the subsequent discussion of the Java Sound API's MIDI package. If you have a thorough understanding of MIDI, you can safely skip this section. Before writing substantial MIDI applications, programmers who are unfamiliar with MIDI will probably need a fuller description of MIDI than can be included in this programmer's guide. See the Complete MIDI 1.0 Detailed Specification, which is available only in hard copy from http://www.midi.org (although you might find paraphrased or summarized versions on the Web).

MIDI is both a hardware specification and a software specification. To understand MIDI's design, it helps to understand its history. MIDI was originally designed for passing musical events, such as key depressions, between electronic keyboard instruments such as synthesizers. (As mentioned in Chapter 1, MIDI data consists primarily of control events that communicate a musician's gestures. MIDI data doesn't contain the audio that results from these events.) Hardware devices known as sequencers stored sequences of notes that could control a synthesizer, allowing musical performances to be recorded and subsequently played back. Later, hardware interfaces were developed that connected MIDI instruments to a computer's serial port, allowing sequencers to be implemented in software. More recently, computer sound cards have incorporated hardware for MIDI I/O and for synthesizing musical sound. Today, many users of MIDI deal only with sound cards, never connecting to external MIDI devices. CPUs have become fast enough that synthesizers, too, can be implemented in software. A sound card is needed only for audio I/O and, in some applications, for communicating with external MIDI devices.

The brief hardware portion of the MIDI specification prescribes the pinouts for MIDI cables and the jacks into which these cables are plugged. This portion need not concern us. Because devices that originally required hardware, such as sequencers and synthesizers, are now implementable in software, perhaps the only reason for most programmers to know anything about MIDI hardware devices is simply to understand the metaphors in MIDI. However, external MIDI hardware devices are still essential for some important music applications, and so the Java Sound API supports input and output of MIDI data.

The software portion of the MIDI specification is extensive. This portion concerns the structure of MIDI data and how devices such as synthesizers should respond to that data. It is important to understand that MIDI data can be streamed or sequenced. This duality reflects two different parts of the Complete MIDI 1.0 Detailed Specification:

  • MIDI 1.0
  • Standard MIDI Files

We'll explain what's meant by streaming and sequencing by examining the purpose of each of these two parts of the MIDI specification.

Streaming Data in the MIDI Wire Protocol

The first of these two parts of the MIDI specification describes what is known informally as "MIDI wire protocol." MIDI wire protocol, which is the original MIDI protocol, is based on the assumption that the MIDI data is being sent over a MIDI cable (the "wire"). The cable transmits digital data from one MIDI device to another. Each of the MIDI devices might be a musical instrument or a similar device, or it might be a general-purpose computer equipped with a MIDI-capable sound card or a MIDI-to-serial-port interface.

MIDI data, as defined by MIDI wire protocol, is organized into messages. The different kinds of message are distinguished by the first byte in the message, known as the status byte. (Status bytes are the only bytes that have the highest-order bit set to 1.) The bytes that follow the status byte in a message are known as data bytes. Certain MIDI messages, known as channel messages, have a status byte that contains four bits to specify the kind of channel message and another four bits to specify the channel number. There are therefore 16 MIDI channels; devices that receive MIDI messages can be set to respond to channel messages on all or only one of these virtual channels. Often each MIDI channel (which shouldn't be confused with a channel of audio) is used to send the notes for a different instrument. As an example, two common channel messages are Note On and Note Off, which start a note sounding and then stop it, respectively. These two messages each take two data bytes: the first specifies the note's pitch and the second its "velocity" (how fast the key is depressed or released, assuming a keyboard instrument is playing the note).

MIDI wire protocol defines a streaming model for MIDI data. A central feature of this protocol is that the bytes of MIDI data are delivered in real time—in other words, they are streamed. The data itself contains no timing information; each event is processed as it's received, and it's assumed that it arrives at the correct time. That model is fine if the notes are being generated by a live musician, but it's insufficient if you want to store the notes for later playback, or if you want to compose them out of real time. This limitation is understandable when you realize that MIDI was originally designed for musical performance, as a way for a keyboard musician to control more than one synthesizer, back in the days before many musicians used computers. (The first version of the specification was released in 1984.)

Sequenced Data in Standard MIDI Files

The Standard MIDI Files part of the MIDI specification addresses the timing limitation in MIDI wire protocol. A standard MIDI file is a digital file that contains MIDI events. An event is simply a MIDI message, as defined in the MIDI wire protocol, but with an additional piece of information that specifies the event's timing. (There are also some events that don't correspond to MIDI wire protocol messages, as we'll see in the next section.) The additional timing information is a series of bytes that indicates when to perform the operation described by the message. In other words, a standard MIDI file specifies not just which notes to play, but exactly when to play each of them. It's a bit like a musical score.

The information in a standard MIDI file is referred to as a sequence. A standard MIDI file contains one or more tracks. Each track typically contains the notes that a single instrument would play if the music were performed by live musicians. A sequencer is a software or hardware device that can read a sequence and deliver the MIDI messages contained in it at the right time. A sequencer is a bit like an orchestra conductor: it has the information for all the notes, including their timings, and it tells some other entity when to perform the notes.

The Java Sound API's Representation of MIDI Data

Now that we've sketched the MIDI specification's approach to streamed and sequenced musical data, let's examine how the Java Sound API represents that data.

MIDI Messages

MidiMessage is an abstract class that represents a "raw" MIDI message. A "raw" MIDI message is usually a message defined by the MIDI wire protocol. It can also be one of the events defined by the Standard MIDI Files specification, but without the event's timing information. There are three categories of raw MIDI message, represented in the Java Sound API by these three respective MidiMessage subclasses:

  • ShortMessages are the most common messages and have at most two data bytes following the status byte. The channel messages, such as Note On and Note Off, are all short messages, as are some other messages.
  • SysexMessages contain system-exclusive MIDI messages. They may have many bytes, and generally contain manufacturer-specific instructions.
  • MetaMessages occur in MIDI files, but not in MIDI wire protocol. Meta messages contain data, such as lyrics or tempo settings, that might be useful to sequencers but that are usually meaningless for synthesizers.

MIDI Events

As we've seen, standard MIDI files contain events that are wrappers for "raw" MIDI messages along with timing information. An instance of the Java Sound API's MidiEvent class represents an event such as might be stored in a standard MIDI file.

The API for MidiEvent includes methods to set and get the event's timing value. There's also a method to retrieve its embedded raw MIDI message, which is an instance of a subclass of MidiMessage, discussed next. (The embedded raw MIDI message can be set only when constructing the MidiEvent.)

Sequences and Tracks

As mentioned earlier, a standard MIDI file stores events that are arranged into tracks. Usually the file represents one musical composition, and usually each track represents a part such as might have been played by a single instrumentalist. Each note that the instrumentalist plays is represented by at least two events: a Note On that starts the note, and a Note Off that ends it. The track may also contain events that don't correspond to notes, such as meta-events (which were mentioned above).

The Java Sound API organizes MIDI data in a three-part hierarchy:

  • Sequence
  • Track
  • MidiEvent

A Track is a collection of MidiEvents, and a Sequence is a collection of Tracks. This hierarchy reflects the files, tracks, and events of the Standard MIDI Files specification. (Note: this is a hierarchy in terms of containment and ownership; it's not a class hierarchy in terms of inheritance. Each of these three classes inherits directly from java.lang.Object.)

Sequences can be read from MIDI files, or created from scratch and edited by adding Tracks to the Sequence (or removing them). Similarly, MidiEvents can be added to or removed from the tracks in the sequence.

The Java Sound API's Representation of MIDI Devices

The previous section explained how MIDI messages are represented in the Java Sound API. However, MIDI messages don't exist in a vacuum. They're typically sent from one device to another. A program that uses the Java Sound API can generate MIDI messages from scratch, but more often the messages are instead created by a software device, such as a sequencer, or received from outside the computer through a MIDI input port. Such a device usually sends these messages to another device, such as a synthesizer or a MIDI output port.

The MidiDevice Interface

In the world of external MIDI hardware devices, many devices can transmit MIDI messages to other devices and also receive messages from other devices. Similarly, in the Java Sound API, software objects that implement the MidiDevice interface can transmit and receive messages. Such an object can be implemented purely in software, or it can serve as an interface to hardware such as a sound card's MIDI capabilities. The base MidiDevice interface provides all the functionality generally required by a MIDI input or output port. Synthesizers and sequencers, however, further implement one of the subinterfaces of MidiDevice: Synthesizer or Sequencer, respectively.

The MidiDevice interface includes API for opening and closing a device. It also includes an inner class called MidiDevice.Info that provides textual descriptions of the device, including its name, vendor, and version. If you've read the sampled-audio portion of this programmer's guide, this API will probably sound familiar, because its design is similar to that of the javax.sampled.Mixer interface, which represents an audio device and which has an analogous inner class, Mixer.Info.

Transmitters and Receivers

Most MIDI devices are capable of sending MidiMessages, receiving them, or both. The way a device sends data is via one or more transmitter objects that it "owns." Similarly, the way a device receives data is via one or more of its receiver objects. The transmitter objects implement the Transmitter interface, and the receivers implement the Receiver interface.

Each transmitter can be connected to only one receiver at a time, and vice versa. A device that sends its MIDI messages to multiple other devices simultaneously does so by having multiple transmitters, each connected to a receiver of a different device. Similarly, a device that can receive MIDI messages from more than one source at a time must do so via multiple receivers.

Sequencers

A sequencer is a device for capturing and playing back sequences of MIDI events. It has transmitters, because it typically sends the MIDI messages stored in the sequence to another device, such as a synthesizer or MIDI output port. It also has receivers, because it can capture MIDI messages and store them in a sequence. To its superinterface, MidiDevice, Sequencer adds methods for basic MIDI sequencing operations. A sequencer can load a sequence from a MIDI file, query and set the sequence's tempo, and synchronize other devices to it. An application program can register an object to be notified when the sequencer processes certain kinds of events.

Synthesizers

A Synthesizer is a device for generating sound. It's the only object in the javax.sound.midi package that produces audio data. A synthesizer device controls a set of MIDI channel objects—typically 16 of them, since the MIDI specification calls for 16 MIDI channels. These MIDI channel objects are instances of a class that implements the MidiChannel interface, whose methods represent the MIDI specification's "channel voice messages" and "channel mode messages."

An application program can generate sound by directly invoking methods of a synthesizer's MIDI channel objects. More commonly, though, a synthesizer generates sound in response to messages sent to one or more of its receivers. These messages might be sent by a sequencer or MIDI input port, for example. The synthesizer parses each message that its receivers get, and usually dispatches a corresponding command (such as noteOn or controlChange) to one of its MidiChannel objects, according to the MIDI channel number specified in the event.

The MidiChannel uses the note information in these messages to synthesize music. For example, a noteOn message specifies the note's pitch and "velocity" (volume). However, the note information is insufficient; the synthesizer also requires precise instructions on how to create the audio signal for each note. These instructions are represented by an Instrument. Each Instrument typically emulates a different real-world musical instrument or sound effect. The Instruments might come as presets with the synthesizer, or they might be loaded from soundbank files. In the synthesizer, the Instruments are arranged by bank number (these can be thought of as rows) and program number (columns).

This chapter has provided a background for understanding MIDI data, and it has introduced some of the important interfaces and classes related to MIDI in the Java Sound API. Subsequent chapters show how you can access and use these objects in your application program.


Chapter 2: Overview of the Sampled Package

Notes

  1. With J2SE 5.0 and the new Direct Audio mixers, the Sun reference implementation allows use of all available soundcards and all supported sample rates and bits per sample.
  2. Direct Audio mixers are always the default on Windows. They are the default on Solaris if the Solaris audio mixer is enabled (see Solaris man page for mixer). On Linux, they are the default only if there is a device that supports mixing.
  3. Because they are "direct," Direct Audio mixers do not support SAMPLE_RATE control.
  4. The default mixer can be selected via the sound.properties file.

This chapter provides an introduction to the JavaTM Sound API's digital audio architecture, which is accessed through the javax.sound.sampled package. First, an explanation is given of the package's focus: playback and capture of formatted audio data. Then this chapter describes the three fundamental components required for playback or capture: an audio data format, a line, and a mixer. The Line interface and its subinterfaces are introduced briefly.

Design Goals

Before examining the elements of the Java Sound API, it helps to understand the orientation of the javax.sound.sampled package.

A Focus on Data Transport

The javax.sound.sampled package is fundamentally concerned with audio transport—in other words, the Java Sound API focuses on playback and capture. The central task that the Java Sound API addresses is how to move bytes of formatted audio data into and out of the system. This task involves opening audio input and output devices and managing buffers that get filled with real-time sound data. It can also involve mixing multiple streams of audio into one stream (whether for input or output). The transport of sound into or out of the system has to be correctly handled when the user requests that the flow of sound be started, paused, resumed, or stopped.

To support this focus on basic audio input and output, the Java Sound API provides methods for converting between various audio data formats, and for reading and writing common types of sound files. However, it does not attempt to be a comprehensive sound-file toolkit. A particular implementation of the Java Sound API need not support an extensive set of file types or data format conversions. Third-party service providers can supply modules that "plug in" to an existing implementation to support additional file types and conversions.

Buffered and Unbuffered Handling of Audio

The Java Sound API can handle audio transport in both a streaming, buffered fashion and an in-memory, unbuffered fashion. "Streaming" is used here in a general sense to refer to real-time handling of audio bytes; it does not refer to the specific, well-known case of sending audio over the Internet in a certain format. In other words, a stream of audio is simply a continuous set of audio bytes that arrive more or less at the same rate that they are to be handled (played, recorded, etc.). Operations on the bytes commence before all the data has arrived. In the streaming model, particularly in the case of audio input rather than audio output, you do not necessarily know in advance how long the sound is and when it will finish arriving. You simply handle one buffer of audio data at a time, until the operation is halted. In the case of audio output (playback), you also need to buffer data if the sound you want to play is too large to fit in memory all at once. In other words, you deliver your audio bytes to the sound engine in chunks, and it takes care of playing each sample at the right time. Mechanisms are provided that make it easy to know how much data to deliver in each chunk.

The Java Sound API also permits unbuffered transport in the case of playback only, assuming you already have all the audio data at hand and it is not too large to fit in memory. In this situation, there is no need for the application program to buffer the audio, although the buffered, real-time approach is still available if desired. Instead, the entire sound can be preloaded at once into memory for subsequent playback. Because all the sound data is loaded in advance, playback can start immediately—for example, as soon as the user clicks a Start button. This can be an advantage compared to the buffered model, where the playback has to wait for the first buffer to fill. In addition, the in-memory, unbuffered model allows sounds to be easily looped (cycled) or set to arbitrary positions in the data.

These two models for playback are discussed further in Chapter 4, "Playing Back Audio." Buffered recording is discussed in Chapter 5, "Capturing Audio."

The Essentials: Format, Mixer, and Line

To play or capture sound using the Java Sound API, you need at least three things: formatted audio data, a mixer, and a line. Each of these is explained below.

What Is Formatted Audio Data?

Formatted audio data refers to sound in any of a number of standard formats. The Java Sound API distinguishes between data formats and file formats.

Data Formats

A data format tells you how to interpret a series of bytes of "raw" sampled audio data, such as samples that have already been read from a sound file, or samples that have been captured from the microphone input. You might need to know, for example, how many bits constitute one sample (the representation of the shortest instant of sound), and similarly you might need to know the sound's sample rate (how fast the samples are supposed to follow one another). When setting up for playback or capture, you specify the data format of the sound you are capturing or playing.

In the Java Sound API, a data format is represented by an AudioFormat object, which includes the following attributes:

  • Encoding technique, usually pulse code modulation (PCM)
  • Number of channels (1 for mono, 2 for stereo, etc.)
  • Sample rate (number of samples per second, per channel)
  • Number of bits per sample (per channel)
  • Frame rate
  • Frame size in bytes
  • Byte order (big-endian or little-endian)

PCM is one kind of encoding of the sound waveform. The Java Sound API includes two PCM encodings that use linear quantization of amplitude, and signed or unsigned integer values. Linear quantization means that the number stored in each sample is directly proportional (except for any distortion) to the original sound pressure at that instant—and similarly proportional to the displacement of a loudspeaker or eardrum that is vibrating with the sound at that instant. Compact discs, for example, use linear PCM-encoded sound. Mu-law encoding and a-law encoding are common nonlinear encodings that provide a more compressed version of the audio data; these encodings are typically used for telephony or recordings of speech. A nonlinear encoding maps the original sound's amplitude to the stored value using a nonlinear function, which can be designed to give more amplitude resolution to quiet sounds than to loud sounds.

A frame contains the data for all channels at a particular time. For PCM-encoded data, the frame is simply the set of simultaneous samples in all channels, for a given instant in time, without any additional information. In this case, the frame rate is equal to the sample rate, and the frame size in bytes is the number of channels multiplied by the sample size in bits, divided by the number of bits in a byte.

For other kinds of encodings, a frame might contain additional information besides the samples, and the frame rate might be completely different from the sample rate. For example, consider the MP3 (MPEG-1 Audio Layer 3) encoding, which is not explicitly mentioned in the current version of the Java Sound API, but which could be supported by an implementation of the Java Sound API or by a third-party service provider. In MP3, each frame contains a bundle of compressed data for a series of samples, not just one sample per channel. Because each frame encapsulates a whole series of samples, the frame rate is slower than the sample rate. The frame also contains a header. Despite the header, the frame size in bytes is less than the size in bytes of the equivalent number of PCM frames. (After all, the purpose of MP3 is to be more compact than PCM data.) For such an encoding, the sample rate and sample size refer to the PCM data that the encoded sound will eventually be converted into before being delivered to a digital-to-analog converter (DAC).

File Formats

A file format specifies the structure of a sound file, including not only the format of the raw audio data in the file, but also other information that can be stored in the file. Sound files come in various standard varieties, such as WAVE (also known as WAV, and often associated with PCs), AIFF (often associated with Macintoshes), and AU (often associated with UNIX systems). The different types of sound file have different structures. For example, they might have a different arrangement of data in the file's "header." A header contains descriptive information that typically precedes the file's actual audio samples, although some file formats allow successive "chunks" of descriptive and audio data. The header includes a specification of the data format that was used for storing the audio in the sound file. Any of these types of sound file can contain various data formats (although usually there is only one data format within a given file), and the same data format can be used in files that have different file formats.

In the Java Sound API, a file format is represented by an AudioFileFormat object, which contains:

  • The file type (WAVE, AIFF, etc.)
  • The file's length in bytes
  • The length, in frames, of the audio data contained in the file
  • An AudioFormat object that specifies the data format of the audio data contained in the file

The AudioSystem class (described in Chapter 3, "Accessing Audio System Resources") provides methods for reading and writing sounds in different file formats, and for converting between different data formats. Some of the methods let you access a file's contents through a kind of stream called an AudioInputStream. An AudioInputStream is a subclass of the generic Java InputStream class, which encapsulates a series of bytes that can be read sequentially. To its superclass, the AudioInputStream class adds knowledge of the bytes' audio data format (represented by an AudioFormat object). By reading a sound file as an AudioInputStream, you get immediate access to the samples, without having to worry about the sound file's structure (its header, chunks, etc.). A single method invocation gives you all the information you need about the data format and the file type.

What Is a Mixer?

Many application programming interfaces (APIs) for sound make use of the notion of an audio device. A device is often a software interface to a physical input/output device. For example, a sound-input device might represent the input capabilities of a sound card, including a microphone input, a line-level analog input, and perhaps a digital audio input.

In the Java Sound API, devices are represented by Mixer objects. The purpose of a mixer is to handle one or more streams of audio input and one or more streams of audio output. In the typical case, it actually mixes together multiple incoming streams into one outgoing stream. A Mixer object can represent the sound-mixing capabilities of a physical device such as a sound card, which might need to mix the sound coming in to the computer from various inputs, or the sound coming from application programs and going to outputs.

Alternatively, a Mixer object can represent sound-mixing capabilities that are implemented entirely in software, without any inherent interface to physical devices.

In the Java Sound API, a component such as the microphone input on a sound card is not itself considered a device—that is, a mixer—but rather a port into or out of the mixer. A port typically provides a single stream of audio into or out of the mixer (although the stream can be multichannel, such as stereo). The mixer might have several such ports. For example, a mixer representing a sound card's output capabilities might mix several streams of audio together, and then send the mixed signal to any or all of various output ports connected to the mixer. These output ports could be (for example) a headphone jack, a built-in speaker, or a line-level output.

To understand the notion of a mixer in the Java Sound API, it helps to visualize a physical mixing console, such as those used in live concerts and recording studios. (See illustration that follows.)

A Physical Mixing Console

A physical mixer has "strips" (also called "slices"), each representing a path through which a single audio signal goes into the mixer for processing. The strip has knobs and other controls by which you can control the volume and pan (placement in the stereo image) for the signal in that strip. Also, the mixer might have a separate bus for effects such as reverb, and this bus can be connected to an internal or external reverberation unit. Each strip has a potentiometer that controls how much of that strip's signal goes into the reverberated mix. The reverberated ("wet") mix is then mixed with the "dry" signals from the strips. A physical mixer sends this final mixture to an output bus, which typically goes to a tape recorder (or disk-based recording system) and/or speakers.

Imagine a live concert that is being recorded in stereo. Cables (or wireless connections) coming from the many microphones and electric instruments on stage are plugged into the inputs of the mixing console. Each input goes to a separate strip of the mixer, as illustrated. The sound engineer decides on the settings of the gain, pan, and reverb controls. The output of all the strips and the reverb unit are mixed together into two channels. These two channels go to two outputs on the mixer, into which cables are plugged that connect to the stereo tape recorder's inputs. The two channels are perhaps also sent via an amplifier to speakers in the hall, depending on the type of music and the size of the hall.

Now imagine a recording studio, in which each instrument or singer is recorded to a separate track of a multitrack tape recorder. After the instruments and singers have all been recorded, the recording engineer performs a "mixdown" to combine all the taped tracks into a two-channel (stereo) recording that can be distributed on compact discs. In this case, the input to each of the mixer's strips is not a microphone, but one track of the multitrack recording. Once again, the engineer can use controls on the strips to decide each track's volume, pan, and reverb amount. The mixer's outputs go once again to a stereo recorder and to stereo speakers, as in the example of the live concert.

These two examples illustrate two different uses of a mixer: to capture multiple input channels, combine them into fewer tracks, and save the mixture, or to play back multiple tracks while mixing them down to fewer tracks.

In the Java Sound API, a mixer can similarly be used for input (capturing audio) or output (playing back audio). In the case of input, the source from which the mixer gets audio for mixing is one or more input ports. The mixer sends the captured and mixed audio streams to its target, which is an object with a buffer from which an application program can retrieve this mixed audio data. In the case of audio output, the situation is reversed. The mixer's source for audio is one or more objects containing buffers into which one or more application programs write their sound data; and the mixer's target is one or more output ports.

What Is a Line?

The metaphor of a physical mixing console is also useful for understanding the Java Sound API's concept of a line.

A line is an element of the digital audio "pipeline"—that is, a path for moving audio into or out of the system. Usually the line is a path into or out of a mixer (although technically the mixer itself is also a kind of line).

Audio input and output ports are lines. These are analogous to the microphones and speakers connected to a physical mixing console. Another kind of line is a data path through which an application program can get input audio from, or send output audio to, a mixer. These data paths are analogous to the tracks of the multitrack recorder connected to the physical mixing console.

One difference between lines in the Java Sound API and those of a physical mixer is that the audio data flowing through a line in the Java Sound API can be mono or multichannel (for example, stereo). By contrast, each of a physical mixer's inputs and outputs is typically a single channel of sound. To get two or more channels of output from the physical mixer, two or more physical outputs are normally used (at least in the case of analog sound; a digital output jack is often multichannel). In the Java Sound API, the number of channels in a line is specified by the AudioFormat of the data that is currently flowing through the line.

Lines in an Audio-output Configuration

Let's now examine some specific kinds of lines and mixers. The following diagram shows different types of lines in a simple audio-output system that could be part of an implementation of the Java Sound API:

A Possible Configuration of Lines for Audio Output

In this example, an application program has gotten access to some available inputs of an audio-input mixer: one or more clips and source data lines. A clip is a mixer input (a kind of line) into which you can load audio data prior to playback; a source data line is a mixer input that accepts a real-time stream of audio data. The application program preloads audio data from a sound file into the clips. It then pushes other audio data into the source data lines, a buffer at a time. The mixer reads data from all these lines, each of which may have its own reverberation, gain, and pan controls, and mixes the dry audio signals with the wet (reverberated) mix. The mixer delivers its final output to one or more output ports, such as a speaker, a headphone jack, and a line-out jack.

Although the various lines are depicted as separate rectangles in the diagram, they are all "owned" by the mixer, and can be considered integral parts of the mixer. The reverb, gain, and pan rectangles represent processing controls (rather than lines) that can be applied by the mixer to data flowing through the lines.

Note that this is just one example of a possible mixer that is supported by the API. Not all audio configurations will have all the features illustrated. An individual source data line might not support panning, a mixer might not implement reverb, and so on.

Lines in an Audio-input Configuration

A simple audio-input system might be similar:

A Possible Configuration of Lines for Audio Input

Here, data flows into the mixer from one or more input ports, commonly the microphone or the line-in jack. Gain and pan are applied, and the mixer delivers the captured data to an application program via the mixer's target data line. A target data line is a mixer output, containing the mixture of the streamed input sounds. The simplest mixer has just one target data line, but some mixers can deliver captured data to multiple target data lines simultaneously.

The Line Interface Hierarchy

Now that we've seen some functional pictures of what lines and mixers are, let's discuss them from a slightly more programmatic perspective. Several types of line are defined by subinterfaces of the basic Line interface. The interface hierarchy is shown below.

The Line Interface Hierarchy

The base interface, Line, describes the minimal functionality common to all lines:

  • Controls
    Data lines and ports often have a set of controls that affect the audio signal passing through the line. The Java Sound API specifies control classes that can be used to manipulate aspects of sound such as: gain (which affects the signal's volume in decibels), pan (which affects the sound's right-left positioning, reverb (which adds reverberation to the sound to emulate different kinds of room acoustics), and sample rate (which affects the rate of playback as well as the sound's pitch).
  • Open or closed status
    Successful opening of a line guarantees that resources have been allocated to the line. A mixer has a finite number of lines, so at some point multiple application programs (or the same one) might vie for usage of the mixer's lines. Closing a line indicates that any resources used by the line may now be released.
  • Events
    A line generates events when it opens or closes. Subinterfaces of Line can introduce other types of events. When a line generates an event, the event is sent to all objects that have registered to "listen" for events on that line. An application program can create these objects, register them to listen for line events, and react to the events as desired.

We'll now examine the subinterfaces of the Line interface.

Ports are simple lines for input or output of audio to or from audio devices. As mentioned earlier, some common types of ports are the microphone, line input, CD-ROM drive, speaker, headphone, and line output.

The Mixer interface represents a mixer, of course, which as we have seen represents either a hardware or a software device. The Mixer interface provides methods for obtaining a mixer's lines. These include source lines, which feed audio to the mixer, and target lines, to which the mixer delivers its mixed audio. For an audio-input mixer, the source lines are input ports such as the microphone input, and the target lines are TargetDataLines (described below), which deliver audio to the application program. For an audio-output mixer, on the other hand, the source lines are Clips or SourceDataLines (described below), to which the application program feeds audio data, and the target lines are output ports such as the speaker.

A Mixer is defined as having one or more source lines and one or more target lines. Note that this definition means that a mixer need not actually mix data; it might have only a single source line. The Mixer API is intended to encompass a variety of devices, but the typical case supports mixing.

The Mixer interface supports synchronization; that is, you can specify that two or more of a mixer's lines be treated as a synchronized group. Then you can start, stop, or close all those data lines by sending a single message to any line in the group, instead of having to control each line individually. With a mixer that supports this feature, you can obtain sample-accurate synchronization between lines.

The generic Line interface does not provide a means to start and stop playback or recording. For that you need a data line. The DataLine interface supplies the following additional media-related features beyond those of a Line:

  • Audio format
    Each data line has an audio format associated with its data stream.
  • Media position
    A data line can report its current position in the media, expressed in sample frames. This represents the number of sample frames captured by or rendered from the data line since it was opened.
  • Buffer size
    This is the size of the data line's internal buffer in bytes. For a source data line, the internal buffer is one to which data can be written, and for a target data line it's one from which data can be read.
  • Level (the current amplitude of the audio signal)

  • Start and stop playback or capture

  • Pause and resume playback or capture

  • Flush (discard unprocessed data from the queue)

  • Drain (block until all unprocessed data has been drained from the queue, and the data line's buffer has become empty)

  • Active status
    A data line is considered active if it is engaged in active presentation or capture of audio data to or from a mixer.
  • Events
    START and STOP events are produced when active presentation or capture of data from or to the data line starts or stops.

    • A TargetDataLine receives audio data from a mixer. Commonly, the mixer has captured audio data from a port such as a microphone; it might process or mix this captured audio before placing the data in the target data line's buffer. The TargetDataLine interface provides methods for reading the data from the target data line's buffer and for determining how much data is currently available for reading.

    A SourceDataLine receives audio data for playback. It provides methods for writing data to the source data line's buffer for playback, and for determining how much data the line is prepared to receive without blocking.

    A Clip is a data line into which audio data can be loaded prior to playback. Because the data is pre-loaded rather than streamed, the clip's duration is known before playback, and you can choose any starting position in the media. Clips can be looped, meaning that upon playback, all the data between two specified loop points will repeat a specified number of times, or indefinitely.

    This chapter has introduced most of the important interfaces and classes of the sampled-audio API. Subsequent chapters show how you can access and use these objects in your application program.


Chapter 4: Playing Back Audio

Playback is sometimes referred to as presentation or rendering. These are general terms that are applicable to other kinds of media besides sound. The essential feature is that a sequence of data is delivered somewhere for eventual perception by a user. If the data is time-based, as sound is, it must be delivered at the correct rate. With sound even more than video, it's important that the rate of data flow be maintained, because interruptions to sound playback often produce loud clicks or irritating distortion. The JavaTM Sound API is designed to help application programs play sounds smoothly and continuously, even very long sounds.

The previous chapter discussed how to obtain a line from the audio system or from a mixer. This chapter shows how to play sound through a line.

There are two kinds of line that you can use for playing sound: a Clip and a SourceDataLine. These two interfaces were introduced briefly under "The Line Interface Hierarchy" in Chapter 2, "Overview of the Sampled Package." The chief difference between the two is that with a Clip you specify all the sound data at one time, before playback, whereas with a SourceDataLine you keep writing new buffers of data continuously during playback. Although there are many situations in which you could use either a Clip or a SourceDataLine, the following criteria help identify which kind of line is better suited for a particular situation:

  • Use a Clip when you have non-real-time sound data that can be preloaded into memory.

    For example, you might read a short sound file into a clip. If you want the sound to play back more than once, a Clip is more convenient than a SourceDataLine, especially if you want the playback to loop (cycle repeatedly through all or part of the sound). If you need to start the playback at an arbitrary position in the sound, the Clip interface provides a method to do that easily. Finally, playback from a Clip generally has less latency than buffered playback from a SourceDataLine. In other words, because the sound is preloaded into a clip, playback can start immediately instead of having to wait for the buffer to be filled.

  • Use a SourceDataLine for streaming data, such as a long sound file that won't all fit in memory at once, or a sound whose data can't be known in advance of playback.

    As an example of the latter case, suppose you're monitoring sound input—that is, playing sound back as it's being captured. If you don't have a mixer that can send input audio right back out an output port, your application program will have to take the captured data and send it to an audio-output mixer. In this case, a SourceDataLine is more appropriate than a Clip. Another example of sound that can't be known in advance occurs when you synthesize or manipulate the sound data interactively in response to the user's input. For example, imagine a game that gives aural feedback by "morphing" from one sound to another as the user moves the mouse. The dynamic nature of the sound transformation requires the application program to update the sound data continuously during playback, instead of supplying it all before playback starts.

Using a Clip

You obtain a Clip as described earlier under "Getting a Line of a Desired Type" in Chapter 3, "Accessing Audio System Resources": Construct a DataLine.Info object with Clip.class for the first argument, and pass this DataLine.Info as an argument to the getLine method of AudioSystem or Mixer.

Setting Up the Clip for Playback

Obtaining a line just means you've gotten a way to refer to it; getLine doesn't actually reserve the line for you. Because a mixer might have a limited number of lines of the desired type available, it can happen that after you invoke getLine to obtain the clip, another application program jumps in and grabs the clip before you're ready to start playback. To actually use the clip, you need to reserve it for your program's exclusive use by invoking one of the following Clip methods:

   void open(AudioInputStream stream)
   void open(AudioFormat format, byte[] data, int offset,
   int bufferSize)
Despite the bufferSize argument in the second open method above, Clip (unlike SourceDataLine) includes no methods for writing new data to the buffer. The bufferSize argument here just specifies how much of the byte array to load into the clip. It's not a buffer into which you can subsequently load more data, as you can with a SourceDataLine's buffer.

After opening the clip, you can specify at what point in the data it should start playback, using Clip's setFramePosition or setMicroSecondPosition methods. Otherwise, it will start at the beginning. You can also configure the playback to cycle repeatedly, using the setLoopPoints method.

Starting and Stopping Playback

When you're ready to start playback, simply invoke the start method. To stop or pause the clip, invoke the stop method, and to resume playback, invoke start again. The clip remembers the media position where it stopped playback, so there's no need for explicit pause and resume methods. If you don't want it to resume where it left off, you can "rewind" the clip to the beginning (or to any other position, for that matter) using the frame- or microsecond-positioning methods mentioned above.

A Clip's volume level and activity status (active versus inactive) can be monitored by invoking the DataLine methods getLevel and isActive, respectively. An active Clip is one that is currently playing sound.

Using a SourceDataLine

Obtaining a SourceDataLine is similar to obtaining a Clip. See "Getting a Line of a Desired Type" in Chapter 3, "Accessing Audio System Resources."

Setting Up the SourceDataLine for Playback

Opening the SourceDataLine is also similar to opening a Clip, in that the purpose is once again to reserve the line. However, you use a different method, inherited from DataLine:

    void open(AudioFormat format)
Notice that when you open a SourceDataLine, you don't associate any sound data with the line yet, unlike opening a Clip. Instead, you just specify the format of the audio data you want to play. The system chooses a default buffer length.

You can also stipulate a certain buffer length in bytes, using this variant:

    void open(AudioFormat format, int bufferSize)
For consistency with similar methods, the buffersize argument is expressed in bytes, but it must correspond to an integral number of frames.

How would you select a buffer size? It depends on your program's needs.

To start with, shorter buffer sizes mean less latency. When you send new data, you hear it sooner. For some application programs, particularly highly interactive ones, this kind of responsiveness is important. For example, in a game, the onset of playback might need to be tightly synchronized with a visual event. Such programs might need a latency of less than 0.1 second. As another example, a conferencing application needs to avoid delays in both playback and capture. However, many application programs can afford a greater delay, up to a second or more, because it doesn't matter exactly when the sound starts playing, as long as the delay doesn't confuse or annoy the user. This might be the case for an application program that streams a large audio file using one-second buffers. The user probably won't care if playback takes a second to start, because the sound itself lasts so long and the experience isn't highly interactive.

On the other hand, shorter buffer sizes also mean a greater risk that you'll fail to write data fast enough into the buffer. If that happens, the audio data will contain discontinuities, which will probably be audible as clicks or breakups in the sound. Shorter buffer sizes also mean that your program has to work harder to keep the buffers filled, resulting in more intensive CPU usage. This can slow down the execution of other threads in your program, not to mention other programs.

So an optimal value for the buffer size is one that minimizes latency just to the degree that's acceptable for your application program, while keeping it large enough to reduce the risk of buffer underflow and to avoid unnecessary consumption of CPU resources. For a program like a conferencing application, delays are more annoying than low-fidelity sound, so a small buffer size is preferable. For streaming music, an initial delay is acceptable, but breakups in the sound are not. Thus for streaming music a larger buffer size—say, a second—is preferable. (Note that high sample rates make the buffers larger in terms of the number of bytes, which are the units for measuring buffer size in the DataLine API.)

Instead of using the open method described above, it's also possible to open a SourceDataLine using Line's open() method, without arguments. In this case, the line is opened with its default audio format and buffer size. However, you can't change these later. If you want to know the line's default audio format and buffer size, you can invoke DataLine's getFormat and getBufferSize methods, even before the line has ever been opened.

Starting and Stopping Playback

Once the SourceDataLine is open, you can start playing sound. You do this by invoking DataLine's start method, and then writing data repeatedly to the line's playback buffer.

The start method permits the line to begin playing sound as soon as there's any data in its buffer. You place data in the buffer by the following method:

    int write(byte[] b, int offset, int length)
The offset into the array is expressed in bytes, as is the array's length.

The line begins sending data as soon as possible to its mixer. When the mixer itself delivers the data to its target, the SourceDataLine generates a START event. (In a typical implementation of the Java Sound API, the delay between the moment that the source line delivers data to the mixer and the moment that the mixer delivers the data to its target is negligible—that is, much less than the time of one sample.) This START event gets sent to the line's listeners, as explained below under "Monitoring a Line's Status." The line is now considered active, so the isActive method of DataLine will return true. Notice that all this happens only once the buffer contains data to play, not necessarily right when the start method is invoked. If you invoked start on a new SourceDataLine but never wrote data to the buffer, the line would never be active and a START event would never be sent. (However, in this case, the isRunning method of DataLine would return true.)

So how do you know how much data to write to the buffer, and when to send the second batch of data? Fortunately, you don't need to time the second invocation of write to synchronize with the end of the first buffer! Instead, you can take advantage of the write method's blocking behavior:

  • The method returns as soon as the data has been written to the buffer. It doesn't wait until all the data in the buffer has finished playing. (If it did, you might not have time to write the next buffer without creating a discontinuity in the audio.)
  • It's all right to try to write more data than the buffer will hold. In this case, the method blocks (doesn't return) until all the data you requested has actually been placed in the buffer. In other words, one buffer's worth of your data at a time will be written to the buffer and played, until the remaining data all fits in the buffer, at which point the method returns. Whether or not the method blocks, it returns as soon as the last buffer's worth of data from this invocation can be written. Again, this means that your code will in all likelihood regain control before playback of the last buffer's worth of data has finished.
  • While in many contexts it is fine to write more data than the buffer will hold, if you want to be certain that the next write issued does not block, you can limit the number of bytes you write to the number that DataLine's available method returns.

Here's an example of iterating through chunks of data that are read from a stream, writing one chunk at a time to the SourceDataLine for playback:

// read chunks from a stream and write them to a source data
line
line.start();
while (total < totalToRead && !stopped)}
    numBytesRead = stream.read(myData, 0, numBytesToRead);
    if (numBytesRead == -1) break;
    total += numBytesRead;
    line.write(myData, 0, numBytesRead);

}
If you don't want the write method to block, you can first invoke the available method (inside the loop) to find out how many bytes can be written without blocking, and then limit the numBytesToRead variable to this number, before reading from the stream. In the example given, though, blocking won't matter much, since the write method is invoked inside a loop that won't complete until the last buffer is written in the final loop iteration. Whether or not you use the blocking technique, you'll probably want to invoke this playback loop in a separate thread from the rest of the application program, so that your program doesn't appear to freeze when playing a long sound. On each iteration of the loop, you can test whether the user has requested playback to stop. Such a request needs to set the stopped boolean, used in the code above, to true.

Since write returns before all the data has finished playing, how do you learn when the playback has actually completed? One way is to invoke the drain method of DataLine after writing the last buffer's worth of data. This method blocks until all the data has been played. When control returns to your program, you can free up the line, if desired, without fear of prematurely cutting off the playback of any audio samples:

line.write(b, offset, numBytesToWrite);
//this is the final invocation of write
line.drain();
line.stop();
line.close();
line = null;
You can intentionally stop playback prematurely, of course. For example, the application program might provide the user with a Stop button. Invoke DataLine's stop method to stop playback immediately, even in the middle of a buffer. This leaves any unplayed data in the buffer, so that if you subsequently invoke start, the playback resumes where it left off. If that's not what you want to happen, you can discard the data left in the buffer by invoking flush.

A SourceDataLine generates a STOP event whenever the flow of data has been stopped, whether this stoppage was initiated by the drain method, the stop method, or the flush method, or because the end of a playback buffer was reached before the application program invoked write again to provide new data. A STOP event doesn't necessarily mean that the stop method was invoked, and it doesn't necessarily mean that a subsequent invocation of isRunning will return false. It does, however, mean that isActive will return false. (When the start method has been invoked, the isRunning method will return true, even if a STOP event is generated, and it will begin to return false only once the stop method is invoked.) It's important to realize that START and STOP events correspond to isActive, not to isRunning.

Monitoring a Line's Status

Once you have started a sound playing, how do you find when it's finished? We saw one solution above—invoking the drain method after writing the last buffer of data—but that approach is applicable only to a SourceDataLine. Another approach, which works for both SourceDataLines and Clips, is to register to receive notifications from the line whenever the line changes its state. These notifications are generated in the form of LineEvent objects, of which there are four types: OPEN, CLOSE, START, and STOP.

Any object in your program that implements the LineListener interface can register to receive such notifications. To implement the LineListener interface, the object simply needs an update method that takes a LineEvent argument. To register this object as one of the line's listeners, you invoke the following Line method:

public void addLineListener(LineListener listener)

Whenever the line opens, closes, starts, or stops, it sends an update message to all its listeners. Your object can query the LineEvent that it receives. First you might invoke LineEvent.getLine to make sure the line that stopped is the one you care about. In the case we're discussing here, you want to know if the sound is finished, so you see whether the LineEvent is of type STOP. If it is, you might check the sound's current position, which is also stored in the LineEvent object, and compare it to the sound's length (if known) to see whether it reached the end and wasn't stopped by some other means (such as the user's clicking a Stop button, although you'd probably be able to determine that cause elsewhere in your code).

Along the same lines, if you need to know when the line is opened, closed, or started, you use the same mechanism. LineEvents are generated by different kinds of lines, not just Clips and SourceDataLines. However, in the case of a Port you can't count on getting an event to learn about a line's open or closed state. For example, a Port might be initially open when it's created, so you don't invoke the open method and the Port doesn't ever generate an OPEN event. (See "Selecting Input and Output Ports" in Chapter 3, "Accessing Audio System Resources.")

Synchronizing Playback on Multiple Lines

If you're playing back multiple tracks of audio simultaneously, you probably want to have them all start and stop at exactly the same time. Some mixers facilitate this behavior with their synchronize method, which lets you apply operations such as open, close, start, and stop to a group of data lines using a single command, instead of having to control each line individually. Furthermore, the degree of accuracy with which operations are applied to the lines is controllable.

To find out whether a particular mixer offers this feature for a specified group of data lines, invoke the Mixer interface's isSynchronizationSupported method:

boolean isSynchronizationSupported(Line[] lines,
  boolean  maintainSync)
The first parameter specifies a group of specific data lines, and the second parameter indicates the accuracy with which synchronization must be maintained. If the second parameter is true, the query is asking whether the mixer is capable of maintaining sample-accurate precision in controlling the specified lines at all times; otherwise, precise synchronization is required only during start and stop operations, not throughout playback.

Processing the Outgoing Audio

Some source data lines have signal-processing controls, such as gain, pan, reverb, and sample-rate controls. Similar controls, especially gain controls, might be present on the output ports as well. For more information on how to determine whether a line has such controls, and how to use them if it does, see Chapter 6, "Processing Audio with Controls."


Chapter 11: Playing, Recording and Editing MIDI Sequences

Note

With the 5.0 release, there is a new real-time Sequencer (implementation) that works with all Midi devices and, via its getTransmitter() method, an unlimited number of transmitters may be obtained. Prior to this release, it was not possible to get a Transmitter from a Sequencer.

In the world of MIDI, a sequencer is any hardware or software device that can precisely play or record a sequence of time-stamped MIDI messages. Similarly, in the JavaTM Sound API, the Sequencer abstract interface defines the properties of an object that can play and record Sequences of MidiEvent objects. A Sequencer typically loads these MidiEvent sequences from a standard MIDI file or saves them to such a file. Sequences can also be edited. This chapter explains how to use Sequencer objects, along with related classes and interfaces, to accomplish such tasks.

Introduction to Sequencers

To develop an intuitive understanding of what a Sequencer is, think of it by analogy with a tape recorder, which a sequencer resembles in many respects. Whereas a tape recorder plays audio, a sequencer plays MIDI data. A sequence is a multi-track, linear, time-ordered recording of MIDI musical data, which a sequencer can play at various speeds, rewind, shuttle to particular points, record into, or copy to a file for storage.

Chapter 10, "Transmitting and Receiving MIDI Messages," explained that devices typically have Receiver objects, Transmitter objects, or both. To play music, a device generally receives MidiMessages through a Receiver, which in turn has usually received them from a Transmitter that belongs to a Sequencer. The device that owns this Receiver might be a Synthesizer, which will generate audio directly, or it might be a MIDI output port, which transmits MIDI data through a physical cable to some external piece of equipment. Similarly, to record music, a series of time-stamped MidiMessages are generally sent to a Receiver owned by a Sequencer, which places them in a Sequence object. Typically the object sending the messages is a Transmitter associated with a hardware input port, and the port relays MIDI data that it gets from an external instrument. However, the device responsible for sending the messages might instead be some other Sequencer, or any other device that has a Transmitter. Furthermore, as mentioned in Chapter 10, a program can send messages without using any Transmitter at all.

A Sequencer itself has both Receivers and Transmitters. When it's recording, it actually obtains MidiMessages via its Receivers. During playback, it uses its Transmitters to send MidiMessages that are stored in the Sequence that it has recorded (or loaded from a file).

One way to think of the role of a Sequencer in the Java Sound API is as an aggregator and "de-aggregator" of MidiMessages. A series of separate MidiMessages, each of which is independent, is sent to the Sequencer along with its own time stamp that marks the timing of a musical event. These MidiMessages are encapsulated in MidiEvent objects and collected in Sequence objects through the action of the Sequencer.record method. A Sequence is a data structure containing aggregates of MidiEvents, and it usually represents a series of musical notes, often an entire song or composition. On playback, the Sequencer again extracts the MidiMessages from the MidiEvent objects in the Sequence and then transmits them to one or more devices that will either render them into sound, save them, modify them, or pass them on to some other device.

Some sequencers might have neither transmitters nor receivers. For example, they might create MidiEvents from scratch as a result of keyboard or mouse events, instead of receiving MidiMessages through Receivers. Similarly, they might play music by communicating directly with an internal synthesizer (which could actually be the same object as the sequencer) instead of sending MidiMessages to a Receiver associated with a separate object. However, the rest of this chapter assumes the normal case of a sequencer that uses Receivers and Transmitters.

When to Use a Sequencer

It's possible for an application program to send MIDI messages directly to a device, without using a sequencer, as was described in Chapter 10, "Transmitting and Receiving MIDI Messages." The program simply invokes the Receiver.send method each time it wants to send a message. This is a straightforward approach that's useful when the program itself creates the messages in real time. For example, consider a program that lets the user play notes by clicking on an onscreen piano keyboard. When the program gets a mouse-down event, it immediately sends the appropriate Note On message to the synthesizer.

As mentioned in Chapter 10, the program can include a time stamp with each MIDI message it sends to the device's receiver. However, such time stamps are used only for fine-tuning the timing, to correct for processing latency. The caller can't generally set arbitrary time stamps; the time value passed to Receiver.send must be close to the present time, or the receiving device might not be able to schedule the message correctly. This means that if an application program wanted to create a queue of MIDI messages for an entire piece of music ahead of time (instead of creating each message in response to a real-time event), it would have to be very careful to schedule each invocation of Receiver.send for nearly the right time.

Fortunately, most application programs don't have to be concerned with such scheduling. Instead of invoking Receiver.send itself, a program can use a Sequencer object to manage the queue of MIDI messages for it. The sequencer takes care of scheduling and sending the messages—in other words, playing the music with the correct timing. Generally, it's advantageous to use a sequencer whenever you need to convert a non-real-time series of MIDI messages to a real-time series (as in playback), or vice versa (as in recording). Sequencers are most commonly used for playing data from MIDI files and for recording data from a MIDI input port.

Understanding Sequence Data

Before examining the Sequencer API, it helps to understand the kind of data that's stored in a sequence.

Sequences and Tracks

In the Java Sound API, sequencers closely follow the Standard MIDI Files specification in the way that they organize recorded MIDI data. As mentioned above, a Sequence is an aggregation of MidiEvents, organized in time. But there is more structure to a Sequence than just a linear series of MidiEvents: a Sequence actually contains global timing information plus a collection of Tracks, and it is the Tracks themselves that hold the MidiEvent data. So the data played by a sequencer consists of a three-level hierarchy of objects: Sequencer, Track, and MidiEvent.

In the conventional use of these objects, the Sequence represents a complete musical composition or section of a composition, with each Track corresponding to a voice or player in the ensemble. In this model, all the data on a particular Track would also therefore be encoded into a particular MIDI channel reserved for that voice or player.

This way of organizing data is convenient for purposes of editing sequences, but note that this is just a conventional way to use Tracks. There is nothing in the definition of the Track class per se that keeps it from containing a mix of MidiEvents on different MIDI channels. For example, an entire multi-channel MIDI composition can be mixed and recorded onto one Track. Also, standard MIDI files of Type 0 (as opposed to Type 1 and Type 2) contain by definition only one track; so a Sequence that's read from such a file will necessarily have a single Track object.

MidiEvents and Ticks

As discussed in Chapter 8, "Overview of the MIDI Package," the Java Sound API includes MidiMessage objects that correspond to the raw two- or three-byte sequences that make up most standard MIDI messages. A MidiEvent is simply a packaging of a MidiMessage along with an accompanying timing value that specifies when the event occurs. (We might then say that a sequence really consists of a four- or five-level hierarchy of data, rather than three-level, because the ostensible lowest level, MidiEvent, actually contains a lower-level MidiMessage, and likewise the MidiMessage object contains an array of bytes that comprises a standard MIDI message.)

In the Java Sound API, there are two different ways in which MidiMessages can be associated with timing values. One is the way mentioned above under "When to Use a Sequencer." This technique is described in detail under "Sending a Message to a Receiver without Using a Transmitter" and "Understanding Time Stamps" in Chapter 10, "Transmitting and Receiving MIDI Messages." There, we saw that the send method of Receiver takes a MidiMessage argument and a time-stamp argument. That kind of time stamp can only be expressed in microseconds.

The other way in which a MidiMessage can have its timing specified is by being encapsulated in a MidiEvent. In this case, the timing is expressed in slightly more abstract units called ticks.

What is the duration of a tick? It can vary between sequences (but not within a sequence), and its value is stored in the header of a standard MIDI file. The size of a tick is given in one of two types of units:

  • Pulses (ticks) per quarter note, abbreviated as PPQ
  • Ticks per frame, also known as SMPTE time code (a standard adopted by the Society of Motion Picture and Television Engineers)

If the unit is PPQ, the size of a tick is expressed as a fraction of a quarter note, which is a relative, not absolute, time value. A quarter note is a musical duration value that often corresponds to one beat of the music (a quarter of a measure in 4/4 time). The duration of a quarter note is dependent on the tempo, which can vary during the course of the music if the sequence contains tempo-change events. So if the sequence's timing increments (ticks) occur, say 96 times per quarter note, each event's timing value measures that event's position in musical terms, not as an absolute time value.

On the other hand, in the case of SMPTE, the units measure absolute time, and the notion of tempo is inapplicable. There are actually four different SMPTE conventions available, which refer to the number of motion-picture frames per second. The number of frames per second can be 24, 25, 29.97, or 30. With SMPTE time code, the size of a tick is expressed as a fraction of a frame.

In the Java Sound API, you can invoke Sequence.getDivisionType to learn which type of unit—namely, PPQ or one of the SMPTE units—is used in a particular sequence. You can then calculate the size of a tick after invoking Sequence.getResolution. The latter method returns the number of ticks per quarter note if the division type is PPQ, or per SMPTE frame if the division type is one of the SMPTE conventions. You can get the size of a tick using this formula in the case of PPQ:

ticksPerSecond =
    resolution * (currentTempoInBeatsPerMinute / 60.0);
tickSize = 1.0 / ticksPerSecond;

and this formula in the case of SMPTE:

framesPerSecond =
  (divisionType == Sequence.SMPTE_24 ? 24
    : (divisionType == Sequence.SMPTE_25 ? 25
      : (divisionType == Sequence.SMPTE_30 ? 30
        : (divisionType == Sequence.SMPTE_30DROP ?

            29.97))));
ticksPerSecond = resolution * framesPerSecond;
tickSize = 1.0 / ticksPerSecond;

The Java Sound API's definition of timing in a sequence mirrors that of the Standard MIDI Files specification. However, there's one important difference. The tick values contained in MidiEvents measure cumulative time, rather than delta time. In a standard MIDI file, each event's timing information measures the amount of time elapsed since the onset of the previous event in the sequence. This is called delta time. But in the Java Sound API, the ticks aren't delta values; they're the previous event's time value plus the delta value. In other words, in the Java Sound API the timing value for each event is always greater than that of the previous event in the sequence (or equal, if the events are supposed to be simultaneous). Each event's timing value measures the time elapsed since the beginning of the sequence.

To summarize, the Java Sound API expresses timing information in either MIDI ticks or microseconds. MidiEvents store timing information in terms of MIDI ticks. The duration of a tick can be calculated from the Sequence's global timing information and, if the sequence uses tempo-based timing, the current musical tempo. The time stamp associated with a MidiMessage sent to a Receiver, on the other hand, is always expressed in microseconds.

One goal of this design is to avoid conflicting notions of time. It's the job of a Sequencer to interpret the time units in its MidiEvents, which might have PPQ units, and translate these into absolute time in microseconds, taking the current tempo into account. The sequencer must also express the microseconds relative to the time when the device receiving the message was opened. Note that a sequencer can have multiple transmitters, each delivering messages to a different receiver that might be associated with a completely different device. You can see, then, that the sequencer has to be able to perform multiple translations at the same time, making sure that each device receives time stamps appropriate for its notion of time.

To make matters more complicated, different devices might update their notions of time based on different sources (such as the operating system's clock, or a clock maintained by a sound card). This means that their timings can drift relative to the sequencer's. To keep in synchronization with the sequencer, some devices permit themselves to be "slaves" to the sequencer's notion of time. Setting masters and slaves is discussed later under "Using Advanced Sequencer Features."

Overview of Sequencer Methods

The Sequencer interface provides methods in several categories:

  • Methods to load sequence data from a MIDI file or a Sequence object, and to save the currently loaded sequence data to a MIDI file.
  • Methods analogous to the transport functions of a tape recorder, for stopping and starting playback and recording, enabling and disabling recording on specific tracks, and shuttling the current playback or recording position in a Sequence.
  • Advanced methods for querying and setting the synchronization and timing parameters of the object. A Sequencer may play at different tempos, with some Tracks muted, and in various synchronization states with other objects.
  • Advanced methods for registering "listener" objects that are notified when the Sequencer processes certain kinds of MIDI events.

Regardless of which Sequencer methods you'll invoke, the first step is to obtain a Sequencer device from the system and reserve it for your program's use.

Obtaining a Sequencer

An application program doesn't instantiate a Sequencer; after all, Sequencer is just an interface. Instead, like all devices in the Java Sound API's MIDI package, a Sequencer is accessed through the static MidiSystem object. As mentioned in Chapter 9, "Accessing MIDI System Resources," the following MidiSystem method can be used to obtain the default Sequencer:

    static Sequencer getSequencer()

The following code fragment obtains the default Sequencer, acquires any system resources it needs, and makes it operational:

    Sequencer sequencer;
    // Get default sequencer.
    sequencer = MidiSystem.getSequencer();
    if (sequencer == null) {
        // Error -- sequencer device is not supported.
        // Inform user and return...
    } else {
         // Acquire resources and make operational.
        sequencer.open();
    }

The invocation of open reserves the sequencer device for your program's use. It doesn't make much sense to imagine sharing a sequencer, because it can play only one sequence at a time. When you're done using the sequencer, you can make it available to other programs by invoking close.

Non-default sequencers can be obtained as described in Chapter 9, "Accessing MIDI System Resources."

Loading a Sequence

Having obtained a sequencer from the system and reserved it, you then need load the data that the sequencer should play. There are three typical ways of accomplishing this:

  • Reading the sequence data from a MIDI file
  • Recording it in real time by receiving MIDI messages from another device, such as a MIDI input port
  • Building it programmatically "from scratch" by adding tracks to an empty sequence and adding MidiEvent objects to those tracks

We'll now look at the first of these ways of getting sequence data. (The other two ways are described later under "Recording and Saving Sequences" and "Editing a Sequence," respectively.) This first way actually encompasses two slightly different approaches. One approach is to feed MIDI file data to an InputStream that you then read directly to the sequencer by means of Sequencer.setSequence(InputStream). With this approach, you don't explicitly create a Sequence object. In fact, the Sequencer implementation might not even create a Sequence behind the scenes, because some sequencers have a built-in mechanism for handling data directly from a file.

The other approach is to create a Sequence explicitly. You'll need to use this approach if you're going to edit the sequence data before playing it. With this approach, you invoke MidiSystem's overloaded method getSequence. The method is able to get the sequence from an InputStream, a File, or a URL. The method returns a Sequence object that can then be loaded into a Sequencer for playback. Expanding on the previous code excerpt, here's an example of obtaining a Sequence object from a File and loading it into our sequencer:

    try {
        File myMidiFile = new File("seq1.mid");
        // Construct a Sequence object, and
        // load it into my sequencer.
         Sequence mySeq = MidiSystem.getSequence(myMidiFile);
        sequencer.setSequence(mySeq);
    } catch (Exception e) {
        // Handle error and/or return
    }

Like MidiSystem's getSequence method, setSequence may throw an InvalidMidiDataException—and, in the case of the InputStream variant, an IOException—if it runs into any trouble.

Playing a Sequence

Starting and stopping a Sequencer is accomplished using the following methods:

    void start()

and

    void stop()

The Sequencer.start method begins playback of the sequence. Note that playback starts at the current position in a sequence. Loading an existing sequence using the setSequence method, described above, initializes the sequencer's current position to the very beginning of the sequence. The stop method stops the sequencer, but it does not automatically rewind the current Sequence. Starting a stopped Sequence without resetting the position simply resumes playback of the sequence from the current position. In this case, the stop method has served as a pause operation. However, there are various Sequencer methods for setting the current sequence position to an arbitrary value before playback is started. (We'll discuss these methods below.)

As mentioned earlier, a Sequencer typically has one or more Transmitter objects, through which it sends MidiMessages to a Receiver. It is through these Transmitters that a Sequencer plays the Sequence, by emitting appropriately timed MidiMessages that correspond to the MidiEvents contained in the current Sequence. Therefore, part of the setup procedure for playing back a Sequence is to invoke the setReceiver method on the Sequencer's Transmitter object, in effect wiring its output to the device that will make use of the played-back data. For more details on Transmitters and Receivers, see Chapter 10, "Transmitting and Receiving MIDI Messages."

Recording and Saving Sequences

To capture MIDI data to a Sequence, and subsequently to a file, you need to perform some additional steps beyond those described above. The following outline shows the steps necessary to set up for recording to a Track in a Sequence:

  1. Use MidiSystem.getSequencer to get a new sequencer to use for recording, as above.

  2. Set up the "wiring" of the MIDI connections. The object that is transmitting the MIDI data to be recorded should be configured, through its setReceiver method, to send data to a Receiver associated with the recording Sequencer.

  3. Create a new Sequence object, which will store the recorded data. When you create the Sequence object, you must specify the global timing information for the sequence. For example:
          Sequence mySeq;
      try{
          mySeq = new Sequence(Sequence.PPQ, 10);
      } catch (Exception ex) {
          ex.printStackTrace();
      }
    The constructor for Sequence takes as arguments a divisionType and a timing resolution. The divisionType argument specifies the units of the resolution argument. In this case, we've specified that the timing resolution of the Sequence we're creating will be 10 pulses per quarter note. An additional optional argument to the Sequence constructor is a number of tracks argument, which would cause the initial sequence to begin with the specified number of (initially empty) Tracks. Otherwise the Sequence will be created with no initial Tracks; they can be added later as needed.

  4. Create an empty Track in the Sequence, with Sequence.createTrack. This step is unnecessary if the Sequence was created with initial Tracks.

  5. Using Sequencer.setSequence, select our new Sequence to receive the recording. The setSequence method ties together an existing Sequence with the Sequencer, which is somewhat analogous to loading a tape onto a tape recorder.

  6. Invoke Sequencer.recordEnable for each Track to be recorded. If necessary, get a reference to the available Tracks in the Sequence by invoking Sequence.getTracks.

  7. Invoke startRecording on the Sequencer.

  8. When done recording, invoke Sequencer.stop or Sequencer.stopRecording.

  9. Save the recorded Sequence to a MIDI file with MidiSystem.write. The write method of MidiSystem takes a Sequence as one of its arguments, and will write that Sequence to a stream or file.

Editing a Sequence

Many application programs allow a sequence to be created by loading it from a file, and quite a few also allow a sequence to be created by capturing it from live MIDI input (that is, recording). Some programs, however, will need to create MIDI sequences from scratch, whether programmatically or in response to user input. Full-featured sequencer programs permit the user to manually construct new sequences, as well as to edit existing ones.

These data-editing operations are achieved in the Java Sound API not by Sequencer methods, but by methods of the data objects themselves: Sequence, Track, and MidiEvent. You can create an empty sequence using one of the Sequence constructors, and then add tracks to it by invoking the following Sequence method:

    Track createTrack()
If your program allows the user to edit sequences, you'll need this Sequence method to remove tracks:
    boolean deleteTrack(Track track)

Once the sequence contains tracks, you can modify the contents of the tracks by invoking methods of the Track class. The MidiEvents contained in the Track are stored as a java.util.Vector in the Track object, and Track provides a set of methods for accessing, adding, and removing the events in the list. The methods add and remove are fairly self-explanatory, adding or removing a specified MidiEvent from a Track. A get method is provided, which takes an index into the Track's event list and returns the MidiEvent stored there. In addition, there are size and tick methods, which respectively return the number of MidiEvents in the track, and the track's duration, expressed as a total number of Ticks.

To create a new event before adding it to the track, you'll of course use the MidiEvent constructor. To specify or modify the MIDI message embedded in the event, you can invoke the setMessage method of the appropriate MidiMessage subclass (ShortMessage, SysexMessage, or MetaMessage). To modify the time that the event should occur, invoke MidiEvent.setTick.

In combination, these low-level methods provide the basis for the editing functionality needed by a full-featured sequencer program.

Using Advanced Sequencer Features

So far, this chapter has focused on simple playback and recording of MIDI data. This section will briefly describe some of the more advanced features available through methods of the Sequencer interface and the Sequence class.

Moving to an Arbitrary Position in the Sequence

There are two Sequencer methods that obtain the sequencer's current position in the sequence. The first of these:

    long getTickPosition()

returns the position measured in MIDI ticks from the beginning of the sequence. The second method:

long getMicrosecondPosition()

returns the current position in microseconds. This method assumes that the sequence is being played at the default rate as stored in the MIDI file or in the Sequence. It does not return a different value if you've changed the playback speed as described below.

You can similarly set the sequencer's current position according to one unit or the other:

void setTickPosition(long tick)

or

void setMicrosecondPosition(long microsecond)

Changing the Playback Speed

As indicated earlier, a sequence's speed is indicated by its tempo, which can vary over the course of the sequence. A sequence can contain events that encapsulate standard MIDI tempo-change messages. When the sequencer processes such an event, it changes the speed of playback to reflect the indicated tempo. In addition, you can programmatically change the tempo by invoking any of these Sequencer methods:

    public void setTempoInBPM(float bpm)
    public void setTempoInMPQ(float mpq)
    public void setTempoFactor(float factor)
The first two of these methods set the tempo in beats per minute or microseconds per quarter note, respectively. The tempo will stay at the specified value until one of these methods is invoked again, or until a tempo-change event is encountered in the sequence, at which point the current tempo is overridden by the newly specified one.

The third method, setTempoFactor, is different in nature. It scales whatever tempo is set for the sequencer (whether by tempo-change events or by one of the first two methods above). The default scalar is 1.0 (no change). Although this method causes the playback or recording to be faster or slower than the nominal tempo (unless the factor is 1.0), it doesn't alter the nominal tempo. In other words, the tempo values returned by getTempoInBPM and getTempoInMPQ are unaffected by the tempo factor, even though the tempo factor does affect the actual rate of playback or recording. Also, if the tempo is changed by a tempo-change event or by one of the first two methods, it still gets scaled by whatever tempo factor was last set. If you load a new sequence, however, the tempo factor is reset to 1.0.

Note that all these tempo-change directives are ineffectual when the sequence's division type is one of the SMPTE types, instead of PPQ.

Muting or Soloing Individual Tracks in the Sequence

It's often convenient for users of sequencers to be able to turn off certain tracks, to hear more clearly exactly what is happening in the music. A full-featured sequencer program lets the user choose which tracks should sound during playback. (Speaking more precisely, since sequencers don't actually create sound themselves, the user chooses which tracks will contribute to the stream of MIDI messages that the sequencer produces.) Typically, there are two types of graphical controls on each track: a mute button and a solo button. If the mute button is activated, that track will not sound under any circumstances, until the mute button is deactivated. Soloing is a less well-known feature. It's roughly the opposite of muting. If the solo button on any track is activated, only tracks whose solo buttons are activated will sound. This feature lets the user quickly audition a small number of tracks without having to mute all the other tracks. The mute button typically takes priority over the solo button: if both are activated, the track doesn't sound.

Using Sequencer methods, muting or soloing tracks (as well as querying a track's current mute or solo state) is easily accomplished. Let's assume we have obtained the default Sequencer and that we've loaded sequence data into it. Muting the fifth track in the sequence would be accomplished as follows:

    sequencer.setTrackMute(4, true);
    boolean muted = sequencer.getTrackMute(4);
    if (!muted) {
        return;		// muting failed
    }
There are a couple of things to note about the above code snippet. First, tracks of a sequence are numbered starting with 0 and ending with the total number of tracks minus 1. Also, the second argument to setTrackMute is a boolean. If it's true, the request is to mute the track; otherwise the request is to unmute the specified track. Lastly, in order to test that the muting took effect, we invoke the Sequencer getTrackMute method, passing it the track number we're querying. If it returns true, as we'd expect in this case, then the mute request worked. If it returns false, then it failed.

Mute requests may fail for various reasons. For example, the track number specified in the setTrackMute call might exceed the total number of tracks, or the sequencer might not support muting. By calling getTrackMute, we can determine if our request succeeded or failed.

As an aside, the boolean that's returned by getTrackMute can, indeed, tell us if a failure occurred, but it can't tell us why it occurred. We could test to see if a failure was caused by passing an invalid track number to the setTrackMute method. To do this, we would call the getTracks method of Sequence, which returns an array containing all of the tracks in the sequence. If the track number specified in the setTrackMute call exceeds the length of this array, then we know we specified an invalid track number.

If the mute request succeeded, then in our example, the fifth track will not sound when the sequence is playing, nor will any other tracks that are currently muted.

The method and techniques for soloing a track are very similar to those for muting. To solo a track, invoke the setTrackSolo method of Sequence:

void setTrackSolo(int track, boolean bSolo)
As in setTrackMute, the first argument specifies the zero-based track number, and the second argument, if true, specifies that the track should be in solo mode; otherwise the track should not be soloed.

By default, a track is neither muted nor soloed.

Synchronizing with Other MIDI Devices

Sequencer has an inner class called Sequencer.SyncMode. A SyncMode object represents one of the ways in which a MIDI sequencer's notion of time can be synchronized with a master or slave device. If the sequencer is being synchronized to a master, the sequencer revises its current time in response to certain MIDI messages from the master. If the sequencer has a slave, the sequencer similarly sends MIDI messages to control the slave's timing.

There are three predefined modes that specify possible masters for a sequencer: INTERNAL_CLOCK, MIDI_SYNC, and MIDI_TIME_CODE. The latter two work if the sequencer receives MIDI messages from another device. In these two modes, the sequencer's time gets reset based on system real-time timing clock messages or MIDI time code (MTC) messages, respectively. (See the MIDI specification for more information about these types of message.) These two modes can also be used as slave modes, in which case the sequencer sends the corresponding types of MIDI messages to its receiver. A fourth mode, NO_SYNC, is used to indicate that the sequencer should not send timing information to its receivers.

By calling the setMasterSyncMode method with a supported SyncMode object as the argument, you can specify how the sequencer's timing is controlled. Likewise, the setSlaveSyncMode method determines what timing information the sequencer will send to its receivers. This information controls the timing of devices that use the sequencer as a master timing source.

Specifying Special Event Listeners

Each track of a sequence can contain many different kinds of MidiEvents. Such events include Note On and Note Off messages, program changes, control changes, and meta events. The Java Sound API specifies "listener" interfaces for the last two of these event types (control change events and meta events). You can use these interfaces to receive notifications when such events occur during playback of a sequence.

Objects that support the ControllerEventListener interface can receive notification when a Sequencer processes particular control-change messages. A control-change message is a standard type of MIDI message that represents a change in the value of a MIDI controller, such as a pitch-bend wheel or a data slider. (See the MIDI specification for the complete list of control-change messages.) When such a message is processed during playback of a sequence, the message instructs any device (probably a synthesizer) that's receiving the data from the sequencer to update the value of some parameter. The parameter usually controls some aspect of sound synthesis, such as the pitch of the currently sounding notes if the controller was the pitch-bend wheel. When a sequence is being recorded, the control-change message means that a controller on the external physical device that created the message has been moved, or that such a move has been simulated in software.

Here's how the ControllerEventListener interface is used. Let's assume that you've developed a class that implements the ControllerEventListener interface, meaning that your class contains the following method:

    void controlChange(ShortMessage msg)
Let's also assume that you've created an instance of your class and assigned it to a variable called myListener. If you include the following statements somewhere within your program:
    int[] controllersOfInterest = { 1, 2, 4 };
    sequencer.addControllerEventListener(myListener,
        controllersOfInterest);
then your class's controlChange method will be invoked every time the sequencer processes a control-change message for MIDI controller numbers 1, 2, or 4. In other words, when the Sequencer processes a request to set the value of any of the registered controllers, the Sequencer will invoke your class's controlChange method. (Note that the assignments of MIDI controller numbers to specific control devices is detailed in the MIDI 1.0 Specification.)

The controlChange method is passed a ShortMessage containing the controller number affected, and the new value to which the controller was set. You can obtain the controller number using the ShortMessage.getData1 method, and the new setting of the controller's value using the ShortMessage.getData2 method.

The other kind of special event listener is defined by the MetaEventListener interface. Meta messages, according to the Standard MIDI Files 1.0 specification, are messages that are not present in MIDI wire protocol but that can be embedded in a MIDI file. They are not meaningful to a synthesizer, but can be interpreted by a sequencer. Meta messages include instructions (such as tempo change commands), lyrics or other text, and other indicators (such as end-of-track).

The MetaEventListener mechanism is analogous to ControllerEventListener. Implement the MetaEventListener interface in any class whose instances need to be notified when a MetaMessage is processed by the sequencer. This involves adding the following method to the class:

void meta(MetaMessage msg)

You register an instance of this class by passing it as the argument to the Sequencer addMetaEventListener method:

boolean b = sequencer.addMetaEventListener
        (myMetaListener);
This is slightly different from the approach taken by the ControllerEventListener interface, because you have to register to receive all MetaMessages, not just selected ones of interest. If the sequencer encounters a MetaMessage in its sequence, it will invoke myMetaListener.meta, passing it the MetaMessage encountered. The meta method can invoke getType on its MetaMessage argument to obtain an integer from 0 to 127 that indicates the message type, as defined by the Standard MIDI Files 1.0 specification.


Preface

For Whom This Guide Is Intended

This guide is intended for three groups of readers:

  • Application developers: software programmers who want to write JavaTM applications or applets using audio or MIDI. Most readers will fall into this category.
  • Service providers: developers of software modules that extend the capabilities of an implementation of the Java Sound application programming interface (API). For example, a vendor might provide a new audio mixer or MIDI synthesizer, or the ability to read and write a new file format. The Java Sound API is designed to let programs automatically access all such "plug-in" modules available on a particular system.
  • API implementors: developers creating new implementations of the Java Sound API.

It is assumed that the reader has a basic knowledge of programming in the Java language. Familiarity with audio and MIDI is helpful but not assumed.

What This Guide Describes

This is a largely conceptual description of the Java Sound API, with some code snippets as programming examples. The Java Sound API specifies a software layer that allows application programs to communicate with an audio and MIDI engine. The Java Sound API is part of the JavaTM 2 Platform, Standard Edition (J2SE), version 1.3, which is the version described by this guide. The sound API is included in both the Java 2 Software Development Kit (SDK), Standard Edition, and the Java 2 Runtime Environment, Standard Edition. Earlier implementations of the Java Sound API were supplied as a separate products and their programming interfacea differ from the one described here.

Note:

This guide is not a description of any particular implementation of the Java Sound API. In particular, it does not specifically describe the reference implementation of the Java Sound API created by Sun Microsystems, Inc. For example, you will not find here a list of exactly which sound file formats are supported in the reference implementation. (Because the Java Sound API makes "plug-in" services possible, API implementors and/or third parties can add support for new formats, ports with special features, etc.) In general, this guide ignores unique features, extensions, limitations, or bugs of a particular implementation.

As a convenience for developers, it does make note of some current limitations of Sun's reference implemenation. If you are having problems, it is highly recommended that you consult:

  • Sun's Bug Database in the Java Developer Connection
  • Java Sound Home Page
  • Java Sound Reference Implementation Notes

For More Information

See the links to the Java Sound API reference documentation at http://java.sun.com/products/jdk/1.4/docs/guide/sound/. This Web site also includes a brief description of the reference implementation, as well as links to other resources about the Java Sound API, such as demo programs, mailing lists, and Frequently Answered Questions (FAQs). Also see the Java Sound Home Page mentioned above.

Copyright © 2000, Sun Microsystems Inc. All rights reserved.


Chapter 6: Processing Audio with Controls

Previous chapters have discussed how to play or capture audio samples. The implicit goal has been to deliver samples as faithfully as possible, without modification (other than possibly mixing the samples with those from other audio lines). Sometimes, however, you want to be able to modify the signal. The user might want it to sound louder, quieter, fuller, more reverberant, higher or lower in pitch, and so on. This chapter discusses the JavaTM Sound API features that provide these kinds of signal processing.

There are two ways to apply signal processing:

  • You can use any processing supported by the mixer or its component lines, by querying for Control objects and then setting the controls as the user desires. Typical controls supported by mixers and lines include gain, pan, and reverberation controls.

  • If the kind of processing you need isn't provided by the mixer or its lines, your program can operate directly on the audio bytes, manipulating them as desired.

This chapter discusses the first technique in greater detail, because there is no special API for the second technique.

Introduction to Controls

A mixer can have various sorts of signal-processing controls on some or all of its lines. For example, a mixer used for audio capture might have an input port with a gain control, and target data lines with gain and pan controls. A mixer used for audio playback might have sample-rate controls on its source data lines. In each case, the controls are all accessed through methods of the Line interface.

Because the Mixer interface extends Line, the mixer itself can have its own set of controls. These might serve as master controls affecting all the mixer's source or target lines. For example, the mixer might have a master gain control whose value in decibels is added to the values of individual gain controls on its target lines.

Others of the mixer's own controls might affect a special line, neither a source nor a target, that the mixer uses internally for its processing. For example, a global reverb control might choose the sort of reverberation to apply to a mixture of the input signals, and this "wet" (reverberated) signal would get mixed back into the "dry" signal before delivery to the mixer's target lines.

If the mixer or any of its lines have controls, you might wish to expose the controls via graphical objects in your program's user interface, so that the user can adjust the audio characteristics as desired. The controls are not themselves graphical; they just allow you to retrieve and change their settings. It's up to you to decide what sort of graphical representations (sliders, buttons, etc.), if any, to use in your program.

All controls are implemented as concrete subclasses of the abstract class Control. Many typical audio-processing controls can be described by abstract subclasses of Control based on a data type (such as boolean, enumerated, or float). Boolean controls, for example, represent binary-state controls, such as on/off controls for mute or reverb. Float controls, on the other hand, are well suited to represent continuously variable controls, such as pan, balance, or volume.

The Java Sound API specifies the following abstract subclasses of Control:

  • BooleanControl—represents a binary-state (true or false) control. For example, mute, solo, and on/off switches would be good candidates for BooleanControls.

  • FloatControl—data model providing control over a range of floating-point values. For example, volume and pan are FloatControls that could be manipulated via a dial or slider.

  • EnumControl—offers a choice from a set of objects. For example, you might associate a set of buttons in the user interface with an EnumControl to select one of several preset reverberation settings.

  • CompoundControl—provides access to a collection of related items, each of which is itself an instance of a Control subclass. CompoundControls represent multi-control modules such as graphic equalizers. (A graphic equalizer would typically be depicted by a set of sliders, each affecting a FloatControl.)

Each subclass of Control above has methods appropriate for its underlying data type. Most of the classes include methods that set and get the control's current value(s), get the control's label(s), and so on.

Of course, each class has methods that are particular to it and the data model represented by the class. For example, EnumControl has a method that lets you get the set of its possible values, and FloatControl permits you to get its minimum and maximum values, as well as the precision (increment or step size) of the control.

Each subclass of Control has a corresponding Control.Type subclass, which includes static instances that identify specific controls.

The following table shows each Control subclass, its corresponding Control.Type subclass, and the static instances that indicate specific kinds of controls:

Control | Control.Type | Control.Type instances
BooleanControl BooleanControl.Type

MUTE

Mute status of line

APPLY_REVERB

Reverberation on/off

CompoundControl | CompoundControl.Type | (none)
EnumControl EnumControl.Type REVERB

Access to reverb settings (each is an instance of ReverbType)

FloatControl FloatControl.Type AUX_RETURN

Auxiliary return gain on a line

AUX_SEND

Auxiliary send gain on a line

BALANCE

Left-right volume balance

MASTER_GAIN

Overall gain on a line

PAN

Left-right position

REVERB_RETURN

Post-reverb gain on a line

REVERB_SEND

Pre-reverb gain on a line

SAMPLE_RATE

Playback sample rate

VOLUME

Volume on a line

An implementation of the Java Sound API can provide any or all of these control types on its mixers and lines. It can also supply additional control types not defined in the Java Sound API. Such control types could be implemented via concrete subclasses of any of these four abstract subclasses, or via additional Control subclasses that don't inherit from any of these four abstract subclasses. An application program can query each line to find what controls it supports.

Getting a Line that Has the Desired Controls

In many cases, an application program will simply display whatever controls happen to be supported by the line in question. If the line doesn't have any controls, so be it. But what if it's important to find a line that has certain controls? In that case, you can use a Line.Info to obtain a line that has the right characteristics, as described under "Getting a Line of a Desired Type" in Chapter 3, "Accessing Audio System Resources."

For example, suppose you prefer an input port that lets the user set the volume of the sound input. The following code excerpt shows how one might query the default mixer to determine whether it has the desired port and control:

Port lineIn;
FloatControl volCtrl;
try {
  mixer = AudioSystem.getMixer(null);
  lineIn = (Port)mixer.getLine(Port.Info.LINE_IN);
  lineIn.open();
  volCtrl = (FloatControl) lineIn.getControl(

      FloatControl.Type.VOLUME);
  // Assuming getControl call succeeds,
  // we now have our LINE_IN VOLUME control.
} catch (Exception e) {
  System.out.println("Failed trying to find LINE_IN"
    + " VOLUME control: exception = " + e);
}
if (volCtrl != null)
  // ...

Getting the Controls from the Line

An application program that needs to expose controls in its user interface might simply query the available lines and controls, and then display an appropriate user-interface element for every control on every line of interest. In such a case, the program's only mission is to provide the user with "handles" on the control; not to know what those controls do to the audio signal. As long as the program knows how to map a line's controls into user-interface elements, the Java Sound API architecture of Mixer, Line, and Control will generally take care of the rest.

For example, suppose your program plays back sound. You're using a SourceDataLine, which you've obtained as described under "Getting a Line of a Desired Type" in Chapter 3, "Accessing Audio System Resources." You can access the line's controls by invoking the Line method:

Control[] getControls()
Then, for each of the controls in this returned array, you then use the following Control method to get the control's type:
Control.Type getType()
Knowing the specific Control.Type instance, your program can display a corresponding user-interface element. Of course, choosing "a corresponding user-interface element" for a specific Control.Type depends on the approach taken by your program. On the one hand, you might use the same kind of element to represent all Control.Type instances of the same class. This would require you to query the class of the Control.Type instance using, for example, the Object.getClass method. Let's say the result matched BooleanControl.Type. In this case, your program might display a generic checkbox or toggle button, but if its class matched FloatControl.Type, then you might display a graphic slider.

On the other hand, your program might distinguish between different types of controls—even those of the same class—and use a different user-interface element for each one. This would require you to test the instance returned by Control's getType method. Then if, for example, the type matched BooleanControl.Type.APPLY_REVERB, your program might display a checkbox; while if the type matched BooleanControl.Type.MUTE, you might instead display a toggle button.

Using a Control to Change the Audio Signal

Note

The current implementation requires that to change the value of a Control its corresponding Line must be open.

Now that you know how to access a control and determine its type, this section will describe how to use Controls to change aspects of the audio signal. This section doesn't cover every available control; rather, it provides a few examples in this area to show you how to get started. These example include:

  • Controlling a line's mute state
  • Changing a line's volume
  • Selecting among various reverberation presets

Suppose that your program has accessed all of its mixers, their lines and the controls on those lines, and that it has a data structure to manage the logical associations between the controls and their corresponding user-interface elements. Then, translating the user's manipulations of those controls into the corresponding Control methods becomes a fairly straightforward matter.

The following subsections describe some of the methods that must be invoked to affect the changes to specific controls.

Controlling a Line's Mute State

Controlling the mute state of any line is simply a matter of calling the following BooleanControl method:

void setValue(boolean value)
(Presumably, the program knows, by referring to its control-management data structures, that the mute is an instance of a BooleanControl.) To mute the signal that's passing through the line, the program invokes the method above, specifying true as the value. To turn muting off, permitting the signal to flow through the line, the program invokes the method with the parameter set to false.

Changing a Line's Volume

Let's assume your program associates a particular graphic slider with a particular line's volume control. The value of a volume control (i.e., FloatControl.Type.VOLUME) is set using the following FloatControl method:

void setValue(float newValue)
Detecting that the user moved the slider, the program gets the slider's current value and passes it, as the parameter newValue, to the method above. This changes the volume of the signal flowing though the line that "owns" the control.

Selecting among Various Reverberation Presets

Let's suppose that our program has a mixer with a line that has a control of type EnumControl.Type.REVERB. Calling the EnumControl method:

java.lang.Objects[] getValues()
on that control produces an array of ReverbType objects. If desired, the particular parameter settings of each of these objects can be accessed using the following ReverbType methods:
int getDecayTime()
int getEarlyReflectionDelay()
float getEarlyReflectionIntensity()
int getLateReflectionDelay()
float getLateReflectionIntensity()
For example, if a program only wants a single reverb setting that sounds like a cavern, it can iterate over the ReverbType objects until it finds one for which getDecayTime returns a value greater than 2000. For a thorough explanation of these methods, including a table of representative return values, see the API reference documentation for javax.sound.sampled.ReverbType.

Typically, though, a program will create a user-interface element, for example, a radio button, for each of the ReverbType objects within the array returned by the getValues method. When the user clicks on one of these radio buttons, the program invokes the EnumControl method

void setValue(java.lang.Object value)
where value is set to the ReverbType that corresponds to the newly engaged button. The audio signal sent through the line that "owns" this EnumControl will then be reverberated according to the parameter settings that constitute the control's current ReverbType (i.e., the particular ReverbType specified in the value argument of the setValue method).

So, from our application program's perspective, enabling a user to move from one reverberation preset (i.e., ReverbType) to another is simply a matter of connecting each element of the array returned by getValues to a distinct radio button.

Manipulating the Audio Data Directly

The Control API allows an implementation of the Java Sound API, or a third-party provider of a mixer, to supply arbitrary sorts of signal processing through controls. But what if no mixer offers the kind of signal processing you need? It will take more work, but you might be able to implement the signal processing in your program. Because the Java Sound API gives you access to the audio data as an array of bytes, you can alter these bytes in any way you choose.

If you're processing incoming sound, you can read the bytes from a TargetDataLine and then manipulate them. An algorithmically trivial example that can yield sonically intriguing results is to play a sound backwards by arranging its frames in reverse order. This trivial example may not be of much use for your program, but there are numerous sophisticated digital signal processing (DSP) techniques that might be more appropriate. Some examples are equalization, dynamic-range compression, peak limiting, and time stretching or compression, as well as special effects such as delay, chorus, flanging, distortion, and so on.

To play back processed sound, you can place your manipulated array of bytes into a SourceDataLine or Clip. Of course, the array of bytes need not be derived from an existing sound. You can synthesize sounds from scratch, although this requires some knowledge of acoustics or else access to sound-synthesis functions. For either processing or synthesis, you may want to consult an audio DSP textbook for the algorithms in which you're interested, or else import a third-party library of signal-processing functions into your program. For playback of synthesized sound, consider whether the Synthesizer API in the javax.sound.midi package meets your needs instead. (See Chapter 12, "Synthesizing Sound.")


Chapter 15: Providing MIDI Services

Chapter 13, "Introduction to the Service Provider Interfaces," explained that the javax.sound.sampled.spi and javax.sound.midi.spi packages define abstract classes to be used by developers of sound services. By implementing a subclass of one of these abstract classes, a service provider can create a new service that extends the functionality of the runtime system. Chapter 14 covered the use of the javax.sound.sampled.spi package. The present chapter discusses how to use the javax.sound.midi.spi package to provide new services for handling MIDI devices and files.

Applications programmers who only use existing MIDI services in their programs can safely skip this chapter. For an overview of MIDI and the use of the installed MIDI services in an application program, see Part II, "MIDI," of this Programmer's Guide. This chapter assumes that the reader is familiar with the JavaTM Sound API methods that application programs invoke to access installed MIDI services.

Introduction

There are four abstract classes in the javax.sound.midi.spi package, which represent four different types of services that you can provide for the MIDI system:

  • MidiFileWriter provides MIDI file-writing services. These services make it possible for an application program to save, to a MIDI file, a MIDI Sequence that it has generated or processed.
  • MidiFileReader provides file-reading services that return a MIDI Sequence from a MIDI file for use in an application program.
  • MidiDeviceProvider supplies instances of one or more specific types of MIDI device, possibly including hardware devices.
  • SoundbankReader supplies soundbank file-reading services. Concrete subclasses of SoundbankReader parse a given soundbank file, producing a Soundbank object that can be loaded into a Synthesizer.

An application program will not directly create an instance of a service object—whether a provider object, such as a MidiDeviceProvider, or an object, such as a Synthesizer, that is supplied by the provider object. Nor will the program directly refer to the SPI classes. Instead, the application program makes requests to the MidiSystem object in the javax.sound.midi package, and MidiSystem in turn uses concrete subclasses of the javax.sound.midi.spi classes to process these requests.

Providing MIDI File-Writing Services

There are three standard MIDI file formats, all of which an implementation of the Java Sound API can support: Type 0, Type 1, and Type 2. These file formats differ in their internal representation of the MIDI sequence data in the file, and are appropriate for different kinds of sequences. If an implementation doesn't itself support all three types, a service provider can supply the support for the unimplemented ones. There are also variants of the standard MIDI file formats, some of them proprietary, which similarly could be supported by a third-party vendor.

The ability to write MIDI files is provided by concrete subclasses of MidiFileWriter. This abstract class is directly analogous to javax.sampled.spi.AudioFileWriter. Again, the methods are grouped into query methods for learning what types of files can be written, and methods for actually writing a file. As with AudioFileWriter, two of the query methods are concrete:

boolean isFileTypeSupported(int fileType)
boolean isFileTypeSupported(int fileType, Sequence sequence)
The first of these provides general information about whether the file writer can ever write the specified type of MIDI file type. The second method is more specific: it asks whether a particular Sequence can be written to the specified type of MIDI file. Generally, you don't need to override either of these two concrete methods. In the default implementation, each invokes one of two other corresponding query methods and iterates over the results returned. Being abstract, these other two query methods need to be implemented in the subclass:
abstract int[] getMidiFileTypes()
abstract int[] getMidiFileTypes(Sequence sequence)
The first of these returns an array of all the file types that are supported in general. A typical implementation might initialize the array in the file writer's constructor and return the array from this method. From that set of file types, the second method finds the subset to which the file writer can write the given Sequence. In accordance with the MIDI specification, not all types of sequences can be written to all types of MIDI files.

The write methods of a MidiFileWriter subclass perform the encoding of the data in a given Sequence into the correct data format for the requested type of MIDI file, writing the coded stream to either a file or an output stream:

abstract int write(Sequence in, int fileType,
                   java.io.File out)
abstract int write(Sequence in, int fileType,
                   java.io.OutputStream out)
To do this, the write method must parse the Sequence by iterating over its tracks, construct an appropriate file header, and write the header and tracks to the output. The MIDI file's header format is, of course, defined by the MIDI specification. It includes such information as a "magic number" identifying this as a MIDI file, the header's length, the number of tracks, and the sequence's timing information (division type and resolution). The rest of the MIDI file consists of the track data, in the format defined by the MIDI specification.

Let's briefly look at how the application program, MIDI system, and service provider cooperate in writing a MIDI file. In a typical situation, an application program has a particular MIDI Sequence to save to a file. The program queries the MidiSystem object to see what MIDI file formats, if any, are supported for the particular Sequence at hand, before attempting to write the file. The MidiSystem.getMidiFileTypes(Sequence) method returns an array of all the MIDI file types to which the system can write a particular sequence. It does this by invoking the corresponding getMidiFileTypes method for each of the installed MidiFileWriter services, and collecting and returning the results in an array of integers that can be thought of as a master list of all file types compatible with the given Sequence. When it comes to writing the Sequence to a file, the call to MidiSystem.write is passed an integer representing a file type, along with the Sequence to be written and the output file; MidiSystem uses the supplied type to decide which installed MidiFileWriter should handle the write request, and dispatches a corresponding write to the appropriate MidiFileWriter.

Providing MIDI File-Reading Services

The MidiFileReader abstract class is directly analogous to javax.sampled.spi.AudioFileReader class. Both consist of two overloaded methods, each of which can take a File, URL, or InputStream argument. The first of the overloaded methods returns the file format of a specified file. In the case of MidiFileReader, the API is:

abstract MidiFileFormat getMidiFileFormat(java.io.File file)
abstract MidiFileFormat getMidiFileFormat(
    java.io.InputStream stream)
abstract MidiFileFormat getMidiFileFormat(java.net.URL url)
Concrete subclasses must implement these methods to return a filled-out MidiFileFormat object describing the format of the specified MIDI file (or stream or URL), assuming that the file is of a type supported by the file reader and that it contains valid header information. Otherwise, an InvalidMidiDataException should be thrown.

The other overloaded method returns a MIDI Sequence from a given file, stream, or URL :

abstract Sequence getSequence(java.io.File file)
abstract Sequence getSequence(java.io.InputStream stream)
abstract Sequence getSequence(java.net.URL url)
The getSequence method performs the actual work of parsing the bytes in the MIDI input file and constructing a corresponding Sequence object. This is essentially the inverse of the process used by MidiFileWriter.write. Because there is a one-to-one correspondence between the contents of a MIDI file as defined by the MIDI specification and a Sequence object as defined by the Java Sound API, the details of the parsing are straightforward. If the file passed to getSequence contains data that the file reader can't parse (for example, because the file has been corrupted or doesn't conform to the MIDI specification), an InvalidMidiDataException should be thrown.

Providing Particular MIDI Devices

A MidiDeviceProvider can be considered a factory that supplies one or more particular types of MIDI device. The class consists of a method that returns an instance of a MIDI device, as well as query methods to learn what kinds of devices this provider can supply.

As with the other javax.sound.midi.spi services, application developers get indirect access to a MidiDeviceProvider service through a call to MidiSystem methods, in this case MidiSystem.getMidiDevice and MidiSystem.getMidiDeviceInfo. The purpose of subclassing MidiDeviceProvider is to supply a new kind of device, so the service developer must also create an accompanying class for the device being returned—just as we saw with MixerProvider in the javax.sound.sampled.spi package. There, the returned device's class implemented the javax.sound.sampled.Mixer interface; here it implements the javax.sound.midi.MidiDevice interface. It might also implement a subinterface of MidiDevice, such as Synthesizer or Sequencer.

Because a single subclass of MidiDeviceProvider can provide more than one type of MidiDevice, the getDeviceInfo method of the class returns an array of MidiDevice.Info objects enumerating the different MidiDevices available:

abstract MidiDevice.Info[] getDeviceInfo()

The returned array can contain a single element, of course. A typical implementation of the provider might initialize an array in its constructor and return it here. This allows MidiSystem to iterate over all installed MidiDeviceProviders to construct a list of all installed devices. MidiSystem can then return this list (MidiDevice.Info[] array) to an application program.

MidiDeviceProvider also includes a concrete query method:

boolean isDeviceSupported(MidiDevice.Info info)
This method permits the system to query the provider about a specific kind of device. Generally, you don't need to override this convenience method. The default implementation iterates over the array returned by getDeviceInfo and compares the argument to each element.

The third and final MidiDeviceProvider method returns the requested device:

abstract MidiDevice getDevice(MidiDevice.Info info)
This method should first test the argument to make sure it describes a device that this provider can supply. If it doesn't, it should throw an IllegalArgumentException. Otherwise, it returns the device.

Providing Soundbank File-Reading Services

A SoundBank is a set of Instruments that can be loaded into a Synthesizer. An Instrument is an implementation of a sound-synthesis algorithm that produces a particular sort of sound, and includes accompanying name and information strings. A SoundBank roughly corresponds to a bank in the MIDI specification, but it's a more extensive and addressable collection; it can perhaps better be thought of as a collection of MIDI banks. (For more background information on SoundBanks and Synthesizers, see Chapter 12, "Synthesizing Sound.")

SoundbankReader consists of a single overloaded method, which the system invokes to read a Soundbank object from a soundbank file:

abstract Soundbank getSoundbank(java.io.File file)
abstract Soundbank getSoundbank(java.io.InputStream stream)
abstract Soundbank getSoundbank(java.net.URL url)

Concrete subclasses of SoundbankReader will work in tandem with particular provider-defined implementations of SoundBank, Instrument, and Synthesizer to allow the system to load a SoundBank from a file into an instance of a particular Synthesizer class. Synthesis techniques may differ wildly from one Synthesizer to another, and, as a consequence, the data stored in an Instrument or SoundBank providing control or specification data for the synthesis process of a Synthesizer can take a variety of forms. One synthesis technique may require only a few bytes of parameter data; another may be based on extensive sound samples. The resources present in a SoundBank will depend upon the nature of the Synthesizer into which they get loaded, and therefore the implementation of the getSoundbank method of a SoundbankReader subclass has access to knowledge of a particular kind of SoundBank. In addition, a particular subclass of SoundbankReader understands a particular file format for storing the SoundBank data. That file format may be vendor-specific and proprietary.

SoundBank is just an interface, with only weak constraints on the contents of a SoundBank object. The methods an object must support to implement this interface (getResources, getInstruments, getVendor, getName, etc.) impose loose requirements on the data that the object contains. For example, getResources and getInstruments can return empty arrays. The actual contents of a subclassed SoundBank object, in particular its instruments and its non-instrument resources, are defined by the service provider. Thus, the mechanism of parsing a soundbank file depends entirely on the specification of that particular kind of soundbank file.

Soundbank files are created outside the Java Sound API, typically by the vendor of the synthesizer that can load that kind of soundbank. Some vendors might supply end-user tools for creating such files.


Chapter 14: Providing Sampled-Audio Services

As discussed in Chapter 13, "Introduction to the Service Provider Interfaces," the JavaTM Sound API includes two packages, javax.sound.sampled.spi and javax.sound.midi.spi, that define abstract classes to be used by developers of sound services. By implementing and installing a subclass of one of these abstract classes, a service provider registers the new service, extending the functionality of the runtime system. The present chapter tells you how to go about using the javax.sound.sampled.spi package to provide new services for handling sampled audio.

This chapter can be safely skipped by application programmers who merely wish to use existing audio services in their programs. For the use of the installed audio services in an application program, see Part I, "Sampled Audio," of this Programmer's Guide. This chapter assumes that the reader is familiar with the JavaTM Sound API methods that application programs invoke to access installed audio services.

Introduction

There are four abstract classes in the javax.sound.sampled.spi package, representing four different types of services that you can provide for the sampled-audio system:

  • AudioFileWriter provides sound file-writing services. These services make it possible for an application program to write a stream of audio data to a file of a particular type.
  • AudioFileReader provides file-reading services. These services enable an application program to ascertain a sound file's characteristics, and to obtain a stream from which the file's audio data can be read.
  • FormatConversionProvider provides services for converting audio data formats. These services allow an application program to translate audio streams from one data format to another.
  • MixerProvider provides management of a particular kind of mixer. This mechanism allows an application program to obtain information about, and access instances of, a given kind of mixer.

To recapitulate the discussion in Chapter 13, service providers can extend the functionality of the runtime system. A typical SPI class has two types of methods: ones that respond to queries about the types of services available from a particular provider, and ones that either perform the new service directly, or return instances of objects that actually provide the service. The runtime environment's service-provider mechanism provides registration of installed services with the audio system, and management of the new service provider classes.

In essence there is a double isolation of the service instances from the application developer. An application program never directly creates instances of the service objects, such as mixers or format converters, that it needs for its audio processing tasks. Nor does the program even directly request these objects from the SPI classes that administer them. The application program makes requests to the AudioSystem object in the javax.sound.sampled package, and AudioSystem in turn uses the SPI objects to process these queries and service requests.

The existence of new audio services might be completely transparent to both the user and the application programmer. All application references are through standard objects of the javax.sound.sampled package, primarily AudioSystem, and the special handling that new services might be providing is often completely hidden.

In this chapter, we'll continue the previous chapter's convention of referring to new SPI subclasses by names like AcmeMixer and AcmeMixerProvider.

Providing Audio File-Writing Services

Let's start with AudioFileWriter, one of the simpler SPI classes.

A subclass that implements the methods of AudioFileWriter must provide implementations of a set of methods to handle queries about the file formats and file types supported by the class, as well as provide methods that actually write out a supplied audio data stream to a File or OutputStream.

AudioFileWriter includes two methods that have concrete implementations in the base class:

boolean isFileTypeSupported(AudioFileFormat.Type fileType)
boolean isFileTypeSupported(AudioFileFormat.Type fileType,
    AudioInputStream stream)
The first of these methods informs the caller whether this file writer can write sound files of the specified type. This method is a general inquiry, it will return true if the file writer can write that kind of file, assuming the file writer is handed appropriate audio data. However, the ability to write a file can depend on the format of the specific audio data that's handed to the file writer. A file writer might not support every audio data format, or the constraint might be imposed by the file format itself. (Not all kinds of audio data can be written to all kinds of sound files.) The second method is more specific, then, asking whether a particular AudioInputStream can be written to a particular type of file.

Generally, you won't need to override these two concrete methods. Each is simply a wrapper that invokes one of two other query methods and iterates over the results returned. These other two query methods are abstract and therefore need to be implemented in the subclass:

abstract AudioFileFormat.Type[] getAudioFileTypes()
abstract AudioFileFormat.Type[]
    getAudioFileTypes(AudioInputStream stream)
These methods correspond directly to the previous two. Each returns an array of all the supported file types-all that are supported in general, in the case of the first method, and all that are supported for a specific audio stream, in the case of the second method. A typical implementation of the first method might simply return an array that the file writer's constructor initializes. An implementation of the second method might test the stream's AudioFormat object to see whether it's a data format that the requested type of file supports.

The final two methods of AudioFileWriter do the actual file-writing work:

abstract  int write(AudioInputStream stream,
    AudioFileFormat.Type fileType, java.io.File out)
 abstract  int write(AudioInputStream stream,
    AudioFileFormat.Type fileType, java.io.OutputStream out)
These methods write a stream of bytes representing the audio data to the stream or file specified by the third argument. The details of how this is done depend on the structure of the specified type of file. The write method must write the file's header and the audio data in the manner prescribed for sound files of this format (whether it's a standard type of sound file or a new, possibly proprietary one).

Providing Audio File-Reading Services

The AudioFileReader class consists of six abstract methods that your subclass needs to implement-actually, two different overloaded methods, each of which can take a File, URL, or InputStream argument. The first of these overloaded methods accepts queries about the file format of a specified file:

abstract AudioFileFormat getAudioFileFormat(
    java.io.File file)
abstract AudioFileFormat getAudioFileFormat(
    java.io.InputStream stream)
abstract AudioFileFormat getAudioFileFormat(
    java.net.URL url)
A typical implementation of getAudioFileFormat method reads and parses the sound file's header to ascertain its file format. See the description of the AudioFileFormat class to see what fields need to be read from the header, and refer to the specification for the particular file type to figure out how to parse the header.

Because the caller providing a stream as an argument to this method expects the stream to be unaltered by the method, the file reader should generally start by marking the stream. After reading to the end of the header, it should reset the stream to its original position.

The other overloaded AudioFileReader method provides file-reading services, by returning an AudioInputStream from which the file's audio data can be read:

abstract AudioInputStream getAudioInputStream(
    java.io.File file)
abstract AudioInputStream getAudioInputStream(
     java.io.InputStream stream)
abstract AudioInputStream getAudioInputStream(
     java.net.URL url)
Typically, an implementation of getAudioInputStream returns an AudioInputStream wound to the beginning of the file's data chunk (after the header), ready for reading. It would be conceivable, though, for a file reader to return an AudioInputStream whose audio format represents a stream of data that is in some way decoded from what is contained in the file. The important thing is that the method return a formatted stream from which the audio data contained in the file can be read. The AudioFormat encapsulated in the returned AudioInputStream object will inform the caller about the stream's data format, which is usually, but not necessarily, the same as the data format in the file itself.

Generally, the returned stream is an instance of AudioInputStream; it's unlikely you would ever need to subclass AudioInputStream.

Providing Format-Conversion Services

A FormatConversionProvider subclass transforms an AudioInputStream that has one audio data format into one that has another format. The former (input) stream is referred to as the source stream, and the latter (output) stream is referred to as the target stream. Recall from Chapter 2, "Overview of the Sampled Package," that an AudioInputStream contains an AudioFormat, and the AudioFormat in turn contains a particular type of data encoding, represented by an AudioFormat.Encoding object. The format and encoding in the source stream are called the source format and source encoding, and those in the target stream are likewise called the target format and target encoding.

The work of conversion is performed in the overloaded abstract method of FormatConversionProvider called getAudioInputStream. The class also has abstract query methods for learning about all the supported target and source formats and encodings. There are concrete wrapper methods for querying about a specific conversion.

The two variants of getAudioInputStream are:

abstract AudioInputStream getAudioInputStream(
    AudioFormat.Encoding targetEncoding,
    AudioInputStream sourceStream)
and
abstract AudioInputStream getAudioInputStream(
    AudioFormat targetFormat,
    AudioInputStream sourceStream)
These differ in the first argument, according to whether the caller is specifying a complete target format or just the format's encoding.

A typical implementation of getAudioInputStream works by returning a new subclass of AudioInputStream that wraps around the original (source) AudioInputStream and applies a data format conversion to its data whenever a read method is invoked. For example, consider the case of a new FormatConversionProvider subclass called AcmeCodec, which works with a new AudioInputStream subclass called AcmeCodecStream.

The implementation of AcmeCodec's second getAudioInputStream method might be:

public AudioInputStream getAudioInputStream
      (AudioFormat outputFormat, AudioInputStream stream) {
        AudioInputStream cs = null;
        AudioFormat inputFormat = stream.getFormat();
        if (inputFormat.matches(outputFormat) ) {
            cs = stream;
        } else {
            cs = (AudioInputStream)
                (new AcmeCodecStream(stream, outputFormat));
            tempBuffer = new byte[tempBufferSize];
        }
        return cs;
    }
The actual format conversion takes place in new read methods of the returned AcmeCodecStream, a subclass of AudioInputStream. Again, application programs that access this returned AcmeCodecStream simply operate on it as an AudioInputStream, and don't need to know the details of its implementation.

The other methods of a FormatConversionProvider all permit queries about the input and output encodings and formats that the object supports. The following four methods, being abstract, need to be implemented:

abstract AudioFormat.Encoding[] getSourceEncodings()
abstract AudioFormat.Encoding[] getTargetEncodings()
abstract AudioFormat.Encoding[] getTargetEncodings(
    AudioFormat sourceFormat)
abstract  AudioFormat[] getTargetFormats(
    AudioFormat.Encoding targetEncoding,
    AudioFormat sourceFormat)

As in the query methods of the AudioFileReader class discussed above, these queries are typically handled by checking private data of the object and, for the latter two methods, comparing them against the argument(s).

The remaining four FormatConversionProvider methods are concrete and generally don't need to be overridden:

boolean isConversionSupported(
    AudioFormat.Encoding targetEncoding,
    AudioFormat sourceFormat)
boolean isConversionSupported(AudioFormat targetFormat,
    AudioFormat sourceFormat)
boolean isSourceEncodingSupported(
    AudioFormat.Encoding sourceEncoding)
boolean isTargetEncodingSupported(
    AudioFormat.Encoding targetEncoding)
As with AudioFileWriter.isFileTypeSupported(), the default implementation of each of these methods is essentially a wrapper that invokes one of the other query methods and iterates over the results returned.

Providing New Types of Mixers

As its name implies, a MixerProvider supplies instances of mixers. Each concrete MixerProvider subclass acts as a factory for the Mixer objects used by an application program. Of course, defining a new MixerProvider only makes sense if one or more new implementations of the Mixer interface are also defined. As in the FormatConversionProvider example above, where our getAudioInputStream method returned a subclass of AudioInputStream that performed the conversion, our new class AcmeMixerProvider has a method getMixer that returns an instance of another new class that implements the Mixer interface. We'll call the latter class AcmeMixer. Particularly if the mixer is implemented in hardware, the provider might support only one static instance of the requested device. If so, it should return this static instance in response to each invocation of getMixer.

Since AcmeMixer supports the Mixer interface, application programs don't require any additional information to access its basic functionality. However, if AcmeMixer supports functionality not defined in the Mixer interface, and the vendor wants to make this extended functionality accessible to application programs, the mixer should of course be defined as a public class with additional, well-documented public methods, so that a program that wishes to make use of this extended functionality can import AcmeMixer and cast the object returned by getMixer to this type.

The other two methods of MixerProvider are:

abstract Mixer.Info[] getMixerInfo()
and
boolean isMixerSupported(Mixer.Info info)
These methods allow the audio system to determine whether this particular provider class can produce a device that an application program needs. In other words, the AudioSystem object can iterate over all the installed MixerProviders to see which ones, if any, can supply the device that the application program has requested of the AudioSystem. (See the discussion under "Getting a Mixer" in Chapter 3, "Accessing Audio System Resources.") The getMixerInfo method returns an array of objects containing information about the kinds of mixer available from this provider object. The system can pass these information objects, along with those from other providers, to an application program.

A single MixerProvider can provide more than one kind of mixer. When the system invokes the MixerProvider's getMixerInfo method, it gets a list of information objects identifying the different kinds of mixer that this provider supports. The system can then invoke MixerProvider.getMixer(Mixer.Info) to obtain each mixer of interest.

Your subclass needs to implement getMixerInfo, as it's abstract. The isMixerSupported method is concrete and doesn't generally need to be overridden. The default implementation simply compares the provided Mixer.Info to each one in the array returned by getMixerInfo.


sound.properties File

Appendix 2: sound.properties File

The Java Sound Configuration file, sound.properties, can be used to specify default service providers for javax.sound.sampled.AudioSystem and javax.sound.midi.MidiSystem.

Properties Keys

The following keys are recognized by AudioSystem methods:

javax.sound.sampled.Clip
javax.sound.sampled.Port
javax.sound.sampled.SourceDataLine
javax.sound.sampled.TargetDataLine

The following keys are recognized by MidiSystem methods:

javax.sound.midi.Sequencer
javax.sound.midi.Synthesizer
javax.sound.midi.Transmitter
javax.sound.midi.Receiver

The values should specify the full class name of the service provider and/or the device name.

sound.properties is located at $JAVAHOME/jre/lib in the Sun implementation.

For more details, see the class descriptions for AudioSystem and MidiSystem.

Examples

To use MyDeviceProvider as the default for SourceDataLine lines, set the following key:

javax.sound.sampled.SourceDataLine=com.xyz.MyDeviceProvider

To specify the default Synthesizer by its name InternalSynth, set the following key:

javax.sound.midi.Synthesizer=#InternalSynth

To specify the default Receiver by provider and name, set the following key:

javax.sound.midi.Receiver=com.sun.media.sound.MidiProvider#SunMIDI1


Chapter 12: Synthesizing Sound

Most programs that avail themselves of the JavaTM Sound API's MIDI package do so to synthesize sound. The entire apparatus of MIDI files, events, sequences, and sequencers, which was discussed in other chapters, nearly always has the goal of eventually sending musical data to a synthesizer to convert into audio. (Possible exceptions include programs that convert MIDI into musical notation that can be read by a musician, and programs that send messages to external MIDI-controlled devices such as mixing consoles.)

The Synthesizer interface is therefore fundamental to the MIDI package. This chapter shows how to manipulate a synthesizer to play sound. Many programs will simply use a sequencer to send MIDI file data to the synthesizer, and won't need to invoke many Synthesizer methods directly. However, it's possible to control a synthesizer directly, without using sequencers or even MidiMessage objects, as explained near the end of this chapter.

The synthesis architecture might seem complex for readers who are unfamiliar with MIDI. Its API includes three interfaces:

  • Synthesizer
  • MidiChannel
  • Soundbank

and four classes:

  • Instrument
  • Patch
  • SoundbankResource
  • VoiceStatus

As orientation for all this API, the next section explains some of the basics of MIDI synthesis and how they're reflected in the Java Sound API. (Also see the brief section "Synthesizers" under "The Java Sound API's Representation of MIDI Devices" in Chapter 8, "Overview of the MIDI Package.") Subsequent sections give a more detailed look at the API.

Understanding MIDI Synthesis

How does a synthesizer generate sound? Depending on its implementation, it may use one or more sound-synthesis techniques. For example, many synthesizers use wavetable synthesis. A wavetable synthesizer reads stored snippets of audio from memory, playing them at different sample rates and looping them to create notes of different pitches and durations. For example, to synthesize the sound of a saxophone playing the note C#4 (MIDI note number 61), the synthesizer might access a very short snippet from a recording of a saxophone playing the note Middle C (MIDI note number 60), and then cycle repeatedly through this snippet at a slightly faster sample rate than it was recorded at, which creates a long note of a slightly higher pitch. Other synthesizers use techniques such as frequency modulation (FM), additive synthesis, or physical modeling, which don't make use of stored audio but instead generate audio from scratch using different algorithms.

Instruments

What all synthesis techniques have in common is the ability to create many sorts of sounds. Different algorithms, or different settings of parameters within the same algorithm, create different-sounding results. An instrument is a specification for synthesizing a certain type of sound. That sound may emulate a traditional musical instrument, such as a piano or violin; it may emulate some other kind of sound source, for instance, a telephone or helicopter; or it may emulate no "real-world" sound at all. A specification called General MIDI defines a standard list of 128 instruments, but most synthesizers allow other instruments as well. Many synthesizers provide a collection of built-in instruments that are always available for use; some synthesizers also support mechanisms for loading additional instruments.

An instrument may be vendor-specific—in other words, applicable to only one synthesizer or several models from the same vendor. This incompatibility results when two different synthesizers use different sound-synthesis techniques, or different internal algorithms and parameters even if the fundamental technique is the same. Because the details of the synthesis technique are often proprietary, incompatibility is common. The Java Sound API includes ways to detect whether a given synthesizer supports a given instrument.

An instrument can usually be considered a preset; you don't have to know anything about the details of the synthesis technique that produces its sound. However, you can still vary aspects of its sound. Each Note On message specifies the pitch and volume of an individual note. You can also alter the sound through other MIDI commands such as controller messages or system-exclusive messages.

Channels

Many synthesizers are multimbral (sometimes called polytimbral), meaning that they can play the notes of different instruments simultaneously. (Timbre is the characteristic sound quality that enables a listener to distinguish one kind of musical instrument from other kinds.) Multimbral synthesizers can emulate an entire ensemble of real-world instruments, instead of only one instrument at a time. MIDI synthesizers normally implement this feature by taking advantage of the different MIDI channels on which the MIDI specification allows data to be transmitted. In this case, the synthesizer is actually a collection of sound-generating units, each emulating a different instrument and responding independently to messages that are received on a different MIDI channel. Since the MIDI specification provides only 16 channels, a typical MIDI synthesizer can play up to 16 different instruments at once. The synthesizer receives a stream of MIDI commands, many of which are channel commands. (Channel commands are targeted to a particular MIDI channel; for more information, see the MIDI specification.) If the synthesizer is multitimbral, it routes each channel command to the correct sound-generating unit, according to the channel number indicated in the command.

In the Java Sound API, these sound-generating units are instances of classes that implement the MidiChannel interface. A synthesizer object has at least one MidiChannel object. If the synthesizer is multimbral, it has more than one, normally 16. Each MidiChannel represents an independent sound-generating unit.

Because a synthesizer's MidiChannel objects are more or less independent, the assignment of instruments to channels doesn't have to be unique. For example, all 16 channels could be playing a piano timbre, as though there were an ensemble of 16 pianos. Any grouping is possible—for instance, channels 1, 5, and 8 could be playing guitar sounds, while channels 2 and 3 play percussion and channel 12 has a bass timbre. The instrument being played on a given MIDI channel can be changed dynamically; this is known as a program change.

Even though most synthesizers allow only 16 or fewer instruments to be active at a given time, these instruments can generally be chosen from a much larger selection and assigned to particular channels as required.

Soundbanks and Patches

Instruments are organized hierarchically in a synthesizer. As was mentioned in Chapter 8, "Overview of the MIDI Package," the instruments are arranged by bank number and program number. Banks and programs can be thought of as rows and columns in a two-dimensional table of instruments. A bank is a collection of programs. The MIDI specification allows up to 128 programs in a bank, and up to 128 banks. However, a particular synthesizer might support only one bank, or a few banks, and might support fewer than 128 programs per bank.

In the Java Sound API, there's a higher level to the hierarchy: a soundbank. Soundbanks can contain up to 128 banks, each containing up to 128 instruments. Some synthesizers can load an entire soundbank into memory.

To select an instrument from the current soundbank, you specify a bank number and a program number. The MIDI specification accomplishes this with two MIDI commands: bank select and program change. In the Java Sound API, the combination of a bank number and program number is encapsulated in a Patch object. You change a MIDI channel's current instrument by specifying a new patch. The patch can be considered the two-dimensional index of the instruments in the current soundbank.

You might be wondering if soundbanks, too, are indexed numerically. The answer is no; the MIDI specification does not provide for this. In the Java Sound API, a Soundbank object can be obtained by reading a soundbank file. If the soundbank is supported by the synthesizer, its instruments can be loaded into the synthesizer individually as desired, or all at once. Many synthesizers have a built-in or default soundbank; the instruments contained in this soundbank are always available to the synthesizer.

Voices

It's important to distinguish between the number of timbres a synthesizer can play simultaneously and the number of notes it can play simultaneously. The former was described above under "Channels." The ability to play multiple notes at once is referred to as polyphony. Even a synthesizer that isn't multitimbral can generally play more than one note at a time (all having the same timbre, but different pitches). For example, playing any chord, such as a G major triad or a B minor seventh chord, requires polyphony. Any synthesizer that generates sound in real time has a limitation on the number of notes it can synthesize at once. In the Java Sound API, the synthesizer reports this limitation through the getMaxPolyphony method.

A voice is a succession of single notes, such as a melody that a person can sing. Polyphony consists of multiple voices, such as the parts sung by a choir. A 32-voice synthesizer, for example, can play 32 notes simultaneously. (However, some MIDI literature uses the word "voice" in a different sense, similar to the meaning of "instrument" or "timbre.")

The process of assigning incoming MIDI notes to specific voices is known as voice allocation. A synthesizer maintains a list of voices, keeping track of which ones are active (meaning that they currently have notes sounding). When a note stops sounding, the voice becomes inactive, meaning that it's now free to accept the next note-on request that the synthesizer receives. An incoming stream of MIDI commands can easily request more simultaneous notes than the synthesizer is capable of generating. When all the synthesizer's voices are active, how should the next Note On request be handled? Synthesizers can implement different strategies: the most recently requested note can be ignored; or it can be played by discontinuing another note, such as the least recently started one.

Although the MIDI specification does not require it, a synthesizer can make public the contents of each of its voices. The Java Sound API includes a VoiceStatus class for this purpose.

A VoiceStatus reports on the voice's current active or inactive status, MIDI channel, bank and program number, MIDI note number, and MIDI volume.

With this background, let's examine the specifics of the Java Sound API for synthesis.

Managing Instruments and Soundbanks

In many cases, a program can make use of a Synthesizer object without explicitly invoking almost any of the synthesis API. For example, suppose you're playing a standard MIDI file. You load it into a Sequence object, which you play by having a sequencer send the data to the default synthesizer. The data in the sequence controls the synthesizer as intended, playing all the right notes at the right times.

However, there are cases when this simple scenario is inadequate. The sequence contains the right music, but the instruments sound all wrong! This unfortunate situation probably arose because the creator of the MIDI file had different instruments in mind than the ones that are currently loaded into the synthesizer.

The MIDI 1.0 Specification provides for bank-select and program-change commands, which affect which instrument is currently playing on each MIDI channel. However, the specification does not define what instrument should reside in each patch location (bank and program number). The more recent General MIDI specification addresses this problem by defining a bank containing 128 programs that correspond to specific instrument sounds. A General MIDI synthesizer uses 128 instruments that match this specified set. Different General MIDI synthesizers can sound quite different, even when playing what's supposed to be the same instrument. However, a MIDI file should for the most part sound similar (even if not identical), no matter which General MIDI synthesizer is playing it.

Nonetheless, not all creators of MIDI files want to be limited to the set of 128 timbres defined by General MIDI. This section shows how to change the instruments from the default set that the synthesizer comes with. (If there is no default, meaning that no instruments are loaded when you access the synthesizer, you'll have to use this API to start with in any case.)

Learning What Instruments Are Loaded

To learn whether the instruments currently loaded into the synthesizer are the ones you want, you can invoke this Synthesizer method:

Instrument[] getLoadedInstruments()
and iterate over the returned array to see exactly which instruments are currently loaded. Most likely, you would display the instruments' names in the user interface (using the getName method of Instrument), and let the user decide whether to use those instruments or load others. The Instrument API includes a method that reports which soundbank the instrument belongs to. The soundbank's name might help your program or the user ascertain exactly what the instrument is.

This Synthesizer method:

Soundbank getDefaultSoundbank()
gives you the default soundbank. The Soundbank API includes methods to retrieve the soundbank's name, vendor, and version number, by which the program or the user can verify the bank's identity. However, you can't assume when you first get a synthesizer that the instruments from the default soundbank have been loaded into the synthesizer. For example, a synthesizer might have a large assortment of built-in instruments available for use, but because of its limited memory it might not load them automatically.

Loading Different Instruments

The user might decide to load instruments that are different from the current ones (or you might make that decision programmatically). The following method tells you which instruments come with the synthesizer (versus having to be loaded from soundbank files):

Instrument[] getAvailableInstruments()
You can load any of these instruments by invoking:
boolean loadInstrument(Instrument instrument)
The instrument gets loaded into the synthesizer in the location specified by the instrument's Patch object (which can be retrieved using the getPatch method of Instrument).

To load instruments from other soundbanks, first invoke Synthesizer's isSupportedSoundbank method to make sure that the soundbank is compatible with this synthesizer (if it isn't, you can iterate over the system's synthesizers to try to find one that supports the soundbank). You can then invoke one of these methods to load instruments from the soundbank:

boolean loadAllInstruments(Soundbank soundbank)
boolean loadInstruments(Soundbank soundbank,
  Patch[] patchList)
As the names suggest, the first of these loads the entire set of instruments from a given soundbank, and the second loads selected instruments from the soundbank. You could also use Soundbank's getInstruments method to access all the instruments, then iterate over them and load selected instruments one at a time using loadInstrument.

It's not necessary for all the instruments you load to be from the same soundbank. You could use loadInstrument or loadInstruments to load certain instruments from one soundbank, another set from a different soundbank, and so on.

Each instrument has its own Patch object that specifies the location on the synthesizer where the instrument should be loaded. The location is defined by a bank number and a program number. There's no API to change the location by changing the patch's bank or program number.

However, it is possible to load an instrument into a location other than the one specified by its patch, using the following method of Synthesizer:

boolean remapInstrument(Instrument from, Instrument to)
This method unloads its first argument from the synthesizer, and places its second argument in whatever synthesizer patch location had been occupied by the first argument.

Unloading Instruments

Loading an instrument into a program location automatically unloads whatever instrument was already at that location, if any. You can also explicitly unload instruments without necessarily replacing them with new ones. Synthesizer includes three unloading methods that correspond to the three loading methods. If the synthesizer receives a program-change message that selects a program location where no instrument is currently loaded, there won't be any sound from the MIDI channel on which the program-change message was sent.

Accessing Soundbank Resources

Some synthesizers store other information besides instruments in their soundbanks. For example, a wavetable synthesizer stores audio samples that one or more instruments can access. Because the samples might be shared by multiple instruments, they're stored in the soundbank independently of any instrument. Both the Soundbank interface and the Instrument class provide a method call getSoundbankResources, which returns a list of SoundbankResource objects. The details of these objects are specific to the synthesizer for which the soundbank is designed. In the case of wavetable synthesis, a resource might be an object that encapsulates a series of audio samples, taken from one snippet of a sound recording. Synthesizers that use other synthesis techniques might store other kinds of objects in the synthesizer's SoundbankResources array.

Querying the Synthesizer's Capabilities and Current State

The Synthesizer interface includes methods that return information about the synthesizer's capabilities:

    public long getLatency()
    public int getMaxPolyphony()
The latency measures the worst-case delay between the time a MIDI message is delivered to the synthesizer and the time that the synthesizer actually produces the corresponding result. For example, it might take a synthesizer a few milliseconds to begin generating audio after receiving a note-on event.

The getMaxPolyphony method indicates how many notes the synthesizer can sound simultaneously, as discussed under "Voices" in the section "Understanding MIDI Synthesis" earlier in this chapter. As mentioned in the same discussion, a synthesizer can provide information about its voices. This is accomplished through the following method:

public VoiceStatus[] getVoiceStatus()
Each VoiceStatus in the returned array reports the voice's current active or inactive status, MIDI channel, bank and program number, MIDI note number, and MIDI volume. The array's length should normally be the same number returned by getMaxPolyphony. If the synthesizer isn't playing, all its VoiceStatus objects have their active field set to false.

You can learn additional information about the current status of a synthesizer by retrieving its MidiChannel objects and querying their state. This is discussed more in the next section.

Using Channels

Sometimes it's useful or necessary to access a synthesizer's MidiChannel objects directly. This section discusses such situations.

Controlling the Synthesizer without Using a Sequencer

When using a sequence, such as one read from a MIDI file, you don't need to send MIDI commands to the synthesizer yourself. Instead, you just load the sequence into a sequencer, connect the sequencer to the synthesizer, and let it run. The sequencer takes care of scheduling the events, and the result is a predictable musical performance. This scenario works fine when the desired music is known in advance, which is true when it's read from a file.

In some situations, however, the music is generated on the fly as it's playing. For example, the user interface might display a musical keyboard or a guitar fretboard and let the user play notes at will by clicking with the mouse. As another example, an application might use a synthesizer not to play music per se, but to generate sound effects in response to the user's actions. This scenario is typical of games. As a final example, the application might indeed be playing music that's read from a file, but the user interface allows the user to interact with the music, altering it dynamically. In all these cases, the application sends commands directly to the synthesizer, since the MIDI messages need to be delivered immediately, instead of being scheduled for some determinate point in the future.

There are at least two ways of sending a MIDI message to the synthesizer without using a sequencer. The first is to construct a MidiMessage and pass it to the synthesizer using the send method of Receiver. For example, to produce a Middle C (MIDI note number 60) on MIDI channel 5 (one-based) immediately, you could do the following:

    ShortMessage myMsg = new ShortMessage();
    // Play the note Middle C (60) moderately loud
    // (velocity = 93)on channel 4 (zero-based).
    myMsg.setMessage(ShortMessage.NOTE_ON, 4, 60, 93);
    Synthesizer synth = MidiSystem.getSynthesizer();
    Receiver synthRcvr = synth.getReceiver();
    synthRcvr.send(myMsg, -1); // -1 means no time stamp
The second way is to bypass the message-passing layer (that is, the MidiMessage and Receiver API) altogether, and interact with the synthesizer's MidiChannel objects directly. You first need to retrieve the synthesizer's MidiChannel objects, using the following Synthesizer method:
public MidiChannel[] getChannels()
after which you can invoke the desired MidiChannel methods directly. This is a more immediate route than sending the corresponding MidiMessages to the synthesizer's Receiver and letting the synthesizer handle the communication with its own MidiChannels. For example, the code corresponding to the preceding example would be:
    Synthesizer synth = MidiSystem.getSynthesizer();
    MidiChannel chan[] = synth.getChannels();
    // Check for null; maybe not all 16 channels exist.
    if (chan[4] != null) {
         chan[4].noteOn(60, 93);
    }

Getting a Channel's Current State

The MidiChannel interface provides methods that correspond one-to-one to each of the "channel voice" or "channel mode" messages defined by the MIDI specification. We saw one case with the use of the noteOn method in the previous example. However, in addition to these canonical methods, the Java Sound API's MidiChannel interface adds some "get" methods to retrieve the value most recently set by corresponding voice or mode "set" methods:

    int       getChannelPressure()
    int       getController(int controller)
    boolean   getMono()
    boolean   getOmni()
    int	      getPitchBend()
    int	      getPolyPressure(int noteNumber)
    int	      getProgram()
These methods might be useful for displaying channel state to the user, or for deciding what values to send subsequently to the channel.

Muting and Soloing a Channel

The Java Sound API adds the notions of per-channel solo and mute, which are not required by the MIDI specification. These are similar to the solo and mute on the tracks of a MIDI sequence. (See "Muting or Soloing Individual Tracks in the Sequence" in Chapter 11, "Playing, Recording, and Editing MIDI Sequences.)"

If mute is on, this channel will not sound, but other channels are unaffected. If solo is on, this channel, and any other soloed channel, will sound (if it isn't muted), but no other channels will sound. A channel that is both soloed and muted will not sound. The MidiChannel API includes four methods:

    boolean	 getMute()
    boolean	 getSolo()
    void	 setMute(boolean muteState)
    void	 setSolo(boolean soloState)

Permission to Play Synthesized Sound

The audio produced by any installed MIDI synthesizer is typically routed through the sampled-audio system. If your program doesn't have permission to play audio, the synthesizer's sound won't be heard, and a security exception will be thrown. For more information on audio permissions, see "Permission to Use Audio Resources" in Chapter 3, "Accessing Audio System Resources."


Chapter 10: Transmitting and Receiving MIDI Messages

Understanding Devices, Transmitters, and Receivers

The JavaTM Sound API specifies a message-routing architecture for MIDI data that's flexible and easy to use, once you understand how it works. The system is based on a module-connection design: distinct modules, each of which performs a specific task, can be interconnected (networked), enabling data to flow from one module to another.

The base module in the Java Sound API's messaging system is MidiDevice (a Java language interface). MidiDevices include sequencers (which record, play, load, and edit sequences of time-stamped MIDI messages), synthesizers (which generate sounds when triggered by MIDI messages), and MIDI input and output ports, through which data comes from and goes to external MIDI devices. The functionality typically required of MIDI ports is described by the base MidiDevice interface. The Sequencer and Synthesizer interfaces extend the MidiDevice interface to describe the additional functionality characteristic of MIDI sequencers and synthesizers, respectively. Concrete classes that function as sequencers or synthesizers should implement these interfaces.

A MidiDevice typically owns one or more ancillary objects that implement the Receiver or Transmitter interfaces. These interfaces represent the "plugs" or "portals" that connect devices together, permitting data to flow into and out of them. By connecting a Transmitter of one MidiDevice to a Receiver of another, you can create a network of modules in which data flows from one to another.

The MidiDevice interface includes methods for determining how many transmitter and receiver objects the device can support concurrently, and other methods for accessing those objects. A MIDI output port normally has at least one Receiver through which the outgoing messages may be received; similarly, a synthesizer normally responds to messages sent to its Receiver or Receivers. A MIDI input port normally has at least one Transmitter, which propagates the incoming messages. A full-featured sequencer supports both Receivers, which receive messages during recording, and Transmitters, which send messages during playback.

The Transmitter interface includes methods for setting and querying the receivers to which the transmitter sends its MidiMessages. Setting the receiver establishes the connection between the two. The Receiver interface contains a method that sends a MidiMessage to the receiver. Typically, this method is invoked by a Transmitter. Both the Transmitter and Receiver interfaces include a close method that frees up a previously connected transmitter or receiver, making it available for a different connection.

We'll now examine how to use transmitters and receivers. Before getting to the typical case of connecting two devices (such as hooking a sequencer to a synthesizer), we'll examine the simpler case where you send a MIDI message directly from your application program to a device. Studying this simple scenario should make it easier to understand how the Java Sound API arranges for sending MIDI messages between two devices.

Sending a Message to a Receiver without Using a Transmitter

Let's say you want to create a MIDI message from scratch and then send it to some receiver. You can create a new, blank ShortMessage and then fill it with MIDI data using the following ShortMessage method:

void setMessage(int command, int channel, int data1,
         int data2)

Once you have a message ready to send, you can send it to a Receiver object, using this Receiver method:

void send(MidiMessage message, long timeStamp)

The time-stamp argument will be explained momentarily. For now, we'll just mention that its value can be set to -1 if you don't care about specifying a precise time. In this case, the device receiving the message will try to respond to the message as soon as possible.

An application program can obtain a receiver for a MidiDevice by invoking the device's getReceiver method. If the device can't provide a receiver to the program (typically because all the device's receivers are already in use), a MidiUnavailableException is thrown. Otherwise, the receiver returned from this method is available for immediate use by the program. When the program has finished using the receiver, it should call the receiver's close method. If the program attempts to invoke methods on a receiver after calling close, an IllegalStateException may be thrown.

As a concrete simple example of sending a message without using a transmitter, let's send a Note On message to the default receiver, which is typically associated with a device such as the MIDI output port or a synthesizer. We do this by creating a suitable ShortMessage and passing it as an argument to Receiver's send method:

  ShortMessage myMsg = new ShortMessage();
  // Start playing the note Middle C (60),
  // moderately loud (velocity = 93).
  myMsg.setMessage(ShortMessage.NOTE_ON, 0, 60, 93);
  long timeStamp = -1;
  Receiver	 rcvr = MidiSystem.getReceiver();
  rcvr.send(myMsg, timeStamp);

This code uses a static integer field of ShortMessage, namely, NOTE_ON, for use as the MIDI message's status byte. The other parts of the MIDI message are given explicit numeric values as arguments to the setMessage method. The zero indicates that the note is to be played using MIDI channel number 1; the 60 indicates the note Middle C; and the 93 is an arbitrary key-down velocity value, which typically indicates that the synthesizer that eventually plays the note should play it somewhat loudly. (The MIDI specification leaves the exact interpretation of velocity up to the synthesizer's implementation of its current instrument.) This MIDI message is then sent to the receiver with a time stamp of -1. We now need to examine exactly what the time stamp parameter means, which is the subject of the next section.

Understanding Time Stamps

Chapter 8, "Overview of the MIDI Package," explained that the MIDI specification has different parts. One part describes MIDI "wire" protocol (messages sent between devices in real time), and another part describes Standard MIDI Files (messages stored as events in "sequences"). In the latter part of the specification, each event stored in a standard MIDI file is tagged with a timing value that indicates when that event should be played. By contrast, messages in MIDI wire protocol are always supposed to be processed immediately, as soon as they're received by a device, so they have no accompanying timing values.

The Java Sound API adds an additional twist. It comes as no surprise that timing values are present in the MidiEvent objects that are stored in sequences (as might be read from a MIDI file), just as in the Standard MIDI Files specification. But in the Java Sound API, even the messages sent between devices—in other words, the messages that correspond to MIDI wire protocol—can be given timing values, known as time stamps. It is these time stamps that concern us here. (The timing values in MidiEvent objects are discussed in detail in Chapter 11, "Playing, Recording, and Editing MIDI Sequences.")

Time Stamps on Messages Sent to Devices

The time stamp that can optionally accompany messages sent between devices in the Java Sound API is quite different from the timing values in a standard MIDI file. The timing values in a MIDI file are often based on musical concepts such as beats and tempo, and each event's timing measures the time elapsed since the previous event. In contrast, the time stamp on a message sent to a device's Receiver object always measures absolute time in microseconds. Specifically, it measures the number of microseconds elapsed since the device that owns the receiver was opened.

This kind of time stamp is designed to help compensate for latencies introduced by the operating system or by the application program. It's important to realize that these time stamps are used for minor adjustments to timing, not to implement complex queues that can schedule events at completely arbitrary times (as MidiEvent timing values do).

The time stamp on a message sent to a device (through a Receiver) can provide precise timing information to the device. The device might use this information when it processes the message. For example, it might adjust the event's timing by a few milliseconds to match the information in the time stamp. On the other hand, not all devices support time stamps, so the device might completely ignore the message's time stamp.

Even if a device supports time stamps, it might not schedule the event for exactly the time that you requested. You can't expect to send a message whose time stamp is very far in the future and have the device handle it as you intended, and you certainly can't expect a device to correctly schedule a message whose time stamp is in the past! It's up to the device to decide how to handle time stamps that are too far off in the future or are in the past. The sender doesn't know what the device considers to be too far off, or whether the device had any problem with the time stamp. This ignorance mimics the behavior of external MIDI hardware devices, which send messages without ever knowing whether they were received correctly. (MIDI wire protocol is unidirectional.)

Some devices send time-stamped messages (via a Transmitter). For example, the messages sent by a MIDI input port might be stamped with the time the incoming message arrived at the port. On some systems, the event-handling mechanisms cause a certain amount of timing precision to be lost during subsequent processing of the message. The message's time stamp allows the original timing information to be preserved.

To learn whether a device supports time stamps, invoke the following method of MidiDevice:

    long getMicrosecondPosition()

This method returns -1 if the device ignores time stamps. Otherwise, it returns the device's current notion of time, which you as the sender can use as an offset when determining the time stamps for messages you subsequently send. For example, if you want to send a message with a time stamp for five milliseconds in the future, you can get the device's current position in microseconds, add 5000 microseconds, and use that as the time stamp. Keep in mind that the MidiDevice's notion of time always places time zero at the time the device was opened.

Now, with all that explanation of time stamps as a background, let's return to the send method of Receiver:

void send(MidiMessage message, long timeStamp)

The timeStamp argument is expressed in microseconds, according to the receiving device's notion of time. If the device doesn't support time stamps, it simply ignores the timeStamp argument. You aren't required to time-stamp the messages you send to a receiver. You can use -1 for the timeStamp argument to indicate that you don't care about adjusting the exact timing; you're just leaving it up to the receiving device to process the message as soon as it can. However, it's not advisable to send -1 with some messages and explicit time stamps with other messages sent to the same receiver. Doing so is likely to cause irregularities in the resultant timing.

Connecting Transmitters to Receivers

We've seen how you can send a MIDI message directly to a receiver, without using a transmitter. Now let's look at the more common case, where you aren't creating MIDI messages from scratch, but are simply connecting devices together so that one of them can send MIDI messages to the other.

Connecting to a Single Device

The specific case we'll take as our first example is connecting a sequencer to a synthesizer. After this connection is made, starting the sequencer running will cause the synthesizer to generate audio from the events in the sequencer's current sequence. For now, we'll ignore the process of loading a sequence from a MIDI file into the sequencer. Also, we won't go into the mechanism of playing the sequence. Loading and playing sequences is discussed in detail in Chapter 11, "Playing, Recording, and Editing MIDI Sequences." Loading instruments into the synthesizer is discussed in Chapter 12, "Synthesizing Sound." For now, all we're interested in is how to make the connection between the sequencer and the synthesizer. This will serve as an illustration of the more general process of connecting one device's transmitter to another device's receiver.

For simplicity, we'll use the default sequencer and the default synthesizer. (See Chapter 9, "Accessing MIDI System Resources," for more about default devices and how to access non-default devices.)

    Sequencer    	seq;
    Transmitter  	seqTrans;
    Synthesizer  	synth;
    Receiver	     synthRcvr;
    try {
          seq	  = MidiSystem.getSequencer();
          seqTrans = seq.getTransmitter();
          synth	  = MidiSystem.getSynthesizer();
          synthRcvr = synth.getReceiver();
          seqTrans.setReceiver(synthRcvr);
    } catch (MidiUnavailableException e) {
          // handle or throw exception
    }

An implementation might actually have a single object that serves as both the default sequencer and the default synthesizer. In other words, the implementation might use a class that implements both the Sequencer interface and the Synthesizer interface. In that case, it probably wouldn't be necessary to make the explicit connection that we did in the code above. For portability, though, it's safer not to assume such a configuration. If desired, you can test for this condition, of course:

if (seq instanceof Synthesizer)

although the explicit connection above should work in any case.

Connecting to More than One Device

The previous code example illustrated a one-to-one connection between a transmitter and a receiver. But, what if you need to send the same MIDI message to multiple receivers? For example, suppose you want to capture MIDI data from an external device to drive the internal synthesizer while simultaneously recording the data to a sequence. This form of connection, sometimes referred to as "fan out" or as a "splitter," is straightforward. The following statements show how to create a fan-out connection, through which the MIDI messages arriving at the MIDI input port are sent to both a Synthesizer object and a Sequencer object. We assume you've already obtained and opened the three devices: the input port, sequencer, and synthesizer. (To obtain the input port, you'll need to iterate over all the items returned by MidiSystem.getMidiDeviceInfo.)

    Synthesizer  synth;
    Sequencer    seq;
    MidiDevice   inputPort;
    // [obtain and open the three devices...]
    Transmitter	  inPortTrans1, inPortTrans2;
    Receiver     	synthRcvr;
    Receiver     	seqRcvr;
    try {
          inPortTrans1 = inputPort.getTransmitter();
          synthRcvr = synth.getReceiver();
          inPortTrans1.setReceiver(synthRcvr);
          inPortTrans2 = inputPort.getTransmitter();
          seqRcvr = seq.getReceiver();
          inPortTrans2.setReceiver(seqRcvr);
    } catch (MidiUnavailableException e) {
          // handle or throw exception
    }

This code introduces a dual invocation of the MidiDevice.getTransmitter method, assigning the results to inPortTrans1 and inPortTrans2. As mentioned earlier, a device can own multiple transmitters and receivers. Each time MidiDevice.getTransmitter() is invoked for a given device, another transmitter is returned, until no more are available, at which time an exception will be thrown.

To learn how many transmitters and receivers a device supports, you can use the following MidiDevice method:

    int getMaxTransmitters()
    int getMaxReceivers()

These methods return the total number owned by the device, not the number currently available.

A transmitter can transmit MIDI messages to only one receiver at a time. (Every time you call Transmitter's setReceiver method, the existing Receiver, if any, is replaced by the newly specified one. You can tell whether the transmitter currently has a receiver by invoking Transmitter.getReceiver.) However, if a device has multiple transmitters, it can send data to more than one device at a time, by connecting each transmitter to a different receiver, as we saw in the case of the input port above.

Similarly, a device can use its multiple receivers to receive from more than one device at a time. The multiple-receiver code that's required is straightforward, being directly analogous to the multiple-transmitter code above. It's also possible for a single receiver to receive messages from more than one transmitter at a time.

Closing Connections

Once you're done with a connection, you can free up its resources by invoking the close method for each transmitter and receiver that you've obtained. The Transmitter and Receiver interfaces each have a close method. Note that invoking Transmitter.setReceiver doesn't close the transmitter's current receiver. The receiver is left open, and it can still receive messages from any other transmitter that's connected to it.

If you're also done with the devices, you can similarly make them available to other application programs by invoking MidiDevice.close(). Closing a device automatically closes all its transmitters and receivers.


Chapter 7: Using Files and Format Converters

Most application programs that deal with sound need to read sound files or audio streams. This is common functionality, regardless of what the program may subsequently do with the data it reads (such as play, mix, or process it). Similarly, many programs need to write sound files (or streams). In some cases, the data that has been read (or that will be written) needs to be converted to a different format.

As was briefly mentioned in Chapter 3, "Accessing Audio System Resources," the JavaTM Sound API provides application developers with various facilities for file input/output and format translations. Application programs can read, write, and translate between a variety of sound file formats and audio data formats.

Chapter 2, "Overview of the Sampled Package," introduced the main classes related to sound files and audio data formats. As a review:

  • A stream of audio data, as might be read from or written to a file, is represented by an AudioInputStream object. (AudioInputStream inherits from java.io.InputStream.)
  • The format of this audio data is represented by an AudioFormat object.

    This format specifies how the audio samples themselves are arranged, but not the structure of a file that they might be stored in. In other words, an AudioFormat describes "raw" audio data, such as the system might hand your program after capturing it from a microphone input or after parsing it from a sound file. An AudioFormat includes such information as the encoding, the byte order, the number of channels, the sampling rate, and the number of bits per sample.

  • There are several well-known, standard formats for sound files, such as WAV, AIFF, or AU. The different types of sound file have different structures for storing audio data as well as for storing descriptive information about the audio data. A sound file format is represented in the Java Sound API by an AudioFileFormat object. The AudioFileFormat includes an AudioFormat object to describe the format of the audio data stored in the file, and also includes information about the file type and the length of the data in the file.

  • The AudioSystem class provides methods for (1) storing a stream of audio data from an AudioInputStream into an audio file of a particular type (in other words, writing a file), (2) extracting a stream of audio bytes (an AudioInputStream) from an audio file (in other words, reading a file), and (3) converting audio data from one data format to another. The present chapter, which is divided into three sections, explains these three kinds of activity.

Note that an implementation of the Java Sound API does not necessarily provide comprehensive facilities for reading, writing, and converting audio in different data and file formats. It might support only the most common data and file formats. However, service providers can develop and distribute conversion services that extend this set, as outlined in Chapter 14, "Providing Sampled-Audio Services." The AudioSystem class supplies methods that allow application programs to learn what conversions are available, as described later in this chapter under "Converting File and Data Formats."

Reading Sound Files

The AudioSystem class provides two types of file-reading services:

  • Information about the format of the audio data stored in the sound file
  • A stream of formatted audio data that can be read from the sound file

The first of these is given by three variants of the getAudioFileFormat method:

static AudioFileFormat getAudioFileFormat (java.io.File file)
static AudioFileFormat getAudioFileFormat(java.io.InputStream stream)
static AudioFileFormat getAudioFileFormat (java.net.URL url)

As mentioned above, the returned AudioFileFormat object tells you the file type, the length of the data in the file, encoding, the byte order, the number of channels, the sampling rate, and the number of bits per sample.

The second type of file-reading functionality is given by these AudioSystem methods

static AudioInputStream getAudioInputStream (java.io.File file)
static AudioInputStream getAudioInputStream (java.net.URL url)
static AudioInputStream getAudioInputStream (java.io.InputStream stream)

These methods give you an object (an AudioInputStream) that lets you read the file's audio data, using one of the read methods of AudioInputStream. We'll see an example momentarily.

Suppose you're writing a sound-editing application that allows the user to load sound data from a file, display a corresponding waveform or spectrogram, edit the sound, play back the edited data, and save the result in a new file. Or perhaps your program will read the data stored in a file, apply some kind of signal processing (such as an algorithm that slows the sound down without changing its pitch), and then play the processed audio. In either case, you need to get access to the data contained in the audio file. Assuming that your program provides some means for the user to select or specify an input sound file, reading that file's audio data involves three steps:

  1. Get an AudioInputStream object from the file.
  2. Create a byte array in which you'll store successive chunks of data from the file.
  3. Repeatedly read bytes from the audio input stream into the array. On each iteration, do something useful with the bytes in the array (for example, you might play them, filter them, analyze them, display them, or write them to another file).

The following code example outlines these steps.

int totalFramesRead = 0;
File fileIn = new File(somePathName);
// somePathName is a pre-existing string whose value was
// based on a user selection.
try {
  AudioInputStream audioInputStream =
    AudioSystem.getAudioInputStream(fileIn);
  int bytesPerFrame =
    audioInputStream.getFormat().getFrameSize();
  // Set an arbitrary buffer size of 1024 frames.
  int numBytes = 1024 * bytesPerFrame;
  byte[] audioBytes = new byte[numBytes];
  try {
    int numBytesRead = 0;
    int numFramesRead = 0;
    // Try to read numBytes bytes from the file.
    while ((numBytesRead =
      audioInputStream.read(audioBytes)) != -1) {
      // Calculate the number of frames actually read.
      numFramesRead = numBytesRead / bytesPerFrame;
      totalFramesRead += numFramesRead;
      // Here, do something useful with the audio data that's
      // now in the audioBytes array...
    }
  } catch (Exception ex) {
    // Handle the error...
  }
} catch (Exception e) {
  // Handle the error...
}
Let's take a look at what's happening in the above code sample. First, the outer try clause instantiates an AudioInputStream object through the call to the AudioSystem.getAudioInputStream(File) method. This method transparently performs all of the testing required to determine whether the specified file is actually a sound file of a type that is supported by the Java Sound API. If the file being inspected (fileIn in this example) is not a sound file, or is a sound file of some unsupported type, an UnsupportedAudioFileException exception is thrown. This behavior is convenient, in that the application programmer need not be bothered with testing file attributes, nor with adhering to any file-naming conventions. Instead, the getAudioInputStream method takes care of all the low-level parsing and verification that is required to validate the input file.

The outer try clause then creates a byte array, audioBytes, of an arbitrary fixed length. We make sure that its length in bytes equals an integral number of frames, so that we won't end up reading only part of a frame or, even worse, only part of a sample. This byte array will serve as a buffer to temporarily hold a chunk of audio data as it's read from the stream. If we knew we would be reading nothing but very short sound files, we could make this array the same length as the data in the file, by deriving the length in bytes from the length in frames, as returned by AudioInputStream's getFrameLength method. (Actually, we'd probably just use a Clip object instead.) But to avoid running out of memory in the general case, we instead read the file in chunks, one buffer at a time.

The inner try clause contains a while loop, which is where we read the audio data from the AudioInputStream into the byte array. You should add code in this loop to handle the audio data in this array in whatever way is appropriate for your program's needs. If you're applying some kind of signal processing to the data, you'll probably need to query the AudioInputStream's AudioFormat further, to learn the number of bits per sample and so on.

Note that the method AudioInputStream.read(byte[]) returns the number of bytes read—not the number of samples or frames. This method returns -1 when there's no more data to read. Upon detecting this condition, we break from the while loop.

Writing Sound Files

The previous section described the basics of reading a sound file, using specific methods of the AudioSystem and AudioInputStream classes. This section describes how to write audio data out to a new file.

The following AudioSystem method creates a disk file of a specified file type. The file will contain the audio data that's in the specified AudioInputStream:

static int write(AudioInputStream in,
  AudioFileFormat.Type fileType, File out)
Note that the second argument must be one of the file types supported by the system (for example, AU, AIFF, or WAV), otherwise the write method will throw an IllegalArgumentException. To avoid this, you can test whether or not a particular AudioInputStream may be written to a particular type of file, by invoking this AudioSystem method:
static boolean isFileTypeSupported
  (AudioFileFormat.Type fileType, AudioInputStream stream)
which will return true only if the particular combination is supported.

More generally, you can learn what types of file the system can write by invoking one of these AudioSystem methods:

static AudioFileFormat.Type[] getAudioFileTypes()
static AudioFileFormat.Type[]
  getAudioFileTypes(AudioInputStream stream)
The first of these returns all the types of file that the system can write, and the second returns only those that the system can write from the given audio input stream.

The following excerpt demonstrates one technique for creating an output file from an AudioInputStream using the write method mentioned above.

File fileOut = new File(someNewPathName);
AudioFileFormat.Type fileType = fileFormat.getType();
if (AudioSystem.isFileTypeSupported(fileType,
    audioInputStream)) {
  AudioSystem.write(audioInputStream, fileType, fileOut);
}
The first statement above, creates a new File object, fileOut, with a user- or program-specified pathname. The second statement gets a file type from a pre-existing AudioFileFormat object called fileFormat, which might have been obtained from another sound file, such as the one that was read in the "Reading Sound Files" section of this chapter. (You could instead supply whatever supported file type you want, instead of getting the file type from elsewhere. For example, you might delete the second statement and replace the other two occurrences of fileType in the code above with AudioFileFormat.Type.WAVE.)

The third statement tests whether a file of the designated type can be written from a desired AudioInputStream. Like the file format, this stream might have been derived from the sound file previously read. (If so, presumably you've processed or altered its data in some way, because otherwise there are easier ways to simply copy a file.) Or perhaps the stream contains bytes that have been freshly captured from the microphone input.

Finally, the stream, file type, and output file are passed to the AudioSystem.write method, to accomplish the goal of writing the file.

Converting File and Data Formats

Recall from the section "What Is Formatted Audio Data?" in Chapter 2, "Overview of the Sampled Package," that the Java Sound API distinguishes between audio file formats and audio data formats. The two are more or less independent. Roughly speaking, the data format refers to the way in which the computer represents each raw data point (sample), while the file format refers to the organization of a sound file as stored on a disk. Each sound file format has a particular structure that defines, for example, the information stored in the file's header. In some cases, the file format also includes structures that contain some form of meta-data, in addition to the actual "raw" audio samples. The remainder of this chapter examines methods of the Java Sound API that enable a variety of file-format and data-format conversions.

Converting from One File Format to Another

This section covers the fundamentals of converting audio file types in the Java Sound API. Once again we pose a hypothetical program whose purpose, this time, is to read audio data from an arbitrary input file and write it into a file whose type is AIFF. Of course, the input file must be of a type that the system is capable of reading, and the output file must be of a type that the system is capable of writing. (In this example, we assume that the system is capable of writing AIFF files.) The example program doesn't do any data format conversion. If the input file's data format can't be represented as an AIFF file, the program simply notifies the user of that problem. On the other hand, if the input sound file is an already an AIFF file, the program notifies the user that there is no need to convert it.

The following function implements the logic just described:

public void ConvertFileToAIFF(String inputPath,
  String outputPath) {
  AudioFileFormat inFileFormat;
  File inFile;
  File outFile;
  try {
    inFile = new File(inputPath);
    outFile = new File(outputPath);
  } catch (NullPointerException ex) {
    System.out.println("Error: one of the
      ConvertFileToAIFF" +" parameters is null!");
    return;
  }
  try {
    // query file type
    inFileFormat = AudioSystem.getAudioFileFormat(inFile);
    if (inFileFormat.getType() != AudioFileFormat.Type.AIFF)
    {
      // inFile is not AIFF, so let's try to convert it.
      AudioInputStream inFileAIS =
        AudioSystem.getAudioInputStream(inFile);
      inFileAIS.reset(); // rewind
      if (AudioSystem.isFileTypeSupported(
             AudioFileFormat.Type.AIFF, inFileAIS)) {
         // inFileAIS can be converted to AIFF.
         // so write the AudioInputStream to the
         // output file.
         AudioSystem.write(inFileAIS,
           AudioFileFormat.Type.AIFF, outFile);
         System.out.println("Successfully made AIFF file, "
           + outFile.getPath() + ", from "
           + inFileFormat.getType() + " file, " +
           inFile.getPath() + ".");
         inFileAIS.close();
         return; // All done now
       } else
         System.out.println("Warning: AIFF conversion of "
           + inFile.getPath()
           + " is not currently supported by AudioSystem.");
    } else
      System.out.println("Input file " + inFile.getPath() +
          " is AIFF." + " Conversion is unnecessary.");
  } catch (UnsupportedAudioFileException e) {
    System.out.println("Error: " + inFile.getPath()
        + " is not a supported audio file type!");
    return;
  } catch (IOException e) {
    System.out.println("Error: failure attempting to read "
      + inFile.getPath() + "!");
    return;
  }
}

As mentioned, the purpose of this example function, ConvertFileToAIFF, is to query an input file to determine whether it's an AIFF sound file, and if it isn't, to try to convert it to one, producing a new copy whose pathname is specified by the second argument. (As an exercise, you might try making this function more general, so that instead of always converting to AIFF, the function converts to the file type specified by a new function argument.) Note that the audio data format of the copy—that is, the new file-mimics the audio data format of original input file.

Most of this function is self-explanatory and is not specific to the Java Sound API. There are, however, a few Java Sound API methods used by the routine that are crucial for sound file-type conversions. These method invocations are all found in the second try clause, above, and include the following:

  • AudioSystem.getAudioFileFormat: used here to determine whether the input file is already an AIFF type. If so, the function quickly returns; otherwise the conversion attempt proceeds.

  • AudioSystem.isFileTypeSupported: Indicates whether the system can write a file of the specified type that contains audio data from the specified AudioInputStream. In our example, this method returns true if the specified audio input file can be converted to AIFF audio file format. If AudioFileFormat.Type.AIFF isn't supported, ConvertFileToAIFF issues a warning that the input file can't be converted, then returns.

  • AudioSystem.write: used here to write the audio data from the AudioInputStream inFileAIS to the output file outFile.

The second of these methods, isFileTypeSupported, helps to determine, in advance of the write, whether a particular input sound file can be converted to a particular output sound file type. In the next section we will see how, with a few modifications to this ConvertFileToAIFF sample routine, we can convert the audio data format, as well as the sound file type.

Converting Audio between Different Data Formats

The previous section showed how to use the Java Sound API to convert a file from one file format (that is, one type of sound file) to another. This section explores some of the methods that enable audio data format conversions.

In the previous section, we read data from a file of an arbitrary type, and saved it in an AIFF file. Note that although we changed the type of file used to store the data, we didn't change the format of the audio data itself. (Most common audio file types, including AIFF, can contain audio data of various formats.) So if the original file contained CD-quality audio data (16-bit sample size, 44.1-kHz sample rate, and two channels), so would our output AIFF file.

Now suppose that we want to specify the data format of the output file, as well as the file type. For example, perhaps we are saving many long files for use on the Internet, and are concerned about the amount of disk space and download time required by our files. We might choose to create smaller AIFF files that contain lower-resolution data-for example, data that has an 8-bit sample size, an 8-kHz sample rate, and a single channel.

Without going into as much coding detail as before, let's explore some of the methods used for data format conversion, and consider the modifications that we would need to make to the ConvertFileToAIFF function to accomplish the new goal.

The principal method for audio data conversion is, once again, found in the AudioSystem class. This method is a variant of getAudioInputStream:

AudioInputStream getAudioInputStream(AudioFormat
    format, AudioInputStream stream)
This function returns an AudioInputStream that is the result of converting the AudioInputStream, stream, using the indicated AudioFormat, format. If the conversion isn't supported by AudioSystem, this function throws an IllegalArgumentException.

To avoid that, we can first check whether the system can perform the required conversion by invoking this AudioSystem method:

boolean isConversionSupported(AudioFormat targetFormat,
    AudioFormat sourceFormat)
In this case, we'd pass stream.getFormat() as the second argument.

To create a specific AudioFormat object, we use one of the two AudioFormat constructors shown below, either

 AudioFormat(float sampleRate, int sampleSizeInBits,
    int channels, boolean signed, boolean bigEndian)
which constructs an AudioFormat with a linear PCM encoding and the given parameters, or
AudioFormat(AudioFormat.Encoding encoding,
    float sampleRate, int sampleSizeInBits, int channels,
    int frameSize, float frameRate, boolean bigEndian)
which also constructs an AudioFormat, but lets you specify the encoding, frame size, and frame rate, in addition to the other parameters.

Now, armed with the methods above, let's see how we might extend our ConvertFileToAIFF function to perform the desired "low-res" audio data format conversion. First, we would construct an AudioFormat object describing the desired output audio data format. The following statement would suffice and could be inserted near the top of the function:

AudioFormat outDataFormat = new AudioFormat((float) 8000.0,
(int) 8, (int) 1, true, false);
Since the AudioFormat constructor above is describing a format with 8-bit samples, the last parameter to the constructor, which specifies whether the samples are big or little endian, is irrelevant. (Big versus little endian is only an issue if the sample size is greater than a single byte.)

The following example shows how we would use this new AudioFormat to convert the AudioInputStream, inFileAIS, that we created from the input file:

AudioInputStream lowResAIS;
  if (AudioSystem.isConversionSupported(outDataFormat,
    inFileAIS.getFormat())) {
    lowResAIS = AudioSystem.getAudioInputStream
      (outDataFormat, inFileAIS);
  }
It wouldn't matter too much where we inserted this code, as long as it was after the construction of inFileAIS. Without the isConversionSupported test, the call would fail and throw an IllegalArgumentException if the particular conversion being requested was unsupported. (In this case, control would transfer to the appropriate catch clause in our function.)

So by this point in the process, we would have produced a new AudioInputStream, resulting from the conversion of the original input file (in its AudioInputStream form) to the desired low-resolution audio data format as defined by outDataFormat.

The final step to produce the desired low-resolution, AIFF sound file would be to replace the AudioInputStream parameter in the call to AudioSystem.write (that is, the first parameter) with our converted stream, lowResAIS, as follows:

AudioSystem.write(lowResAIS, AudioFileFormat.Type.AIFF,
  outFile);
These few modifications to our earlier function produce something that converts both the audio data and the file format of any specified input file, assuming of course that the system supports the conversion.

Learning What Conversions Are Available

Several AudioSystem methods test their parameters to determine whether the system supports a particular data format conversion or file-writing operation. (Typically, each method is paired with another that performs the data conversion or writes the file.) One of these query methods, AudioSystem.isFileTypeSupported, was used in our example function, ConvertFileToAIFF, to determine whether the system was capable of writing the audio data to an AIFF file. A related AudioSystem method, getAudioFileTypes(AudioInputStream), returns the complete list of supported file types for the given stream, as an array of AudioFileFormat.Type instances. The method:

boolean isConversionSupported(AudioFormat.Encoding encoding,
                              AudioFormat format)
is used to determine whether an audio input stream of the specified encoding can be obtained from an audio input stream that has the specified audio format. Similarly, the method:
boolean isConversionSupported(AudioFormat newFormat,
                              AudioFormat oldFormat)

tells us whether an AudioInputStream with the specified audio format, newFormat, can be obtained through the conversion of an AudioInputStream that has the audio format oldFormat. (This method was invoked in the previous section's code excerpt that created a low-resolution audio input stream, lowResAIS.)

These format-related queries help prevent errors when attempting to perform format conversions with the Java Sound API.


Deva Search

Java Sound Search Page
Tips


Endorsed Standards doc, v7

Java Endorsed Standards Override Mechanism

Introduction

From time to time it is necessary to update the Java platform in order to incorporate newer versions of standards that are created outside of the Java Community Process (Endorsed Standards), or in order to update the version of a technology included in the platform to correspond to a later standalone version of that technology (Standalone Technologies).

The Endorsed Standards Override Mechanism provides a means whereby later versions of classes and interfaces that implement Endorsed Standards or Standalone Technologies may be incorporated into the Java Platform.

Deploying updated packages

Packages to be updated through this mechanism should be placed in JAR files. The system property java.endorsed.dirs specifies one or more directories that the Java runtime environment will search for such JAR files. If more than one directory path is specified by java.endorsed.dirs, they must be separated by File.pathSeparatorChar. If no value is set for java.endorsed.dirs, then Sun Microsystem's implementation of the Java platform looks for JAR files in a default standard location:
<java-home>\lib\endorsed          [Microsoft Windows]
<java-home>/lib/endorsed          [Solaris or Linux]
Here <java-home> refers to the directory where the runtime software is installed (which is the top-level directory of the Java SE Runtime Environment or the jre directory in the JDK).

The Java SE runtime environment will use classes in such JAR files to override the corresponding classes provided in the Java platform as it was shipped.

Endorsed Standards APIs

The Endorsed Standards for Java SE constitute all classes and interfaces that are defined in the packages listed in this section. Classes and interfaces defined in sub-packages of listed packages are not Endorsed Standards unless those sub-packages are themselves listed. The Endorsed Standards Override Mechanism may be used to override the Java SE platform packages in this list, and these packages may be overridden only by versions of the Endorsed Standard that are newer than that provided by the Java platform as released by Sun. With the exception of packages listed here and the technologies listed in the Standalone Technologies section below, no other packages from the Java SE platform API specification may be overridden.
javax.rmi.CORBA
org.omg.CORBA
org.omg.CORBA.DynAnyPackage
org.omg.CORBA.ORBPackage
org.omg.CORBA.portable
org.omg.CORBA.TypeCodePackage
org.omg.CORBA_2_3
org.omg.CORBA_2_3.portable
org.omg.CosNaming
org.omg.CosNaming.NamingContextExtPackage
org.omg.CosNaming.NamingContextPackage
org.omg.Dynamic
org.omg.DynamicAny
org.omg.DynamicAny.DynAnyFactoryPackage
org.omg.DynamicAny.DynAnyPackage
org.omg.IOP
org.omg.IOP.CodecFactoryPackage
org.omg.IOP.CodecPackage
org.omg.Messaging
org.omg.PortableInterceptor
org.omg.PortableInterceptor.ORBInitInfoPackage
org.omg.PortableServer
org.omg.PortableServer.CurrentPackage
org.omg.PortableServer.POAManagerPackage
org.omg.PortableServer.POAPackage
org.omg.PortableServer.portable
org.omg.PortableServer.ServantLocatorPackage
org.omg.SendingContext
org.omg.stub.java.rmi
org.w3c.dom
org.xml.sax
org.xml.sax.ext
org.xml.sax.helpers
In addition to the packages listed above, which are part of the Java SE specification, users of Sun's Java SE Reference Implementation are allowed to use the Endorsed Standards Override Mechanism to override implementation-specific classes associated with these packages, such as the org.w3c.dom sub-packages delivered in Sun's Reference Implementation.

Standalone Technologies

The Standalone Technologies for Java SE constitute all classes and interfaces that are defined and implemented in the technologies listed in this section. The Endorsed Standards Override Mechanism may be used to override the Java technologies in this list, and these technologies may be overridden only by providing a complete and newer implementation of the Standalone Technology than was provided in the original implementation of the Java Platform. With the exception of the technologies in this list and the packages listed in the Endorsed Standards APIs section above, no other packages from the Java SE platform API specification may be overridden.
Java API for XML Processing (JAXP), version 1.4
Java Architecture for XML Binding (JAXB), version 2.0
Java API for XML-Based Web Services (JAX-WS), version 2.0
Java Compiler API, version 1.0
Pluggable Annotation Processing API, version 1.0
Common Annotations for the Java Platform, version 1.0
Scripting for the Java Platform, version 1.0


Swing

Java

Swing
(JavaTM Foundation Classes)

 Documentation Contents
The Swing classes (part of the JavaTM Foundation Classes (JFC) software) implement a set of components for building graphical user interfaces (GUIs) and adding rich graphics functionality and interactivity to Java applications. The Swing components are implemented entirely in the Java programming language. The pluggable look and feel lets you create GUIs that can either look the same across platforms or can assume the look and feel of the current OS platform (such as Microsoft Windows, SolarisTM or Linux).
Overview
  • About the JFC and Swing from The Swing Tutorial.

API Specification

  • API Reference
  • Focus Model Specification

Tutorials and Programmer's Guides

  • The Swing Tutorial

API Enhancements

  • Swing Enhancements in the JDK 5.0
  • Swing Enhancements in the Java 2 SDK, v1.4.1 and v1.4.2
  • Swing Enhancements in the Java 2 SDK, v1.4

More Information

  • The Swing Connection
  • The JavaDesktop Community
  • The JFC Home Page

Copyright © 2005 Sun Microsystems, Inc. All Rights Reserved.

Please send comments to: swing-feedback@java.sun.com 		Sun Microsystems, Inc
Java Software


Swing Changes and New Features

Java

Swing Changes and New Features for JavaTM 2 SDK, Standard Edition, v 1.4

 Project Swing

Changes Specific to releases 1.4.1 and 1.4.2

This document contains information relevant to all 1.4.* releases. For information specific to 1.4.1 and 1.4.2, see Swing Changes Since Java 2 SDK, Standard Edition, v 1.4.

Major Changes

Certain features, typically ones that have a large impact on Swing, have been extensively written up in separate documents. The following link to these documents:

  • Windows XP look and feel
  • GTK+ look and feel
  • Support for indeterminate progress bars
  • JTabbedPane with scrollable tabs
  • JSpinner
  • JFormattedTextField
  • Popup and PopupFactory
  • New Focus Model Specification and Javadoc
  • Windows look and feel update.
  • The new Drag and Drop architecture.

Minor Changes

Each section contains changes for a set of related classes. Most of the sections are focused on the classes that are part of a single Swing component like JEditorPane or JTable. Each API change is associated with a link to a report on the Java Developer Connection (JDC) Bug Parade , where you'll find the original bug or RFE ("request for enhancement") that motivated the change. In this document you'll also find the following information for each API change:

  • The method signatures with a link to the Javadoc for new methods or methods whose semantics have changed.
  • A brief description of the overall change and how to take advantage of it. You'll probably find this same material in the evaluation section of the bug/rfe report.
  • If the API change corrects a long standing bug or provides a missing feature - suggestions about how to migrate typical workarounds or extensions to the new feature.
  • Nearly all changes (even bugfixes!) introduce some kind of incompatibility. We've done our best to predict these incompatibilities and provide advice about how to avoid them.

Sections

  • Box
  • JButton
  • JComboBox
  • JFileChooser
  • JInternalFrame
  • JList
  • JOptionPane
  • JPopupMenu
  • JPanel
  • JRootPane
  • JScrollBar
  • JScrollPane
  • JTabbedPane
  • JTable
  • JTextComponent
  • JTree
  • RepaintManager
  • SpringLayout
  • Miscellaneous
  • Known Bugs

Box

Box now descends from JComponent

The bugtraq report that corresponds to this change is: 4304100.

Historically, the superclass for Box has been Component. Since Box did not descend from JComponent, you could not use it like a normal Swing component, for example, you couldn't set the borders, or issue revalidate. Not only this, but changing visibility, or other similiar visual properties, on a standard Swing component typically triggers a repaint or revalidate, but Box did not conform to this behavior. As of this release, Box and Box.Filler now descend from the JComponent superclass and therefore behave more like standard Swing components.

BoxLayout Now Supports Right-to-Left and Bottom-to-Top Component Orientations

The bugtraq report that corresponds to this change is: 4140833.

BoxLayout did not consider the ComponentOrientation of the Container it is laying out. Other AWT layout managers were made to do this when the ComponentOrientation feature was added in JDK 1.2. Adding this feature to BoxLayout makes it useful for programs that support Middle East locales. Because BoxLayout is also used internally by other Swing components, such as JOptionPane, JToolBar and JMenuBar, adding this feature is also necessary for these components to support ComponentOrientation.

To support this functionality, the constants LINE_AXIS and PAGE_AXIS, and the constructor, BoxLayout(Container, int), were added to BoxLayout.

There were also changes to several methods in SizeRequirements:

  • calculateTiledPositions(int,SizeRequirements,SizeRequirements[],int[],int[],boolean)
  • calculateTiledPositions(int,SizeRequirements,SizeRequirements[],int[],int[])
  • calculateAlignedPositions(int,SizeRequirements,SizeRequirements[],int[],int[],boolean)
  • calculateAlignedPositions(int,SizeRequirements,SizeRequirements[],int[],int[])

JButton

Default Button Follows the Focus on Windows LAF

The bugtraq report that corresponds to this change is: 4659800.

With this bug, introduced in 1.4.0, the default button did not always follow the focus. This has been fixed in 1.4.1.

New Control of Highlighted Characters

The bugtraq report that corresponds to this change is: 4138746.

AbstractButton and JLabel both allow the developer to set a character, called the mnemonic, that can be used to perform an action when typed at the keyboard. The javadoc for these methods states that the first case-insensitive occurrence of the character is decorated. While this suits most developers, often times a different occurrence of the character needs to be highlighted. For example: in Notepad, 'a' is the accelerator for Save As, but the second 'a' is decorated. Developers need a way to be able to specify this.

This is solved with the new AbstractButton.setDisplayedMnemonicIndex and JLabel.setDisplayedMnemonicIndex methods. Once you have specified a mnemonic, via the setMnemonic or setDisplayedMnemonic methods, you can then change the character that is highlighted via the setDisplayedMnemonicIndex method. There are also new AbstractButton.getDisplayedMnemonicIndex and JLabel.getDisplayedMnemonicIndex methods. Finally, drawStringUnderlineCharAt has been added to javax.swing.plaf.basic.BasicGraphicsUtils.

AbstractButton.configurePropertiesFromAction Now Honors ACTION_COMMAND_KEY Property

The bugtraq report that corresponds to this change is: 4457940.

Previously, the AbstractButton methods configurePropertiesFromAction(Action) and configurePropertiesFromAction(Action, String[]) did not honor the ACTION_COMMAND_KEY property. That has now been addressed. This affects the javadoc for the configurePropertiesFromAction methods in the following subclasses of AbstractButton:

  • JButton.configurePropertiesFromAction(Action)
  • JMenu.configurePropertiesFromAction(Action)
  • JCheckBox.configurePropertiesFromAction(Action)
  • JRadioButton.configurePropertiesFromAction(Action)

JComboBox

PopupMenuListener Added to JComboBox

The bugtraq report that corresponds to this change is: 4287690.

Many developers have requested support for listeners to be notified when a combo box's drop down menu is popped up, dismissed, or canceled. Applications could use these listeners to lazily populate the combo box's model with items.

This feature wasn't provided in earlier versions of Swing because there was some, probably academic, concern about supporting a listener for a feature (the drop down menu) that some look and feel implementations might not provide. All of the look and feels that are shipped with Java, and all of the ones we've come across, do use a drop down menu to show all of the combo box items. Some developers have resorted to non-portable hacks to get the menu state change notifications.

For this release, we added a PopupMenuListener to JComboBox. So long as the underlying look and feel supports an item menu, this listener can be used to perform actions before and after the combo box menu appears. Several new JComboBox methods were required to support this feature:

    public void addPopupMenuListener(PopupMenuListener l)
    public void removePopupMenuListener(PopupMenuListener l)
    public void firePopupMenuWillBecomeVisible()
    public void firePopupMenuWillBecomeInvisible()
    public void firePopupMenuCanceled()

JComboBox Now Supports Prototype Cell for Lists

The bugtraq report that corresponds to this change is: 4231298.

JComboBox previously configured a renderer for every item it displayed. For large lists this could take quite a while. Instead, developers needed the ability to specify a prototype that all cells match, so that the prototype is only checked once instead of every cell. For this release, getPrototypeDisplayValue and setPrototypeDisplayValue have been added to JComboBox.

Javadoc for JComboBox and Related Classes Has Improved Documentation

The bugtraq report that corresponds to this change is 4394300.

Previously, public API for JComboBox and its UI delegates contained javadoc which described the details of its implementation. Refactoring and bug fixing over the course of its history had made this javadoc out of date. The javadoc has been checked and revised so that it describes the behavior of the method rather than the implementation details. Also, some of the javadoc for "protected" methods and fields which should really have been private have been removed so that overriding or calling these methods are not encouraged.

The doc has been changed for JComboBox, ComboBoxModel, MutableComboBoxModel, javax.swing.plaf.basic.BasicComboBoxUI, javax.swing.plaf.basic.ComboPopup, and javax.swing.plaf.basic.BasicComboPopup.

JFileChooser

JFileChooser Windows Look and Feel Improved

The bugtraq report that corresponds to this change is 4290709.

Although Swing's JFileChooser closely resembles the Microsoft Windows common file dialog under the Windows look and feel, there are several deficiencies for which we have received complaints. In particular, the Microsoft Windows aesthetics guide mentions the following:

If you cannot use the [common] Open and Save As dialog boxes, you should incorporate the following features into your open and save dialog boxes to ensure that they are consistent with the shell, the Windows accessories, and other applications:

  • Support the same namespace hierarchy as the shell; that is, Desktop should be at the root of the hierarchy, followed by all folders and objects on the desktop, including My Computer, My Network, and so on. [...]
  • Support shortcuts (also known as shell links). [...]
  • Display filenames with the corresponding icons and filename extensions removed, as the shell does.
  • Allow the user to browse the network hierarchy directly.
  • Make sure that all of your dialog boxes (not just your open and save dialog boxes) use only nonbold fonts. [...]

The first four points are not possible in Swing without additional API support from the AWT. The AWT common file dialog is also currently an unacceptable solution for the following reasons:

  • It cannot be embedded into a frame or dialog like JFileChooser.
  • Filename filter is not implemented and is difficult to implement on Windows.

The new functionality is accomplished by adding the following public methods to the javax.swing.filechooser.FileSystemView class, providing file and directory information beyond the scope of the File class:

    public boolean isTraversable(File f)
    public String getSystemDisplayName(File f)
    public String getSystemTypeDescription
    public Icon getSystemIcon(File f)
    public boolean isParent(File folder, File file)
    public File getChild(File parent, String filename)
    public boolean isFileSystem(File f)
    public boolean isFileSystemRoot(File dir)
    public boolean isDrive(File dir)
    public boolean isFloppyDrive(File dir)
    public boolean isComputerNode(File dir)
    public File createFileSystemRoot(File f)
    public File[] getRoots()

The isTraversable method has been removed from javax.swing.plaf.basic.BasicFileChooserUI.BasicFileView so that the superclass's implementation is used.

createListSelectionListener has been added to javax.swing.plaf.metal.MetalFileChooserUI.

Also, javax.swing.plaf.basic.BasicDirectoryModel has the following changes:

    public void intervalAdded(ListDataEvent e)
    public void intervalRemoved(ListDataEvent e)
    public void renameFile(File oldFile, File newFile)

New Ability to Specify Characteristics of Open Directory Button in JFileChooser

The bugtraq report that corresponds to this change is 4318785.

Look and feels need the ability to specify the text, tooltip text, and mnemonic for the button used to open a directory in JFileChooser.

To support this, several constants and methods were added to plaf.basic.BasicFileChooserUI:

    protected int directoryOpenButtonMnemonic = 0;
    protected String directoryOpenButtonText = null
    protected String directoryOpenButtonToolTipText = null
    protected boolean isDirectorySelected()
    protected void setDirectorySelected(boolean b)
    protected File getDirectory()
    protected void setDirectory(File f)

Multiple File Selection Supported

The bugtraq report that corresponds to this change is 4218431.

Multiple file selection was added to JFileChooser in the 1.4 release, but the javadoc for setMultiSelectionEnabled wasn't updated until the 1.4.1 release.

JInternalFrame

JInternalFrame Now Truncates Titles That are Too Long

The bugtraq report that corresponds to this change is 4134077.

Previously, the title of an internal frame would not be clipped if it was too long. This would lead to the title displaying over parts of the icons, as well no visual feedback to the user that the title had been clipped. To solve this, BasicInternalFrameTitlePane.getTitle was added.

JInternalFrame Titles in Windows Look and Feel May Now be Rendered with a Gradient

The bugtraq report that corresponds to this change is: 4389209.

To implement this correctly, we needed to create a class, com.sun.java.swing.plaf.windows.WindowsInternalFrameTitlePane, which extended javax.swing.plaf.basic.BasicInternalFrameTitlePane, but overrode the paint routine to render the gradient when appropriate. The best way to get code-reuse was to break out the portion of the paint method which paints just the background and override just that in WindowsInternalFrameTitlePane. The method paintTitleBackground was added to javax.swing.plaf.basic.BasicInternalFrameTitlePane.

JTextComponent

New Support for Tooltips for Images in JEditorPane

The bugtraq report that corresponds to this change is: 4252169.

In previous releases it was not possible for ImageView (the View responsible for rendering images in a JEditorPane) to show tooltip text because there was no way for a View to influence the tooltip text that is displayed for a JTextComponent. In this release, if the the JTextComponent doesn't have a tooltip, then the view under the mouse is asked to provide one. If that View corresponds to an HTML element with an ALT attribute, then the tooltip text is the value of that attribute.

To make it possible for Views to affect the tooltip text, a number of methods were needed. getToolTipText was added to javax.swing.plaf.TextUI so that it is possible to get the tooltip text for a particular location. JTextComponent's getToolTipText method then forwards to the TextUI, assuming a tooltip was not set on the JTextComponent.

getToolTipText was also added to javax.swing.text.View. The default implementation of View.getToolTipText will forward the request to the View's child at the given location. To make it easy to determine the child at a particular location, getViewIndex was added to View.

The View implementation invokes getViewIndex and then getToolTipText on the child View. ImageView then overrides getToolTipText and returns the value from the ALT attribute of its AttributeSet.

ImageView Class is Now Public

The bugtraq report that corresponds to this change is: 4233811.

The package private class javax.swing.text.html.ImageView is now public so that it can be extended.

New HyperlinkEvent Read-Only elementOffset Property

The bugtraq report that corresponds to this change is: 4182124.

The HTML package exposes a way for developers to determine when the mouse moves over a link via the HyperlinkEvent and HyperlinkListener classes. Often times developers need a way to extract information from the document when the HyperlinkListener is notified. There was previously no way for a developer to determine the position in the document a HyperlinkEvent represents. To remedy this the constructor HyperlinkEvent(Object, EventType, URL, String, Element) and the method getSourceElement were added to HyperlinkEvent.

HTMLFrameHyperlinkEvent extends HyperlinkEvent, which already defines the method getSourceElement. Since the superclass now defines this method, the getSourceElement javadoc was removed from HTMLFrameHyperlinkEvent (the method is now inherited):

HTML Parser Change: Whitespace Reporting

The bugtraq report that corresponds to this change is: 4241788.

The semantics of the HTML parser ( javax.swing.text.html.parser.Parser) have slightly changed to better match that of the browser (NetscapeTM and Internet Explorer). While no API was changed, those using the parser may notice a slight difference in the reporting of whitespace. Here is how things have changed: if strict (an instance variable of javax.swing.text.html.parser.Parser) == false (the default) an instance variable is used to try and mimic the behavior of Netscape and Explorer.

The problematic scenarios are:

'<b>blah <i> <strike> foo'

which can be treated as:

'<b>blah <i><strike>foo'

as well as:

'<p><a href="xx"> <em>Using</em></a></p>'

which appears to be treated as:

'<p><a href="xx"><em>Using</em></a></p>'

When a tag that breaks flow, or trailing whitespace is encountered an instance variable is set to true. From then on, all whitespace is ignored. The instance variable is set back to false the first time a non whitespace character is encountered.

Improved Support for Writing HTML Forms

The bugtraq report that corresponds to this change is: 4200439.

The HTML support provided in the J2SETM has never correctly supported writing out form elements. This was due, in large part, to the way that forms were modeled. To better match the document object model (see DOM at www.w3.org) we have changed how the forms are modeled internally. Previously, any attributes of a form would be stored in the attributeSet of all of the children character elements. As of this release, an element is created to represent the form, better matching that of the HTML file itself. This allows for better modeling of the form, as well as consistent writing of the form.

This affects developers that relied on forms being handled loosely. As an example, we would previously treat the following invalid HTML:

<table>
<form>
</table>
</form>

as:

<form>
<table>
</table>
</form>

With this release, we instead treat it as:

<table>
<form>
</form>
</table>

Static DefaultPainter in javax.swing.text.DefaultHighlighter Class is Now Final

The bugtraq report that corresponds to this change is: 4328938.

Prior to this release, the static field DefaultPainter of javax.swing.text.DefaultHighlighter was not final. This was a potential security problem. For this release, it is now Final.

PlainDocument Constructor is Now Public

The bugtraq report that corresponds to this change is: 4220001.

Prior to this release, the PlainDocument(AbstractDocument.Content) constructor was protected. This meant that developers wishing to use the constructor had to subclass. This constructor was intended to be public, and is now public in this release.

JEditorPane.scrollToReference Method is Now Public

The bugtraq report that corresponds to this change is: 4304676.

JEditorPane.scrollToReference was protected for no good reason. This method is intended to be useful without having to subclass, as such it has been made public in this release.

Document.getText Method Now Allows for Partial Returns

The bugtraq report that corresponds to this change is: 4156650.

For efficiently accessing the content of a text document, Document defines the method getText(int, int, Segment). Unfortunately, there has been no way for the caller to determine if the receiver could efficiently satisfy the request. For example, GapContent could efficiently implement the request as long as the request didn't span the last edited spot of the document (the gap). To facilitate efficient access of the content, the methods setPartialReturn and isPartialReturn have been added to Segment. The current semantics of Document.getText still hold, but for more efficient use callers should invoke segment.setPartialReturn(true) and be prepared to get back a portion of the document at a time.

JEditorPane Now Provides HTML Accessibility Support

The bugtraq report that corresponds to this change is: 4303259.

Assistive technologies for people with disabilities require programmatic access to the contents of JEditorPane using the Accessibility API. Previously, the only access was to hypertext links. This API change provided accessibility to all HTML components using the Accessibility API.

javax.swing.text.html.HTMLEditorKit now implements javax.accessibility.Accessible.

JEditorPane now implements getAccessibleContext().

Further Support for New AbstractDocument.replace Method

The bugtraq report that corresponds to this change is: 4458513.

As part of RFE 4431047, a replace method was added to AbstractDocument. In order to allow this method to call remove and insertString (the only methods defined in the interface for mutating a Document), the restrictions on when writeLock may be invoked have been relaxed. This allows replace to be compatible with old versions of AbstractDocument that only override remove and insertString.

JOptionPane

New showInputDialog Methods

The bugtraq report that corresponds to this change is: 4226644.

Prior to this release, if programs wished to display a simple input dialog containing a textfield with a default string, they had to invoke the complex JOptionPane.showInputDialog method which requires seven parameters. Two new methods, showInputDialog(Object, Object), and showInputDialog(Component, Object, Object), make it more convenient to create and display simple input dialogs.

JOptionPane Now Supports ComponentOrientation

The bugtraq report that corresponds to this change is: 4265463.

JOptionPane needed to support right-to-left layout. This was a bug fix and no actual API was required, however, the class spec for JOptionPane and javax.swing.plaf.basic.BasicOptionPane have been updated.

JOptionPane now uses Non-Resizable Dialogs

The bugtraq report that corresponds to this change is: 4829588.

As of release 1.4.0, JOptionPane is changed to use non-resizable dialogs. As a result, the dialogs displayed by many JOptionPane methods have slightly changed. The first two changes are desirable:

  • The dialogs are, obviously, no longer resizable.

  • The dialogs no longer show the system menu icon (that typically appears in the upper-left corner of the dialog on a left-to-right system).
A side effect of this change appears in the handling of extra-long text. Previously, long text was clipped, showing "..." at the end, as the dialog was restricted to the size of the screen. Now, extra-long text can cause the dialog to be sized larger than the screen in order to accomodate all of the text. Keep watching bug 4829588 to see how this undesirable behavior is resolved.

JPopupMenu

JPopupMenu and Focus

As of this release, showing a JPopupMenu causes focus to transfer to the parent JRootPane. This was done so that JPopupMenus would support keyboard traversal ( 4212563). This may cause problems for applications that are doing validation on focus lost. If this affects you, it is recommended that in the focusLost notification you check the temporary property of the FocusEvent and, if true, do nothing. In situations where you don't want JPopupMenu to grab focus, there is unfortunately no way to disable this in the current release. In release 1.4.1 the decision to transfer focus is based on the focusability of the JPopupMenu. Refer to bug 4632782 for details.

JPopupMenu Now Supports Key Bindings

The bugtraq report that corresponds to this change is: 4212563.

Previously, JPopupMenu didn't support key bindings. The arrow keys, mnemonics, the enter key, and escape did not work with a JPopupMenu unless it was used as part of a compound component (like a JMenu or a JComboBox).

This behavior can be traced to the fact that JPopupMenu did not always gain focus, and could therefore not get KeyEvents. It was previously not possible for light weight toolkits, such as Swing, to request focus and indicate that the focus change was temporary. The new focus architecture solved this problem, and Swing can now request a temporary focus change. Fixing this bug required making the JPopupMenu get focus so that the key bindings can be processed. Consumers that had previously not expected focus changes need to update their code to check the temporary property of the FocusEvents.

JPopupMenu.setVisible(true) Now Throws HeadlessException in Headless Mode

The bugtraq report that corresponds to this change is: 4401222.

When the new headless mode was introduced, JPopupMenu.setVisible(true) was implemented to throw NullPointerException when called in headless mode. It has now been fixed to throw HeadlessException instead, to indicate that this operation cannot be performed in headless mode.

JPanel

New setUI, getUI Methods

The bugtraq report that corresponds to this change is: 4226238.

The setUI/getUI methods were not implemented for JPanel, even though its look and feel is defined by pluggable look and feel (plaf). See javax.swing.plaf.basic.BasicPanelUI.java, for example.

JTabbedPane

JTabbedPane and Focus

The new focus specification states that focus requests on components that are not showing will fail. This can have subtle side effects. One such side effect is that requesting focus from a ChangeListener associated with a JTabbedPane may fail. At the same time, the ChangeListener is notified that the component is not currently visible and therefore the focus request fails in the same situation that it probably worked under the previous release. If you are running into this situation with JTabbedPane it is suggested you make the component visible before requesting focus. Other situations may require different approaches.

New indexAtLocation Method in JTabbedPane

The bugtraq report that corresponds to this change is: 4241787.

Prior to this change, there was no way for client programs to convert a coordinate location to a particular tab in a tabbedpane. This made it difficult to implement special event handling on a JTabbedPane (like popping up a menu over a tab).

The method indexAtLocation has been added to JTabbedPane.

New Mnemonic Support for Accessing Tabs in JTabbedPane

The bugtraq report that corresponds to this change is: 4284674.

The panes of a JTabbedPane did not previously allow for mnemonics. To facilitate this, the methods getDisplayedMnemonicIndexAt and setDisplayedMnemonicIndexAt have been added.

Exceptions Thrown by JTabbedPane Now Consistent

The bugtraq report that corresponds to this change is: 4287053.

The JTabbedPane class is a container that has many methods which take an integer index as a parameter. Unfortunately, these methods weren't inconsistent with their approach to throwing exceptions (some methods check/throw, some don't). Additionally, the javadoc was in error - it stated that an IllegalParameterException was thrown when in fact an ArrayIndexOutOfBoundsException was thrown (by the underlying Vector).

Any method which takes an index that must be in the valid range from 0 to tabCount-1 now documents that it throws an IndexOutOfBoundsException (note: the underlying code continues to throw ArrayIndexOutOfBoundsException for compatibility reasons).

The following doc change:

    * @exception IndexOutOfBoundsException if index is out of range
    *       (index < 0 || index >= tab count)
will be applied to the following JTabbedPane methods:
    public String getTitleAt(int index)
    public Icon getIconAt(int index)
    public Icon getDisabledIconAt(int index)
    public String getToolTipTextAt(int index)
    public Color getBackgroundAt(int index)
    public Color getForegroundAt(int index)
    public boolean isEnabledAt(int index)
    public Component getComponentAt(int index)
    public int getDisplayedMnemonicIndexAt(int index)
    public Rectangle getBoundsAt(int index)
    public void setTitleAt(int index, String title)
    public void setIconAt(int index, Icon icon)
    public void setDisabledIconAt(int index, Icon icon)
    public void setToolTipTextAt(int index, String toolTipText)
    public void setForegroundAt(int index, Color foreground)
    public void setBackgroundAt(int index, Color background)
    public void setEnabledAt(int index, boolean enabled)
    public void setComponentAt(int index, Component component)
    public void setDisplayedMnemonicIndexAt(int tabIndex, int mnemonicIndex)

The same exception handling will be added to the following methods which previously did nothing:

    public void setSelectedIndex(int index)
    public void remove(int index)

JTable

DefaultTableModel.moveRow Specification Clarified

The bugtraq report that corresponds to this change is: 4144295.

In JDK 1.3, the moveRow method in DefaultTableModel was documented in such a way that it did not clearly define whether the row at startIndex or the row at endIndex row would end up at toIndex. By inference from the examples, it appears that the startIndex should end up at toIndex when moving rows downward and the endIndex should end up at toIndex when moving rows upward.

That said, the implementation of moveRow had a bug such that whenever the number of rows being moved was more than one - the rows would end up in somewhat arbitrary positions and would not even be contiguous after the move. Bug 4144295 noted that the implementation did not even perform the example in its specification: the moveRow(1, 3, 5) example in practice left the vector in the following state:

a|C|e|B|D|f|g|h|i|j|k
The new implementation makes the observation that this operation is a simple rotation of elements between bounds that can be calculated from the inputs.

Since the previous implementation did not work we have taken the opportunity to simplify the definition to one where the startIndex is always moved to the toIndex, with all other elements appearing after toIndex in the same order that they were originally. Note that this performs the same operation as the previous implementation in the only case where it worked - when a single row was being moved.

The new implementation does not throw an exception when endIndex is less than startIndex - it does nothing instead having satisfied the implied contract to move all rows, r, where startIndex <= r="r" <="endIndex.

Typing into a JTable Now Transfers Focus to the Cell

The bugtraq report that corresponds to this change is: 4274963.

The Excel application automatically gives focus to underlying editors when a user presses an alphanumeric key. We have received over 200 JDC votes requesting that we offer this behavior in JTable. While we can't change the default behavior for reasons of backwards compatibility, in this release we have added the new property, surrendersFocusOnKeystroke, to address this request. The new methods setSurrendersFocusOnKeystroke and getSurrendersFocusOnKeystrok support this feature. The default behavior remains unchanged.

DefaultTableModel Now Allows a Null For Name Argument

The bugtraq report that corresponds to this change is: 4474094.

The methods DefaultTableModel.addColumn(Object) and DefaultTableModel.addColumn(Object, Vector) did not previously allow null for the name argument - they threw an IllegalArgumentException. As it is possible to set the column name to null via other means (using constructors, or directly manipulating the field), the addColumn methods now also allows a null value.

JTree

DefaultTreeModel Now Allows a Null Root

The bugtraq report that corresponds to this change is: 4264897.

DefaultTreeModel now allows a null root node . Previously, the javadoc for TreeModel specified that a null root was valid, but DefaultTreeModel would not allow one. DefaultTreeModel now allows setting a null root, as well as a null root in the constructor. The javadoc for setRoot has been revised to reflect the change.

Added First Letter Navigation to JTree

The bugtraq report that corresponds to this change is: 4284709.

Often times users wish to navigate to cells in a JTree using alphanumeric keys. To facilitate this, a method named getNextMatch has been added to JTree. BasicTreeUI installs a KeyListener that invokes this method as keys are typed on the keyboard.

JList

ListDataEvent.toString Now Provides Useful Information

The bugtraq report that corresponds to this change is: 4134085.

Developers often rely on the toString method for useful debugging information. Unfortunately ListDataEvent's toString method did not really provide anything useful. For this release, it has been changed to return something useful.

JList Now Supports First Letter Key Navigation

The bugtraq report that corresponds to this change is: 4284709.

Often times users wish to navigate to cells in a JList using alphanumeric keys. To facilitate this, getNextMatch was added to JList. BasicListUI will then install a KeyListener that will invoke this method as keys are typed to update the selection.

JList Items May Now be Arranged Horizontally

The bugtraq report that corresponds to this change is: 4460016.

JList previously only allowed laying out its cells vertically, that is:

1
2
3
4

Numerous users have asked for the ability to lay out the list horizontally, something like:

1  3
2  4
or
1  2
3  4

To achieve this, three constants are added to JList, VERTICAL, VERTICAL_WRAP, and HORIZONTAL_WRAP. The methods getLayoutOrientation and setLayoutOrientation are also added to JList. The javadoc for the JList methods getScrollableTracksViewportHeight, getScrollableTracksViewportWidth, getScrollableBlockIncrement, and getPreferredScrollableViewportSize are updated accordingly. Likewise, the javadoc for getPreferredSize in javax.swing.plaf.basic.BasicListUI is updated.

Miscellaneous

Two default settings in Metal look and feel have changed

Two default settings have changed in the Metal look and feel:

  • The foreground color for JLabel has changed from dark blue to black.

  • The font for DefaultListCellRenderer has changed from normal to bold.

JColorChooser.setPreviewPanel doesn't remove the old one

The bugtraq report that corresponds to this change is: 4759306.

When calling this method the default PreviewPanel was not removed from the colorChooser, though the new panel was added. This resulted in strange artifacts. This has been fixed in release 1.4.2.

Deadlock in JColorChooser Fixed

The bugtraq report that corresponds to this change is: 4668511.

This bug when encountered in 1.4.0, caused a deadlock that would hang the entire application. This has been fixed in 1.4.1.

JFrame.setDefaultCloseOperation Can Now Throw SecurityException

As of release 1.4.1, the setDefaultCloseOperation method in JFrame may now throw SecurityException.

Metal Can Now Pick up Font Sizes from the Desktop on Microsoft Windows

The bugtraq reports that correspond to this change are: 4419964 and 4668963.

Prior to this release, the DefaultMetalTheme ignored the font size information from the Windows desktop. As of release 1.4.1, DefaultMetalTheme can use the font sizes specified in the Windows desktop. This can be disabled using the system property swing.useSystemFontSettings. An additional part of this bug is that our Windows look and feel was picking up the wrong fonts for a handful of components; this has been fixed.

Some Locales Will Honor Font Size Only from the Desktop on Windows

The bugtraq report that corresponds to this change is: 4615396.

On Microsoft Windows, with the WindowsLookAndFeel, in certain locales we only honor font size from the desktop. This has been addressed in 1.4.1.

Document Which Properties a Look and Feel May Ignore

The bugtraq report that corresponds to this change is: 4420209.

Some look and feel implementations may ignore certain properties which affect the look and feel. With this release, the documentation for certain methods has been modified to indicate that these properties may be ignored by some look and feels. Also, the class spec for UIManager and the documentation for the javax.swing.plaf.metal package were modified to specify that the Java look and feel is the default look and feel. This modification affects only documentation.

The affected methods are:

  • javax.swing.AbstractButton
    • public boolean isFocusPainted()
    • public void setFocusPainted(boolean b)
    • public boolean isRolloverEnabled()
    • public void setRolloverEnabled(boolean b)
  • javax.swing.JButton
    • public boolean isDefaultButton()
    • public boolean isDefaultCapable()
    • public void setDefaultCapable(boolean defaultCapable)
  • javax.swing.JCheckBox
    • public boolean isBorderPaintedFlat()
    • public void setBorderPaintedFlat(boolean b)
  • javax.swing.JColorChooser
    • public boolean getDragEnabled()
    • public void setDragEnabled(boolean b)
  • javax.swing.JComboBox
    • public boolean isLightWeightPopupEnabled()
    • public void setLightWeightPopupEnabled(boolean aFlag)
  • javax.swing.JFileChooser
    • public boolean getDragEnabled()
    • public void setDragEnabled(boolean b)
    • public boolean getControlButtonsAreShown()
    • public void setControlButtonsAreShown(boolean b)
  • javax.swing.JInternalFrame
    • public boolean isIconifiable()
    • public void setIconifiable(boolean b)
  • javax.swing.JList
    • public boolean getDragEnabled()
    • public void setDragEnabled(boolean b)
  • javax.swing.JPopupMenu
    • public boolean isLightWeightPopupEnabled()
    • public void setLightWeightPopupEnabled(boolean aFlag)
  • javax.swing.JProgressBar
    • public boolean isStringPainted()
    • public void setStringPainted(boolean b)
    • public boolean isIndeterminate()
    • public void setIndeterminate(boolean newValue)
  • javax.swing.JSplitPane
    • public boolean isOneTouchExpandable()
    • public void setOneTouchExpandable(boolean newValue)
    • public boolean isContinuousLayout()
    • public void setContinuousLayout(boolean newContinuousLayout)
  • javax.swing.JTable
    • public boolean getDragEnabled()
    • public void setDragEnabled(boolean b)
  • javax.swing.text.JTextComponent
    • public boolean getDragEnabled()
    • public void setDragEnabled(boolean b)
  • javax.swing.JToolBar
    • public boolean isFloatable()
    • public void setFloatable(boolean b)
  • javax.swing.JTree
    • public boolean getDragEnabled()
    • public void setDragEnabled(boolean b)
    • public boolean getShowsRootHandles()
    • public void setShowsRootHandles(boolean newValue)
    • public boolean getScrollsOnExpand()
    • public void setScrollsOnExpand(boolean newValue)

SwingConstants Now Define NEXT and PREVIOUS

The bugtraq report that corresponds to this change is: 4175466.

SwingConstants defines constants that are used throughout Swing. A common UI operation is to locate the next/previous item in a sequence; as such, SwingConstants now defines constants for NEXT and PREVIOUS.

New Way to Process Bindings for Swing Components from a non-Swing Component

The bugtraq report that corresponds to this change is: 4344900.

Swing has an elaborate infrastructure to support associating actions with particular key strokes. This means that when the user types a character the action executes. The processing of these events is triggered from within JComponent.processKeyEvent (processKeyEvent is overridden from java.awt.Component). As the processing of these actions occurs within JComponent, there was previously no way for developers to process bindings from within non-JComponent subclasses that get focus. To facilitate this, a processKeyBindings method was added to SwingUtilities.

Auditory Feedback for Swing Components

The bugtraq report that corresponds to this change is: 4290988.

Note: Due to a handful of bugs in the sound package we default to playing no sounds. If you would like to turn on sounds, you can do the following:

    UIManager.put("AuditoryCues.playList",
        UIManager.get("AuditoryCues.allAuditoryCues"));

Previously, Swing components did not provide the same auditory feedback as native components on many platforms. MALF2, a set of modifications to Swing's PLAFs, is primarily intended for use as an output-only, non-speech audio user feedback mechanism. The MALF2 project is important from the perspective of Swing/JFC and the Java platform's goal of tight user interface integration with the underlying platform. The MALF2 project ensures that a user's experience with a native application and a Swing/JFC application is identical with regard to the auditory user feedback.

The implementation centers around adding API to BasicLookAndFeel to support loading an ActionMap containing Actions that play sounds. Various BasicComponentUI implementations then invoke actionPerformed on the Action at the appropriate time to play the sound. For example, BasicMenuItemUI uses doClick to perform the action. While BasicLookAndFeel plays sounds using the Java Sound API, subclasses can use an alternative method. For example, WindowsLookAndFeel maps the Strings to Runnables by way of Toolkit.getDefaultToolkit().getDesktopProperty(), to provide integration with the sounds provided by Windows.

The ActionMap containing the sounds can be accessed via BasicLookAndFeel.getAudioActionMap. When getAudioActionMap is first invoked, it performs the following:

  1. The default entry auditoryCues.cueList (an Object[]) is used to determine a list of sounds to load.
  2. Each entry in the array is passed to createAudioAction to obtain the Action responsible for playing the sound.
  3. The Object passed into BasicLookAndFeel.createAudioAction is used to look up a path to a sound file from the defaults table that can be loaded by Java Sound.
  4. When one of the BasicComponentUIs classes wishes to play a sound, it invokes BasicLookAndFeel.playSound, passing in the Action.
  5. BasicLookAndFeel.playSound invokes actionPerformed on the Action if the name of the Action is contained in the defaults entry AuditoryCues.playList.

This architecture allows the developer numerous ways to customize the sounds that are played:

  • The sounds associated with a particular JComponent can be manipulated by changing the Action in the ActionMap associated with the JComponent, eg:
    ActionMap map = menuItem.getActionMap();
map.put("MenuItem.commandSound", differentActionToPlaySound);
  • The sounds used by all Components of a particular type can be changed by manipulating the defaults table, eg:
    UIManager.put("MenuItem.commandSound", "pathToNewSoundFild");
  • Developers creating a custom look and feel may override one of the BasicLookAndFeel methods to load the sounds in an alternative manner, or perhaps play the sounds in a different way.

Alternatively, the set of sounds to be played can be manipulated by way of the defaults entry AuditoryCues.playList. This Object array contains the keys in the defaults table indicating which sounds to play. MetalLookAndFeel defines this to be:

new Object[]  {"OptionPane.errorSound",
      "OptionPane.informationSound",
      "OptionPane.questionSound",
      "OptionPane.warningSound" }
This has the effect of turning on only the sounds that JOptionPane supports.

JMenu Updated to Work with New Focus Architecture

The bugtraq report that corresponds to this change is: 4371580.

The new focus architecture introduced via RFE 4290675 allows for developers to request a temporary focus change. The request is done through the protected Component methods requestFocus(boolean) or requestFocusInWindow(boolean). These two methods are protected as they are not meant for general use, but only for implementors of lightweight toolkits, such as Swing. Swing is architected in such a way that code in different packages needs to temporarily request focus; as such, the parent class of all Swing Components, JComponent, needs to expose requestFocus(boolean) and requestFocusInWindow as public.

New Support for Changing ComponentOrientation in Tree of Components

The bugtraq report that corresponds to this change is: 4337186.

With the bulk of the Swing components paying attention to their ComponentOrientation property, we now need two features to make it easier to manage the ComponentOrientation settings of an entire hierarchy of components. It should be easy to set entire hierarchies of components to a consistent ComponentOrientation setting using the new SwingUtilities method applyComponentOrientation(Component c, ComponentOrientation o).

New Access to Desktop Properties

The bugtraq report that corresponds to this change is: 4290973.

As part of the Windows look and feel update, a method was added to LookAndFeel, getDesktopPropertyValue, to facilitate accessing desktop properties.

New Method to Offset Rectangle by Component's Insets

This was actually added as part of the update to JProgressBar to support an indeterminate state. The bugtraq report that corresponds to this change is: 4290717.

The new method is calculateInnerArea(Component, Rectangle) has been added to SwingUtilities.

New API for Mouse Wheels

The bugtraq report that corresponds to this change is: 4356268.

Wheel mice, with a scroll wheel as a middle mouse button, are increasingly popular. This proposal provides for built-in Java support for scrolling via the mouse wheel, as well as a new wheel event listener so developers can customize mouse wheel behavior.

A new class, MouseWheelListener, and a new interface, MouseWheelEvent, have been added. The constant, MOUSE_WHEEL_EVENT_MASK has been added to AWTEvent. AWTEventMulticaster has three new methods: mouseWheelMoved, add, and remove. Component has two new methods: addMouseWheelListener, and removeMouseWheelListener. ScrollPane also has two new methods: setWheelScrollingEnabled and isWheelScrollingEnabled. Finally, Robot has the new method mouseWheel.

JFrame, JDialog, and JApplet No Longer Override processKeyEvent

The bugtraq report that corresponds to this change is: 4462408.

Swing supports the option of registering key bindings on JComponents. In previous releases it was necessary for Swing top level components ( JFrame, JDialog, and JApplet) to override processKeyEvent (defined in java.awt.Component) to activate these bindings if the focus was ever on one of these top level components. With the addition of java.awt.KeyEventPostProcessor and Swing taking advantage of this ( RFE 4389332), it is no longer necessary for these methods to be overridden in the Swing top level components. As of this release, these methods have been removed at the top level and are now inherited.

Document Headless Exceptions for JWindow Constructors

The bugtraq report that corresponds to this change is: 4483258.

Though the headless mode was added to this release, two JWindow constructors did not indicate that HeadlessException may be thrown. This has been fixed in the doc for Window(Window, GraphicsConfiguration) and JWindow(GraphicsConfiguration).

Known Input Verifier Bug

The bugtraq report that corresponds to this change is: 4532517.

We've recently found an input verifier bug that has been causing problems for some of our users. Under 1.4, the shouldYieldFocus method does not allow side-effects such as popping up an OptionPane.

We do have the following workaround:

    public boolean shouldYieldFocus(JComponent input) {
      if (verify(input)) {
        return true;
      }

      // According to the documentation, should yield focus is allowed to cause
      // side effects.  So temporarily remove the input verifier on the text
      // field.
      input.setInputVerifier(null);
      System.out.println("Removed input verifier");

      // Pop up the message dialog.
      String message = "Roll over the 'JButton1' with mouse pointer "
        + "after closing this dialog.\nIt sometimes behaves correctly "
        + "for the first time\n but repeating action brings incorrect "
        + "behaviour of button.";
      JOptionPane.showMessageDialog(null, message , "invalid value",
        JOptionPane.WARNING_MESSAGE);
      System.out.println("Showed message.");

      // Reinstall the input verifier.
      input.setInputVerifier(this);
      System.out.println("Reinstalled input verifier");

      // Tell whomever called us that we don't want to yield focus.
      return false;
    }

Known Bugs

Focus Bug When Simultaneously Running Windows and a Remote Display Application

In certain circumstances showing a heavy weight Window that is not focusable causes focus to be lost. This specifically happens when running flavors of Windows and a remote display application, such as Reflection-X, at the same time. Note that this bug was filed against release 1.4, but is fixed in 1.4.1. Refer to bug 4628933 for details.

JRootPane

New Multi Implementation of RootPaneUI

The bugtraq report that corresponds to this change is: 4338458.

The classes in javax.swing.plaf.multi are used to multiplex between multiple look and feels. This is typically used by assistive technologies that use an auxiliary look and feel to provide additional information, such as auditory information. There is currently no implementation in multi for RootPaneUI which makes using an auxiliary look and feel problematic.

The new class javax.swing.plaf.multi.MultiRootPaneUI has been added.

Support for Look and Feels to Provide Window Decorations

The bugtraq report that corresponds to this change is: 4290471.

AWT recently provided API such that Windows may be undecorated. That is, when undecorated is true, the Window will not render any widgets for closing, moving, or resizing. As such, Swing has made it possible for the look and feel to render decorations for Windows.

This feature is primarily supported in javax.swing.JRootPane, but we encourage developers to use the switches provided in javax.swing.JFrame and javax.swing.JDialog.

The following changes were made to JRootPane:

    public static final int NONE;
    public static final int FRAME;
    public static final int PLAIN_DIALOG;
    public static final int INFORMATION_DIALOG;
    public static final int ERROR_DIALOG;
    public static final int COLOR_CHOOSER_DIALOG;
    public static final int FILE_CHOOSER_DIALOG;
    public static final int QUESTION_DIALOG;
    public static final int WARNING_DIALOG;

    public void setWindowDecorationStyle(int style)
    public int getWindowDecorationStyle()

Not all look and feels support the window decoration style; the method getSupportsWindowDecorations has been added to javax.swing.LookAndFeel to provide a way for look and feels to indicate whether they support this behavior.

The methods, isDefaultLookAndFeelDecorated(), and setDefaultLookAndFeelDecorated have been added to JFrame.

The methods, isDefaultLookAndFeelDecorated(), and setDefaultLookAndFeelDecorated have also been added to JDialog.

JScrollBar

JScrollBar Now Overrides setUI

The bugtraq report that corresponds to this change is: 4213298.

JScrollBar did not previously override the setUI method. For this release, it has been changed to conform to this behavior.

JScrollPane

JScrollPane Supports New MouseWheelListener

This was implemented as part of the mouse wheel support. This section only documents the changes to JScrollPane, for details of the other changes refer to this section. The bugtraq report that corresponds to this change is: 4356268.

The methods isWheelScrollingEnabled and setWheelScrollingEnabled were added to JScrollPane.

A new protected inner class, MouseWheelHandler, was added to javax.swing.plaf.basic.BasicScrollPaneUI. The relevant method in this inner class is mouseWheelMoved. Finally, the new method createMouseWheelListener has been added to BasicScrollPaneUI.

RepaintManager

New VolatileImage Support

The bugtraq report that corresponds to this change is: 4363288.

The Java 2D team has implemented a new VolatileImage mechanism that has the ability to take advantage of hardware acceleration for Image graphics and blit-to-screen operations.

By default, Swing uses double-buffering to paint the contents of GUI components (by rendering into an offscreen image and then copying that image to the screen) and has been changed to take advantage of the new VolatileImage support.

The double buffer that Swing uses to do painting is obtained from the RepaintManager by using the method getOffscreenBuffer. Since a VolatileImage object requires special handling (to test for failure conditions), we could not simply change this method to return a VolatileImage since there may be existing code out there that invokes this method and does not implement this additional handling. Therefore, we have added a method, getVolatileOffscreenBuffer, to javax.swing.RepaintManager to specifically return a VolatileImage object.

SpringLayout

New SpringLayout Class

The bugtraq report that corresponds to this change is: 4290203.

This release introduces the new layout manager, SpringLayout.

See How to Use SpringLayout in The Java Tutorial for examples of using SpringLayout.

Copyright © 2002 Sun Microsystems, Inc. All Rights Reserved.

Please send comments to: swing-feedback@java.sun.com. This is not a subscription list. 		Sun
Java Software


Swing Packages

 Documentation Contents

  • javax.swing - Provides a set of "lightweight" (written in Java with no native code) components that, to the maximum degree possible, work the same on all platforms.
  • javax.swing.border - Provides classes and interfaces for drawing specialized borders around a Swing component.
  • javax.swing.colorchooser - Contains classes and interfaces used by the JColorChooser component.
  • javax.swing.event - Provides support for events fired by Swing components.
  • javax.swing.filechooser - Contains classes and interfaces used by the JFileChooser component.
  • javax.swing.plaf - Provides one interface and many abstract classes that Swing uses to provide its pluggable look and feel capabilities.
  • javax.swing.plaf.basic - Provides user interface objects built according to the Basic look and feel.
  • javax.swing.plaf.metal - Provides user interface objects built according to the Java look and feel (once codenamed Metal), which is the default look and feel.
  • javax.swing.plaf.multi - Provides user interface objects that combine two or more look and feels.
  • javax.swing.plaf.synth - Provides user interface objects for a skinnable look and feel in which all painting is delegated.
  • javax.swing.table - Provides classes and interfaces for dealing with JTable.
  • javax.swing.text - Provides classes and interfaces that deal with editable and non-editable text components.
  • javax.swing.text.html - Provides the class HTMLEditorKit and supporting classes for creating HTML text editors.
  • javax.swing.text.html.parser - Provides the default HTML parser, along with support classes.
  • javax.swing.text.rtf - Provides a class (RTFEditorKit) for creating Rich Text Format text editors.
  • javax.swing.tree - Provides classes and interfaces for dealing with JTree.
  • javax.swing.undo - Allows developers to provide support for undo/redo in applications such as text editors.


Formatted Text Fields

This document outlines the Swing implementation of formatted text fields. Formatted text fields provide a way for developers to specify the legal set of characters that can be input into a text component. This document is arranged in the following sections:

  • Using JFormattedTextField
  • How JFormattedTextField Works
  • Filtering Input
  • Filtering Navigation
  • JFormattedTextField.AbstractFormatter
  • JFormattedTextField.AbstractFormatterFactory
  • DefaultFormatter
  • AbstractFormatter implementations
  • java.text.Format changes
  • JavaDoc

Using JFormattedTextField

JFormattedTextField will allow formatting of dates, numbers, Strings and arbitrary Objects. JFormattedTextField will rely on the java.text.Format classes to handle formatting of dates and numbers. To create a JFormattedTextField to input dates in the current locale-specific format:

    new JFormattedTextField(new Date());

If you need to display the dates in a specific format, you can use one of the SimpleDateFormat constructors:

    new JFormattedTextField(new SimpleDateFormat("MM/dd/yy"));

Numbers will be handled by an instance of java.text.NumberFormat. The following shows several ways to create a JFormattedTextField to edit numbers.

   new JFormattedTextField(new Number(1000));
   new JFormattedTextField(new DecimalFormat("#,###"));
   new JFormattedTextField(new DecimalFormat("0.###E0"));

JFormattedTextField will also support editing of strings given a mask that specifies what the legal characters are at a given character position. To create a JFormattedTextField to edit US phone numbers the following could be used:

   new JFormattedTextField(new MaskFormatter("(###) ###-####"));

How JFormattedTextField Works

JFormattedTextField itself exposes a minimal amount of API in addition to that of its super class, JTextField. In its simplest terms, JFormattedTextField can be thought of as a JTextField with an additional value property (of type Object) and an object to handle the formatting (instance of AbstractFormatter).

As the value property is of type Object, it is necessary for the developer to cast the return type based on how the JFormattedTextField has been configured. The following shows a typical scenario of using a JFormattedTextField with dates:

  JFormattedTextField ftf = new JFormattedTextField();
  ftf.setValue(new Date());
  ...
  Date date = (Date)ftf.getValue();

A typical session for editing numbers looks like:

  JFormattedTextField ftf = new JFormattedTextField();
  ftf.setValue(new Integer(1000));
  ...
  int intValue = ((Number)ftf.getValue()).intValue();

Filtering Input

Constraining the input into a text component previously required creating a subclass of Document. This is a rather heavy operation for such a simple, and common, usage. To make this task easier, we have created a class, DocumentFilter, that can be plugged into a Document (Document is an interface, which has not changed, instead AbstractDocument now has a setter/getter for a DocumentFilter, and a property is set for Documents that do not descend from AbstractDocument so that others can support DocumentFilter should they want to). When a Document with a DocumentFilter is messaged to remove or insert content, the Document invokes the corresponding method on the DocumentFilter. It is the DocumentFilter's responsibility to issue a callback if the operation should proceed. In this manner the DocumentFilter has total control over how the Document can be mutated. DocumentFilter is defined by:

  public void remove(FilterBypass fb, int offset, int length) throws BadLocationException;
  public void insertString(FilterBypass fb, int offset, String string, AttributeSet attr) throws BadLocationException;
  public void replace(FilterBypass fb, int offset, int length, String string, AttributeSet attr) throws BadLocationException;

If the DocumentFilter wants to mutate the Document from inside the remove or insertString methods, it should either invoke super's implementation, or invoke the method on the FilterBypass. Invoking the method on super or FilterBypass provides a way to circumvent the filter so that the caller doesn't get stuck in stack recursion. The DocumentFilter is not limited to only invoking one method back on the FilterBypass. It can invoke any of the methods exposed by FilterBypass, and can invoke them as many times as it wishes (within the scope of one of DocumentFilter's methods). FilterBypass is defined by:

  public abstract Document getDocument();
  public abstract void remove(int offset, int length) throws BadLocationException;
  public abstract void insertString(int offset, String string, AttributeSet attr) throws BadLocationException;
  public abstract void replace(int offset, int length, String string, AttributeSet attr) throws BadLocationException;

The following example illustrates creating a DocumentFilter that maps lower case to upper case letters:

   DocumentFilter upperDF = new DocumentFilter() {
      public void insertString(FilterBypass fb, int offset, String string, AttributeSet attr) throws BadLocationException {
          super.insertString(fb, offset, string.toUpperCase(), attr);
      }

      public void replace(FilterBypass fb, int offset, int length, String string, AttributeSet attr) throws BadLocationException {
          if (string != null) {
              string = text.toUpperCase();
          }
          super.replace(fb, offset, length, string, attr);
      }
   };

Filtering Navigation

Similar to DocumentFilter, a new class, NavigationFilter, allows for filtering where the selection can be placed. NavigationFilter is called by the navigation actions (such as left, right, center) to determine the next position to place the selection from a given position. NavigationFilter is a property on JTextComponent, and is defined by:

    public void setDot(FilterBypass fb, int dot, Position.Bias bias);
    public void moveDot(FilterBypass fb, int dot, Position.Bias bias);
    public int getNextVisualPositionFrom(JTextComponent text, int pos, Position.Bias bias, int direction, Position.Bias[] biasRet) throws BadLocationException;

Note that getNextVisualPositionFrom is defined in View; for consistency, the method in NavigationFilter is named the same.

Similar to DocumentFilter, NavigationFilter is passed a FilterBypass that should be invoked to handle the actual mutation. NavigationFilter.FilterBypass is defined by:

    public abstract Caret getCaret();
    public abstract void setDot(int dot, Position.Bias bias);
    public abstract void moveDot(int dot, Position.Bias bias);

JFormattedTextField.AbstractFormatter

As previously mentioned, an instance of AbstractFormatter is used to format a particular Object value. AbstractFormatter can also impose an editing policy by defining a DocumentFilter; it can also impose a navigation policy by defining a NavigationFilter. AbstractFormatter is defined by:

    public void install(JFormattedTextField ftf);
    public void uninstall();
    public abstract Object stringToValue(String text) throws ParseException;
    public abstract String valueToString(Object value) throws ParseException;
    protected JFormattedTextField getFormattedTextField();
    protected void setEditValid(boolean valid);
    protected void invalidEdit();
    protected Action[] getActions();
    protected DocumentFilter getDocumentFilter();
    protected NavigationFilter getNavigationFilter();

Once JFormattedTextField is ready to use an AbstractFormatter it invokes install. AbstractFormatter.install performs the following:

  1. Sets the text of the JFormattedTextField to the return value of valueToString (if a ParseException is thrown, an empty String is used and setEditValid(false) is invoked).
  2. Installs the DocumentFilter returned from getDocumentFilter onto the JFormattedTextField's Document.
  3. Installs the NavigationFilter returned from getNavigationFilter onto the JFormattedTextField.
  4. Installs the Actions returned from getActions onto the JFormattedTextField's ActionMap.

Subclasses will typically only override install if they need to install additional Listeners beyond the DocumentFilter and NavigationFilter, or perhaps place the caret at an initial location.

Some AbstractFormatters allow the JFormattedTextField to contain an invalid value when editing. To allow the JFormattedTextField to provide an indication of this, the AbstractFormatter should invoke setEditValid(false) when the user enters an invalid value, and then invoke setEditValid(true) when the value is valid again.

When JFormattedTextField is done with an AbstractFormatter, it invokes uninstall. uninstall removes the previously installed Listeners.

JFormattedTextField.AbstractFormatterFactory

JFormattedTextField delegates the creation of AbstractFormatters to an instance of AbstractFormatterFactory (a public static inner class of JFormattedTextField). This makes it easy for developers to provide different formatters for different states of the JFormattedTextField. For example, you could provide a special AbstractFormatter if the current value is null, or one formatter when editing and another when displaying. AbstractFormatterFactory is defined by:

    public abstract AbstractFormatter getFormatter(JFormattedTextField ftf);

If the developer has not supplied an AbstractFormatterFactory, one will be created based on the Class of the value.

DefaultFormatter

DefaultFormatter extends JFormattedTextField.AbstractFormatter and is the superclass for all of the formatter implementations we provide. DefaultFormatter formats Objects using toString and creates the Object using the constructor that takes a String. DefaultFormatter allows a number of configuration options:
Option | Description
CommitsOnValidEdit | Determines when edits are published back to the JFormattedTextField. If true, commitEdit is invoked on the JFormattedTextField after every successful edit, otherwise commitEdit is invoked only when return is pressed.
OverwriteMode | Configures the behavior when inserting characters. If overwriteMode is true (the default), new characters overwrite existing characters in the model as they are inserted.
AllowsInvalid | Determines whether the value being edited is allowed to be invalid. It is often convenient to allow the user to enter invalid values until a commit is attempted.

AbstractFormatter implementations

The following table lists the AbstractFormatter implementations that we provide, as well as intended use:
AbstractFormatter | Object Type | Notes
DefaultFormatter | Object | valueToString uses Object.toString(), and stringToValue uses the single argument constructor that takes a String.
MaskFormatter | Strings | Behavior is dictated by a per character mask that specifies legal values (e.g. "###-####").
InternationalFormatter | Objects | Uses an instance of java.text.Format to handle valueToString and stringToValue.
NumberFormatter | Numbers | Uses an instance of NumberFormat to handle formatting, descends from InternationalFormatter.
DateFormatter | Date | Uses an instance of DateFormat to handle formatting, descends from InternationalFormatter.

java.text.Format changes

The Swing support for formatted dates and numbers made extensive use of the Format classes in the java.text package. The following problems were encountered using the previous API:

  • You could only get the limits of one field at a time. If you wanted more, you had to invoke format repeatedly.
  • The previous field constants were not sufficient to describe the entire text of the formatted strings. One glaring omission was the exponential part of formatted numbers.
  • Using integer IDs for a set of constants that pretended to be extensible wasn't very elegant. When new constants were added, there could potentially be a conflict with any Format subclasses out there that we didn't know about. Note that the constants for DateFormat and NumberFormat already overlap, so a NumberFormat would have happily interpreted YEAR_FIELD as FRACTION_FIELD. The problem was exacerbated by the existence of the polymorphic Format.format(Object, StringBuffer, FieldPosition) method.
  • The specification didn't define the behavior if a field didn't exist in a formatted string, and the actual results varied between different releases.
  • The specification didn't define the behavior if a field wasn't recognized by a formatter; for example, if I asked a NumberFormat for the MONTH_FIELD (the actual implementation of this case returned 0 for both begin index and end index).
  • Because of that, a caller could not find out which fields a Format subclass actually supported unless it knew the specific subclass. This, along with the fact that not all characters in a formatted string are part of fields, makes the implementation of a generic method that returns all fields impossible.

These issues have largely been addressed by adding the following method to java.text.Format:

    public AttributedCharacterIterator formatToCharacterIterator(Object obj);

Each Format class uses a type safe enumeration for the constants it supports.

JavaDoc

New Classes

The following classes are new to the 1.4 release:

  • JFormattedTextField
  • DocumentFilter
  • NavigationFilter
  • JFormattedTextField.AbstractFormatter
  • JFormattedTextField.AbstractFormatterFactory
  • DefaultFormatterFactory
  • DefaultFormatter
  • MaskFormatter
  • InternationalFormatter
  • Number Formatter
  • DateFormatter

Constants are renamed to conform to Java naming conventions

The bugtraq report that corresponds to this change is: 4468474.

The following constants have been replaced to conform Java to naming conventions:

  • CommitValueOnFocusLost has been replaced with COMMIT.
  • CommitOrRevertValueOnFocusLost has been replaced with COMMIT_OR_REVERT.
  • RevertValueOnFocusLost has been replaced with REVERT.
  • PersistValueOnFocusLost has been replaced with PERSIST.


Indeterminate Progress Bars

This document describes the changes we made to implement indeterminate progress bars -- GUI components that look similar to normal progress bars and, like normal progress bars, use animation to show that a time-consuming operation is occurring. Unlike normal progress bars, indeterminate progress bars do not show the degree of completeness of the operation. This document has the following sections:

  • New JProgressBar API
  • New UI Defaults
  • New BasicProgressBarUI API
  • Converting Existing Progress Bar Implementations
  • Implementation Details
  • Javadoc for New API

New JProgressBar API

By default, every progress bar (created using one of several JProgressBar constructors) is determinate. You may make any JProgressBar indeterminate using the setIndeterminate method:

    pb.setIndeterminate(true);

An indeterminate progress bar animates constantly. You can stop the animation and clear the progress bar by making the progress bar determinate and setting the current value to the minimum. For example:

    pb.setValue(pb.getMinimum());
    pb.setIndeterminate(false);

You can switch from determinate to indeterminate mode, and vice versa, at any time. You can check whether the progress bar is indeterminate using the isIndeterminate method.

When a progress bar is indeterminate, it ignores its model (a BoundedRangeModel). However, the model should exist and contain legal data, since L&Fs that haven't been updated for indeterminate progress bars might use the model.

New UI Defaults

To give developers control over the progress bar's speed of animation, we've added two new UI defaults:

  • "ProgressBar.repaintInterval"
  • "ProgressBar.cycleTime"

The "ProgressBar.cycleTime" UI default lets look and feel implementers (as well as other developers)specify how many milliseconds each animation cycle takes. For example, a cycle time of 500 means that the indeterminate-mode progress bar animation repeats twice per second. The default drawing code uses this value --along with the repaint interval, box length, and component inner area --to determine how far to move the bouncing box each time it's drawn. This value must be an even multiple of the repaint interval. For example, if the repaint interval is 100, then valid cycle times are 200, 1000, and 1200, but not 100 or 500. If the user specifies an invalid cycle time,the indeterminate progress bar code automatically increases the cycle time to a suitable value.

To set the repaint interval and cycle time defaults:

    UIManager.put("ProgressBar.repaintInterval", new Integer(250));
    UIManager.put("ProgressBar.cycleTime", new Integer(6000));

To get the repaint interval and cycle time:

    int interval = UIManager.getInt("ProgressBar.repaintInterval");
    int totalTime = UIManager.getInt("ProgressBar.cycleTime");

In the basic, JLF, Motif, and Windows implementations provided by Sun, these defaults are checked when (and only when) the progress bar is switching into indeterminate mode.

New BasicProgressBarUI API

To help programmers implement look-and-feel code for progress bars,we have added the following API to the BasicProgressBarUI class.

Methods related to painting:

  • protected void paintIndeterminate(Graphics g, JComponent c)
  • protected void paintDeterminate(Graphics g, JComponent c)
  • protected Rectangle getBox(Rectangle)

Methods for setting and getting the index of the current frame of animation:

  • protected int getAnimationIndex()
  • protected void setAnimationIndex(int newValue)
  • protected void incrementAnimationIndex()

Methods for starting and stopping custom animation threads:

  • protected void startAnimationTimer()
  • protected void stopAnimationTimer()

The paint method that previously performed all painting for the progress bar now delegates all its drawing to either paintDeterminate or paintIndeterminate, depending on the value of the progress bar's indeterminate property. When the progress bar is in indeterminate mode, the paint method (and thus the paintIndeterminate method) executes every repaint interval milliseconds.The paintIndeterminate method should paint the progress bar to match the animation state, which is specified by the getAnimationIndex method.

The getBox method allows implementations to customize bouncing box painting. For example, MetalProgressBarUI invokes getBox in its paintIndeterminate method to get the box drawn by the superclass (BasicProgressBarUI) and then to add an outline to the box. By overriding the getBox method, an implementer gets full control over the bouncing box's size and position without needing to reimplement paintIndeterminate.

If you override paintIndeterminate or getBox, you might also have to override incrementAnimationIndex so that it cycles correctly through the valid values. The first value (representing the first drawing) is 0. By convention, the second is 1, the third is 2, and so on. The last legal value is, by convention, the total number of drawings in the animation cycle, minus one. To determine the total number of drawings, you may need to take into account the repaint interval and perhaps the component size. As the "by convention" implies, you can implement the animation index to have any meaning and values you wish, as long as zero indicates the beginning of the animation cycle.

If you don't want to use the animation thread we provide, you must override the two xxx AnimationTimer methods. You can then provide your own implementation that periodically increments the animation index and invokes repaint on the progress bar.

As a side effect of the progress bar work, we've added a new method to SwingUtilities:

  • public static Rectangle calculateInnerArea(Component c, Rectangle r)

The calculateInnerArea method is useful to all classes that perform drawing. It returns the area in which the component can draw -- that is, the rectangle (in the component's coordinate system) that includes all of the component except its border area (the component's insets).

Converting Existing Progress Bar Implementations

Converting an existing L&F to indeterminate progress bars is relatively straightforward. If the L&F's progress bar UI class doesn't override paint (or does but also invokes super.paint), then support for indeterminate progress bars is automatic. WindowsProgressBarUI, MotifProgressBarUI, and MetalProgressBarUI are in this lucky camp.

If the L&F's progress bar UI class is a subclass of BasicProgressBarUI and overrides paint without invoking the superclass version, then determinate mode still works, but indeterminate mode looks the same as determinate mode.

Existing drawing code should be moved out of the paint method and into the new paintDeterminate method. Code for indeterminate painting should go in the new paintIndeterminate method. If at all possible, the paint method should not be overridden unless it invokes super.paint. The reason: the BasicProgressBarUI implementation of the paint method may work with the default animation thread to enhance performance and behavior.

The Mac look and feel (both the no-longer-maintained Sun version and the Apple version) is an example of a look and feel that overrides paint without invoking the superclass version.

If you already have a thread scheme for indeterminate painting, you can continue to use that scheme by overriding startAnimationTimer and stopAnimationTimer. Or you can just delete your thread code and use our scheme.

Implementation Details

The BasicProgressBarUI class contains most of our implementation of indeterminate progress bars. Aside from the drawing code, most of the code is in two private inner classes: Animator, which implements the animation thread, andPropertyChangeHandler, which listens for changes to and from indeterminate mode.

The Animator implements the default animation thread, using the Swing Timer class. An Animator instance is created if necessary by the BasicProgressBarUI.startAnimationTimer method, which the property handler invokes when the progress bar switches to indeterminate mode. When the progress bar is indeterminate, the Animator timer fires an action event once every repaint interval milliseconds. Animator's action event handler invokes incrementAnimationIndex, followed by repaint (which causes paintIndeterminate to run). Repaint interval is specified by the ProgressBar.repaintInterval UI default, which is checked by startAnimationTimer.

The PropertyChangeHandler registers itself as a property listener on the progress bar. When it detects the "indeterminate" property changing,the handler notes the change and invokes either stopAnimationTimer or startAnimationTimer.

Javadoc for New API

In javax.swing.JProgressBar:

    public void setIndeterminate(boolean newValue)

    public boolean isIndeterminate()

In javax.swing.plaf.basic.BasicProgressBarUI:

    protected void paintIndeterminate(Graphics g, JComponent c)

    protected void paintDeterminate(Graphics g, JComponent c)

    protected int getAnimationIndex()

    protected void setAnimationIndex(int newValue)

    protected void incrementAnimationIndex()

    protected void startAnimationTimer()

    protected void stopAnimationTimer()

    protected Rectangle getBox(Rectangle r)

In javax.swing.SwingUtilities:


JSpinner - A Simple Sequence Container

This document describes the new Swing component, JSpinner.

One of the most commonly requested new Swing components is a spinner - a single line input field that lets the user select an number or an object value from an ordered set. Spinners typically provide a pair of tiny arrow buttons for stepping through the possible values, the up/down arrow keys also cycle through the values. The user may also be allowed to type a (legal) value directly into the spinner. Although combo boxes provide similar functionality, spinners are sometimes preferred because they don't require a drop down list that can obscure important data.

The bugtraq report that corresponds to this change is: 4290529.

A Short Catalog of Spinners

Spinners are common in modern GUIs. Here are some examples from some popular look and feels and from OpenWindows:
Windows spinner | CDE/Motif spinner | JLF spinner | Mac Aqua spinner | OpenWindows spinner
Windows | CDE/Motif | JLF | Mac Aqua | OpenWindows

All of the spinners deliver very simple behavior: clicking on the arrow buttons changes the fields value and, when the spinner has the focus, the keyboard up and down arrow keys do the same. In some applications the spinners up or down arrow button is disabled when the upper or lower limit of the spinner has been reached, in other cases the spinner just resets its value to the opposite extreme.

JSpinner, SpinnerModel, SpinnerListModel

The JSpinner class is a simple Swing container that manages three children: two arrow buttons and a single component, called the editor that displays the spinner's value. The value displayed by the spinner is encapsulated by model of a sequence of objects called a SpinnerModel.

public interface SpinnerModel {
    Object getValue();
    void setValue(Object);
    Object getNextValue();
    Object getPreviousValue();
    void addChangeListener(ChangeListener x);
    void removeChangeListener(ChangeListener x);}

The SpinnerModel interface is similar to ListModel - they both represent a sequence a values - however there are some important differences:

  • The model doesn't support random access to sequence elements. Only three sequence values are accessible at a time: current, next and previous.
  • The number of sequence elements isn't necessarily bounded so there's no sequence length returning size method.
  • The model's value property is read/write, unlike the elements of a ListModels sequence, which are read-only. This difference reflects the different roles of JList and JSpinner. The former was designed to simplify selecting one or more items from a list and the latter for entering a single value directly.

The relationship between the JSpinner and its model is simple. The editor component monitors the model with a ChangeListener and always displays the object returned by SpinnerModel.getValue(). The up and down arrow buttons update the value by calling setValue(getNextValue()) or setValue(getPreviousValue()) respectively. The getNextValue and getPreviousValue methods return null when the end or the beginning of the sequence has been reached, so the arrow button actions have to check for null before updating the models value. If the editor is a writable field of some kind, it's responsible for honoring the constraints defined by the model or handling the IllegalArgumentException thrown by setValue for invalid values.

The SpinnerListModel provides support for two common mutable sequence types: java.util.List, and an array of objects. For example to create a JSpinner that lets the user choose a day of the week in the default locale one could write:

    String[] days = new DateFormatSymbols().getWeekdays();
    SpinnerModel model = new SpinnerListModel(days);
    JSpinner spinner = new JSpinner(model);

In addition to initializing the model property of the spinner, these constructors create an editor component that displays the SpinnerModel's value and can be used to change it. The protected JSpinner.createEditor method is used for this and, by default, it creates a JFormattedTextField that has been configured to display the model.

To find or initialize a spinners current value one can either use the models value property or use the convenience JSpinner value property which just delegates to the model. For example, using the spinner configured in the example above, the following two statements are equivalent:

    String selectedDay = spinner.getModel().getValue().toString();
    String selectedDay = spinner.getValue().toString();

Setting the spinner's value is similar. Attempts to set the SpinnerModel value to an object that the model doesn't support cause an IllegalArgumentException to be thrown.

Dates and numbers are two of the most common applications for a spinner component. To simplify spinning these types, two additional SpinnerModel implementation classes are provided: SpinnerDateModel and SpinnerNumberModel.

SpinnerDateModel

One of the most common uses of a spinner is to compactly present an editable date. Here's a simple example of creating a JSpinner that allows the user to enter a (fully localized) date:

    SpinnerDateModel model = new SpinnerDateModel();
    JSpinner spinner = new JSpinner(model);
    Date value = model.getDate();

In this example, the JSpinner constructor has created a JFormattedTextField editor that's configured for editing dates and it has added a ChangeListener to the SpinnerDateModel to keep the editor and the model in sync.

Here's the SpinnerDateModel API. We've added three new read/write properties: start, end, and stepSize and a read-only date property that returns the models value cast to a Date.

public class SpinnerDateModel extends AbstractSpinnerModel {
    public SpinnerDateModel(Date value, Comparable start, Comparable end, int stepSize)
    public SpinnerDateModel()
    public void setStart(Comparable start)
    public Comparable getStart()
    public void setEnd(Comparable end)
    public Comparable getEnd()
    public Object getNextValue()
    public Object getPreviousValue()
    public Date getDate()
    public Object getValue()
    public void setValue(Object value)}

The startDate and endDate properties can be null to indicate that there is no lower or upper limit. The no-arguments SpinnerDateModel constructor initializes both the start and end date to null, the initial value of the model is the current date.

The value of the stepSize property must be one of the java.util.Calendar constants that specify a field within a Calendar. The getNextValue and getPreviousValue methods change the date forward or backwards by this amount. For example, if stepSize is Calendar.DAY_OF_WEEK, then nextValue produces a Date that's 24 hours after the current value, and previousValue produces a Date that's 24 hours earlier.

The legal values for stepSize are:

  • Calendar.ERA
  • Calendar.YEAR
  • Calendar.MONTH
  • Calendar.WEEK_OF_YEAR
  • Calendar.WEEK_OF_MONTH
  • Calendar.DAY_OF_MONTH
  • Calendar.DAY_OF_YEAR
  • Calendar.DAY_OF_WEEK
  • Calendar.DAY_OF_WEEK_IN_MONTH
  • Calendar.AM_PM
  • Calendar.HOUR
  • Calendar.HOUR_OF_DAY
  • Calendar.MINUTE
  • Calendar.SECOND
  • Calendar.MILLISECOND

The default SpinnerDateModel editor adjusts the stepSize property based on the text cursor position. For example if the cursor moves into the editor's month subfield then the incrementSize would be changed to Calendar.DAY_OF_MONTH.

SpinnerNumberModel

Spinners are often used to present editable integers and real numbers that represent everything from temperature to stock prices. The SpinnerNumberModel provides basic support for all of the basic Java Number types, from Byte to Double.

To create a spinner that allows the user to pick a real multiple of 1/8 between 0.0 and 1000.0, with an initial value of 500.0, one could write:

    SpinnerNumberModel model = new SpinnerNumberModel(500.0, 0.0, 1000.0, 0.625);
    JSpinner spinner = new JSpinner(model);
    double value = model.getNumber().doubleValue();

In this example, the JSpinner constructor has created a JFormattedTextField editor that's configured for editing real numbers and it has added a ChangeListener to the SpinnerNumberModel to keep the editor and the model in sync.

Here's a summary of the SpinnerNumberModel API. We've added three new read/write properties: minimum, maximum, and stepSize and a read-only number property that returns the models value cast to a Number.

public class SpinnerNumberModel extends AbstractSpinnerModel {
    public SpinnerNumberModel(Number value, Comparable minimum, Comparable maximum, Number stepSize)
    public SpinnerNumberModel(int value, int minimum, int maximum, int stepSize)
    public SpinnerNumberModel(double value, double minimum, double maximum, double stepSize)
    public SpinnerNumberModel()
    public void setMinimum(Comparable minimum)
    public Comparable getMinimum()
    public void setMaximum(Comparable maximum)
    public Comparable getMaximum()
    public void setStepSize(Number stepSize)
    public Number getStepSize()
    public Object getNextValue()
    public Object getPreviousValue()
    public Number getNumber()
    public Object getValue()
    public void setValue(Object value)}

As with the SpinnerDateModel, the minimum and maximum properties can be null to indicate that there is no lower or upper limit. The stepSize property just specifies how much to add or subtract from the value to compute the nextValue or the previousValue.

Summary of the Spinner APIs

Support for spinners added six classes and one interface (SpinnerModel) to the javax.swing package:

  • JSpinner
  • SpinnerListModel
  • AbstractSpinnerModel
  • SpinnerDateModel
  • SpinnerModel
  • SpinnerNumberModel

Additionally, SpinnerUI has been added to the javax.swing.plaf package and BasicSpinnerUI to the javax.swing.plaf.basic package:

  • SpinnerUI
  • BasicSpinnerUI


Popup & PopupFactory

The bugtraq report that corresponds to this change is: 4303635.

Certain Components, such as JPopupMenu and JToolTip, present themselves above all other Components in a particular containment hierarchy. Rather than each of these Components containing the same code to obtain the same behavior, they delegate to a Popup which can be obtained from a PopupFactory. A Popup is able to display a Component at a particular location on the screen. Based on the size and location of the requested Component, PopupFactory returns an appropriate Popup.

Previously, Popup and PopupFactory were package private. For JDK 1.4, we have exposed these classes to enable custom look and feel implementations to create their own Popups. This allows other look and feels to position menus in an appropriate manner for their look and feel. To this end, we have made these classes public:

public class PopupFactory {
    public static void setSharedInstance(PopupFactory factory);
    public static PopupFactory getSharedInstance();
    public Popup getPopup(Component owner, Component contents, int x, int y) throws IllegalArgumentException;
    }

public class Popup {
    protected Popup(Component owner, Component contents, int x, int y);
    protected Popup();
    public void show();
    public void hide();
    }

To enable the Popup used by JPopupMenu to be replaced by the UI, we added the following to PopupMenuUI:

    public Popup getPopup(JPopupMenu popup, int x, int y);

PopupMenuUI.getPopup's implementation obtains the Popup from the shared PopupFactory, but custom look and feel implementations may override this and return whatever Popup they desire.

Semantic Changes

JPopupMenu previously defined the method setLocation. Prior to this release, this method would invoke setLocation on the Popup, but as we have removed this method from Popup, JPopupMenu now recreates the Popup.

JPopupMenu also defined the method setPopupSize, which invoked setSize on the Popup if it was visible. Internally, we changed this method to set the preferred size of the JPopupMenu, which gives the same results. If the JPopupMenu is visible when this is invoked, the Popup will be recreated. The JPopupMenu javadoc changed to reflect the new behavior:

    public void setPopupSize(Dimension d);

    public void setPopupSize(int width, int height);


Scrollable Tabs

JTabbedPane: Scrollable Tabs

Previously with JTabbedPane, if all the tabs did not fit within a single tab run, the JTabbedPane wrapped tabs onto multiple runs. There have been many requests to provide an alternative scheme, where the JTabbedPane would instead display a single, scrollable run of tabs. This document describes the new API for providing such scrollable tab support in JTabbedPane for the 1.4 release. The bugtraq report that corresponds to this change is: 4093898.

  • The Too-Many-Tabs Dilemma
  • New JTabbedPane API
  • Compatibility

The Too-Many-Tabs Dilemma

Wrapping tabs onto multiple lines provides the benefit of always allowing the user to view all possible tab selections at a given time:

Graphic with two rows of tabs. The first row has five, the second row has four.

However, the problem with multiple runs is in handling the case where the user selects a tab in a run which is not adjacent to the panel display area. For the Windows and Motif look and feel implementations, this action will cause the runs to rotate such that the run containing the selected tab is placed adjacent to the panel display area.

Graphic with selected tab adjacent to panel display area

This behavior can be extremely disorienting to the user because it constantly re-arranges the tabs, eliminating predictability in the UI. The Metal look and feel solved this problem by always leaving the runs fixed, even if the selected tab is not adjacent to the panel display area:

Graphic with selected tab is denoted by different color

Unfortunately the downside of the Metal solution is that it visually departs from the 'tabbed folder' metaphor (the selected tab is not 'attached' to its content). In fact, Chapter 7 of the Java Look and Feel Guidelines recommends against creating tabbed panes with multiple runs:

"If your tabbed pane requires multiple rows of tabs, consider dividing the content among several dialog boxes or components. Multiple rows of tabs can be confusing."

While constraining tabs in a tabbed pane to a number which will fit within a single run is an important UI guideline, there are circumstances where a proliferation of tabs cannot be avoided. This is often the case if the tabs are created dynamically by the application at runtime (perhaps driven off the content of a database).

An alternate solution for handling the tab proliferation case is to constrain the tabbed pane to a single, scrollable run of tabs:

Graphic with a single row of tabs that does not include all the possible choices

Naturally, this solution has its own set of usability problems, the most obvious of which is that the user can no longer view all possible selections at one time. However, this scrollable-tab behavior is becoming increasingly common in user interfaces and therefore Swing now supports it as an option.

New JTabbedPane API

To allow programs to define which tab layout behavior they require, we now provide a "tabLayoutPolicy" bound property on JTabbedPane:

    public void setTabLayoutPolicy(int layoutPolicy)

    public boolean getTabLayoutPolicy()

Additionally, constants for the supported policy values have been added to JTabbedPane:

    public static final int WRAP_TAB_LAYOUT = 0;

    public static final int SCROLL_TAB_LAYOUT = 1;

Compatibility

This feature had no impact on compatibility, as the default value for the tabLayoutPolicy property is WRAP_TAB_LAYOUT which matches the previous layout behavior of the tabbed pane.


Swing Changes Since Java 2 SDK, v1.4

Java

Swing Changes Since JavaTM 2 SDK, Standard Edition, v 1.4

 Project Swing

The Swing Changes and New Features for Java 2 SDK, Standard Edition, v 1.4 document describes changes for all the 1.4.* releases. This document provides links to changes specific to the 1.4.1 and 1.4.2 releases.

Changes for the Incremental Release, Java 2 SDK, S.E., v1.4.1

For Swing, this release primarily features bugfixes. Bugs that have been fixed include:

Focus related bugs:

  • 4632782: JPopupMenu may now be prevented from taking focus
  • 4628933: Heavy weight windows may lose focus when running on some versions of Microsoft Windows with a remote display application
  • 4659800: Default button should follow the focus on Microsoft Windows look and feel
  • JTabbedPane and Focus Clarification

Drag and drop related bugs:

  • 4513715: Drop no longer clobbers selected text
  • 4513638: Cut/copy/drag fixed for JEditorPane with RTFEditorKit
  • Import/export behavior has changed for the JEditorPane component

Miscellaneous:

  • 4532517: Workaround for input verifier bug
  • 4419964, 4668963: Metal look and feel can now pick up font sizes from the desktop on Microsoft Windows
  • 4615396: Some locales will only honor font size from the desktop
  • 4668511: Deadlock in JColorChooser
  • 4218431: Document that multiple file selection is supported in JFileChooser

Changes for the Incremental Release, Java 2 SDK, S.E., v1.4.2

In addition to many bugfixes, this release features these new enhancements:

JFileChooser Performance Enhancements

The bugtraq reports that correspond to this change are: 4679673 and 4712307.

This release features many performance improvements to JFileChooser. In some situations, JFileChooser now performs 300 times faster.

Windows XP look and feel

Release 1.4.2 introduces support for the standard Microsoft Windows XP appearance as the default when running on the Windows XP platform. This look and feel automatically appears if your app is using Swing's WindowsLookAndFeel class (either by way of UIManager.getSystemLookAndFeelClassName() or by explicitly using com.sun.java.swing.plaf.windows.WindowsLookAndFeel) on a machine running the Windows XP operating system. The following example illustrates the preferred way of setting the look and feel to match that of the native platform:

  UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

If you prefer your Swing app to look like a classic Windows app you can turn of the XP look using the system property swing.noxp=true. This is typically used as a command line parameter, eg:

  java -Dswing.noxp=true -jar SwingSet2.jar

Note that the swing.noxp property may not be supported in future releases.

GTK+ look and feel

Release 1.4.2 introduces a look and feel based on GTK+ 2.0. In order to get this look and feel you need to explicitly ask for it by way of UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel") or by defining the system property swing.defaultlaf to be com.sun.java.swing.plaf.gtk.GTKLookAndFeel. In the next release we will make UIManager.getSystemLookAndFeelClassName() return this look and feel when appropriate.

The GTK+ look and feel can be customized by way of resource files. Swing's GTK+ look and feel uses the following algorithm to locate the resource files:

  1. If the system property swing.gtkthemefile exists, parse it and stop, for example: java -Dswing.gtkthemefile=/tmp/customTheme -jar SwingSet2.jar.
  2. If the file user.home/.gtkrc-2.0 exists, parse it and continue.
  3. Determine the user selected theme name (THEMENAME) by way of the desktop property gnome.net/ThemeName which is determined using XSETTINGS. If this property is null, use Default as THEMENAME.
    1. If the file user.home/.themes/THEMENAME/gtk-2.0/gtkrc exists parse it and stop.
    2. If the system property swing.gtkthemedir exists and the file swing.gtkthemedir/THEMENAME/gtk-2.0/gtkrc exists, parse it and stop.
    3. If the system property swing.gtkthemedir doesn't exist and the file /usr/share/themes/THEMENAME/gtk-2.0/gtkrc exists, parse it and stop.
    4. Lastly if swing.gtkthemedir is defined parse swing.gtkthemedir/THEMENAME/gtk/gtkrc, otherwise parse /usr/share/themes/THEMENAME/gtk/gtkrc.

One way GTK+ can be customized is by way of a theme engine. A handful of engines exist. In 1.4.2, Swing supports theme files for Default, pixmap, and bluecurve engines. We are investigating ways to open up the API to allow for the creation of additional GTK engines. Visit http://www.themes.org for examples.

GTK+ allows for specifying fonts in two ways: using an XLFD or using a pango string. Pango provides for facilities similar to the composite Fonts on the Java platform, that is, a font that consists of a number of different fonts for different code points. Because pango's composite fonts do not exactly match Java's composite fonts, a Swing app with the GTKLookAndFeel will not exactly match a native GTK+ app. We are investigating ways to deal with this. One option is to replace your pango font file with a version equivalent to Java's font.properties file. Additionally we currently ignore XLFDs and pass Pango strings (after mapping sans to sansserif and monospace to monospaced) directly to a java.awt.Font.

GTK+ does not provide MDI (JInternalFrame) capabilities nor does it directly support theming of top level windows, rather that is left up to the WindowManager. For Swing's MDI classes we support theming by way of Metacity. We currently only support the Crux and Bluecurve themes. If we can not locate either of these themes we fall back to our own custom theme. You can use the system property swing.metacitythemename to name a particular theme to use, otherwise we will look in user.dir/.gconf/apps/metacity/general/%gconf.xml to determine the name of theme and look in /usr/share/themes/THEMENAME/metacity-1/metacity-theme-1.xml or /usr/gnome/share/themes/THEMENAME/metacity-1/metacity-theme-1.xml for the actual resource file. The following example shows how to trigger Swing to use a specific metacity theme:

  java -Dswing.metacitythemename=Bluecurve -jar SwingSet2.jar

GTK+ resource files allow for customizing a number of look and feel options beyond the look. In 1.4.2 we support the primary style configurations (fg, bg, base ..), gtk-font-name, gtk-icon-sizes, stock icons (for optionpane), focus-line-width, focus-padding, focus-line-pattern, internal-padding, shadow-type (for menubars), and trough-border.

GTK provides a mechanism for which running applications can pick up a theme change and automatically update the UI, this will be supported in a future version of Swing's GTK look and feel.

GTK Incompatabilities

Correctly supporting a GTK+ look and feel posed a number of challenges to Swing's current architecture. In Swing an opaque component ALWAYS paints its background by way of ComponentUI's update method, in GTK+ a nonopaque component may or may not paint the background, depending upon the engine. To correctly mirror GTK+ a number of Components that previously were opaque have been made nonopaque (by way of the ComponentUI subclass's installUI method). Additionally because the look of a component can change based on the containment hierarchy the opacity may change after the constructor has completed. A ramification of this is that if you invoke setOpaque() on a component, it may change out from under you. We will fix this in the next release.

GTK+ calls into the engine to paint border decorations before the actual contents of the widget are painted. Some engines, most notably the pixmap engine, rely on this ordering to correctly render decorations behind the contents. In Swing the border is rendered after the widget contents are painted. In the GTKLookAndFeel we install a Border only to provide space, and let the UI do the actual rendering of the border decorations as part of the paint method. The ramification of this is that if you install a Border on a widget with the GTKLookAndFeel you will likely not get the effect you are after. Again, we are investigating alternatives and will provide a better solution in the next release.

1.4.2 Bugs

One bug worth mentioning:
  • 4759306: JColorChooser.setPreviewPanel does not remove the old one.

Copyright © 2002 Sun Microsystems, Inc. All Rights Reserved.

Please send comments to: swing-feedback@java.sun.com. This is not a subscription list. 		Sun
Java Software


Swing Data Transfer

For the JavaTM 2 Platform, Standard Edition, v 1.4 release, Swing has added support for data transfer between applications. A drag and drop operation is a data transfer request that has been specified by a gesture with a graphical pointing device. In the case of copy/paste, data transfer is often initiated with the keyboard. The ability to transfer data takes two forms:

  • Drag and drop (DnD) support
  • Clipboard transfer via cut/copy/paste
When adding data transfer support to Swing, the goal was to make it easy for developers using Swing components to add clipboard transfer as well as drag and drop to an application. Previous AWT support for drag and drop provided a great deal of flexibility, but also a fair amount of complexity, to implement. Also, AWT support for clipboard transfer had not been integrated into Swing in a natural way. For this release, data transfer support has been implemented so that the developer may take advantage of these powerful features with minimal effort.

Because the state of each Swing component is independent of the definition of the data model, it was easy to implement a mechanism for moving the data between components without worrying about the details of the data itself. The data transfer amounts to transferring part of one model to another model. (In the case of cut/copy/paste, the data is transferred between the model and the clipboard.) To support data transfer, we:

  • Added a small amount of API to enable data transfer with a few method calls.
  • Made it possible to disable the Swing DnD implementation so that the user can use the support provided by AWT to customize any special behavior.
  • Implemented the necessary changes in the look and feel implementations we provide.

Quick Reference: Components That Support DnD

Component | Supports Drag | Supports Drop
JColorChooser | X | X
JEditorPane | X | X
JFileChooser | X |
JFormattedTextField | X | X
JLabel | see here | see here
JList | X |
JPasswordField |  | X
JTable | X |
JTextArea | X | X
JTextField | X | X
JTextPane | X | X
JTree | X |

This document has the following sections:

  • Data Transfer Support
    • Default TransferHandler Support
    • Example of Adding Support to JLabel
  • Drag Support
    • Default Drag Support
    • Adding Drag Support to Subclasses of Swing Classes
    • Operation of TransferHandler.exportAsDrag
  • Drop Support
    • Default Drop Support
    • Using the Drop Support in Subclasses of Swing Classes
  • Clipboard Transfer Support
    • Default Clipboard Transfer
    • Using the Clipboard Transfer Support in Subclasses of Swing Classes
  • Implementation Details
  • Changes Since Beta
  • Known Bugs

Data Transfer Support

The foundation of data transfer is support for handling the transfer of data into and out of a component. With this functionality available on the component, the mechanics of managing a drag and drop can be provided automatically. In addition, support for cut/copy/paste can also be provided automatically. The crux of this implementation is the new class TransferHandler. The JComponent property methods, setTransferHandler and getTransferHandler, provide an entrypoint to the data transfer mechanism for any component which extends JComponent.

The table below details the extent of the cut, copy, paste, and drop support for each of the components when a non-null TransferHandler is installed. Note that this support is enabled by the look and feel code. Support for dragging is initially disabled, but may be enabled by calling setDragEnabled(true) on the component. If the component doesn't have such a method, the drag may be enabled by binding some kind of gesture to it.

Default TransferHandler Support

For the components listed below, Swing installs default implementations of TransferHandler. For those components that have default Swing support, the TransferHandler is installed by the ComponentUI if the value of the transferHandler property is null or marked by the presence of the UIResource interface. The default TransferHandler implementation installed by the ComponentUI is marked by the UIResource interface, enabling developers to override the default TransferHandler. The following table shows the support provided.

Components That Support DnD

Component | Exports (Drag, Cut, Copy) | Imports (Drop, Paste)
JColorChooser | The selected color is offered through the JavaBeansTM property handling of TransferHandler. The flavor offered is application/x-java-jvm-local-objectref; class=java.awt.Color. The value transferred is determined by getColor. | Accepts inserts of type Color. The data is imported by using setColor (from the bean property handling). Any flavor having class=java.awt.Color (or a subclass of java.awt.Color) is accepted.
JEditorPane | 1.4: If the content-type of the JEditorPane is text/plain, the selected text is offered as as text/plain through the write method of the EditorKit. If the content-type is OTHER, it is exported both as text/plain using the getSelectedText method, and as OTHER using the write method of the EditorKit. 1.4.1: The selected text, as returned by the getSelectedText method, is exported as text/plain. In addition, if the content-type of the JEditorPane is other than text/plain, the selected content is also offered in that other flavor using the EditorKit's write method. | 1.4: Accepts inserts of type text/plain and whatever the current type returned by getContentType. If a type is found matching the current type (including text/plain), it is imported using the EditorKit's read method. Otherwise, text/plain is imported through the component's replaceSelection method. Paste: the contents of the selection, if any, are replaced. Drop: the data is inserted at the caret position. 1.4.1: Accepts inserts of type text/plain and whatever the current type returned by getContentType. If a type is found matching the current type (excluding text/plain), it is imported using the EditorKit's read method. Otherwise, text/plain is imported through the component's replaceSelection method. Paste: the contents of the selection, if any, are replaced. Drop: the data is inserted at the caret position.
JFileChooser | The selection is offered in the same manner as those from the native file chooser. | Imports not accepted. As the mouse is moved over the list, the potential drop point is indicated by highlighting the file/directory under the cursor. See Default Drop Support.
JFormattedTextField | The selected text is offered as text/plain. | Accepts inserts of type text/plain. Paste: the contents of the selection, if any, are replaced; otherwise the data is inserted at the caret position. Drop: the data is inserted at the caret position. Note that paste and drop employ the same code paths as typing from the keyboard, therefore code validation is preserved.
JList | If the selection is a single item, it is offered as text/plain. If multiple items are selected, they are offered as text/html. The format of the text/html is a <UL> tag followed by the selected list items each starting with an <LI> tag. | Imports not accepted. As the mouse is moved over the list, the potential drop point is indicated by highlighting the list item under the cursor. See Default Drop Support.
JPasswordField | For security reasons, cut, copy, and drag are not supported. | Accepts inserts of type text/plain. Paste: the contents of the selection, if any, are replaced; otherwise the data is inserted at the caret position. Drop: the data is inserted at the caret position.
JTable | If the selection is a single item, it is offered as text/plain. If multiple items are selected, they are offered as text/html. The format of the text/html is a <TABLE> tag followed by a <TR> tag for each row and a <TD> tag for each cell. | Imports not accepted. As the mouse is moved over the table, the potential drop point is indicated by highlighting the cell under the cursor. See Default Drop Support.
JTextArea | The selected text is offered as text/plain. | Accepts inserts of type text/plain. Paste: the contents of the selection, if any, are replaced; otherwise the data is inserted at the caret position. Drop: the data is inserted at the caret position.
JTextField | The selected text is offered as text/plain. | Accepts inserts of type text/plain. Paste: the contents of the selection, if any, are replaced; otherwise the data is inserted at the caret position. Drop: the data is inserted at the caret position.
JTextPane | Same as JEditorPane. | Same as JEditorPane.
JTree | If the selection is a single item, it is offered as text/plain. If multiple items are selected, they are offered as text/html. The format of the text/html is nested lists, similar to the format used for JList. | Imports not accepted. As the mouse is moved over the table, the potential drop point is indicated by highlighting the tree node under the cursor. See Default Drop Support.

Example of Adding Support to JLabel

The JLabel component does not support DnD by default. The following code fragment creates a JLabel that supports drag and drop on the "text" property (a String):

JLabel componentType = new JLabel();
componentType.setTransferHandler(new TransferHandler("text"));
MouseListener ml = new MouseAdapter() {
    public void mousePressed(MouseEvent e) {
        JComponent c = (JComponent)e.getSource();
        TransferHandler th = c.getTransferHandler();
        th.exportAsDrag(c, e, TransferHandler.COPY);
    }
};
componentType.addMouseListener(ml);

We have included a small example that implements drag and drop using a JTextField and a JLabel. You can type a value into the text field, highlight the text, then hold the mouse button down over the textfield and drag a few pixels. An icon appears under the cursor. Release the icon over the JLabel and see the text replace the "Drop Here" text. Simultaneously with the drop, the text is removed from the source textfield. The default behavior for drag and drop is MOVE. To change the behavior to COPY, hold down the CONTROL key while selecting the text. On Windows, a plus sign appears in the icon. When the text is released on the target, it is left intact in the source. You can likewise drag from the JLabel to the text field. Note that JLabel does not have bindings for copy/paste and is unable to get the focus that is required to support this feature.

See the JLabelDragNDrop.java example here.

Drag Support

Some components, such as text fields, support selections. For those kinds of components, a drag operation is typically initiated by dragging an existing selection with the mouse. A controller for this type of component can recognize this condition and initiate a drag. For those components that don't have selections, Swing can't automatically initiate the drag, but Swing can handle the mechanics of the drag if told that a drag attempt has been initiated as shown in the JLabel example.

With this level of drag support, the Swing developer can focus on implementing a TransferHandler that represents the desired transfer, and setting properties on the Swing component. This greatly simplifies the burden to the Swing developer wanting to support dragging in an application.

Note that we are currently investigating providing different visual appearances of the drag, hence the reference to Icon in the API. Stay tuned for future developments.

Default Drag Support

The simplest level of support is to set a flag that indicates the developer would like the default support enabled. The components that offer default support for dragging are described in the Exports column of the Components That Support DnD table; but to summarize, the classes that directly implement setDragEnabled and getDragEnabled are: JColorChooser, JFileChooser, JList, JTable, JTree, and JTextComponent. The drag gesture is defined as the press of the first mouse button over a selection and dragging a few pixels. Setting the dragEnabled property to true therefore has a subtle effect on mouse behavior.

When dragging is enabled on a component, the Swing controller (in the corresponding ComponentUI subclass) begins looking for a drag gesture, and if the transferHandler property is null, or marked by the presence of the UIResource interface, a default implementation is installed. The implementation provided by Swing is marked with the UIResource interface, so a developer can insert a new TransferHandler by replacing the default TransferHandler property with a custom implementation. When a drag gesture is recognized, the exportAsDrag method is called on the TransferHandler which initiates the drag mechanism. The actual transfer is handled by the java.awt.dnd mechanism, requiring no further effort from the developer.

Adding Drag Support to Subclasses of Swing Classes

The drag support provided by Swing is activated by the TransferHandler.exportAsDrag method. This makes adding drag support as easy as:

  1. Installing a TransferHandler implementation (so there is something to drag) by calling the setTransferHandler method.
  2. Recognizing a drag gesture.
  3. Calling the exportAsDrag method.

Some scenarios for accomplishing this are:

  • Add a MouseListener that watches for the desired gesture, then call getTransferHandler on the component and call the exportAsDrag method when the desired gesture is found. See the JLabel example.
  • Reimplement the processMouseEvent method in a subclass and call the exportAsDrag method on the ComponentUI variable when a drag gesture is seen, otherwise execute the superclass behavior.
  • In a component with a custom UI implementation, have the controller call exportAsDrag when a drag gesture has been seen.

Operation of TransferHandler.exportAsDrag

When the exportAsDrag method is called on TransferHandler, the drag is handled by Swing provided functionality. When this method is called, it is assumed that a valid drag gesture has been recognized. The method performs the following steps:

  1. A Swing implementation of a DragSource and DragListener is used to start the drag using the Transferable implementation returned by createTransferable as data transfer object.
  2. When the drop has completed, the exportDone method is called on the TransferHandler. For some operations, such as MOVE, it may be necessary to remove the data from the source. The default behavior for text-based components, for example, is that a standard drag implements MOVE behavior (following the drop the selected text is removed from the source component). The user may override this behavior by holding down the control key when the text is selected for dragging. On Windows, the drag icon visually reflects this behavior with a small plus-sign.

Drop Support

The primary support for handling a drop is the same as for a paste operation, the importData method on the TransferHandler. The semantics of inserting data into a component are generally more meaningful at the application level than the toolkit level. Users of an application can drop all kinds of Transferable implementations on components that are completely unknown to the Swing toolkit. It is up to the Swing developer to provide a TransferHandler with meaningful import semantics if the default TransferHandler is insufficient.

A drop operation does have some differences from a paste however:

  • Typically a potential drop site provides feedback of where the data would be accepted.
  • For components with selection capabilities, the insertion point is moved to indicate where the data would be placed.

Default Drop Support

To assist Swing developers in adding drop support to an application, Swing provides DropTarget implementations that use the TransferHandler property on the Swing component. For those components that have a non-null TransferHandler property, the drop target is installed by the ComponentUI if the value of the dropTarget property is null or marked by the presence of the UIResource interface. The default DropTarget implementations installed by the ComponentUI is marked by the UIResource interface, enabling developers to override the default DropTarget.

The components that provide a complete drop implementation by default are indicated in the Imports column of the Components That Support DnD table. There are four components that provide only some support for drop. JFileChooser, JList, JTable, and JTree by default have an installed DropTarget that indicates a potential insertion point. However, to fully support imports of data the developer must write and install a custom TransferHandler.

Using the Drop Support in Subclasses of Swing Classes

A well behaved DropTarget implementation uses the transferHandler property on JComponent to perform the drop. The Swing developer automatically gets a simple DropTarget implementation that links the drop to the TransferHandler when the transferHandler property is set and the dropTarget property is null.

Clipboard Transfer Support

Cut, copy, and paste operations perform data transfer in a manner that is more useful to those without a mouse, as they are typically initiated via a keyboard gesture. These operations can use the same TransferHandler services as the drag and drop support. This improves the accessibility of the data transfers, and enables Swing to provide keyboard bindings for these operations even though Swing may not know how to actually transfer the data to/from the clipboard. The keyboard bindings for clipboard transfer are dependent upon the current look and feel that is installed.

Default Clipboard Transfer

As with drag and drop, clipboard transfers are the most useful for those components that support selections. The list of components shown in the Exports column of the Components That Support DnD table have cut, copy, and paste actions in the component action map, along with a LAF dependent set of keyboard bindings in the input map of the component. Having Swing provide these bindings frees the developer from trying to track the current look and feel and change the bindings.

Using the Clipboard Transfer Support in Subclasses of Swing Classes

A well behaved cut, copy, and paste implementation uses the transferHandler property on JComponent to perform the transfer. When the transferHandler property is set on a JComponent, a simple Action implementation that links the transfer of between a Clipboard and TransferHandler is installed in the component's action map under the keys cut, copy, and paste if there is no action currently installed.

Implementation Details

Note: The following information outlines private implementation details and is subject to change. We are providing this information only to satisfy the curiosity of those who have access to the source code and feel compelled to thump the tires and peek under the hood.

If a TransferHandler is installed on a JComponent, the look and feel then enables cut, copy, and paste using the following TransferHandler methods:

  • getCutAction
  • getCopyAction
  • getPasteAction
If you bind some event to TransferHandler.exportAsDrag you also get drag support. This plumbing is located in package-private nested classes inside of the TransferHandler class.

The following package-private classes were added to the javax.swing.plaf.basic package for creating the default support:

BasicTransferable
The basis of the various Transferable implementations.
BasicDropTargetListener
Adds scrolling support and drop target feedback for those components supporting selection.
BasicDragGestureRecognizer
Supports the "select and move a few pixels" drag gesture recognition.

Each of the ComponentUI classes that support DnD then have some additional nested classes:

BasicTreeUI:

TreeTransferHandler
Default import/export support.
TreeTransferable
The actual tree data.
TreeDragGestureRecognizer
Tree drag gesture recognition, enabled by JTree.setDragEnabled.
TreeDropHandler
Shows drop target location.

BasicListUI, BasicTableUI, BasicTextUI all have a pattern similar to as BasicTreeUI.

BasicFileChooserUI
Uses the list support, but has a FileTransferHandler that produces the FileTransferable that extends the ListTransferable with the flavor used for file transfers.
BasicColorChooserUI
Uses the TransferHandler bean support and binds the "color" property. A mouse listener is added to the preview area to bind a mouse press to the exportAsDrag method on the TransferHandler.

Changes Since Beta

TransferHandler Actions Should be Registered by UI

The bugtraq report that corresponds to this change is: 4460011.

To implement drag and drop, bindings were provided in the Action class to support copying and pasting the data. In order for a look and feel, or other code, to override these Actions, the UI must install them - Actions are no longer automatically installed by the TransferHandler. The package-private methods getCutAction, getCopyAction, and getPasteAction in TransferHandler are now made public.

Ability to Disable DropTarget

The bugtraq report that corresponds to this change is: 4485914.

The drag and drop implementation causes a DropTarget to be added to a JComponent if that component has a TransferHandler installed. This may affect applications that are manually adding DropTargets. Therefore the System property suppressSwingDropSupport has been added. The JComponent methods setTransferHandler(TransferHandler) and getTransferHandler can be used to enable or disable this property.

Known Bugs

Drop Clobbers Selected Text in JTextComponent

The bugtraq report that corresponds to this problem is: 4513715.

Selecting text and then dragging and dropping that text within the selected region of the same text component causes the selected text to be clobbered and nothing to be pasted. This bug is fixed in release 1.4.1.

Occasional Errors in Restoring Caret when Exiting a Component

The bugtraq report that corresponds to this problem is: 4513720.

With the built-in drop support, Swing text components respond to DnD dragovers by setting the Caret to visible and using it to display the potential insert location. When the drag exits the component, the Caret's visibility is restored. Unfortunately, since the Caret uses the same "visible" property to represent the usual meaning of visible as well as when it is in mid-flash, we sometimes restore the Caret's visibility incorrectly.

Cut/Copy/Drag Broken for JEditorPane with RTFEditorKit

The bugtraq report that corresponds to this problem is: 4513638.

When using an RTFEditorKit set explicitly on a JEditorPane using setEditorKit, or by setting the content-type to text/rtf, cut, copy and drag no longer work. Note that this bug, filed against release 1.4, is fixed in release 1.4.1.


Windows Desktop Property Support

This feature involves two areas:

  • Honor More User Preferences
    • Color Properties
    • Geometry Properties
    • Font Properties
    • Visual Effect Properties
    • Audio Feedback Properties
    • Input Properties
  • Respond to Dynamic Changes

Honor More User Preferences

On the Windows platform, users may customize their GUIs via the"Properties" option off the desktop's popup menu. In order to ensure the Swing Windows Look and Feel properly implements the user's visual and behavioral preferences, it must obtain the values of these UI properties from the system registry. The values for these properties will be retrievable from the getDesktopProperty() method on java.awt.Toolkit.

Most of the properties accessible via this method are specific to the Windows platform and hence have a "win." prefix. The list of supported Windows property names can be obtained programmaticallyby querying the "win.propNames" property:

     String propnames[] = (String[])Toolkit.getDefaultToolkit().getDesktopProperty("win.propNames");
     System.out.println("Supported windows property names:");
         for(int i = 0; i < propnames.length; i++) {
             System.out.println(propnames[i]);
         }

Properties which are supported on all platforms begin with an "awt." prefix.

Programs do not need to access these properties directly; the Windows look and feel will automatically read and interpret these properties to provide proper visuals and behavior for the components.

Color Properties

User Preference | Java Property Name | Type
3D Object Background | "win.3d.backgroundColor" | java.awt.Color
3D Object Highlight | "win.3d.highlightColor" | java.awt.Color
3D Object Light Highlight | "win.3d.lightColor" | java.awt.Color
3D Object Shadow | "win.3d.shadowColor" | java.awt.Color
Active Title Bar color1 | "win.frame.activeCaptionColor" | java.awt.Color
Active Title Bar color2 | "win.frame.activeCaptionGradientColor"(TBI) | java.awt.Color
Active Title Bar font color | "win.frame.captionTextColor" | java.awt.Color
Active Window Border color | "win.frame.activeBorderColor" | java.awt.Color
Application Background color | "win.mdi.backgroundColor" | java.lang.Color
Desktop color | "win.desktop.backgroundColor" | java.awt.Color
Inactive Title Bar color1 | "win.frame.inactiveCaptionColor" | java.awt.Color
Inactive Title Bar color2 | "win.frame.inactiveCaptionGradientColor"(TBI) | java.awt.Color
Inactive Title Bar font color | "win.frame.inactiveCaptionTextColor" | java.awt.Color
Inactive Window Border color | "win.frame.inactiveBorderColor" | java.awt.Color
Menu color | "win.menu.backgroundColor" | java.awt.Color
Menu font color | "win.menu.textColor" | java.awt.Color
Message Box font color | "win.frame.textColor?????" | java.awt.Color
Selected Items color | "win.item.highlightColor" | java.awt.Color
Selected Items font color | "win.item.highlightTextColor" | java.awt.Color
ToolTip color | "win.tooltip.backgroundColor" | java.awt.Color
ToolTip font color | "win.tooltip.textColor" | java.awt.Color
Window color | "win.frame.backgroundColor" | java.awt.Color
Window font color | "win.frame.textColor" | java.awt.Color
Hot tracking color | "win.item.hotTrackedColor" | java.awt.Color

Geometry Properties

User Preference | Java Property Name | Type
Active Title Bar size | "win.frame.captionHeight" | java.lang.Integer
Active Window Border size | "win.frame.sizingBorderWidth" | java.lang.Integer
Caption Buttons size | "win.frame.captionButtonHeight" "win.frame.captionButtonWidth" win.frame.captionHeight" | java.lang.Integer
Icon size | "win.icon.hspacing" "win.icon.vspacing"??? | java.lang.Integer
Icon horizontal spacing | "win.icon.hspacing" | java.lang.Integer
Icon vertical spacing | "win.icon.vspacing" | java.lang.Integer
Inactive Title Bar size | "win.frame.captionButtonHeight" "win.frame.captionButtonWidth" "win.frame.captionHeight" | java.lang.Integer
Inactive Window Border size | "win.frame.sizingBorderWidth" | java.lang.Integer
Menu font size | "win.menu.font" "win.menu.height" | java.lang.Integer
Menu Size | "win.menu.height" "win.menu.buttonWidth" | java.awt.Integer
Palette Title size | "win.frame.smallCaptionHeight" "win.frame.smallCaptionButtonHeight" "win.frame.smallCaptionButtonWidth" | java.lang.Integer
Scrollbar width | "win.scrollbar.width" | java.lang.Integer
Scrollbar height | "win.scrollbar.height" | java.lang.Integer
Selected Items size | "win.menu.height" "win.menu.buttonWidth" | java.lang.Integer

Font Properties

User Preference | Java Property Name | Type
Active Title Bar font | "win.frame.captionFont" | java.awt.Font
Icon font | "win.icon.font" | java.awt.Font
Inactive Title Bar font | "win.frame.captionFont" | java.awt.Font
Menu font | "win.menu.font" | java.awt.Font
Message Box font | "win.messagebox.font" | java.awt.Font
Palette Title font | "win.frame.smallCaptionFont" | java.awt.Font
Selected Items font | "win.menu.font" | java.awt.Font
ToolTip font | "win.tooltip.font" | java.awt.Font

Font Compatibility

Now Swing programs running in the Windows look and feel will render with the system font set by the user instead of a Java-defined font. Since this may cause compatibility problems for programs which depend on the old behavior (because of geometry issues, localization dependencies on particular font glyphs, etc.), a runtime property has been provided to allow this feature to be turned off as necessary:

     java -Dswing.useSystemFontSettings=false MyJavaProgram

Visual Effect Properties

User Preference | Java Property Name | Type
Icon title wrapping | "win.icon.titleWrappingOn" | java.lang.Boolean
Window Drag effects | "win.frame.fullWindowDragOn" | java.lang.Boolean
Keyboard Navigation Display | "win.menu.keyboardCuesOn"(TBI) | java.lang.Boolean
Hot tracking on toolbars/menubars | "win.item.hotTrackingOn" | java.lang.Boolean
Title Bar Gradients | "win.frame.captionGradientsOn" | java.lang.Boolean

Audio-feedback Properties

User Preference | Java Property Name | Type
Default sound | "win.sound.default" | java.lang.Runnable
Close sound | "win.sound.close" | java.lang.Runnable
Maximize sound | "win.sound.maximize" | java.lang.Runnable
Minimize sound | "win.sound.minimize" | java.lang.Runnable
Menu Command sound | "win.sound.menuCommand" | java.lang.Runnable
Menu Popup sound | "win.sound.menuPopup" | java.lang.Runnable
Open sound | "win.sound.open" | java.lang.Runnable
Restore Down sound | "win.sound.restoreDown" | java.lang.Runnable
Restore Up sound | "win.sound.restoreUp" | java.lang.Runnable
System Asterisk sound | "win.sound.asterisk" | java.lang.Runnable
System Exclamation sound | "win.sound.exclamation" | java.lang.Runnable
System Exit sound | "win.sound.exit" | java.lang.Runnable
System Hand sound | "win.sound.hand" | java.lang.Runnable
System Question sound | "win.sound.question" | java.lang.Runnable
System Start sound | "win.sound.start" | java.lang.Runnable

Dynamic Changes to Sounds

Note that the object returned for a sound property is simply a Runnable that plays the current audio clip for that property. This means that there is no need for watching for dynamic changes to sound properties because the sound's property value is a live link to the current sound setting.

Input Properties

User Preference | Java Property Name | Type
Double click interval | "awt.multiClickInterval" | java.lang.Integer
Cursor blink rate | "awt.cursorBlinkRate"(TBI) | java.lang.Integer

Respond to Dynamic Changes

In JDK 1.3, AWT added the ability to register for notification when one of these desktop property values changes. This is supported via the addPropertyChangeListener() method on java.awt.Toolkit. Swing's Windows Look and Feel will use this mechanism to watch for dynamic property change events on visual properties, and update the GUI by uninstalling and reinstalling the UI delegates in order for the components to have the most up-to-date visual property values. This dynamic behavior will automatically occur for all Swing programs running the Windows look and feel.

This mechanism will update GUI components by traversing the GUI hierarchy (starting with Frame.getFrames() and traversing all windows/containers/components from there). If a client has any undisplayable components when this occurs (see the isDisplayable() method on java.awt.Component for a definition of when a component is displayable), those components will not update automatically and it will be the client program's responsibility to update the UI on those components to ensure their Look and Feel is up-to-date. For example, this occurs in the SwingSet2 demo because demo panels are created but not added to the GUI heirarchy until they are selected from the demo's tabbedpane. Therefore, before the newly selected demo panel is added to the hierarchy, its UI is updated to ensure it has the most current property settings:

    fragment from SwingSet2.java:  // Ensure panel's UI is current before making visible
    JComponent currentDemoPanel = demo.getDemoPanel();
    SwingUtilities.updateComponentTreeUI(currentDemoPanel);
    // Replace current demo with newly selected demo
    demoPanel.removeAll();
    demoPanel.add(currentDemoPanel, BorderLayout.CENTER);


Windows Look and Feel Keyboard Navigation Hiding

Keyboard Navigation Hiding

One of the new features that was introduced in Windows 2000 has been a display property which will hide the keyboard mnemonic for a menu item or a dialog control until the Alt key is pressed. In other words, all the underlined characters which represent an Alt key combination to invoke that menu or control will not be drawn until the user indicates the intention to invoke a command with the keyboard rather than the mouse. The result of this behavior is to provide an interface which is not visually cluttered with underlined characters for people who choose to navigate the user interface with the mouse.

The keyboard navigation hiding feature will be automatically enabled on Windows 2000 if the application uses the Windows look and feel and the "Hide keyboard navigation indicators until I use the Alt key" property is enabled in the Windows 2000 "Display Properties" control panel applet.

Implementation Details

These details will be of use to developers who are extending look and feels. The keyboard navigation hiding feature will automatically be enabled when a Windows Look and Feel Java application is run on Windows 2000.

When the WindowsLookAndFeel is instantiated, it will read the DesktopProperty "win.menu.keyboardCuesOn". This value is stored in the UIManager and can be referenced using the key: "Button.isMnemonicHidingEnabled". The static methods setMnemonicHidden and isMnemonicHidden in WindowsLookAndFeelprovide access to this value.

Hiding the mnemonics in the menus

The existing BasicMenuItemUI.paintMenuItem() method is responsible for rendering the background, text, icon and mnemonic of a menu item. A new protected method, paintText() was extracted from paintMenuItem(), which is consistent in name and signature to a similar method in the BasicButtonUI hierarchy.

The paintText() methods are overloaded in WindowsMenuItemUI and WindowsMenuUI. The body of the overloaded paintText method checks the isMnemonicEnabled flag in the WindowsLookAndFeel class to determine if the mnemonic should be hidden and then appropriately renders the text.

Hiding the mnemonic in controls

BasicButtonUI already defined a protected method paintText. The WindowsButtonUI and similar classes overloaded this method in much the same manner. A new class was introduced, WindowsGraphicsUtils, to consolidate all the paintText methods. This was done because the Windows...UI classes don't follow the same inheritance hierarchy as the Basic..UI classes.

A new RootPaneUI delegate called WindowsRootPaneUI was created for the Windows look and feel. This class had an action registered to reset the mnemonic hidden bit and repaint the ui when the Alt key was pressed.

New API

All these methods were added as result of implementing this feature. These methods will only have value to developers who wish to extend or create a Look and Feel.

New method for BasicMenuItemUI:

    /**
     * Renders the text of the current menu item.
     *
     * @param g graphics context
     * @param menuItem menu item to render
     * @param textRect bounding rectangle for rendering the text
     * @param text String to render
     * @since 1.4
     */
     protected void paintText(Graphics g, JMenuItem menuItem, Rectangle textRect, String text)

New class WindowsRootPaneUI:

    /**
     * Windows implementation of RootPaneUI. One WindowsRootPaneUI
     * object is shared between all JRootPane instances.
     *
     * @version 1.1 08/16/00
     * @author Mark Davidson
     * @since 1.4
     */
     public class WindowsRootPaneUI extends BasicRootPaneUI

New class WindowsGraphicsUtils:

    /**
     * A collection of static utility methods used for rendering the
     * Windows look and feel.
     *
     * @Version 1.1 08/16/00
     * @author Mark Davidson
     * @since 1.4
     */
     public class WindowsGraphicsUtils

New methods for WindowsLookAndFeel:

    /**
     * Sets the state of the hide mnemonic flag. This flag is used by the
     * component UI delegates to determine if the mnemonic should be rendered.
     * This method is a non operation if the underlying operating system
     * does not support the mnemonic hiding feature.
     *
     * @param hide true if mnemonics should be hidden
     * @since 1.4
     */
     public static void setMnemonicHidden(boolean hide)

    /**
     * Gets the state of the hide mnemonic flag. This only has meaning
     * if this feature is supported by the underlying OS.
     *
     * @return true if mnemonics are hidden, otherwise, false
     * @see #setMnemonicHidden
     * @since 1.4
     */
     public static Boolean isMnemonicHidden()

    /**
     * Gets the state of the flag which indicates if the old Windows
     * look and feel should be rendered. This flag is used by the
     * component UI delegates as a hint to determine which style the component
     * should be rendered.
     *
     * @return true if Windows 95 and Windows NT 4 look and feel should
     *     be rendered
     * @since 1.4
     */
     public static Boolean isClassicWindows()


Windows Look and Feel Update

Overview

The ideal Swing application running under the Windows look and feel would be indistinguishable from its native running counterparts, however due to both changes in the native Windows look and feel (Windows 98, Windows 2000, etc.) and atrophy of our existing Windows look and feel implementation, this has not been the reality. However, for this release we have provided an updated Windows look and feel which integrates seamlessly into the Windows desktop.

This project was composed of a set of independent smaller projects, which involve either fixing a previous emulation deficiency or adding functionality to track 2000/98 features. In some cases the project spans both Swing and AWT:

  • Fix Emulation Bugs
  • Desktop Property Support
  • Column-Wrapping Lists
  • Hot-tracking Toolbar Buttons
  • Gradient Titlebars
  • Keyboard Navigation Hiding
  • Scroll Wheel Support
  • Menu/Tooltip Transition Effects
  • FileChooser Makeover

We chose to modify and enhance the com.sun.java.swing.plaf.windows look and feel package rather than introduce a new 'window2000' package. Almost all of the new functionality is keyed off of Windows native user preferences so that an updated windows look and feel package gracefully runs on eitherWindows 95, Windows 98, Windows NT or Windows 2000 machines. In other words, if a running Swing application detects that a particular user preference (such as Menu fading) doesn't exist, then the windows look and feel will not execute that feature.

The focus of this project was quality, not quantity. Where we deemed it difficult to implement a feature with a high quality result, we deferred that feature to a future release when we can emulate it with better fidelity.

Fix Emulation Bugs

There were many bugs filed against our Windows look and feel and we fixed many of these with this release. We are tracking these bugs witha "w2k" keyword. See Windows Look And Feel Buglist for a list of these windows look and feel bugs.

Desktop Property Support

The current Windows look and feel in Swing only tracks the user's desktop colorscheme (via AWT's SystemColor mechanism). However, on the Windowsdesktop, the user can set many more GUI preferences, such as fonts, sounds, metrics, and can change them at any time and have Windows programs dynamically reflect those changes. We have revised Swing to honor a wider range of user preferences and to also support responding to dynamic changes made by the user. See Windows Desktop Properties Support Specification for details.

Column-Wrapping Lists

List was only capable of displaying a single column and has been updated to support wrapping into multiple columns (like the Windows Explorer pane). This feature is also used to better support the Windows filechooser. See JList Spec update for details.

Hot-Tracking Toolbar Buttons

Buttons contained inside toolbars have become flat in appearance and only when they are 'rolled over' do the borders appear. This feature is supported by the Metal look and feel, but will be added as a general Swing toolbar feature.

Gradient Titlebars

The titlebars on toplevel windows in Windows 2000 by default use a gradient pattern instead of a solid bar color. We get this for free on toplevel windows such as JFrame, however we will use Java2D to implement this rendering for JInternalFrame.

Scroll Wheel Support

Almost all PCs these days come with a scroll-wheel on the mouse and to support this AWT is adding support for scroll wheel input and Swing's scrolling components (JScrollPane, JScrollbar) are being modified to handle this new event type. See MouseWheel API for details of AWT support and see JScrollPane changes for details of support in Swing.

Keyboard Navigation Hiding

In windows the user can set a desktop property which causes applications to hide their keyboard navigation cues *until* ALT is pressed, at which time they magically appear. If the user has this option set on the desktop, Swing will implement this behavior in its menus. See Keyboard Navigation Spec for more information.

Menu/Tooltip Transition Effects

The most obvious feature addition to the Windows look and feel is the new stylistic menu animation. In Windows 98, menus can be set to appear by sliding out. Windows 2000 then introduced a very hip fade-in/fade-out for menus and tooltips.

In order to ensure the most accurate visual effect, this feature is implemented by forcing menus/tooltips to be true toplevel "heavyweight" windows which can take advantage of Microsoft Windows native window animation functionality inside the AWT.

File Chooser Makeover

Although Swing's JFileChooser component closely resembles the Windows file chooser, there are some deficiencies which limit its use on the Windows platform, such as the lack of support for network browsing and the Windows virtual desktop("My Computer", "My Network", etc.). See JFileChooser Spec update for more information.


Windows Look&Feel Bugs

4146858: Wrong DefaultButton behavior in Windows & Motif L&Fs
4166803: Focus set incorrectly on JInternalFrames
4172991: Microsoft Windows PLAF: Alt key for menus doesn't work
4183333: Please provide different WindowsLookAndFeel Border for JPopupMenu
4196518: Windows L&F JInternalFrame menus Disabled system menu items should get focus
4199085: JButtons are too tall and too narrow in Windows look and feel.
4199382: Swing Menus - text/icon/checkmark alignment schemes severely broken
4201986: Swing Tooltips not honoring desktop setting for tooltip font
4249732: JComboBox (Windows L&F) does not resemble native Windows combo
4252279: JFileChooser behavior under the windows look and feel on a "new folder"
4253171: white JTabbedPane on a white JPanel in windows L&F does not paint correctly
4264764: JButton has wrong margin in a JToolBar with Windows LAF
4268204: Windows Look&Feel doesn't look and feel like Windows
4268306: JToolBar uses wrong interior padding w/ Windows LF
4302970: WindowsDesktopManager does not look and feel like Windows
4337049: Background color on JComboBox also changes color of drop down button

Note: There may be additional Windows look&feel bugs not on this list because they have not yet been tagged with the "w2k" keyword.


Swing API changes in JDK 5.0

The API changes in Swing for J2SE 5.0 are broken down into the following sections:

  1. Major Changes
  2. Text Changes
  3. Miscellaneous Changes
  4. Incompatibilities

Major Swing Changes

4607364: Improve default look and feel of Swing

Description:

This is the most visible change to Swing in 5.0. If you use the Java look and feel your application will automatically get a new look, called Ocean, in 5.0. Ocean was designed with compatibility in mind so that we did not change the preferred size of any of the widgets, only the look and a small portion of the feel has changed. The old look can be obtained by setting the system property swing.metalTheme=steel.

Ocean is implemented as a custom MetalTheme that is currently private. The advantage of this approach is that if you have created a custom MetalTheme you will not be affected at all by Ocean, that is, your application will look as it did in 1.4.

Specification

Disabled Icons for AbstractButton subclasses are now generated from the UI. This resulted in revising the specification of getDisabledIcon to:

    /**
     * Returns the icon used by the button when it's disabled.
     * If no disabled icon has been set this will forward the call to
     * the ui to construct an appropriate disabled Icon.
     * <p>
     * Some look and feels might not render the disabled Icon, in which
     * case they will ignore this.
     *
     * @return the <code>disabledIcon</code> property
     * @see #getPressedIcon
     * @see #setDisabledIcon
     * @see javax.swing.plaf.ButtonUI#getDisabledIcon
     */
    public Icon getDisabledIcon();

And adding the method getDisabledIcon to ButtonUI.

    /**
     * Returns the icon to display when the developer has not specified
     * a disabled icon.
     * <p>
     * Some look and feels might not render the disabled Icon, in which
     * case they will ignore this.
     *
     * @param button AbstractButton requesting the Icon
     * @return Disabled icon, or null.
     * @see javax.swing.AbstractButton#setIcon
     * @see javax.swing.AbstractButton#setDisabledIcon
     * @throws NullPointerException if <code>button</code> is null
     * @since 1.5
     */
    public Icon getDisabledIcon(AbstractButton button);

To customize the look of disabled icons for JButton MetalButtonUI will override getDisabledIcon.

    /**
     * Returns the icon to display when the button is disabled.
     *
     * @param button AbstractButton requesting the Icon
     * @return Disabled icon, or null.
     * @see javax.swing.AbstractButton#setIcon
     * @see javax.swing.AbstractButton#setDisabledIcon
     * @throws NullPointerException if <code>button</code> is null
     * @since 1.5
     */
    public Icon getDisabledIcon(AbstractButton button);

To customize the look of JComboBox MetalCombBoxUI will override the following methods:

    /**
     * If necessary paints the currently selected item.
     *
     * @param g Graphics to paint to
     * @param bounds Region to paint current value to
     * @param hasFocus whether or not the JComboBox has focus
     * @throws NullPointerException if any of the arguments are null.
     * @since 1.5
     */
    public void paintCurrentValue(Graphics g, Rectangle bounds,
                                  boolean hasFocus);

    /**
     * If necessary paints the background of the currently selected item.
     *
     * @param g Graphics to paint to
     * @param bounds Region to paint background to
     * @param hasFocus whether or not the JComboBox has focus
     * @throws NullPointerException if any of the arguments are null.
     * @since 1.5
     */
    public void paintCurrentValueBackground(Graphics g, Rectangle bounds,
                                            boolean hasFocus);

To customize the look of JButton MetalButtonUI will override the following methods:

    /**
     * If necessary paints the background of the component, then
     * invokes <code>paint</code>.
     *
     * @param g Graphics to paint to
     * @param c JComponent painting on
     * @throws NullPointerException if <code>g</code> or <code>c</code> is
     *         null
     * @see javax.swing.plaf.ComponentUI#update
     * @see javax.swing.plaf.ComponentUI#paint
     * @since 1.5
     */
    public void update(Graphics g, JComponent c);

To customize the look of JMenuBar metal will now provide MetalMenuBarUI.

To customize the look of JToolBar MetalToolBarUI will now override update.

    /**
     * If necessary paints the background of the component, then invokes
     * <code>paint</code>.
     *
     * @param g Graphics to paint to
     * @param c JComponent painting on
     * @throws NullPointerException if <code>g</code> or <code>c</code> is
     *         null
     * @see javax.swing.plaf.ComponentUI#update
     * @see javax.swing.plaf.ComponentUI#paint
     * @since 1.5
     */
    public void update(Graphics g, JComponent c);

To customize the look of JToggleButton MetalToggleButtonUI will now override the following methods:

    /**
     * If necessary paints the background of the component, then invokes
     * <code>paint</code>.
     *
     * @param g Graphics to paint to
     * @param c JComponent painting on
     * @throws NullPointerException if <code>g</code> or <code>c</code> is
     *         null
     * @see javax.swing.plaf.ComponentUI#update
     * @see javax.swing.plaf.ComponentUI#paint
     * @since 1.5
     */
    public void update(Graphics g, JComponent c);

    /**
     * Paints the appropriate icon of the button <code>b</code> in the
     * space <code>iconRect</code>.
     *
     * @param g Graphics to paint to
     * @param b Button to render for
     * @param iconRect space to render in
     * @throws NullPointerException if any of the arguments are null.
     * @since 1.5
     */
    protected void paintIcon(Graphics g, AbstractButton b, Rectangle iconRect);

    /**
     * Returns the icon to display when the button is disabled.
     *
     * @param button AbstractButton requesting the Icon
     * @return Disabled icon, or null.
     * @see javax.swing.AbstractButton#setIcon
     * @see javax.swing.AbstractButton#setDisabledIcon
     * @throws NullPointerException if <code>button</code> is null
     * @since 1.5
     */
    public Icon getDisabledIcon(AbstractButton button);

4632193: Swing Skins Look and Feel

Description:

One of Swing's early design goals was the ability for an application to support a multitude of look and feels without changing code. This feature allows developers to seamlessly run their applications with numerous look and feels. While there have been a handful of custom look and feels, most notably the Alloy Look and Feel and L2F's Skinnable Look and Feel, creating a new look and feel requires programming and an extensive knowledge of Swing's pluggable look-and-feel architecture, limiting this feature mostly to experts. In 5.0, a skinnable look and feel, named Synth, has been added to Swing which can be completely customized without writing code, enabling even non-programmers to create new look and feels.

Synth lives in the javax.swing.plaf.synth package. The package level javadoc gives a brief overview of Synth. Synth can be customized by way of a file. To enable Synth to extend javax.swing.plaf.basic the following changes were made:

The following methods were unnecessary (implementation identical to that of the superclass) and have been removed: BasicOptionPaneUI's getMinimumSize BasicOptionPaneUI's getMaximumSize BasicTabbedPaneUI's getPreferredSize BasicMenuBarUI's getPreferredSize BasicPopupMenuUI's getMinimumSize BasicPopupMenuUI's getPreferredSize BasicPopupMenuUI's getMaximumSize BasicScrollPaneUI's getPreferredSize BasicScrollPaneUI's getMinimumSize BasicListUI's getMinimumSize BasicListUI's getMaximumSize BasicScrollBarUI's getMinimumSize BasicToolBarSeparatorUI's getMinimumSize BasicToolBarSeparatorUI's getMaximumSize BasicToolBarUI's getMinimumSize BasicToolBarUI's getPreferredSize BasicToolBarUI's getMaximumSize.

Many of the JComponent subclasses have primitive properties. As the UIs need to install a value for these properties they have no way to determine if the property was set by the developer and may end up resetting the value a developer has specified. To enable the UI to only set a value if the the developer hasn't specified we will route all primitive setters through a method in LookAndFeel:

    /**
     * Convenience method for installing a property with the specified name
     * and value on a component if that property has not already been set
     * by the client program.  This method is intended to be used by
     * UI delegate instances that need to specify a default value for a
     * property of primitive type (boolean, int, ..), but do not wish
     * to override a value set by the client.  Since primitive property
     * values cannot be wrapped with the UIResource marker, this method
     * uses private state to determine whether the property has been set
     * by the client.
     * @throws IllegalArgumentException if the specified property is not
     *         one which can be set using this method
     * @throws ClassCastException May be thrown if the propertyValue is not
     *         of the expected type.
     * @throws NullPointerException May be thrown if the JComponent is null,
     *         or the propertyValue is null.
     * @param c the target component for installing the property
     * @param propertyName String containing the name of the property to be set
     * @param propertyValue Object containing the value of the property
     * @since 1.5
     */
    public static void installProperty(JComponent c,
                       String propertyName, Object propertyValue)

To allow subclasses of BasicTabbedPaneUI to create their own buttons the following method was added:

    /**
     * Creates and returns a JButton that will provide the user
     * with a way to scroll the tabs in a particular direction. The
     * returned JButton must be instance of UIResource.
     *
     * @param direction One of the SwingConstants constants:
     * SOUTH, NORTH, EAST or WEST
     * @return Widget for user to
     * @see javax.swing.JTabbedPane#setTabPlacement
     * @see javax.swing.SwingConstants
     * @throws IllegalArgumentException if direction is not one of
     *         NORTH, SOUTH, EAST or WEST
     * @since 1.5
     */
    protected JButton createScrollButton(int direction);

To allow subclasses of BasicTabbedPaneUI to determine which tab has focus the following was added:

    /**
     * Returns the index of the tab that has focus.
     *
     * @return index of tab that has focus
     * @since 1.5
     */
    protected int getFocusIndex();

To allow subclasses of BasicTabbedPaneUI to provide a rollover effect the following was added:

    /**
     * Sets the tab the mouse is currently over to index.
     * index will be -1 if the mouse is no longer over any
     * tab. No checking is done to ensure the passed in index identifies a
     * valid tab.
     *
     * @param index Index of the tab the mouse is over.
     * @since 1.5
     */
    protected void setRolloverTab(int index);

    /**
     * Returns the tab the mouse is currently over, or -1 if the mouse is no
     * longer over any tab.
     *
     * @param index Index of the tab the mouse is over.
     * @since 1.5
     */
    protected int getRolloverTab();

The following field was added to BasicColorChooserUI:

    /**
     * JColorChooser this BasicColorChooserUI is installed on.
     *
     * @since 1.5
     */
    protected JColorChooser chooser;

To allow BasicSpinnerUI subclasses to install their own keyboard actions the following method was added:

    /**
     * Installs the keyboard Actions onto the JSpinner.
     *
     * @since 1.5
     */
    protected void installKeyboardActions();

To allow BasicSpinnerUI subclasses to provide their own spin buttons the following methods were added:

    /**
     * Installs the necessary listeners on the next button, c,
     * to update the JSpinner in response to a user gesture.
     *
     * @param c Component to install the listeners on
     * @throws NullPointerException if c is null.
     * @see #createNextButton
     * @since 1.5
     */
    protected void installNextButtonListeners(Component c);

    /**
     * Installs the necessary listeners on the previous button, c,
     * to update the JSpinner in response to a user gesture.
     *
     * @param c Component to install the listeners on.
     * @throws NullPointerException if c is null.
     * @see #createPreviousButton
     * @since 1.5
     */
    protected void installPreviousButtonListeners(Component c);

To allow subclasses of BasicScrollBarUI to provide rollover feedback the following method were added:

    /**
     * Sets whether or not the mouse is currently over the thumb.
     *
     * @param active True indicates the thumb is currently active.
     * @since 1.5
     */
    protected void setThumbRollover(boolean active);

    /**
     * Returns true if the mouse is currently over the thumb.
     *
     * @return true if the thumb is currently active
     * @since 1.5
     */
    public boolean isThumbRollover();

    /**
     * Indicates whether the user can absolutely position the thumb with
     * a mouse gesture (usually the middle mouse button).
     *
     * @return true if a mouse gesture can absolutely position the thumb
     * @since 1.5
     */
    public boolean getSupportsAbsolutePositioning();

To cut down on class loads the following was added to BasicComboPopup:

    /**
     * Gets the AccessibleContext associated with this BasicComboPopup.
     * The AccessibleContext will have its parent set to the ComboBox.
     *
     * @return an AccessibleContext for the BasicComboPopup
     * @since 1.5
     */
    public AccessibleContext getAccessibleContext();

To enable subclasses of BasicSplitPaneDivider to provide mouse over feedback the following was added:

    /**
     * Sets whether or not the mouse is currently over the divider.
     *
     * @param mouseOver whether or not the mouse is currently over the divider
     * @since 1.5
     */
    protected void setMouseOver(boolean mouseOver);

    /**
     * Returns whether or not the mouse is currently over the divider
     *
     * @param Returns whether or not the mouse is currently over the divider
     */
    public boolean isMouseOver();

To allow subclasses of BasicTreeUI to alter the location of a particular row the following had been added:

    /**
     * Returns the location, along the x-axis, to render a particular row
     * at. The return value does not include any Insets specified on the JTree.
     * This does not check for the validity of the row or depth, it is assumed
     * to be correct and will not throw an Exception if the row or depth
     * doesn't match that of the tree.
     *
     * @param row Row to return x location for
     * @param depth Depth of the row
     * @return amount to indent the given row.
     * @since 1.5
     */
    protected int getRowX(int row, int depth);

To allow subclasses of BasicProgressBarUI to alter the size of the progress bar the following was added:

    /**
     * Used to hold the location and size of the bouncing box (returned
     * by getBox) to be painted.
     *
     * @since 1.5
     */
    protected Rectangle boxRect;

    /**
     * Returns the length
     * of the "bouncing box" to be painted.
     * This method is invoked by the
     * default implementation of <code>paintIndeterminate</code>
     * to get the width (if the progress bar is horizontal)
     * or height (if vertical) of the box.
     * For example:
     * <blockquote>
     * <pre>
     *boxRect.width = getBoxLength(componentInnards.width,
     *                             componentInnards.height);
     * </pre>
     * </blockquote>
     *
     * @param availableLength  the amount of space available
     *                         for the bouncing box to move in;
     *                         for a horizontal progress bar,
     *                         for example,
     *                         this should be
     *                         the inside width of the progress bar
     *                         (the component width minus borders)
     * @param otherDimension   for a horizontal progress bar, this should be
     *                         the inside height of the progress bar; this
     *                         value might be used to constrain or determine
     *                         the return value
     *
     * @return the size of the box dimension being determined;
     *         must be no larger than <code>availableLength</code>
     *
     * @see javax.swing.SwingUtilities#calculateInnerArea
     * @since 1.5
     */
    protected int getBoxLength(int availableLength, int otherDimension);

To enable subclasses of BasicSliderUI to specialize painting based on the state of the slider the following was added:

    /**
     * Returns true if the user is dragging the slider.
     *
     * @return true if the user is dragging the slider
     * @since 1.5
     */
    protected boolean isDragging();

To allow subclasses of BasicToolBarUI to specialize how the window used for dragging is painted the following was added:

    /**
     * Paints the contents of the window used for dragging.
     *
     * @param g Graphics to paint to.
     * @throws NullPointerException is g is null
     * @since 1.5
     */
    protected void paintDragWindow(Graphics g);

To allow subclasses of BasicDesktopIconUI to get a handle to the iconPane the following was added:

    /**
     * The title pane component used in the desktop icon.
     *
     * @since 1.5
     */
    protected JComponent iconPane;

4634626: Implement context popup menus for components

Description:

JPopupMenu allows for creating a popup menu. Prior to 5.0, developers using a JPopupMenu would have to install the necessary listeners and register the appropriate key bindings to show the JPopupMenu. In 5.0 we added a mechanism to take care of registering the appropriate listeners and key bindings. This resulted in the following methods being added to JComponent:

    /**
     * Sets whether or not <code>getComponentPopupMenu</code> should delegate
     * to the parent if this component does not have a <code>JPopupMenu</code>
     * assigned to it.
     * <p>
     * The default value for this is false, but some <code>JComponent</code>
     * subclasses that are implemented as a number of <code>JComponent</code>s
     * may set this to true.
     * <p>
     * This is a bound property.
     *
     * @param value whether or not the JPopupMenu is inherited
     * @see #setComponentPopupMenu
     * @beaninfo
     *        bound: true
     *  description: Whether or not the JPopupMenu is inherited
     * @since 1.5
     */
    public void setInheritsPopupMenu(boolean value);

    /**
     * Returns true if the JPopupMenu should be inherited from the parent.
     *
     * @see #setComponentPopupMenu
     * @since 1.5
     */
    public boolean getInheritsPopupMenu();

    /**
     * Sets the <code>JPopupMenu</code> for this <code>JComponent</code>.
     * The UI is responsible for registering bindings and adding the necessary
     * listeners such that the <code>JPopupMenu</code> will be shown at
     * the appropriate time. When the <code>JPopupMenu</code> is shown
     * depends upon the look and feel: some may show it on a mouse event,
     * some may enable a key binding.
     * <p>
     * If <code>popup</code> is null, and <code>getInheritsPopupMenu</code>
     * returns true, then <code>getComponentPopupMenu</code> will be delegated
     * to the parent. This provides for a way to make all child components
     * inherit the popupmenu of the parent.
     * <p>
     * This is a bound property.
     *
     * @param popup - the popup that will be assigned to this component
     *                may be null
     * @see #getComponentPopupMenu
     * @beaninfo
     *        bound: true
     *    preferred: true
     *  description: Popup to show
     * @since 1.5
     */
    public void setComponentPopupMenu(JPopupMenu popup);

    /**
     * Returns <code>JPopupMenu</code> that assigned for this component.
     * If this component does not have a <code>JPopupMenu</code> assigned
     * to it and <code>getInheritsPopupMenu</code> is true, this
     * will return <code>getParent().getComponentPopupMenu()</code> (assuming
     * the parent is valid.)
     *
     * @return <code>JPopupMenu</code> assigned for this component
     *         or <code>null</code> if no popup assigned
     * @see #setComponentPopupMenu
     * @since 1.5
     */
    public JPopupMenu getComponentPopupMenu();

The following was added to BasicLookAndFeel:

     /**
      * UIManager.setLookAndFeel calls this method before the first call
      * (and typically the only call) to getDefaults().
      *
      * @since 1.5
      */
     public void initialize() {

     /**
      * UIManager.setLookAndFeel calls this method just
      * before we're replaced by a new default look and feel.
      *
      * @since 1.5
      */
     public void uninitialize() {

4791650: JTable needs printing support

Description:

Synopsis says it all. The following has been added to JTable:

    /**
     * Printing modes, used in printing <code>JTable</code>s.
     *
     * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
     *             boolean, PrintRequestAttributeSet, boolean)
     * @see #getPrintable
     * @since 1.5
     */
    public enum PrintMode {

        /**
         * Printing mode that prints the table at its current size,
         * spreading both columns and rows across multiple pages if necessary.
         */
        NORMAL,

        /**
         * Printing mode that scales the output smaller, if necessary,
         * to fit the table's entire width (and thereby all columns) on each page;
         * Rows are spread across multiple pages as necessary.
         */
        FIT_WIDTH
    }
    /**
     * A convenience method that displays a printing dialog, and then prints
     * this <code>JTable</code> in mode <code>PrintMode.FIT_WIDTH</code>,
     * with no header or footer text. A modal progress dialog, with an abort
     * option, will be shown for the duration of printing.
     * <p>
     * Note: In headless mode, no dialogs will be shown.
     *
     * @return true, unless printing is cancelled by the user
     * @throws PrinterException if an error in the print system causes the job
     *                          to be aborted
     * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
     *             boolean, PrintRequestAttributeSet, boolean)
     * @see #getPrintable
     *
     * @since 1.5
     */
    public boolean print() throws PrinterException;

    /**
     * A convenience method that displays a printing dialog, and then prints
     * this <code>JTable</code> in the given printing mode,
     * with no header or footer text. A modal progress dialog, with an abort
     * option, will be shown for the duration of printing.
     * <p>
     * Note: In headless mode, no dialogs will be shown.
     *
     * @param  printMode        the printing mode that the printable should use
     * @return true, unless printing is cancelled by the user
     * @throws PrinterException if an error in the print system causes the job
     *                          to be aborted
     * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
     *             boolean, PrintRequestAttributeSet, boolean)
     * @see #getPrintable
     *
     * @since 1.5
     */
    public boolean print(PrintMode printMode) throws PrinterException;

    /**
     * A convenience method that displays a printing dialog, and then prints
     * this <code>JTable</code> in the given printing mode,
     * with the specified header and footer text. A modal progress dialog,
     * with an abort option, will be shown for the duration of printing.
     * <p>
     * Note: In headless mode, no dialogs will be shown.
     *
     * @param  printMode        the printing mode that the printable should use
     * @param  headerFormat     a <code>MessageFormat</code> specifying the text
     *                          to be used in printing a header,
     *                          or null for none
     * @param  footerFormat     a <code>MessageFormat</code> specifying the text
     *                          to be used in printing a footer,
     *                          or null for none
     * @return true, unless printing is cancelled by the user
     * @throws PrinterException if an error in the print system causes the job
     *                          to be aborted
     * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
     *             boolean, PrintRequestAttributeSet, boolean)
     * @see #getPrintable
     *
     * @since 1.5
     */
    public boolean print(PrintMode printMode,
                         MessageFormat headerFormat,
                         MessageFormat footerFormat) throws PrinterException;

    /**
     * Print this <code>JTable</code>. Takes steps that the majority of
     * developers would take in order to print a <code>JTable</code>.
     * In short, it prepares the table, calls <code>getPrintable</code> to
     * fetch an appropriate <code>Printable</code>, and then sends it to the
     * printer.
     * <p>
     * A <code>boolean</code> parameter allows you to specify whether or not
     * a printing dialog is displayed to the user. When it is, the user may
     * use the dialog to change printing attributes or even cancel the print.
     * Another parameter allows for printing attributes to be specified
     * directly. This can be used either to provide the initial values for the
     * print dialog, or to supply any needed attributes when the dialog is not
     * shown.
     * <p>
     * A second <code>boolean</code> parameter allows you to specify whether
     * or not to perform printing in an interactive mode. If <code>true</code>,
     * a modal progress dialog, with an abort option, is displayed for the
     * duration of printing . This dialog also prevents any user action which
     * may affect the table. However, it can not prevent the table from being
     * modified by code (for example, another thread that posts updates using
     * <code>SwingUtilities.invokeLater</code>). It is therefore the
     * responsibility of the developer to ensure that no other code modifies
     * the table in any way during printing (invalid modifications include
     * changes in: size, renderers, or underlying data). Printing behavior is
     * undefined when the table is changed during printing.
     * <p>
     * If <code>false</code> is specified for this parameter, no dialog will
     * be displayed and printing will begin immediately on the event-dispatch
     * thread. This blocks any other events, including repaints, from being
     * processed until printing is complete. Although this effectively prevents
     * the table from being changed, it doesn't provide a good user experience.
     * For this reason, specifying <code>false</code> is only recommended when
     * printing from an application with no visible GUI.
     * <p>
     * Note: Attempting to show the printing dialog or run interactively, while
     * in headless mode, will result in a <code>HeadlessException</code>.
     * <p>
     * Before fetching the printable, this method prepares the table in order
     * to get the most desirable printed result. If the table is currently
     * in an editing mode, it terminates the editing as gracefully as
     * possible. It also ensures that the the table's current selection and
     * focused cell are not indicated in the printed output. This is handled on
     * the view level, and only for the duration of the printing, thus no
     * notification needs to be sent to the selection models.
     * <p>
     * See {@link #getPrintable} for further description on how the
     * table is printed.
     *
     * @param  printMode        the printing mode that the printable should use
     * @param  headerFormat     a <code>MessageFormat</code> specifying the text
     *                          to be used in printing a header,
     *                          or null for none
     * @param  footerFormat     a <code>MessageFormat</code> specifying the text
     *                          to be used in printing a footer,
     *                          or null for none
     * @param  showPrintDialog  whether or not to display a print dialog
     * @param  attr             a <code>PrintRequestAttributeSet</code>
     *                          specifying any printing attributes,
     *                          or null for none
     * @param  interactive      whether or not to print in an interactive mode
     * @return true, unless printing is cancelled by the user
     * @throws PrinterException if an error in the print system causes the job
     *                          to be aborted
     * @throws HeadlessException if the method is asked to show a printing
     *                           dialog or run interactively, and
     *                           <code>GraphicsEnvironment.isHeadless</code>
     *                           returns true
     * @see #getPrintable
     * @see java.awt.GraphicsEnvironment#isHeadless
     *
     * @since 1.5
     */
    public boolean print(PrintMode printMode,
                         MessageFormat headerFormat,
                         MessageFormat footerFormat,
                         boolean showPrintDialog,
                         PrintRequestAttributeSet attr,
                         boolean interactive) throws PrinterException,
                                                     HeadlessException;
    /**
     * Return a <code>Printable</code> for use in printing this JTable.
     * <p>
     * The <code>Printable</code> can be requested in one of two printing modes.
     * In both modes, it spreads table rows naturally in sequence across
     * multiple pages, fitting as many rows as possible per page.
     * <code>PrintMode.NORMAL</code> specifies that the table be
     * printed at its current size. In this mode, there may be a need to spread
     * columns across pages in a similar manner to that of the rows. When the
     * need arises, columns are distributed in an order consistent with the
     * table's <code>ComponentOrientation</code>.
     * <code>PrintMode.FIT_WIDTH</code> specifies that the output be
     * scaled smaller, if necessary, to fit the table's entire width
     * (and thereby all columns) on each page. Width and height are scaled
     * equally, maintaining the aspect ratio of the output.
     * <p>
     * The <code>Printable</code> heads the portion of table on each page
     * with the appropriate section from the table's <code>JTableHeader</code>,
     * if it has one.
     * <p>
     * Header and footer text can be added to the output by providing
     * <code>MessageFormat</code> arguments. The printing code requests
     * Strings from the formats, providing a single item which may be included
     * in the formatted string: an <code>Integer</code> representing the current
     * page number.
     * <p>
     * You are encouraged to read the documentation for
     * <code>MessageFormat</code> as some characters, such as single-quote,
     * are special and need to be escaped.
     * <p>
     * Here's an example of creating a <code>MessageFormat</code> that can be
     * used to print "Duke's Table: Page - " and the current page number:
     * <p>
     * <pre>
     *     // notice the escaping of the single quote
     *     // notice how the page number is included with "{0}"
     *     MessageFormat format = new MessageFormat("Duke''s Table: Page - {0}");
     * </pre>
     * <p>
     * The <code>Printable</code> constrains what it draws to the printable
     * area of each page that it prints. Under certain circumstances, it may
     * find it impossible to fit all of a page's content into that area. In
     * these cases the output may be clipped, but the implementation
     * makes an effort to do something reasonable. Here are a few situations
     * where this is known to occur, and how they may be handled by this
     * particular implementation:
     * <ul>
     *   <li>In any mode, when the header or footer text is too wide to fit
     *       completely in the printable area -- print as much of the text as
     *       possible starting from the beginning, as determined by the table's
     *       <code>ComponentOrientation</code>.
     *   <li>In any mode, when a row is too tall to fit in the
     *       printable area -- print the upper-most portion of the row
     *       and paint no lower border on the table.
     *   <li>In <code>PrintMode.NORMAL</code> when a column
     *       is too wide to fit in the printable area -- print the center
     *       portion of the column and leave the left and right borders
     *       off the table.
     * </ul>
     * <p>
     * It is entirely valid for this <code>Printable</code> to be wrapped
     * inside another in order to create complex reports and documents. You may
     * even request that different pages be rendered into different sized
     * printable areas. The implementation must be prepared to handle this
     * (possibly by doing its layout calculations on the fly). However,
     * providing different heights to each page will likely not work well
     * with <code>PrintMode.NORMAL</code> when it has to spread columns
     * across pages.
     * <p>
     * It is important to note that this <code>Printable</code> prints the
     * table at its current visual state, using the table's existing renderers.
     * <i>Before</i> calling this method, you may wish to <i>first</i> modify
     * the state of the table (such as to change the renderers, cancel editing,
     * or hide the selection).
     * <p>
     * You must not, however, modify the table in any way <i>after</i>
     * this <code>Printable</code> is fetched (invalid modifications include
     * changes in: size, renderers, or underlying data). The behavior of the
     * returned <code>Printable</code> is undefined once the table has been
     * changed.
     * <p>
     * Here's a simple example that calls this method to fetch a
     * <code>Printable</code>, shows a cross-platform print dialog, and then
     * prints the <code>Printable</code> unless the user cancels the dialog:
     * <p>
     * <pre>
     *     // prepare the table for printing here first (for example, hide selection)
     *
     *     // wrap in a try/finally so table can be restored even if something fails
     *     try {
     *         // fetch the printable
     *         Printable printable = table.getPrintable(JTable.PrintMode.FIT_WIDTH,
     *                                                  new MessageFormat("My Table"),
     *                                                  new MessageFormat("Page - {0}"));
     *
     *         // fetch a PrinterJob
     *         PrinterJob job = PrinterJob.getPrinterJob();
     *
     *         // set the Printable on the PrinterJob
     *         job.setPrintable(printable);
     *
     *         // create an attribute set to store attributes from the print dialog
     *         PrintRequestAttributeSet attr = new HashPrintRequestAttributeSet();
     *
     *         // display a print dialog and record whether or not the user cancels it
     *         boolean printAccepted = job.printDialog(attr);
     *
     *         // if the user didn't cancel the dialog
     *         if (printAccepted) {
     *             // do the printing (may need to handle PrinterException)
     *             job.print(attr);
     *         }
     *     } finally {
     *         // restore the original table state here (for example, restore selection)
     *     }
     * </pre>
     *
     * @param  printMode     the printing mode that the printable should use
     * @param  headerFormat  a <code>MessageFormat</code> specifying the text to
     *                       be used in printing a header, or null for none
     * @param  footerFormat  a <code>MessageFormat</code> specifying the text to
     *                       be used in printing a footer, or null for none
     * @return a <code>Printable</code> for printing this JTable
     * @see Printable
     * @see PrinterJob
     *
     * @since 1.5
     */
    public Printable getPrintable(PrintMode printMode,
                                  MessageFormat headerFormat,
                                  MessageFormat footerFormat);

Changes to Swing's text classes

4201999: JTextArea's don't automatically scroll when appending() to them.

Description:

Some of Swing's text component methods are thread safe; particularly those that modify the content of the text component. Prior to 5.0 the location of the caret would only be updated if the modification happens on the event dispatching thread. In certain situations it is desirable to update the location regardless of what thread the modification happens on. In order to accomodate this the updatePolicy property was added to DefaultCaret. This property allows the developer to specify when the location should change when the content changes. For backward compatibility the policy is still to only update the location if the modification happens on the event dispatching thread.

The results in the following fields and methods being added to DefaultCaret.

     /**
      * Indicates that the caret position is to be updated only when
      * document changes are performed on the Event Dispatching Thread.
      * @see #setUpdatePolicy
      * @see #getUpdatePolicy
      * @since 1.5
      */
     public static final int UPDATE_WHEN_ON_EDT = 0;

     /**
      * Indicates that the caret should remain at the same
      * absolute position in the document regardless of any document
      * updates, except when the document length becomes less than
      * the current caret position due to removal. In that case the caret
      * position is adjusted to the end of the document.
      *
      * @see #setUpdatePolicy
      * @see #getUpdatePolicy
      * @since 1.5
      */
     public static final int NEVER_UPDATE = 1;

     /**
      * Indicates that the caret position is to be <b>always</b>
      * updated accordingly to the document changes regardless whether
      * the document updates are performed on the Event Dispatching Thread
      * or not.
      *
      * @see #setUpdatePolicy
      * @see #getUpdatePolicy
      * @since 1.5
      */
     public static final int ALWAYS_UPDATE = 2;

     /**
      * Sets the caret movement policy on the document updates. Normally
      * the caret updates its absolute position within the document on
      * insertions occurred before or at the caret position and
      * on removals before the caret position. 'Absolute position'
      * means here the position relative to the start of the document.
      * For example if
      * a character is typed within editable text component it is inserted
      * at the caret position and the caret moves to the next absolute
      * position within the document due to insertion and if
      * <code>BACKSPACE</code> is typed then caret decreases its absolute
      * position due to removal of a character before it. Sometimes
      * it may be useful to turn off the caret position updates so that
      * the caret stays at the same absolute position within the
      * document position regardless of any document updates.
      * <p>
      * The following update policies are allowed:
      * <ul>
      *   <li><code>NEVER_UPDATE</code>: the caret stays at the same
      *       absolute position in the document regardless of any document
      *       updates, except when document length becomes less than
      *       the current caret position due to removal. In that case caret
      *       position is adjusted to the end of the document.
      *       The caret doesn't try to keep itself visible by scrolling
      *       the associated view when using this policy. </li>
      *   <li><code>ALWAYS_UPDATE</code>: the caret always tracks document
      *       changes. For regular changes it increases its position
      *       if an insertion occurs before or at its current position,
      *       and decreases position if a removal occurs before
      *       its current position. For undo/redo updates it is always
      *       moved to the position where update occurred. The caret
      *       also tries to keep itself visible by calling
      *       <code>adjustVisibility</code> method.</li>
      *   <li><code>UPDATE_WHEN_ON_EDT</code>: acts like <code>ALWAYS_UPDATE</code>
      *       if the document updates are performed on the Event Dispatching Thread
      *       and like <code>NEVER_UPDATE</code> if updates are performed on
      *       other thread. </li>
      * </ul> <p>
      * The default property value is <code>UPDATE_WHEN_ON_EDT</code>.
      *
      * @param policy one of the following values : <code>UPDATE_WHEN_ON_EDT</code>,
      * <code>NEVER_UPDATE</code>, <code>ALWAYS_UPDATE</code>
      * @throws IllegalArgumentException if invalid value is passed
      *
      * @see #getUpdatePolicy
      * @see #adjustVisibility
      * @see #UPDATE_WHEN_ON_EDT
      * @see #NEVER_UPDATE
      * @see #ALWAYS_UPDATE
      *
      * @since 1.5
      */
     public void setUpdatePolicy(int policy)

     /**
      * Gets the caret movement policy on document updates.
      *
      * @return one of the following values : <code>UPDATE_WHEN_ON_EDT</code>,
      * <code>NEVER_UPDATE</code>, <code>ALWAYS_UPDATE</code>
      *
      * @see #getUpdatePolicy
      * @see #UPDATE_WHEN_ON_EDT
      * @see #NEVER_UPDATE
      * @see #ALWAYS_UPDATE
      *
      * @since 1.5
      */
     public int getUpdatePolicy()

4473401: Forms should generate a hyperlink event, not directly post/get the data

Description:

JEditorPane can be used to display HTML text. When a user clicks on a link an event is generated the allows the developer to customize what will happen. Currently if a HTML page has forms in it and the user triggers a submission the post happens automatically without allowing the developer to alter the behavior. To allow developers to customize the behavior the following methods have been added to HTMLEditorKit:

    /**
     * Indicates whether an html form submission is processed automatically
     * or only <code>FormSubmitEvent</code> is fired.
     *
     * @return true  if html form submission is processed automatically,
     *         false otherwise.
     *
     * @see #setAutoFormSubmission
     * @since 1.5
     */
    public boolean isAutoFormSubmission();

    /**
     * Specifies if an html form submission is processed
     * automatically or only <code>FormSubmitEvent</code> is fired.
     * By default it the property is set to true.
     *
     * @see #isAutoFormSubmission
     * @see FormSubmitEvent
     * @since 1.5
     */
    public void setAutoFormSubmission(boolean isAuto);

A crucial part of this work was making the class FormSubmitEvent public, refer to 4954126 for details on this.

4513720: DefaultCaret visibility should be separate from blinking

Description:

There is currently no way to determine if the caret in active and blinking. The isVisible method was intended for this purpose, but the implementation returns whether the caret is painted at the moment it is invoked, i.e. if the caret is blinking isVisible changes between true and false as the caret blinks. To maintain backward compatibility the interpretation of the isVisible method has been left the same, and an isActive property was added that tells if the caret is active but not necessarily visible at the time the method is invoked.

The following methods have been added to DefaultCaret:

    /**
     * Determines if the caret is currently active.
     * <p>
     * This method returns whether or not the <code>Caret</code>
     * is currently in a blinking state. It does not provide
     * information as to whether it is currently blinked on or off.
     * To determine if the caret is currently painted use the
     * <code>isVisible</code> method.
     *
     * @return <code>true</code> if active else <code>false</code>
     * @see #isVisible
     *
     * @since 1.5
     */
    public boolean isActive()

     * Sets the caret visibility, and repaints the caret.
     * It is important to understand the relationship between this method,
     * <code>isVisible</code> and <code>isActive</code>.
     * Calling this method with a value of <code>true</code> activates the
     * caret blinking. Setting it to <code>false</code> turns it completely off.
     * To determine whether the blinking is active, you should call
     * <code>isActive</code>. In effect, <code>isActive</code> is an
     * appropriate corresponding "getter" method for this one.
     * <code>isVisible</code> can be used to fetch the current
     * visibility status of the caret, meaning whether or not it is currently
     * painted. This status will change as the caret blinks on and off.
     * <p>
     * Here's a list showing the potential return values of both
     * <code>isActive</code> and <code>isVisible</code>
     * after calling this method:
     * <p>
     * <b><code>setVisible(true)</code></b>:
     * <ul>
     *     <li>isActive(): true</li>
     *     <li>isVisible(): true or false depending on whether
     *         or not the caret is blinked on or off</li>
     * </ul>
     * <p>
     * <b><code>setVisible(false)</code></b>:
     * <ul>
     *     <li>isActive(): false</li>
     *     <li>isVisible(): false</li>
     * </ul>
     *
     * @param e the visibility specifier
     * @see #isActive
     * @see Caret#setVisible
     */
    public void setVisible(boolean e)

The documentation for DefaultCaret's isVisible method has been updated to indicate the distinction between the two properties:

    /**
     * Indicates whether or not the caret is currently visible. As the
     * caret flashes on and off the return value of this will change
     * between true, when the caret is painted, and false, when the
     * caret is not painted. <code>isActive</code> indicates whether
     * or not the caret is in a blinking state, such that it <b>can</b>
     * be visible, and <code>isVisible</code> indicates whether or not
     * the caret <b>is</b> actually visible.
     * <p>
     * Subclasses that wish to render a different flashing caret
     * should override paint and only paint the caret if this method
     * returns true.
     *
     * @return true if visible else false
     * @see Caret#isVisible
     * @see #isActive
     */
    public boolean isVisible()

4530474: background-color CSS attribute in HTML font tag works in style but not class

Description:

The background attribute from css style sheet is ignored when rendering HTML text. To get this to work we added the following method to LabelView:

    /**
     * Sets the background color for the view. This method is typically
     * invoked as part of configuring this <code>View</code>. If you need
     * to customize the background color you should override
     * <code>setPropertiesFromAttributes</code> and invoke this method. A
     * value of null indicates no background should be rendered, so that the
     * background of the parent <code>View</code> will show through.
     *
     * @param bg background color, or null
     * @see #setPropertiesFromAttributes
     * @since 1.5
     */
    protected void setBackground(Color bg);

4829622: TabSet class does not override equals

Description:

The TabSet does not override the equals method, which causes comparisons to fail if the TabStop array does contain the same TabStops. It causes AttributeSet not to be equal, even though the only difference is another object instance of TabSet.

TabSet will now override equals and hashCode:

/**
     * Indicates whether this <code>TabSet</code> is equal to another one.
     * @param o the <code>TabSet</code> instance which this instance
     *  should be compared to.
     * @return <code>true</code> if <code>o</code> is the instance of
     * <code>TabSet</code>, has the same number of <code>TabStop</code>s
     * and they are all equal, <code>false</code> otherwise.
     *
     * @since 1.5
     */
    public boolean equals(Object o)

    /**
     * Returns a hashcode for this set of TabStops.
     * @return  a hashcode value for this set of TabStops.
     *
     * @since 1.5
     */
    public int hashCode()

4838730: REGRESSION: In JTextArea setEditable(...) breaks focus traversal keys

Description:

Invoking JTextArea.setEditable resets the focus traversal keys. This is problmatic for developers that want to provide a custom set of focus traversal keys and conditionally change the editable property.

To fix this JComponent now overrides the following:

    /**
     * Sets the focus traversal keys for a given traversal operation for this
     * Component.
     * Refer to
     * {@link java.awt.Component#setFocusTraversalKeys}
     * for a complete description of this method.
     *
     * @param id one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
     *        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, or
     *        KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS
     * @param keystrokes the Set of AWTKeyStroke for the specified operation
     * @see java.awt.KeyboardFocusManager#FORWARD_TRAVERSAL_KEYS
     * @see java.awt.KeyboardFocusManager#BACKWARD_TRAVERSAL_KEYS
     * @see java.awt.KeyboardFocusManager#UP_CYCLE_TRAVERSAL_KEYS
     * @throws IllegalArgumentException if id is not one of
     *         KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
     *         KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, or
     *         KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or if keystrokes
     *         contains null, or if any Object in keystrokes is not an
     *         AWTKeyStroke, or if any keystroke represents a KEY_TYPED event,
     *         or if any keystroke already maps to another focus traversal
     *         operation for this Component
     * @since 1.5
     * @beaninfo
     *       bound: true
     */
    public void setFocusTraversalKeys(int id, Set keystrokes);

4954126: Make FormSubmitEvent class and its accessor methods public

Description:

As requested FormSubmitEvent is not public.

Miscellaneous Swing Changes

4198834: ListDataEvent.getIndex0() should be <= getIndex1()

Description:

ListDataEvent's constructor has been changed to swap the two indices it is passed so that the return value from getIndex0 is always <= the return value from getIndex1.

Specification

   /**
    * Constructs a ListDataEvent object. If index0 is >
    * index1, index0 and index1 will be swapped such that
    * index0 will always be <= index1.
    *
    * @param source  the source Object (typically <code>this</code>)
    * @param type    an int specifying {@link #CONTENTS_CHANGED},
    *                {@link #INTERVAL_ADDED}, or {@link #INTERVAL_REMOVED}
    * @param index0  one end of the new interval
    * @param index1  the other end of the new interval
    */
public ListDataEvent(Object source, int type, int index0, int index1) {

4303294: Implement discontinuous selection from the keyboard for list-like components

Description:

JTable and JList currently provide no way to make discontinuous selections using the keyboard. To enable this the following was added to DefaultListSelectionModel:

/**
 * Set the lead selection index, leaving all selection values unchanged.
 * If leadAnchorNotificationEnabled is true, send a notification covering
 * the old and new lead cells.
 *
 * @param leadIndex the new lead selection index
 *
 * @see #setAnchorSelectionIndex
 * @see #setLeadSelectionIndex
 * @see #getLeadSelectionIndex
 *
 * @since 1.5
 */
public void moveLeadSelectionIndex(int leadIndex)

Additionally DefaultListSelectionModel's isLeadAnchorNotificationEnabled and changeSelection methods were revised.

4621323: Some swing constants are not constant.

Description:

The following static fields are now static final: JDesktopPane.LIVE_DRAG_MODE, JDesktopPane.OUTLINE_DRAG_MODE and DTD.FILE_VERSION.

4664885: Shadow colors are swapped depending on whether BevelBorder is raised/lowered

Description:

Bevel borders interchange their shadowInner and shadowOuter colors depending on whether they are raised or lowered. However, the BorderFactory and BevelBorder don't say this - it's written for a raised bevel border only. This resulted in adding the following to BevelBorder's constructor and BorderFactory's createBevelBorder method:

     * Note: The shadow inner and outer colors are
     * switched for a lowered bevel border.

4665148: javadoc for javax.swing.JScrollPane.isValidateRoot is completely wrong

Description:

Javadoc for JScrollPane.isValidateRoot is completely wrong and misleading and has been changed to:
    /**
     * Overridden to return true so that any calls to <code>revalidate</code>
     * on any descendants of this <code>JScrollPane</code> will cause the
     * entire tree beginning with this <code>JScrollPane</code> to be
     * validated.
     *
     * @return true
     * @see java.awt.Container#validate
     * @see JComponent#revalidate
     * @see JComponent#isValidateRoot
     *
     * @beaninfo
     *    hidden: true
     */

4682386: Refactoring SwingPropertyChangeSupport and PropertyChangeSupport

Description:

The PropertyChangeSupport class is a utility that makes it easy to register and fire PropertyChangeEvents - which is a notification that a JavaBean property has been modified. SwingPropertyChangeSupport is a subclass of PropertyChangeSupport and has a lot of redundant methods. Furthermore, in the 1.2 timeframe, support for property changes was added to Component. Rather than introduce a dependency on SwingPropertyChangeSupport, Component uses PropertyChangeSupport. JComponent maintains an instance of SwingPropertyChangeSupport and Component maintains an instance of PropertyChangeSupport. The results is every JComponent having two instances of PropertyChangeSupport - one of which is dormant. To cut down on the overlap between Component and JComponent as well as PropertyChangeSupport and SwingPropertyChangeSupport the following changes were made:

Promote the following methods from JComponent to Component:

    /**
     * Reports a bound property change.
     *
     * @param propertyName the programmatic name of the property
     *               that was changed
     * @param oldValue the old value of the property (as a byte)
     * @param newValue the new value of the property (as a byte)
     * @see #firePropertyChange(java.lang.String, java.lang.Object,
     *               java.lang.Object)
     * @since 1.5
     */
    public void firePropertyChange(String propertyName, byte oldValue, byte newValue);

    /**
     * Reports a bound property change.
     *
     * @param propertyName the programmatic name of the property
     *               that was changed
     * @param oldValue the old value of the property (as a char)
     * @param newValue the new value of the property (as a char)
     * @see #firePropertyChange(java.lang.String, java.lang.Object,
     *               java.lang.Object)
     * @since 1.5
     */
     public void firePropertyChange(String propertyName, char oldValue, char newValue);

    /**
     * Reports a bound property change.
     *
     * @param propertyName the programmatic name of the property
     *               that was changed
     * @param oldValue the old value of the property (as a short)
     * @param newValue the old value of the property (as a short)
     * @see #firePropertyChange(java.lang.String, java.lang.Object,
     *               java.lang.Object)
     * @since 1.5
     */
    public void firePropertyChange(String propertyName, short oldValue, short newValue);

    /**
     * Reports a bound property change.
     *
     * @param propertyName the programmatic name of the property
     *               that was changed
     * @param oldValue the old value of the property (as a long)
     * @param newValue the new value of the property (as a long)
     * @see #firePropertyChange(java.lang.String, java.lang.Object,
     *               java.lang.Object)
     * @since 1.5
     */
    public void firePropertyChange(String propertyName, long oldValue, long newValue);

    /**
     * Reports a bound property change.
     *
     * @param propertyName the programmatic name of the property
     *               that was changed
     * @param oldValue the old value of the property (as a float)
     * @param newValue the new value of the property (as a float)
     * @see #firePropertyChange(java.lang.String, java.lang.Object,
     *               java.lang.Object)
     * @since 1.5
     */
    public void firePropertyChange(String propertyName, float oldValue, float newValue);

    /**
     * Reports a bound property change.
     *
     * @param propertyName the programmatic name of the property
     *               that was changed
     * @param oldValue the old value of the property (as a double)
     * @param newValue the new value of the property (as a double)
     * @see #firePropertyChange(java.lang.String, java.lang.Object,
     *               java.lang.Object)
     * @since 1.5
     */
    public void firePropertyChange(String propertyName, double oldValue, double newValue);

The corresponding methods in JComponent have been removed.

All the methods from SwingPropertyChangeSupport have been removed, only the constructor remains.

4706356: Swing's default CellRenderers should override more methods for improved perf

Description:

Swing's cell rendenders override a handful of methods to do nothing as they are not needed for cell renderers. They should override a couple of methods that are now being called to do nothing.

The following methods were added to DefaultTableCellRenderer, DefaultListCellRenderer and DefaultTreeCellRenderer

    /**
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a>
     * for more information.
     *
     * @since 1.5
     */
    public void invalidate();
    /**
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a>
     * for more information.
     *
     * @since 1.5
     */
    public void repaint();

4716935: Invoking JLayeredPane.removeAll can result in a leak

Description:

JLayeredPane maintains a HashTable of the Components it contains. It does not currently override removeAll to update the HashTable, resulting in a possible leak. JLayeredPane will now override removeAll to do the necessary cleanup:

    /**
     * Removes all the components from this container.
     *
     * @since 1.5
     */
    public void removeAll();

4717180: Swing should document that UIs may change visual properties when installed

Description:

Swing classes document the default value of many properties. Custom look and feels may change these values so that it appears that the default isn't valid, this needs to be clarified. To document this, the following was added to JComponent's class level javadoc:

     * <code>JComponent</code> and its subclasses document default values
     * for certain properties.  For example, <code>JTable</code> documents the
     * default row height as 16.  Each <code>JComponent</code> subclass
     * that has a <code>ComponentUI</code> will create the
     * <code>ComponentUI</code> as part of its constructor.  In order
     * to provide a particular look and feel each
     * <code>ComponentUI</code> may set properties back on the
     * <code>JComponent</code> that created it.  For example, a custom
     * look and feel may require <code>JTable</code>s to have a row
     * height of 24. The documented defaults are the value of a property
     * BEFORE the <code>ComponentUI</code> has been installed.  If you
     * need a specific value for a particular property you should
     * explicitly set it.

4723745: Metal & Windows FileChooserUI classes cannot be used without ShellFolder

Description:

Since 1.4, the JFileChooser code has too strong a dependence on the native layer. An attempt was made to bypass this class for programs that use a customized "virtual" filesystem, but the algorithm is not 100% reliable. To toggle this behavior, use the client property FileChooser.useShellFolder, for example, to turn off use of the native set this to false:

    jFileChooser.putClientProperty("FileChooser.useShellFolder", Boolean.FALSE);

4749723: Spring and SpringLayout need some ease of methods methods

Description:

It is currently rather difficult to construct some common layouts with SpringLayout. Builders have requested a couple methods to make it easier to create common layouts with SpringLayout, as well as to make it easier to persist SpringLayout.

The following has been added to Spring:

    /**
     * Returns a spring whose <em>minimum</em>, <em>preferred</em>, <em>maximum</em>
     * and <em>value</em> properties are each multiples of the properties of the
     * argument spring, <code>s</code>. Minimum and maximum properties are
     * swapped when <code>factor</code> is negative (in accordance with the
     * rules of interval arithmetic).
     * <p>
     * When factor is, for example, 0.5f the result represents 'the mid-point'
     * of its input - an operation that is useful for centering components in
     * a container.
     *
     * @param s the spring to scale
     * @param factor amount to scale by.
     * @return  a spring whose properties are those of the input spring <code>s</code>
     * multiplied by <code>factor</code>
     * @throws NullPointerException if <code>s</code> is null
     * @since 1.5
     */
    public static Spring scale(Spring s, float factor);

    /**
     * Returns a spring whose <em>minimum</em>, <em>preferred</em>, <em>maximum</em>
     * and <em>value</em> properties are defined by the widths of the <em>minimumSize</em>,
     * <em>preferredSize</em>, <em>maximumSize</em> and <em>size</em> properties
     * of the supplied component. The returned spring is a 'wrapper' implementation
     * whose methods call the appropriate size methods of the supplied component.
     * The minimum, preferred, maximum and value properties of the returned spring
     * therefore report the current state of the appropriate properties in the
     * component and track them as they change.
     *
     * @param c Component used for calculating size
     * @return  a spring whose properties are defined by the horizontal component
     * of the component's size methods.
     * @throws NullPointerException if <code>c</code> is null
     * @since 1.5
     */
    public static Spring width(Component c);

    /**
     * Returns a spring whose <em>minimum</em>, <em>preferred</em>, <em>maximum</em>
     * and <em>value</em> properties are defined by the heights of the <em>minimumSize</em>,
     * <em>preferredSize</em>, <em>maximumSize</em> and <em>size</em> properties
     * of the supplied component. The returned spring is a 'wrapper' implementation
     * whose methods call the appropriate size methods of the supplied component.
     * The minimum, preferred, maximum and value properties of the returned spring
     * therefore report the current state of the appropriate properties in the
     * component and track them as they change.
     *
     * @param c Component used for calculating size
     * @return  a spring whose properties are defined by the vertical component
     * of the component's size methods.
     * @throws NullPointerException if <code>c</code> is null
     * @since 1.5
     */
    public static Spring height(Component c);

And the following has been added to SpringLayout.Constraints:

        /**
         * Creates a <code>Constraints</code> object with
         * suitable <code>x</code>, <code>y</code>, <code>width</code> and
         * <code>height</code> springs for component, <code>c</code>.
         * The <code>x</code> and <code>y</code> springs are constant
         * springs  initialised with the component's location at
         * the time this method is called. The <code>width</code> and
         * <code>height</code> springs are special springs, created by
         * the <code>Spring.width()</code> and <code>Spring.height()</code>
         * methods, which track the size characteristics of the component
         * when they change.
         *
         * @param c  the component whose characteristics will be reflected by this Constraints object
         * @throws NullPointerException if <code>c</code> is null.
         * @since 1.5
         */
        public Constraints(Component c);

4753342: Swing's top level component should redirect add/remove methods to ContentPane

Description:

Contrary to AWT programming, JFrame/JDialg/JWindow/JApplet/JInternalFrame do not allow you to add Components to it, instead you must learn about JRootPane and add children Components to it. This adds needless confusion to new developers.

Prior to 5.0, attempting to add or remove a Component from one of these top level Components would result in an exception be thrown. In 5.0, no exception will be thrown, instead the Component will be added or removed from the content pane. This resulted in several revisions to the javadoc of JFrame, JDialog, JWindow, JApplet and JInternalFrame. This has been summarized in RootPaneContainer's javadoc:

     * For conveniance
     * <code>JFrame</code>, <code>JDialog</code>, <code>JWindow</code>,
     * <code>JApplet</code> and <code>JInternalFrame</code>, by default,
     * forward all calls to <code>add</code> and its variants,
     * <code>remove</code> and <code>setLayout</code> to the
     * <code>contentPane</code>. This means rather than writing:
     * <pre>
     * rootPaneContainer.getContentPane().add(component);
     * </pre>
     * you can do:
     * <pre>
     * rootPaneContainer.add(component);
     * </pre>
     * <p>
     * The behavior of <code>add</code> and its variants and
     * <code>setLayout</code> for
     * <code>JFrame</code>, <code>JDialog</code>, <code>JWindow</code>,
     * <code>JApplet</code> and <code>JInternalFrame</code> is controlled by
     * the <code>rootPaneCheckingEnabled</code> property. If this property is
     * true, the default, then <code>add</code> and its variants and
     * <code>setLayout</code> are
     * forwarded to the <code>contentPane</code>, if it is false, then these
     * methods operate directly on the <code>RootPaneContainer</code>. This
     * property is only intended for subclasses, and is therefor protected.

4789491: JFileChooser doesn't say how to choose directories

Description:

The documentation for JFileChooser is not clear on where to tell the file chooser whether files, directories or both are to be selected. This resulted in revising the documentation for the following methods:

    /**
     * Adds a filter to the list of user choosable file filters.
     * For information on setting the file selection mode, see
     * {@link #setFileSelectionMode setFileSelectionMode}.
     *
     * @param filter the <code>FileFilter</code> to add to the choosable file
     *               filter list
     *
     * @beaninfo
     *   preferred: true
     *       bound: true
     * description: Adds a filter to the list of user choosable file filters.
     *
     * @see #getChoosableFileFilters
     * @see #removeChoosableFileFilter
     * @see #resetChoosableFileFilters
     * @see #setFileSelectionMode
     */
    public void addChoosableFileFilter(FileFilter filter);

    /**
     * Sets the <code>JFileChooser</code> to allow the user to just
     * select files, just select
     * directories, or select both files and directories.  The default is
     * <code>JFilesChooser.FILES_ONLY</code>.
     *
     * @param mode the type of files to be displayed:
     * <ul>
     * <li>JFileChooser.FILES_ONLY
     * <li>JFileChooser.DIRECTORIES_ONLY
     * <li>JFileChooser.FILES_AND_DIRECTORIES
     * </ul>
     *
     * @exception IllegalArgumentException  if <code>mode</code> is an
     *                          illegal file selection mode
     * @beaninfo
     *   preferred: true
     *       bound: true
     * description: Sets the types of files that the JFileChooser can choose.
     *        enum: FILES_ONLY JFileChooser.FILES_ONLY
     *              DIRECTORIES_ONLY JFileChooser.DIRECTORIES_ONLY
     *              FILES_AND_DIRECTORIES JFileChooser.FILES_AND_DIRECTORIES
     *
     *
     * @see #getFileSelectionMode
     */
    public void setFileSelectionMode(int mode);

4831322: JDesktopPane.setDesktopManager should update the desktop manager at the UI.

Description:

Invoking JDesktopPane.setDesktopManager does not take affect until the UI is reloaded.

To fix this BasicDesktopPaneUI will not override the following methods:

    /**
     * Installs the <code>PropertyChangeListener</code> returned from
     * <code>createPropertyChangeListener</code> on the <code>JDesktopPane</code>.
     *
     * @since 1.5
     * @see #createPropertyChangeListener
     */
    protected void installListeners()

    /**
     * Uninstalls the <code>PropertyChangeListener</code> returned from
     * <code>createPropertyChangeListener</code> from the <code>JDesktopPane</code>.
     *
     * @since 1.5
     * @see #createPropertyChangeListener
     */
    protected void uninstallListeners()

    /*
     * Returns the <code>PropertyChangeListener</code> to install on
     * the <code>JDesktopPane</code>.
     *
     * @since 1.5
     * @return The PropertyChangeListener that will be added to track
     * changes in the desktop pane.
     */
    protected PropertyChangeListener createPropertyChangeListener()

4864304: Improve memory consumption of Swing apps

Description:

To cut down on the per instance size of various JComponent subclasses the following changes have been made.

To avoid duplicate storage of the preferred, minimum and maximum size of JComponent's the following methods have been promoted to Component:

    /**
     * Sets the preferred size of this component to a constant
     * value.  Subsequent calls to <code>getPreferredSize</code> will always
     * return this value.  Setting the preferred size to <code>null</code>
     * restores the default behavior.
     *
     * @param preferredSize The new preferred size, or null
     * @see #getPreferredSize
     * @see #isPreferredSizeSet
     * @since 1.5
     */
    public void setPreferredSize(Dimension preferredSize);

    /**
     * Returns true if the preferred size has been set to a
     * non-<code>null</code> value otherwise returns false.
     *
     * @return true if <code>setPreferredSize</code> has been invoked
     *         with a non-null value.
     * @since 1.5
     */
    public boolean isPreferredSizeSet();

    /**
     * Sets the minimum size of this component to a constant
     * value.  Subsequent calls to <code>getMinimumSize</code> will always
     * return this value.  Setting the minimum size to <code>null</code>
     * restores the default behavior.
     *
     * @param minimumSize the new minimum size of this component
     * @see #getMinimumSize
     * @see #isMinimumSizeSet
     * @since 1.5
     */
    public void setMinimumSize(Dimension minimumSize);

    /**
     * Returns whether or not <code>setMinimumSize</code> has been
     * invoked with a non-null value.
     *
     * @return true if <code>setMinimumSize</code> has been invoked with a
     *              non-null value.
     * @since 1.5
     */
    public boolean isMinimumSizeSet();

    /**
     * Sets the maximum size of this component to a constant
     * value.  Subsequent calls to <code>getMaximumSize</code> will always
     * return this value.  Setting the maximum size to <code>null</code>
     * restores the default behavior.
     *
     * @param maximumSize a <code>Dimension</code> containing the
     *               desired maximum allowable size
     * @see #getMaximumSize
     * @see #isMaximumSizeSet
     * @since 1.5
     */
    public void setMaximumSize(Dimension maximumSize);

    /**
     * Returns true if the maximum size has been set to a non-<code>null</code>
     * value otherwise returns false.
     *
     * @return true if <code>maximumSize</code> is non-<code>null</code>,
     *               false otherwise
     * @since 1.5
     */
    public boolean isMaximumSizeSet();

To improve memory needed for autoscrolling JComponent will now override the following method:

    /**
     * Processes mouse events occurring on this component by
     * dispatching them to any registered
     * <code>MouseListener</code> objects, refer to
     * {@link java.awt.Component#processMouseEvent(MouseEvent)}
     * for a complete description of this method.
     *
     * @param       e the mouse event
     * @see         java.awt.Component#processMouseEvent
     * @since 1.5
     */
    protected void processMouseEvent(MouseEvent e);

To reduce the size of AbstractButton's the following methods will be overriden:

    /**
     * Adds the specified component to this container at the specified
     * index, refer to
     * {@link java.awt.Container#addImpl(Component, Object, int)}
     * for a complete description of this method.
     *
     * @param     comp the component to be added
     * @param     constraints an object expressing layout constraints
     *                 for this component
     * @param     index the position in the container's list at which to
     *                 insert the component, where <code>-1</code>
     *                 means append to the end
     * @exception IllegalArgumentException if <code>index</code> is invalid
     * @exception IllegalArgumentException if adding the container's parent
     *			to itself
     * @exception IllegalArgumentException if adding a window to a container
     * @since 1.5
     */
    protected void addImpl(Component comp, Object constraints, int index);

    /**
     * Sets the layout manager for this container, refer to
     * {@link java.awt.Container#setLayout(LayoutManager)}
     * for a complete description of this method.
     *
     * @param mgr the specified layout manager
     * @since 1.5
     */
    public void setLayout(LayoutManager mgr);

4905905: Swing's key binding mapping documentation if out of date.

Description:

Swing documents the key bindings for various components in the files Key-Index.html, Key-Metal.html, Key-Motif.html and Key-Windows.html. These files are in the directory src/share/classes/javax/swing/doc-files and are referenced by a handful of Swing widgets. These files are extremely dated and never really documented all of Swing's key bindings, they have been removed along with all references to them.

4908889: GTKLookAndFeel should be the system look and feel for Solaris w/Gnome

Description:

Swing's UIManager class is used, among other things, to find out the name of the class that can be used to provide the look and feel for the current system. On Solaris w/Gnome the call getSystemLookAndFeelClassName should return the package name for the GTK look and feel.

This resulted in the following changes to UIManager:

    /**
     * Returns the name of the <code>LookAndFeel</code> class that implements
     * the native systems look and feel if there is one, otherwise
     * the name of the default cross platform <code>LookAndFeel</code>
     * class. If the system property <code>swing.systemlaf</code> has been
     * defined, it's value will be returned.
     *
     * @return the <code>String</code> of the <code>LookAndFeel</code>
     *               class
     *
     * @see #setLookAndFeel
     * @see #getCrossPlatformLookAndFeelClassName
     */
    public static String getSystemLookAndFeelClassName();

    /**
     * Returns the name of the <code>LookAndFeel</code> class that implements
     * the default cross platform look and feel -- the Java
     * Look and Feel (JLF).  If the system property
     * <code>swing.crossplatformlaf</code> has been
     * defined, it's value will be returned.
     *
     * @return  a string with the JLF implementation-class
     * @see #setLookAndFeel
     * @see #getSystemLookAndFeelClassName
     */
    public static String getCrossPlatformLookAndFeelClassName();

As part of this work we also created WindowsClassicLookAndFeel. This class is useful to force the windows classic look to be used even if you're running XP.

4953840: Add override of getFontMetrics to JComponent

Description:

As a precursor to providing antialiased text in Swing JComponent will now override the following method:

    /**
     * Gets the <code>FontMetrics</code> for the specified <code>Font</code>.
     *
     * @param font the font for which font metrics is to be
     *          obtained
     * @return the font metrics for <code>font</code>
     * @throws NullPointerException if <code>font</code> is null
     * @since 1.5
     */
    public FontMetrics getFontMetrics(Font font);

Potential Incompatibilities

A handful of these API changes have introduced potential incompatibilities between 5.0 and previous releases. Very few developers will be affected by these changes. The possible incompatibilities are listed below:

4607364

Ocean draws a gradient on buttons. The gradient will only be drawn if the contentAreaFilled property is true, or the background property is an instance of UIResource. If you do not want the gradient, either set the contentAreaFilled property to false, or set the background to a non-UIResource. In most cases this is a simple as:

    button.setBackground(Color.RED);

If, for some reason, you are picking up a UIResource you need to create a new Color that is not a UIResource, for example:

    button.setBackground(new Color(oldColor));

4303294

JTree and JList interpret cursor movement relative to the lead. For example, if the lead is on row four in a JTree and you press the up key the selection changes to row three. Similarly, JTree and JList pass an argument to their renderers indicating whether the item being rendered has the focus — this is based on whether the item being rendered is the lead. Prior to 5.0, JTable used the anchor for these situations; in 5.0, JTable uses the lead. This could affect developers that were assuming the anchor was the cell that has the focus and could result in rendering a focus indicator in the wrong situations.

4864304

To render the popup for a JComboBox Sun's look and feels use an instance of JScrollPane. The JScrollPane is configured to never have a horizontal scroll bar. In 5.0 setHorizontalScrollBar(null) is now invoked.


Package Version Identification

 Documentation Contents
The versioning feature enables package-level version control so that applications and applets can identify at runtime the version of a specific Java Runtime Environment, VM, and class package.

Package Versioning Specification

  • Versioning Specification (HTML, PDF)

API Reference

  • java.lang.Class
  • java.lang.ClassLoader
  • java.lang.Package
  • java.lang.System

Copyright © 2002 Sun Microsystems, Inc. All Rights Reserved.

Please send comments to: TO CHANGE 		Sun
Java Software


JavaTM Product Versioning Specification
Contents | Previous | Next

Contents

Java™ Product Versioning Specification

Introduction

Requirements

Users

Product support

Webmasters and Administrators

Product Developers

Problems of Evolution in Distributed Systems

Design for Evolution

Java Language Specification on Backwards Compatibility

Object Serialization Specification on Backwards Compatibility

Package Version Specification

Specification Versioning

Virtual Machine Versioning

Version Identification of the Java Runtime

Package Versioning

API to Package Version Information

java.lang.Class Additions

java.lang.ClassLoader Additions

JAR Manifest Format

How Users Know What is Running

Rationale for limiting Implementation version numbers to identity

Documenting How to Develop

Contents | Previous | Next

Copyright © 2003 Sun Microsystems, Inc. All rights reserved.


Java™ Product Versioning

Chapter 1

1.1 Introduction

In any system support must be provided for the system to evolve over time. Most existing systems have conventions and mechanisms that specify how change is accommodated. These systems have been based on the model where software programs are installed on a computer. Typically, developers have been able to specify what versions of other packages are required and the installation process has helped verify and configure the system.

In open distributed systems the static assumptions of existing systems does not work and evolution is more difficult because it is not possible to control how or when the packages change and correct operation depends on a greater number of dependencies between packages. What is needed is an updated set of conventions and mechanisms that specify how the packages of a system should evolve so that the goal of an open reliable scalable distributed system can be achieved.

This document specifies:

  • how classes, resources, and files that make up a Java package are versioned. Packages define the consistent unit that can be developed, packaged, verified, updated, and distributed. Per package manifest information identifies the contents of the package;
  • products are distributed by putting packages into archive files. Archives include a manifest to identify the product version and packages it contains;
  • the standards and conventions used by developers and administrators to build and deploy products that operate reliably as their packages and the packages they depend on are upgraded.

1.2 Requirements

The impact of changes within a distributed system has a significant impact on end users, support organizations, web administrators, and developers.

  • End Users
  • Product Support Organizations
  • Webmasters and Administrators
  • Product Developers

Each of these groups has different requirements on products deployed on the net that evolve over time.

Users

For users there is a need to build confidence that Java based products will be reliable and compatible over time. The reluctance to upgrade needs be addressed by building confidence in the Write Once Run Anywhere philosophy. With Java it should no longer be the norm that users will complain “if I upgrade it will break something” or “I won't be able to read/write data others can use”.

  • They need to know that upgrading will not break either other programs or will obsolete existing data or produce data unusable by others.
  • At the simplest level users want to know if the features they need are in the product version they have and what version to ask for to get particular features.
  • More knowledgeable users keep track of what bugs are in what product version so they can work around them or avoid them.

Product support

Product organizations rely on being able to easily and correctly identify the product that is being used, the environment in which it is being used, and the integrity of the product packaging.

  • Databases of known problems and solutions are indexed by product identification information.
  • The interoperation of products and packages can introduce new kinds of problems and require all of the packages in a system to be identified. Problems can originate from public interfaces that are under-specified, implementations that do not conform to the specification, or clients that use implementation specific details that are not part of the specification.

Webmasters and Administrators

Webmasters, administrators, and service providers need to deploy applications for their clients via the web or network filesystems in a way that is reliable and supportable.

  • The staff of these organizations must be able to support their sites, identifying problems with individual packages and interactions between packages.
  • Site configuration must be able to support the scaling up of sites with automated site management tools.
  • Installing updating packages must not present a risk to the correction operation of existing packages or active users.

Product Developers

Product developers need to know how to write and deploy applications and libraries that satisfy the requirements of the users, administrators and support personnel. The must be able to make products and packages that:

  • can operate correctly in the open dynamic environment of the web,
  • can be upgraded without breaking compatibility with clients,
  • can take advantage of upgrades in the packages they rely upon,
  • can take advantage of dynamic extensions of their packages,
  • can identify the packages they rely on for reporting of problems,
  • are packaged to support the needs of users, webmasters and support organizations,
  • can have known packages and combinations that satisfy the auditing and security requirements appropriate for the application and organization.

1.3 Problems of Evolution in Distributed Systems

In open distributed systems many problems can occur when the packages evolve and are updated independently. If the specified behavior inherent in the use of public interfaces are not maintained the system may fail in unexpected ways. Open systems are made up of many packages from different companies and organizations. These organizations operate asynchronously, introducing and upgrading their products on their own schedules. The distribution of those upgraded products takes time and adoption is not universal.

In Java, the components of local and distributed systems rely on the public interfaces and contracts for the behavior of other packages. Those packages will themselves evolve over time. In order for a package to operate correctly the packages it depends on must continue to provide the expected behavior even though they have been updated.

In distributed systems only partial consistency is possible, since it is impossible to have knowledge of the entire state of the system. Each process and package of the system has its own partial view of the current state of the system, accumulated incrementally by requesting information from other parts of the distributed system. Each piece of information whether from an applet that was started, a class that was loaded, a remote method invoked, or a web page retrieved must be treated carefully so that it can be used consistently with the rest of that partial view.

Many kinds of errors could result from inconsistencies in the classes that are loaded, including class verification errors, classes could compute incorrectly but without recognizable errors, or user requested functions could exhibit arbitrary failures.

Typical problems include:

  • If an applet is running and has loaded only some of its classes when the web server is updated with a new version. When the applet incrementally loads more classes they may be inconsistent with the classes already loaded.
  • If an application is using libraries from multiple websites and has loaded only some of the classes it needs, the libraries might be updated raising the potential of incompatibilities that the applet or user is left to detect.
  • If an application or applet is running and makes a RMI call that returns an object for which the class needs to be loaded. The class that is loaded could be inconsistent with respect to the other classes already loaded.
  • If an application or applet is running and makes a RMI call that returns an object that is for a newer or older version of the class.
  • Bugs may exist in a library, if the clients have worked around the bug a cascade of problems may be introduced when the bug is fixed.

These problems cannot be prevented or solved directly because they arise out of inconsistencies between dynamically loaded packages that are not under the control of a single system administrator and so cannot be addressed by current configuration management techniques.

1.4 Design for Evolution

The key to dealing with these problems and meeting the requirements stated above is the careful design of the packages and packaging of the system so that they may be updated, distributed, and loaded in consistent units. Typical to mass produced products is the notion of the field replacable unit. It is the smallest unit of a product that can be identified with a specification, a supplier, can be distributed and redistributed, and can be replaced if faulty. This same model is used for software distribution, products have a name, a version number, adhere to one or more specifications, are distributed on the network or cdrom and its problems can be reported to support organizations. These packages are the smallest unit that can be distributed, used, validated and replaced or upgraded when necessary. Packages can be assembled with other packages and each package can still be identified, verified, and distributed.

The Java language based package mechanism fits well with the idea of a replacable unit. Java packages expose only public interfaces and use only the public interfaces of other packages. The Java Language Specification define the approaches for compatible evolution of packages.

1.4.1 Java Language Specification on Backwards Compatibility

The Java Language Specification lays the groundwork for developing packages that can be expected to evolve gracefully over time. It defines how classes can change and still be backward compatible with other classes previously compiled and distributed. Essential to robust evolution is the stability of the public, protected, and package interfaces and behavior as the implementations evolve. It defines “compatible” changes as those changes that do not change existing interfaces or behavior. Thus, if a class defines a method, and the method had a particular behavior, that same contract must be supported by the all later evolutions of the class. Detailed rules are given in Chapter 13 of the Java Language Specification. One additional incompatible change has been added; it is incompatible to add methods to a public interface.

Incompatible changes are not permitted, but new or similar functionality can always be added in new or existing interfaces or classes.

By choosing the Java package as the unit of update the package and private methods of the classes may change allowing flexibility in the implementation of the package while the public and protected classes and methods maintain the external interfaces and semantics.

1.4.2 Object Serialization Specification on Backwards Compatibility

Robust persistent storage and robust communication between the components is important to distributed systems. Components must be able to maintain persistent storage as they evolve, being able to evolve classes and yet have them read data previously written to storage. Components in a distributed system evolve at different rates and must still be able to reliably communicate.

Adhering to the compatibility requirements of object serialization allows newer and older versions to communicate in a predictable and consistent way. The details are in Chapter 5 of the Java™ Object Serialization Specification.

1.5 Package Version Specification

There are several categories of artifacts that need to be identified including specifications, implementation, the Java Virtual Machine and Java Runtime Environment.

1.5.1 Specification Versioning

Open systems are based on the idea that a specification may have multiple implementations. Specifications evolve under the auspices of an organization or company. It is highly undesirable if a specification has multiple incompatible versions. Each version of a specification or implementation must evolve only into a single subsequent version. The philosophy of requiring specifications to be backward compatible allows specifications to be identified as supersets of the previous specification. Since there is a single sequence of version specifications they can meaningfully be identified by version numbers with specific semantics that imply the ordering. Specification version numbers use a Dewey decimal notation consisting of numbers seperated by periods.

A specification is identified by the:

  • Owner of the specification
  • Name of the Specification
  • Version number - major.minor.micro; major version numbers identify significant functional changes, minor version numbers identify smaller extensions to the functionality, micro versions are even finer grained versions. These version numbers are ordered with larger numbers specifying additions to the specification.

1.5.2 Virtual Machine Versioning

An implementation of the Java Virtual Machine should be identify both the specification and the implementation. These properties should be added to those already available using java.lang.System.getProperties.

  • java-vm.specification.version i.e. 1.2
  • java-vm.specification.vendor i.e. Sun Microsystems Inc.
  • java-vm.specification.name i.e. Java™ Virtual Machine Specification
  • java-vm.version i.e. Solaris 5.5 Native 1.0 build32
  • java-vm.vendor i.e. Sun Microsystems Inc.
  • java-vm.name i.e. Solaris 5.x JVM

These properties are accessed using the method java.lang.System.getProperty and each returns a string.

1.5.3 Version Identification of the Java Runtime

The requirement to identify the Java Runtime is already partially met via the properties specified by the Java Language Specification, §20.18.7 using java.lang.System.getProperties.

  • java.version i.e. Solaris 1.2
  • java.vendor i.e. Sun Microsystems Inc.

Currently these identify the implementation of the Java runtime and the core classes that are available. These properties do not identify the Java Language Specification version that this JDK implements.

Additional properties are needed to identify the version of the Java Runtime Environment specification that this implementation adhere’s to. The properties are:

  • java.specification.version i.e. 1.1
  • java.specification.name i.e. Java™ Language Specification
  • java.specification.vendor i.e. Sun Microsystems Inc.

These properties are accessed using the method java.lang.System.getProperty and return their values as strings.

1.5.4 Package Versioning

Each Java package is made up of class files plus optional resource files. The information needed to identify the contents of the package is stored with the package contents.

This specification applies to all packages regardless of whether they are developed as a core package distributed with a Java Runtime, a standard extension, an applet or application package.

Unlike version numbers for specifications version information for implementations cannot be used to identify the package as being backward compatible with earlier versions. Package version numbers are present to identify differences between the specification and the implementation, i.e. bugs. New versions of implementations are specifically produced to remove (bad or incorrect) behavior and thus are intended not to be backward compatible. Thus package version strings can have any unique value and can only be compared for equality. For a complete explanation of the rationale, see Section 1.5.10 "Rationale for limiting Implementation version numbers to identity”.

The following attribute names are defined for a package. The value of each attribute is a string:

  • Package-Title Title of the package
  • Package-Version Version number
  • Package-Vendor Vendors company or organization
  • Specification-Title Title of the specification
  • Specification-Version Version number
  • Specification-Vendor Vendors company or organization

These attributes are stored in the manifest and retrieved by programs using the java.lang.Package API described below.

1.5.5 API to Package Version Information

The java.lang.Package class provides a object to locate and access information about the package.

Package objects are created explicitly by class loaders and should be created before the first class in the package is defined. The attributes of each package are stored in the manifest and are retrieved by the classloader.

package java.lang;
public class Package {

    // Return the name of this package.
    public String getName();

    // Return the title of the specification of this package.
    public String getSpecificationTitle();

    // Return the version of the specification of this package.
    public String getSpecificationVersion();

    // Return the vendor of the specification of this package.
    public String getSpecificationVendor();

    // Return the title of the implementation of this package.
    public String getImplementationTitle();

    // Return the version of the implementation of this package.
    public String getImplementationVersion();

    // Return the vendor of the implementation of this package.
    public String getImplementationVendor();

    // Is this package is compatible with the requested version
    public boolean isCompatibleWith(String desired);

    // Get the Package for the named class
    public static Package getPackage(String classname);

    // Return the packages for currently loaded classes.
    public static Package[] getAllPackages();

    // Return true if this package is equal to another object.
    public boolean equals(Object obj);

    // Return the hashcode for this object
    public int hashCode();

    // Return the string describing this package.
    public String toString();
}

The getName method returns this package’s name, for example, java.lang.

The getSpecificationTitle method return this packages specification title if it is known and null otherwise.

The getSpecificationVersion method return this the version number of the specification this package implements. Null is returned if the version is not known.

The getSpecificationVendor returns the organization, group or vendor that owns the specification.

The getImplementationTitle method return this packages implementation title if it is known and null otherwise.

The getImplementationVersion method return this the version number of the implementation this package implements. Null is returned if the version is not known.

The getImplementationVendor returns the organization, group or vendor that owns this implementation.

The isCompatibleWith method returns true if this package’s specification version number is compatible with the desired version number. True is returned if this packages specification version number is greater than the supplied version string. A version string is a series of positive numbers separated by periods. The numbers are compared component by component from left to right. If any number is greater than the corresponding number of the supplied string the method returns true. If the number is less than it returns false. If the corresponding numbers are equal the next number is examined.

The getPackage method locates the package for the class by name. The current class loader is consulted to map the package name to the package object in that class loader. It returns the package object containing the attributes for the package. Null is returned if the package information has not yet been loaded or if no package information was defined by the classloader.

The getAllPackages method will return an array of the packages known to the current classloader. It includes the packages of both the system and classloaded classes. It does not identify all packages available to be loaded by the classloader. It only identifies those packages for which the classloader has provided information.

The equals method returns true if this package has the same name and classloader as the object passed in.

The hashCode method returns a hashcode consistent with definition of equals as required by the Java Language Specification.

The toString method returns a string consisting of “package” and the package name. If available the specification title and specification version number are appended to the string.

1.5.6 java.lang.Class Additions

A method has been added to java.lang.Class to get the package for this class.

package java.lang;
public class Class {
    ...
    public Package getPackage();
    ...
}

1.5.7 java.lang.ClassLoader Additions

In order to support Packages the classloader is extended to keep track of the mapping from classes to packages and to allow classloaders to define the Package instances for the classes they load. The additional methods are defined to allow subclasses to define packages in this classloader to allow the Package implementation to get information about packages defined by this classloader.

The java.lang.Package implementation needs to identify the current classloader in order to call it from system code.

package java.lang;
public class ClassLoader {
    ...
    // Return the non-null classloader of callers
    public static ClassLoader currentClassLoader();
    // Define a Package
    protected Package(String pkgname,
            String spectitle, String specversion,
            String specvendor,	String impltitle,
            String implversion, String implvendor);
    ...
}

The currentClassLoader method is used to find the current ClassLoader even if called from a system class. When called from a classloader loaded class it will return the equivalent of this.getClass().getClassLoader(). It’s behavior is identical to the current SecurityManager.currentClassLoader method but is public.

The protected access definePackage method is used by subclasses to define the packages of the classes it is loading. Packages with a given name may only be defined once and must be defined before the first class of that package is loaded. The classloader should supply the versioning attributes from the manifest if they are available.

1.5.8 JAR Manifest Format

The current manifest format is extended to allow the specification of the attributes for package versioning information. A manifest entry should be created for each Java package. The name of the entry will be the directory within the archive that contains the package’s class and resource files. For example:

Manifest-version: 1.0

Name: java/util/
Specification-Title: “Java Utility Classes”
Specification-Version: “1.2”
Specification-Vendor: “Sun Microsystems Inc.”.
Package-Title: “java.util”
Package-Version: “build57”
Package-Vendor: “Sun Microsystems. Inc.”

These attributes can be inserted in the manifest by creating a prototype manifest file and using the “-m” switch of the jar tool to merge them into the manifest when it is built. JarTool will be extended to browse and set the versioning attributes in the manifest.

1.5.9 How Users Know What is Running

Users need to be able to report the identities of the packages in use when bugs occur. It’s up to the application, applet or browser to expose the available information to the user on demand or when an error occurs. API’s are available to allow the following to be reported:

  • What are the packages loaded?
    The package.getAllPackages method will return the active packages.
  • What are the package versions?
    The java.lang.Package methods allow the attributes for names and versions to be examined as listed in Section 1.5.4 "Package Versioning”.
  • What version of the Java Runtime is active?
    The System.getProperties method can be used to get the properties of this virtual machine listed in Section 1.5.3 "Version Identification of the Java Runtime”.
  • What version of the Java VM is active?
    The System.getProperties method can be used to get the properties of this virtual machine listed in Section 1.5.2 "Virtual Machine Versioning”.

1.5.10 Rationale for limiting Implementation version numbers to identity

Implementations evolve independently over time to fix bugs, improve performance or add new functions called for by later revisions of the specifications. Packages implement specifications and must identify which version of each specification they implement. Interactions occur between packages only through their public and protected interfaces and classes. It is the public api and behavior that must remain stable over time so that changes can be allowed in the implementation of one package without affecting the behavior of another package.

If the classes of a package always faithfully implemented the specification it would be sufficient just to identify the specification. Since in the real world this rarely happens packages need to identify themselves so that bugs can be reported against the packages that may have contributed to the problem.

There is a significant tendency to try to attach some significance to version identifiers of implementations. If the purpose is to allow the tracking of bugs then a unique number is sufficient. It is also sufficient for a client package to workaround a bug in a particular version of a vendors package since that version can be tested for and the bug avoided.

However, many additional problems can occur when one package attempts to work around bugs in other packages. They need to identify behavior that is not part of the specification and may try to use behavior that is only part of one implementation. Such implementation specific behavior cannot be relied upon to be in any particular version other than the one(s) seen and tested by the developer.

A bug first appears in some version of a vendors package and may or may not continue to be a problem in subsequent versions. If the client of the buggy package uses a work around based on version numbers it could correctly work around the bug in the specific version. Now, if the buggy package was fixed, how would the client package know whether the bug was fixed or not. If it assumed that higher versions still contained the bug it would still try to work around the bug. The work around itself might not work correctly with the non-buggy package. This could cause a cascade of bugs caused by fixing a bug. Only the developer, through testing with a new version, can determine whether or not the workaround for a bug is still necessary or whether it will cause problems with the correctly behaving package. The developer only knows that the bug exists in a particular individual versions.

1.6 Documenting How to Develop

This section should discuss each aspect of product development and distributions giving direction on how to achieve a robust evolvable product.

  • Read the JLS, be backward compatible
  • Read Serialization Specification, be backward compatible
  • Develop on a platform that includes all of the functionality required.
  • Test for new functionality not included in each previous version of the platform specification and fall back or put up sensible messages
  • Author the package and product versioning information and create the necessary files
  • Depending on the archive model the entire contents will need to be signed and the manifests be created
  • Test on oldest platform
  • Distribute only in archives with manifests to insure consistency and integrity
  • Update only whole java packages or whole archive files

Contents | Previous | Next JavaTM Product Versioning Specification

Copyright © 2003 Sun Microsystems, Inc. All rights reserved.


Java™ Product Versioning Specification

Author: Roger.Riggs@East.Sun.COM

Date: 11/8/02

Evolution in open distributed systems must be managed carefully because correct operation depends on a great number of dependencies between packages. The impact of changes within a distributed system has a significant impact on users, support organizations, web administrators, and developers. Packages within a distributed system must operate correctly given only partial knowledge about the state of the whole system. The difficulty is increased because the packages of the system must be able to evolve at different rates. Evolution in such a system is made possible by explicitly managing the dependencies between the packages using techniques of object oriented design to govern how individual packages evolve. The Java language defines packages that are a natural for the consistent unit of update, they expose only public interfaces and consume only public interfaces of other classes.

Contents | Previous | Next JavaTM Product Versioning Specification

Copyright © 2003 Sun Microsystems, Inc. All rights reserved.


Class Data Sharing

Overview

Class data sharing (CDS) is a new feature in J2SE 5.0 intended to reduce the startup time for Java programming language applications, in particular smaller applications, as well as reduce footprint. When the JRE is installed on 32-bit platforms using the Sun provided installer, the installer loads a set of classes from the system jar file into a private internal representation, and dumps that representation to a file, called a "shared archive". Class data sharing is not supported in Microsoft Windows 95/98/ME. If the Sun JRE installer is not being used, this can be done manually, as explained below. During subsequent JVM invocations, the shared archive is memory-mapped in, saving the cost of loading those classes and allowing much of the JVM's metadata for these classes to be shared among multiple JVM processes.

In J2SE 5.0, class data sharing is supported only with the Java HotSpot Client VM, and only with the serial garbage collector.

The primary motivation for including CDS in the 5.0 release is the decrease in startup time it provides. CDS produces better results for smaller applications because it eliminates a fixed cost: that of loading certain core classes. The smaller the application relative to the number of core classes it uses, the larger the saved fraction of startup time.

The footprint cost of new JVM instances has been reduced in two ways. First, a portion of the shared archive, currently between five and six megabytes, is mapped read-only and therefore shared among multiple JVM processes. Previously this data was replicated in each JVM instance. Second, since the shared archive contains class data in the form in which the Java Hotspot VM uses it, the memory which would otherwise be required to access the original class information in rt.jar is not needed. These savings allow more applications to be run concurrently on the same machine. On Microsoft Windows, the footprint of a process, as measured by various tools, may appear to increase, because a larger number of pages are being mapped in to the process' address space. This is offset by the reduction in the amount of memory (inside Microsoft Windows) which is needed to hold portions on rt.jar. Reducing footprint remains a high priority.

Regenerating the Shared Archive

Under some circumstances the system administrator may need to manually regenerate the shared archive. This is typically only necessary on Solaris if the Java SE packages were installed over the network to a machine of a different architecture than that performing the installation. Regardless, these regeneration instructions apply to all supported platforms.

The shared archive file is colocated with the shared library for the JVM. On Unix platforms, it is stored in jre/lib/[arch]/client/classes.jsa and on Microsoft Windows platforms in jre/bin/client/classes.jsa. If this file exists, it must be manually removed before regeneration.

To regenerate the archive, log in as the administrator; in networked situations, log on to a machine of the same architecture as the J2SE installation and ensure that you have permission to write to the installation directory. Then execute the command

java -Xshare:dump
Diagnostic information will be printed as the archive is generated.

Manually Controlling Class Data Sharing

The class data sharing feature is automatically enabled when conditions allow it to be used. The following command line options are present primarily for diagnostic and debugging purposes and may change or be removed in future releases.

-Xshare:off
Disable class data sharing.
-Xshare:on
Require class data sharing to be enabled. If it could not be enabled for various reasons, print an error message and exit.
-Xshare:auto
The default; enable class data sharing whenever possible.


Concurrent Mark Sweep Collector Enhancements

  • Description
  • System.gc() Performed Concurrently
  • Larger Default Young Generation Size
  • Parallel Marking
  • More Information

Description

The concurrent mark sweep collector, also known as the concurrent collector or CMS, is targeted at applications that are sensitive to garbage collection pauses. It performs most garbage collection activity concurrently, i.e., while the application threads are running, to keep garbage collection-induced pauses short. The key performance enhancements made to the CMS collector in JDK 6 are outlined below. See the documents referenced below for more detailed information on these changes, the CMS collector, and garbage collection in HotSpot.

Note that these features only apply when the CMS collector is in use; the option -XX:+UseConcMarkSweepGC selects the CMS collector.

System.gc() Performed Concurrently

The System.gc() and Runtime.getRuntime().gc() methods instruct the JVM to run the garbage collector to recycle unused objects. The HotSpot implementation of these methods currently stops all application threads to collect the entire heap, which can result in a lengthy pause particularly when the heap is large. This works against the goal of the CMS collector to keep pauses short.

In JDK 6, the CMS collector can optionally perform these collections concurrently, to avoid a lengthy pause in response to a System.gc() or Runtime.getRuntime().gc() call. To enable this feature, add the option

-XX:+ExplicitGCInvokesConcurrent

to the java command line.

Larger Default Young Generation Size

Several changes were made that increase the default size of the young generation when the CMS collector is used:

  • the minimum young generation size was increased from 4MB to 16MB.
  • the proportion of the overall heap used for the young generation was increased from 1/15 to 1/7.
  • the survivor spaces are now used by default, and their default size was increased. (In prior releases the survivor spaces were disabled by default with the CMS collector.)

The primary effect of these changes is to improve application performance by reducing garbage collection overhead. However, because the default young generation size is larger, applications may also see larger young generation pause times and a larger memory footprint. If necessary, please see the documents referenced below for more details on generations, survivor spaces and the options available for adjusting their sizes.

Parallel Marking

The CMS collector now uses multiple threads to perform the concurrent marking task in parallel on platforms with multiple processors. This reduces the duration of the concurrent marking cycle, allowing the collector to support applications with larger numbers of threads and higher object allocation rates, particularly on large multiprocessor machines. Prior releases used only a single thread for concurrent marking, limiting the collector's ability to keep up with applications with very high object allocation rates.

More Information

The HotSpot memory management whitepaper provides more detail about the CMS collector and the other collectors available in HotSpot, as well as descriptions of the generations, survivor spaces and other memory management concepts.

The HotSpot documentation page contains links to Garbage Collection Tuning Guides, specific to each release, which include guidelines for choosing the garbage collector that best suits your application and techniques that can help reduce garbage collection overhead.


DTrace Probes in HotSpot VM

  • Overview
  • The hotspot Provider
    • VM Lifecycle Probes
    • Thread Lifecycle Probes
    • Classloading Probes
    • Garbage Collection Probes
    • Method Compilation Probes
    • Monitor Probes
    • Application Tracking Probes
  • The hotspot_jni Provider
  • Reference

Overview

With the introduction of DTrace on Solaris 10, DTrace support has been added to the Java SE 6 HotSpot VM. The hotspot and hotspot_jni providers make available probes that can be used to monitor JVM internal state and activities as well as the Java application that is running. All of the probes are USDT probes and are accessed using the process-id of the JVM process. The probe details are listed in the next section, and the API is provided in the reference section.

The hotspot Provider

The hotspot provider makes available probes that can be used to track the lifespan of the VM, thread start and stop events, GC and memory pool statistics, method compilations, and monitor activity. With a startup flag, additional probes are enabled which can be used to monitor the running Java program, such as method enter and return probes, and object allocations. All of the hotspot probes originate in the VM library (libjvm.so), so they are also provided from programs which embed the VM.

Many of the probes in the provider have arguments that can be examined to provide further details on the state of the VM. Many of these probes' arguments are opaque IDs which can be used to link probe firings to each other, however strings and other data are also provided. When string values are provided, they are always present as a pair: a pointer to unterminated modified UTF-8 data (see JVM spec :4.4.7) , and a length value which indicates the extent of that data. Because the string data (even when none of the characters are outside the ASCII range) is not guaranteed to be terminated by a NUL character, it is necessary to use the length-terminated copyinstr() intrinsic to read the string data from the process.

VM Life-cycle Probes

The probes that relate to the VM life-cycle are indicated below. None have any arguments at this time.

vm-init-begin | Probe that fires just as the VM initialization begins
vm-init-end | Probe that fires when the VM initialization finishes, and the VM is ready to start running application code
vm-shutdown | Probe that fires as the VM is shutting down due to program termination or an error

Thread Lifecycle Probes

Two probes are available for tracking thread start and stop events.

thread-start | Probe that fires when a thread is started. Provides the arguments listed below
thread-stop | Probe that fires when the thread has completed. Provides the arguments listed below

Each of these probes has the following arguments:

args[0] | A pointer to UTF-8 string data which contains the thread name
args[1] | The length of the thread name data (in bytes)
args[2] | The Java thread ID. This is the value that will match other HotSpot VM probes which contain a thread argument
args[3] | The native/OS thread ID. This is the ID assigned by the host operating system
args[4] | A boolean value which indicates if this thread is a daemon or not. A value of 0 indicates a non-daemon thread

Classloading Probes

Two probes are available for tracking class loading and unloading activity.

class-loaded | Probe that fires when a class has been loaded
class-unloaded | Probe that fires when a class has been unloaded from the system

Each of these probes has the following arguments:

args[0] | A pointer to UTF-8 string data which contains the name of the class that was loaded
args[1] | The length of the class name data (in bytes)
args[2] | The class loader ID, which is a unique identifier for a class loader in the VM. This is the class loader that loaded the class
args[3] | A boolean value which indicates if the class is a shared class (if the class was loaded from the shared archive)

Garbage Collection Probes

Probes are available that can be used to measure the duration of a system-wide garbage collection cycle (for those garbage collectors that have a defined begin and end). Each memory pool can be tracked independently. The probes for individual pools pass the memory manager's name, the pool name, and pool usage information at both the begin and end of pool collection.

The provided GC-related probes are:

gc-begin | Probe that fires when a system-wide collection is about to start. It's one argument (arg[0]) is a boolean value which indicates if this is to be a Full GC.
gc-end | Probe that fires when a system-wide collection has completed. No arguments.
mem-pool-gc-begin | Probe that fires when an individual memory pool is about to be collected. Provides the arguments listed below
mem-pool-gc-end | Probe that fires after an individual memory pool has been collected. Provides the arguments listed below

Memory pool probe arguments:

args[0] | A pointer to UTF-8 string data which contains the name of the manager which manages this memory pool
args[1] | The length of the manager name data (in bytes)
args[2] | A pointer to UTF-8 string data which contains the name of the memory pool
args[3] | The length of the memory pool name data (in bytes)
args[4] | The initial size of the memory pool (in bytes)
args[5] | The amount of memory in use in the memory pool (in bytes)
args[6] | The number of committed pages in the memory pool
args[7] | The maximum size of the memory pool

Method Compilation Probes

Probes are available to indicate which methods are being compiled and by which compiler. Probes are also available to track the installing and uninstalling of compiled methods.

Probes that mark the begin and end of method compilation:

method-compile-begin | Probe that fires as method compilation begins. Provides the arguments listed below
method-compile-end | Probe that fires when method compilation completes. In addition to the arguments listed below, argv[8] is a boolean value which indicates if the compilation was successful

Method compilation probe arguments:

args[0] | A pointer to UTF-8 string data which contains the name of the compiler which is compiling this method
args[1] | The length of the compiler name data (in bytes)
args[2] | A pointer to UTF-8 string data which contains the name of the class of the method being compiled
args[3] | The length of the class name data (in bytes)
args[4] | A pointer to UTF-8 string data which contains the name of the method being compiled
args[5] | The length of the method name data (in bytes)
args[6] | A pointer to UTF-8 string data which contains the signature of the method being compiled
args[7] | The length of the signature data (in bytes)

When compiled methods are installed for execution or uninstalled, the following probes are fired:

compiled-method-load | Probe that fires when a compiled method is installed. In addition to the arguments listed below, argv[6] contains a pointer to the compiled code, and argv[7] is the size of the compiled code
compiled-method-unload | Probe that fires when a compiled method is uninstalled. Provides the arguments listed below

Compiled method loading probe arguments:

args[0] | A pointer to UTF-8 string data which contains the name of the class of the method being installed
args[1] | The length of the class name data (in bytes)
args[2] | A pointer to UTF-8 string data which contains the name of the method being installed
args[3] | The length of the method name data (in bytes)
args[4] | A pointer to UTF-8 string data which contains the signature of the method being installed
args[5] | The length of the signature data (in bytes)

Monitor Probes

As the Java application runs, threads will enter and exit monitors, wait on monitors, and perform notifications. Probes are available for all wait and notification events, as well as for contended monitor entry and exit events. A contended monitor entry is the situation where a thread attempts to enter a monitor when another thread is already in the monitor. A contended monitor exit event occurs when a thread leaves a monitor and other threads are waiting to enter to the monitor. Thus, contended enter and contended exit events may not match up to each other in relation to the thread that encounters these events, though it is expected that a contended exit from one thread should match up to a contended enter on another thread (the thread waiting to enter the monitor).

All monitor events provide the thread ID, a monitor ID, and the type of the class of the object as arguments. It is expected that the thread and the class will help map back to the Java program, while the monitor ID can provide matching information between probe firings.

Since the existence of these probes in the VM causes performance degradation, they will only fire if the VM flag -XX:+ExtendedDTraceProbes is set on the java command line. This flag can be turned on and off dynamically at runtime by using the jinfo utility.

If the above flag is off, the monitor probes are still present in the probe listing obtainable from dtrace, but will remain dormant and will never fire. It is intended that this restriction be removed in future releases of the VM, where these probes will be enabled all the time with no impact to performance.

The available probes:

monitor-contended-enter | Probe that fires as a thread attempts to enter a contended monitor
monitor-contended-entered | Probe that fires when a thread successfully enters the contended monitor
monitor-contended-exit | Probe that fires when a thread leaves a monitor and other threads are waiting to enter
monitor-wait | Probe that fires as a thread begins a wait on a monitor via Object.wait(). The probe has an additional argument, args[4] which is a 'long' value which indicates the timeout being used.
monitor-waited | Probe that fires when a thread completes an Object.wait().
monitor-notify | Probe that fires when a thread calls Object.notify() to notify waiters on a monitor
monitor-notifyAll | Probe that fires when a thread calls Object.notifyAll() to notify waiters on a monitor

Monitor probe arguments:

args[0] | The Java thread identifier for the thread performing the monitor operation
args[1] | A unique, but opaque identifier for the specific monitor that the action is performed upon
args[2] | A pointer to UTF-8 string data which contains the class name of the object being acted upon
args[3] | The length of the class name data (in bytes)

Application Tracking Probes

A few probes are provided to allow fine-grained examination of Java thread execution. These consist of probes that fire anytime a method is entered or returned from, as well as a probe that fires whenever a Java object has been allocated.

Since the existence of these probes in the VM causes performance degradation, they will only fire if the VM has the ExtendedDTraceProbes flag enabled. By default the probes are all present in any listing of the probes in the VM, but are dormant without the appropriate flag. It is intended that this restriction be removed in future releases of the VM, where these probes will be enabled all the time with no impact to performance.

The method entry and return probes:

method-entry | Probe that fires when a method is being entered.
method-return | Probe that fires when a method returns, either normally or due to an exception.

Method probe arguments:

args[0] | The Java thread ID of the thread that is entering or leaving the method
args[1] | A pointer to UTF-8 string data which contains the name of the class of the method
args[2] | The length of the class name data (in bytes)
args[3] | A pointer to UTF-8 string data which contains the name of the method
args[4] | The length of the method name data (in bytes)
args[5] | A pointer to UTF-8 string data which contains the signature of the method
args[6] | The length of the signature data (in bytes)

The available allocation probe:

object-alloc Probe that fires when any object is allocated, provided that the ExtendedDTraceProbes flag is enabled.

The object allocation probe has the following arguments:

args[0] | The Java thread ID of the thread that is allocating the object
args[1] | A pointer to UTF-8 string data which contains the class name of the object being allocated
args[2] | The length of the class name data (in bytes)
args[3] | The size of the object being allocated

The hotspot_jni Provider

In order to call from native code to Java code, due to embedding of the VM in an application or execution of native code within a Java application, the native code must make a call through the JNI interface. The JNI interface provides a number of methods for invoking Java code and examining the state of the VM. DTrace probes are provided at the entry point and return point for each of these methods. The probes are provided by the hotspot_jni provider. The name of the probe is the name of the JNI method, appended with "-entry" for entry probes, and "-return" for return probes. The arguments available at each entry probe are the arguments that were provided to the function (with the exception of the Invoke* methods, which omit the arguments that are passed to the Java method). The return probes have the return value of the method as an argument (if available).

Reference

provider hotspot {
  probe vm-init-begin();
  probe vm-init-end();
  probe vm-shutdown();
  probe class-loaded(
      char* class_name, uintptr_t class_name_len, uintptr_t class_loader_id, bool is_shared);
  probe class-unloaded(
      char* class_name, uintptr_t class_name_len, uintptr_t class_loader_id, bool is_shared);
  probe gc-begin(bool is_full);
  probe gc-end();
  probe mem-pool-gc-begin(
      char* mgr_name, uintptr_t mgr_name_len, char* pool_name, uintptr_t pool_name_len,
      uintptr_t initial_size, uintptr_t used, uintptr_t committed, uintptr_t max_size);
  probe mem-pool-gc-end(
      char* mgr_name, uintptr_t mgr_name_len, char* pool_name, uintptr_t pool_name_len,
      uintptr_t initial_size, uintptr_t used, uintptr_t committed, uintptr_t max_size);
  probe thread-start(
      char* thread_name, uintptr_t thread_name_length,
      uintptr_t java_thread_id, uintptr_t native_thread_id, bool is_daemon);
  probe thread-stop(
      char* thread_name, uintptr_t thread_name_length,
      uintptr_t java_thread_id, uintptr_t native_thread_id, bool is_daemon);
  probe method-compile-begin(
      char* class_name, uintptr_t class_name_len,
      char* method_name, uintptr_t method_name_len,
      char* signature, uintptr_t signature_len);
  probe method-compile-end(
      char* class_name, uintptr_t class_name_len,
      char* method_name, uintptr_t method_name_len,
      char* signature, uintptr_t signature_len,
      bool is_success);
  probe compiled-method-load(
      char* class_name, uintptr_t class_name_len,
      char* method_name, uintptr_t method_name_len,
      char* signature, uintptr_t signature_len,
      void* code, uintptr_t code_size);
  probe compiled-method-unload(
      char* class_name, uintptr_t class_name_len,
      char* method_name, uintptr_t method_name_len,
      char* signature, uintptr_t signature_len);
  probe monitor-contended-enter(
      uintptr_t java_thread_id, uintptr_t monitor_id,
      char* class_name, uintptr_t class_name_len);
  probe monitor-contended-entered(
      uintptr_t java_thread_id, uintptr_t monitor_id,
      char* class_name, uintptr_t class_name_len);
  probe monitor-contended-exit(
      uintptr_t java_thread_id, uintptr_t monitor_id,
      char* class_name, uintptr_t class_name_len);
  probe monitor-wait(
      uintptr_t java_thread_id, uintptr_t monitor_id,
      char* class_name, uintptr_t class_name_len,
      uintptr_t timeout);
  probe monitor-waited(
      uintptr_t java_thread_id, uintptr_t monitor_id,
      char* class_name, uintptr_t class_name_len);
  probe monitor-notify(
      uintptr_t java_thread_id, uintptr_t monitor_id,
      char* class_name, uintptr_t class_name_len);
  probe monitor-notifyAll(
      uintptr_t java_thread_id, uintptr_t monitor_id,
      char* class_name, uintptr_t class_name_len);
  probe method-entry(
      uintptr_t java_thread_id, char* class_name, uintptr_t class_name_len,
      char* method_name, uintptr_t method_name_len,
      char* signature, uintptr_t signature_len);
  probe method-return(
      uintptr_t java_thread_id, char* class_name, uintptr_t class_name_len,
      char* method_name, uintptr_t method_name_len,
      char* signature, uintptr_t signature_len);
  probe object-alloc(
      uintptr_t java_thread_id, char* class_name, uintptr_t class_name_len,
      uintptr_t size);
};

provider hotspot_jni {
  probe AllocObject-entry(void*, void*);
  probe AllocObject-return(void*);
  probe AttachCurrentThreadAsDaemon-entry(void*, void**, void*);
  probe AttachCurrentThreadAsDaemon-return(uint32_t);
  probe AttachCurrentThread-entry(void*, void**, void*);
  probe AttachCurrentThread-return(uint32_t);
  probe CallBooleanMethodA-entry(void*, void*, uintptr_t);
  probe CallBooleanMethodA-return(uintptr_t);
  probe CallBooleanMethod-entry(void*, void*, uintptr_t);
  probe CallBooleanMethod-return(uintptr_t);
  probe CallBooleanMethodV-entry(void*, void*, uintptr_t);
  probe CallBooleanMethodV-return(uintptr_t);
  probe CallByteMethodA-entry(void*, void*, uintptr_t);
  probe CallByteMethodA-return(char);
  probe CallByteMethod-entry(void*, void*, uintptr_t);
  probe CallByteMethod-return(char);
  probe CallByteMethodV-entry(void*, void*, uintptr_t);

  probe CallByteMethodV-return(char);
  probe CallCharMethodA-entry(void*, void*, uintptr_t);
  probe CallCharMethodA-return(uint16_t);
  probe CallCharMethod-entry(void*, void*, uintptr_t);
  probe CallCharMethod-return(uint16_t);
  probe CallCharMethodV-entry(void*, void*, uintptr_t);
  probe CallCharMethodV-return(uint16_t);
  probe CallDoubleMethodA-entry(void*, void*, uintptr_t);
  probe CallDoubleMethodA-return(double);
  probe CallDoubleMethod-entry(void*, void*, uintptr_t);
  probe CallDoubleMethod-return(double);
  probe CallDoubleMethodV-entry(void*, void*, uintptr_t);
  probe CallDoubleMethodV-return(double);
  probe CallFloatMethodA-entry(void*, void*, uintptr_t);
  probe CallFloatMethodA-return(float);
  probe CallFloatMethod-entry(void*, void*, uintptr_t);
  probe CallFloatMethod-return(float);
  probe CallFloatMethodV-entry(void*, void*, uintptr_t);
  probe CallFloatMethodV-return(float);
  probe CallIntMethodA-entry(void*, void*, uintptr_t);
  probe CallIntMethodA-return(uint32_t);
  probe CallIntMethod-entry(void*, void*, uintptr_t);
  probe CallIntMethod-return(uint32_t);
  probe CallIntMethodV-entry(void*, void*, uintptr_t);
  probe CallIntMethodV-return(uint32_t);
  probe CallLongMethodA-entry(void*, void*, uintptr_t);
  probe CallLongMethodA-return(uintptr_t);
  probe CallLongMethod-entry(void*, void*, uintptr_t);
  probe CallLongMethod-return(uintptr_t);
  probe CallLongMethodV-entry(void*, void*, uintptr_t);
  probe CallLongMethodV-return(uintptr_t);
  probe CallNonvirtualBooleanMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualBooleanMethodA-return(uintptr_t);
  probe CallNonvirtualBooleanMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualBooleanMethod-return(uintptr_t);
  probe CallNonvirtualBooleanMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualBooleanMethodV-return(uintptr_t);
  probe CallNonvirtualByteMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualByteMethodA-return(char);
  probe CallNonvirtualByteMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualByteMethod-return(char);
  probe CallNonvirtualByteMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualByteMethodV-return(char);
  probe CallNonvirtualCharMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualCharMethodA-return(uint16_t);
  probe CallNonvirtualCharMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualCharMethod-return(uint16_t);
  probe CallNonvirtualCharMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualCharMethodV-return(uint16_t);
  probe CallNonvirtualDoubleMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualDoubleMethodA-return(double);
  probe CallNonvirtualDoubleMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualDoubleMethod-return(double);
  probe CallNonvirtualDoubleMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualDoubleMethodV-return(double);
  probe CallNonvirtualFloatMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualFloatMethodA-return(float);
  probe CallNonvirtualFloatMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualFloatMethod-return(float);
  probe CallNonvirtualFloatMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualFloatMethodV-return(float);
  probe CallNonvirtualIntMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualIntMethodA-return(uint32_t);
  probe CallNonvirtualIntMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualIntMethod-return(uint3t);
  probe CallNonvirtualIntMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualIntMethodV-return(uint32_t);
  probe CallNonvirtualLongMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualLongMethodA-return(uintptr_t);
  probe CallNonvirtualLongMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualLongMethod-return(uintptr_t);
  probe CallNonvirtualLongMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualLongMethodV-return(uintptr_t);
  probe CallNonvirtualObjectMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualObjectMethodA-return(void*);
  probe CallNonvirtualObjectMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualObjectMethod-return(void*);
  probe CallNonvirtualObjectMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualObjectMethodV-return(void*);
  probe CallNonvirtualShortMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualShortMethodA-return(uint16_t);
  probe CallNonvirtualShortMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualShortMethod-return(uint16_t);
  probe CallNonvirtualShortMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualShortMethodV-return(uint16_t);
  probe CallNonvirtualVoidMethodA-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualVoidMethodA-return();
  probe CallNonvirtualVoidMethod-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualVoidMethod-return();
  probe CallNonvirtualVoidMethodV-entry(void*, void*, void*, uintptr_t);
  probe CallNonvirtualVoidMethodV-return();
  probe CallObjectMethodA-entry(void*, void*, uintptr_t);
  probe CallObjectMethodA-return(void*);
  probe CallObjectMethod-entry(void*, void*, uintptr_t);
  probe CallObjectMethod-return(void*);
  probe CallObjectMethodV-entry(void*, void*, uintptr_t);
  probe CallObjectMethodV-return(void*);
  probe CallShortMethodA-entry(void*, void*, uintptr_t);
  probe CallShortMethodA-return(uint16_t);
  probe CallShortMethod-entry(void*, void*, uintptr_t);
  probe CallShortMethod-return(uint16_t);
  probe CallShortMethodV-entry(void*, void*, uintptr_t);
  probe CallShortMethodV-return(uint16_t);
  probe CallStaticBooleanMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticBooleanMethodA-return(uintptr_t);
  probe CallStaticBooleanMethod-entry(void*, void*, uintptr_t);
  probe CallStaticBooleanMethod-return(uintptr_t);
  probe CallStaticBooleanMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticBooleanMethodV-return(uintptr_t);
  probe CallStaticByteMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticByteMethodA-return(char);
  probe CallStaticByteMethod-entry(void*, void*, uintptr_t);
  probe CallStaticByteMethod-return(char);
  probe CallStaticByteMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticByteMethodV-return(char);
  probe CallStaticCharMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticCharMethodA-return(uint16_t);
  probe CallStaticCharMethod-entry(void*, void*, uintptr_t);
  probe CallStaticCharMethod-return(uint16_t);
  probe CallStaticCharMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticCharMethodV-return(uint16_t);
  probe CallStaticDoubleMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticDoubleMethodA-return(double);
  probe CallStaticDoubleMethod-entry(void*, void*, uintptr_t);
  probe CallStaticDoubleMethod-return(double);
  probe CallStaticDoubleMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticDoubleMethodV-return(double);
  probe CallStaticFloatMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticFloatMethodA-return(float);
  probe CallStaticFloatMethod-entry(void*, void*, uintptr_t);
  probe CallStaticFloatMethod-return(float);
  probe CallStaticFloatMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticFloatMethodV-return(float);
  probe CallStaticIntMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticIntMethodA-return(uint32_t);
  probe CallStaticIntMethod-entry(void*, void*, uintptr_t);
  probe CallStaticIntMethod-return(uint32_t);
  probe CallStaticIntMethodentry(void*, void*, uintptr_t);
  probe CallStaticIntMethodV-return(uint32_t);
  probe CallStaticLongMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticLongMethodA-return(uintptr_t);
  probe CallStaticLongMethod-entry(void*, void*, uintptr_t);
  probe CallStaticLongMethod-return(uintptr_t);
  probe CallStaticLongMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticLongMethodV-return(uintptr_t);
  probe CallStaticObjectMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticObjectMethodA-return(void*);
  probe CallStaticObjectMethod-entry(void*, void*, uintptr_t);
  probe CallStaticObjectMethod-return(void*);
  probe CallStaticObjectMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticObjectMethodV-return(void*);
  probe CallStaticShortMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticShortMethodA-return(uint16_t);
  probe CallStaticShortMethod-entry(void*, void*, uintptr_t);
  probe CallStaticShortMethod-return(uint16_t);
  probe CallStaticShortMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticShortMethodV-return(uint16_t);
  probe CallStaticVoidMethodA-entry(void*, void*, uintptr_t);
  probe CallStaticVoidMethodA-return();
  probe CallStaticVoidMethod-entry(void*, void*, uintptr_t);
  probe CallStaticVoidMethod-return();
  probe CallStaticVoidMethodV-entry(void*, void*, uintptr_t);
  probe CallStaticVoidMethodV-return();
  probe CallVoidMethodA-entry(void*, void*, uintptr_t);
  probe CallVoidMethodA-return();
  probe CallVoidMethod-entry(void*, void*, uintptr_t);
  probe CallVoidMethod-return();
  probe CallVoidMethodV-entry(void*, void*, uintptr_t);
  probe CallVoidMethodV-return();
  probe CreateJavaVM-entry(void**, void**, void*);
  probe CreateJavaVM-return(uint32_t);
  probe DefineClass-entry(void*, const char*, void*, char, uintptr_t);
  probe DefineClass-return(void*);
  probe DeleteGlobalRef-entry(void*, void*);
  probe DeleteGlobalRef-return();
  probe DeleteLocalRef-entry(void*, void*);
  probe DeleteLocalRef-return();
  probe DeleteWeakGlobalRef-entry(void*, void*);
  probe DeleteWeakGlobalRef-return();
  probe DestroyJavaVM-entry(void*);
  probe DestroyJavaVM-return(uint32_t);
  probe DetachCurrentThread-entry(void*);
  probe DetachCurrentThread-return(uint32_t);
  probe EnsureLocalCapacity-entry(void*, uint32_t);
  probe EnsureLocalCapacity-return(uint32_t);
  probe ExceptionCheck-entry(void*);
  probe ExceptionCheck-return(uintptr_t);
  probe ExceptionClear-entry(void*);
  probe ExceptionClear-return();
  probe ExceptionDescribe-entry(void*);
  probe ExceptionDescribe-return();
  probe ExceptionOccurred-entry(void*);
  probe ExceptionOccurred-return(void*);
  probe FatalError-entry(void* env, const char*);
  probe FatalError-return();
  probe FindClass-entry(void*, const char*);
  probe FindClass-return(void*);
  probe FromReflectedField-entry(void*, void*);
  probe FromReflectedField-return(uintptr_t);
  probe FromReflectedMethod-entry(void*, void*);
  probe FromReflectedMethod-return(uintptr_t);
  probe GetArrayLength-entry(void*, void*);
  probe GetArrayLength-return(uintptr_t);
  probe GetBooleanArrayElements-entry(void*, void*, uintptr_t*);
  probe GetBooleanArrayElements-return(uintptr_t*);
  probe GetBooleanArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uintptr_t*);
  probe GetBooleanArrayRegion-return();
  probe GetBooleanField-entry(void*, void*, uintptr_t);
  probe GetBooleanField-return(uintptr_t);
  probe GetByteArrayElements-entry(void*, void*, uintptr_t*);
  probe GetByteArrayElements-return(char*);
  probe GetByteArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, char*);
  probe GetByteArrayRegion-return();
  probe GetByteField-entry(void*, void*, uintptr_t);
  probe GetByteField-return(char);
  probe GetCharArrayElements-entry(void*, void*, uintptr_t*);
  probe GetCharArrayElements-return(uint16_t*);
  probe GetCharArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
  probe GetCharArrayRegion-return();
  probe GetCharField-entry(void*, void*, uintptr_t);
  probe GetCharField-return(uint16_t);
  probe GetCreatedJavaVMs-eintptr_t*);
  probe GetCreatedJavaVMs-return(uintptr_t);
  probe GetCreateJavaVMs-entry(void*, uintptr_t, uintptr_t*);
  probe GetCreateJavaVMs-return(uint32_t);
  probe GetDefaultJavaVMInitArgs-entry(void*);
  probe GetDefaultJavaVMInitArgs-return(uint32_t);
  probe GetDirectBufferAddress-entry(void*, void*);
  probe GetDirectBufferAddress-return(void*);
  probe GetDirectBufferCapacity-entry(void*, void*);
  probe GetDirectBufferCapacity-return(uintptr_t);
  probe GetDoubleArrayElements-entry(void*, void*, uintptr_t*);
  probe GetDoubleArrayElements-return(double*);
  probe GetDoubleArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, double*);
  probe GetDoubleArrayRegion-return();
  probe GetDoubleField-entry(void*, void*, uintptr_t);
  probe GetDoubleField-return(double);
  probe GetEnv-entry(void*, void*, void*);
  probe GetEnv-return(uint32_t);
  probe GetFieldID-entry(void*, void*, const char*, const char*);
  probe GetFieldID-return(uintptr_t);
  probe GetFloatArrayElements-entry(void*, void*, uintptr_t*);
  probe GetFloatArrayElements-return(float*);
  probe GetFloatArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, float*);
  probe GetFloatArrayRegion-return();
  probe GetFloatField-entry(void*, void*, uintptr_t);
  probe GetFloatField-return(float);
  probe GetIntArrayElements-entry(void*, void*, uintptr_t*);
  probe GetIntArrayElements-return(uint32_t*);
  probe GetIntArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uint32_t*);
  probe GetIntArrayRegion-return();
  probe GetIntField-entry(void*, void*, uintptr_t);
  probe GetIntField-return(uint32_t);
  probe GetJavaVM-entry(void*, void**);
  probe GetJavaVM-return(uint32_t);
  probe GetLongArrayElements-entry(void*, void*, uintptr_t*);
  probe GetLongArrayElements-return(uintptr_t*);
  probe GetLongArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uintptr_t*);
  probe GetLongArrayRegion-return();
  probe GetLongField-entry(void*, void*, uintptr_t);
  probe GetLongField-return(uintptr_t);
  probe GetMethodID-entry(void*, void*, const char*, const char*);
  probe GetMethodID-return(uintptr_t);
  probe GetObjectArrayElement-entry(void*, void*, uintptr_t);
  probe GetObjectArrayElement-return(void*);
  probe GetObjectClass-entry(void*, void*);
  probe GetObjectClass-return(void*);
  probe GetObjectField-entry(void*, void*, uintptr_t);
  probe GetObjectField-return(void*);
  probe GetObjectRefType-entry(void*, void*);
  probe GetObjectRefType-return(void*);
  probe GetPrimitiveArrayCritical-entry(void*, void*, uintptr_t*);
  probe GetPrimitiveArrayCritical-return(void*);
  probe GetShortArrayElements-entry(void*, void*, uintptr_t*);
  probe GetShortArrayElements-return(uint16_t*);
  probe GetShortArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
  probe GetShortArrayRegion-return();
  probe GetShortField-entry(void*, void*, uintptr_t);
  probe GetShortField-return(uint16_t);
  probe GetStaticBooleanField-entry(void*, void*, uintptr_t);
  probe GetStaticBooleanField-return(uintptr_t);
  probe GetStaticByteField-entry(void*, void*, uintptr_t);
  probe GetStaticByteField-return(char);
  probe GetStaticCharField-entry(void*, void*, uintptr_t);
  probe GetStaticCharField-return(uint16_t);
  probe GetStaticDoubleField-entry(void*, void*, uintptr_t);
  probe GetStaticDoubleField-return(double);
  probe GetStaticFieldID-entry(void*, void*, const char*, const char*);
  probe GetStaticFieldID-return(uintptr_t);
  probe GetStaticFloatField-entry(void*, void*, uintptr_t);
  probe GetStaticFloatField-return(float);
  probe GetStaticIntField-entry(void*, void*, uintptr_t);
  probe GetStaticIntField-return(uint32_t);
  probe GetStaticLongField-entry(void*, void*, uintptr_t);
  probe GetStaticLongField-return(uintptr_t);
  probe GetStaticMethodID-entry(void*, void*, const char*, const char*);
  probe GetStaticMethodID-return(uintptr_t);
  probe GetStaticObjectField-entry(void*, void*, uintptr_t);
  probe GetStaticObjectField-return(void*);
  probe GetStaticShortField-entry(void*, void*, uintptr_t);
  probe GetStaticShortField-return(uint16_t);
  pro GetStringChars-entry(void*, void*, uintptr_t*);
  probe GetStringChars-return(const uint16_t*);
  probe GetStringCritical-entry(void*, void*, uintptr_t*);
  probe GetStringCritical-return(const uint16_t*);
  probe GetStringLength-entry(void*, void*);
  probe GetStringLength-return(uintptr_t);
  probe GetStringRegion-entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
  probe GetStringRegion-return();
  probe GetStringUTFChars-entry(void*, void*, uintptr_t*);
  probe GetStringUTFChars-return(const char*);
  probe GetStringUTFLength-entry(void*, void*);
  probe GetStringUTFLength-return(uintptr_t);
  probe GetStringUTFRegion-entry(void*, void*, uintptr_t, uintptr_t, char*);
  probe GetStringUTFRegion-return();
  probe GetSuperclass-entry(void*, void*);
  probe GetSuperclass-return(void*);
  probe GetVersion-entry(void*);
  probe GetVersion-return(uint32_t);
  probe IsAssignableFrom-entry(void*, void*, void*);
  probe IsAssignableFrom-return(uintptr_t);
  probe IsInstanceOf-entry(void*, void*, void*);
  probe IsInstanceOf-return(uintptr_t);
  probe IsSameObject-entry(void*, void*, void*);
  probe IsSameObject-return(uintptr_t);
  probe MonitorEnter-entry(void*, void*);
  probe MonitorEnter-return(uint32_t);
  probe MonitorExit-entry(void*, void*);
  probe MonitorExit-return(uint32_t);
  probe NewBooleanArray-entry(void*, uintptr_t);
  probe NewBooleanArray-return(void*);
  probe NewByteArray-entry(void*, uintptr_t);
  probe NewByteArray-return(void*);
  probe NewCharArray-entry(void*, uintptr_t);
  probe NewCharArray-return(void*);
  probe NewDirectByteBuffer-entry(void*, void*, uintptr_t);
  probe NewDirectByteBuffer-return(void*);
  probe NewDoubleArray-entry(void*, uintptr_t);
  probe NewDoubleArray-return(void*);
  probe NewFloatArray-entry(void*, uintptr_t);
  probe NewFloatArray-return(void*);
  probe NewGlobalRef-entry(void*, void*);
  probe NewGlobalRef-return(void*);
  probe NewIntArray-entry(void*, uintptr_t);
  probe NewIntArray-return(void*);
  probe NewLocalRef-entry(void*, void*);
  probe NewLocalRef-return(void*);
  probe NewLongArray-entry(void*, uintptr_t);
  probe NewLongArray-return(void*);
  probe NewObjectA-entry(void*, void*, uintptr_t);
  probe NewObjectA-return(void*);
  probe NewObjectArray-entry(void*, uintptr_t, void*, void*);
  probe NewObjectArray-return(void*);
  probe NewObject-entry(void*, void*, uintptr_t);
  probe NewObject-return(void*);
  probe NewObjectV-entry(void*, void*, uintptr_t);
  probe NewObjectV-return(void*);
  probe NewShortArray-entry(void*, uintptr_t);
  probe NewShortArray-return(void*);
  probe NewString-entry(void*, const uint16_t*, uintptr_t);
  probe NewString-return(void*);
  probe NewStringUTF-entry(void*, const char*);
  probe NewStringUTF-return(void*);
  probe NewWeakGlobalRef-entry(void*, void*);
  probe NewWeakGlobalRef-return(void*);
  probe PopLocalFrame-entry(void*, void*);
  probe PopLocalFrame-return(void*);
  probe PushLocalFrame-entry(void*, uint32_t);
  probe PushLocalFrame-return(uint32_t);
  probe RegisterNatives-entry(void*, void*, const void*, uint32_t);
  probe RegisterNatives-return(uint32_t);
  probe ReleaseBooleanArrayElements-entry(void*, void*, uintptr_t*, uint32_t);
  probe ReleaseBooleanArrayElements-return();
  probe ReleaseByteArrayElements-entry(void*, void*, char*, uint32_t);
  probe ReleaseByteArrayElements-return();
  probe ReleaseCharArrayElements-entry(void*, void*, uint16_t*, uint32_t);
  probe ReleaseCharArrayElements-return();
  probe ReleaseDoubleArrayElements-entry(void*, void*, double*, uint32_t);
  probe ReleaseDoubleArrayElements-return();
  probe ReleaseFloatArrayElements-entry(void*, void*, float*, uint32_t);
  probe ReleaseFloatArrayElements-return();
  probe ReleaseIntArrayElements-entry(void*, void*, uint32_t*, uint32_t);
  probe ReleaseIntArrayElements-return();
  probe ReleaseLongArrayElements-entry(void*, void*, uintptr_t*, uint32_t);
  probe ReleaseLongArrayElements-return();
  probe ReleaseObjectArrayElements-entry(void*, void*, void**, uint32_t);
  probe ReleaseObjectArrayElements-return();
  probe Releasey(void*, void*, void*, uint32_t);
  probe ReleasePrimitiveArrayCritical-return();
  probe ReleaseShortArrayElements-entry(void*, void*, uint16_t*, uint32_t);
  probe ReleaseShortArrayElements-return();
  probe ReleaseStringChars-entry(void*, void*, const uint16_t*);
  probe ReleaseStringChars-return();
  probe ReleaseStringCritical-entry(void*, void*, const uint16_t*);
  probe ReleaseStringCritical-return();
  probe ReleaseStringUTFChars-entry(void*, void*, const char*);
  probe ReleaseStringUTFChars-return();
  probe SetBooleanArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uintptr_t*);
  probe SetBooleanArrayRegion-return();
  probe SetBooleanField-entry(void*, void*, uintptr_t, uintptr_t);
  probe SetBooleanField-return();
  probe SetByteArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const char*);
  probe SetByteArrayRegion-return();
  probe SetByteField-entry(void*, void*, uintptr_t, char);
  probe SetByteField-return();
  probe SetCharArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uint16_t*);
  probe SetCharArrayRegion-return();
  probe SetCharField-entry(void*, void*, uintptr_t, uint16_t);
  probe SetCharField-return();
  probe SetDoubleArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const double*);
  probe SetDoubleArrayRegion-return();
  probe SetDoubleField-entry(void*, void*, uintptr_t, double);
  probe SetDoubleField-return();
  probe SetFloatArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const float*);
  probe SetFloatArrayRegion-return();
  probe SetFloatField-entry(void*, void*, uintptr_t, float);
  probe SetFloatField-return();
  probe SetIntArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uint32_t*);
  probe SetIntArrayRegion-return();
  probe SetIntField-entry(void*, void*, uintptr_t, uint32_t);
  probe SetIntField-return();
  probe SetLongArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uintptr_t*);
  probe SetLongArrayRegion-return();
  probe SetLongField-entry(void*, void*, uintptr_t, uintptr_t);
  probe SetLongField-return();
  probe SetObjectArrayElement-entry(void*, void*, uintptr_t, void*);
  probe SetObjectArrayElement-return();
  probe SetObjectField-entry(void*, void*, uintptr_t, void*);
  probe SetObjectField-return();
  probe SetShortArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uint16_t*);
  probe SetShortArrayRegion-return();
  probe SetShortField-entry(void*, void*, uintptr_t, uint16_t);
  probe SetShortField-return();
  probe SetStaticBooleanField-entry(void*, void*, uintptr_t, uintptr_t);
  probe SetStaticBooleanField-return();
  probe SetStaticByteField-entry(void*, void*, uintptr_t, char);
  probe SetStaticByteField-return();
  probe SetStaticCharField-entry(void*, void*, uintptr_t, uint16_t);
  probe SetStaticCharField-return();
  probe SetStaticDoubleField-entry(void*, void*, uintptr_t, double);
  probe SetStaticDoubleField-return();
  probe SetStaticFloatField-entry(void*, void*, uintptr_t, float);
  probe SetStaticFloatField-return();
  probe SetStaticIntField-entry(void*, void*, uintptr_t, uint32_t);
  probe SetStaticIntField-return();
  probe SetStaticLongField-entry(void*, void*, uintptr_t, uintptr_t);
  probe SetStaticLongField-return();
  probe SetStaticObjectField-entry(void*, void*, uintptr_t, void*);
  probe SetStaticObjectField-return();
  probe SetStaticShortField-entry(void*, void*, uintptr_t, uint16_t);
  probe SetStaticShortField-return();
  probe Throw-entry(void*, void*);
  probe ThrowNew-entry(void*, void*, const char*);
  probe ThrowNew-return(uint32_t);
  probe Throw-return(uint32_t);
  probe ToReflectedField-entry(void*, void*, uintptr_t, uintptr_t);
  probe ToReflectedField-return(void*);
  probe ToReflectedMethod-entry(void*, void*, uintptr_t, uintptr_t);
  probe ToReflectedMethod-return(void*);
  probe UnregisterNatives-entry(void*, void*);
  probe UnregisterNatives-return(uint32_t);
};


Error Reporting
When the Java Virtual Machine (JVM) detects a crash in native code such as JNI code written by the developer or when the JVM itself crashes, it will print debug information about the crash. This error message normally will include information such as the function name, library name, source-file name and line number at which the error occurred. (Currently, information about file name and line number are available only available on Microsoft Windows platforms.) For an example of a message emitted by the error handler, see JNI Error example.

The information provided by the new error-reporting mechanism will allow developers to more easily and efficiently debug their applications. If an error message indicates a problem in the JVM code itself, it will allow a developer to submit a more accurate and helpful bug report.

Sometimes the error-reporting mechanism won't be able to determine the information that might be helpful in locating the source of a crash. To get the most out of the error handler, developers should be aware of the following guidelines and limitations.

Compile in debug mode

In some circumstances, the error-reporting mechanism won't be able to determine symbol names. The most common reason for this is that the binary code that crashed was not compiled in debug mode and therefore doesn't have symbol tables. Developers should compile their code in debug mode to ensure that it contains the necessary debug information. In Visual Studio, for example, this means choosing "Debug" rather than "Release" as the project's build mode. When using gcc or cc on Linux or on the SolarisTM operating environment, compile using the -g command-line option.

Non-exported functions

Even without debug information in the binary code, the error handler can still print the function name of the crash site. However, the function name might not be correct if the problematic function is not "exported" from the dynamic library. On Linux and Solaris, all functions are exported except those declared static. On Microsoft Windows platforms, no functions are exported unless explicitly declared so (using JNIEXPORT or __declspec(dllexport)).

Visual Studio limitation on Windows 98 and Windows NT

On Windows 98 and Windows NT platforms, the error handler uses the system's imagehlp.dll file to help determine the function name, source file, and line number of a crash site. (Windows 2000 and Windows ME use two files, imagehlp.dll and debughlp.dll to perform this task.) However, the imagehlp.dll file in Windows 98 and Windows NT does not work well with binary code and DLLs generated by Visual Studio 6.0.

This problem may cause the error handler to generate error messages with incorrect information about the function name, source file and line number of the crash site, though other information in the error message will be correct.

Copyright © 2002 Sun Microsystems, Inc. All Rights Reserved.

 Sun


Garbage Collection Ergonomics

Garbage Collector Ergonomics

The following changes take effect with J2SE 5.0.

  1. On server-class machines running the server VM, the garbage collector (GC) has changed from the previous serial collector (-XX:+UseSerialGC) to a parallel collector (-XX:+UseParallelGC). You can override this default by using the -XX:+UseSerialGC command-line option to the java command.

  2. On server-class machines running either VM (client or server) with the parallel garbage collector (-XX:+UseParallelGC) the initial heap size and maximum heap size have changed as follows.

    initial heap size:

    Larger of 1/64th of the machine's physical memory on the machine or some reasonable minimum. Before J2SE 5.0, the default initial heap size was a reasonable minimum, which varies by platform. You can override this default using the -Xms command-line option.

    maximum heap size:

    Smaller of 1/4th of the physical memory or 1GB. Before J2SE 5.0, the default maximum heap size was 64MB. You can override this default using the -Xmx command-line option.

    Note: The boundaries and fractions given for the heap size are correct for J2SE 5.0. They are likely to be different in subsequent releases as computers get more powerful.

  3. The parallel garbage collector (UseParallelGC) throws an out-of-memory exception if an excessive amount of time is being spent collecting a small amount of the heap. To avoid this exception, you can increase the size of the heap. You can also set the parameters -XX:GCTimeLimit=time-limit and -XX:GCHeapFreeLimit=space-limit where:

    time-limit:
    The upper limit on the amount of time spent in garbage collection in percent of total time (default is 98).
    space-limit:
    The lower limit on the amount of space freed during a garbage collection in percent of the maximum heap (default is 2).

  4. The implementation of -XX:+UseAdaptiveSizePolicy used by default with the -XX:+UseParallelGC garbage collector has changed to consider three goals:
    • a desired maximum GC pause goal
    • a desired application throughput goal
    • minimum footprint

The implementation checks (in this order):

    1. If the GC pause time is greater than the pause time goal then reduce the generations sizes to better attain the goal.
    2. If the pause time goal is being met then consider the application's throughput goal. If the application's throughput goal is not being met, then increase the sizes of the generations to better attain the goal.
    3. If both the pause time goal and the throughput goal are being met, then the size of the generations are decreased to reduce footprint.

Flags

    -XX:MaxGCPauseMillis=nnn
    A hint to the virtual machine that pause times of nnn milliseconds or less are desired. The VM will adjust the java heap size and other GC-related parameters in an attempt to keep GC-induced pauses shorter than nnn milliseconds. Note that this may cause the VM to reduce overall throughput, and in some cases the VM will not be able to meet the desired pause time goal.

    By default there is no pause time goal. There are definite limitations on how well a pause time goal can be met. The pause time for a GC depends on the amount of live data in the heap. The minor and major collections depend in different ways on the amount of live data. This parameter should be used with caution. A value that is too small will cause the system to spend an excessive amount of time doing garbage collection.

    -XX:GCTimeRatio=nnn
    A hint to the virtual machine that it's desirable that not more than 1 / (1 + nnn) of the application execution time be spent in the collector.

    For example -XX:GCTimeRatio=19 sets a goal of 5% of the total time for GC and throughput goal of 95%. That is, the application should get 19 times as much time as the collector.

    By default the value is 99, meaning the application should get at least 99 times as much time as the collector. That is, the collector should run for not more than 1% of the total time. This was selected as a good choice for server applications. A value that is too high will cause the size of the heap to grow to its maximum.

Suggested strategy

Do not choose a maximum value for the heap unless you know that the heap is greater than the default maximum heap size. Choose a throughput goal that is sufficient for your application.

In an ideal situation the heap will grow to a value (less than the maximum) that will support the chosen throughput goal.

If the heap grows to its maximum, the throughput cannot be met within that maximum. Set the maximum heap as large as you can, but no larger than the size of physical memory on the platform, and execute the application again. If the throughput goal can still not be met, then it is too high for the available memory on the platform.

If the throughput goal can be met but there are pauses that are too long, select a pause time goal. This will likely mean that your throughput goal will not be met, so choose values that are an acceptable compromise for the application.


Java Virtual Machine Technology

Java

JavaTM Virtual Machine Technology

 Documentation Contents

The JDKTM provides one or more implementations of the JavaTM virtual machine (VM):

  • On platforms typically used for client applications, the JDK comes with a VM implementation called the Java HotSpotTM Client VM (client VM). The client VM is tuned for reducing start-up time and memory footprint. It can be invoked by using the -client command-line option when launching an application.

  • On all platforms, the JDK comes with an implementation of the Java virtual machine called the Java HotSpot Server VM (server VM). The server VM is designed for maximum program execution speed. It can be invoked by using the -server command-line option when launching an application.

Some features of Java HotSpot technology, common to both VM implementations, are the following.

  • Adaptive compiler - Applications are launched using a standard interpreter, but the code is then analyzed as it runs to detect performance bottlenecks, or "hot spots". The Java HotSpot VMs compile those performance-critical portions of the code for a boost in performance, while avoiding unnecessary compilation of seldom-used code (most of the program). The Java HotSpot VMs also use the adaptive compiler to decide, on the fly, how best to optimize compiled code with techniques such as in-lining. The runtime analysis performed by the compiler allows it to eliminate guesswork in determining which optimizations will yield the largest performance benefit.

  • Rapid memory allocation and garbage collection - Java HotSpot technology provides for rapid memory allocation for objects, and it offers a choice of fast, efficient, state-of-the-art garbage collectors.

  • Thread synchronization - The Java programming language allows for use of multiple, concurrent paths of program execution (called "threads"). Java HotSpot technology provides a thread-handling capability that is designed to scale readily for use in large, shared-memory multiprocessor servers.

Tools

Some operating characteristics of the Java HotSpot VM can be controlled by the use of command-line flags.

  • Standard HotSpot VM Options for Microsoft Windows | Solaris and Linux Operating Environments - The command-line options supported by the Java HotSpot VMs are described on the reference pages for the Java application launcher.
  • Non-standard Java HotSpot VM Options - Non-standard options recognized by the current implementations of the VMs, but not necessarily by future or non-Sun implementations, are described on this web page.

Enhancements

Enhancements in JDK 6:
  • DTrace Probes
  • Garbage Collection Enhancements
    • Parallel Compaction
    • Concurrent Mark Sweep Collector Enhancements
Enhancements in JDK 5.0:
  • Class Data Sharing
  • Server-Class Machine Detection
  • Garbage Collection Ergonomics
  • Thread Priority Changes
Enhancements in J2SE 1.4.x:
  • Virtual Machine Enhancements in JDK 1.4.2, 1.4.1 and 1.4.0

More Information

  • The HotSpot Home Page
  • Performance Improvements

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

Feedback 		Sun


Parallel Compaction

  • Description
  • Enabling Parallel Compaction
  • More Information

Description

Parallel compaction complements the existing parallel collector by performing full GCs in parallel to take advantage of multiprocessor (or multi-threaded) hardware. As the name suggests, it is best suited to platforms that have two or more CPUs or two or more hardware threads. It was first made available in JDK 5.0 update 6; the implementation in JDK 6 contains significant performance improvements.

Prior to the availability of parallel compaction, the parallel collector would perform young generation collections (young GCs) in parallel, but full GCs were performed single-threaded. (During a young GC, only the young generation is collected; during a full GC the entire heap is collected. See the documents referenced below for more details on generations and garbage collection.) Parallel compaction performs full GCs in parallel, resulting in lower garbage collection overhead and better application performance, particularly for applications with large heaps running on multiprocessor hardware.

Enabling Parallel Compaction

Parallel compaction is not enabled by default; add the option

-XX:+UseParallelOldGC

to the java command line to enable parallel compaction. (Parallel compaction will likely be enabled by default on multiprocessor hardware in a future release.)

Note that parallel compaction is not available in combination with the concurrent mark sweep collector; it can only be used with the parallel young generation collector. The documents referenced below provide more information on the available collectors and recommendations for their use.

More Information

The HotSpot memory management whitepaper describes the various collectors available in HotSpot and includes recommendations on when to use parallel compaction as well as a high-level description of the algorithm.

The HotSpot documentation page contains links to Garbage Collection Tuning Guides, specific to each release, which include guidelines for choosing the garbage collector that best suits your requirements and techniques that can help reduce garbage collection overhead.


Sample Output from Deadlock Detection Utility

^\Full thread dump Java HotSpot(TM) Client VM (1.4.1 mixed mode):

"DestroyJavaVM" prio=5 tid=0x2c788 nid=0x1 waiting on condition [0..ffbee16c]

"Thread-7" prio=5 tid=0x119570 nid=0x11 waiting for monitor entry [f1681000..f168199c]
        at Locker.run(Deadlock.java:98)
        - waiting to lock  (a java.lang.Object)
        - locked  (a java.lang.String)

"Thread-6" prio=5 tid=0x118a18 nid=0x10 waiting for monitor entry [f1781000..f178199c]
        at Locker.run(Deadlock.java:98)
        - waiting to lock  (a java.lang.String)
        - locked  (a java.lang.Object)

"Thread-5" prio=5 tid=0x117660 nid=0xf waiting on condition [f1881000..f188199c]
        at java.lang.Thread.sleep(Native Method)
        at Deadlock$3.run(Deadlock.java:55)
        - locked  (a java.lang.Object)
        at java.lang.Thread.run(Thread.java:536)

"Thread-4" prio=5 tid=0x116ab8 nid=0xe waiting for monitor entry [f1981000..f198199c]
        at Deadlock.jniEnter(Native Method)
        at Deadlock$2.run(Deadlock.java:41)
        at java.lang.Thread.run(Thread.java:536)

"Thread-3" prio=5 tid=0x115f10 nid=0xd runnable [f1a81000..f1a8199c]
        at Deadlock.rawEnter(Deadlock.java:76)
        at Deadlock$1.run(Deadlock.java:24)
        at java.lang.Thread.run(Thread.java:536)

"Thread-2" prio=5 tid=0x1154a8 nid=0xc waiting for monitor entry [f1b81000..f1b8199c]
        at Locker.run(Deadlock.java:98)
        - waiting to lock  (a java.lang.String)
        - locked  (a java.lang.Object)

"Thread-1" prio=5 tid=0x115270 nid=0xb waiting for monitor entry [f1c81000..f1c8199c]
        at Locker.run(Deadlock.java:98)
        - waiting to lock  (a java.lang.Object)
        - locked  (a java.lang.Object)

"Signal Dispatcher" daemon prio=10 tid=0xbac48 nid=0x9 waiting on condition [0..0]

"Finalizer" daemon prio=8 tid=0xb5590 nid=0x6 in Object.wait() [fa381000..fa38199c]
        at java.lang.Object.wait(Native Method)
        - waiting on  (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:111)
        - locked  (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:127)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:159)

"Reference Handler" daemon prio=10 tid=0xb3c40 nid=0x5 in Object.wait() [fdf81000..fdf8199c]
        at java.lang.Object.wait(Native Method)
        - waiting on  (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:426)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:113)
        - locked  (a java.lang.ref.Reference$Lock)

"VM Thread" prio=5 tid=0xb2808 nid=0x4 runnable

"VM Periodic Task Thread" prio=10 tid=0xb9190 nid=0x7 waiting on condition
"Suspend Checker Thread" prio=10 tid=0xb9ae8 nid=0x8 runnable

Found one Java-level deadlock:
=============================
"Thread-7":
  waiting to lock monitor 0xb48d8 (object 0xf203fe18, a java.lang.Object),
  which is held by "Thread-6"
"Thread-6":
  waiting to lock monitor 0xb48a0 (object 0xf6112a88, a java.lang.String),
  which is held by "Thread-7"

Java stack information for the threads listed above:
===================================================
"Thread-7":
        at Locker.run(Deadlock.java:98)
        - waiting to lock  (a java.lang.Object)
        - locked  (a java.lang.String)
"Thread-6":
        at Locker.run(Deadlock.java:98)
        - waiting to lock  (a java.lang.String)
        - locked  (a java.lang.Object)

Found one Java-level deadlock:
=============================
"Thread-4":
  waiting to lock monitor 0xb4868 (object 0xf203fdf8, a java.lang.Object)
  in JNI, which is held by "Thread-1"
"Thread-1":
  waiting to lock monitor 0xb4910 (object 0xf203fe00, a java.lang.Object),
  which is held by "Thread-2"
"Thread-2":
  waiting to lock monitor 0xb4830 (object 0xf6112a60, a java.lang.String),
  which is held by "Thread-3"
"Thread-3":
  waiting to lock monitor 0x119520 (JVMDI/JVMPI raw monitor),
  which is held by "Thread-4"

Java stack information for the threads listed above:
===================================================
"Thread-4":
        at Deadlock.jniEnter(Native Method)
        at Deadlock$2.run(Deadlock.java:41)
        at java.lang.Thread.run(Thread.java:536)
"Thread-1":
        at Locker.run(Deadlock.java:98)
        - waiting to lock  (a java.lang.Object)
        - locked  (a java.lang.Object)
"Thread-2":
        at Locker.run(Deadlock.java:98)
        - waiting to lock  (a java.lang.String)
        - locked  (a java.lang.Object)
"Thread-3":
        at Deadlock.rawEnter(Deadlock.java:76)
        at Deadlock$1.run(Deadlock.java:24)
        at java.lang.Thread.run(Thread.java:536)

Found 2 deadlocks.


Server-Class Machine Detection

Starting with J2SE 5.0, when an application starts up, the launcher can attempt to detect whether the application is running on a "server-class" machine and, if so, use the Java HotSpot Server Virtual Machine (server VM) instead of the Java HotSpot Client Virtual Machine (client VM). The aim is to improve performance even if no one configures the VM to reflect the application it's running. In general, the server VM starts up more slowly than the client VM, but over time runs more quickly.

Note: For Java SE 6, the definition of a server-class machine is one with at least 2 CPUs and at least 2GB of physical memory.

In Java SE 6, server-class detection occurs if neither -server nor -client is specified when launching the application on an i586 or Sparc 32-bit machine running Solaris or Linux. As the following table shows, the i586 Microsoft Windows platform uses the client VM by default. The remaining Sun-supported platforms use only the server VM.

Platform |  | Default VM
Architecture | OS | client VM | if server-class, server VM; otherwise, client VM | server VM
SPARC 32-bit | Solaris |  | X |
i586 | Solaris |  | X |
 | Linux |  | X |
 | Microsoft Windows | X |  |
SPARC 64-bit | Solaris | — |  | X
AMD64 | Solaris | — |  | X
 | Linux | — |  | X
 | Microsoft Windows | — |  | X
Legend: X = default VM — = client VM not provided for this platform

For details of using command-line options for launching applications, see the java tool documentation for Solaris and Linux, or Microsoft Windows.


Signal Chaining
The JavaTM 2 SDK, Standard Edition, (JDK) v1.4 contains a new signal-chaining facility. Signal-chaining enables the Java Platform to better interoperate with native code that installs its own signal handlers. The facility works on both Solaris and Linux platforms.

The signal-chaining facility was introduced to remedy a problem with signal handling in previous versions of the Java HotSpot VM. Prior to version 1.4, the Java HotSpot VM would not allow application-installed signal handlers for certain signals including, for example, SIGBUS, SIGSEGV, SIGILL, etc, since those signal handlers could conflict with the signal handlers used internally by the Java HotSpot VM.

The signal-chaining facility offers:

A. Support for pre-installed signal handlers when the HotSpot VM is created.
B. Support for signal handler installation after the HotSpot VM is created, inside JNI code or from another native thread.

Pre-installed signal handlers (A) are supported by means of saving existing signal handlers, for signals that are used by the VM, when the VM is first created. Later, when any of these signals are raised and found not to be targeted at the Java HotSpot VM, the pre-installed handlers are invoked. In other words, pre-installed handlers are "chained" behind the VM handlers for these signals.

The signal-chaining facility also allows an application to link and load a shared library libjsig.so before libc/libthread/libpthread. This library ensures that calls such as signal(), sigset(), and sigaction() are intercepted so that they do not actually replace the Java HotSpot VM's signal handlers if the handlers conflict with those already installed by the Java HotSpot VM (B). Instead, these calls save the new signal handlers, or "chain" them behind the VM-installed handlers. Later, when any of these signals are raised and found not to be targeted at the Java HotSpot VM, the pre-installed handlers are invoked. libjsig.so is not needed if (B) is not required.

To use libjsig.so, either link it with the application that creates/embeds a HotSpot VM, for example:

cc -L <libjvm.so dir> -ljsig -ljvm java_application.c
or use LD_PRELOAD environment variable, for example:
export LD_PRELOAD=<libjvm.so dir>/libjsig.so; java_application (ksh)

setenv LD_PRELOAD <libjvm.so dir>/libjsig.so; java_application (csh)
The interposed signal()/sigset()/sigaction() return the saved signal handlers, not the signal handlers installed by the Java HotSpot VM which are seen by the OS.

The signal-chaining facility was introduced to address Request for Enhancement number 4381843.

Copyright © 2002 Sun Microsystems, Inc. All Rights Reserved.

 Sun


Thread Priority on Solaris

Thread Priority on the Solaris™ Platform

This document discusses how the Java™ virtual machine (JVM) maps priorities for threads executing in the JVM (Java threads) onto native thread priorities on Solaris. It covers both current and past implementations of Solaris threads and the JVM.

  • Background Information: Java Threads
  • Background Information: Solaris Threads
    • Libthread Variants: T1 and T2
    • Native LWP Priorities
    • Summary
  • Historical Thread Priority Implementations
    • Before JRE 1.4.2
    • JRE 1.4.2
    • JRE 5.0
  • Miscellany
  • General Scheduling Issues: Priority, Yielding, and Monitor Fairness

Background Information: Java Threads

The JVM defines a range of ten logical priorities for Java threads, including:

java.lang.Thread.MIN_PRIORITY  = 1
java.lang.Thread.NORM_PRIORITY = 5
java.lang.Thread.MAX_PRIORITY  = 10

These values [1..10] are passed into Thread.setPriority(int) to assign priorities to Java threads. The default priority of a Java thread is NORM_PRIORITY. (A Java thread that doesn't explicitly call setPriority runs at NORM_PRIORITY.) A JVM is free to implement priorities in any way it chooses, including ignoring the value.

The Java HotSpot™ virtual machine currently associates each Java thread with a unique native thread. The relationship between the Java thread and the native thread is stable and persists for the lifetime of the Java thread.

Background Information: Solaris

Libthread Variants: T1 and T2

Prior to Solaris 9 the default libthread was the so-called T1 libthread. T1 provided an M:N threading model where M native threads were multiplexed on top of N kernel threads (LWPs). The relationship between native threads and LWPs was fluid and dynamic and could change even while a thread was running and without the knowledge of the thread. Solaris provided the priocntl() system call to change the dispatching priority of an LWP, but because the relationship between LWPs and native threads was unstable so there was no reliable way to change to change the dispatching priority of a native thread. (The JVM could change the priority of the LWP on which a Java thread was currently running, but the thread could switch to another LWP without the JVM's knowledge).

T2, the default libthread in Solaris 9 and better, implements a much more simple and robust 1:1 threading model. Each native thread is assigned to a unique LWP, and that relationship is stable for the lifetime of the native thread.

Both T1 and T2 expose a thr_setprio() API that applications use to set a thread's process-local priority. The value assigned by thr_setprio() is a process-local attribute and is not visible to the kernel scheduler. The thr_setprio()-priority controls the placement and ordering of threads on user-level process-local sleep queues, such as the queue of threads associated with a contended process-local mutex. In HotSpot most mutexes are uncontended and condvars have usually have either 0 or 1 threads. As such, the ordering imposed by thr_setprio()-priority has very little effect on most Java threads. The thr_setprio() function supports priority values in the range 0 through 127, inclusive, with 127 representing the highest priority.

T1 also uses thread priority to implement rudimentary user-mode preemption. T1 maintains an invariant that the thr_setprio()-priority of any thread on the local ready queue must be less than or equal to the priority of any unbound thread that's currently running and associated with an LWP. If the invariant is threatened, T1 preempts the lowest priority executing thread to "steal" its LWP in order to reestablish the invariant.

Preemption can occur in these cases:

  • When a running native thread lowers its own priority
  • When a running native thread increases the priority of a ready thread
  • When a native thread becomes ready, and its priority is higher than any "running" native thread. This could happen, for example, when a Java thread exits a monitor or calls notify and the JVM is using user-level Solaris synchronization primitives.

An early version of T2, referred to as the alternate libthread, appeared in Solaris 8.

For additional information about T1, T2, and LWPs refer to the following:

  • http://developers.sun.com/solaris/articles/alt_thread_lib.html
  • http://wwws.sun.com/software/whitepapers/solaris9/multithread.pdf

Native LWP Priorities

In Solaris an LWP's priority influences how many CPU cycles a thread receives relative to other threads. The Solaris scheduler uses priority (among other factors) to determine if one thread should preempt another thread, how often a thread runs, and how long a thread runs. Native LWP priorities are assigned by the priocntl() system call.

Summary

To recap, we have Java threads, with priorities set by the Thread.setPriority method. Java threads run on native threads. The thr_setprio() function is used to change the priority of native threads. Native threads run on LWPs. The priocntl() system call is used to change the priority of LWPs.

Historical Thread Priority Implementations

Before 1.4.2

In releases earlier than 1.4.2, when a Java thread called the Thread.setPriority method or when a thread was created, HotSpot would call thr_setprio() to map the Java priority to an native priority. Calling thr_setprio() had very little effect on the execution behavior of of a Java thread. The JVM did not call priocntl() to adjust the priority of the underlying LWP. This was a conscious design decision because in the 1.4.2 time frame the only libthread available on Solaris was the older T1 libthread.

Note: The JVM could have forced native threads to be bound 1:1 to LWPs under T1 by specifying THR_BOUND when threads are created. THR_BOUND is not sufficient, however, as threads that attach to the JVM might not be THR_BOUND and the primordial thread is not THR_BOUND. Given that there's no way in Solaris to force a thread to be bound after it's been created, the HotSpot implementors decided that it was prudent not to change LWP priority when a Java thread called setPriority()

1.4.2

In 1.4.2 HotSpot was able to determine at startup time if it was running under T1 or T2. If the JVM started under T1 the effect of priorities would be precisely the same as in earlier releases.

Under T2, however, 1.4.2 translated calls to the Thread.setPriority method into calls to both thr_setprio() (to change the native process-local priority) and to priocntl() (to change the dispatching priority of the underlying LWP). The JVM called priocntl() only for threads that are running in the TS (timeshare), IA (interactive), and RT (real-time) scheduling classes. Refer to the Solaris priocntl(2) man page for a description of scheduling classes. If a Java thread was not in the TS, IA, or RT scheduling classes the JVM would not attempt to set the priority of the underlying LWP with priocntl().

Unfortunately the default priority of native threads in the TS and IA scheduling classes is the highest possible priority. The default logical priority for Java threads is NORM_PRIORITY, which is midway in domain of Java thread priorities. When the JVM maps NORM_PRIORITY to native and LWP priorities, the outcome is a value that is less then the default native priority. Let's say we have a 2-CPU system running a JVM, and that JVM has two Java threads, both at NORM_PRIORITY. Assume that the threads are in the IA or TS scheduling class, as is commonly the case. When the Java threads are created, the JVM calls priocntl() to map NORM_PRIORITY to the middle of the TS or IA priority bands. Furthermore, assume that 2 native "C" threads in another process are running/ready concurrently with the Java threads. Both the native C threads and the Java threads are CPU-bound and spin, computing. The native threads will run at the highest priority in the TS or IA scheduling class, and the JVM threads will run at the middle priority. Since all four threads are competing for CPU cycles, the native threads will receive relatively more CPU cycles and the Java threads will, in a sense, be disadvantaged. This effect occurs only when Java threads compete with normal threads and the system is entirely saturated.

Conversely, a benefit of using lower relative priorities is that in the TS and IA scheduling classes a thread running at lower priorities receives a longer quantum, assuming that it's not preempted mid-quantum by higher priority threads that become ready. A longer quantum is often beneficial for threads in server applications as the context switch rate from preemption decreases. A thread is permitted to run on a CPU for a longer period and the cache-reload transient (the period immediately after a thread is scheduled on to a CPU — when a thread incurs a high cache miss rate as it repopulates the CPU's data caches and displaces the previous thread's data) is amortized over a longer quantum.

JRE 5.0

JRE 5.0 provides the same priority mapping as 1.4.2 except that Java priorities in the range [10...5] are all mapped to the highest possible TS or IA priority, while priorities in the range [1..4] are mapped to correspondingly lower native TS or IA priorities. The advantage of this change is that Java threads at NORM_PRIORITY can now compete as expected with native threads. If neither the Java threads nor the native threads have explicitly set priorities (which is commonly the case), both classes of thread will compete on an equal footing, running at the highest priority in the TS or IA scheduling class.

Assuming that Java threads don't explicitly set their priority with setPriority(), this change restores the behavior and effective LWP priority of Java threads that was used prior to 1.4.2. The disadvantage to this implementation is that Java priorities from 5 to 10 are not differentiated. A Java thread at logical priority 8 maps to the same LWP priority as a Java thread at priority 9, for instance.

Miscellany

The following statements apply to all versions of HotSpot:

  • The JVM never changes the scheduling class of an LWP.
  • Calling the Thread.setPriority method may be an expensive operation. Frivolous priority adjustments can reduce performance.
  • If a foreign thread attaches to a JVM, the JVM sets that thread's priority to NORM_PRIORITY. This, in turn, changes the thread's native priority and potentially changes the priority of the LWP on which the native thread is running. Specifically, if a native thread adjusts its priority and then attaches to a JVM, the JVM overwrites the previous priority settings of the thread. The JVM does not "undo" or restore a native thread's priority if the thread detaches.

General Scheduling Issues: Priority, Yielding, and Monitor Fairness

The Thread.setPriority and Thread.yield methods are advisory. They constitute hints from the application to the JVM. Properly written, robust, platform-independent code can use setPriority() and yield() to optimize the performance of the application, but should not depend on these attributes for correctness. Likewise, no assumptions should be made about the order in which threads are granted ownership of a monitor or the order in which threads wake in response to the notify or notifyAll method. An excellent reference for these topics is Chapter 9, "Threads," in Joshua Bloch's book Effective Java Programming Language Guide.


Virtual Machine Enhancements in J2SE 1.4.x

Enhancements in J2SE 1.4.2

  • Runtime Performance

    The following are enhancements to runtime performance in 1.4.2. Also see Virtual Machine release notes for issues.

    • The interpreter-only Itanium version of 1.4.1 has been enhanced by the addition of the server compiler. Performance is up to thirty times faster than for 1.4.1.

    • The performance of applications that make heavy use of Class.forName and related methods has been significantly improved.

    • Java Native Interface usage checking via the -Xcheck:jni switch is more extensive and robust than in 1.4.1.

    • Third-party memory managers now work properly when using JVMPI and JVMDI.

  • Client HotSpot Compiler

    The following are enhancements to the client HotSpot compiler in 1.4.2. Also see Virtual Machine release notes for issues.

    • Improvements in compile speed and footprint.

  • Server HotSpot Compiler

    The following are enhancements to the server HotSpot compiler in 1.4.2. Also see Virtual Machine release notes for issues.

    • Use of SSE and SSE2 instructions on IA32 platforms when they are supported by the processor and operating system.

    • Faster integer division by constants.

    • Faster floating-point division by powers of 2.

    • Faster NullPointerException handling.

Enhancements in J2SE 1.4.1

  • J2SE 1.4.1 is available in versions that support the 64-bit Intel Itanium processor on Linux Red Hat 7.2 and Windows XP 64-bit edition. Look for the downloads for these versions on the J2SE 1.4.1 download page.

    In this release, these 64-bit versions have the following limitations.

    • Applications can be run only in interpreted mode. The platform will run in interpreted mode by default, with no need to supply the -Xint flag on the command line when launching an application. When using the 64-bit versions of the J2SE 1.4.1 platform, the command java MyApp will launch and execute MyApp by interpreting the bytecode. Java HotSpot-technology-based dynamic compilers for 64-bit support is planned for a future release of the Java SE platform.
    • The 64-bit versions of J2SE 1.4.1 do not include the Java Plug-in and Java Web Start products.
    • The 64-bit versions of J2SE 1.4.1 do not have an installer application. These versions are available only as a tar bundle.
    The 32-bit versions of the J2SE 1.4.1 will not work on Intel Itanium machines.

  • A deadlock detection utility has been added to the Java HotSpot VM. The utility is invoked by a Ctrl+\ on the command line while an application is running. The utility detects Java-platform-level deadlocks, including locking done from the Java Native Interface (JNI), the Java Virtual Machine Profiler Interface (JVMPI), and Java Virtual Machine Debug Interface (JVMDI).

    When invoked, the utility displays a thread dump to standard out and indicates any Java-platform-level deadlocks it detects. Refer to this sample output. If the application is deadlocked because two or more threads are involved in a cylce to acquire monitors, then the list of such threads and monitors involved in the deadlocks are displayed. Note, however, that this will not find deadlocks involving threads waiting on monitors on which no signal will be forthcoming.

Enhancements in J2SE 1.4.0

  • Signal chaining

  • Error-reporting mechanism

  • The new -Xloggc:file option reports on each garbage-collection event, as with -verbose:gc, but logs this data to file. In addition to the information -verbose:gc provides, each reported event is preceeded by the time (in seconds) since the first garbage-collection event.

  • Beginning with J2SDK 1.4.0, the Classic Virtual Machine is no longer shipped as part of the Java 2 SDK. (On Solaris platforms, the Classic VM was removed in J2SDK 1.3.0.) If you have been running your applications on the Classic VM by using the -classic command-line option, you will need to use either the Java HotSpot Client VM (invoked by default or by using the -client option) or Java HotSpot Server VM (invoked with the -server option). Attempting to launch an application with the -classic option will result in this message: Error: Classic VM no longer supported.

  • The SolarisTM-SPARCTM platform edition of J2SDK 1.4.0 will support 64-bit operation on 64-bit Sparc-v9 platforms when using the Java HotSpot Server VM. With a 64-bit address space, more than four gigabytes of heap memory is available. The Java HotSpot Server VM includes support for both 32-bit and 64-bit operations, and users can select either 32-bit or 64-bit operation by using command-line flags -d32 or -d64, respectively.
    • Users of the Java Native Interface will need to recompile their code to be able to run it on the 64-bit VM.
    • There is no 64-bit support for the Java HotSpot Client VM. Only the Java HotSpot Server VM provides for optional 64-bit operation.
    • Users must install 64-bit Solaris support in order to run the virtual machine in 64-bit mode.
    • On older Sparcv9 systems, users must modify the file /platform/sun4u/boot.conf in order to enable 64-bit programs. See the text in the boot.conf file for more information.

  • The new -Xcheck:jni command-line option performs additional checks for Java Native Interface (JNI) functions. Specifically, the Java Virtual Machine validates the parameters passed to the JNI function as well as the runtime environment data before processing the JNI request. Any invalid data encountered indicates a problem in the native code, and the Java Virtual Machine will terminate with a fatal error in such cases. Expect a performance degradation when this option is used.

  • The J2SE 1.4.0 platform accepts class file versions in the range 45.3 to 48.0.


XML in the Java(TM) SE Platform

Java

XML in the Java Platform Standard Edition (Java SE) 6

 Documentation Contents

XML (Extensible Markup Language) is a flexible way to create common information formats and share both the format and the data on the World Wide Web, intranets, and elsewhere. XML can be used by any individual or group of individuals or companies that wants to share information in a consistent way. XML, a formal recommendation from the World Wide Web Consortium (W3C), is similar to the language of today's Web pages, the Hypertext Markup Language (HTML). Both XML and HTML contain markup symbols to describe the contents of a page or file. HTML, however, describes the content of a Web page (mainly text and graphic images) only in terms of how it is to be displayed and interacted with. For example, a <P> starts a new paragraph. XML describes the content in terms of what data is being described. For example, a <PHONENUM> could indicate that the data that followed it was a phone number. This means that an XML file can be processed purely as data by a program or it can be stored with similar data on another computer or, like an HTML file, that it can be displayed. For example, depending on how the application in the receiving computer wanted to handle the phone number, it could be stored, displayed, or dialed.

XML Features for the Java Platform Standard Edition (Java SE)

  • The JavaTM API For XML Processing (JAXP)
  • The JavaTM Architecture For XML Binding (JAXB)

More Information

  • Java Technology XML Home Page
  • XML information in the J2EE Tutorial
  • XML at Sun

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

Feedback

Sun
Java Software


Java API for XML Processing

Java

Java Architecture for XML Binding (JAXB)

Documentation Contents

The JavaTM Architecture for XML Binding (JAXB) provides an API and tools that automate the mapping between XML documents and Java objects.

The JAXB framework enables developers to perform the following operations:

  • Unmarshal XML content into a Java representation
  • Access and update the Java representation
  • Marshal the Java representation of the XML content into XML content

JAXB gives Java developers an efficient and standard way of mapping between XML and Java code. Java developers using JAXB are more productive because they can write less code themselves and do not have to be experts in XML. JAXB makes it easier for developers to extend their applications with XML and Web Services technologies.

Tutorials and Programmer's Guides

  • Running the binding compiler (XJC): [command-line instructions, using the XJC Ant task]
  • Running the schema generator (schemagen): [command-line instructions, using the SchemaGen Ant task]
  • Unofficial JAXB User's Guide
  • Sample Applications
  • JAXB FAQs [java.sun.com, jaxb.dev.java.net]

API Enhancements

  • Release Notes

API Specification

  • Javadoc API documentation (javax.xml.bind.*)
  • JAXB Specification

More Information

  • JAXB Home Page
  • JAXB Project Community Page

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

Feedback

Sun Microsystems, Inc
Java Software


Java API for XML Processing RI 1.4 -- Readme

JavaTM API for XML Processing (JAXP)

The Java API for XML Processing (JAXP) enables applications to parse, transform, validate and query XML documents using an API that is independent of a particular XML processor implementation. JAXP provides a pluggability layer to enable vendors to provide their own implementations without introducing dependencies in application code. Using this software, application and tool developers can build fully-functional XML-enabled Java applications for e-commerce, application integration, and web publishing.

The Java Platform, Standard Edition version 6.0 includes JAXP 1.4. JAXP 1.4 is a maintenance release of JAXP 1.3 with support for the Streaming API for XML (StAX). For information about the current development activities, please refer to the JAXP project at Java.net.

API Specification

The JAXP 1.4 API includes the following packages:

  • javax.xml.datatype

  • javax.xml.namespace

  • javax.xml.parsers

  • javax.xml.stream

  • javax.xml.stream.events

  • javax.xml.stream.util

  • javax.xml.transform

  • javax.xml.transform.dom

  • javax.xml.transform.sax

  • javax.xml.transform.stax

  • javax.xml.transform.stream

  • javax.xml.validation

  • javax.xml.xpath

  • org.w3c.dom

  • org.w3c.dom.ranges

  • org.w3c.dom.traversal

  • org.w3c.dom.bootstrap

  • org.w3c.dom.events

  • org.w3c.dom.ls

  • org.xml.sax

  • org.xml.sax.ext

  • org.xml.sax.helpers

Additional Documentation

    JAXP 1.4 Release Notes

    JAXP 1.4 Compatibility Guide

Feedback

You may use the mailing lists for JAXP to send us feedback. For general questions, please post your messages to users@jaxp.dev.java.net. For issues and bugs, please use issues@jaxp.dev.java.net. You may need to subscribe to the mailing lists in order to send and receive messages.


JAXP 1.3 Release Notes

JavaTM API for XML Processing Release Notes

Specification Version: 1.3
Reference Implementation (RI) Version: 1.3.0

This document contains installation instructions and other notes that may help you use this software library more effectively. See also the JAXP FAQ for more information.

Note:
If you are reading this page online, this is the most current version of the release notes. If this page was downloaded as part of the release bundle, please see the JAXP Documentation page for the most current version of the release notes.

Contents

  • Component Versions
  • Identifying the JAR Files
  • XML Parsing
    • Known Schema Processing Limitations
    • Known Migration Issues
      • from JAXP 1.1
      • from JAXP 1.2
  • The Compiling XSLT Processor (XSLTC)
    • Custom Class Loader Issue
  • JWSDP Security Considerations
  • Changes in JAXP RI Versions

Component Versions

These versions of the relevant technologies have been incorporated into the reference implementation.
  • Xerces version 2.6.2 + (Xerces version 2.6.2 with controlled bug fixes)
  • XSLTC version 2.6.0 + (XSLTC version 2.6.0 , with controlled bug fixes, based on the Xalan 2.6.0 release)

Identifying the JAR Files

This release is contained in six JAR files:

jaxp-api.jar
The javax.xml.parsers, javax.xml.transform, javax.xml.xpath, javax.xml.validation, javax.xml.datatype, and javax.xml.namespace components of JAXP. These packages contain the APIs that give applications a consistent way to obtain instances of XML processing implementations. The javax.xml.xpath package supports the standard XPath API.
sax.jar
The APIs and helper classes for the Simple API for XML (SAX), used for serial access to XML data. The APIs support SAX version 2.0.2.
dom.jar
The APIs and helper classes for the Document Object Model (DOM), used to create an in-memory tree structure from the XML data. The APIs support DOM Level 3.
xercesImpl.jar
The implementation classes for the SAX and DOM parsers, as well as Xerces-specific implementations of the JAXP APIs..
xalan.jar
Contains XSLTC the compiling XSLT processor from the Xalan project.

XML Parsing

The information in this section pertains to the Xerces technology. The latest updates can be found at http://jaxp.dev.java.net. For information on known bugs and recent fixes in the latest Apache version, see http://xml.apache.org/xerces2-j/releases.html.

Known Schema Processing Limitations

This section discusses known schema processing bugs, limitations, and implementation-dependent operations.

Limitations

These limitations specify known upper bounds on values.
  • Length, minLength, and maxLength facets are limited to the value 2147483647.
    Items larger than this limit will not be validated correctly.
  • Year and seconds values in date/time datatypes are limited to the value 2147483647.
    Items larger than this limit will not be validated correctly.

Implementation-Dependent Operations

This implementation-dependent operation is not fully clarified by the W3C XML Schema specification (http://www.w3.org/2001/XMLSchema). As a result, differing implementations exist.
  • The JAXP 1.2 reference implementation parser (Xerces 2.0.1), <keyref> Identity Constraints refers to <key> or <unique> identity constraints within the scope of the elements to which the <keyref> is attached, as defined in the XML Schema Part 1: Structures. (The introductory section of XML Schema, on the other hand, (XML Schema Part 0: Primer) contains an example with a <keyref> declared on an element used inside the element of its corresponding <key>. The discrepancy is noted here in an effort to avoid confusion.)

Known Migration Issues

This section covers known issues that arise when migrating from earlier versions of JAXP.

Migrating from JAXP 1.2

JAXP 1.2 is built into JWSDP and J2EE 1.4. These sections of the Compatibility Guide cover the relevant migration issues:

  • IOException added to SAX EntityResolver API
    This is a change to the SAX 2.0.1 API.
  • Methods added to DOM interfaces
    This is a change in the DOM Level 3 API.
  • Package Name Changes
    This change affects applications that access implementation-specific features.

Migrating from JAXP 1.1

JAXP 1.1 is built into J2EE 1.3 and J2SE 1.4. For differences in functionality from JAXP 1.1, see the JAXP Compatibility Guide.

DOM Level 3 Implementation Notes

This section contains implementation notes for DOM Level 3 Core and DOM Level 3 Load and Save.

DOM Level 3 Core

Not implemented:

  • DOMConfiguration "infoset" parameter - value "true" is not supported.

Supported parameters:

  • error-handler [ DOMErrorHandler ]
  • resource-resolver [ DOMResourceResolver ]
  • schema-type [ String ]
  • schema-location [ String ]
  • canonical-form [ false ]
  • cdata-sections [ true/false ]
  • comments [ true/false ]
  • namespaces [ true/false ]
  • entities [ true/false ]
  • infoset [ false ]
  • namespace-declarations [ true ]
  • normalize-characters [ false ]
  • split-cdata-sections [ true/false ]
  • validate-if-schema [ true/false ]
  • whitespace-in-element-content [ true ]
  • datatype-normalization [ true/false ]
  • validate [ true/false ] -- revalidation is supported only against XML Schemas. For more information, please refer to How to revalidate DOM in memory? .
  • validate-if-schema [ true/false ]
  • check-character-normalization [ false ]
  • well-formed [ true/false ]
  • psvi [ true/false ] -- (NON-DOM) setting the value of this parameter to true will include PSVI information in the DOM tree. To access the information, cast dom.Element to org.apache.xerces.xs.ElementPSVI and dom.Attr to org.apache.xerces.xs.AttributePSVI.

DOM Level 3 Load and Save

Not supported:

  • LSParser parserWithContext
  • DOMImplementationLS MODE_ASYNCHRONOUS
  • LSSerializer - the following parameters are not supported:
    • ignore-unknown-character-denormalizations [ true ]
    • normalize-characters [ true ]
    • well-formed [ true ]

The Compiling XSLT Processor (XSLTC)

The XSLTC transformer generates a transformation engine, or translet, from an XSL stylesheet. This approach separates the interpretation of stylesheet instructions from their runtime application to XML data.

XSLTC works by compiling a stylesheet into Java byte code (translets), which can then be used to perform XSLT transformations. This approach greatly improves the performance of XSLT transformations where a given stylesheet is compiled once and used many times. It also generates an extremely lightweight translet, because only the XSLT instructions that are actually used by the stylesheet are included.

Note:
XSLT is supported by the JAXP transform package. See javax.xml.transform for details on accessing basic XSLT functionality in an implementation-independent manner.

Custom Class Loader Issue

A problem can occur when using a custom class loader with a transformation factory.

Transformation factories in JAXP always prefer the use of the "context class loader" to the use of the "system class loader". Thus, if an application uses a custom class loader, it may need to set the custom class loader as the context class loader for transformation factory to use it. Setting a custom class loader on the current thread can be done as follows:

try {
  Thread currentThread = Thread.currentThread();
  currentThread.setContextClassLoader(customClassLoader);
}
catch (SecurityException e) {
  // ...
}

If the application is multi-threaded, the custom class loader may need to be set in all threads (every time a new thread is created). A security exception is thrown if an application does not have permission to set the context class loader.

JWSDP Security Considerations

When an application is running on a web server, such as the Java Web Services Developer Pack (JWSDP), with security enabled, the following permissions must be set:

permission java.io.FilePermission

    "/${webserver.home}/common/endorsed/xercesImpl.jar", "read";
permission java.io.FilePermission
    "/${webserver.home}/common/endorsed/xalan.jar", "read";

permission java.util.PropertyPermission
    "javax.xml.parser.SAXParserFactory", "read, write";
permission java.util.PropertyPermission
    "javax.xml.transform.TransformerFactory", "read, write";

permission java.util.PropertyPermission "user.dir",        "read";
permission java.util.PropertyPermission "file.separator",  "read";
permission java.util.PropertyPermission "line.separator",  "read";
permission java.util.PropertyPermission "JavaClass.debug", "read";

permission java.lang.RuntimePermission "createClassLoader";
permission java.lang.RuntimePermission "accessDeclaredMembers";

Note:
If read permission is not set for xercesImpl.jar, a FactoryConfigurationError is thrown that says:
Provider org.apache.xerces.jaxp.SAXParserFactoryImpl not found

Changes in JAXP RI Versions

Changes in JAXP RI version 1.3

  • Xerces version changed from 2.3.0 to 2.6.2 (+ controlled bug fixes).
  • The two XSL transformation engines available in the standalone version of JAXP 1.3 are Xalan interpretive and XSLTC (based on Xalan 2.6.0 (+ controlled bugfixes)). The JAXP 1.3 version included in J2SE 5 includes only the XSLTC transformer (based on Xalan 2.6.0 (+ controlled bug fixes)).
  • New features and functionality added, as described in the What's New section of the Compatibility Guide.
  • A denial of service vulnerability was rectified by adding the system property elementAttributeLimit, which can be used to limit the number of attributes in a element. The default limit is 10,000 attributes for an element.

Changes in JAXP RI version 1.2.4

  • Fix for a J2SE 1.4.2 compilation bug in Xerces.

Changes in JAXP RI version 1.2.3

  • Xerces version changed from 2.2.1 to 2.3.0 (+ controlled bug fixes). This version Includes many bug fixes.
  • All Decimal value that should be invalid according to the Schema specification are now found by the parser (removing a 1.2.2 limitation).
  • Solved the problem of Xerces compilation under JDK 1.4.1.
  • XML Schema loading performance improved dramatically (virtually cut in half).

Changes in JAXP RI version 1.2.2

  • New properties were implemented for increased security, as described in the Security Issue section.
  • Parser implementation changed from Xerces 2.0.1_04 to Xerces 2.2.1 with controlled bug fixes.
  • XSLT processor imlpementation changed from Xalan 2.3.1_01 to Xalan 2.4.1 with controlled bug fixes..
  • XSLTC is included in this release.

Changes in JAXP Ri version 1.2.1

Performance of Xerces parser improved significantly.

XSLTC was not included as part of this release, which was destined solely for the J2EE platform.

Changes in JAXP RI version 1.2.0-FCS

The parser implementation changed from Xerces 2.0.0_01 to Xerces-J 2.0.1_01
(Xerces 2.0.1 final with controlled bug fixes). The Xalan XSLT processor
implementation was updated to xalan-j 2.3.1_01 (Xalan version 2.3.1 with
controlled bug fixes).

Finally, this release fully supports the proposed 1.2 JAXP specification,
which implements document validation using W3C XML Schema.

Changes In JAXP RI version 1.2.0-EA2

The parser implementation changed from Xerces 2.0.0 beta3 to Xerces-J 2.0.0_01 (Xerces 2.0.0 final with controlled bug fixes). The Xalan XSLT processor implementation was updated to xalan-j 2.3.0_01 (Xalan version 2.3.0 with controlled bug fixes).

The Xalan XSLTC processor was also added in this release. (It is used to compile a stylesheet into a transformation engine (translet) that is ready to run.)

This release fully supports the proposed 1.2 JAXP specification, which implements document validation using W3C XML Schema.

Changes in JAXP RI version 1.2.0-EA1

The parser implementation changed from Apache Crimson to Xerces 2 version 2.0.0 beta3. The XSLT processor implementation was updated to Xalan classic version 2.2.D14.

The parser supports W3C XML Schema but does not support all aspects of the proposed JAXP 1.2 specification. In particular, the ability to enforce that an instance document conforms to a particular schema has not been implemented. However, the validation portions of the specification can be used along with schema hints in the instance document.


JAXP 1.4 Release Notes

JavaTM API for XML Processing Release Notes

Specification Version: 1.4
Reference Implementation (RI) Version: 1.4.0

This document contains installation instructions and other notes that may help you use this software library more effectively. See also the JAXP FAQ for more information.

Note:
If you are reading this page online, this is the most current version of the release notes. If this page was downloaded as part of the release bundle, please see the JAXP Documentation page for the most current version of the release notes.

Contents

  • Feature Changes
  • gMonth
  • JAXP Specification Changes since 1.3

Feature Changes

An important technical change in JAXP 1.4 is the addition of the javax.xml.stream.* packages from StAX, the Streaming API for XML (JSR 173). With this addition, JAXP 1.4 now supports validation and transformation of documents with the streaming API. Since JAXP 1.4 is integrated in Java SE 6, the StAX support is transparent on any system running the latest Java.

gMonth

JAXP 1.4 changed its XML Schema validation logic for gMonth to reflect the changes made in the XML Schema 1.0 Specification Errata: E2-12 Error. Specifically, it will now reject gMonths with a lexical representation of "--MM--" as invalid.

JAXP Specification Changes since 1.3

Refer also to JAXP 1.4 Specification Chapter 9. Changes Since JAXP 1.3.

The following sections summarize the significant changes introduced in JAXP 1.4. For additional details, please see the appropriate JavaDoc.

1. Package javax.xml.datatype

1.1. Class DatatypeFactory

  • Changed DATATYPEFACTORY_IMPLEMENTATION_CLASS to com.sun.org.apache.xerces.internal.jaxp.datatype.DatatypeFactoryImpl.

  • Added newInstance(String, ClassLoader) method.

1.2. Class Duration

  • Return false if the argument to equals() is null instead of throwing NullPointerException.

1.3. Class XMLGregorianCalendar

  • Return false if the argument to equals() is null instead of throwing NullPointerException.

2. Package javax.xml.parsers

2.1. Class DocumentBuilderFactory

  • Added newInstance(String, ClassLoader) method.

2.2. Class SAXParserFactory

  • Added newInstance(String, ClassLoader) method.

3. Package javax.xml.stream

Added the javax.xml.stream package to support StAX. The package consists of the following interfaces:

  • EventFilter

  • Location

  • StreamFilter

  • XMLEventReader

  • XMLEventWriter

  • XMLReporter

  • XMLResolver

  • XMLStreamConstants

  • XMLStreamReader

  • XMLStreamWriter

Classes:

  • XMLEventFactory

  • XMLInputFactory

  • XMLOutputFactory

Exceptions:

  • XMLStreamException

And errors:

  • FactoryConfigurationError

4. Package javax.xml.stream.events

Added the javax.xml.stream.events package to support StAX. The package consists of the following interfaces:

  • Attribute

  • Characters

  • Comment

  • DTD

  • EndDocument

  • EndElement

  • EntityDeclaration

  • EntityReference

  • Namespace

  • NotationDeclaration

  • ProcessingInstruction

  • StartDocument

  • StartElement

  • XMLEvent

4.1. Package javax.xml.stream.util

Added the javax.xml.stream.util package to support StAX. The package consists of the following interfaces:

  • XMLEventAllocator

  • XMLEventConsumer

And classes:

  • EventReaderDelegate

  • StreamReaderDelegate

5. Package javax.xml.transform

5.1. Class ErrorListener

  • Clarified the semantics of fatalError().

5.2. Class Transformer

  • Clarified the semantics of getOutputProperty() with respect to properties that have not been set explicitly with either setOutputProperty() or xsl:output in the stylesheet.

5.3. Class TransformerFactory

  • Added newInstance(String, ClassLoader) method.

5.4. Package javax.xml.transform.stax

Added the javax.xml.transform.stax package to support StAX. The package consists of the following interfaces:

  • TemplatesHandler

  • TransformerHandler

And classes:

  • StAXResult

  • StAXSource

6. Package javax.xml.validation

6.1. Class Schema

  • Clarified that the features set on the SchemaFactory should be passed to the Validator created with newValidator().

  • Clarified that the features set on the SchemaFactory should be passed to the ValidatorHandler created with newValidatorHandler().

6.2. Class SchemaFactory

  • Added newInstance(String, ClassLoader) method.

  • Clarified that the features set on the SchemaFactory should be passed to the Schemas created with newSchema(). Included a note to implementors and developers about the subtleties associated with newSchema() in this context.

  • Clarified that the inputs to newSchema(Source[]) are expected to be XML documents or elements.

  • Updated documentation of setFeature() to clarify that the features set on the SchemaFactory should be passed to the Schemas created with this factory and by extension to the Validator and ValidatorHandlers created from that Schema.

6.3. Class SchemaFactoryLoader

The SchemaFactoryLoader class was created during the JAXP 1.3 development process. Shortly before JAXP 1.3 was finished, the factory mechanisms associated with validation were changed, and this class was removed. Unfortunately, the file was left in a repository and it slipped into the Java 2 Platform Standard Edition 5.0 API Specification.

Since the class can neither be added to JAXP 1.3 nor removed from the Java 5.0 API Specification due to backwards compatibility issues, it is being added to JAXP 1.4. The class is harmless and should not be used. It is being added simply to avoid the confusion that arises when developers notice that it's defined in the platform but not in JAXP.

Do not use this class.

6.4. Class TypeInfoProvider

  • Extended the semantics of getElementTypeInfo(), allowing it to be called from either the startElement event or the endElement event. This allows the API to support W3C XML Schema union types more usefully.

    When W3C XML Schema validation is being performed, in the case where an element has a union type, the TypeInfo returned by a call to getElementTypeInfo() from the startElement event will be the union type. The TypeInfo returned by a call from the endElement event will be the actual member type used to validate the element.

6.5. Class Validator

  • The Validator may now accept Sources other than DOMSource and SAXSource; for example, StAXSource.

  • Clarified that the inputs to validate() are expected to be XML documents or elements.

7. Package javax.xml.xpath

7.1. Class XPath

  • Clarified that it is the XPathVariableResolver in effect at compile time that is used to resolve any variables that appear in the expression.

7.2. Class XPathFactory

  • Added newInstance(String, ClassLoader) method.


JAXP Compatibility

JAXP Compatibility Guide
for the J2SE 6 Platform

Contents

  • What's New

  • DOM Level 3

    • Methods added to DOM interfaces

    • Preserving the XML format

  • SAX 2.0.2

  • Invoking XSLT

    • Programmatic Access to Xalan XPath

  • Package Name Changes

    • What Changed, and Why

    • Using System Properties and Implementation Classes

  • Security Issue Posed by Nested Entity Definitions

Introduction

The J2SE 1.4 platform included the Crimson reference implementation for JAXP 1.1. The J2SE 6 platform includes a reference implementation for JAXP 1.4 based on the Apache Xerces library.

Because these implementations come from entirely different codebases, and because the JAXP standard has evolved from 1.1 to 1.4, there are some subtle differences between the implementations, even they both conform to the JAXP standard. These two factors combine to create the compatibility issues described in this guide.

What's New

See Release Notes.

DOM Level 3

While the reference implementation in J2SE 1.4 supported the DOM Level 2 API, the implementation in J2SE 6 supports the DOM Level 3 family of APIs. This section covers the impact of those changes on programs that used the JAXP 1.1 reference implementation:

  • Methods added to DOM interfaces

  • Preserving the XML format

For more information, see the complete list of changes in the DOM Level 3 Changes appendix.

Methods added to DOM interfaces

In DOM level 3, additional methods were defined in the following interfaces:

  • Attr

  • Document

  • DOMImplementation

  • Element

  • Entity

  • Node

  • Text

The added methods only affect applications that implement the interfaces directly, and only when the application is recompiled. Applications that use the factory methods to obtain implementation classes for these interfaces will have no problems.

Preserving the XML format

These changes affect an application that reads in XML data into a DOM, makes modifications, and then writes it out in a way that preserves the original formatting.

In JAXP 1.1, extraneous whitespace was automatically removed on input, and a single property (ignoringLexicalInfo) was set to false to preserve entity nodes and CDATA nodes, for example. Including the additional nodes made the DOM somewhat more complex to process, but because they were there, adding whitespace output (indentation and newlines) produced highly readable, formatted version of the XML data which closely approximated the input.

In JAXP 1.4, there are four APIs that the application uses to determine how much lexical (formatting) information is available to process, using the following DocumentBuilderFactory methods:

  • setCoalescing()
    To convert CDATA nodes to Text node and append
    to an adjacent Text node (if any).

  • setExpandEntityReferences()
    To expand entity reference nodes.

  • setIgnoringComments()
    To ignore comments.

  • setIgnoringElementContentWhitespace()
    To ignore whitespace that is not a significant part
    of element content.

The default values for all of these properties is false, which preserves all the lexical information necessary to reconstruct the incoming document in its original form. Setting them all to true lets you construct the simplest possible DOM, so the application can focus on the data's semantic content, without having to worry about lexical syntax details.

Note:
When adding new nodes, the application must add any indentation and newline formatting that is needed for readability, since it is not provided automatically.

SAX 2.0.2

Following are the changes made between SAX 2.0.0 and SAX 2.0.2 that might affect compatibility.

  • DeclHandler.externalEntityDecl now requires the parser to return the absolute system identifier for consistency with DTDHandler.unparsedEntityDecl. This may cause some incompatibilities.

  • In SAX 2.0.1, an application can set ErrorHandler, EntityResolver, ContentHandler, or DTDHandler to null. This is a relaxation of the previous restriction in SAX 2.0, which generated a NullPointerException (NPE) in such circumstances.

    So the following code is legal in JAXP 1.3:

    SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
XMLReader reader = sp.getXMLReader();
reader.setErrorHandler(null);
reader.setContentHandler(null);
reader.setEntityResolver(null);
reader.setDTDHandler(null);

  • The resolveEntity() method in the EntityResolver API now throws IOException, as well as SAXException. (Before, it only threw SAXException.)

    The vast majority of applications are unaffected by this change, because the DefaultHandler implementation class has been modified to declare the additional exception, and very few applications use the DefaultHandler in such a way that they will run into a problem.

    The only way an application can be affected is if it overrides the resolveEntity() method and also invokes super.resolveEntity(). In that case, the application won't compile in J2SE 5 until the method is modified to handle the IOExceptions that super.resolveEntity() could throw.

  • The following new features are recognized :

    • http://xml.org/sax/features/external-general-entities
      To include external general entities.

    • http://xml.org/sax/features/external-parameter-entities
      To include external parameter entities and the external DTD subset.

    and the following new property:

    • http://xml.org/sax/properties/xml-string
      To get the string of characters associated with the current event.

    For a complete list of Xerces features and properties, see http://xml.apache.org/xerces2-j/features.html and http://xml.apache.org/xerces2-j/properties.html.

Note:
One point of compatibility is also worth mentioning. Namespace recognition was turned off by default in J2SE 1.4 (JAXP 1.1). For backward compatibility, that policy is continued in J2SE 6 (JAXP 1.4). However, namespace recognition is turned on by default in the official SAX implementation at www.saxproject.org. While not strictly a compatibility issue from the standpoint of JAXP, it is an issue that sometimes comes as a surprise.

Using XSLT

Code that uses the standard JAXP APIs to create and access an XSL transformer does not need to be changed. The output will be the same, but will in general be produced much faster, since the XSLTC compiling transformer will be used by default, instead of the interpreting Xalan transformer.

Note:
There may be no significant difference between Xalan and XSLTC performance for a single run on a small data set, as when you are developing and testing an XSL stylesheet. But there is a major performance benefit when using XSLTC on anything larger.

Programmatic Access to Xalan XPath

JAXP 1.4 provides the standard XPath API for evaluating XPath expressions. We encourage users to use this API. Xalan-interpretive is not included in the reference implementation. If an application explicitly uses the Xalan XPath API to evaluate a standalone XPath expression (one that is not part of an XSLT stylesheet), you'll need to download and install the Apache libraries for Xalan.

Package Name Changes

This change does not affect applications that confine themselves to using the standard JAXP APIs. But applications that access implementation-specific features of the XML processors defined in JAXP versions prior to 1.3 will have to be modified.

The change has several effects on previous applications:

  1. The property-values that were used to access the internal implementations must be changed.

  2. Applications that used internal APIs that from the Xalan implementation classes must change the import statements that gave them access to those APIs.

  3. Applications that used internal APIs from the Crimson implementation must be re-coded -- ideally, by using newer JAXP APIs or, if necessary, by using Xerces APIs.

What Changed, and Why

In J2SE 1.4, the fact that JAXP was built into the Java platform was a mixed blessing. On the one hand, an application could rely on that fact that it was there. On the other, most applications needed features and bug fixes that were available in later versions.

But adding new libraries had no effect, because internal classes always take precedence over the classpath. The solution for that problem in 1.4 was to use the endorsed standards mechanism. However, that was a new mechanism, and one which frequently placed an additional burden on the end user, as well as the application developer.

The solution since JAXP 1.3 is to change the package names of the Apache libraries used in the implementation. That change lets a user reference newer Apache libraries in the classpath, so application developers can use them in the same way that would use any other additions to the Java platform.

The new names given to the Apache packages in the JAXP 1.3 reference implementation are shown below:

JAXP 1.1

Since JAXP 1.3

JAXP

org.apache.crimson

-/-
com.sun.org.apache.xerces.internal

org.apache.xml

com.sun.org.apache.xml.internal

XSLT

org.apache.xalan
org.apache.xpath
org.apache.xalan.xsltc

com.sun.org.apache.xalan.internal
com.sun.org.apache.xpath.internal
com.sun.org.apache.xalan.internal.xsltc

Security Issue Posed by Nested Entity Definitions

While XML does not allow recursive entity definitions, it does permit nested entity definitions, which produces the potential for Denial of Service attacks on a server which accepts XML data from external sources. For example, a SOAP document like the following that has very deeply nested entity definitions can consume 100% of CPU time and large amounts of memory in entity expansions:

<?xml version="1.0" encoding ="UTF-8"?>
 <!DOCTYPE foobar[
 <!ENTITY x100 "foobar">
 <!ENTITY  x99 "&x100;&x100;">
 <!ENTITY  x98 "&x99;&x99;">
 ...
 <!ENTITY   x2 "&x3;&x3;">
 <!ENTITY   x1 "&x2;&x2;">
 ]>
<SOAP-ENV:Envelope xmlns:SOAP-ENV=...>
<SOAP-ENV:Body>
<ns1:aaa xmlns:ns1="urn:aaa" SOAP-ENV:encodingStyle="...">
<foobar xsi:type="xsd:string">&x1;</foobar>
</ns1:aaa>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

A system that doesn't take in external XML data need not be concerned with the issue, but one that does can utilize one of the following safeguards to prevent the problem:

New system property to limit entity expansion
The entityExpansionLimit system property lets existing applications constrain the total number of entity expansions without recompiling the code. The parser throws a fatal error once it has reached the entity expansion limit. (By default, the limit is set to 64000.)

To set the entity expansion limit using the system property, use an option like the following on the java command line: -DentityExpansionLimit=100000

New parser property to disallow DTDs
The application can also set the http://apache.org/xml/features/disallow-doctype-decl parser property to true. A fatal error is then thrown if the incoming XML document contains a DOCTYPE declaration. (The default value for this property is false.) This property is typically useful for SOAP based applications where a SOAP message must not contain a Document Type Declaration.
New feature for Secure Processing
JAXP 1.3 includes a new secure processing feature in which an application can configure the SAXParserFactory or DocumentBuilderFactory to get an XML processor that behaves in a secured fashion. Setting this feature to true sets the entity expansion limit to 64000. Note that the default limit can be increased using the entityExpansionLimit system property.


JAXP Compatibility

JAXP Compatibility Guide
for the J2SE 5 Platform

Contents

  • What's New
  • DOM Level 3
    • Methods added to DOM interfaces
    • Preserving the XML format
  • SAX 2.0.2
  • Invoking XSLT
    • Programmatic Access to Xalan XPath
  • Package Name Changes
    • What Changed, and Why
    • Using System Properties and Implementation Classes
  • Security Issue Posed by Nested Entity Definitions

Introduction

The J2SE 1.4 platform included the "Crimson" reference implementation for JAXP 1.1. The J2SE 5 platform includes a reference implementation for JAXP 1.3 based on the Apache "Xerces" library.

Because these implementations come from entirely different codebases, and because the JAXP standard has evolved from 1.1 to 1.3, there are some subtle differences between the impementations, even they both conform to the JAXP standard. These two factors combine to create the compatibility issues described in this guide.

What's New

However, while XML applications written for 1.4 do suffer some incompatibilities, JAXP 1.3 in the
J2SE 5 platform provides some compelling advantages:

  • A built-in validation processor for XML Schema.
  • The ability to use other schema validators, as well, with the javax.xml.validation package.
  • A thorough implementation of XML Schema data types in javax.xml.datatype, including Gregorian Calendar dates and times that previously had no natural analogues in the Java platform.
  • XSLTC, the fast, compiling transformer, which is now the default engine for XSLT processing.
  • DOM Level 3 core, which provides:
    • XML 1.1 and Namespaces 1.1 (javax.xml.namespace) which provide better support for unicode characters in tag names and namespaces.
    • Support for normalization of documents
      Support for schema datatypes (TypeInfo)
    • Better ErrorHandling and identification of an error's location
    • Bootstrapping. DOMLevel 3 supports implementation independent way to obtain DOMImplementation.
    • DOMLevel 3 allows setting of application data in a node, also allows setting of UserDataHandler which gets called whenever a node is cloned, removed, renamed.
  • Java-Centric XPath APIs in javax.xml.xpath, which provide a more java-friendly way to use an XPath expression. It was designed to be applicable to any data model that implements the interface. You can use it now to process the reference implementation DOM. In the future, it is likely to be available when processing a JDom, or STAX data model, as well.
  • An implementation of XInclude, which makes it possible to build a document using text or XML stored in reusable segments elsewhere.
  • Grammar pre-parsing and caching, which has a major impact on performance for high-volume XML processing.
  • APIs that tell you implementation and version of the parser, so that when you install new libraries you can make sure the application is using them.

    That's the good news. The bad news is that some compatibility issues have survived all attempts at eradication. The remainder of this document discusses those issues.

    DOM Level 3

    While the reference implementation in J2SE 1.4 supported the DOM Level 2 API, the implementation in J2SE 5 supports the DOM Level 3 family of APIs. This section covers the impact of those changes on programs that used the JAXP 1.1 reference implementation:

    • Methods added to DOM interfaces
    • Preserving the XML format

    For more information, see the complete list of changes in the DOM Level 3 Changes appendix.

    Methods added to DOM interfaces

    In DOM level 3, additional methods were defined in the following interfaces:

    • Attr
    • Document
    • DOMImplementation
    • Element
    • Entity
    • Node
    • Text

    The added methods only affect applications that implement the interfaces directly, and only then when the application is recompiled. Applications that use the factory methods to obtain implementation classes for these interfaces will have no problems.

    Preserving the XML format

    These changes affect an application that reads in XML data into a DOM, makes modifications, and then writes it out in a way that preserves the original formatting.

    In JAXP 1.1, extraneous whitespace was automatically removed on input, and a single property (ignoringLexicalInfo) was set to false to preserve entity nodes and CDATA nodes, for example. Including the additional nodes made the DOM somewhat more complex to process, but because they were there, adding whitespace output (indentation and newlines) produced highly readable, formatted version of the XML data which closely approximated the input.

    In JAXP 1.3, there are four APIs that the application uses to determine how much lexical (formatting) information is available to process, using the following DocumentBuilderFactory methods:

    • setCoalescing()
      To convert CDATA nodes to Text node and append
      to an adjacent Text node (if any).
    • setExpandEntityReferences()
      To expand entity reference nodes.
    • setIgnoringComments()
      To ignore comments.
    • setIgnoringElementContentWhitespace()
      To ignore whitespace that is not a significant part
      of element content.

    The default values for all of these properties is false, which preserves all the lexical information necessary to reconstruct the incoming document in its original form. Setting them all to true lets you construct the simplest possible DOM, so the application can focus on the data's semantic content, without having to worry about lexical syntax details.

    Note:
    When adding new nodes, the application must add any indentation and newline formatting that is needed for readability, since it is not provided automatically.

    SAX 2.0.2

    Following are the changes made between SAX 2.0.0 and SAX 2.0.2 that might affect compatibility.

    • DeclHandler.externalEntityDecl now requires the parser to return the absolute system identifier for consistency with DTDHandler.unparsedEntityDecl. This may cause some incompatibilities.

    • In SAX 2.0.1, an application can set ErrorHandler, EntityResolver, ContentHandler, or DTDHandler to null. This is a relaxation of the previous restriction in SAX 2.0, which generated a NullPointerException (NPE) in such circumstances.

      So the following code is legal in JAXP 1.3:

      SAXParserFactory spf = SAXParserFactory.newInstance();
      SAXParser sp = spf.newSAXParser();
      XMLReader reader = sp.getXMLReader();

      reader.setErrorHandler(null);
      reader.setContentHandler(null);
      reader.setEntityResolver(null);
      reader.setDTDHandler(null);
    • The resolveEntity() method in the EntityResolver API now throws IOException, as well as SAXException. (Before, it only threw SAXException.)

      The vast majority of applications are unaffected by this change, because the DefaultHandler implementation class has been modified to declare the additional exception, and very few applications use the DefaultHandler in such a way that they will run into a problem.

      The only way an application can be affected is if it overrides the resolveEntity() method and also invokes super.resolveEntity(). In that case, the application won't compile in J2SE 5 until the method is modified to handle the IOExceptions that super.resolveEntity() could throw.

    • The following new features are recognized :
      • http://xml.org/sax/features/external-general-entities
        To include external general entities.
      • http://xml.org/sax/features/external-parameter-entities
        To include external parameter entities and the external DTD subset.

      and the following new property:

      • http://xml.org/sax/properties/xml-string
        To get the string of characters associated with the current event.

      For a complete list of Xerces features and properties, see http://xml.apache.org/xerces2-j/features.html and http://xml.apache.org/xerces2-j/properties.html.

    Note:
    One point of compatibility is also worth mentioning. Namespace recognition was turned off by default in J2SE 1.4 (JAXP 1.1). For backward compatibility, that policy is continued in J2SE 5 (JAXP 1.3). However, namespace recognition is turned on by default in the official SAX implementation at www.saxproject.org. While not strictly a compatibility issue from the standpoint of JAXP, it is an issue that sometimes comes as a surprise.

    Using XSLT

    Code that uses the standard JAXP APIs to create and access an XSL transformer does not need to be changed. The output will be the same, but will in general be produced much faster, since the XSLTC compiling transformer will be used by default, instead of the interpreting Xalan transformer.

    Note:
    There is no significant difference between Xalan and XSLTC performance for a single run on a small data set, as when you are developing and testing an XSL stylesheet. But there is a major performance benefit when using XSLTC on anything larger.

    Using XSLT

    Code that uses the standard JAXP APIs to create and access an XSL transformer does not need to be changed. The output will be the same, but will in general be produced much faster, since the XSLTC compiling transformer will be used by default, instead of the interpreting Xalan transformer.

    Note:
    There is no significant difference between Xalan and XSLTC performance for a single run on a small data set, as when you are developing and testing an XSL stylesheet. But there is a major performance benefit when using XSLTC on anything larger.

    Programmatic Access to Xalan XPath

    JAXP 1.3 provides the standard XPath API for evaluating XPath expressions. We encourage users to use this API. Xalan-interpretive is not included in the reference implementation. If an application explicitly uses the Xalan XPath API to evaluate a standalone XPath expression (one that is not part of an XSLT stylesheet), you'll need to download and install the Apache libraries for Xalan, put them on the classpath.

    Package Name Changes

    This change does not affect applications that confine themselves to using the standard JAXP APIs. But applications that access implementation-specific features of the XML processors defined in previous JAXP versions will have to be modified to take into account package names that changed in JAXP 1.3.

    The change has several effects on previous applications:

    1. The property-values that were used to access the internal implementations must be changed.
    2. Applications that used internal APIs that from the Xalan implementation classes must change the import statements that gave them access to those APIs.
    3. Applications that used internal APIs from the Crimson implementation must be recoded -- ideally, by using newer JAXP APIs or, if necessary, by using Xerces APIs.

    What Changed, and Why

    In J2SE 1.4, the fact that JAXP was built into the Java platform was a mixed blessing. On the one hand, an application could rely on that fact that it was there. On the other, most applications needed features and bug fixes that were available in later versions.

    But adding new libarires had no effect, because internal classes always take precedence over the classpath. The solution for that problem in 1.4 was to use the endorsed standards mechanism. However, that was a new mechanism, and one which frequently placed an additional burden on the end user, as well as the application developer.

    The solution in the JAXP 1.3 reference name is to change the package names of the Apache libraries used in the implementation. That change lets you reference newer Apache libraries in the classpath, so application developers can use them in the same way that would use any other additions to the Java platform.

    The new names given to the Apache packages in the JAXP 1.3 reference implementation are shown below:

    JAXP 1.1
            JAXP 1.3
    JAXP org.apache.crimson

             -/-
    com.sun.org.apache.xerces.internal
    org.apache.xml com.sun.org.apache.xml.internal
    XSLT org.apache.xalan
    org.apache.xpath
    org.apache.xalan.xsltc
             com.sun.org.apache.xalan.internal
    com.sun.org.apache.xpath.internal
    com.sun.org.apache.xalan.internal.xsltc

    Using System Properties and Implementation Classes

    Applications that specifying system properties on the command line with -D, in the JRE's lib/jaxp.properties file, or by hard-coding them into the application, generally do so in order to access functionality that is not present in the standard APIs.

    JAXP 1.3 contains many new additions. When upgrading such applications, it is advisable to look for standard APIs in the javax.xml.* packages that will do the same job, because that's the best way to keep from having to change the application in the future. If absolutely necessary (either because of functionality restrictions or lack of time to investigate the new APIs), the property values can be changed by converting old-format package names into the format:

    org.apache.somePackage --> com.sun.org.apache.SomePackage.internal

    Similarly, internal implementation classes all use the new package names. If your application is using implementaton classes (it shouldn't!) those package names will have to change, as well.

    Security Issue Posed by Nested Entity Definitions

    While XML does not allow recursive entity definitions, it does permit nested entity definitions, which produces the potential for Denial of Service attacks on a server which accepts XML data from external sources. For example, a SOAP document like the following that has very deeply nested entity definitions can consume 100% of CPU time and large amounts of memory in entity expansions:

    <?xml version="1.0" encoding ="UTF-8"?>
     <!DOCTYPE foobar[
     <!ENTITY x100 "foobar">
     <!ENTITY  x99 "&x100;&x100;">
     <!ENTITY  x98 "&x99;&x99;">
     ...
     <!ENTITY   x2 "&x3;&x3;">
     <!ENTITY   x1 "&x2;&x2;">
     ]>
    <SOAP-ENV:Envelope xmlns:SOAP-ENV=...>
    <SOAP-ENV:Body>
    <ns1:aaa xmlns:ns1="urn:aaa" SOAP-ENV:encodingStyle="...">
    <foobar xsi:type="xsd:string">&x1;</foobar>
    </ns1:aaa>
    </SOAP-ENV:Body>
    </SOAP-ENV:Envelope>

    A system that doesn't take in external XML data need not be concerned with the issue, but one that does can utilize one of the following safeguards to prevent the problem:

    New system property to limit entity expansion
    The entityExpansionLimit system property lets existing applications constrain the total number of entity expansions without recompiling the code. The parser throws a fatal error once it has reached the entity expansion limit. (By default, the limit is set to 64000.)

    To set the entity expansion limit using the system property, use an option like the following on the java command line: -DentityExpansionLimit=100000

    New parser property to disallow DTDs
    The application can also set the http://apache.org/xml/features/disallow-doctype-decl parser property to true. A fatal error is then thrown if the incoming XML document contains a DOCTYPE declaration. (The default value for this property is false.) This property is typically useful for SOAP based applications where a SOAP message must not contain a Document Type Declaration.

    New feature for Secure Processing
    JAXP 1.3 includes a new secure processing feature in which an application can configure the SAXParserFactory or DocumentBuilderFactory to get an XML processor that behaves in a secured fashion. Setting this feature to true sets the entity expansion limit to 64000. Note that the default limit can be increased using the entityExpansionLimit system property.


JDK Demos

Java

Demonstration
Applets and Applications

 Documentation Contents

    Applets

    Demonstration applets and source code are available at:

    • Demo applets and source code on java.sun.com website

    • Demo applets and source code in the JDK installation demo/applets directory

    To run the applets, use your browser to go to the HTML page and click on the applet link, or use AppletViewer to open the HTML page.

    Running an applet in a browser requires the JavaTM Plug-in, which is installed by default with the JDK and JRE. The AppletViewer is provided with the JDK, at bin\appletviewer. For information about how to use the AppletViewer and other JDK tools, see JDK Tools and Utilities.

    Applications

    Applications and sample code are also available in the JDK installation. These demonstrate various features of the Java 2 platform. The available demos are described in the following sections.

    JFC Applications and Applets

    These applications and applets, located in the JDK demo/jfc directory, demonstrate Swing and Java 2DTM technology.

    Java Platform Debugger Architecture

    The demo/jpda/examples.jar file in the JDK contains JPDA examples, including source code for the jdb Java Debugger and the prototype javadt GUI debugger.

    The Poller Demo (SolarisTM Operating System only)

    This demo, located in the JDK demo/jni/Poller directory, demonstrates access to the input/output multiplexing functionality from the Java programming language. See the Solaris poll man page.

    Additional Applications and Applets

    Additional applets and applications may be found at:
    • Guide to Features - Examples are included in the documentation for particular features.
    • Applets Page - Located on Sun Java Software web site
    • The Java Tutorial - Located on Sun Java Software web site
      • First Cup of Java
      • "Hello World" Applet and Application
      • BINGO! Client/Server Application

Copyright © 2004 Sun Microsystems, Inc. All Rights Reserved.

Sun

Java Software


JDK Samples

Java

Java Web Start Samples

 Documentation Contents

The JDK contains a sample/jnlp directory that includes five samples:

  • CORBA
  • JRE auto-download installer
  • Random-access file
  • servlet
  • WebPad Application

Each is briefly described below. For more information, see the README files for each in the samples/jnlp directory in the SDK.

CORBA

This sample demonstrates how to use CORBA within Java Web Start. It shows how a simple Java program using CORBA can be packaged, downloaded, and executed as a JNLP application by Java Web Start. RMI-IIOP utilizes the Java CORBA Object Request Broker (ORB) and IIOP. This lets you can write all your code in Java and use the rmic compiler to generate the code necessary for connecting your applications via the Internet InterORB Protocol (IIOP) to other applications written in any CORBA-compliant language. Please note that this sample doesn't use any of the JNLP APIs.

JRE auto-download installer

This example shows how to build a Java Web Start JRE auto-download installer.

Random-access file

This sample demonstrates features of the JNLPRandomAccessFile API. The file, which the user picks, is opened as a random file for both writing and reading. The application first writes some hard-coded strings to the file selected by the user. It then reads whatever was written to the file and displays it on to the screen using the awt Container and TextArea components.

servlet

Java Web Start includes a servlet in the sample/jnlp/servlet directory that can be used to package a JNLP file and its associated resources in a Web Archive (.war) file. The purpose of the servlet is to provide a simple and convenient packaging format for JNLP applications, so they can be easily deployed in a Web Container, such as Tomcat or a J2EE-compliant Application Server.

WebPad Application

This simple word-processing application allows users to Create, Open, Modify, Save, and Print files. Webpad application extensively uses the following JNLP APIs to access local resources even when running in the untrusted execution environment: FileOpenService, FileContent, FileSaveService, ClipboardService, PrintService, DownloadService, BasicService, and PersistenceService.

Copyright © 2004 Sun Microsystems, Inc. All Rights Reserved.

Please submit comments at our feedback form. 		Sun

Java Software


AppletViewer Tags

Documentation Contents

The applet viewer makes it possible to run a Java applet without using a browser. AppletViewer ignores any HTML that is not immediately relevant to launching an applet. However, it recognizes a wide variety of applet-launching syntax. The HTML code that AppletViewer recognizes is shown below. All other HTML code is ignored.

object

The object tag is the HTML 4.0 tag for embedding applets and mult-media objects into an HTML page. It is also an Internet Explorer 4.x extension to HTML 3.2 which allows IE to run a Java applet using the latest Java plugin from Sun.

<object
  width="pixelWidth"
  height="pixelHeight"
>
  <param name="code" value="yourClass.class">
  <param name="object" value="serializedObjectOrJavaBean">
  <param name="codebase" value="classFileDirectory">
   ...
  alternate-text
</object>

Notes:

  • AppletViewer ignores the "classID" attribute, on the assumption that it is pointing to the Java plugin, with the value:

    classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"

  • AppletViewer also ignores the "codebase" attribute that is usually included as part of the object tag, assuming that it points to a Java plugin in a network cab file with a value like:

    codebase="http://java.sun.com/products/plugin/1.1/jinstall-11-win32.cab#Version=1,1,0,0"

  • The optional codebase param tag supplies a relative URL that specifies the location of the applet class.

  • Either code or object is specified, not both.

  • The type param tag is not used by AppletViewer, but should be present so that browsers load the plugin properly.

    For an applet, the value should be something like:

    <param name="type" value="application/x-java-applet;version=1.1">

    or

    <param name="type" value="application/x-java-applet">

    For a serialized object or JavaBean, the type param value should be something like:

       <param name="type" value="application/x-java-bean;version=1.1">

    or

      <param name="type" value="application/x-java-bean">

  • Other param tags are argument values supplied to the applet.

  • The object tag recognized by IE4.x and the embed tag recognized by Netscape 4.x can be combined so that an applet can use the latest Java plugin from Sun, regardless of the browser that downloads the applet.

    For more information, see Java PlugIn HTML Specification

  • AppletViewer does not recognize the java_code, java_codebase, java_object, or java_type param tags. These tags are only needed when the applet defines parameters with the names code, codebase, object, or type, respectively. (In that situation, the plugin recognizes and uses the java_ version in preference to the version that will be used by the applet.) If the applet requires a parameter with one of these 4 names, it may not run in AppletViewer.

embed

The embed tag is the Netscape extension to HTML 3.2 that allows embedding an applet or a multimedia object in an HTML page. It allows a Netscape 4.x browser (which supports HTML 3.2) to run a Java applet using the latest Java plugin from Sun.

<embed
  code="yourClass.class"
  object="serializedObjectOrJavaBean"
  codebase="classFileDirectory"
  width="pixelWidth"
  height="pixelHeight"
>
   ...
</embed>

Notes:

  • The object and embed tags can be combined so that an applet can use the latest Java plugin from Sun, regardless of the browser that downloads the applet.

    For more information, see the Java PlugIn HTML Specification

  • Unlike the object tag, all values specified in an embed tag are attributes (part of the tag) rather than parameters (between the start tag and end tag, specified with a param tag.

  • To supply argument values for applet parameters, you add additional attributes to the <embed> tag.

  • AppletViewer ignores the "src" attribute that is usually part of an <embed> tag.

  • Either code or object is specified, not both.

  • The optional codebase attribute supplies a relative URL that specifies the location of the applet class.

  • The type attribute is not used by AppletViewer, but should be present so that browsers load the plugin properly.

    For an applet, the value should be something like:

    <type="application/x-java-applet;version=1.1">...

    or

    <type="application/x-java-applet">...

    For a serialized object or JavaBean, the type param value should be something like:

    <type="application/x-java-bean;version=1.1">...

    or

    <type="application/x-java-bean">...

  • The "pluginspage" attribute is not used by AppletViewer, but should be present so that browsers load the plugin properly. It should point to a Java plugin in a network cab file with a value like:

    pluginspage="http://java.sun.com/products/plugin/1.1/jinstall-11-win32.cab#Version=1,1,0,0"

applet

The applet tag is the original HTML 3.2 tag for embedding an applet in an HTML page. Applets loaded using the applet tag are run by the browser, which may not be using the latest version of the Java platform. To ensure that the applet runs with the latest version, use the object tag to load the Java plugin into the browser. The plugin will then run the applet.

<applet
  code="yourClass.class"
  object="serializedObjectOrJavaBean"
  codebase="classFileDirectory"
  width="pixelWidth"
  height="pixelHeight"
>
  <param name="..." value="...">
   ...
  alternate-text
</applet>

Notes:

  • Either code or object is specified, not both.

  • The optional codebase attribute supplies a relative URL that specifies the location of the applet class.

  • Param tags supply argument values for applet parameters.

app

The app tag was a short-lived abbreviation for applet that is no longer supported. AppletViewer translates the tag and prints out an equivalent tag that is supported.

<app
  class="classFileName" (without a .class suffix)
  src="classFileDirectory"
  width="pixelWidth"
  height="pixelHeight"
>
<param name="..." value="...">
 ...
</app>

For more information on the tags that AppletViewer supports and how to combine them, see the Java PlugIn HTML Specification.

Copyright © 2001 Sun Microsystems, Inc. All Rights Reserved.

Java Software


How Classes are Found

 SDK Tools
  • How the Java Launcher Finds Classes
    • How the Java Launcher Finds Bootstrap Classes
    • How the Java Launcher Finds Extension Classes
    • How the Java Launcher Finds User Classes
    • How the Java Launcher Finds JAR-class-path Classes
  • How Javac and Javadoc Find Classes
  • Class Loading and Security Policies

How the Java Launcher Finds Classes

The Java launcher, java, initiates the Java virtual machine. The virtual machine searches for and loads classes in this order:

  • Bootstrap classes - Classes that comprise the Java platform, including the classes in rt.jar and several other important jar files.
  • Extension classes - Classes that use the Java Extension mechanism. These are bundled as .jar files located in the extensions directory.
  • User classes - Classes defined by developers and third parties that do not take advantage of the extension mechanism. You identify the location of these classes using the -classpath option on the command line (the preferred method) or by using the CLASSPATH environment variable. (See Setting the Classpath for Windows or Solaris.)

In effect, these three search paths are joined to form a simple class path. This is similar to the "flat" class path previously used, but the current model has some important differences:

  • It is relatively difficult to accidentally "hide" or omit the bootstrap classes.
  • In general, you only have to specify the location of user classes. Bootstrap classes and extension classes are found "automatically".
  • The tools classes are now in a separate archive (tools.jar) and can only be used if included in the user class path (to be explained shortly).

How the Java Launcher Finds Bootstrap Classes

Bootstrap classes are the classes that implement the Java 2 Platform. Bootstrap classes are in the rt.jar and several other jar files in the jre/lib directory. These archives are specified by the value of the bootstrap class path which is stored in the sun.boot.class.path system property. This system property is for reference only, and should not be directly modified.

It is very unlikely that you will need to redefine the bootstrap class path. The nonstandard option, -Xbootclasspath, allows you to do so in those rare cicrcumstances in which it is necessary to use a different set of core classes.

Note that the classes which implement the Java 2 SDK tools are in a separate archive from the bootstrap classes. The tools archive is the SDK's/lib/tools.jar file. The development tools add this archive to the user class path when invoking the launcher. However, this augmented user class path is only used to execute the tool. The tools that process source code, javac and javadoc, use the original class path, not the augmented version. (For more information, see How Javac and Javadoc Find Classes, below.)

How the Java Launcher Finds Extension Classes

Extension classes are classes which extend the Java platform. Every .jar file in the extension directory, jre/lib/ext, is assumed to be an extension and is loaded using the Java Extension Framework. Loose class files in the extension directory will not be found. They must be contained in a .jar file (or .zip file). There is no option provided for changing the location of the extension directory.

If the jre/lib/ext directory contains multiple .jar files, and those files contain classes with the same name, such as:

smart-extension1_0.jar contains class smart.extension.Smart
smart-extension1_1.jar contains class smart.extension.Smart

the class that actually gets loaded is undefined.

How the Java Launcher Finds User Classes

User classes are classes which build on the Java platform. To find user classes, the launcher refers to the user class path -- a list of directories, JAR archives, and ZIP archives which contain class files.

A class file has a subpath name that reflects the class's fully-qualified name. For example, if the class com.mypackage.MyClass is stored under /myclasses, then /myclasses must be in the user class path and the full path to the class file must be /myclasses/com/mypackage/MyClass.class. If the class is stored in an archive named myclasses.jar, then myclasses.jar must be in the user class path, and the class file must be stored in the archive as com/mypackage/MyClass.class.

The user class path is specified as a string, with a colon (:) separating the class path entries on Solaris, and a semi-colon (;) separating entries on Microsoft Windows systems. The java launcher puts the user class path string in the java.class.path system property. The possible sources of this value are:

  • The default value, ".", meaning that user class files are all the class files in the current directory (or under it, if in a package).
  • The value of the CLASSPATH environment variable, which overrides the default value.
  • The value of the -cp or -classpath command line option, which overrides both the default value and the CLASSPATH value.
  • The JAR archive specified by the -jar option, which overrides all other values. If this option is used, all user classes must come from the specified archive.

How the Java Launcher Finds JAR-class-path Classes

A JAR file usually contains a "manifest" -- a file which lists the contents of the JAR. The manifest can define a JAR-class-path, which further extends the class path (but only while loading classes from that JAR). Classes accessed by a JAR-class-path are found in the following order:

  • In general, classes referenced by a JAR-class-path entry are found as though they were part of the JAR file. The JAR files that appear in the JAR-class-path are searched after any earlier class path entries, and before any entries that appear later in the class path.
  • However, if the JAR-class-path points to a JAR file that was already searched (for example, an extension, or a JAR file that was listed earlier in the class path) then that JAR file will not be searched again. (This optimization improves efficiency and prevents circular searches.) Such a JAR file is searched at the point that it appears, earlier in the class path.
  • If a JAR file is installed as an extension, then any JAR-class-path it defines is ignored. All the classes required by an extension are presumed to be part of the SDK or to have themselves been installed as extensions.

How Javac and JavaDoc Find Classes

The javac and javadoc tools use class files in two distinct ways:

  • Like any Java application, javac and javadoc must load various class files in order to run.
  • To process the source code they operate on, javac and javadoc must obtain information on object types used in the source code.

The class files used to resolve source code references are mostly the same class files used to run javac and javadoc. But there are some important exceptions:

  • Both javac and javadoc often resolve references to classes and interfaces that having nothing to do with the implementation of javac or javadoc. Information on referenced user classes and interfaces may be present in the form of class files, source code files, or both.
  • The tools classes in tools.jar are only used to run javac and javadoc. The tools classes are not used to resolve source code references unless tools.jar is in the user class path.
  • A programmer may want to resolve boot class or extension class references using an alternative Java platform implementation. Both javac and javadoc support this with their -bootclasspath and -extdirs options. Use of these options does not modify the set of class files used to run the javac or javadoc tools themselves.

If a referenced class is defined in both a class file and source file, javadoc always uses the source file (javadoc never compiles source files). In the same situation javac uses class files, but automatically recompiles any class files it determines to be out of date. The rules for automatic recompilation are documented in the javac document for Windows or Solaris.

By default, javac and javadoc search the user class path for both class files and source code files. If the -sourcepath option is specified, javac and javadoc search for source files only on the specified source file path, while still searching the user class path for class files.

Class Loading and Security Policies

To be used, a class or interface must be loaded by a class loader. Use of a particular class loader determines a security policy associated with the class loader.

A program can load a class or interface by calling the loadClass method of a class loader object. But usually a program loads a class or interface simply by referring to it. This invokes an internal class loader, which can apply a security policy to extension and user classes. If the security policy has not been enabled, all classes are "trusted". Even if the security policy is enabled, it does not apply to bootstrap classes, which are always "trusted."

When enabled, security policy is configured by system and user policy files. The Java 2 SDK includes a system policy file that grants "trusted" status to extension classes and places basic restrictions on user classes.

To enable or configure the security policy, refer to Security Features.

Note: Some security programming techniques that worked with the Java 1.1 platform are incompatible with the class loading model of the Java 2 Platform.

Copyright © 2001 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


JDK Development Tools

Java

JDK Tools and Utilities

 Documentation Contents

General

  • General Information (file structure, classpath, how classes are found, changes)

Standard JDK Tools and Utilities

  • Basic Tools (javac, java, javadoc, apt, appletviewer, jar, jdb, javah, javap, extcheck)
  • Security Tools (keytool, jarsigner, policytool, kinit, klist, ktab)
  • Internationalization Tools (native2ascii)
  • Remote Method Invocation (RMI) Tools (rmic, rmiregistry, rmid, serialver)
  • Java IDL and RMI-IIOP Tools (tnameserv, idlj, orbd, servertool)
  • Java Deployment Tools (pack200, unpack200)
  • Java Plug-in Tools (htmlconverter)
  • Java Web Start Tools (javaws)
  • Java Monitoring and Management Console (jconsole)
  • Java Web Services Tools

Experimental JDK Tools and Utilities

NOTE - The tools described in this section are unsupported and experimental in nature and should be used with that in mind. They might not be available in future JDK versions.

  • Monitoring Tools (jps, jstat, jstatd)
  • Troubleshooting Tools (jinfo, jhat, jmap, jsadebugd, jstack)
  • Scripting Tools (jrunscript)

Troubleshooting Documentation

  • J2SE 5.0 Trouble-Shooting and Diagnostic Guide (tools, options, and other items for use in analyzing problems)

NOTE - Some tools have separate reference pages for Windows, Linux and Solaris to accommodate minor differences in configuration and usage -- for example, the character used to specify directory separators may be different.

General Information

The following documents contain important information you will need to know to get the most out of the SDK tools.

JDK File Structure | [Solaris] [Linux] [Windows]
Setting the Classpath | [Solaris and Linux] [Windows]
How Classes are Found | [Solaris, Linux and Windows]
Tool Changes in Java 2 SDK, v1.4 | [Solaris, Linux and Windows]

Basic Tools

These tools are the foundation of the JDK. They are the tools you use to create and build applications.
Tool Name | Brief Description | Links to Reference Pages
javac | The compiler for the Java programming language. | [Solaris and Linux] [Windows]
java | The launcher for Java applications. In this release, a single launcher is used both for development and deployment. The old deployment launcher, jre, is no longer provided. | [Solaris and Linux] [Windows]
javadoc | API documentation generator. See Javadoc Tool page for doclet and taglet APIs. | [Solaris and Linux] [Windows]
apt | Annotation processing tool. See Annotation Processing Tool for program annotation processing. | [Solaris, Linux, and Windows]
appletviewer | Run and debug applets without a web browser. | [Solaris and Linux] [Windows]
jar | Create and manage Java Archive (JAR) files. See Java Archive Files page for the JAR specification. | [Solaris and Linux] [Windows]
jdb | The Java Debugger. See JPDA for the debugger architecture specifications. | [Solaris and Linux] [Windows]
javah | C header and stub generator. Used to write native methods. | [Solaris and Linux] [Windows]
javap | Class file disassembler | [Solaris and Linux] [Windows]
extcheck | Utility to detect Jar conflicts. | [Solaris and Linux] [Windows]

Security Tools

These security tools help you set security policies on your system and create apps that can work within the scope of security policies set at remote sites.
Tool Name | Brief Description | Links to Reference Pages
keytool | Manage keystores and certificates. | [Solaris and Linux] [Windows]
jarsigner | Generate and verify JAR signatures. | [Solaris and Linux] [Windows]
policytool | GUI tool for managing policy files. | [Solaris and Linux] [Windows]

These security tools help you obtain, list, and manage Kerberos tickets.

Tool Name | Brief Description | Links to Reference Pages
kinit | Tool for obtaining Kerberos v5 tickets. Equivalent functionality is available on the Solaris operating system via the kinit tool. For example, for Solaris 8, see the kinit reference page. | [Windows]
klist | Command-line tool to list entries in credential cache and key tab. Equivalent functionality is available on the Solaris operating system via the klist tool. For example, for Solaris 8, see the klist reference page. | [Windows]
ktab | Command-line tool to help the user manage entires in the key table. Equivalent functionality is available on the Solaris operating system via the kadmin tool. For example, for Solaris 8, see the kadmin reference page. | [Windows]

Internationalization Tools

This tool helps to create localizable apps.
Tool Name | Brief Description | Links to Reference Pages
native2ascii | Convert text to Unicode Latin-1. | [Solaris and Linux] [Windows]

Remote Method Invocation (RMI) Tools

These tools help to create apps that interact over the Web or other network.
Tool Name | Brief Description | Links to Reference Pages
rmic | Generate stubs and skeletons for remote objects. | [Solaris and Linux] [Windows]
rmiregistry | Remote object registry service. | [Solaris and Linux] [Windows]
rmid | RMI activation system daemon. | [Solaris and Linux] [Windows]
serialver | Return class serialVersionUID. | [Solaris and Linux] [Windows]

Java IDL and RMI-IIOP Tools

These tools are used when creating applications that use OMG-standard IDL and CORBA/IIOP.
Tool Name | Brief Description
tnameserv | Provides access to the naming service.
idlj | Generates .java files that map an OMG IDL interface and enable an application written in the Java programming language to use CORBA functionality.
orbd | Provides support for clients to transparently locate and invoke persistent objects on servers in the CORBA environment. ORBD is used instead of the Transient Naming Service, tnameserv. ORBD includes both a Transient Naming Service and a Persistent Naming Service. The orbd tool incorporates the functionality of a Server Manager, an Interoperable Naming Service, and a Bootstrap Name Server. When used in conjunction with the servertool, the Server Manager locates, registers, and activates a server when a client wants to access the server.
servertool | Provides ease-of-use interface for the application programmers to register, unregister, startup, and shutdown a server.

Java Deployment Tools

Utilities for use in conjunction with deployment of java applications and applets on the web.
Tool Name | Brief Description
pack200 | Transforms a JAR file into a compressed pack200 file using the Java gzip compressor. The compressed packed files are highly compressed JARs, which can be directly deployed, saving bandwidth and reducing download time.
unpack200 | Transforms a packed file produced by pack200 into a JAR file.

Java Plug-in Tools

Utilities for use in conjunction with the Java Plug-in.
Tool Name | Brief Description with Links to Reference Pages
htmlconverter | Converts an HTML page (file) containing applets to the OBJECT / EMBED tag format for Java Plug-in.

Java Web Start Tools

Utilities for use in conjunction with Java Web Start.
Tool Name | Brief Description
javaws | Command line tool for launching Java Web Start and setting various options. See Java Web Start Guide for more information.

Java Monitoring and Management Console

Tool Name | Brief Description
jconsole | A JMX-compliant graphical tool for monitoring a Java virtual machine. It can monitor both local and remote JVMs. It can also monitor and manage an application. See Monitoring and Management for the Java Platform for more information.

Java Web Services Tools

Tool Name | Brief Description
schemagen | Schema generator for Java Architecture for XML Binding.
wsgen | Tool to generate JAX-WS portable artifacts.
wsimport | Tool to generate JAX-WS portable artifacts.
xjc | Binding compiler for Java Ardchitecture for XML Binding.

Monitoring Tools

You can use the following tools to monitor JVM performance statistics. The tools described in this section are unsupported and experimental, and should be used with that in mind. They may not be available in future JDK versions.

These tools are supported on all platforms except Windows 98 and Windows ME.

Tool Name | Brief Description
jps | Experimental: JVM Process Status Tool - Lists instrumented HotSpot Java virtual machines on a target system.
jstat | Experimental: JVM Statistics Monitoring Tool - Attaches to an instrumented HotSpot Java virtual machine and collects and logs performance statistics as specified by the command line options.
jstatd | Experimental: JVM jstat Daemon - Launches an RMI server application that monitors for the creation and termination of instrumented HotSpot Java virtual machines and provides a interface to allow remote monitoring tools to attach to Java virtual machines running on the local system.

Troubleshooting Tools

The following tools can be used for specific troubleshooting tasks. The tools described in this section are unsupported and experimental in nature and should be used with that in mind. They may not be available in future JDK versions.

Some of these tools are not currently available on Windows platforms.

Tool Name | Brief Description
jinfo | Experimental - Configuration Info for Java - Prints configuration information for for a given process or core file or a remote debug server.
jhat | Experimental - Heap Dump Browser - Starts a web server on a heap dump file (eg, produced by jmap -dump), allowing the heap to be browsed.
jmap | Experimental - Memory Map for Java - Prints shared object memory maps or heap memory details of a given process or core file or a remote debug server.
jsadebugd | Experimental - Serviceability Agent Debug Daemon for Java - Attaches to a process or core file and acts as a debug server.
jstack | Experimental - Stack Trace for Java - Prints a stack trace of threads for a given process or core file or remote debug server.

Refer to the Java TM 2 Platform, Standard Edition 5.0 Trouble-Shooting and Diagnostic Guide which provides descriptions of tools, options, and other items for use in analyzing problems. This document contains suggestions about what to try before submitting a bug report and what data to collect for a report.

Scripting Tools

The following tool can be used to run scripts that interact with the Java platfrom. This tool is unsupported and experimental in nature and should be used with that in mind. It might not be available in future JDK versions.
Tool Name | Brief Description
jrunscript | Experimental - Script shell for Java - Runs a script.

Copyright © 2002-2004 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


SDK Tools Changes

Java

JavaTM 2 SDK v 1.4
Tools Changes

 SDK Tools
This document describes some of the changes made to the tools in version 1.4 of the Java 2 SDK, Standard Edition. For links to reference pages for all the tools and utilities, see SDK Tools.

Tools changes in Java 2 SDK 1.4.1

  • Three new security tools were added in the 1.4.1 release of the Java 2 platform: kinit, klist, and ktab. These tools help users obtain, list and manage Kerberos tickets.
  • For changes to the javac bytecode compiler in J2SE 1.4.1, see the online release notes.
  • The javadoc tool has about 2 dozen bug fixes. For more details, see What's New in Javadoc 1.4.1.

Tools changes in Java 2 SDK 1.4.0

These changes have been brought forward to subsequent releases in the Java 2 SDK 1.4 family.
  • The java application launcher supports command-line options for the new Assertions Facility. New option -Xconcgc is available for invoking concurrent garbage collection on multi-processor platforms to reduce garbage-collections pauses on large heaps. On the SolarisTM Operating Environment (SPARCTM Platform Edition) new command-line options are available for specifying 64-bit or 32-bit operation. On all platforms, new option -Xloggc:file logs each garbage-collection event in the specified file.
  • The javac byte-code compiler has a new -source option that enables support for compiling source code containing assertions. Also, default compilation is for -target 1.2. Previously, the default was 1.1. The compiler now correctly detects unreachable empty statements, as discussed in bug 4083890. Javac also recognizes the new -Xswitchcheck option that checks switch blocks for fall-through cases and provides a warning message for any that are found.
  • The javadoc tool has several new tags, a dozen new options, smarter inheriting of doc comments, more control over HTML output, improvements to the Doclet API, better error messages, dozens of bug fixes, and is easier to run. For more details, see What's New in Javadoc 1.4.0.

    Downloaded separately from the SDK, the MIF doclet has had a major upgrade -- it generates API documentation in FrameMaker and PDF format.

  • The native2ascii tool contains bug fixes to now correctly process source files encoded with Unicode encoding, such as the default encoding on WinNT. More specifically, the conversion code correctly processes line endings in encodings where a line-end is encoded as 2-bytes (Unicode being the most notable example). (Fixes bugs 4191313 and 4218514)
  • The graphical Policy Tool utility has been enhanced to enable specifying a Principal field indicating what user is to be granted specified access control permissions.
  • The idlj tool has changed the default generated files and provides new command-line options. By default, the idlj tool generates server-side bindings following the Portable Servant Inheritance Model. New command-line options enable you to continue to generate backwards-compatible server-side bindings. These changes were made to more closely align with the Object Management Group (OMG) CORBA specifications.
  • The orbd tool, which stands for Object Request Broker Daemon, is new to this release. ORBD is used instead of the Transient Naming Service, tnameserv. ORBD includes both a Transient Naming Service and a Persistent Naming Service. The orbd tool is used to enable clients to transparently locate and invoke persistent objects on servers in the CORBA environment. The orbd tool incorporates the functionality of a Server Manager, an Interoperable Naming Service, and a Bootstrap Name Server. When used in conjunction with the servertool, the Server Manager locates, registers, and activates a server when a client wants to access the server.
  • The servertool is new to this release. The servertool provides an ease-of-use interface for application programmers to register, unregister, startup, and shutdown a server.
  • The rmic compiler has a new option to enable Portable Object Adapter, or POA support for Remote Method Invocation. The POA enables portability among vendor ORBs, among other uses. To learn more about the POA, follow the link. To enable POA support with the rmic compiler, use the arguments rmic -iiop -poa.
  • There are minor bug fixes but no feature changes to other basic tools: appletviewer, jar, jdb, javah, javap, extcheck, and unregbean.
Copyright © 2002 Sun Microsystems, Inc. All Rights Reserved.
 Sun

Java Software


JDK File Structure for Linux

JDK and JRE File Structure

 JDK Tools

This page provides an introductory overview of the JDK directories and the files they contain. Note that the file structure of the JRE is identical to that of the JDK's jre directory.

Development Files and Directories

This section describes the most important files and directories required to develop applications for the Java platform.

(Note that some of the directories that are not required include demos, Java source code, and C header files. These are mentioned in the Additional Files and Directories section.)

          jdk1.6.0
   ___________|_________________
  |           |                 |
 bin         lib               jre
  |           |         ________|__________
java*     tools.jar    |                   |
javac*    dt.jar      bin                 lib
javap*                 |       ________ ___|___ _________ ________ _______
javah*               java*    |        |       |         |        |       |
javadoc*                    rt.jar    ext   security   i386    applet  fonts
                        charsets.jar   |              /    \
                                  localedata.jar  server  client

Assuming the JDK software is installed at /jdk1.6.0, here are some of the most important directories:

/jdk1.6.0
Root directory of the JDK software installation. Contains copyright, license, and README files. Also contains src.jar, the archive of source code for the Java platform.
/jdk1.6.0/bin
Executables for all the development tools contained in the JDK. The PATH environment variable should contain an entry for this directory. For more information on the tools, see the JDK Tools.
/jdk1.6.0/lib
Files used by the development tools. Includes tools.jar, which contains non-core classes for support of the tools and utilities in the JDK. Also includes dt.jar, the DesignTime archive of BeanInfo files that tell interactive development environments (IDE's) how to display the Java components and how to let the developer customize them for an application.
/jdk1.6.0/jre
Root directory of the Java runtime environment used by the JDK development tools. The runtime environment is an implementation of the Java platform. This is the directory referred to by the java.home system property.
/jdk1.6.0/jre/bin
Executable files for tools and libraries used by the Java platform. The executable files are identical to files in /jdk1.6.0/bin. The java launcher tool serves as an application launcher (and replaced the old jre tool that shipped with 1.1 versions of the JDK). This directory does not need to be in the PATH environment variable.
/jdk1.6.0/jre/lib
Code libraries, property settings, and resource files used by the Java runtime environment. For example:
  • rt.jar -- the bootstrap classes (the RunTime classes that comprise the Java platform's core API).
  • charsets.jar -- character-conversion classes.
Aside from the ext subdirectory (described below) there are several additional resource subdirectories not described here.
/jdk1.6.0/jre/lib/ext
Default installation directory for Extensions to the Java platform. This is where the JavaHelp jar file goes when it is installed, for example.
  • localedata.jar -- locale data for java.text and java.util.
/jdk1.6.0/jre/lib/security
Contains files used for security management. These include the security policy (java.policy) and security properties (java.security) files.
/jdk1.6.0/jre/lib/i386/client
Contains the .so file used by the Java HotSpotTM Client Virtual Machine, which is implemented with Java HotSpotTM technology. This is the default VM.
/jdk1.6.0/jre/lib/i386/server
Contains the .so file used by the Java HotSpotTM Server Virtual Machine.
/jdk1.6.0/jre/lib/applet
Jar files containing support classes for applets can be placed in the lib/applet/ directory. This reduces startup time for large applets by allowing applet classes to be pre-loaded from the local file system by the applet class loader, providing the same protections as if they had been downloaded over the net.
/jdk1.6.0/jre/lib/fonts
Font files for use by platform.

Additional Files and Directories

This section describes the directory structure for the demos, Java source code, and C header files.

                        jdk1.6.0
                 ___________|__________ _________
                |           |          |         |
              demo       include    src.jar     man
             ___|___ _________ __________ ________
            |       |         |          |        |
          applets  jfc       jpda     plugin     jni

The additional files and directories shown above are:

/jdk1.6.0/src.jar
Archive containing source code for the Java platform.
/jdk1.6.0/demo
Examples, with source code, that show you how to program for the Java platform.
/jdk1.6.0/demo/applets
Applets that can be used on a web page.
/jdk1.6.0/demo/jfc
Examples that use Java 2DTM and JFC/Swing components.
/jdk1.6.0/demo/jpda
Examples of using the Java Platform Debugging Architecture. Includes source code for the javadt and jdb utilities.
/jdk1.6.0/demo/plugin
Demos for use with the Java Plug-in product.
/jdk1.6.0/demo/jni
Example classes and C code that demonstrate access to poll(2) functionality from the Java platform.
/jdk1.6.0/include
C-language header files that support native-code programming using the Java Native Interface and the Java Virtual Machine Debugger Interface.
/jdk1.6.0/man
Contains man pages for the JDK tools.

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


apt man page

NAME

apt - annotation processing tool

SYNOPSIS

apt [-classpath classpath] [-sourcepath sourcepath] [-d directory] [-s directory] [-factorypath path] [-factory class] [-print] [-nocompile] [-Akey[=val] ...] [javac option] sourcefiles [@files]

PARAMETERS

Options may be in any order. For a discussion of parameters which apply to a specific option, see OPTIONS below.

sourcefiles
Zero or more source files to be processed.
@files
One or more files that list source files or other options

DESCRIPTION

The tool apt, annotation processing tool, includes a set of new reflective APIs and supporting infrastructure to process program annotations. The apt reflective APIs provide a build-time, source-based, read-only view of program structure. These reflective APIs are designed to cleanly model the JavaTM programming language's type system after the addition of generics. First, apt runs annotation processors that can produce new source code and other files. Next, apt can cause compilation of both original and generated source files, easing development. The reflective APIs and other APIs used to interact with the tool are subpackages of com.sun.mirror.

A fuller discussion of how the tool operates as well as instructions for developing with apt are in Getting Started with apt.

Note:
The functionality of apt has been subsumed by the annotation-processing infrastructure that is now part of the javac tool and standardized for use by all Java compilers. This new infrastructure relies on the language model and annotation-processing APIs that are now part of the Java Platform. It is recommended that new annotation processor development be based on the new APIs and the javac tool.

OPTIONS

apt specific options

-s dir
Specify the directory root under which processor-generated source files will be placed; files are placed in subdirectories based on package namespace.
-nocompile
Do not compile source files to class files.
-print
Print out textual representation of specified types; perform no annotation processing or compilation.
-A[key[=val]]
Options to pass to annotation processors -- these are not interpreted by apt directly, but are made available for use by individual processors
-factorypath path
Specify where to find annotation processor factories; if this option is used, the classpath is not searched for factories.
-factory classname
Name of annotation processor factory to use; bypasses default discovery process

Options shared with javac

-d dir
Specify where to place processor and javac generated class files
-cp path or -classpath path
Specify where to find user class files and annotation processor factories. If -factorypath is given, the classpath is not searched for factories.

Consult the javac(1) man page for information on javac options.

NOTES

The functionality of apt has been subsumed by the standard annotation-processing infrastructure now offered by javac. Support for apt and its associated APIs may be discontinued in some future JDK release.

SEE ALSO

  • javac, java


idlj - The IDL-to-Java Compiler

idlj generates Java bindings from a given IDL file.

Synopsis

idlj [ options ] idl-file

where idl-file is the name of a file containing Interface Definition Language (IDL) definitions. Options may appear in any order, but must precede the idl-file.

Description

The IDL-to-Java Compiler generates the Java bindings for a given IDL file. For binding details, see the OMG IDL to Java Language Language Mapping Specification. Some previous releases of the IDL-to-Java compiler were named idltojava.

Emitting Client and Server Bindings

To generate Java bindings for an IDL file named My.idl:
    idlj My.idl
This generates the client-side bindings and is equivalent to:
    idlj -fclient My.idl
The client-side bindings do not include the server-side skeleton. If you want to generate the server-side bindings for the interfaces:
    idlj -fserver My.idl
Server-side bindings include the client-side bindings plus the skeleton, all of which are POA (that is, Inheritance Model) classes. If you want to generate both client and server-side bindings, use one of the following (equivalent) commands:
    idlj -fclient -fserver My.idl
    idlj -fall My.idl

There are two possible server-side models: the Inheritance Model and the Tie Delegation Model.

The default server-side model is the Portable Servant Inheritance Model. Given an interface My defined in My.idl, the file MyPOA.java is generated. You must provide the implementation for My and it must inherit from MyPOA.

MyPOA.java is a stream-based skeleton that extends org.omg.PortableServer.Servant and implements the InvokeHandler interface and the operations interface associated with the IDL interface the skeleton implements.

The PortableServer module for the Portable Object Adapter (POA) defines the native Servant type. In the Java programming language, the Servant type is mapped to the Java org.omg.PortableServer.Servant class. It serves as the base class for all POA servant implementations and provides a number of methods that may be invoked by the application programmer, as well as methods which are invoked by the POA itself and may be overridden by the user to control aspects of servant behavior.

Another option for the Inheritance Model is to use the -oldImplBase flag in order to generate server-side bindings that are compatible with versions of the Java programming language prior to J2SE 1.4. Note that using the -oldImplBase flag is non-standard: these APIs are being deprecated. You would use this flag ONLY for compatibility with existing servers written in J2SE 1.3. In that case, you would need to modify an existing MAKEFILE to add the -oldImplBase flag to the idlj compiler, otherwise POA-based server-side mappings will be generated. To generate server-side bindings that are backwards compatible:

    idlj -fclient -fserver -oldImplBase My.idl
    idlj -fall -oldImplBase My.idl
Given an interface My defined in My.idl, the file _MyImplBase.java is generated. You must provide the implementation for My and it must inherit from _MyImplBase.

The other server-side model is called the Tie Model. This is a delegation model. Because it is not possible to generate ties and skeletons at the same time, they must be generated separately. The following commands generate the bindings for the Tie Model:

    idlj -fall My.idl
    idlj -fallTIE My.idl
For the interface My, the second command generates MyPOATie.java. The constructor to MyPOATie takes a delegate. In this example, using the default POA model, the constructor also needs a poa. You must provide the implementation for delegate, but it does not have to inherit from any other class, only the interface MyOperations. But to use it with the ORB, you must wrap your implementation within MyPOATie. For instance:
        ORB orb = ORB.init(args, System.getProperties());

    // Get reference to rootpoa & activate the POAManager
    POA rootpoa = (POA)orb.resolve_initial_references("RootPOA");
    rootpoa.the_POAManager().activate();

    // create servant and register it with the ORB
    MyServant myDelegate = new MyServant();
    myDelegate.setORB(orb);

    // create a tie, with servant being the delegate.
    MyPOATie tie = new MyPOATie(myDelegate, rootpoa);

    // obtain the objectRef for the tie
    My ref = tie._this(orb);
You might want to use the Tie model instead of the typical Inheritance model if your implementation must inherit from some other implementation. Java allows any number of interface inheritance, but there is only one slot for class inheritance. If you use the inheritance model, that slot is used up . By using the Tie Model, that slot is freed up for your own use. The drawback is that it introduces a level of indirection: one extra method call occurs when invoking a method.

To generate server-side, Tie model bindings that are compatible with versions of the IDL to Java language mapping in versions prior to J2SE 1.4.

    idlj -oldImplBase -fall My.idl
    idlj -oldImplBase -fallTIE My.idl

For the interface My, this will generate My_Tie.java. The constructor to My_Tie takes a impl. You must provide the implementation for impl, but it does not have to inherit from any other class, only the interface HelloOperations. But to use it with the ORB, you must wrap your implementation within My_Tie. For instance:

        ORB orb = ORB.init(args, System.getProperties());

    // create servant and register it with the ORB
    MyServant myDelegate = new MyServant();
    myDelegate.setORB(orb);

    // create a tie, with servant being the delegate.
    MyPOATie tie = new MyPOATie(myDelegate);

    // obtain the objectRef for the tie
    My ref = tie._this(orb);

Specifying Alternate Locations for Emitted Files

If you want to direct the emitted files to a directory other than the current directory, invoke the compiler as:
idlj -td /altdir My.idl
For the interface My, the bindings will be emitted to /altdir/My.java, etc., instead of ./My.java.

Specifying Alternate Locations for Include Files

If My.idl included another idl file, MyOther.idl, the compiler assumes that MyOther.idl resides in the local directory. If it resides in /includes, for example, then you would invoke the compiler with the following command:
    idlj -i /includes My.idl
If My.idl also included Another.idl that resided in /moreIncludes, for example, then you would invoke the compiler with the following command:
    idlj -i /includes -i /moreIncludes My.idl
Since this form of include can become irritatingly long, another means of indicating to the compiler where to search for included files is provided. This technique is similar to the idea of an environment variable. Create a file named idl.config in a directory that is listed in your CLASSPATH. Inside of idl.config, provide a line with the following form:
    includes=/includes;/moreIncludes
The compiler will find this file and read in the includes list. Note that in this example the separator character between the two directories is a semicolon (;). This separator character is platform dependent. On the Windows platform, use a semicolon, on the Unix platform, use a colon, etc. For more information on includes, see the Setting the Classpath.

Emitting Bindings for Include Files

By default, only those interfaces, structs, etc, that are defined in the idl file on the command line have Java bindings generated for them. The types defined in included files are not generated. For example, assume the following two idl files:
    My.idl
    #include <MyOther.idl>
    interface My
    {
    };
    MyOther.idl

    interface MyOther
    {
    };

The following command will only generate the java bindings for My:
    idlj My.idl
To generate all of the types in My.idl and all of the types in the files that My.idl includes (in this example, MyOther.idl), use the following command:
    idlj -emitAll My.idl
There is a caveat to the default rule. #include statements which appear at global scope are treated as described. These #include statements can be thought of as import statements. #include statements which appear within some enclosing scope are treated as true #include statements, meaning that the code within the included file is treated as if it appeared in the original file and, therefore, Java bindings are emitted for it. Here is an example:
    My.idl
    #include <MyOther.idl>
    interface My
    {
      #include <Embedded.idl>
    };
    MyOther.idl
    interface MyOther
    {
    };
    Embedded.idl
    enum E {one, two, three};
Running the following command:
    idlj My.idl
will generate the following list of Java files:
    ./MyHolder.java
    ./MyHelper.java
    ./_MyStub.java
    ./MyPackage
    ./MyPackage/EHolder.java
    ./MyPackage/EHelper.java
    ./MyPackage/E.java
    ./My.java
Notice that MyOther.java was not generated because it is defined in an import-like #include. But E.java was generated because it was defined in a true #include. Also notice that since Embedded.idl was included within the scope of the interface My, it appears within the scope of My (that is,in MyPackage).

If the -emitAll flag had been used in the previous example, then all types in all included files would be emitted.

Inserting Package Prefixes

Suppose that you work for a company named ABC that has constructed the following IDL file:

    Widgets.idl

    module Widgets
    {
      interface W1 {...};
      interface W2 {...};
    };

Running this file through the IDL-to-Java compiler will place the Java bindings for W1 and W2 within the package Widgets. But there is an industry convention that states that a company's packages should reside within a package named com.<company name>. The Widgets package is not good enough. To follow convention, it should be com.abc.Widgets. To place this package prefix onto the Widgets module, execute the following:
    idlj -pkgPrefix Widgets com.abc Widgets.idl
If you have an IDL file which includes Widgets.idl, the -pkgPrefix flag must appear in that command also. If it does not, then your IDL file will be looking for a Widgets package rather than a com.abc.Widgets package.

If you have a number of these packages that require prefixes, it might be easier to place them into the idl.config file described above. Each package prefix line should be of the form:

    PkgPrefix.<type>=<prefix>
So the line for the above example would be:
    PkgPrefix.Widgets=com.abc

The use of this option does not affect the Repository ID.

Defining Symbols Before Compilation

You may need to define a symbol for compilation that is not defined within the IDL file, perhaps to include debugging code in the bindings. The command
    idlj -d MYDEF My.idl
is the equivalent of putting the line #define MYDEF inside My.idl.

Preserving Pre-Existing Bindings

If the Java binding files already exist, the -keep flag will keep the compiler from overwriting them. The default is to generate all files without considering if they already exist. If you've customized those files (which you should not do unless you are very comfortable with their contents), then the -keep option is very useful. The command
    idlj -keep My.idl
emit all client-side bindings that do not already exist.

Viewing Progress of Compilation

The IDL-to-Java compiler will generate status messages as it progresses through its phases of execution. Use the -v option to activate this "verbose" mode:
    idlj -v My.idl
By default the compiler does not operate in verbose mode.

Displaying Version Information

To display the build version of the IDL-to-Java compiler, specify the -version option on the command-line:

idlj -version

Version information also appears within the bindings generated by the compiler. Any additional options appearing on the command-line are ignored.

Options

-d symbol
This is equivalent to the following line in an IDL file:
#define symbol

-emitAll
Emit all types, including those found in #include files.

-fside
Defines what bindings to emit. side is one of client, server, serverTIE, all, or allTIE. The -fserverTIE and -fallTIE options cause delegate model skeletons to be emitted. Assumes -fclient if the flag is not specified.

-i include-path
By default, the current directory is scanned for included files. This option adds another directory.

-keep
If a file to be generated already exists, do not overwrite it. By default it is overwritten.

-noWarn
Suppresses warning messages.

-oldImplBase
Generates skeletons compatible with pre-1.4 JDK ORBs. By default, the POA Inheritance Model server-side bindings are generated. This option provides backward-compatibility with older versions of the Java programming language by generating server-side bindings that are ImplBase Inheritance Model classes.

-pkgPrefix type prefix
Wherever type is encountered at file scope, prefix the generated Java package name with prefix for all files generated for that type. The type is the simple name of either a top-level module, or an IDL type defined outside of any module.

-pkgTranslate type package
Whenever the module name type is encountered in an identifier, replace it in the identifier with package for all files in the generated Java package. Note that pkgPrefix changes are made first. type is the simple name of either a top-level module, or an IDL type defined outside of any module, and must match the full package name exactly.

If more than one translation matches an identifier, the longest match is chosen. For example, if the arguments include:

  -pkgTranslate foo bar -pkgTranslate foo.baz buzz.fizz

The following translations would occur:

foo          =>	bar
foo.boo      =>	bar.boo
foo.baz      =>	buzz.fizz
foo.baz.bar  =>	buzz.fizz.bar

The following package names cannot be translated:

  • org
  • org.omg or any subpackages of org.omg

Any attempt to translate these packages will result in uncompilable code, and the use of these packages as the first argument after -pkgTranslate will be treated as an error.

-skeletonName xxx%yyy
Use xxx%yyy as the pattern for naming the skeleton. The defaults are:
  • %POA for the POA base class (-fserver or -fall)
  • _%ImplBase for the oldImplBase class (-oldImplBase and (-fserver or -fall))

-td dir
Use dir for the output directory instead of the current directory.

-tieName xxx%yyy
Name the tie according to the pattern. The defaults are:
  • %POATie for the POA tie base class (-fserverTie or -fallTie)
  • %_Tie for the oldImplBase tie class (-oldImplBase and (-fserverTie or -fallTie))

-nowarn, -verbose
Verbose mode.

-version
Display version information and terminate.
See the Description section for more option information.

Restrictions:

  • Escaped identifiers in the global scope may not have the same spelling as IDL primitive types, Object, or ValueBase. This is because the symbol table is pre-loaded with these identifiers; allowing them to be redefined would overwrite their original definitions. (Possible permanent restriction).
  • The fixed IDL type is not supported.

Known Problems:

  • No import generated for global identifiers. If you invoke on an unexported local impl, you do get an exception, but it seems to be due to a NullPointerException in the ServerDelegate DSI code.

Copyright © 2001-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


Java(TM) API for XML Web Services (JAX-WS) 2.0 - wsgen

wsgen - JAX-WS 2.0 Beta

The wsgen tool generates JAX-WS portable artifacts used in JAX-WS web services. The tool reads a web service endpoint implementation class (SEI) and generates all the required artifacts for web service deployment, and invocation.

SYNOPSIS

wsgen [options] <SEI>

OPTIONS

The following table lists the wsgen options.

Table 1-1 wsgen Options

Option

Description

-classpath <path>

Specify where to find input class files

-cp <path>

Same as -classpath <path>

-d <directory>

Specify where to place generated output files

-extension

allow vendor extensions (functionality not specified by the specification). Use of extensions may result in applications that are not portable or may not interoperate with other implementations

-help

Display help

-keep

Keep generated files

-r <directory>

Used only in conjunction with the -wsdl option. Specify where to place generated resource files such as WSDLs

-s <directory>

Specify where to place generated source files

-verbose

Output messages about what the compiler is doing

-version

Print version information. Use of this option will ONLY print version information. Normal processing will not occur.
-wsdl[:protocol]
 By default wsgen does not generate a WSDL file. This flag is optional and will cause wsgen to generate a WSDL file and is usually only used so that the developer can look at the WSDL before the endpoint is deploy. The protocol is optional and is used to specify what protocol should be used in the wsdl:binding. Valid protocols include: soap1.1 and Xsoap1.2. The default is soap1.1. Xsoap1.2 is not standard and can only be used in conjunction with the -extension option.

-servicename <name>

Used only in conjunction with the -wsdl option. Used to specify a particular wsdl:service name to be generated in the WSDL. Example, -servicename "{http://mynamespace/}MyService"

-portname <name>

Used only in conjunction with the -wsdl option. Used to specify a particular wsdl:port name to be generated in the WSDL. Example, -portname "{http://mynamespace/}MyPort"

Ant task

An Ant task for the wsgen tool is provided along with the tool. The attributes and elements supported by the Ant task are listed below:

    <wsgen
         sei="..."
         destdir="directory for generated class files"
         classpath="classpath" | cp="classpath"
         resourcedestdir="directory for generated resource files such as WSDLs"
         sourcedestdir="directory for generated source files"
         keep="true|false"
         verbose="true|false"
         genwsdl="true|false"
         protocol="soap1.1|Xsoap1.2"
         servicename="..."
         portname="...">
         extension="true|false"
         <classpath refid="..."/>
     </wsgen>

Attribute

Description

Command line

sei

Name of the service endpoint implementation class

SEI

destdir

Specify where to place output generated classes

-d

classpath

Specify where to find input class files

-classpath

cp

Same as -classpath

-cp

resourcedestdir

Used only in conjunction with the -wsdl option. Specify where to place generated resource files such as WSDLs

-r

sourcedestdir

Specify where to place generated source files

-s

keep

Keep generated files

-keep

verbose

Output messages about what the compiler is doing

-verbose

genwsdl

Specify that a WSDL file should be generated

-wsdl

protocol

Used in conjunction with genwsdl to specify the protocol to use in the wsdl:binding. Value values are "soap1.1" or "Xsoap1.2", default is "soap1.1". "Xsoap1.2" is not standard and can only be used in conjunction with the -extensions option

-wsdl:soap11

servicename

Used in conjunction with the genwsdl option. Used to specify a particular wsdl:service name for the generated WSDL.Example, servicename="{http://mynamespace/}MyService"

-servicename

portname

Used in conjunction with the genwsdl option. Used to specify a particular wsdl:portmame name for the generated WSDL. Example, portname="{http://mynamespace/}MyPort"

-servicename

extension

allow vendor extentions (funcionality not specified by the specification). Use of extensions may result in applications that are not portable or may not interoperate with other implementations

-extension

The classpath attribute is a path-like structure and can also be set via nested <classpath> elements. Before this task can be used, a <taskdef> element needs to be added to the project as given below:

  <taskdef name="wsgen" classname="com.sun.tools.ws.ant.WsGen">
      <classpath path="jaxws.classpath"/>
  </taskdef>

where jaxws.classpath is a reference to a path-like structure, defined elsewhere in the build environment, and contains the list of classes required by the JAX-WS tools.

Example

<wsgen
      resourcedestdir="${wsdl.dir}"
      sei="fromjava.server.AddNumbersImpl">
      <classpath refid="compile.classpath"/>
</wsgen>

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


Java(TM) API for XML Web Services (JAX-WS) 2.0 - wsimport

wsimport - JAX-WS 2.0 Beta

SYNOPSIS

wsimport [options] <wsdl>

DESCRIPTION

The wsimport tool generates JAX-WS portable artifacts, such as:

  • Service Endpoint Interface (SEI)
  • Service
  • Exception class mapped from wsdl:fault (if any)
  • Async Reponse Bean derived from response wsdl:message (if any)
  • JAXB generated value types (mapped java classes from schema types)

These artifacts can be packaged in a WAR file with the WSDL and schema documents along with the endpoint implementation to be deployed.

wsimport tool can be launched using the command line script wsimport.sh (Unix) or wsimport.bat(windows). There is also and ant task to import and compile the wsdl, see the details below.

OPTIONS

The following table lists the wsimport options.

Table 1-1 wsimport Options

Option | Description
-d <directory> | Specify where to place generated output files
-b <path> | Specify external JAX-WS or JAXB binding files (Each <file> must have its own -b)
-catalog | Specify catalog file to resolve external entity references, it supports TR9401, XCatalog, and OASIS XML Catalog format. Please read the XML Entity and URI Resolvers document or see wsimport_catalog sample.
-extension | allow vendor extensions (functionality not specified by the specification). Use of extensions may result in applications that are not portable or may not interoperate with other implementations
-help | Display help
-httpproxy:<host>:<port> | Specify an HTTP proxy server (port defaults to 8080)
-keep | Keep generated files
-p | Specifying a target package via this command-line option, overrides any wsdl and schema binding customization for package name and the default package name algorithm defined in the specification
-s <directory> | Specify where to place generated source files
-verbose | Output messages about what the compiler is doing
-version | Print version information
-wsdllocation <location> | @WebService.wsdlLocation and @WebServiceClient.wsdlLocation value

Multiple JAX-WS and JAXB binding files can be specified using -b option and they can be used to customize various things like package names, bean names, etc. More information on JAX-WS and JAXB binding files can be found in the customization documentation.

Ant task

An Ant task for the wsimport tool is provided along with the tool. The attributes and elements supported by the Ant task are listed below:

   <wsimport
      wsdl="..."
      destdir="directory for generated class files"
      sourcedestdir="directory for generated source files"
      keep="true|false"
      extension="true|false"
      verbose="true|false"
      version="true|false"
      wsdlLocation="..."
      catalog="catalog file"
      package="package name"
      <binding dir="..." includes="..." />
  </wsimport>

Attribute

Description

Command line

wsdl

WSDL file

WSDL

destdir

Specify where to place output generated classes

-d

sourcedestdir

Specify where to place generated source files, keep is turned on with this option

-s

keep

Keep generated files, tunred on with sourcedestdir option

-keep

verbose

Output messages about what the compiler is doing

-verbose

binding

Specify external JAX-WS or JAXB binding files

-b

extension

allow vendor extentions (funcionality not specified by the specification). Use of extensions may result in applications that are not portable or may not interoperate with other implementations

-extension
wsdllocation
 The wsdl URI passed thru this option will be used to set the value of @WebService.wsdlLocation and @WebServiceClient.wsdlLocation annotation elements on the generated SEI and Service interface
 -wsdllocation
catalog
 Specify catalog file to resolve external entity references, it supports TR9401, XCatalog, and OASIS XML Catalog format. Additionally, ant xmlcatalog type can be used to resolve entities, see wsimport_catalog sample.
 -catalog
package
 Specifies the target package -p

The binding attributes is like a path-like structure and can also be set via nested <binding> elements, respectively. Before this task can be used, a <taskdef> element needs to be added to the project as given below:

  <taskdef name="wsimport" classname="com.sun.tools.ws.ant.WsImport">
      <classpath path="jaxws.classpath"/>
  </taskdef>

where jaxws.classpath is a reference to a path-like structure, defined elsewhere in the build environment, and contains the list of classes required by the JAX-WS tools.

Examples

  <wsimport
      destdir="${build.classes.home}"
      debug="true"
      wsdl="AddNumbers.wsdl"
      binding="custom.xml"/>

The above example generates client-side artifacts for AddNumbers.wsdl, stores .class files in the ${build.classes.home} directory using the custom.xml customization file. The classpath used is xyz.jar and compiles with debug information on.

  <wsimport
      keep="true"
      sourcedestdir="${source.dir}"
      destdir="${build.classes.home}"
      wsdl="AddNumbers.wsdl">
      <binding dir="${basedir}/etc" includes="custom.xml"/>
  </wsimport>

The above example generates portable artifacts for AddNumbers.wsdl, stores .java files in the ${source.dir} directory, stores .class files in the ${build.classes.home} directory.

Notes

Summary of Changed and Removed wsimport ant attributes:

base replaced by destdir
sourceBase is replaced by sourcedestdir
wsdlFile is replaced by wsdl

httpProxy is removed. Use ant's setproxy task instead for proxy configuration.

version is removed

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


javaws Command Line

NAME

javaws - Java Web Start launcher command

SYNOPSIS

javaws [run-options] <jnlp>

javaws [control-options]

PARAMETERS

[run-options]

Command-line run-options. run-options may be in any order. For a discussion of the various run-options, see RUN-OPTIONS below.

<jnlp>

This can be either the path of, or the Uniform Resource Locater (URL) of the JNLP (Java Network Launching Protocol) file.

[control-options]

Command-line control-options. control-options may be in any order. For a discussion of the various control-options, see CONTROL-OPTIONS below.

DESCRIPTION

The javaws command launches Java Web Start, which is the reference implementation of the Java Network Launching Protocol (JNLP). Java Web Start launches Java applications/applets hosted on a network.

If a JNLP file is specified, javaws will launch the Java application/applet specified in the JNLP file.

The javaws launcher has a set of options that are supported in the current release. However, the options may be removed in a future release.

RUN-OPTIONS

-offline

run Java Web Start in offline mode.

-Xnosplash

disable the display of the initial splash screen.

-open <arguments>

If specified, replaces the arguments in the jnlp file with -open <arguments>.

-print <arguments>

If specified, replaces the arguments in the jnlp file with -print <arguments>.

-online

run in online mode (default behavior).

-wait

If specified, the javaws process will not exit until the application exits.

-verbose

display additional output.

-J<option>

supply options to the vm.

-system

run the application from the system cache only.

CONTROL-OPTIONS

-viewer

show the Cache Viewer in the java control panel

-userConfig <property name>

clear the specified deployment property.

-userConfig <property name> <property value>

set the specified deployment property to the specified value.

-uninstall

remove all applications from the cache.

-uninstall <jnlp>

remove the application from the cache.

-import [import-options] <jnlp>

import the application to the cache.

IMPORT-OPTIONS

-silent

import silently (with no user interface).

-system

import application to the system cache.

-codebase <url>

retrieve resources from the given codebase.

-shortcut

install shortcuts as if user allowed prompt. This option has no effect unless -silent option is also used.

-association

install associations as if user allowed prompt. This option has no effect unless -silent option is also used.

FILES

For information about the user and system cache and deployment.properties files, see System- and User-Level Properties.

MORE INFORMATION

For more information about Java Web Start, see Java Web Start.


JAXB RI 2.0 ea3 -- Binding Compiler

xjc - JavaTM Architecture for XML Binding
Binding Compiler

Specification Version: 2.0
Reference Implementation (RI) Version: 2.0 ea3

Launching xjc

The binding compiler can be launched using the appropriate xjc shell script in the bin directory for your platform. We also provide an Ant task to run the binding complier - see the instructions for using the XJC Ant task]

For Solaris/Linux

% /path/to/jaxb/bin/xjc.sh -help

For WindowsNT/2000/XP

> c:\path\to\jaxb\bin\xjc.bat -help

Output

Usage: xjc [-options ...] <schema_file/URL/dir> ... [-b <bindinfo>] ...
Options:
 -nv                  : do not perform strict validation of the input schema(s)
 -extension           : allow vendor extensions - do not strictly follow the
                        Compatibility Rules and App E.2 from the JAXB Spec
 -b <file>            : specify external bindings files (each <file> must have its own -b)
 -d <dir>             : generated files will go into this directory
 -p <pkg>             : specifies the target package
 -httpproxy <proxy>   : set HTTP/HTTPS proxy. Format is [user[:password]@]proxyHost:proxyPort
 -httpproxyfile <file>: set the proxy string (same format as above).
 -classpath <arg>     : specify where to find user class files
 -catalog <file>      : specify catalog files to resolve external entity references
                        support TR9401, XCatalog, and OASIS XML Catalog format.
 -readOnly            : generated files will be in read-only mode
 -npa                 : suppress generation of package level annotations (**/package-info.java)
 -xmlschema           : treat input as W3C XML Schema (default)
 -relaxng             : treat input as RELAX NG (experimental,unsupported)
 -relaxng-compact     : treat input as RELAX NG compact syntax (experimental,unsupported)
 -dtd                 : treat input as XML DTD (experimental,unsupported)
 -wsdl                : treat input as WSDL and compile schemas inside it (experimental,unsupported)
 -verbose             : be extra verbose
 -quiet               : suppress compiler output
 -help                : display this help message
 -version             : display version information

Execute the jaxb-xjc.jar JAR File

If all else fails, you should be able to execute the jaxb-xjc.jar file:

For Solaris/Linux:
% java -jar $JAXB_HOME/lib/jaxb-xjc.jar -help
For Windows:
> java -jar %JAXB_HOME%\lib\jaxb-xjc.jar -help

This is equivalent of running "xjc.sh" or "xjc.bat", and it allows you to set the JVM parameters.

OPTIONS

-nv
By default, the XJC binding compiler performs strict validation of the source schema before processing it. Use this option to disable strict schema validation. This does not mean that the binding compiler will not perform any validation, it simply means that it will perform less-strict validation.
-extension
By default, the XJC binding compiler strictly enforces the rules outlined in the Compatibility chapter of the JAXB Specification. Appendix E.2 defines a set of W3C XML Schema features that are not completely supported by JAXB v1.0. In some cases, you may be allowed to use them in the "-extension" mode enabled by this switch. In the default (strict) mode, you are also limited to using only the binding customizations defined in the specification. By using the "-extension" switch, you will be allowed to use the JAXB Vendor Extensions
-b <file>
Specify one or more external binding files to process. (Each binding file must have it's own "-b" switch.) The syntax of the external binding files is extremely flexible. You may have a single binding file that contains customizations for multiple schemas or you can break the customizations into multiple bindings files:

xjc schema1.xsd schema2.xsd schema3.xsd -b bindings123.xjb
xjc schema1.xsd schema2.xsd schema3.xsd -b bindings1.xjb -b bindings2.xjb -b bindings3.xjb
In addition, the ordering of the schema files and binding files on the command line does not matter.

-d <dir>
By default, the XJC binding compiler will generate the Java content classes in the current directory. Use this option to specify an alternate output directory. The output directory must already exist, the XJC binding compiler will not create it for you.
-p <pkg>
Specifying a target package via this command-line option overrides any binding customization for package name and the default package name algorithm defined in the specification.
-httpproxy <proxy>
Specify the HTTP/HTTPS proxy. The format is [user[:password]@]proxyHost[:proxyPort]. The old -host and -port are still supported by the RI for backwards compatibility, but they have been deprecated. Note that the password specified with this option is an argument that is visible to other users who use the top command, for example. For greater security, use -httpproxyfile, below.
-httpproxyfile <file>
Specify the HTTP/HTTPS proxy using a file. Same format as above, but the password specified in the file is not visible to other users.
-classpath <arg>
Specify where to find client application class files used by the <jxb:javaType> and <xjc:superClass> customizations.
-catalog <file>
Specify catalog files to resolve external entity references. Supports TR9401, XCatalog, and OASIS XML Catalog format. Please read the XML Entity and URI Resolvers document or the catalog-resolver sample application.
-readOnly
By default, the XJC binding compiler does not write-protect the Java source files it generates. Use this option to force the XJC binding compiler to mark the generated Java sources read-only.
-npa
Supress the generation of package level annotations into **/package-info.java. Using this switch causes the generated code to internalize those annotations into the other generated classes.
-xmlschema
treat input schemas as W3C XML Schema (default). If you do not specify this switch, your input schemas will be treated as W3C XML Schema.
-relaxng
Treat input schemas as RELAX NG (experimental, unsupported). Support for RELAX NG schemas is provided as a JAXB Vendor Extension.
-relaxng-compact
Treat input schemas as RELAX NG compact syntax(experimental, unsupported). Support for RELAX NG schemas is provided as a JAXB Vendor Extension.
-dtd
Treat input schemas as XML DTD (experimental, unsupported). Support for RELAX NG schemas is provided as a JAXB Vendor Extension.
-wsdl
Treat input as WSDL and compile schemas inside it (experimental,unsupported).
-quiet
Suppress compiler output, such as progress information and warnings..
-verbose
Be extra verbose, such as printing informational messages or displaying stack traces upon some errors..
-help
Display a brief summary of the compiler switches.
-version
Display the compiler version information.
<schema file/URL/dir>
Specify one or more schema files to compile. If you specify a directory, then xjc will scan it for all schema files and compile them.

Summary of Deprecated and Removed Command Line Options

-host & -port
These options have been deprecated and replaced with the -httpproxy option. For backwards compatibility, we will continue to support these options, but they will no longer be documented and may be removed from future releases.
-use-runtime
Since the JAXB 2.0 specification has defined a portable runtime, it is no longer necessary for the JAXB RI to generate **/impl/runtime packages. Therefore, this switch is obsolete and has been removed.
-source
The -source compatibility switch was introduced in the first JAXB 2.0 Early Access release. We have decided to remove this switch from future releases of JAXB 2.0. If you need to generate 1.0.x code, please use an installation of the 1.0.x codebase.
-Xlocator & -Xsync-methods
These switches have been disabled for now. We plan on releasing this functionality as a separate download in the future.

Compiler Restrictions

In general, it is safest to compile all related schemas as a single unit with the same binding compiler switches.

Please keep the following list of restrictions in mind when running xjc. Most of these issues only apply when compiling multiple schemas with multiple invocations of xjc.

  • To compile multiple schemas at the same time, keep the following precedence rules for the target Java package name in mind:
    1. The "-p" command line option takes the highest precedence.
    2. <jaxb:package> customization
    3. If targetNamespace is declared, apply targetNamespace -> Java package name algorithm defined in the specification.
    4. If no targetNamespace is declared, use a hardcoded package named "generated".
  • It is not legal to have more than one <jaxb:schemaBindings> per namespace, so it is impossible to have two schemas in the same target namespace compiled into different Java packages.
  • All schemas being compiled into the same Java package must be submitted to the XJC binding compiler at the same time - they cannot be compiled independently and work as expected.
  • Element substitution groups spread across multiple schema files must be compiled at the same time.

See Also

  • Running the binding compiler (XJC): [command-line instructions, using the XJC Ant task]
  • Java Architecture for XML Binding (JAXB)

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


JAXB RI 2.0 ea3 -- Schema Generator

schemagen - JavaTM Architecture for XML Binding Schema Generator

Specification Version: 2.0
Reference Implementation (RI) Version: 2.0 ea3

Launching schemagen

The schema generator can be launched using the appropriate schemagen shell script in the bin directory for your platform.

The current schema generator can process either Java source files or class files.

We also provide an Ant task to run the schema generator - see the instructions for using schemagen with Ant.

For Solaris/Linux

      % path/to/jaxb/bin/schemagen.sh Foo.java Bar.java ...
      Note: Writing schema1.xsd

For WindowsNT/2000/XP

      > path\to\jaxb\bin\schemagen.bat Foo.java Bar.java ...
      Note: Writing schema1.xsd

If your java sources/classes reference other classes, they must be accessable on your system CLASSPATH environment variable, or they need to be given to the tool by using the -classpath/-cp options. Otherwise you will see errors when generating your schema.

Command Line Options

Usage: schemagen [-options ...] <java files>

Options:
    -d <path>         :  Specify where to place processor and javac generated class files
    -cp <path>        :  Specify where to find user specified files
    -classpath <path> :  Specify where to find user specified files
    -help             :  Display this usage message

Generated Resource Files

The current schema generator simply creates a schema file for each namespace referenced in your Java classes. There is no way to control the name of the generated schema files at this time. For that purpose, use the schema generator ant task.

See Also

  • Running the schema generator (schemagen): [command-line instructions, using the SchemaGen Ant task]
  • Java Architecture for XML Binding (JAXB)


jconsole - Java Monitoring and Management Console

  • Synopsis
  • Parameters
  • Description
  • Options
  • See Also

SYNOPSIS

jconsole [ options ] [ connection ... ]

PARAMETERS

options
Options, if used, should follow immediately after the command name.

connection = pid | host:port | jmxUrl
pid Process ID of a local Java VM. The Java VM must be running with the same user ID as the user ID running jconsole. See JMX Monitoring and Management for details.

host:port Name of the host system on which the Java VM is running and the port number specified by the system property com.sun.management.jmxremote.port when the Java VM was started. See JMX Monitoring and Management for details.

jmxUrl Address of the JMX agent to be connected to as described in JMXServiceURL.

DESCRIPTION

The jconsole command launches a graphical console tool that enables you to monitor and manage Java applications and virtual machines on a local or remote machine.

On Windows, jconsole does not associate with a console window. It will, however, display a dialog box with error information if the jconsole command fails for some reason.

OPTIONS

-interval=n
Set the update interval to n seconds (default is 4 seconds).
-notile
Do not tile windows initially (for two or more connections).
-pluginpath plugins
Specify a list of directories or JAR files which are searched for JConsole plugins. The plugins path should contain a provider-configuration file named:
   META-INF/services/com.sun.tools.jconsole.JConsolePlugin

containing one line for each plugin specifying the fully qualified class name of the class implementing the com.sun.tools.jconsole.JConsolePlugin class.

-version
Output version information and exit.
-help
Output help message and exit.
-J<flag>
Pass <flag> to the Java virtual machine on which jconsole is run.

SEE ALSO

  • Using JConsole
  • Monitoring and Management for Java Platform

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jhat - Java Heap Analysis Tool

  • Synopsis
  • Parameters
  • Description
  • Options
  • See Also

SYNOPSIS

jhat [ options ] <heap-dump-file>

PARAMETERS

options
Options, if used, should follow immediately after the command name.

heap-dump-file
Java binary heap dump file to be browsed. For a dump file that contains multiple heap dumps, you may specify which dump in the file by appending "#<number> to the file name, i.e. "foo.hprof#3".

DESCRIPTION

The jhat command parses a java heap dump file and launches a webserver. jhat enables you to browse heap dumps using your favorite webbrowser. jhat supports pre-designed queries (such as 'show all instances of a known class "Foo"') as well as OQL (Object Query Language) - a SQL-like query language to query heap dumps. Help on OQL is available from the OQL help page shown by jhat. With the default port, OQL help is available at http://localhost:7000/oqlhelp/

There are several ways to generate a java heap dump:

  • Use jmap -dump option to obtain a heap dump at runtime;
  • Use jconsole option to obtain a heap dump via HotSpotDiagnosticMXBean at runtime;
  • Heap dump will be generated when OutOfMemoryError is thrown by specifying -XX:+HeapDumpOnOutOfMemoryError VM option;
  • Use hprof.

NOTE: This tool is experimental and may not be available in future versions of the JDK.

OPTIONS

-stack false/true
Turn off tracking object allocation call stack. Note that if allocation site information is not available in the heap dump, you have to set this flag to false. Default is true.
-refs false/true
Turn off tracking of references to objects. Default is true. By default, back pointers (objects pointing to a given object a.k.a referrers or in-coming references) are calculated for all objects in the heap.
-port port-number
Set the port for the jhat's HTTP server. Default is 7000.
-exclude exclude-file
Specify a file that lists data members that should be excluded from the "reachable objects" query. For example, if the file lists java.lang.String.value, then, whenever list of objects reachable from a specific object "o" are calculated, reference paths involving java.lang.String.value field will not considered.
-baseline baseline-dump-file
Specify a baseline heap dump. Objects in both heap dumps with the same object ID will be marked as not being "new". Other objects will be marked as "new". This is useful while comparing two different heap dumps.
-debug int
Set debug level for this tool. 0 means no debug output. Set higher values for more verbose modes.
-version
Report version number and exit.
-h
Output help message and exit.
-help
Output help message and exit.
-J<flag>
Pass <flag> to the Java virtual machine on which jhat is run. For example, -J-Xmx512m to use a maximum heap size of 512MB.

SEE ALSO

  • jmap - Java Memory Map
  • jconsole - Java Monitoring and Management Console
  • hprof - Heap and CPU profiling tool

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jinfo - Configuration Info

  • Synopsis
  • Parameters
  • Description
  • Options
  • See Also

SYNOPSIS

jinfo [ option ] pid
jinfo [ option ] executable core
jinfo [ option ] [server-id@]remote-hostname-or-IP

PARAMETERS

option
Options are mutually exclusive. Option, if used, should follow immediately after the command name.

pid
process id for which the configuration info is to be printed. The process must be a Java process. To get a list of Java processes running on a machine, jps may be used.
executable
Java executable from which the core dump was produced.
core
core file for which the configuration info is to be printed.
remote-hostname-or-IP
remote debug server's (see jsadebugd) hostname or IP address.
server-id
optional unique id, if multiple debug servers are running on the same remote host.

DESCRIPTION

jinfo prints Java configuration information for a given Java process or core file or a remote debug server. Configuration information includes Java System properties and Java virtual machine command line flags. If the given process is running on a 64-bit VM, you may need to specify the -J-d64 option, e.g.:

jinfo -J-d64 -sysprops pid

NOTE - This utility is unsupported and may or may not be available in future versions of the JDK. On Windows, jinfo only supports the -flag option of a running process.

OPTIONS

<no option>
prints both command line flags as well as System properties name, value pairs.
-flag name
prints the name and value of the given command line flag.
-flag [+|-]name
enables or disables the given boolean command line flag.
-flag name=value
sets the given command line flag to the specified value.
-flags
prints command line flags passed to the JVM. pairs.
-sysprops
prints Java System properties as name, value pairs.
-h
prints a help message
-help
prints a help message

SEE ALSO

  • jps
  • jsadebugd

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jmap - Memory Map

  • Synopsis
  • Parameters
  • Description
  • Options
  • See Also

SYNOPSIS

jmap [ option ] pid
jmap [ option ] executable core
jmap [ option ] [server-id@]remote-hostname-or-IP

PARAMETERS

option
Options are mutually exclusive. Option, if used, should follow immediately after the command name.
pid
process id for which the memory map is to be printed. The process must be a Java process. To get a list of Java processes running on a machine, jps may be used.

executable
Java executable from which the core dump was produced.

core
core file for which the memory map is to be printed.

remote-hostname-or-IP
remote debug server's (see jsadebugd) hostname or IP address.

server-id
optional unique id, if multiple debug servers are running on the same remote host.

DESCRIPTION

jmap prints shared object memory maps or heap memory details of a given process or core file or a remote debug server. If the given process is running on a 64-bit VM, you may need to specify the -J-d64 option, e.g.:

jmap -J-d64 -heap pid
NOTE - This utility is unsupported and may or may not be available in future versions of the JDK.
The only forms of jmap available on the Windows platform are
jmap -dump:<dump-options> pid
and
jmap -histo[:live] pid

OPTIONS

<no option>
When no option is used jmap prints shared object mappings. For each shared object loaded in the target VM, start address, the size of the mapping, and the full path of the shared object file are printed. This is similar to the Solaris pmap utility.

-dump:[live,]format=b,file=<filename>
Dumps the Java heap in hprof binary format to filename. The live suboption is optional. If specified, only the live objects in the heap are dumped. To browse the heap dump, you can use jhat (Java Heap Analysis Tool) to read the generated file.

-finalizerinfo
Prints information on objects awaiting finalization.

-heap
Prints a heap summary. GC algorithm used, heap configuration and generation wise heap usage are printed.

-histo[:live]
Prints a histogram of the heap. For each Java class, number of objects, memory size in bytes, and fully qualified class names are printed. VM internal class names are printed with '*' prefix. If the live suboption is specified, only live objects are counted.

-permstat
Prints class loader wise statistics of permanent generation of Java heap. For each class loader, its name, liveness, address, parent class loader, and the number and size of classes it has loaded are printed. In addition, the number and size of interned Strings are printed.

-F
Force. Use with jmap -dump or jmap -histo option if the pid does not respond. The live suboption is not supported in this mode.

-h
Prints a help message.

-help
Prints a help message.

-J<flag>
Passes <flag> to the Java virtual machine on which jmap is run.

SEE ALSO

  • pmap(1)
  • jhat
  • jps
  • jsadebugd

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jps - Java Virtual Machine Process Status Tool

  • Synopsis
  • Parameters
  • Description
  • Options
  • Host Identifier
  • Output Format
  • Examples
  • See Also

SYNOPSIS

jps [ options ] [ hostid ]

PARAMETERS

options
Command-line options.
hostid
The host identifier of the host for which the process report should be generated. The hostid may include optional components that indicate the communications protocol, port number, and other implementation specific data.

DESCRIPTION

The jps tool lists the instrumented HotSpot Java Virtual Machines (JVMs) on the target system. The tool is limited to reporting information on JVMs for which it has the access permissions.

If jps is run without specifying a hostid, it will look for instrumented JVMs on the local host. If started with a hostid, it will look for JVMs on the indicated host, using the specified protocol and port. A jstatd process is assumed to be running on the target host.

The jps command will report the local VM identifier, or lvmid, for each instrumented JVM found on the target system. The lvmid is typically, but not necessarily, the operating system's process identifier for the JVM process. With no options, jps will list each Java application's lvmid followed by the short form of the application's class name or jar file name. The short form of the class name or JAR file name omits the class's package information or the JAR files path information.

The jps command uses the java launcher to find the class name and arguments passed to the main method. If the target JVM is started with a custom launcher, the class name (or JAR file name) and the arguments to the main method will not be available. In this case, the jps command will output the string Unknown for the class name or JAR file name and for the arguments to the main method.

The list of JVMs produced by the jps command may be limited by the permissions granted to the principal running the command. The command will only list the JVMs for which the principle has access rights as determined by operating system specific access control mechanisms.

NOTE: This utility is unsupported and may not be available in future versions of the JDK. It is not currently available on Windows 98 and Windows ME platforms.

OPTIONS

The jps command supports a number of options that modify the output of the command. These options are subject to change or removal in the future.

-q
Suppress the output of the class name, JAR file name, and arguments passed to the main method, producing only a list of local VM identifiers.
-m
Output the arguments passed to the main method. The output may be null for embedded JVMs.
-l
Output the full package name for the application's main class or the full path name to the application's JAR file.
-v
Output the arguments passed to the JVM.
-V
Output the arguments passed to the JVM through the flags file (the .hotspotrc file or the file specified by the -XX:Flags=<filename> argument).
-J option
Pass option to the java launcher called by jps. For example, -J-Xms48m sets the startup memory to 48 megabytes. It is a common convention for -J to pass options to the underlying VM executing applications written in Java.

HOST IDENTIFIER

The host identifier, or hostid is a string that indicates the target system. The syntax of the hostid string largely corresponds to the syntax of a URI:

[protocol:][[//]hostname][:port][/servername]
protocol
The communications protocol. If the protocol is omitted and a hostname is not specified, the default protocol is a platform specific, optimized, local protocol. If the protocol is omitted and a hostname is specified, then the default protocol is rmi.
hostname
A hostname or IP address indicating the target host. If hostname is omitted, then the target host is the local host.
port
The default port for communicating with the remote server. If the hostname is omitted or the protocol specifies an optimized, local protocol, then port is ignored. Otherwise, treatment of the port parameter is implementation specific. For the default rmi protocol the port indicates the port number for the rmiregistry on the remote host. If port is omitted, and protocol indicates rmi, then the default rmiregistry port (1099) is used.
servername
The treatment of this parameter depends on the implementation. For the optimized, local protocol, this field is ignored. For the rmi protocol, this parameter is a string representing the name of the RMI remote object on the remote host. See the -n option for the jstatd command.

OUTPUT FORMAT

The output of the jps command follows the following pattern:

lvmid [ [ classname | JARfilename | "Unknown"] [ arg* ] [ jvmarg* ] ]

Where all output tokens are separated by white space. An arg that includes embedded white space will introduce ambiguity when attempting to map arguments to their actual positional parameters.

NOTE: You are advised not to write scripts to parse jps output since the format may change in future releases. If you choose to write scripts that parse jps output, expect to modify them for future releases of this tool.

EXAMPLES

This section provides examples of the jps command.

Listing the instrumented JVMs on the local host:

jps

18027 Java2Demo.JAR

18032 jps

18005 jstat

Listing the instrumented JVMs on a remote host:

This example assumes that the jstat server and either the its internal RMI registry or a separate external rmiregistry process are running on the remote host on the default port (port 1099). It also assumes that the local host has appropriate permissions to access the remote host. This example also includes the -l option to output the long form of the class names or JAR file names.

jps -l remote.domain

3002 /opt/jdk1.5.0/demo/jfc/Java2D/Java2Demo.JAR

2857 sun.tools.jstatd.jstatd

Listing the instrumented JVMs on a remote host with a non-default port for the RMI registry

This example assumes that the jstatd server, with an internal RMI registry bound to port 2002, is running on the remote host. This example also uses the -m option to include the arguments passed to the main method of each of the listed Java applications.

jps -m remote.domain:2002

3002 /opt/jdk1.5.0/demo/jfc/Java2D/Java2Demo.JAR

3102 sun.tools.jstatd.jstatd -p 2002

SEE ALSO

  • java - the Java Application Launcher
  • jstat - the Java virtual machine Statistics Monitoring Tool
  • jstatd - the jstat daemon
  • rmiregistry - the Java Remote Object Registry

Copyright © 2003 - 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jrunscript - command line script shell

  • Synopsis
  • Parameters
  • Description
  • Options
  • Arguments
  • Examples
  • See Also

SYNOPSIS

jrunscript [ options ] [ arguments... ]

PARAMETERS

options
Options, if used, should follow immediately after the command name.
arguments
Arguments, if used, should follow immediately after options or command name.

DESCRIPTION

jrunscript is a command line script shell. jrunscript supports both an interactive (read-eval-print) mode and a batch (-f option) mode of script execution. This is a scripting language independent shell. By default, JavaScript is the language used, but the -l option can be used to specify a different language. Through Java to scripting language communication, jrunscript supports "exploratory programming" style.

NOTE: This tool is experimental and may not be available in future versions of the JDK.

OPTIONS

-classpath path
Specify where to find the user's .class files that are accessed by the script.
-cp path
This is a synonym for -classpath path
-D name=value
Set a Java system property.
-J<flag>
Pass <flag> directly to the Java virtual machine on which jrunscript is run.
-l language
Use the specified scripting language. By default, JavaScript is used. Note that to use other scripting languages, you also need to specify the corresponding script engine's jar file using -cp or -classpath option.
-e script
Evaluate the given script. This option can be used to run "one liner" scripts specified completely on the command line.
-encoding encoding
Specify the character encoding used while reading script files.
-f script-file
Evaluate the given script file (batch mode).
-f -
Read and evaluate a script from standard input (interactive mode).
-help
Output help message and exit.
-?
Output help message and exit.
-q
List all script engines available and exit.

ARGUMENTS

If [arguments...] are present and if no -e or -f option is used, then the first argument is the script file and the rest of the arguments, if any, are passed as script arguments. If [arguments..] and -e or -f option are used, then all [arguments..] are passed as script arguments. If [arguments..], -e and -f are missing, interactive mode is used. Script arguments are available to a script in an engine variable named "arguments" of type String array.

EXAMPLES

Executing inline scripts

jrunscript -e "print('hello world')"
jrunscript -e "cat('http://java.sun.com')"

Use specified language and evaluate given script file

jrunscript -l js -f test.js

Interactive mode

jrunscript
js>print('hello world');
hello world
js>34 + 55
89
js> thread(function() { print('hello world'); }
hello world
js>

Run script file with script arguments

jrunscript test.js arg1 arg2 arg3
test.js is script file to execute and arg1, arg2 and arg3 are passed to script as script arguments. Script can access these using "arguments" array.

SEE ALSO

If JavaScript is used, then before evaluating any user defined script, jrunscript initializes certain built-in functions and objects. These JavaScript built-ins are documented in jsdocs.

    Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

             Sun
    Java Software


jsadebugd - Serviceability Agent Debug Daemon

  • Synopsis
  • Parameters
  • Description
  • See Also

SYNOPSIS

jsadebugd pid [ server-id ]
jsadebugd executable core [ server-id ]

PARAMETERS

pid
process id of the process to which the debug server should attach. The process must be a Java process. To get a list of Java processes running on a machine, jps may be used. At most one instance of the debug server may be attached to a single process.
executable
Java executable from which the core dump was produced
core
Core file to which the debug server should attach.
server-id
Optional unique id, needed if multiple debug servers are started on the same machine. This ID must be used by remote clients to identify the particular debug server to attach. Within a single machine, this ID must be unique.

DESCRIPTION

jsadebugd attaches to a Java process or core file and acts as a debug server. Remote clients such as jstack, jmap, and jinfo can attach to the server using Java Remote Method Invocation (RMI). Before starting jsadebugd, rmiregistry must be started with:

rmiregistry -J-Xbootclasspath/p:$JAVA_HOME/lib/sajdi.jar

where $JAVA_HOME is the JDK installation directory. If rmiregistry was not started, jsadebugd will start an rmiregistry in a standard (1099) port internally. Debug server may be stopped by sending SIGINT (pressing Ctrl-C) to it.

NOTE - This utility is unsupported and may or may not be available in future versions of the JDK. jsadebugd is not currently available on Windows platforms.

SEE ALSO

  • jinfo
  • jmap
  • jps
  • jstack
  • rmiregistry

Copyright © 2004 - 2006Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jstack - Stack Trace

  • Synopsis
  • Parameters
  • Description
  • Options
  • See Also
  • Known Bugs

SYNOPSIS

jstack [ option ] pid
jstack [ option ] executable core
jstack [ option ] [server-id@]remote-hostname-or-IP

PARAMETERS

Options are mutually exclusive. Option, if used, should follow immediately after the command name. See OPTIONS.

pid
process id for which the stack trace is to be printed. The process must be a Java process. To get a list of Java processes running on a machine, jps may be used.
executable
Java executable from which the core dump was produced.

core
core file for which the stack trace is to be printed.

remote-hostname-or-IP
remote debug server's (see jsadebugd) hostname or IP address.

server-id
optional unique id, if multiple debug servers are running on the same remote host.

DESCRIPTION

jstack prints Java stack traces of Java threads for a given Java process or core file or a remote debug server. For each Java frame, the full class name, method name, 'bci' (byte code index) and line number, if available, are printed. With the -m option, jstack prints both Java and native frames of all threads along with the 'pc' (program counter). For each native frame, the closest native symbol to 'pc', if available, is printed. C++ mangled names are not demangled. To demangle C++ names, the output of this command may be piped to c++filt. If the given process is running on a 64-bit VM, you may need to specify the -J-d64 option, e.g.:

jstack -J-d64 -m pid

NOTE - This utility is unsupported and may or may not be available in future versions of the JDK. The only form of jstack that is available on Windows platforms is

    jstack [-l] pid

OPTIONS

-F
Force a stack dump when 'jstack [-l] pid' does not respond.
-l
Long listing. Prints additional information about locks such as list of owned java.util.concurrent ownable synchronizers.
-m
prints mixed mode (both Java and native C/C++ frames) stack trace.
-h
prints a help message.

-help
prints a help message

SEE ALSO

  • pstack(1)
  • c++filt(1)
  • jps
  • jsadebugd

KNOWN BUGS

Mixed mode stack trace, the -m option, does not work with the remote debug server.

Copyright © 2004 - 2006Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jstat - Java Virtual Machine Statistics Monitoring Tool

  • Synopsis
  • Parameters
  • Description
  • Virtual Machine Identifier
  • Options
    - General Options
    - Output Options
  • Examples
  • See Also

SYNOPSIS

jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]

PARAMETERS

generalOption
A single general command-line option (-help, -options, or -version)
outputOptions
One or more output options, consisting of a single statOption, plus any of the -t, -h, and -J options.
vmid
Virtual machine identifier, a string indicating the target Java virtual machine (JVM). The general syntax is
[protocol:][//]lvmid[@hostname[:port]/servername]
The syntax of the vmid string largely corresponds to the syntax of a URI. The vmid can vary from a simple integer representing a local JVM to a more complex construction specifying a communications protocol, port number, and other implementation-specific values. See Virtual Machine Identifier for details.
interval[s|ms]
Sampling interval in the specified units, seconds (s) or milliseconds (ms). Default units are milliseconds. Must be a positive integer. If specified, jstat will produce its output at each interval.
count
Number of samples to display. Default value is infinity; that is, jstat displays statistics until the target JVM terminates or the jstat command is terminated. Must be a positive integer.

DESCRIPTION

The jstat tool displays performance statistics for an instrumented HotSpot Java virtual machine (JVM). The target JVM is identified by its virtual machine identifier, or vmid option described below.

NOTE: This utility is unsupported and may not be available in future versions of the JDK. It is not currently available on Windows 98 and Windows ME. platforms.

VIRTUAL MACHINE IDENTIFIER

The syntax of the vmid string largely corresponds to the syntax of a URI:

[protocol:][//]lvmid[@hostname][:port][/servername]
protocol
The communications protocol. If the protocol is omitted and a hostname is not specified, the default protocol is a platform specific optimized local protocol. If the protocol is omitted and a hostname is specified, then the default protocol is rmi.
lvmid
The local virtual machine identifier for the target JVM. The lvmid is a platform-specific value that uniquely identifies a JVM on a system. The lvmid is the only required component of a virtual machine identifier. The lvmid is typically, but not necessarily, the operating system's process identifier for the target JVM process. You can use the jps command to determine the lvmid. Also, you can determine lvmid on Unix platforms with the ps command, and on Windows with the Windows Task Manager.
hostname
A hostname or IP address indicating the target host. If hostname is omitted, then the target host is the local host.
port
The default port for communicating with the remote server. If the hostname is omitted or the protocol specifies an optimized, local protocol, then port is ignored. Otherwise, treatment of the port parameter is implementation specific. For the default rmi protocol, the port indicates the port number for the rmiregistry on the remote host. If port is omitted, and protocol indicates rmi, then the default rmiregistry port (1099) is used.
servername
The treatment of this parameter depends on implementation. For the optimized local protocol, this field is ignored. For the rmi protocol, it represents the name of the RMI remote object on the remote host.

OPTIONS

The jstat command supports two types of options, general options and output options. General options cause jstat to display simple usage and version information. Output options determine the content and format of the statistical output.

NOTE: All options, and their functionality are subject to change or removal in future releases.

GENERAL OPTIONS

If you specify one of the general options, you cannot specify any other option or parameter.

-help
Display help message.
-version
Display version information.
-options
Display list of statistics options. See the Output Options section below.

OUTPUT OPTIONS

If you do not specify a general option, then you can specify output options. Output options determine the content and format of jstat's output, and consist of a single statOption, plus any of the other output options (-h, -t, and -J). The statOption must come first.

Output is formatted as a table, with columns are separated by spaces. A header row with titles describes the columns. Use the -h option to set the frequency at which the header is displayed. Column header names are generally consistent between the different options. In general, if two options provide a column with the same name, then the data source for the two columns are the same.

Use the -t option to display a time stamp column, labeled Timestamp as the first column of output. The Timestamp column contains the elapsed time, in seconds, since startup of the target JVM. The resolution of the time stamp is dependent on various factors and is subject to variation due to delayed thread scheduling on heavily loaded systems.

Use the interval and count parameters to determine how frequently and how many times, respectively, jstat displays its output.

NOTE: You are advised not to write scripts to parse jstat's output since the format may change in future releases. If you choose to write scripts that parse jstat output, expect to modify them for future releases of this tool.

-statOption
Determines the statistics information that jstat displays. The following table lists the available options. Use the -options general option to display the list of options for a particular platform installation.

Option | Displays...
class | Statistics on the behavior of the class loader.
compiler | Statistics of the behavior of the HotSpot Just-in-Time compiler.
gc | Statistics of the behavior of the garbage collected heap.
gccapacity | Statistics of the capacities of the generations and their corresponding spaces.
gccause | Summary of garbage collection statistics (same as -gcutil), with the cause of the last and current (if applicable) garbage collection events.
gcnew | Statistics of the behavior of the new generation.
gcnewcapacity | Statistics of the sizes of the new generations and its corresponding spaces.
gcold | Statistics of the behavior of the old and permanent generations.
gcoldcapacity | Statistics of the sizes of the old generation.
gcpermcapacity | Statistics of the sizes of the permanent generation.
gcutil | Summary of garbage collection statistics.
printcompilation | HotSpot compilation method statistics.
-h n
Display a column header every n samples (output rows), where n is a positive integer. Default value is 0, which displays the column header above the first row of data.
-t n
Display a timestamp column as the first column of output. The timestamp is the the time since the start time of the target JVM.
-J javaOption
Pass javaOption to the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes. For a complete list of options, see java - the Java application launcher

STATOPTIONS AND OUTPUT

The following tables summarize the columns that jstat outputs for each statOption.

-class Option

Class Loader Statistics
Column | Description
Loaded | Number of classes loaded.
Bytes | Number of Kbytes loaded.
Unloaded | Number of classes unloaded.
Bytes | Number of Kbytes unloaded.
Time | Time spent performing class load and unload operations.

-compiler Option

HotSpot Just-In-Time Compiler Statistics
Column | Description
Compiled | Number of compilation tasks performed.
Failed | Number of compilation tasks that failed.
Invalid | Number of compilation tasks that were invalidated.
Time | Time spent performing compilation tasks.
FailedType | Compile type of the last failed compilation.
FailedMethod | Class name and method for the last failed compilation.

-gc Option

Garbage-collected heap statistics
Column | Description
S0C | Current survivor space 0 capacity (KB).
S1C | Current survivor space 1 capacity (KB).
S0U | Survivor space 0 utilization (KB).
S1U | Survivor space 1 utilization (KB).
EC | Current eden space capacity (KB).
EU | Eden space utilization (KB).
OC | Current old space capacity (KB).
OU | Old space utilization (KB).
PC | Current permanent space capacity (KB).
PU | Permanent space utilization (KB).
YGC | Number of young generation GC Events.
YGCT | Young generation garbage collection time.
FGC | Number of full GC events.
FGCT | Full garbage collection time.
GCT | Total garbage collection time.

-gccapacity Option

Memory Pool Generation and Space Capacities
Column | Description
NGCMN | Minimum new generation capacity (KB).
NGCMX | Maximum new generation capacity (KB).
NGC | Current new generation capacity (KB).
S0C | Current survivor space 0 capacity (KB).
S1C | Current survivor space 1 capacity (KB).
EC | Current eden space capacity (KB).
OGCMN | Minimum old generation capacity (KB).
OGCMX | Maximum old generation capacity (KB).
OGC | Current old generation capacity (KB).
OC | Current old space capacity (KB).
PGCMN | Minimum permanent generation capacity (KB).
PGCMX | Maximum Permanent generation capacity (KB).
PGC | Current Permanent generation capacity (KB).
PC | Current Permanent space capacity (KB).
YGC | Number of Young generation GC Events.
FGC | Number of Full GC Events.

-gccause Option

This option displays the same summary of garbage collection statistics as the -gcutil option, but includes the causes of the last garbage collection event and (if applicable) the current garbage collection event. In addition to the columns listed for -gcutil, this option adds the following columns:

Garbage Collection Statistics, Including GC Events
Column Description
LGCC Cause of last Garbage Collection.
GCC Cause of current Garbage Collection.

-gcnew Option

New Generation Statistics
Column | Description
S0C | Current survivor space 0 capacity (KB).
S1C | Current survivor space 1 capacity (KB).
S0U | Survivor space 0 utilization (KB).
S1U | Survivor space 1 utilization (KB).
TT | Tenuring threshold.
MTT | Maximum tenuring threshold.
DSS | Desired survivor size (KB).
EC | Current eden space capacity (KB).
EU | Eden space utilization (KB).
YGC | Number of young generation GC events.
YGCT | Young generation garbage collection time.

-gcnewcapacity Option

New Generation Space Size Statistics
Column | Description
NGCMN
Minimum new generation capacity (KB).
NGCMX | Maximum new generation capacity (KB).
NGC | Current new generation capacity (KB).
S0CMX | Maximum survivor space 0 capacity (KB).
S0C | Current survivor space 0 capacity (KB).
S1CMX | Maximum survivor space 1 capacity (KB).
S1C | Current survivor space 1 capacity (KB).
ECMX | Maximum eden space capacity (KB).
EC | Current eden space capacity (KB).
YGC | Number of young generation GC events.
FGC | Number of Full GC Events.

-gcold Option

Old and Permanent Generation Statistics
Column | Description
PC | Current permanent space capacity (KB).
PU | Permanent space utilization (KB).
OC | Current old space capacity (KB).
OU | old space utilization (KB).
YGC | Number of young generation GC events.
FGC | Number of full GC events.
FGCT | Full garbage collection time.
GCT | Total garbage collection time.

-gcoldcapacity Option

Old Generation Statistics
Column | Description
OGCMN | Minimum old generation capacity (KB).
OGCMX | Maximum old generation capacity (KB).
OGC | Current old generation capacity (KB).
OC | Current old space capacity (KB).
YGC | Number of young generation GC events.
FGC | Number of full GC events.
FGCT | Full garbage collection time.
GCT | Total garbage collection time.

-gcpermcapacity Option

Permanent Generation Statistics
Column | Description
PGCMN | Minimum permanent generation capacity (KB).
PGCMX | Maximum permanent generation capacity (KB).
PGC | Current permanent generation capacity (KB).
PC | Current permanent space capacity (KB).
YGC | Number of young generation GC events.
FGC | Number of full GC events.
FGCT | Full garbage collection time.
GCT | Total garbage collection time.

-gcutil Option

Summary of Garbage Collection Statistics
Column | Description
S0 | Survivor space 0 utilization as a percentage of the space's current capacity.
S1 | Survivor space 1 utilization as a percentage of the space's current capacity.
E | Eden space utilization as a percentage of the space's current capacity.
O | Old space utilization as a percentage of the space's current capacity.
P | Permanent space utilization as a percentage of the space's current capacity.
YGC | Number of young generation GC events.
YGCT | Young generation garbage collection time.
FGC | Number of full GC events.
FGCT | Full garbage collection time.
GCT | Total garbage collection time.

-printcompilation Option

HotSpot Compiler Method Statistics
Column | Description
Compiled | Number of compilation tasks performed.
Size | Number of bytes of bytecode for the method.
Type | Compilation type.
Method | Class name and method name identifying the compiled method. Class name uses "/" instead of "." as namespace separator. Method name is the method within the given class. The format for these two fields is consistent with the HotSpot - XX:+PrintComplation option.

This section presents some examples of monitoring a local JVM with a lvmid of 21891.

Using the gcutil option

This example attaches to lvmid 21891 and takes 7 samples at 250 millisecond intervals and displays the output as specified by the -gcutil option.

jstat -gcutil 21891 250 7

  S0     S1     E      O      P     YGC    YGCT    FGC    FGCT     GCT

 12.44   0.00  27.20   9.49  96.70    78    0.176     5    0.495    0.672

 12.44   0.00  62.16   9.49  96.70    78    0.176     5    0.495    0.672

 12.44   0.00  83.97   9.49  96.70    78    0.176     5    0.495    0.672

  0.00   7.74   0.00   9.51  96.70    79    0.177     5    0.495    0.673

  0.00   7.74  23.37   9.51  96.70    79    0.177     5    0.495    0.673

  0.00   7.74  43.82   9.51  96.70    79    0.177     5    0.495    0.673

  0.00   7.74  58.11   9.51  96.71    79    0.177     5    0.495    0.673

The output of this example shows that a young generation collection occurred between the 3rd and 4th sample. The collection took 0.001 seconds and promoted objects from the eden space (E) to the old space (O), resulting in an increase of old space utilization from 9.49% to 9.51%. Before the collection, the survivor space was 12.44% utilized, but after this collection it is only 7.74% utilized.

Repeating the column header string

This example attaches to lvmid 21891 and takes samples at 250 millisecond intervals and displays the output as specified by -gcutil option. In addition, it uses the -h3 option to output the column header after every 3 lines of data.

jstat -gcnew -h3 21891 250

 S0C    S1C    S0U    S1U   TT MTT  DSS      EC       EU     YGC     YGCT

  64.0   64.0    0.0   31.7 31  31   32.0    512.0    178.6    249    0.203

  64.0   64.0    0.0   31.7 31  31   32.0    512.0    355.5    249    0.203

  64.0   64.0   35.4    0.0  2  31   32.0    512.0     21.9    250    0.204

 S0C    S1C    S0U    S1U   TT MTT  DSS      EC       EU     YGC     YGCT

  64.0   64.0   35.4    0.0  2  31   32.0    512.0    245.9    250    0.204

  64.0   64.0   35.4    0.0  2  31   32.0    512.0    421.1    250    0.204

  64.0   64.0    0.0   19.0 31  31   32.0    512.0     84.4    251    0.204

 S0C    S1C    S0U    S1U   TT MTT  DSS      EC       EU     YGC     YGCT

  64.0   64.0    0.0   19.0 31  31   32.0    512.0    306.7    251    0.204

In addition to showing the repeating header string, this example shows that between the 2nd and 3rd samples, a young GC occurred. Its duration was 0.001 seconds. The collection found enough live data that the survivor space 0 utilization (S0U) would would have exceeded the desired survivor Size (DSS). As a result, objects were promoted to the old generation (not visible in this output), and the tenuring threshold (TT) was lowered from 31 to 2.

Another collection occurs between the 5th and 6th samples. This collection found very few survivors and returned the tenuring threshold to 31.

Including a time stamp for each sample

This example attaches to lvmid 21891 and takes 3 samples at 250 millisecond intervals. The -t option is used to generate a time stamp for each sample in the first column.

jstat -gcoldcapacity -t 21891 250 3

Timestamp          OGCMN        OGCMX         OGC           OC       YGC   FGC    FGCT    GCT

          150.1       1408.0      60544.0      11696.0      11696.0   194    80    2.874   3.799

          150.4       1408.0      60544.0      13820.0      13820.0   194    81    2.938   3.863

          150.7       1408.0      60544.0      13820.0      13820.0   194    81    2.938   3.863

The Timestamp column reports the elapsed time in seconds since the start of the target JVM. In addition, the -gcoldcapacity output shows the old generation capacity (OGC) and the old space capacity (OC) increasing as the heap expands to meet allocation and/or promotion demands. The old generation capacity (OGC) has grown to from 11696 KB to 13820 KB after the 81st Full GC (FGC). The maximum capacity of the generation (and space) is 60544 KB (OGCMX), so it still has room to expand.

Monitor instrumentation for a remote JVM

This example attaches to lvmid 40496 on the system named remote.domain using the -gcutil option, with samples taken every second indefinitely.

jstat -gcutil 40496@remote.domain 1000

... output omitted

The lvmid is combined with the name of the remote host to construct a vmid of 40496@remote.domain. This vmid results in the use of the rmi protocol to communicate to the default jstatd server on the remote host. The jstatd server is located using the rmiregistry on remote.domain that is bound to the default rmiregistry port (port 1099).

SEE ALSO

  • java - the Java Application Launcher
  • jps - the Java Process Status Application
  • jstatd - the jvmstat daemon
  • rmiregistry - the Java Remote Object Registry

Copyright © 2003 - 2006Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jstatd - Virtual Machine jstat Daemon

  • Synopsis
  • Parameters
  • Description
  • Options
  • Security
  • Remote Interface
  • Examples
  • See Also

SYNOPSIS

jstatd [ options ]

PARAMETERS

options
Command-line options. The options may be in any order. If there are redundant or contradictory options, the last option specified will take precedence.

DESCRIPTION

The jstatd tool is an RMI server application that monitors for the creation and termination of instrumented HotSpot Java virtual machines (JVMs) and provides a interface to allow remote monitoring tools to attach to JVMs running on the local host.

The jstatd server requires the presence of an RMI registry on the local host. The jstatd server will attempt to attach to the RMI registry on the default port, or on the port indicated by the -p port option. If an RMI registry is not found, one will be created within the jstatd application bound to the port indicated by the -p port option or to the default RMI registry port if -p port is omitted. Creation of an internal RMI registry can be inhibited by specifying the -nr option.

NOTE: This utility is unsupported and may or may not be available in future versions of the JDK. It is not currently available on the Windows 98 and Windows ME platforms.

OPTIONS

The jstatd command supports the following options:

-nr
Do not attempt to create an internal RMI registry within the jstatd process when an existing RMI registry is not found.
-p port
Port number where the RMI registry is expected to be found, or, if not found, created if -nr is not specified.
-n rminame
Name to which the remote RMI object is bound in the RMI registry. The default name is JStatRemoteHost. If multiple jstatd servers are started on the same host, the name of the exported RMI object for each server can be made unique by by specifying this option. However, doing so will require that the unique server name be included in the monitoring client's hostid and vmid strings.
-J option
Pass option to the java launcher called by javac. For example, -J-Xms48m sets the startup memory to 48 megabytes. It is a common convention for -J to pass options to the underlying VM executing applications written in Java.

SECURITY

The jstatd server can only monitor JVMs for which it has the appropriate native access permissions. Therefor the jstatd process must be running with the same user credentials as the target JVMs. Some user credentials, such as the root user in UNIX(TM) based systems, have permission to access the instrumentation exported by any JVM on the system. A jstatd process running with such credentials can monitor any JVM on the system, but introduces additional security concerns.

The jstatd server does not provide any authentication of remote clients. Therefore, running a jstatd server process exposes the instrumentation export by all JVMs for which the jstatd process has access permissions to any user on the network. This exposure may be undesireable in your environment and local security policies should be considered before starting the jstatd process, particularly in production environments or on unsecure networks.

The jstatd server installs an instance of RMISecurityPolicy if no other security manager has been installed and therefore requires a security policy file to be specified. The policy file must conform to the default policy implementation's Policy File Syntax.

The following policy file will allow the jstatd server to run without any security exceptions. This policy is less liberal then granting all permissions to all codebases, but is more liberal than a policy that grants the minimal permissions to run the jstatd server.

grant codebase "file:${java.home}/../lib/tools.jar" {

   permission java.security.AllPermission;

};

To use this policy, copy the text into a file called jstatd.all.policy and run the jstatd server as follows:

jstatd -J-Djava.security.policy=jstatd.all.policy

For sites with more restrictive security practices, it is possible to use a custom policy file to limit access to specific trusted hosts or networks, though such techniques are subject to IP addreess spoofing attacks. If your security concerns cannot be addressed with a customized policy file, then the safest action is to not run the jstatd server and use the jstat and jps tools locally.

REMOTE INTERFACE

The interface exported by the jstatd process is proprietary and is guaranteed to change. Users and developers are discouraged from writing to this interface.

EXAMPLES

Here are some examples of starting jstatd. Note that the jstatd scripts automatically start the server in the background.

Using Internal RMI Registry

This example demonstrates starting jstatd with an internal RMI registry. This example assumes that no other server is bound to the default RMI Registry port (port 1099).

jstatd -J-Djava.security.policy=all.policy

Using External RMI Registry

This example demonstrates starting jstatd with a external RMI registry.

rmiregistry&
jstatd -J-Djava.security.policy=all.policy

This example demonstrates starting jstatd with an external RMI registry server on port 2020.

rmiregistry 2020&
jstatd -J-Djava.security.policy=all.policy -p 2020

This example demonstrates starting jstatd with an external RMI registry on port 2020, bound to name AlternateJstatdServerName.

rmiregistry 2020&
jstatd -J-Djava.security.policy=all.policy -p 2020 -n AlternateJstatdServerName

Inhibiting creation of an in-process RMI registry

This example demonstrates starting jstatd such that it will not create a RMI registry if one is not found. This example assumes an RMI registry is already running. If it is not, an appropriate error message is emitted.

jstatd -J-Djava.security.policy=all.policy -nr

Enabling RMI logging capabilities.

This example demonstrates starting jstatd with RMI logging capabilities enabled. This technique is useful as a troubleshooting aid or for monitoring server activities.

jstatd -J-Djava.security.policy=all.policy -J-Djava.rmi.server.logCalls=true

SEE ALSO

  • java - the Java Application Launcher
  • jps - the Java Process Status Application
  • jstat - the Java Virtual Machine Statistics Monitoring Tool
  • rmiregistry - the Java Remote Object Registry

Copyright © 2003 - 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


orbd - The Object Request Broker Daemon

orbd is used to enable clients to transparently locate and invoke persistent objects on servers in the CORBA environment.

See also: Naming Service

SYNOPSIS

orbd <options>

DESCRIPTION

The Server Manager included with the orbd tool is used to enable clients to transparently locate and invoke persistent objects on servers in the CORBA environment. The persistent servers, while publishing the persistent object references in the Naming Service, include the port number of the ORBD in the object reference instead of the port number of the Server. The inclusion of an ORBD port number in the object reference for persistent object references has the following advantages:

  • The object reference in the Naming Service remains independent of the server life cycle. For example, the object reference could be published by the server in the Naming Service when it is first installed, and then, independent of how many times the server is started or shutdown, the ORBD will always return the correct object reference to the invoking client.
  • The client needs to lookup the object reference in the Naming Service only once, and can keep re-using this reference independent of the changes introduced due to server life cycle.

To access ORBD's Server Manager, the server must be started using servertool, which is a command-line interface for application programmers to register, unregister, startup, and shutdown a persistent server. For more information on the Server Manager, see the section in this document titled Server Manager.

When orbd starts up, it also starts a naming service. For more information on the naming service, link to Naming Service.

OPTIONS

Required Options

-ORBInitialPort nameserverport
Specifies the port on which the name server should be started. Once started, orbd will listen for incoming requests on this port. Note that when using Solaris software, you must become root to start a process on a port under 1024. For this reason, we recommend that you use a port number greater than or equal to 1024. (required)

OTHER OPTIONS

-port port
Specifies the activation port where ORBD should be started, and where ORBD will be accepting requests for persistent objects. The default value for this port is 1049. This port number is added to the port field of the persistent Interoperable Object References (IOR). (optional)
-defaultdb directory
Specifies the base where the ORBD persistent storage directory orb.db is created. If this option is not specified, the default value is "./orb.db". (optional)
-serverPollingTime milliseconds
Specifies how often ORBD checks for the health of persistent servers registered via servertool. The default value is 1,000 ms. The value specified for milliseconds must be a valid positive integer. (optional)
-serverStartupDelay milliseconds
Specifies how long ORBD waits before sending a location forward exception after a persistent server that is registered via servertool is restarted. The default value is 1,000 ms. The value specified for milliseconds must be a valid positive integer. (optional)
-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes. It is a common convention for -J to pass options to the underlying virtual machine.

Starting and Stopping the Naming Service

A Naming Service is a CORBA service that allows CORBA objects to be named by means of binding a name to an object reference. The name binding may be stored in the naming service, and a client may supply the name to obtain the desired object reference.

Prior to running a client or a server, you will start ORBD. ORBD includes a persistent Naming Service and a transient Naming Service, both of which are an implementation of the COS Naming Service.

The Persistent Naming Service provides persistence for naming contexts. This means that this information is persistent across service shutdowns and startups, and is recoverable in the event of a service failure. If ORBD is restarted, the Persistent Naming Service will restore the naming context graph, so that the binding of all clients' and servers' names remains intact (persistent).

For backward compatibility, tnameserv, a Transient Naming Service shipped with older versions of the JDK, is also included in this release of J2SE. A transient naming service retains naming contexts as long as it is running. If there is a service interruption, the naming context graph is lost.

The -ORBInitialPort argument is a required command-line argument for orbd, and is used to set the port number on which the Naming Service will run. The following instructions assume you can use port 1050 for the Java IDL Object Request Broker Daemon. When using Solaris software, you must become root to start a process on a port under 1024. For this reason, we recommend that you use a port number greater than or equal to 1024. You can substitute a different port if necessary.

To start orbd from a UNIX command shell, enter:

  orbd -ORBInitialPort 1050&

From an MS-DOS system prompt (Windows), enter:

  start orbd -ORBInitialPort 1050

Now that ORBD is running, you can run your server and client applications. When running the client and server applications, they must be made aware of the port number (and machine name, if applicable) where the Naming Service is running. One way to do this is to add the following code to your application:

        Properties props = new Properties();
        props.put("org.omg.CORBA.ORBInitialPort", "1050");
        props.put("org.omg.CORBA.ORBInitialHost", "MyHost");
        ORB orb = ORB.init(args, props);

In this example, the Naming Service is running on port 1050 on host "MyHost". Another way is to specify the port number and/or machine name when running the server or client application from the command line. For example, you would start your "HelloApplication" with the following command line:

     java HelloApplication -ORBInitialPort 1050 -ORBInitialHost MyHost

To stop the naming service, use the relevant operating system command, such as pkill orbd on Solaris, or Ctrl+C in the DOS window in which orbd is running. Note that names registered with the naming service may disappear when the service is terminated if the naming service is transient. The Java IDL naming service will run until it is explicitly stopped.

For more information on the Naming Service included with ORBD, see Naming Service.

Server Manager

To access ORBD's Server Manager and run a persistent server, the server must be started using servertool, which is a command-line interface for application programmers to register, unregister, startup, and shutdown a persistent server. When a server is started using servertool, it must be started on the same host and port on which orbd is executing. If the server is run on a different port, the information stored in the database for local contexts will be invalid and the service will not work properly.

Server Manager: an Example

Using the sample tutorial for our demonstration, you would run the idlj compiler and javac compiler as shown in the tutorial. To run the Server Manager, follow these steps for running the application:

Start orbd.

To start orbd from a UNIX command shell, enter:

  orbd -ORBInitialPort 1050

From an MS-DOS system prompt (Windows), enter:

  start orbd -ORBInitialPort 1050

Note that 1050 is the port on which you want the name server to run. -ORBInitialPort is a required command-line argument. When using Solaris software, you must become root to start a process on a port under 1024. For this reason, we recommend that you use a port number greater than or equal to 1024.

Start the servertool:

To start the Hello server, enter:

  servertool -ORBInitialPort 1050

Make sure the name server (orbd) port is the same as in the previous step, for example, -ORBInitialPort 1050. The servertool must be started on the same port as the name server.

The servertool command line interface appears.

Start the Hello server from the servertool prompt:

  servertool  > register -server HelloServer -classpath . -applicationName
                HelloServerApName

The servertool registers the server, assigns it the name of "HelloServerApName", and displays its server id, along with a listing of all registered servers.

Run the client application from another terminal window or prompt:

  java HelloClient -ORBInitialPort 1050 -ORBInitialHost localhost

For this example, you can omit -ORBInitialHost localhost since the name server is running on the same host as the Hello client. If the name server is running on a different host, use -ORBInitialHost nameserverhost to specify the host on which the IDL name server is running.

Specify the name server (orbd) port as done in the previous step, for example, -ORBInitialPort 1050.

When you have finished experimenting with the Server Manager, be sure to shut down or kill the name server (orbd) and servertool.

To shut down orbd from a DOS prompt, select the window that is running the server and enter Ctrl+C to shut it down. To shut down orbdfrom a Unix shell, find the process, and kill it. The server will continue to wait for invocations until it is explicitly stopped.

To shut down the servertool, type quit and press the Enter key on the keyboard.

See Also

  • Naming Service
  • servertool

Copyright © 2001-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


pack200 - JAR Packing tool

  • Synopsis
  • Description
  • Options
  • Exit Status
  • See Also
  • Notes

SYNOPSIS

pack200 [ options ] output-file JAR-file

Options may be in any order. The last option on the command line or in a properties file supersedes all previously specified options.

options
Command-line options.
output-file
Name of the output file.
JAR-file
Name of the input file.

DESCRIPTION

The pack200 tool is a Java application that transforms a JAR file into a compressed pack200 file using the Java gzip compressor. The pack200 files are highly compressed files that can be directly deployed, saving bandwidth and reducing download time.

The pack200 tool uses several options to fine-tune and set the compression engine.

Typical usage:

% pack200 myarchive.pack.gz myarchive.jar

In this example, myarchive.pack.gz is produced using the default pack200 settings.

OPTIONS

-r --repack

Produces a JAR file by packing the file myarchive.jar and unpacking it. The resulting file can be used as an input to the jarsigner(1) tool.

% pack200 --repack myarchive-packer.jar myarchive.jar

% pack200 --repack myarchive.jar

-g --no-gzip

Produces a pack200 file. With this option a suitable compressor must be used, and the target system must use a corresponding decompresser.

% pack200 --no-gzip myarchive.pack myarchive.jar

-G --strip-debug

Strips attributes used for debugging from the output. These include SourceFile, LineNumberTable, LocalVariableTable and LocalVariableTypeTable. Removing these attributes reduces the size of both downloads and installations but reduces the usefulness of debuggers.

-O --no-keep-file-order

The packer will reorder and transmit all elements. Additionally, the packer may remove JAR directory names. This will reduce the download size; however, certain JAR file optimizations, such as indexing, may not work correctly.

-Svalue --segment-limit=value

The value is the estimated target size N (in bytes) of each archive segment. If a single input file requires
more than N bytes, it will be given its own archive segment. As a special case, a value of -1 will produce a single large segment with all input files, while a value of 0 will produce one segment for each class. Larger archive segments result in less fragmentation and better compression, but processing them requires more memory.

The size of each segment is estimated by counting the size of each input file to be transmitted in the segment, along with the size of its name and other transmitted properties.

The default is 1000000 (a million bytes). This allows input JAR files of moderate size to be transmitted in one segment. It also puts a limit on memory requirements for packers and unpackers.

A 10MB JAR packed without this limit will typically pack about 10% smaller, but the packer may require a larger Java heap (about ten times the segment limit).

-Evalue --effort=value

If the value is set to a single decimal digit, the packer will use the indicated amount of effort in compressing the archive. Level 1 may produce somewhat larger size and faster compression speed, while level 9 will take much longer but may produce better compression. The special value 0 instructs the packer to copy through the original JAR file directly with no compression. The JSR 200 standard requires any unpacker to understand this special case as a pass-through of the entire archive.

The default is 5, investing a modest amount of time to produce reasonable compression.

-Hvalue --deflate-hint=value

Overrides the default, which preserves the input information, but may cause the transmitted archive to be larger. The possible values are:

true
false
In either case, the packer will set the deflation hint accordingly in the output archive, and will not transmit the individual deflation hints of archive elements.
keep
Preserve deflation hints observed in the input JAR. (This is the default.)

-mvalue --modification-time=value

The possible values are:

latest
The packer will attempt to determine the latest modification time, among all the available entries in the original archive, or the latest modification time of all the available entries in that segment. This single value will be transmitted as part of the segment and applied to all the entries in each segment. This can marginally decrease the transmitted size of the archive at the expense of setting all installed files to a single date.
keep
Preserves modification times observed in the input JAR. (This is the default.)

-Pfile --pass-file=file

Indicates that a file should be passed through bytewise with no compression. By repeating the option, multiple files may be specified. There is no pathname transformation, except that the system file separator is replaced by the JAR file separator "/". The resulting file names must match exactly as strings with their occurrences in the JAR file. If file is a directory name, all files under that directory will be passed.

-Uaction --unknown-attribute=action

Overrides the default behavior; i.e., the classfile containing the unknown attribute will be passed through with the specified action. The possible values for actions are:

error
The pack200 operation as a whole will fail with a suitable explanation.
strip
The attribute will be dropped. Note: Removing the required VM attributes may cause Class Loader failures.
pass
Upon encountering this attribute, the entire class will be transmitted as though it is a resource.

-Cattribute-name=layout
    --class-attribute=attribute-name=action
-Fattribute-name=layout
    --field-attribute=attribute-name=action
-Mattribute-name=layout
    --method-attribute=attribute-name=action
-Dattribute-name=layout
    --code-attribute=attribute-name=action

With the above four options, the attribute layout can be specified for a class entity, such as Class attribute, Field attribute, Method attribute, and Code attribute. The attribute-name is the name of the attribute for which the layout or action is being defined. The possible values for action are:

some-layout-string
The layout language is defined in the JSR 200 specification.

Example: --class-attribute=SourceFile=RUH

error
Upon encountering this attribute, the pack200 operation will fail with a suitable explanation.
strip
Upon encountering this attribute, the attribute will be removed from the output. Note: removing VM-required attributes may cause Class Loader failures.

Example: --class-attribute=CompilationID=pass will cause the class file containing this attribute to be passed through without further action by the packer.

-f pack.properties --config-file=pack.properties

A configuration file, containing Java properties to initialize the packer, may be specified on the command line.

% pack200 -f pack.properties myarchive.pack.gz myarchive.jar
% more pack.properties
# Generic properties for the packer.
modification.time=latest
deflate.hint=false
keep.file.order=false
# This option will cause the files bearing new attributes to
# be reported as an error rather than passed uncompressed.
unknown.attribute=error
# Change the segment limit to be unlimited.
segment.limit=-1

-v --verbose

Outputs minimal messages. Multiple specification of this option will output more verbose messages.

-q --quiet

Specifies quiet operation with no messages.

-lfilename --log-file=filename

Specifies a log file to output messages.

-Joption

Passes option to the Java launcher called by pack200. For example, -J-Xms48m sets the startup memory to 48 megabytes. Although it does not begin with -X, it is not a standard option of pack200. It is a common convention for -J to pass options to the underlying VM executing applications written in Java.

EXIT STATUS

The following exit values are returned:

 0 for successful completion;

>0 if an error occurs.

SEE ALSO

  • unpack200 - JAR Unpacking Tool
  • Java SE Documentation
  • Java Deployment Guide - Pack200
  • jar - Java Archive Tool
  • jarsigner - JAR Signer tool
  • attributes(5) man page

NOTES

This command should not be confused with pack(1). They are distinctly separate products.

The Java SE API Specification provided with the JDK is the superseding authority, in case of discrepancies.


servertool - The Java(TM) IDL Server Tool

servertool provides a command-line interface for application programmers to register, unregister, startup, and shutdown a persistent server.

SYNOPSIS

servertool -ORBInitialPort nameserverport options [ commands ]

If you did not enter a command when starting servertool, the command-line tool displays with a servertool > prompt. Enter commands at the servertool > prompt.

If you enter a command when starting servertool, the Java IDL Server Tool starts, runs the command, and exits.

The -ORBInitialPort nameserverport option is required. The value for nameserverport must specify the port on which orbd is running and listening for incoming requests. When using Solaris software, you must become root to start a process on a port under 1024. For this reason, we recommend that you use a port number greater than or equal to 1024 for the nameserverport.

DESCRIPTION

The servertool provides the command-line interface for the application programmers to register, unregister, startup, and shutdown a persistent server. Other commands are provided to obtain various statistical information about the server.

OPTIONS

-ORBInitialHost nameserverhost
Specifies the host machine on which the name server is running and listening for incoming requests. The nameserverhost defaults to localhost if this option is not specified. If orbd and servertool are running on different machines, you must specify the name or IP address of the host on which orbd is running.

-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes. It is a common convention for -J to pass options to the underlying virtual machine.

COMMANDS

register -server <server class name> -classpath <classpath to server> [ -applicationName <application name> -args <args to server> -vmargs <flags to be passed to Java VM> ]
Register a new persistent server with the Object Request Broker Daemon (ORBD). If the server is not already registered, it is registered and activated. This command causes an install method to be invoked in the main class of the server identified by the -server option. The install method must be public static void install(org.omg.CORBA.ORB). The install method is optional and enables the developer to provide their own server installation behavior (for example, creating database schema).

unregister -serverid <server id > | -applicationName <application name>
Unregister a server from the ORBD by using either its server id or its application name. This command causes an uninstall method to be invoked in the main class of the server identified by the -server option. The uninstall method must be public static void uninstall(org.omg.CORBA.ORB). The uninstall method is optional and enables the developer to provide their own server uninstall behavior (for example, undoing the behavior of the install method).

getserverid -applicationName <application name>
Return the server id that corresponds with an application.

list
List information about all persistent servers registered with the ORBD.

listappnames
List the application names for all servers currently registered with the ORBD.

listactive
List information about all persistent servers that have been launched by the ORBD and are currently running.

locate -serverid <server id > | -applicationName <application name> [-endpointType <endpointType> ]
Locate the endpoints (ports) of a specific type for all ORBs created by a registered server. If a server is not already running, it is activated. If an endpoint type is not specified, then the plain/non-protected endpoint associated with each ORB in a server is returned.

locateperorb -serverid <server id > | -applicationName <application name> [-orbid <ORB name> ]
Locate all the endpoints (ports) registered by a specific ORB of registered server. If a server is not already running, then it is activated. If an orbid is not specified, the default value of "" is assigned to the orbid. If any ORBs are created with an orbid of empty string, all ports registered by it are returned.

orblist -serverid <server id > | -applicationName <application name>
Lists the ORBId of the ORBs defined on a server. An ORBId is the string name for the ORB created by the server. If the server is not already running, it is activated.

shutdown -serverid <server id > | -applicationName <application name>
Shutdown an active server that is registered with ORBD. During execution of this command, the shutdown() method defined in the class specified by either the -serverid or -applicationName parameter is also invoked to shutdown the server process appropriately.

startup -serverid <server id > | -applicationName <application name>
Startup or activate a server that is registered with ORBD. If the server is not running, this command launches the server. If the server is already running, an error message is returned to the user.

help
List all the commands available to the server through the server tool.

quit
Exit the server tool.

SEE ALSO

orbd

Copyright © 2001-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


Transient Naming Service -

Java IDL: Transient Naming Service - tnameserv

This document discusses using the Java IDL Transient Naming Service, tnameserv. Java IDL also includes the Object Request Broker Daemon (ORBD). ORBD is a daemon process containing a Bootstrap Service, a Transient Naming Service, a Persistent Naming Service, and a Server Manager. The Java IDL tutorials all use ORBD, however, you can substitute tnameserv for orbd in any of the examples that use a Transient Naming Service. For documentation on the orbd tool, link to its man page or the Java IDL Naming Service Included with ORBD topic.

Topics in this section include:

  • Java IDL Transient Naming Service
  • Starting the Java IDL Transient Naming Service
  • Stopping the Java IDL Transient Naming Service
  • Sample Client: Adding Objects to the Namespace
  • Sample Client: Browsing the Namespace

Java IDL Transient Naming Service

The CORBA COS (Common Object Services) Naming Service provides a tree-like directory for object references much like a filesystem provides a directory structure for files. The Transient Naming Service provided with Java IDL, tnameserv, is a simple implementation of the COS Naming Service specification.

Object references are stored in the namespace by name and each object reference-name pair is called a name binding. Name bindings may be organized under naming contexts. Naming contexts are themselves name bindings and serve the same organizational function as a file system subdirectory. All bindings are stored under the initial naming context. The initial naming context is the only persistent binding in the namespace; the rest of the namespace is lost if the Java IDL naming service process halts and restarts.

For an applet or application to use COS naming, its ORB must know the port of a host running a naming service or have access to a stringified initial naming context for that naming service. The naming service can either be the Java IDL naming service or another COS-compliant naming service.

Starting the Java IDL Transient Naming Service

You must start the Java IDL naming service before an application or applet that uses its naming service. Installation of the Java IDL product creates a script (Solaris: tnameserv) or executable file (Windows NT: tnameserv.exe) that starts the Java IDL naming service. Start the naming service so it runs in the background.

If you do not specify otherwise, the Java IDL naming service listens on port 900 for the bootstrap protocol used to implement the ORB resolve_initial_references() and list_initial_references() methods, as follows:

    tnameserv -ORBInitialPort nameserverport&

If you do not specify the name server port, port 900 is used by default. When running Solaris software, you must become root to start a process on a port under 1024. For this reason, we recommend that you use a port number greater than or equal to 1024. To specify a different port, for example, 1050, and to run the naming service in the background, from a UNIX command shell, enter:

    tnameserv -ORBInitialPort 1050&

From an MS-DOS system prompt (Windows), enter:

    start tnameserv -ORBInitialPort 1050

Clients of the name server must be made aware of the new port number. Do this by setting the org.omg.CORBA.ORBInitialPort property to the new port number when creating the ORB object.

Running the server and client on different hosts

In most of the Java IDL and RMI-IIOP tutorials, the Naming Service, Server, and Client are all running on the development machine. In real world deployment, it is likely that the client and server will run on different host machines than the Naming Service.

For the client and server to find the Naming Service, they must be made aware of the port number and host on which the naming service is running. Do this by setting the org.omg.CORBA.ORBInitialPort and org.omg.CORBA.ORBInitialHost properties in the client and server files to the machine name and port number on which the Naming Service is running. An example of this is shown in The Hello World Example Using RMI-IIOP. You could also use the command line options -ORBInitialPort nameserverport# and -ORBInitialHost nameserverhostname to tell the client and server where to find the Naming Service. Java IDL: Running the Hello World Example on TWO Machines shows one way of doing this using the command line option.

For example, suppose the Transient Naming Service, tnameserv is running on port 1050 on host nameserverhost. The client is running on host clienthost and the server is running on host serverhost.

  • Start tnameserv on the host nameserverhost, as follows:
         tnameserv -ORBInitialPort 1050
  • Start the server on the serverhost, as follows:
         java Server -ORBInitialPort 1050 -ORBInitialHost nameserverhost
  • Start the client on the clienthost, as follows:
         java Client -ORBInitialPort 1050 -ORBInitialHost nameserverhost

The -J option

This command-line option is available for use with tnameserve:
-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes. It is a common convention for -J to pass options to the underlying virtual machine.

Stopping the Java IDL Transient Naming Service

To stop the Java IDL naming service, use the relevant operating system command, such as kill for a Unix process, or Ctrl-C for a Windows process. The naming service will continue to wait for invocations until it is explicitly shutdown. Note that names registered with the Java IDL naming service disappear when the service is terminated.

Sample Client: Adding Objects to the Namespace

The following sample program illustrates how to add names to the namespace. It is a self-contained Transient Naming Service client that creates the following simple tree.

                  Initial
               Naming Context
                  /      \
                 /        \
              plans     Personal
                         /   \
                        /     \
                   calendar  schedule

In this example, plans is an object reference and Personal is a naming context that contains two object references: calendar and schedule.

import java.util.Properties;
import org.omg.CORBA.*;
import org.omg.CosNaming.*;

public class NameClient
{
   public static void main(String args[])
   {
      try {
In the above section, Starting the Java IDL Transient Naming Service, the nameserver was started on port 1050. The following code ensures that the client program is aware of this port number.
        Properties props = new Properties();
        props.put("org.omg.CORBA.ORBInitialPort", "1050");
        ORB orb = ORB.init(args, props);
This code obtains the initial naming context and assigns it to ctx. The second line copies ctx into a dummy object reference objref that we'll attach to various names and add into the namespace.
        NamingContext ctx =
NamingContextHelper.narrow(orb.resolve_initial_references("NameService"));
        NamingContext objref = ctx;
This code creates a name "plans" of type "text" and binds it to our dummy object reference. "plans" is then added under the initial naming context using rebind. The rebind method allows us to run this program over and over again without getting the exceptions we'd get from using bind.
        NameComponent nc1 = new NameComponent("plans", "text");
        NameComponent[] name1 = {nc1};
        ctx.rebind(name1, objref);
        System.out.println("plans rebind sucessful!");
This code creates a naming context called "Personal" of type "directory". The resulting object reference, ctx2, is bound to the name and added under the initial naming context.
        NameComponent nc2 = new NameComponent("Personal", "directory");
        NameComponent[] name2 = {nc2};
        NamingContext ctx2 = ctx.bind_new_context(name2);
        System.out.println("new naming context added..");
The remainder of the code binds the dummy object reference using the names "schedule" and "calendar" under the "Personal" naming context (ctx2).
        NameComponent nc3 = new NameComponent("schedule", "text");
        NameComponent[] name3 = {nc3};
        ctx2.rebind(name3, objref);
        System.out.println("schedule rebind sucessful!");

        NameComponent nc4 = new NameComponent("calender", "text");
        NameComponent[] name4 = {nc4};
        ctx2.rebind(name4, objref);
        System.out.println("calender rebind sucessful!");

    } catch (Exception e) {
        e.printStackTrace(System.err);
    }
  }
}

Sample Client: Browsing the Namespace

The following sample program illustrates how to browse the namespace.

import java.util.Properties;
import org.omg.CORBA.*;
import org.omg.CosNaming.*;

public class NameClientList
{
   public static void main(String args[])
   {
      try {
In the above section, Starting the Java IDL Transient Naming Service, the nameserver was started on port 1050. The following code ensures that the client program is aware of this port number.

        Properties props = new Properties();
        props.put("org.omg.CORBA.ORBInitialPort", "1050");
        ORB orb = ORB.init(args, props);
The following code obtains the intial naming context.
        NamingContext nc =
NamingContextHelper.narrow(orb.resolve_initial_references("NameService"));
The list method lists the bindings in the naming context. In this case, up to 1000 bindings from the initial naming context will be returned in the BindingListHolder; any remaining bindings are returned in the BindingIteratorHolder.
        BindingListHolder bl = new BindingListHolder();
        BindingIteratorHolder blIt= new BindingIteratorHolder();
        nc.list(1000, bl, blIt);
This code gets the array of bindings out of the returned BindingListHolder. If there are no bindings, the program ends.
        Binding bindings[] = bl.value;
        if (bindings.length == 0) return;
The remainder of the code loops through the bindings and prints the names out.
        for (int i=0; i < bindings.length; i++) {

            // get the object reference for each binding
            org.omg.CORBA.Object obj = nc.resolve(bindings[i].binding_name);
            String objStr = orb.object_to_string(obj);
            int lastIx = bindings[i].binding_name.length-1;

            // check to see if this is a naming context
            if (bindings[i].binding_type == BindingType.ncontext) {
              System.out.println( "Context: " +
bindings[i].binding_name[lastIx].id);
            } else {
                System.out.println("Object: " +
bindings[i].binding_name[lastIx].id);
            }
        }

       } catch (Exception e) {
        e.printStackTrace(System.err);
       }
   }
}

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


unpack200 - JAR Unpacking tool

  • Synopsis
  • Description
  • Options
  • Exit Status
  • See Also
  • Notes

SYNOPSIS

unpack200 [ options ] input-file JAR-file

Options may be in any order. The last option on the command line supersedes all previously specified options.

input-file
Name of the input file, which can be a pack200 gzip file or a pack200 file. The input could also be JAR file produced by pack200(1) with an effort of 0. In this case the contents of the input file will be copied to the output JAR file with the Pack200 marker.
JAR-file
Name of the output JAR file.

DESCRIPTION

unpack200 is a native implementation that transforms a packed file produced by pack200(1) into a JAR file. Typical usage:

% unpack200 myarchive.pack.gz myarchive.jar

In this example, the myarchive.jar is produced from myarchive.pack.gz using the default unpack200 settings.

OPTIONS

Standard Options

-Hvalue --deflate-hint=value

Sets the deflation to be true, false, or keep on all entries within a JAR file. The default mode is keep. If true or false, overrides the default behavior and sets the deflation mode on all entries within the output JAR file.

Non-Standard Options

-r --remove-pack-file

Removes the input packed file.

-v --verbose

Outputs minimal messages. Multiple specification of this option will output more verbose messages.

-q --quiet

Specifies quiet operation with no messages.

-lfilename --log-file=filename

Specifies a log file to output messages.

EXIT STATUS

The following exit values are returned:

 0 if successful completion;

>0 if an error occurred.

SEE ALSO

  • pack200 - JAR Packing Tool
  • Java SE Documentation
  • Java Deployment Guide - Pack200
  • jar - Java Archive Tool
  • jarsigner - JAR Signer tool
  • attributes(5) man page

NOTES

This command should not be confused with unpack(1). They are distinctly separate products.

The Java SE API Specification provided with the JDK is the superseding authority, in case of discrepancies.


jsdocs

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES

jrunscript JavaScript built-ins

This document is the API Specification for jrunscript JavaScript built-ins.

Summary

jrunscript JavaScript built-in functions, constructors

jrunscript JavaScript built-in functions, constructors

jrunscript initializes the script engine with built-in functions and constructors before evaluating a user script. These include simple file system utility functions, process utilities (exec, exit etc.), a few XML utilities and some simple IO functions.

File Summary
init.js
Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


Generated Javascript Documentation

Frame Alert

This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client.
Link to Non-frame version.


Index

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES
C D E F G I J L M P Q R W X

C

cat(obj, pattern) - Class method in class GLOBALS
cd(target) - Class method in class GLOBALS
cp(from, to) - Class method in class GLOBALS

D

date() - Class method in class GLOBALS
del(pathname) - Class method in class GLOBALS
dir(d, filter) - Class method in class GLOBALS
dirname(pathname) - Class method in class GLOBALS

E

echo(x) - Class method in class GLOBALS
exec(cmd) - Class method in class GLOBALS
exit(code) - Class method in class GLOBALS

F

find(dir, pattern, callback) - Class method in class GLOBALS

G

GLOBALS - class GLOBALS
grep(pattern, files ) - Class method in class GLOBALS

I

ip(name) - Class method in class GLOBALS

J

jlist - class jlist
jlist(list) - Constructor in class jlist
jmap - class jmap
jmap(map) - Constructor in class jmap
JSInvoker - class JSInvoker
JSInvoker(obj) - Constructor in class JSInvoker

L

load(str) - Class method in class GLOBALS
ls(dir, filter) - Class method in class GLOBALS

M

mkdir(dir) - Class method in class GLOBALS
mkdirs(dir) - Class method in class GLOBALS
mv(from, to) - Class method in class GLOBALS

P

printf(format, args) - Class method in class GLOBALS
pwd() - Class method in class GLOBALS

Q

quit(code) - Class method in class GLOBALS

R

read(prompt, multiline) - Class method in class GLOBALS
ren(from, to) - Class method in class GLOBALS
rm(pathname) - Class method in class GLOBALS
rmdir(pathname) - Class method in class GLOBALS

W

which(cmd) - Class method in class GLOBALS

X

XMLDocument(inp) - Class method in class GLOBALS
XMLResult(out) - Class method in class GLOBALS
XMLSource(inp) - Class method in class GLOBALS
XSLTransform(inp, style, out) - Class method in class GLOBALS
C D E F G I J L M P Q R W X
Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


jrunscript JavaScript built-ins All Classes

jrunscript JavaScript built-ins

All Classes
GLOBALS
jlist
jmap
JSInvoker


jrunscript JavaScript built-ins API Help

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES

How This API Document Is Organized

This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.

Class

Each class has its own separate page. Each of these pages has three sections consisting of a class description, summary tables, and detailed member descriptions:

  • Class inheritance diagram
  • Direct Subclasses
  • Class declaration
  • Class description

  • Field Summary
  • Constructor Summary
  • Method Summary

  • Field Detail
  • Constructor Detail
  • Method Detail
Each summary entry contains the first sentence from the detailed description for that item.

Index

The Index contains an alphabetic list of all classes, constructors, methods, and fields.

Prev/Next

These links take you to the next or previous class, interface, package, or related page.

Frames/No Frames

These links show and hide the HTML frames. All pages are available with or without frames.

This help file applies to API documentation generated using the standard doclet.

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


jrunscript JavaScript built-ins Class Hierarchy

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES

Class Hierarchy

  • Object
    • jlist
    • jmap
    • JSInvoker
Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


jrunscript JavaScript built-ins Overview

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES

init.js

Summary

No overview generated for 'init.js'

Class Summary
jlist
JSInvoker
jmap
Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV NEXT FRAMES NO FRAMES
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


GLOBALS

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Class GLOBALS

Object
   |
   +--GLOBALS
class GLOBALS
Method Summary
<static> void | cat(obj, pattern) Shows the content of a file, URL or InputStream
<static> void | cd(target) Changes the present working directory to the given directory
<static> void | cp(from, to) Copies a file, URL, or stream to another file or stream
<static> void | date() Prints the current date using the current locale
<static> void | del(pathname) A synonym for 'rm'
<static> void | dir(d, filter) A synonym for 'ls'.
<static> Object | dirname(pathname) Returns the directory part of a filename
<static> void | echo(x) Echoes the given string arguments
<static> void | exec(cmd) Execs a child process, waits for completion & returns exit code
<static> void | exit(code) Exit the shell program.
<static> void | find(dir, pattern, callback) Find in files.
<static> void | grep(pattern, files ) Unix-like grep, but accepts JavaScript regex patterns
<static> void | ip(name) Prints the IP addresses of a given domain name
<static> void | load(str) Loads and evaluates JavaScript code from a stream, file, or URL
<static> void | ls(dir, filter) Lists the files in a directory
<static> void | mkdir(dir) Creates a new directory of a given name
<static> void | mkdirs(dir) Creates a directory, including any necessary but nonexistent parent directories.
<static> void | mv(from, to) Moves a file to another
<static> Object | printf(format, args) A C-like printf
<static> void | pwd() Print the working directory
<static> void | quit(code) synonym for exit
<static> Object | read(prompt, multiline) Reads one or more lines from stdin after printing a prompt
<static> void | ren(from, to) A synonym for 'mv'.
<static> Object | rm(pathname) Removes a given file
<static> void | rmdir(pathname) Removes a given directory
<static> void | which(cmd) Prints which command is selected from PATH
<static> Object | XMLDocument(inp) Converts input to DOM Document object
<static> Object | XMLResult(out) Converts an arbitrary stream, file to an XMLResult
<static> Object | XMLSource(inp) Converts an arbitrary stream, file, URL to an XMLSource
<static> void | XSLTransform(inp, style, out) Perform XSLT transform

Method Detail

cat

<static> void cat(obj, pattern)
    Shows the content of a file, URL, or InputStream
    Examples:

    cat('test.txt'); // show test.txt file contents
    cat('http://java.net'); // show the contents from the URL http://java.net
    Parameters:
      obj - input to show
      pattern - optional. Show only the lines matching the pattern

cd

<static> void cd(target)
    Changes the present working directory to the given directory
    Parameters:
      target - the directory to change to. optional, defaults to user's HOME

cp

<static> void cp(from, to)
    Copies a file, URL, or stream to another file or stream
    Parameters:
      from - the input file, URL, or stream
      to - the output stream or file

date

<static> void date()
    Prints the current date using the current locale

del

<static> void del(pathname)
    A synonym for 'rm'

dir

<static> void dir(d, filter)
    A synonym for 'ls'.

dirname

<static> Object dirname(pathname)
    Returns the directory part of a filename
    Parameters:
      pathname - the input path name
    Returns:
      the directory part of the given file name

echo

<static> void echo(x)
    Echoes the given string arguments

exec

<static> void exec(cmd)
    Execs a child process, waits for completion & returns the exit code
    Parameters:
      cmd - the command to execute in child process

exit

<static> void exit(exitCode)
    Exit the shell program.
    Parameters:
      exitCode - the integer code to be returned to the OS shell. Optional, defaults to 0

find

<static> void find(dir, pattern, callback)
    Find in files. Calls a specified callback function for each matching file.
    Examples:

    find('.')
    find('.', '.*\.class', rm);  // remove all .class files
    find('.', '.*\.java');       // print fullpath of each .java file
    find('.', '.*\.java', cat);  // print all .java files
    Parameters:
      dir - the directory of files to search
      pattern - the pattern to search for
      callback - the function to call for matching files

grep

<static> void grep(pattern, files )
    Unix-like grep, but accepts JavaScript regex patterns
    Parameters:
      pattern - the pattern to search for
      files - one or more files to be searched

ip

<static> void ip(name)
    Prints the IP addresses of given domain name
    Parameters:
      name - the domain name

load

<static> void load(str)
    Loads and evaluates JavaScript code from a stream, file, or URL
    Examples:

    load('test.js'); // load script file 'test.js'
    load('http://java.sun.com/foo.js'); // load from a URL
    Parameters:
      str - the input from which the script is loaded and evaluated

ls

<static> void ls(dir, filter)
    Lists the files in a directory
    Parameters:
      dir - the directory from which to list the files. Optional, default to pwd
      filter - a pattern to filter the files listed. Optional, default is '.'

mkdir

<static> void mkdir(dir)
    Creates a new directory
    Parameters:
      dir - the name of the new directory

mkdirs

<static> void mkdirs(dir)
    Creates a directory, including any necessary but nonexistent parent directories.
    Parameters:
      dir - the pathname of the directory to be created

mv

<static> void mv(from, to)
    Moves a file to another
    Parameters:
      from - the original name of the file
      to - the new name for the file

printf

<static> Object printf(format, args)
    A C-like printf
    Parameters:
      format - the string to format the rest of the print items
      args - the variadic argument list

pwd

<static> void pwd()
    Print the working directory

quit

<static> void quit(code)
    A synonym for exit

read

<static> Object read(prompt, multiline)
    Reads one or more lines from stdin after printing a prompt
    Parameters:
      prompt - the prompt. Optional, default is '>'
      multiline - if 0, read a single line, else read multiple lines

ren

<static> void ren(from, to)
    A synonym for 'mv'.

rm

<static> Object rm(pathname)
    Removes a given file
    Parameters:
      pathname - the name of the file

rmdir

<static> void rmdir(pathname)
    Removes a given directory
    Parameters:
      pathname - the name of the directory

which

<static> void which(cmd)
    Print the pathname of a command located on PATH
    Parameters:
      cmd - the name of the command searched from PATH

XMLDocument

<static> Object XMLDocument(inp)
    Converts input to a DOM Document object
    Parameters:
      inp - a file or reader. Optional, If missing a new DOM Document is returned.
    Returns:
      returns a DOM Document object

XMLResult

<static> Object XMLResult(out)
    Convert an arbitrary stream or file to an XMLResult
    Parameters:
      inp - the input stream or file
    Returns:
      XMLResult object

XMLSource

<static> Object XMLSource(inp)
    Converts an arbitrary stream, file, or URL to an XMLSource
    Parameters:
      inp - the input stream, file, or URL
    Returns:
      XMLSource object

XSLTransform

<static> void XSLTransform(inp, style, out)
    Perform an XSLT transform
    Parameters:
      inp - the input XML to transform (URL, File or InputStream)
      style - the XSL Stylesheet to be used (URL, File or InputStream). Optional.
      out - the output XML (File or OutputStream)
Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


jlist

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV CLASS NEXT CLASS FRAMES NO FRAMES
SUMMARY: FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

Class jlist

Object
   |
   +--jlist
class jlist

Defined in init.js

Constructor Summary
jlist (list)
Creates a convenient script object to deal with java.util.List instances.

Constructor Detail

jlist

jlist(list)
    Creates a convenient script object to deal with java.util.List instances. The result script object behaves like an array. For example, scriptObj[index] syntax can be used to access values in the List instance. 'length' field gives size of the List.
    Example:

    var x = new java.util.ArrayList(4);
    x.add('Java');
    x.add('JavaScript');
    x.add('SQL');
    x.add('XML');

    var y = jlist(x);
    print(y[2]); // prints third element of list
    print(y.length); // prints size of the list
    Parameters:
      map - java.util.List instance that will be wrapped
Overview  File   Class  Tree  Index  Help
jrunscript JavaScript built-ins
 PREV CLASS  NEXT CLASS FRAMES    NO FRAMES
SUMMARY: FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


jmap

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV CLASS NEXT CLASS FRAMES NO FRAMES
SUMMARY: FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

Class jmap

Object
   |
   +--jmap
class jmap

Defined in init.js

Constructor Summary
jmap (map)
Creates a convenient script object to deal with java.util.Map instances.

Constructor Detail

jmap

jmap(map)
    Creates a convenient script object to deal with java.util.Map instances. The result script object's field names are keys of the Map. For example, scriptObj.keyName can be used to access value associated with given key.
    Example:

     var x = java.lang.SystemProperties();
     var y = jmap(x);
     print(y['java.class.path']); // prints java.class.path System property
     delete y['java.class.path']; // remove java.class.path System property
    Parameters:
      map - java.util.Map instance that will be wrapped
Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV CLASS NEXT CLASS FRAMES NO FRAMES
SUMMARY: FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


JSInvoker

Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Class JSInvoker

Object
   |
   +--JSInvoker
class JSInvoker

Defined in init.js

Constructor Summary
JSInvoker (obj)
Creates an object that delegates all method calls on it to the 'invoke' method on the given delegate object.

Constructor Detail

JSInvoker

JSInvoker(obj)
    Creates an object that delegates all method calls on it to the 'invoke' method on the given delegate object.
    Example:

     var x  = { invoke: function(name, args) { //code...}
     var y = new JSInvoker(x);
     y.func(3, 3); // calls x.invoke('func', args); where args is array of arguments
    Parameters:
      obj - object to be wrapped by JSInvoker
Overview File Class Tree Index Help
jrunscript JavaScript built-ins
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD
Documentation generated by JSDoc on Wed Jun 8 13:29:43 2005


appletviewer - The Java Applet Viewer

The appletviewer command allows you to run applets outside of a web browser.

SYNOPSIS

appletviewer [ options ] urls ...

DESCRIPTION

The appletviewer command connects to the documents or resources designated by urls and displays each applet referenced by the documents in its own window. Note: if the documents referred to by urls do not reference any applets with the OBJECT, EMBED, or APPLET tag, then appletviewer does nothing. For details on the HTML tags that appletviewer supports, see AppletViewer Tags.

Note: The appletviewer requires encoded URLs according to the escaping mechanism defined in RFC2396. Only encoded URLs are supported. However, file names must be unencoded, as specified in RFC2396.

OPTIONS

-debug
Starts the applet viewer in the Java debugger, jdb, thus allowing you to debug the applets in the document.
-encoding encoding name
Specify the input HTML file encoding name.
-J javaoption
Passes through the string javaoption as a single argument to the Java interpreter which runs the appletviewer. The argument should not contain spaces. Multiple argument words must all begin with the prefix -J, which is stripped. This is useful for adjusting the compiler's execution environment or memory usage.

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


extcheck - Jar conflict detection utility

extcheck - A utility to detect jar conflicts

extcheck detects version conflicts between a target jar file and currently installed extension jar files.

SYNOPSIS

extcheck [ -verbose ] targetfile.jar

DESCRIPTION

The extcheck utility checks a specified Jar file for title and version conflicts with any extensions installed in the JavaTM SDK. Before installing an extension, you can use this utility to see if the same or a more recent version of the extension is already installed.

The extcheck utility compares the Specification-title and Specification-version headers in the manifest of the targetfile.jar file against the corresponding headers in all Jar files currently installed in the extension directory. (The extension directory is jre/lib/ext by default.) The extcheck utility compares version numbers in the same way as the method java.lang.Package.isCompatibleWith.

If no conflict is detected, the return code is 0.

If the manifest of any jar file in the extensions directory has the same Specification-title and the same or a newer Specification-version number, a non-zero error code is returned. A non-zero error code is also returned if targetfile.jar does not have the Specification-title or Specification-version attributes in its manifest.

OPTIONS

-verbose
Lists Jar files in the extension directory as they are checked. Additionally, manifest attributes of the target jar file and any conflicting jar files are also reported.
-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes.

SEE ALSO

jar

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jar-The Java Archive Tool

jar combines multiple files into a single JAR archive file.
  • Synopsis
  • Description
  • Options
  • Command Line Argument Files
  • Examples
  • See Also

SYNOPSIS

Create jar file
jar c[v0Mmfe] [manifest] [jarfile] [entrypoint] [-C dir] inputfiles [-J option]

Update jar file
jar u[v0Mmfe] [manifest] [jarfile] [entrypoint] [-C dir] inputfiles [-J option]

Extract jar file
jar x[vf] [jarfile] [inputfiles] [-J option]

List table of contents of jar file
jar t[vf] [jarfile] [inputfiles] [-J option]

Add index to jar file
jar i jarfile [-J option]

where:

cuxtiv0Mmfe
Options that control the jar command.
jarfile
Jar file to be created (c), updated (u), extracted (x), or have its table of contents viewed (t). The -f option and filename jarfile are a pair -- if either is present, they must both appear. Note that omitting f and jarfile accepts a "jar file" from standard input (for x and t) or sends the "jar file" to standard output (for c and u).
inputfiles
Files or directories, separated by spaces, to be combined into jarfile (for c and u), or to be extracted (for x) or listed (for t) from jarfile. All directories are processed recursively. The files are compressed unless option 0 (zero) is used.
manifest
Pre-existing manifest file whose name: value pairs are to be included in MANIFEST.MF in the jar file. The -m option and filename manifest are a pair -- if either is present, they must both appear. The letters m, f and e must appear in the same order that manifest, jarfile, entrypoint appear.
entrypoint
The name of the class that set as the application entry point for stand-alone applications bundled into executable jar file. The -e option and entrypoint are a pair -- if either is present, they must both appear. The letters m, f and e must appear in the same order that manifest, jarfile, entrypoint appear.
-C dir
Temporarily changes directories to dir while processing the following inputfiles argument. Multiple -C dir inputfiles sets are allowed.
-J option
Option to be passed into the Java runtime environment. (There must be no space between -J and option).

DESCRIPTION

The jar tool combines multiple files into a single JAR archive file. jar is a general-purpose archiving and compression tool, based on ZIP and the ZLIB compression format. However, jar was designed mainly package java applets or applications into a single archive. When the components of an applet or application (files, images and sounds) are combined into a single archive, they can be downloaded by a java agent (like a browser) in a single HTTP transaction, rather than requiring a new connection for each piece. This dramatically improves download times. jar also compresses files and so further improves download time. In addition, it allows individual entries in a file to be signed by the applet author so that their origin can be authenticated. The syntax for the jar tool is almost identical to the syntax for the tar command. A jar archive can be used as a class path entry, whether or not it is compressed.

Typical usage to combine files into a jar file is:

% jar cf myFile.jar *.class
In this example, all the class files in the current directory are placed into the file named myFile.jar. The jar tool automatically generates a manifest file entry named META-INF/MANIFEST.MF. It is always the first entry in the jar file. The manifest file declares meta-information about the archive, and stores that data as name : value pairs. Refer to the JAR file specification for details explaining how the jar tool stores meta-information in the manifest file.

If a jar file should include name : value pairs contained in an existing manifest file, specify that file using the -m option:

% jar cmf myManifestFile myFile.jar *.class
An existing manifest file must end with a new line character. jar does not parse the last line of a manifest file if it does not end with a new line character.

Note: A jar command that specifies cfm on the command line instead of cmf (the order of the m and -f options are reversed), the jar command line must specify the name of the jar archive first, followed by the name of the manifest file:
% jar cfm myFile.jar myManifestFile *.class
The manifest is in a text format inspired by RFC822 ASCII format, so it is easy to view and process manifest-file contents.

To extract the files from a jar file, use x:

% jar xf myFile.jar

To extract individual files from a jar file, supply their filenames:

% jar xf myFile.jar foo bar

Beginning with version 1.3 of the Java 2 SDK, the jar utility supports JarIndex, which allows application class loaders to load classes more efficiently from jar files. If an application or applet is bundled into multiple jar files, only the necessary jar files will be downloaded and opened to load classes. This performance optimization is enabled by running jar with the -ioption. It will generate package location information for the specified main jar file and all the jar files it depends on, which need to be specified in the Class-Path attribute of the main jar file's manifest.

% jar i main.jar

In this example, an INDEX.LIST file is inserted into the META-INF directory of main.jar.

The application class loader uses the information stored in this file for efficient class loading. For details about how location information is stored in the index file, refer to the JarIndex specification.

To copy directories, first compress files in dir1 to stdout, then extract from stdin to dir2 (omitting the -f option from both jar commands):

% (cd dir1; jar c .) | (cd dir2; jar x)

To review command samples which use jar to opeate on jar files and jar file manifests, see Examples, below. Also refer to the jar trail of the Java Tutorial.

OPTIONS

c
Creates a new archive file named jarfile (if f is specified) or to standard output (if f and jarfile are omitted). Add to it the files and directories specified by inputfiles.
u
Updates an existing file jarfile (when f is specified) by adding to it files and directories specified by inputfiles. For example:
jar uf foo.jar foo.class
would add the file foo.class to the existing jar file foo.jar. The -u option can also update the manifest entry, as given by this example:
jar umf manifest foo.jar
updates the foo.jar manifest with the name : value pairs in manifest.
x
Extracts files and directories from jarfile (if f is specified) or standard input (if f and jarfile are omitted). If inputfiles is specified, only those specified files and directories are extracted. Otherwise, all files and directories are extracted. The time and date of the extracted files are those given in the archive.
t
Lists the table of contents from jarfile (if f is specified) or standard input (if f and jarfile are omitted). If inputfiles is specified, only those specified files and directories are listed. Otherwise, all files and directories are listed.
i
Generate index information for the specified jarfile and its dependent jar files. For example:
jar i foo.jar

would generate an INDEX.LIST file in foo.jar which contains location information for each package in foo.jar and all the jar files specified in the Class-Path attribute of foo.jar. See the index example.

f
Specifies the file jarfile to be created (c), updated (u), extracted (x), indexed (i), or viewed (t). The -f option and filename jarfile are a pair -- if present, they must both appear. Omitting f and jarfile accepts a jar file name from stdin(for x and t) or sends jar file to stdout (for c and u).
v
Generates verbose output to standard output. Examples shown below.
0
(zero) Store without using ZIP compression.
M
Do not create a manifest file entry (for c and u), or delete a manifest file entry if one exists (for u).
m
Includes name : value attribute pairs from the specified manifest file manifest in the file at META-INF/MANIFEST.MF. jar adds a name : value pair unless an entry already exists with the same name, in which case jar updates its value.

On the command line, the letters m and f must appear in the same order that manifest and jarfile appear. Example use:

jar cmf myManifestFile myFile.jar *.class
You can add special-purpose name : value attribute pairs to the manifest that aren't contained in the default manifest. For example, you can add attributes specifying vendor information, version information, package sealing, or to make JAR-bundled applications executable. See the JAR Files trail in the Java Tutorial for examples of using the -m option.

e
Sets entrypoint as the application entry point for stand-alone applications bundled into executable jar file. The use of this option creates or overrides the Main-Class attribute value in the manifest file. This option can be used during creation of jar file or while updating the jar file. This option specifies the application entry point without editing or creating the manifest file.

For example, this command creates Main.jar where the Main-Class attribute value in the manifest is set to Main:
jar cfe Main.jar Main Main.class

The java runtime can directly invoke this application by running the following command:

java -jar Main.jar
If the entrypoint class name is in a package it may use either a dot (".") or slash ("/") character as the delimiter. For example, if Main.class is in a package called foo the entry point can be specified in the following ways:
jar -cfe Main.jar foo/Main foo/Main.class
or
jar -cfe Main.jar foo.Main foo/Main.class
Note: specifying both -m and -e options together when the given manifest also contains the Main-Class attribute results in an ambigous Main.class specification, leading to an error and the jar creation or update operation is aborted.

-C dir
Temporarily changes directories (cd dir) during execution of the jar command while processing the following inputfiles argument. Its operation is intended to be similar to the -C option of the UNIX tar utility.

For example, this command changes to the classes directory and adds the bar.class from that directory to foo.jar:
jar uf foo.jar -C classes bar.class
This command changes to the classes directory and adds to foo.jar all files within the classes directory (without creating a classes directory in the jar file), then changes back to the original directory before changing to the bin directory to add xyz.class to foo.jar.
jar uf foo.jar -C classes . -C bin xyz.class
If classes holds files bar1 and bar2, then here's what the jar file will contain using jar tf foo.jar:
META-INF/
META-INF/MANIFEST.MF
bar1
bar2
xyz.class

-Joption
Pass option to the Java runtime environment, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xmx48M sets the maximum memory to 48 megabytes. It is a common convention for -J to pass options to the underlying runtime environment.

COMMAND LINE ARGUMENT FILES

To shorten or simplify the jar command line, you can specify one or more files that themselves contain arguments to the jar command (except -J options). This enables you to create jar commands of any length, overcoming command line limits imposed by the operating system.

An argument file can include options and filenames. The arguments within a file can be space–separated or newline-separated. Filenames within an argument file are relative to the current directory, not relative to the location of the argument file. Wildcards (*) that might otherwise be expanded by the operating system shell are not expanded. Use of the @ character to recursively interpret files is not supported. The -J options are not supported because they are passed to the launcher, which does not support argument files.

When executing jar, pass in the path and name of each argument file with the @ leading character. When jar encounters an argument beginning with the character @, it expands the contents of that file into the argument list.

The example below, classes.list holds the names of files output by a find command:

% find . -name '*.class' -print > classes.list

You can then execute the jar command on Classes.list by passing it to jar using argfile syntax:

% jar cf my.jar @classes.list
An argument file can specify a path, but any filenames inside the argument file that have relative paths are relative to the current working directory, not to the path passed in. Here is an example:
% jar @path1/classes.list

EXAMPLES

To add all the files in a particular directory to an archive (overwriting contents if the archive already exists). Enumerating verbosely (with the -v option) will tell you more information about the files in the archive, such as their size and last modified date.
% ls
1.au          Animator.class    monkey.jpg
2.au          Wave.class        spacemusic.au
3.au          at_work.gif

% jar cvf bundle.jar *
added manifest
adding: 1.au(in = 2324) (out= 67)(deflated 97%)
adding: 2.au(in = 6970) (out= 90)(deflated 98%)
adding: 3.au(in = 11616) (out= 108)(deflated 99%)
adding: Animator.class(in = 2266) (out= 66)(deflated 97%)
adding: Wave.class(in = 3778) (out= 81)(deflated 97%)
adding: at_work.gif(in = 6621) (out= 89)(deflated 98%)
adding: monkey.jpg(in = 7667) (out= 91)(deflated 98%)
adding: spacemusic.au(in = 3079) (out= 73)(deflated 97%)
If you already have separate subdirectories for images, audio files and classes, you can combine them into a single jar file:
% ls -F
audio/ classes/ images/

% jar cvf bundle.jar audio classes images
added manifest
adding: audio/(in = 0) (out= 0)(stored 0%)
adding: audio/1.au(in = 2324) (out= 67)(deflated 97%)
adding: audio/2.au(in = 6970) (out= 90)(deflated 98%)
adding: audio/3.au(in = 11616) (out= 108)(deflated 99%)
adding: audio/spacemusic.au(in = 3079) (out= 73)(deflated 97%)
adding: classes/(in = 0) (out= 0)(stored 0%)
adding: classes/Animator.class(in = 2266) (out= 66)(deflated 97%)
adding: classes/Wave.class(in = 3778) (out= 81)(deflated 97%)
adding: images/(in = 0) (out= 0)(stored 0%)
adding: images/monkey.jpg(in = 7667) (out= 91)(deflated 98%)
adding: images/at_work.gif(in = 6621) (out= 89)(deflated 98%)

% ls -F
audio/ bundle.jar classes/ images/
To see the entry names in the jarfile, use the t option:
% jar tf bundle.jar
META-INF/
META-INF/MANIFEST.MF
audio/1.au
audio/2.au
audio/3.au
audio/spacemusic.au
classes/Animator.class
classes/Wave.class
images/monkey.jpg
images/at_work.gif

To add an index file to the jar file for speeding up class loading, use the i option.

Example:

If you split the inter-dependent classes for a stock trade application into three jar files: main.jar, buy.jar, and sell.jar.

If you specify the Class-path attribute in the main.jar manifest as:
Class-Path: buy.jar sell.jar
then you can use the -i option to speed up the class loading time for your application:
% jar i main.jar
An INDEX.LIST file is inserted to the META-INF directory. This enables the application class loader to download the specified jar files when it is searching for classes or resources.

SEE ALSO

The Jar Overview
The Jar File Specification
The JarIndex Spec
Jar Tutorial on the Java Software web site.
pack200 Reference Page

Copyright 2004-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jarsigner - JAR Signing and Verification Tool

Generates signatures for Java ARchive (JAR) files, and verifies the signatures of signed JAR files.

SYNOPSIS

jarsigner [ options ] jar-file alias
jarsigner -verify [ options ] jar-file

DESCRIPTION

The jarsigner tool is used for two purposes:

  1. to sign Java ARchive (JAR) files, and
  2. to verify the signatures and integrity of signed JAR files.

The JAR feature enables the packaging of class files, images, sounds, and other digital data in a single file for faster and easier distribution. A tool named jar enables developers to produce JAR files. (Technically, any zip file can also be considered a JAR file, although when created by jar or processed by jarsigner, JAR files also contain a META-INF/MANIFEST.MF file.)

A digital signature is a string of bits that is computed from some data (the data being "signed") and the private key of an entity (a person, company, etc.). Like a handwritten signature, a digital signature has many useful characteristics:

  • Its authenticity can be verified, via a computation that uses the public key corresponding to the private key used to generate the signature.
  • It cannot be forged, assuming the private key is kept secret.
  • It is a function of the data signed and thus can't be claimed to be the signature for other data as well.
  • The signed data cannot be changed; if it is, the signature will no longer verify as being authentic.

In order for an entity's signature to be generated for a file, the entity must first have a public/private key pair associated with it, and also one or more certificates authenticating its public key. A certificate is a digitally signed statement from one entity, saying that the public key of some other entity has a particular value.

jarsigner uses key and certificate information from a keystore to generate digital signatures for JAR files. A keystore is a database of private keys and their associated X.509 certificate chains authenticating the corresponding public keys. The keytool utility is used to create and administer keystores.

jarsigner uses an entity's private key to generate a signature. The signed JAR file contains, among other things, a copy of the certificate from the keystore for the public key corresponding to the private key used to sign the file. jarsigner can verify the digital signature of the signed JAR file using the certificate inside it (in its signature block file).

Starting in J2SE 5.0, jarsigner can generate signatures that include a timestamp, thus enabling systems/deployer (including Java Plug-in) to check whether the JAR file was signed while the signing certificate was still valid. In addition, APIs were added in J2SE 5.0 to allow applications to obtain the timestamp information.

At this time, jarsigner can only sign JAR files created by the SDK jar tool or zip files. (JAR files are the same as zip files, except they also have a META-INF/MANIFEST.MF file. Such a file will automatically be created when jarsigner signs a zip file.)

The default jarsigner behavior is to sign a JAR (or zip) file. Use the -verify option to instead have it verify a signed JAR file.

Compatibility with JDK 1.1

The keytool and jarsigner tools completely replace the javakey tool provided in JDK 1.1. These new tools provide more features than javakey, including the ability to protect the keystore and private keys with passwords, and the ability to verify signatures in addition to generating them.

The new keystore architecture replaces the identity database that javakey created and managed. There is no backwards compatibility between the keystore format and the database format used by javakey in 1.1. However,

  • It is possible to import the information from an identity database into a keystore, via the keytool -identitydb command.
  • jarsigner can sign JAR files also previously signed using javakey.
  • jarsigner can verify JAR files signed using javakey. Thus, it recognizes and can work with signer aliases that are from a JDK 1.1 identity database rather than a Java 2 SDK keystore.

The following table explains how JAR files that were signed in JDK 1.1.x are treated in the Java 2 platform.

JAR File Type

Identity in 1.1 database

Trusted Identity imported into Java 2 Platform keystore from 1.1 database (4)

Policy File grants privileges to Identity/Alias

Privileges Granted

Signed JAR

NO

NO

NO

Default privileges granted to all code.

Unsigned JAR

NO

NO

NO

Default privileges granted to all code.

Signed JAR

NO

YES

NO

Default privileges granted to all code.

Signed JAR

YES/Untrusted

NO

NO

Default privileges granted to all code. (3)

Signed JAR

YES/Untrusted

NO

YES

Default privileges granted to all code. (1,3)

Signed JAR

NO

YES

YES

Default privileges granted to all code plus privileges granted in policy file.

Signed JAR

YES/Trusted

YES

YES

Default privileges granted to all code plus privileges granted in policy file. (2)

Signed JAR

YES/Trusted

NO

NO

All privileges

Signed JAR

YES/Trusted

YES

NO

All privileges (1)

Signed JAR

YES/Trusted

NO

YES

All privileges (1)

Notes:

  1. If an identity/alias is mentioned in the policy file, it must be imported into the keystore for the policy file to have any effect on privileges granted.
  2. The policy file/keystore combination has precedence over a trusted identity in the identity database.
  3. Untrusted identities are ignored in the Java 2 platform.
  4. Only trusted identities can be imported into Java 2 SDK keystores.

Keystore Aliases

All keystore entities are accessed via unique aliases.

When using jarsigner to sign a JAR file, you must specify the alias for the keystore entry containing the private key needed to generate the signature. For example, the following will sign the JAR file named "MyJARFile.jar", using the private key associated with the alias "duke" in the keystore named "mystore" in the "working" directory. Since no output file is specified, it overwrites MyJARFile.jar with the signed JAR file.

    jarsigner -keystore /working/mystore -storepass myspass
      -keypass dukekeypasswd MyJARFile.jar duke

Keystores are protected with a password, so the store password (in this case "myspass") must be specified. You will be prompted for it if you don't specify it on the command line. Similarly, private keys are protected in a keystore with a password, so the private key's password (in this case "dukekeypasswd") must be specified, and you will be prompted for it if you don't specify it on the command line and it isn't the same as the store password.

Keystore Location

jarsigner has a -keystore option for specifying the URL of the keystore to be used. The keystore is by default stored in a file named .keystore in the user's home directory, as determined by the user.home system property. On Solaris systems user.home defaults to the user's home directory.

Note that the input stream from the -keystore option is passed to the KeyStore.load method. If NONE is specified as the URL, then a null stream is passed to the KeyStore.load method. NONE should be specified if the KeyStore is not file-based, for example, if it resides on a hardware token device.

Keystore Implementation

The KeyStore class provided in the java.security package supplies well-defined interfaces to access and modify the information in a keystore. It is possible for there to be multiple different concrete implementations, where each implementation is that for a particular type of keystore.

Currently, there are two command-line tools that make use of keystore implementations (keytool and jarsigner), and also a GUI-based tool named Policy Tool. Since KeyStore is publicly available, Java 2 SDK users can write additional security applications that use it.

There is a built-in default implementation, provided by Sun Microsystems. It implements the keystore as a file, utilizing a proprietary keystore type (format) named "JKS". It protects each private key with its individual password, and also protects the integrity of the entire keystore with a (possibly different) password.

Keystore implementations are provider-based. More specifically, the application interfaces supplied by KeyStore are implemented in terms of a "Service Provider Interface" (SPI). That is, there is a corresponding abstract KeystoreSpi class, also in the java.security package, which defines the Service Provider Interface methods that "providers" must implement. (The term "provider" refers to a package or a set of packages that supply a concrete implementation of a subset of services that can be accessed by the Java Security API.) Thus, to provide a keystore implementation, clients must implement a provider and supply a KeystoreSpi subclass implementation, as described in How to Implement a Provider for the Java Cryptography Architecture.

Applications can choose different types of keystore implementations from different providers, using the "getInstance" factory method supplied in the KeyStore class. A keystore type defines the storage and data format of the keystore information, and the algorithms used to protect private keys in the keystore and the integrity of the keystore itself. Keystore implementations of different types are not compatible.

keytool works on any file-based keystore implementation. (It treats the keytore location that is passed to it at the command line as a filename and converts it to a FileInputStream, from which it loads the keystore information.) The jarsigner and policytool tools, on the other hand, can read a keystore from any location that can be specified using a URL.

For jarsigner and keytool, you can specify a keystore type at the command line, via the -storetype option. For Policy Tool, you can specify a keystore type via the "Change Keystore" command in the Edit menu.

If you don't explicitly specify a keystore type, the tools choose a keystore implementation based simply on the value of the keystore.type property specified in the security properties file. The security properties file is called java.security, and it resides in the SDK security properties directory, java.home/lib/security, where java.home is the runtime environment's directory (the jre directory in the SDK or the top-level directory of the Java 2 Runtime Environment).

Each tool gets the keystore.type value and then examines all the currently-installed providers until it finds one that implements keystores of that type. It then uses the keystore implementation from that provider.

The KeyStore class defines a static method named getDefaultType that lets applications and applets retrieve the value of the keystore.type property. The following line of code creates an instance of the default keystore type (as specified in the keystore.type property):

    KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());

The default keystore type is "jks" (the proprietary type of the keystore implementation provided by Sun). This is specified by the following line in the security properties file:

    keystore.type=jks

Note: Case doesn't matter in keystore type designations. For example, "JKS" would be considered the same as "jks".

To have the tools utilize a keystore implementation other than the default, change that line to specify a different keystore type. For example, if you have a provider package that supplies a keystore implementation for a keystore type called "pkcs12", change the line to

    keystore.type=pkcs12

Note that if you us the PKCS#11 provider package, you should refer to the KeyTool and JarSigner section of the Java PKCS#11 Reference Guide for details.

Supported Algorithms

By default, jarsigner signs a JAR file using either

  • DSA (Digital Signature Algorithm) with the SHA-1 digest algorithm, or
  • the RSA algorithm with the MD5 digest algorithm.

That is, if the signer's public and private keys are DSA keys, jarsigner will sign the JAR file using the "SHA1withDSA" algorithm. If the signer's keys are RSA keys, jarsigner will attempt to sign the JAR file using the "MD5withRSA" algorithm.

These default signature algorithms can be overridden using the -sigalg option.

The Signed JAR File

When jarsigner is used to sign a JAR file, the output signed JAR file is exactly the same as the input JAR file, except that it has two additional files placed in the META-INF directory:

  • a signature file, with a .SF extension, and
  • a signature block file, with a .DSA extension.

The base file names for these two files come from the value of the -sigFile option. For example, if the option appears as

  -sigFile MKSIGN

the files are named "MKSIGN.SF" and "MKSIGN.DSA".

If no -sigfile option appears on the command line, the base file name for the .SF and .DSA files will be the first 8 characters of the alias name specified on the command line, all converted to upper case. If the alias name has fewer than 8 characters, the full alias name is used. If the alias name contains any characters that are not allowed in a signature file name, each such character is converted to an underscore ("_") character in forming the file name. Legal characters include letters, digits, underscores, and hyphens.

The Signature (.SF) File

A signature file (the .SF file) looks similar to the manifest file that is always included in a JAR file when jarsigner is used to sign the file. That is, for each source file included in the JAR file, the .SF file has three lines, just as in the manifest file, listing the following:

  • the file name,
  • the name of the digest algorithm used (SHA), and
  • a SHA digest value.

In the manifest file, the SHA digest value for each source file is the digest (hash) of the binary data in the source file. In the .SF file, on the other hand, the digest value for a given source file is the hash of the three lines in the manifest file for the source file.

The signature file also, by default, includes a header containing a hash of the whole manifest file. The presence of the header enables verification optimization, as described in JAR File Verification.

The Signature Block (.DSA) File

The .SF file is signed and the signature is placed in the .DSA file. The .DSA file also contains, encoded inside it, the certificate or certificate chain from the keystore which authenticates the public key corresponding to the private key used for signing.

Signature Timestamp

As of the J2SE 5.0 release, the jarsigner tool can now generate and store a signature timestamp when signing a JAR file. In addition, jarsigner supports alternative signing mechanisms. This behavior is optional and is controlled by the user at the time of signing through these options:

  • -tsa url
  • -tsacert alias
  • -altsigner class
  • -altsignerpath classpathlist

Each of these options is detailed in the Options section below.

JAR File Verification

A successful JAR file verification occurs if the signature(s) are valid, and none of the files that were in the JAR file when the signatures were generated have been changed since then. JAR file verification involves the following steps:

  1. Verify the signature of the .SF file itself.

    That is, the verification ensures that the signature stored in each signature block (.DSA) file was in fact generated using the private key corresponding to the public key whose certificate (or certificate chain) also appears in the .DSA file. It also ensures that the signature is a valid signature of the corresponding signature (.SF) file, and thus the .SF file has not been tampered with.

  2. Verify the digest listed in each entry in the .SF file with each corresponding section in the manifest.

    The .SF file by default includes a header containing a hash of the entire manifest file. When the header is present, then the verification can check to see whether or not the hash in the header indeed matches the hash of the manifest file. If that is the case, verification proceeds to the next step.

    If that is not the case, a less optimized verification is required to ensure that the hash in each source file information section in the .SF file equals the hash of its corresponding section in the manifest file (see The Signature (.SF) File).

    One reason the hash of the manifest file that is stored in the .SF file header may not equal the hash of the current manifest file would be because one or more files were added to the JAR file (using the jar tool) after the signature (and thus the .SF file) was generated. When the jar tool is used to add files, the manifest file is changed (sections are added to it for the new files), but the .SF file is not. A verification is still considered successful if none of the files that were in the JAR file when the signature was generated have been changed since then, which is the case if the hashes in the non-header sections of the .SF file equal the hashes of the corresponding sections in the manifest file.

  3. Read each file in the JAR file that has an entry in the .SF file. While reading, compute the file's digest, and then compare the result with the digest for this file in the manifest section. The digests should be the same, or verification fails.

If any serious verification failures occur during the verification process, the process is stopped and a security exception is thrown. It is caught and displayed by jarsigner.

Multiple Signatures for a JAR File

A JAR file can be signed by multiple people simply by running the jarsigner tool on the file multiple times, specifying the alias for a different person each time, as in:

  jarsigner myBundle.jar susan
  jarsigner myBundle.jar kevin

When a JAR file is signed multiple times, there are multiple .SF and .DSA files in the resulting JAR file, one pair for each signature. Thus, in the example above, the output JAR file includes files with the following names:

  SUSAN.SF
  SUSAN.DSA
  KEVIN.SF
  KEVIN.DSA

Note: It is also possible for a JAR file to have mixed signatures, some generated by the JDK 1.1 javakey tool and others by jarsigner. That is, jarsigner can be used to sign JAR files already previously signed using javakey.

OPTIONS

The various jarsigner options are listed and described below. Note:

  • All option names are preceded by a minus sign (-).
  • The options may be provided in any order.
  • Items in italics (option values) represent the actual values that must be supplied.
  • The -keystore, -storepass, -keypass, -sigfile, -sigalg, -digestalg, and -signedjar options are only relevant when signing a JAR file, not when verifying a signed JAR file. Similarly, an alias is only specified on the command line when signing a JAR file.
-keystore url
Specifies the URL that tells the keystore location. This defaults to the file .keystore in the user's home directory, as determined by the "user.home" system property.

A keystore is required when signing, so you must explicitly specify one if the default keystore does not exist (or you want to use one other than the default).

A keystore is not required when verifying, but if one is specified, or the default exists, and the -verbose option was also specified, additional information is output regarding whether or not any of the certificates used to verify the JAR file are contained in that keystore.

Note: the -keystore argument can actually be a file name (and path) specification rather than a URL, in which case it will be treated the same as a "file:" URL. That is,

  -keystore filePathAndName
is treated as equivalent to
  -keystore file:filePathAndName
If the Sun PKCS#11 provider has been configured in the java.security security properties file (located in the JRE's $JAVA_HOME/lib/security directory), then keytool and jarsigner can operate on the PKCS#11 token by specifying these options:
  • -keystore NONE
  • -storetype PKCS11
For example, this command lists the contents of the configured PKCS#11 token:
   jarsigner -keystore NONE -storetype PKCS11 -list
-storetype storetype
Specifies the type of keystore to be instantiated. The default keystore type is the one that is specified as the value of the "keystore.type" property in the security properties file, which is returned by the static getDefaultType method in java.security.KeyStore.

The PIN for a PCKS#11 token can also be specified using the -storepass option. If none has been specified, keytool and jarsigner will prompt for the token PIN. If the token has a protected authentication path (such as a dedicated PIN-pad or a biometric reader), then the -protected option must be specified and no password options can be specified.

-storepass password
Specifies the password which is required to access the keystore. This is only needed when signing (not verifying) a JAR file. In that case, if a -storepass option is not provided at the command line, the user is prompted for the password.

Note: The password shouldn't be specified on the command line or in a script unless it is for testing purposes, or you are on a secure system. Also, when typing in a password at the password prompt, the password is echoed (displayed exactly as typed), so be careful not to type it in front of anyone.

-keypass password
Specifies the password used to protect the private key of the keystore entry addressed by the alias specified on the command line. The password is required when using jarsigner to sign a JAR file. If no password is provided on the command line, and the required password is different from the store password, the user is prompted for it.

Note: The password shouldn't be specified on the command line or in a script unless it is for testing purposes, or you are on a secure system. Also, when typing in a password at the password prompt, the password is echoed (displayed exactly as typed), so be careful not to type it in front of anyone.

-sigfile file
Specifies the base file name to be used for the generated .SF and .DSA files. For example, if file is "DUKESIGN", the generated .SF and .DSA files will be named "DUKESIGN.SF" and "DUKESIGN.DSA", and will be placed in the "META-INF" directory of the signed JAR file.

The characters in file must come from the set "a-zA-Z0-9_-". That is, only letters, numbers, underscore, and hyphen characters are allowed. Note: All lowercase characters will be converted to uppercase for the .SF and .DSA file names.

If no -sigfile option appears on the command line, the base file name for the .SF and .DSA files will be the first 8 characters of the alias name specified on the command line, all converted to upper case. If the alias name has fewer than 8 characters, the full alias name is used. If the alias name contains any characters that are not legal in a signature file name, each such character is converted to an underscore ("_") character in forming the file name.

-sigalg algorithm
Specifies the name of the signature algorithm to use to sign the JAR file.

See Appendix A of the Java Cryptography Architecture for a list of standard signature algorithm names. This algorithm must be compatible with the private key used to sign the JAR file. If this option is not specified, SHA1withDSA or MD5withRSA will be used depending on the type of private key. There must either be a statically installed provider supplying an implementation of the specified algorithm or the user must specify one with the -providerClass option, otherwise the command will not succeed.

-digestalg algorithm
Specifies the name of the message digest algorithm to use when digesting the entries of a jar file.

See Appendix A of the Java Cryptography Architecture for a list of standard message digest algorithm names. If this option is not specified, SHA-1 will be used. There must either be a statically installed provider supplying an implementation of the specified algorithm or the user must specify one with the -providerClass option, otherwise the command will not succeed.

-signedjar file
Specifies the name to be used for the signed JAR file.

If no name is specified on the command line, the name used is the same as the input JAR file name (the name of the JAR file to be signed); in other words, that file is overwritten with the signed JAR file.

-verify
If this appears on the command line, the specified JAR file will be verified, not signed. If the verification is successful, "jar verified" will be displayed. If you try to verify an unsigned JAR file, or a JAR file signed with an unsupported algorithm (e.g., RSA when you don't have an RSA provider installed), the following is displayed: "jar is unsigned. (signatures missing or not parsable)"

It is possible to verify JAR files signed using either jarsigner or the JDK 1.1 javakey tool, or both.

For further information on verification, see JAR File Verification.

-certs
If this appears on the command line, along with the -verify and -verbose options, the output includes certificate information for each signer of the JAR file. This information includes
  • the name of the type of certificate (stored in the .DSA file) that certifies the signer's public key
  • if the certificate is an X.509 certificate (more specifically, an instance of java.security.cert.X509Certificate): the distinguished name of the signer

The keystore is also examined. If no keystore value is specified on the command line, the default keystore file (if any) will be checked. If the public key certificate for a signer matches an entry in the keystore, then the following information will also be displayed:

  • in parentheses, the alias name for the keystore entry for that signer. If the signer actually comes from a JDK 1.1 identity database instead of from a keystore, the alias name will appear in brackets instead of parentheses.
-verbose
If this appears on the command line, it indicates "verbose" mode, which causes jarsigner to output extra information as to the progress of the JAR signing or verification.
-internalsf
In the past, the .DSA (signature block) file generated when a JAR file was signed used to include a complete encoded copy of the .SF file (signature file) also generated. This behavior has been changed. To reduce the overall size of the output JAR file, the .DSA file by default doesn't contain a copy of the .SF file anymore. But if -internalsf appears on the command line, the old behavior is utilized. This option is mainly useful for testing; in practice, it should not be used, since doing so eliminates a useful optimization.
-sectionsonly
If this appears on the command line, the .SF file (signature file) generated when a JAR file is signed does not include a header containing a hash of the whole manifest file. It just contains information and hashes related to each individual source file included in the JAR file, as described in The Signature (.SF) File .

By default, this header is added, as an optimization. When the header is present, then whenever the JAR file is verified, the verification can first check to see whether or not the hash in the header indeed matches the hash of the whole manifest file. If so, verification proceeds to the next step. If not, it is necessary to do a less optimized verification that the hash in each source file information section in the .SF file equals the hash of its corresponding section in the manifest file.

For further information, see JAR File Verification.

This option is mainly useful for testing; in practice, it should not be used, since doing so eliminates a useful optimization.

-protected
Either true or false. This value should be specified as true if a password must be given via a protected authentication path such as a dedicated PIN reader.

-provider provider-class-name
Used to specify the name of cryptographic service provider's master class file when the service provider is not listed in the security properties file, java.security.

Used in conjunction with the -providerArg ConfigFilePath option, keytool and jarsigner will install the provider dynamically (where ConfigFilePath is the path to the token configuration file). Here's an example of a command to list a PKCS#11 keystore when the Sun PKCS#11 provider has not been configured in the security properties file.

jarsigner -keystore NONE -storetype PKCS11 \
          -providerClass sun.security.pkcs11.SunPKCS11 \
          -providerArg /foo/bar/token.config \
          -list
-providerName providerName
If more than one provider has been configured in the java.security security properties file, you can use the -providerName option to target a specific provider instance. The argument to this option is the name of the provider.

For the Sun PKCS#11 provider, providerName is of the form SunPKCS11-TokenName, where TokenName is the name suffix that the provider instance has been configured with, as detailed in the configuration attributes table. For example, the following command lists the contents of the PKCS#11 keystore provider instance with name suffix SmartCard:

jarsigner -keystore NONE -storetype PKCS11 \
        -providerName SunPKCS11-SmartCard \
        -list
-J javaoption
Passes through the specified javaoption string directly to the Java interpreter. (jarsigner is actually a "wrapper" around the interpreter.) This option should not contain any spaces. It is useful for adjusting the execution environment or memory usage. For a list of possible interpreter options, type java -h or java -X at the command line.

-tsa url
If "-tsa http://example.tsa.url" appears on the command line when signing a JAR file then a timestamp is generated for the signature. The URL, http://example.tsa.url, identifies the location of the Time Stamping Authority (TSA). It overrides any URL found via the -tsacert option. The -tsa option does not require the TSA's public key certificate to be present in the keystore.

To generate the timestamp, jarsigner communicates with the TSA using the Time-Stamp Protocol (TSP) defined in RFC 3161. If successful, the timestamp token returned by the TSA is stored along with the signature in the signature block file.

-tsacert alias
If "-tsacert alias" appears on the command line when signing a JAR file then a timestamp is generated for the signature. The alias identifies the TSA's public key certificate in the keystore that is currently in effect. The entry's certificate is examined for a Subject Information Access extension that contains a URL identifying the location of the TSA.

The TSA's public key certificate must be present in the keystore when using -tsacert.

-altsigner class
Specifies that an alternative signing mechanism be used. The fully-qualified class name identifies a class file that extends the com.sun.jarsigner.ContentSigner abstract class. The path to this class file is defined by the -altsignerpath option. If the -altsigner option is used, jarsigner uses the signing mechanism provided by the specified class. Otherwise, jarsigner uses its default signing mechanism.

For example, to use the signing mechanism provided by a class named com.sun.sun.jarsigner.AuthSigner, use the jarsigner option "-altsigner com.sun.jarsigner.AuthSigner"

-altsignerpath classpathlist
Specifies the path to the class file (the class file name is specified with the -altsigner option described above) and any JAR files it depends on. If the class file is in a JAR file, then this specifies the path to that JAR file, as shown in the example below.

An absolute path or a path relative to the current directory may be specified. If classpathlist contains multiple paths or JAR files, they should be separated with a colon (:) on Solaris and a semi-colon (;) on Windows. This option is not necessary if the class is already in the search path.

Example of specifying the path to a jar file that contains the class file:

-altsignerpath /home/user/lib/authsigner.jar

Note that the JAR file name is included.

Example of specifying the path to the jar file that contains the class file:

-altsignerpath /home/user/classes/com/sun/tools/jarsigner/

Note that the JAR file name is omitted.

EXAMPLES

Signing a JAR File

Suppose you have a JAR file named "bundle.jar" and you'd like to sign it using the private key of the user whose keystore alias is "jane" in the keystore named "mystore" in the "working" directory. Suppose the keystore password is "myspass" and the password for jane's private key is "j638klm". You can use the following to sign the JAR file and name the signed JAR file "sbundle.jar":

    jarsigner -keystore /working/mystore -storepass myspass
      -keypass j638klm -signedjar sbundle.jar bundle.jar jane

Note that there is no -sigfile specified in the command above, so the generated .SF and .DSA files to be placed in the signed JAR file will have default names based on the alias name. That is, they will be named JANE.SF and JANE.DSA.

If you want to be prompted for the store password and the private key password, you could shorten the above command to

    jarsigner -keystore /working/mystore
      -signedjar sbundle.jar bundle.jar jane

If the keystore to be used is the default keystore (the one named ".keystore" in your home directory), you don't need to specify a keystore, as in:

    jarsigner -signedjar sbundle.jar bundle.jar jane

Finally, if you want the signed JAR file to simply overwrite the input JAR file (bundle.jar), you don't need to specify a -signedjar option:

    jarsigner bundle.jar jane

Verifying a Signed JAR File

To verify a signed JAR file, that is, to verify that the signature is valid and the JAR file has not been tampered with, use a command such as the following:

    jarsigner -verify sbundle.jar

If the verification is successful,

    jar verified.

is displayed. Otherwise, an error message appears.

You can get more information if you use the -verbose option. A sample use of jarsigner with the -verbose option is shown below, along with sample output:

    jarsigner -verify -verbose sbundle.jar

           198 Fri Sep 26 16:14:06 PDT 1997 META-INF/MANIFEST.MF
           199 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.SF
          1013 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.DSA
    smk   2752 Fri Sep 26 16:12:30 PDT 1997 AclEx.class
    smk    849 Fri Sep 26 16:12:46 PDT 1997 test.class

      s = signature was verified
      m = entry is listed in manifest
      k = at least one certificate was found in keystore

    jar verified.

Verification with Certificate Information

If you specify the -certs option when verifying, along with the -verify and -verbose options, the output includes certificate information for each signer of the JAR file, including the certificate type, the signer distinguished name information (iff it's an X.509 certificate), and, in parentheses, the keystore alias for the signer if the public key certificate in the JAR file matches that in a keystore entry. For example,

    jarsigner -keystore /working/mystore -verify -verbose -certs myTest.jar

           198 Fri Sep 26 16:14:06 PDT 1997 META-INF/MANIFEST.MF
           199 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.SF
          1013 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.DSA
           208 Fri Sep 26 16:23:30 PDT 1997 META-INF/JAVATEST.SF
          1087 Fri Sep 26 16:23:30 PDT 1997 META-INF/JAVATEST.DSA
    smk   2752 Fri Sep 26 16:12:30 PDT 1997 Tst.class

      X.509, CN=Test Group, OU=Java Software, O=Sun Microsystems, L=CUP, S=CA, C=US (javatest)
      X.509, CN=Jane Smith, OU=Java Software, O=Sun, L=cup, S=ca, C=us (jane)

      s = signature was verified
      m = entry is listed in manifest
      k = at least one certificate was found in keystore

    jar verified.

If the certificate for a signer is not an X.509 certificate, there is no distinguished name information. In that case, just the certificate type and the alias are shown. For example, if the certificate is a PGP certificate, and the alias is "bob", you'd get

      PGP, (bob)

Verification of a JAR File that Includes Identity Database Signers

If a JAR file has been signed using the JDK 1.1 javakey tool, and thus the signer is an alias in an identity database, the verification output includes an "i" symbol. If the JAR file has been signed by both an alias in an identity database and an alias in a keystore, both "k" and "i" appear.

When the -certs option is used, any identity database aliases are shown in square brackets rather than the parentheses used for keystore aliases. For example:

    jarsigner -keystore /working/mystore -verify -verbose -certs writeFile.jar

           198 Fri Sep 26 16:14:06 PDT 1997 META-INF/MANIFEST.MF
           199 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.SF
          1013 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.DSA
           199 Fri Sep 27 12:22:30 PDT 1997 META-INF/DUKE.SF
          1013 Fri Sep 27 12:22:30 PDT 1997 META-INF/DUKE.DSA
   smki   2752 Fri Sep 26 16:12:30 PDT 1997 writeFile.html

      X.509, CN=Jane Smith, OU=Java Software, O=Sun, L=cup, S=ca, C=us (jane)
      X.509, CN=Duke, OU=Java Software, O=Sun, L=cup, S=ca, C=us [duke]

      s = signature was verified
      m = entry is listed in manifest
      k = at least one certificate was found in keystore
      i = at least one certificate was found in identity scope

    jar verified.

Note that the alias "duke" is in brackets to denote that it is an identity database alias, not a keystore alias.

SEE ALSO

  • jar tool documentation
  • keytool tool documentation
  • the Security trail of the Java Tutorial for examples of the use of the jarsigner tool

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


java - the Java application launcher

  • Synopsis
  • Description
  • Options
  • See Also

SYNOPSIS

    java [ options ] class [ argument ... ]
    java [ options ] -jar file.jar [ argument ... ]
options
Command-line options.
class
Name of the class to be invoked.
file.jar
Name of the jar file to be invoked. Used only with -jar.
argument
Argument passed to the main function.

DESCRIPTION

The java tool launches a Java application. It does this by starting a Java runtime environment, loading a specified class, and invoking that class's main method.

The method must be declared public and static, it must not return any value, and it must accept a String array as a parameter. The method declaration must look like the following:

    public static void main(String args[])

By default, the first non-option argument is the name of the class to be invoked. A fully-qualified class name should be used. If the -jar option is specified, the first non-option argument is the name of a JAR archive containing class and resource files for the application, with the startup class indicated by the Main-Class manifest header.

The Java runtime searches for the startup class, and other classes used, in three sets of locations: the bootstrap class path, the installed extensions, and the user class path.

Non-option arguments after the class name or JAR file name are passed to the main function.

OPTIONS

The launcher has a set of standard options that are supported on the current runtime environment and will be supported in future releases. In addition, the current implementations of the virtual machines support a set of non-standard options that are subject to change in future releases.

Standard Options

-client

Select the Java HotSpot Client VM. A 64-bit capable jdk currently ignores this option and instead uses the Java Hotspot Server VM.

For default VM selection, see Server-Class Machine Detection

-server

Select the Java HotSpot Server VM. On a 64-bit capable jdk only the Java Hotspot Server VM is supported so the -server option is implicit.

For default VM selection, see Server-Class Machine Detection

-agentlib:libname[=options]
Load native agent library libname, e.g.

-agentlib:hprof

-agentlib:jdwp=help

-agentlib:hprof=help

For more information, see JVMTI Agent Command Line Options.

-agentpath:pathname[=options]
Load a native agent library by full pathname. For more information, see JVMTI Agent Command Line Options.
-classpath classpath
-cp classpath
Specify a list of directories, JAR archives, and ZIP archives to search for class files. Class path entries are separated by colons (:). Specifying -classpath or -cp overrides any setting of the CLASSPATH environment variable.

If -classpath and -cp are not used and CLASSPATH is not set, the user class path consists of the current directory (.).

As a special convenience, a class path element containing a basename of * is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR (a java program cannot tell the difference between the two invocations).

For example, if directory foo contains a.jar and b.JAR, then the class path element foo/* is expanded to a A.jar:b.JAR, except that the order of jar files is unspecified. All jar files in the specified directory, even hidden ones, are included in the list. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. The CLASSPATH environment variable, where defined, will be similarly expanded. Any classpath wildcard expansion occurs before the Java virtual machine is started -- no Java program will ever see unexpanded wildcards except by querying the environment. For example; by invoking System.getenv("CLASSPATH").

For more information on class paths, see Setting the Class Path.

-D property=value
Set a system property value.
-d32
-d64
Request that the program to be run in a 32-bit or 64-bit environment, respectively. If the requested environment is not installed or is not supported, an error is reported.

Currently only the Java HotSpot Server VM supports 64-bit operation, and the "-server" option is implicit with the use of -d64. And the "-client" option is ignored with the use of -d64. This is subject to change in a future release.

If neither -d32 nor -d64 is specified, the default is to run in a 32-bit environment, except for 64-bit only systems. This is subject to change in a future release.

-enableassertions[:<package name>"..." | :<class name> ]
-ea[:<package name>"..." | :<class name> ]
Enable assertions. Assertions are disabled by default.

With no arguments, enableassertions or -ea enables assertions. With one argument ending in "...", the switch enables assertions in the specified package and any subpackages. If the argument is simply "...", the switch enables assertions in the unnamed package in the current working directory. With one argument not ending in "...", the switch enables assertions in the specified class.

If a single command line contains multiple instances of these switches, they are processed in order before loading any classes. So, for example, to run a program with assertions enabled only in package com.wombat.fruitbat (and any subpackages), the following command could be used:

java -ea:com.wombat.fruitbat... <Main Class>

The -enableassertions and -ea switches apply to all class loaders and to system classes (which do not have a class loader). There is one exception to this rule: in their no-argument form, the switches do not apply to system. This makes it easy to turn on asserts in all classes except for system classes. A separate switch is provided to enable asserts in all system classes; see -enablesystemassertions below.

-disableassertions[:<package name>"..." | :<class name> ]
-da[:<package name>"..." | :<class name> ]
Disable assertions. This is the default.

With no arguments, disableassertions or -da disables assertions. With one argument ending in "...", the switch disables assertions in the specified package and any subpackages. If the argument is simply "...", the switch disables assertions in the unnamed package in the current working directory. With one argument not ending in "...", the switch disables assertions in the specified class.

To run a program with assertions enabled in package com.wombat.fruitbat but disabled in class com.wombat.fruitbat.Brickbat, the following command could be used:

java -ea:com.wombat.fruitbat... -da:com.wombat.fruitbat.Brickbat <Main Class>

The -disableassertions and -da switches apply to all class loaders and to system classes (which do not have a class loader). There is one exception to this rule: in their no-argument form, the switches do not apply to system. This makes it easy to turn on asserts in all classes except for system classes. A separate switch is provided to enable asserts in all system classes; see -disablesystemassertions below.

-enablesystemassertions
-esa
Enable asserts in all system classes (sets the default assertion status for system classes to true).
-disablesystemassertions
-dsa
Disables asserts in all system classes.

-jar
Execute a program encapsulated in a JAR file. The first argument is the name of a JAR file instead of a startup class name. In order for this option to work, the manifest of the JAR file must contain a line of the form Main-Class: classname. Here, classname identifies the class having the public static void main(String[] args) method that serves as your application's starting point. See the Jar tool reference page and the Jar trail of the Java Tutorial for information about working with Jar files and Jar-file manifests.

When you use this option, the JAR file is the source of all user classes, and other user class path settings are ignored.

Note that JAR files that can be run with the "java -jar" option can have their execute permissions set so they can be run without using "java -jar". Refer to Java Archive (JAR) Files.

-javaagent:jarpath[=options]
Load a Java programming language agent, see java.lang.instrument.
-verbose
-verbose:class
Display information about each class loaded.
-verbose:gc
Report on each garbage collection event.
-verbose:jni
Report information about use of native methods and other Java Native Interface activity.
-version
Display version information and exit.
-version:release
Specifies that the version specified by release is required by the class or jar file specified on the command line. If the version of the java command invoked does not meet this specification and an appropriate implementation is found on the system, the appropriate implementation will be used.

release not only can specify an exact version, but can also specify a list of versions called a version string. A version string is an ordered list of version ranges separated by spaces. A version range is either a version-id, a version-id followed by a star (*), a version-id followed by a plus sign (+) , or two version-ranges combined using an ampersand (&). The star means prefix match, the plus sign means this version or greater, and the ampersand means the logical anding of the two version-ranges. For example:

-version:"1.5.0_04 1.5*&1.5.1_02+"
The meaning of the above is that the class or jar file requires either version 1.5.0_02, or a version with 1.5 as a version-id prefix and that is not less than 1.5.1_02. The exact syntax and definition of version strings may be found in Appendix A of the Java Network Launching Protocol & API Specification (JSR-56).

For jar files, the usual preference is to specify version requirements in the jar file manifest rather than on the command line.

See the following NOTES section for important policy information on the use of this option.

-showversion
Display version information and continue.
-?
-help
Display usage information and exit.
-X
Display information about non-standard options and exit.

Non-Standard Options

-Xint
Operate in interpreted-only mode. Compilation to native code is disabled, and all bytecodes are executed by the interpreter. The performance benefits offered by the Java HotSpot VMs' adaptive compiler will not be present in this mode.
-Xbatch
Disable background compilation. Normally the VM will compile the method as a background task, running the method in interpreter mode until the background compilation is finished. The -Xbatch flag disables background compilation so that compilation of all methods proceeds as a foreground task until completed.
-Xbootclasspath:bootclasspath
Specify a colon-separated list of directories, JAR archives, and ZIP archives to search for boot class files. These are used in place of the boot class files included in the Java 2 SDK. Note: Applications that use this option for the purpose of overriding a class in rt.jar should not be deployed as doing so would contravene the Java 2 Runtime Environment binary code license.
-Xbootclasspath/a:path
Specify a colon-separated path of directires, JAR archives, and ZIP archives to append to the default bootstrap class path.
-Xbootclasspath/p:path
Specify a colon-separated path of directires, JAR archives, and ZIP archives to prepend in front of the default bootstrap class path. Note: Applications that use this option for the purpose of overriding a class in rt.jar should not be deployed as doing so would contravene the Java 2 Runtime Environment binary code license.
-Xcheck:jni
Perform additional checks for Java Native Interface (JNI) functions. Specifically, the Java Virtual Machine validates the parameters passed to the JNI function as well as the runtime environment data before processing the JNI request. Any invalid data encountered indicates a problem in the native code, and the Java Virtual Machine will terminate with a fatal error in such cases. Expect a performance degradation when this option is used.
-Xfuture
Perform strict class-file format checks. For purposes of backwards compatibility, the default format checks performed by the Java 2 SDK's virtual machine are no stricter than the checks performed by 1.1.x versions of the JDK software. The -Xfuture flag turns on stricter class-file format checks that enforce closer conformance to the class-file format specification. Developers are encouraged to use this flag when developing new code because the stricter checks will become the default in future releases of the Java application launcher.
-Xnoclassgc
Disable class garbage collection. Use of this option will prevent memory recovery from loaded classes thus increasing overall memory usage. This could cause OutOfMemoryError to be thrown in some applications.
-Xincgc
Enable the incremental garbage collector. The incremental garbage collector, which is off by default, will reduce the occasional long garbage-collection pauses during program execution. The incremental garbage collector will at times execute concurrently with the program and during such times will reduce the processor capacity available to the program.
-Xloggc:file
Report on each garbage collection event, as with -verbose:gc, but log this data to file. In addition to the information -verbose:gc gives, each reported event will be preceeded by the time (in seconds) since the first garbage-collection event.

Always use a local file system for storage of this file to avoid stalling the JVM due to network latency. The file may be truncated in the case of a full file system and logging will continue on the truncated file. This option overrides -verbose:gc if both are given on the command line.

-Xms n
Specify the initial size, in bytes, of the memory allocation pool. This value must be a multiple of 1024 greater than 1MB. Append the letter k or K to indicate kilobytes, or m or M to indicate megabytes. The default value is chosen at runtime based on system configuration. For more information, see HotSpot Ergonomics
Examples:
       -Xms6291456
       -Xms6144k
       -Xms6m
-Xmx n
Specify the maximum size, in bytes, of the memory allocation pool. This value must a multiple of 1024 greater than 2MB. Append the letter k or K to indicate kilobytes, or m or M to indicate megabytes. The default value is chosen at runtime based on system configuration. For more information, see HotSpot Ergonomics
Examples:
       -Xmx83886080
       -Xmx81920k
       -Xmx80m
On Solaris 7 and Solaris 8 SPARC platforms, the upper limit for this value is approximately 4000m minus overhead amounts. On Solaris 2.6 and x86 platforms, the upper limit is approximately 2000m minus overhead amounts. On Linux platforms, the upper limit is approximately 2000m minus overhead amounts.
-Xprof
Profiles the running program, and sends profiling data to standard output. This option is provided as a utility that is useful in program development and is not intended to be be used in production systems.

-Xrs
Reduces use of operating-system signals by the Java virtual machine (JVM).

In a previous release, the Shutdown Hooks facility was added to allow orderly shutdown of a Java application. The intent was to allow user cleanup code (such as closing database connections) to run at shutdown, even if the JVM terminates abruptly.

Sun's JVM catches signals to implement shutdown hooks for abnormal JVM termination. The JVM uses SIGHUP, SIGINT, and SIGTERM to initiate the running of shutdown hooks.

The JVM uses a similar mechanism to implement the pre-1.2 feature of dumping thread stacks for debugging purposes. Sun's JVM uses SIGQUIT to perform thread dumps.

Applications embedding the JVM frequently need to trap signals like SIGINT or SIGTERM, which can lead to interference with the JVM's own signal handlers. The -Xrs command-line option is available to address this issue. When -Xrs is used on Sun's JVM, the signal masks for SIGINT, SIGTERM, SIGHUP, and SIGQUIT are not changed by the JVM, and signal handlers for these signals are not installed.

There are two consequences of specifying -Xrs:

  • SIGQUIT thread dumps are not available.
  • User code is responsible for causing shutdown hooks to run, for example by calling System.exit() when the JVM is to be terminated.
-Xss n
Set thread stack size.
-XX:+UseAltSigs
The VM uses SIGUSR1 and SIGUSR2 by default, which can sometimes conflict with applications that signal-chain SIGUSR1 and SIGUSR2. The -XX:+UseAltSigs option will cause the VM to use signals other than SIGUSR1 and SIGUSR2 as the default.

NOTES

The -version:release command line option places no restrictions on the complexity of the release specification. However, only a restricted subset of the possible release specifications represent sound policy and only these are fully supported. These policies are:

  1. Any version, represented by not using this option.

  2. Any version greater than an arbitrarily precise version-id. For example:
    "1.5.0_03+"

    Would utilize any version greater than 1.5.0_03. This is useful for a case where an interface was introduced (or a bug fixed) in the release specified.

  3. A version greater than an arbitrarily precise version-id, bounded by the upper bound of that release family. For example:
    "1.5.0_03+&1.5*"
  4. "Or" expressions of items 2. or 3. above. For example:
    "1.4.2_05+&1.4* 1.5+"
    Similar to item 2. this is useful when a change was introduced in a release (1.5) but also made available in updates to previous releases.

SEE ALSO

  • javac - the Java programming language compiler
  • jdb - Java Application Debugger
  • javah - C Header and Stub File Generator
  • jar - JAR Archive Tool
  • The Java Extensions Framework
  • Security Features.
  • HotSpot VM Specific Options.

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


javac - Java programming language compiler

  • Synopsis
  • Description
  • Options
  • Command Line Argument Files
  • Annotation Processing
  • Searching for Types
  • Programmatic Interface
  • Examples
  • See Also

SYNOPSIS

    javac [ options ] [ sourcefiles ] [ classes ] [ @argfiles ]

Arguments may be in any order.

options
Command-line options.
sourcefiles
One or more source files to be compiled (such as MyClass.java).
classes
One or more classes to be processed for annotations (such as MyPackage.MyClass).
@argfiles
One or more files that lists options and source files. The -J options are not allowed in these files.

DESCRIPTION

The javac tool reads class and interface definitions, written in the Java programming language, and compiles them into bytecode class files. It can also process annotations in Java source files and classes.

There are two ways to pass source code file names to javac:

  • For a small number of source files, simply list the file names on the command line.
  • For a large number of source files, list the file names in a file, separated by blanks or line breaks. Then use the list file name on the javac command line, preceded by an @ character.

Source code file names must have .java suffixes, class file names must have .class suffixes, and both source and class files must have root names that identify the class. For example, a class called MyClass would be written in a source file called MyClass.java and compiled into a bytecode class file called MyClass.class.

Inner class definitions produce additional class files. These class files have names combining the inner and outer class names, such as MyClass$MyInnerClass.class.

You should arrange source files in a directory tree that reflects their package tree. For example, if you keep all your source files in /workspace, the source code for com.mysoft.mypack.MyClass should be in /workspace/com/mysoft/mypack/MyClass.java.

By default, the compiler puts each class file in the same directory as its source file. You can specify a separate destination directory with -d (see Options, below).

OPTIONS

The compiler has a set of standard options that are supported on the current development environment and will be supported in future releases. An additional set of non-standard options are specific to the current virtual machine and compiler implementations and are subject to change in the future. Non-standard options begin with -X.

Standard Options

-A key[=value]
Options to pass to annotation processors. These are not interpreted by javac directly, but are made available for use by individual processors. key should be one or more identifiers separated by ".".
-cp path or -classpath path
Specify where to find user class files, and (optionally) annotation processors and source files. This classpath overrides the user class path in the CLASSPATH environment variable. If neither CLASSPATH, -cp nor -classpath is specified, the user class path consists of the current directory. See Setting the Class Path for more details.

If the -sourcepath option is not specified, the user class path is also searched for source files.

If the -processorpath option is not specified, the classpath is also searched for annotation processors.

As a special convenience, a class path element containing a basename of * is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR.

For example, if directory foo contains a.jar and b.JAR, then the class path element foo/* is expanded to A.jar:b.JAR, except that the order of jar files is unspecified. All jar files in the specified directory, even hidden ones, are included in the list. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. The CLASSPATH environment variable, where defined, will be similarly expanded. Note: Depending of the configuration of your command line environment, you may have to quote the wild card character, for example, javac -cp "*.jar" MyClass.java.

-Djava.ext.dirs=directories
Override the location of installed extensions.
-Djava.endorsed.dirs=directories
Override the location of endorsed standards path.
-d directory
Set the destination directory for class files. The directory must already exist; javac will not create it. If a class is part of a package, javac puts the class file in a subdirectory reflecting the package name, creating directories as needed. For example, if you specify -d /home/myclasses and the class is called com.mypackage.MyClass, then the class file is called /home/myclasses/com/mypackage/MyClass.class.

If -d is not specified, javac puts each class files in the same directory as the source file from which it was generated.

Note: The directory specified by -d is not automatically added to your user class path.

-deprecation
Show a description of each use or override of a deprecated member or class. Without -deprecation, javac shows a summary of the source files that use or override deprecated members or classes. -deprecation is shorthand for -Xlint:deprecation.
-encoding encoding
Set the source file encoding name, such as EUC-JP and UTF-8. If -encoding is not specified, the platform default converter is used.
-g
Generate all debugging information, including local variables. By default, only line number and source file information is generated.
-g:none
Do not generate any debugging information.
-g:{keyword list}
Generate only some kinds of debugging information, specified by a comma separated list of keywords. Valid keywords are:
source
Source file debugging information
lines
Line number debugging information
vars
Local variable debugging information
-help
Print a synopsis of standard options.
-implicit:{class,none}
Controls the generation of class files for implicitly loaded source files. To automatically generate class files, use -implicit:class. To suppress class file generation, use -implicit:none. If this option is not specified, the default is to automatically generate class files. In this case, the compiler will issue a warning if any such class files are generated when also doing annotation processing. The warning will not be issued if this option is set explicitly. See Searching For Types.
-nowarn
Disable warning messages. This has the same meaning as -Xlint:none.
-proc: {none,only}
Controls whether annotation processing and/or compilation is done. -proc:none means that compilation takes place without annotation processing. -proc:only means that only annotation processing is done, without any subsequent compilation.
-processor class1[,class2,class3...]
Names of the annotation processors to run. This bypasses the default discovery process.
-processorpath path
Specify where to find annotation processors; if this option is not used, the classpath will be searched for processors.
-s dir
Specify the directory where to place generated source files. The directory must already exist; javac will not create it. If a class is part of a package, the compiler puts the source file in a subdirectory reflecting the package name, creating directories as needed. For example, if you specify -s /home/mysrc and the class is called com.mypackage.MyClass, then the source file will be placed in /home/mysrc/com/mypackage/MyClass.java.
-source release
Specifies the version of source code accepted. The following values for release are allowed:
1.3
The compiler does not support assertions, generics, or other language features introduced after JDK 1.3.
1.4
The compiler accepts code containing assertions, which were introduced in JDK 1.4.
1.5
The compiler accepts code containing generics and other language features introduced in JDK 5.
5
Synonym for 1.5.
1.6
This is the default value. No language changes were introduced in Java SE 6. However, encoding errors in source files are now reported as errors, instead of warnings, as previously.
6
Synonym for 1.6.

-sourcepath sourcepath
Specify the source code path to search for class or interface definitions. As with the user class path, source path entries are separated by colons (:) and can be directories, JAR archives, or ZIP archives. If packages are used, the local path name within the directory or archive must reflect the package name.

Note: Classes found through the classpath may be subject to automatic recompilation if their sources are also found. See Searching For Types.

-verbose
Verbose output. This includes information about each class loaded and each source file compiled.
-X
Display information about non-standard options and exit.

Cross-Compilation Options

By default, classes are compiled against the bootstrap and extension classes of the platform that javac shipped with. But javac also supports cross-compiling, where classes are compiled against a bootstrap and extension classes of a different Java platform implementation. It is important to use -bootclasspath and -extdirs when cross-compiling; see Cross-Compilation Example below.

-target version
Generate class files that target a specified version of the VM. Class files will run on the specified target and on later versions, but not on earlier versions of the VM. Valid targets are 1.1 1.2 1.3 1.4 1.5 (also 5) and 1.6 (also 6).

The default for -target depends on the value of -source:

  • If -source is not specified, the value of -target is 1.6
  • If -source is 1.2, the value of -target is 1.4
  • If -source is 1.3, the value of -target is 1.4
  • For all other values of -source, the value of -target is the value of -source.

-bootclasspath bootclasspath
Cross-compile against the specified set of boot classes. As with the user class path, boot class path entries are separated by colons (:) and can be directories, JAR archives, or ZIP archives.
-extdirs directories
Cross-compile against the specified extension directories. Directories is a colon-separated list of directories. Each JAR archive in the specified directories is searched for class files.

Non-Standard Options

-Xbootclasspath/p:path
Prepend to the bootstrap class path.
-Xbootclasspath/a:path
Append to the bootstrap class path.
-Xbootclasspath/:path
Override location of bootstrap class files.
-Xlint
Enable all recommended warnings. In this release, all available warnings are recommended.
-Xlint:none
Disable all warnings not mandated by the Java Language Specification.
-Xlint:-name
Disable warning name, where name is one of the warning names supported for -Xlint:name, below.
-Xlint:unchecked
Give more detail for unchecked conversion warnings that are mandated by the Java Language Specification.
-Xlint:path
Warn about nonexistent path (classpath, sourcepath, etc) directories.
-Xlint:serial
Warn about missing serialVersionUID definitions on serializable classes.
-Xlint:finally
Warn about finally clauses that cannot complete normally.
-Xlint:fallthrough
Check switch blocks for fall-through cases and provide a warning message for any that are found. Fall-through cases are cases in a switch block, other than the last case in the block, whose code does not include a break statement, allowing code execution to "fall through" from that case to the next case. For example, the code following the case 1 label in this switch block does not end with a break statement:
switch (x) {
case 1:
       System.out.println("1");
       //  No  break;  statement here.
case 2:
       System.out.println("2");
}
If the -Xlint:fallthrough flag were used when compiling this code, the compiler would emit a warning about "possible fall-through into case," along with the line number of the case in question.
-Xmaxerrors number
Set the maximum number of errors to print.
-Xmaxwarns number
Set the maximum number of warnings to print.
-Xstdout filename
Send compiler messages to the named file. By default, compiler messages go to System.err.
-Xprefer:{newer,source}
Specify which file to read when both a source file and class file are found for a type. (See Searching For Types). If -Xprefer:newer is used, it reads the newer of the source or class file for a type (default). If the -Xprefer:source option is used, it reads source file. Use -Xprefer:source when you want to be sure that any annotation processors can access annotations declared with a retention policy of SOURCE.
-Xprint
Print out textual representation of specified types for debugging purposes; perform neither annotation processing nor compilation. The format of the output may change.
-XprintProcessorInfo
Print information about which annotations a processor is asked to process.
-XprintRounds
Print information about initial and subsequent annotation processing rounds.

The -J Option

-J option
Pass option to the java launcher called by javac. For example, -J-Xms48m sets the startup memory to 48 megabytes. Although it does not begin with -X, it is not a `standard option' of javac. It is a common convention for -J to pass options to the underlying VM executing applications written in Java.

Note: CLASSPATH, -classpath, -bootclasspath, and -extdirs do not specify the classes used to run javac. Fiddling with the implementation of the compiler in this way is usually pointless and always risky. If you do need to do this, use the -J option to pass through options to the underlying java launcher.

COMMAND LINE ARGUMENT FILES

To shorten or simplify the javac command line, you can specify one or more files that themselves contain arguments to the javac command (except -J options). This enables you to create javac commands of any length on any operating system.

An argument file can include javac options and source filenames in any combination. The arguments within a file can be space-separated or newline-separated. If a filename contains embedded spaces, put the whole filename in double quotes.

Filenames within an argument file are relative to the current directory, not the location of the argument file. Wildcards (*) are not allowed in these lists (such as for specifying *.java). Use of the '@' character to recursively interpret files is not supported. The -J options are not supported because they are passed to the launcher, which does not support argument files.

When executing javac, pass in the path and name of each argument file with the '@' leading character. When javac encounters an argument beginning with the character `@', it expands the contents of that file into the argument list.

Example - Single Arg File

You could use a single argument file named "argfile" to hold all javac arguments:

  % javac @argfile

This argument file could contain the contents of both files shown in the next example.

Example - Two Arg Files

You can create two argument files -- one for the javac options and the other for the source filenames: (Notice the following lists have no line-continuation characters.)

Create a file named "options" containing:

     -d classes
     -g
     -sourcepath /java/pubs/ws/1.3/src/share/classes

Create a file named "classes" containing:

     MyClass1.java
     MyClass2.java
     MyClass3.java

You would then run javac with:

  % javac @options @classes

Example - Arg Files with Paths

The argument files can have paths, but any filenames inside the files are relative to the current working directory (not path1 or path2):

  % javac @path1/options @path2/classes

ANNOTATION PROCESSING

javac provides direct support for annotation processing, superseding the need for the separate annotation processing tool, apt.

The API for annotation processors is defined in the javax.annotation.processing and javax.lang.model packages and subpackages.

Overview of annotation processing

Unless annotation processing is disabled with the -proc:none option, the compiler searches for any annotation processors that are available. The search path can be specified with the -processorpath option; if it is not given, the user class path is used. Processors are located by means of service provider-configuration files named META_INF/services/javax.annotation.processing.Processor on the search path. Such files should contain the names of any annotation processors to be used, listed one per line. Alternatively, processors can be specified explicitly, using the -processor option.

After scanning the source files and classes on the command line to determine what annotations are present, the compiler queries the processors to determine what annotations they process. When a match is found, the processor will be invoked. A processor may "claim" the annotations it processes, in which case no further attempt is made to find any processors for those annotations. Once all annotations have been claimed, the compiler does not look for additional processors.

If any processors generate any new source files, another round of annotation processing will occur: any newly generated source files will be scanned, and the annotations processed as before. Any processors invoked on previous rounds will also be invoked on all subsequent rounds. This continues until no new source files are generated.

After a round occurs where no new source files are generated, the annotation processors will be invoked one last time, to give them a chance to complete any work they may need to do. Finally, unless the -proc:only option is used, the compiler will compile the original and all the generated source files.

Implicitly loaded source files

To compile a set of source files, the compiler may need to implicitly load additional source files. (See Searching For Types). Such files are currently not subject to annotation processing. By default, the compiler will give a warning if annotation processing has occurred and any implicitly loaded source files are compiled. See the -implicit option for ways to suppress the warning.

SEARCHING FOR TYPES

When compiling a source file, the compiler often needs information about a type whose definition did not appear in the source files given on the command line. The compiler needs type information for every class or interface used, extended, or implemented in the source file. This includes classes and interfaces not explicitly mentioned in the source file but which provide information through inheritance.

For example, when you subclass java.applet.Applet, you are also using Applet's ancestor classes: java.awt.Panel, java.awt.Container, java.awt.Component, and java.lang.Object.

When the compiler needs type information, it looks for a source file or class file which defines the type. The compiler searches for class files first in the bootstrap and extension classes, then in the user class path (which by default is the current directory). The user class path is defined by setting the CLASSPATH environment variable or by using the -classpath command line option. (For details, see Setting the Class Path).

If you set the -sourcepath option, the compiler searches the indicated path for source files; otherwise the compiler searches the user class path for both class files and source files.

You can specify different bootstrap or extension classes with the -bootclasspath and -extdirs options; see Cross-Compilation Options below.

A successful type search may produce a class file, a source file, or both. If both are found, you can use the -Xprefer option to instruct the compiler which to use. If newer is given, the compiler will use the newer of the two files. If source is given, it will use the source file. The default is newer.

If a type search finds a source file for a required type, either by itself, or as a result of the setting for -Xprefer, the compiler will read the source file to get the information it needs. In addition, it will by default compile the source file as well. You can use the -implicit option to specify the behavior. If none is given, no class files will be generated for the source file. If class is given, class files will be generated for the source file.

The compiler may not discover the need for some type information until after annotation processing is complete. If the type information is found in a source file and no -implicit option is given, the compiler will give a warning that the file is being compiled without being subject to annotation processing. To disable the warning, either specify the file on the command line (so that it will be subject to annotation processing) or use the -implicit option to specify whether or not class files should be generated for such source files.

PROGRAMMATIC INTERFACE

javac supports the new Java Compiler API defined by the classes and interfaces in the javax.tools package.

Example

To perform a compilation using arguments as you would give on the command line, you can use the following:

JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
int rc = javac.run(null, null, null, args);

This will write any diagnostics to the standard output stream, and return the exit code that javac would give when invoked from the command line.

You can use other methods on the javax.tools.JavaCompiler interface to handle diagnostics, control where files are read from and written to, and so on.

Old Interface

Note: This API is retained for backwards compatibility only; all new code should use the Java Compiler API, described above.

The com.sun.tools.javac.Main class provides two static methods to invoke the compiler from a program:

public static int compile(String[] args);
public static int compile(String[] args, PrintWriter out);

The args parameter represents any of the command line arguments that would normally be passed to the javac program and are outlined in the above Synopsis section.

The out parameter indicates where the compiler's diagnostic output is directed.

The return value is equivalent to the exit value from javac.

Note that all other classes and methods found in a package whose name starts with com.sun.tools.javac (informally known as sub-packages of com.sun.tools.javac) are strictly internal and subject to change at any time.

EXAMPLES

Compiling a Simple Program

One source file, Hello.java, defines a class called greetings.Hello. The greetings directory is the package directory both for the source file and the class file and is off the current directory. This allows us to use the default user class path. It also makes it unnecessary to specify a separate destination directory with -d.

% ls
greetings/
% ls greetings
Hello.java
% cat greetings/Hello.java
package greetings;

public class Hello {
    public static void main(String[] args) {
        for (int i=0; i < args.length; i++) {
            System.out.println("Hello " + args[i]);
        }
    }
}
% javac greetings/Hello.java
% ls greetings
Hello.class   Hello.java
% java greetings.Hello World Universe Everyone
Hello World
Hello Universe
Hello Everyone

Compiling Multiple Source Files

This example compiles all the source files in the package greetings.

% ls
greetings/
% ls greetings
Aloha.java         GutenTag.java      Hello.java         Hi.java
% javac greetings/*.java
% ls greetings
Aloha.class         GutenTag.class      Hello.class         Hi.class
Aloha.java          GutenTag.java       Hello.java          Hi.java

Specifying a User Class Path

Having changed one of the source files in the previous example, we recompile it:

% pwd
/examples
% javac greetings/Hi.java

Since greetings.Hi refers to other classes in the greetings package, the compiler needs to find these other classes. The example above works, because our default user class path happens to be the directory containing the package directory. But suppose we want to recompile this file and not worry about which directory we're in? Then we need to add /examples to the user class path. We can do this by setting CLASSPATH, but here we'll use the -classpath option.

% javac -classpath /examples /examples/greetings/Hi.java

If we change greetings.Hi again, to use a banner utility, that utility also needs to be accessible through the user class path.

% javac -classpath /examples:/lib/Banners.jar \
        /examples/greetings/Hi.java

To execute a class in greetings, we need access both to greetings and to the classes it uses.

% java -classpath /examples:/lib/Banners.jar greetings.Hi

Separating Source Files and Class Files

It often makes sense to keep source files and class files in separate directories, especially on large projects. We use -d to indicate the separate class file destination. Since the source files are not in the user class path, we use -sourcepath to help the compiler find them.

% ls
classes/  lib/      src/
% ls src
farewells/
% ls src/farewells
Base.java      GoodBye.java
% ls lib
Banners.jar
% ls classes
% javac -sourcepath src -classpath classes:lib/Banners.jar \
        src/farewells/GoodBye.java -d classes
% ls classes
farewells/
% ls classes/farewells
Base.class      GoodBye.class

Note: The compiler compiled src/farewells/Base.java, even though we didn't specify it on the command line. To trace automatic compiles, use the -verbose option.

Cross-Compilation Example

Here we use javac to compile code that will run on a 1.5 VM.

% javac -target 1.5 -bootclasspath jdk1.5.0/lib/rt.jar \
        -extdirs "" OldCode.java

The -target 1.5 option ensures that the generated class files will be compatible with 1.5 VMs. By default, javac compiles for JDK 6.

The Java Platform JDK's javac would also by default compile against its own bootstrap classes, so we need to tell javac to compile against JDK 1.5 bootstrap classes instead. We do this with -bootclasspath and -extdirs. Failing to do this might allow compilation against a Java Platform API that would not be present on a 1.5 VM and would fail at runtime.

SEE ALSO

  • The javac Guide
  • java - the Java Application Launcher
  • jdb - Java Application Debugger
  • javah - C Header and Stub File Generator
  • javap - Class File Disassembler
  • javadoc - API Documentation Generator
  • jar - JAR Archive Tool
  • The Java Extensions Framework

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


javadoc - The Java API Documentation Generator

Generates HTML pages of API documentation from Java source files. This document contains Javadoc examples for Sun Solaris.

CONTENTS

Reference Guide

  • Synopsis
  • Description
    • Processing of Source Files
    • Javadoc Doclets
    • Related Documentation
    • Terminology
  • Source Files
    • Class Source Code Files
    • Package Comment Files
    • Overview Comment File
    • Miscellaneous Unprocessed Files
    • Test Files and Template Files
  • Generated Files
    • Generated API Declarations
  • Documentation Comments
    • Commenting the Source Code
    • Automatic Copying of Method Comments
  • Javadoc Tags (@tag)
    • Where Tags Can Be Used
  • Options (-option)
    • Javadoc Options
    • Options Provided by the Standard Doclet
  • Command Line Argument Files

Running

  • Running Javadoc
  • Simple Examples
    • Documenting One or More Packages
    • Documenting One or More Classes
    • Documenting Both Packages and Classes
  • Real World Example
    • Command Line Example
    • Makefile Example
  • Troubleshooting
    • General Troubleshooting
    • Errors and Warnings
  • Environment
    • CLASSPATH
  • Troubleshooting
  • See Also

Reference Guide

SYNOPSIS

javadoc [ options ] [ packagenames ] [ sourcefilenames ] [ -subpackages pkg1:pkg2:... ] [ @argfiles ]

Arguments can be in any order. See processing of Source Files for details on how the Javadoc tool determines which ".java" files to process.

options
Command-line options, as specified in this document. To see a typical use of javadoc options, see Real-World Example.
packagenames
A series of names of packages, separated by spaces, such as java.lang java.lang.reflect java.awt. You must separately specify each package you want to document. Wildcards are not allowed; use -subpackages for recursion. The Javadoc tool uses -sourcepath to look for these package names. See Example - Documenting One or More Packages
sourcefilenames
A series of source file names, separated by spaces, each of which can begin with a path and contain a wildcard such as asterisk (*). The Javadoc tool will process every file whose name ends with ".java", and whose name, when stripped of that suffix, is actually a legal class name (see Identifiers). Therefore, you can name files with dashes (such as X-Buffer), or other illegal characters, to prevent them from being documented. This is useful for test files and template files The path that precedes the source file name determines where javadoc will look for the file. (The Javadoc tool does not use -sourcepath to look for these source file names.) Relative paths are relative to the current directory, so passing in Button.java is identical to ./Button.java. A source file name with an absolute path and a wildcard, for example, is /home/src/java/awt/Graphics*.java. See Example - Documenting One or More Classes. You can also mix packagenames and sourcefilenames, as in Example - Documenting Both Packages and Classes
-subpackages pkg1:pkg2:...
Generates documentation from source files in the specified packages and recursively in their subpackages. An alternative to supplying packagenames or sourcefilenames.
@argfiles
One or more files that contain a list of Javadoc options, packagenames and sourcefilenames in any order. Wildcards (*) and -J options are not allowed in these files.

DESCRIPTION

The Javadoc tool parses the declarations and documentation comments in a set of Java source files and produces a corresponding set of HTML pages describing (by default) the public and protected classes, nested classes (but not anonymous inner classes), interfaces, constructors, methods, and fields. You can use it to generate the API (Application Programming Interface) documentation or the implementation documentation for a set of source files.

You can run the Javadoc tool on entire packages, individual source files, or both. When documenting entire packages, you can either use -subpackages for traversing recursively down from a top-level directory, or pass in an explicit list of package names. When documenting individual source files, you pass in a list of source (.java) filenames. Examples are given at the end of this document. How Javadoc processes source files is covered next.

Processing of source files

The Javadoc tool processes files that end in ".java" plus other files described under Source Files. If you run the Javadoc tool by explicitly passing in individual source filenames, you can determine exactly which ".java" files are processed. However, that is not how most developers want to work, as it is simpler to pass in package names. The Javadoc tool can be run three ways without explicitly specifying the source filenames. You can (1) pass in package names, (2) use -subpackages, and (3) use wildcards with source filenames (*.java). In these cases, the Javadoc tool processes a ".java" file only if it fulfills all of the following requirements:

  • Its name, after stripping off the ".java" suffix, is actually a legal class name (see Identifiers for legal characters)
  • Its directory path relative to the root of the source tree is actually a legal package name (after converting its separators to dots)
  • Its package statement contains the legal package name (specified in the previous bullet)

Processing of links - During a run, the Javadoc tool automatically adds cross-reference links to package, class and member names that are being documented as part of that run. Links appear in several places:

  • Declarations (return types, argument types, field types)
  • "See Also" sections generated from @see tags
  • In-line text generated from {@link} tags
  • Exception names generated from @throws tags
  • "Specified by" links to members in interfaces and "Overrides" links to members in classes
  • Summary tables listing packages, classes and members
  • Package and class inheritance trees
  • The index

You can add hyperlinks to existing text for classes not included on the command line (but generated separately) by way of the -link and -linkoffline options.

Other processing details - The Javadoc tool produces one complete document each time it is run; it cannot do incremental builds -- that is, it cannot modify or directly incorporate results from previous runs of the Javadoc tool. However, it can link to results from other runs, as just mentioned.

As implemented, the Javadoc tool requires and relies on the java compiler to do its job. The Javadoc tool calls part of javac to compile the declarations, ignoring the member implementation. It builds a rich internal representation of the classes, including the class hierarchy, and "use" relationships, then generates the HTML from that. The Javadoc tool also picks up user-supplied documentation from documentation comments in the source code.

In fact, the Javadoc tool will run on .java source files that are pure stub files with no method bodies. This means you can write documentation comments and run the Javadoc tool in the earliest stages of design while creating the API, before writing the implementation.

Relying on the compiler ensures that the HTML output corresponds exactly with the actual implementation, which may rely on implicit, rather than explicit, source code. For example, the Javadoc tool documents default constructors (section 8.6.7 of Java Language Specification) that are present in the .class files but not in the source code.

In many cases, the Javadoc tool allows you to generate documentation for source files whose code is incomplete or erroneous. This is a benefit that enables you to generate documentation before all debugging and troubleshooting is done. For example, according to the Java Language Specification, a class that contains an abstract method should itself be declared abstract. The Javadoc tool does not check for this, and would proceed without a warning, whereas the javac compiler stops on this error. The Javadoc tool does do some primitive checking of doc comments. Use the DocCheck doclet to check the doc comments more thoroughly.

When the Javadoc tool builds its internal structure for the documentation, it loads all referenced classes. Because of this, the Javadoc tool must be able to find all referenced classes, whether bootstrap classes, extensions, or user classes. For more about this, see How Classes Are Found. Generally speaking, classes you create must either be loaded as an extension or in the Javadoc tool's class path.

Javadoc Doclets

You can customize the content and format of the Javadoc tool's output by using doclets. The Javadoc tool has a default "built-in" doclet, called the standard doclet, that generates HTML-formatted API documentation. You can modify or subclass the standard doclet, or write your own doclet to generate HTML, XML, MIF, RTF or whatever output format you'd like. Information about doclets and their use is at the following locations:

  • Javadoc Doclets
  • The -doclet command-line option

When a custom doclet is not specified with the -doclet command line option, the Javadoc tool will use the default standard doclet. The javadoc tool has several command line options that are available regardless of which doclet is being used. The standard doclet adds a supplementary set of command line options. Both sets of options are described below in the options section.

Related Documentation and Doclets

  • Javadoc Enhancements for details about improvements added in Javadoc.
  • Javadoc FAQ for answers to common questions, information about Javadoc-related tools, and workarounds for bugs.
  • How to Write Doc Comments for Javadoc for more information about Sun conventions for writing documentation comments.
  • Requirements for Writing API Specifications - Standard requirements used when writing the Java 2 Platform Specification. It can be useful whether you are writing API specifications in source file documentation comments or in other formats. It covers requirements for packages, classes, interfaces, fields and methods to satisfy testable assertions.
  • Documentation Comment Specification - The original specification on documentation comments, Chapter 18, Documentation Comments, in the Java Language Specification, First Edition, by James Gosling, Bill Joy, and Guy Steele. (This chapter was removed from the second edition.)
  • DocCheck Doclet - Checks doc comments in source files and generates a report listing the errors and irregularities it finds. It is part of the Sun Doc Check Utilities.
  • MIF Doclet - Can automate the generation of API documentation in MIF, FrameMaker and PDF formats. MIF is Adobe FrameMaker's interchange format.

Terminology

The terms documentation comment, doc comment, main description, tag, block tag, and in-line tag are described at Documentation Comments. These other terms have specific meanings within the context of the Javadoc tool:

generated document
The document generated by the javadoc tool from the doc comments in Java source code. The default generated document is in HTML and is created by the standard doclet.

name
A name of a program element written in the Java Language -- that is, the name of a package, class, interface, field, constructor or method. A name can be fully-qualified, such as java.lang.String.equals(java.lang.Object), or partially-qualified, such as equals(Object).

documented classes
The classes and interfaces for which detailed documentation is generated during a javadoc run. To be documented, the source files must be available, their source filenames or package names must be passed into the javadoc command, and they must not be filtered out by their access modifier (public, protected, package-private or private). We also refer to these as the classes included in the javadoc output, or the included classes.

included classes
Classes and interfaces whose details are documented during a run of the Javadoc tool. Same as documented classes.

excluded classes
Classes and interfaces whose details are not documented during a run of the Javadoc tool.

referenced classes
The classes and interfaces that are explicitly referred to in the definition (implementation) or doc comments of the documented classes and interfaces. Examples of references include return type, parameter type, cast type, extended class, implemented interface, imported classes, classes used in method bodies, @see, {@link}, {@linkplain}, and {@inheritDoc} tags. (Notice this definition has changed since 1.3.) When the Javadoc tool is run, it should load into memory all of the referenced classes in javadoc's bootclasspath and classpath. (The Javadoc tool prints a "Class not found" warning for referenced classes not found.) The Javadoc tool can derive enough information from the .class files to determine their existence and the fully-qualified names of their members.

external referenced classes
The referenced classes whose documentation is not being generated during a javadoc run. In other words, these classes are not passed into the Javadoc tool on the command line. Links in the generated documentation to those classes are said to be external references or external links. For example, if you run the Javadoc tool on only the java.awt package, then any class in java.lang, such as Object, is an external referenced class. External referenced classes can be linked to using the -link and -linkoffline options. An important property of an external referenced class is that its source comments are normally not available to the Javadoc run. In this case, these comments cannot be inherited.

SOURCE FILES

The Javadoc tool will generate output originating from four different types of "source" files: Java language source files for classes (.java), package comment files, overview comment files, and miscellaneous unprocessed files. This section also covers test files and template files that can also be in the source tree, but which you want to be sure not to document.

Class Source Code Files

Each class or interface and its members can have their own documentation comments, contained in a .java file. For more details about these doc comments, see Documentation Comments.

Package Comment Files

Each package can have its own documentation comment, contained in its own "source" file, that the Javadoc tool will merge into the package summary page that it generates. You typically include in this comment any documentation that applies to the entire package.

To create a package comment file, you have a choice of two files to place your comments:

  • package-info.java - Can contain a package declaration, package annotations, package comments and Javadoc tags. This file is new in JDK 5.0, and is preferred over package.html.
  • package.html - Can contain only package comments and Javadoc tags, no package annotations.

A package may have a single package.html file or a single package-info.java file but not both. Place either file in the package directory in the source tree along with your .java files.

package-info.java - This file can contain a package comment of the following structure -- the comment is placed before the package declaration:

File: java/applet/package-info.java

/**
 * Provides the classes necessary to create an
 * applet and the classes an applet uses
 * to communicate with its applet context.
 * <p>
 * The applet framework involves two entities:
 * the applet and the applet context.
 * An applet is an embeddable window (see the
 * {@link java.awt.Panel} class) with a few extra
 * methods that the applet context can use to
 * initialize, start, and stop the applet.
 *
 * @since 1.0
 * @see java.awt
 */
package java.lang.applet;

Note that while the comment separators /** and /* must be present, the leading asterisks on the intermediate lines can be omitted.

package.html - This file can contain a package comment of the following structure -- the comment is placed in the <body> element:

File: java/applet/package.html

<HTML>
<BODY>
Provides the classes necessary to create an applet and the
classes an applet uses to communicate with its applet context.
<p>
The applet framework involves two entities: the applet
and the applet context. An applet is an embeddable
window (see the {@link java.awt.Panel} class) with a
few extra methods that the applet context can use to
initialize, start, and stop the applet.

@since 1.0
@see java.awt
</BODY>
</HTML>

Notice this is just a normal HTML file and does not include a package declaration. The content of the package comment file is written in HTML, like all other comments, with one exception: The documentation comment should not include the comment separators /** and */ or leading asterisks. When writing the comment, you should make the first sentence a summary about the package, and not put a title or any other text between <body> and the first sentence. You can include package tags; as with any documentation comment, all block tags must appear after the main description. If you add a @see tag in a package comment file, it must have a fully-qualified name. For more details, see the example of package.html.

Processing of package comment file - When the Javadoc tool runs, it will automatically look for the package comment file; if found, the Javadoc tool does the following:

  • Copies the comment for processing. (For package.html, copies all content between <body> and </body> HTML tags. You can include a <head> section to put a <title>, source file copyright statement, or other information, but none of these will appear in the generated documentation.)
  • Processes any package tags that are present.
  • Inserts the processed text at the bottom of the package summary page it generates, as shown in Package Summary.
  • Copies the first sentence of the package comment to the top of the package summary page. It also adds the package name and this first sentence to the list of packages on the overview page, as shown in Overview Summary. The end-of-sentence is determined by the same rules used for the end of the first sentence of class and member main descriptions.

Overview Comment File

Each application or set of packages that you are documenting can have its own overview documentation comment, kept in its own "source" file, that the Javadoc tool will merge into the overview page that it generates. You typically include in this comment any documentation that applies to the entire application or set of packages.

To create an overview comment file, you can name the file anything you want, typically overview.html and place it anywhere, typically at the top level of the source tree. For example, if the source files for the java.applet package are contained in /home/user/src/java/applet directory, you could create an overview comment file at /home/user/src/overview.html.

Notice you can have multiple overview comment files for the same set of source files, in case you want to run javadoc multiple times on different sets of packages. For example, you could run javadoc once with -private for internal documentation and again without that option for public documentation. In this case, you could describe the documentation as public or internal in the first sentence of each overview comment file.

The content of the overview comment file is one big documentation comment, written in HTML, like the package comment file described previously. See that description for details. To re-iterate, when writing the comment, you should make the first sentence a summary about the application or set of packages, and not put a title or any other text between <body> and the first sentence. You can include overview tags; as with any documentation comment, all tags except in-line tags, such as {@link}, must appear after the main description. If you add a @see tag, it must have a fully-qualified name.

When you run the Javadoc tool, you specify the overview comment file name with the -overview option. The file is then processed similar to that of a package comment file.

  • Copies all content between <body> and </body> tags for processing.
  • Processes any overview tags that are present.
  • Inserts the processed text at the bottom of the overview page it generates, as shown in Overview Summary.
  • Copies the first sentence of the overview comment to the top of the overview summary page.

Miscellaneous Unprocessed Files

You can also include in your source any miscellaneous files that you want the Javadoc tool to copy to the destination directory. These typically includes graphic files, example Java source (.java) and class (.class) files, and self-standing HTML files whose content would overwhelm the documentation comment of a normal Java source file.

To include unprocessed files, put them in a directory called doc-files which can be a subdirectory of any package directory that contains source files. You can have one such subdirectory for each package. You might include images, example code, source files, .class files, applets and HTML files. For example, if you want to include the image of a button button.gif in the java.awt.Button class documentation, you place that file in the /home/user/src/java/awt/doc-files/ directory. Notice the doc-files directory should not be located at /home/user/src/java/doc-files because java is not a package -- that is, it does not directly contain any source files.

All links to these unprocessed files must be hard-coded, because the Javadoc tool does not look at the files -- it simply copies the directory and all its contents to the destination. For example, the link in the Button.java doc comment might look like:

    /**
     * This button looks like this:
     * <img src="doc-files/Button.gif">
     */

Test Files and Template Files

Some developers have indicated they want to store test files and templates files in the source tree near their corresponding source files. That is, they would like to put them in the same directory, or a subdirectory, of those source files.

If you run the Javadoc tool by explicitly passing in individual source filenames, you can deliberately omit test and templates files and prevent them from being processed. However, if you are passing in package names or wildcards, you need to follow certain rules to ensure these test files and templates files are not processed.

Test files differ from template files in that the former are legal, compilable source files, while the latter are not, but may end with ".java".

Test files - Often developers want to put compilable, runnable test files for a given package in the same directory as the source files for that package. But they want the test files to belong to a package other than the source file package, such as the unnamed package (so the test files have no package statement or a different package statement from the source). In this scenario, when the source is being documented by specifying its package name specified on the command line, the test files will cause warnings or errors. You need to put such test files in a subdirectory. For example, if you want to add test files for source files in com.package1, put them in a subdirectory that would be an invalid package name (because it contains a hyphen):

    com/package1/test-files/

The test directory will be skipped by the Javadoc tool with no warnings.

If your test files contain doc comments, you can set up a separate run of the Javadoc tool to produce documentation of the test files by passing in their test source filenames with wildcards, such as com/package1/test-files/*.java.

Templates for source files - Template files have names that often end in ".java" and are not compilable. If you have a template for a source file that you want to keep in the source directory, you can name it with a dash (such as Buffer-Template.java), or any other illegal Java character, to prevent it from being processed. This relies on the fact that the Javadoc tool will only process source files whose name, when stripped of the ".java" suffix, is actually a legal class name (see Identifiers).

GENERATED FILES

By default, javadoc uses a standard doclet that generates HTML-formatted documentation. This doclet generates the following kinds of files (where each HTML "page" corresponds to a separate file). Note that javadoc generates files with two types of names: those named after classes/interfaces, and those that are not (such as package-summary.html). Files in the latter group contain hyphens to prevent filename conflicts with those in the former group.

Basic Content Pages

  • One class or interface page (classname.html) for each class or interface it is documenting.
  • One package page (package-summary.html) for each package it is documenting. The Javadoc tool will include any HTML text provided in a file named package.html or package-info.java in the package directory of the source tree.
  • One overview page (overview-summary.html) for the entire set of packages. This is the front page of the generated document. The Javadoc tool will include any HTML text provided in a file specified with the -overview option. Note that this file is created only if you pass into javadoc two or more package names. For further explanation, see HTML Frames.)

Cross-Reference Pages

  • One class hierarchy page for the entire set of packages (overview-tree.html). To view this, click on "Overview" in the navigation bar, then click on "Tree".
  • One class hierarchy page for each package (package-tree.html) To view this, go to a particular package, class or interface page; click "Tree" to display the hierarchy for that package.
  • One "use" page for each package (package-use.html) and a separate one for each class and interface (class-use/classname.html). This page describes what packages, classes, methods, constructors and fields use any part of the given class, interface or package. Given a class or interface A, its "use" page includes subclasses of A, fields declared as A, methods that return A, and methods and constructors with parameters of type A. You can access this page by first going to the package, class or interface, then clicking on the "Use" link in the navigation bar.
  • A deprecated API page (deprecated-list.html) listing all deprecated names. (A deprecated name is not recommended for use, generally due to improvements, and a replacement name is usually given. Deprecated APIs may be removed in future implementations.)
  • A constant field values page (constant-values.html) for the values of static fields.
  • A serialized form page (serialized-form.html) for information about serializable and externalizable classes. Each such class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class comment. The standard doclet automatically generates a serialized form page: any class (public or non-public) that implements Serializable is included, along with readObject and writeObject methods, the fields that are serialized, and the doc comments from the @serial, @serialField, and @serialData tags. Public serializable classes can be excluded by marking them (or their package) with @serial exclude, and package-private serializable classes can be included by marking them (or their package) with @serial include. As of 1.4, you can generate the complete serialized form for public and private classes by running javadoc without specifying the -private option.
  • An index (index-*.html) of all class, interface, constructor, field and method names, alphabetically arranged. This is internationalized for Unicode and can be generated as a single file or as a separate file for each starting character (such as A-Z for English).

Support Files

  • A help page (help-doc.html) that describes the navigation bar and the above pages. You can provide your own custom help file to override the default using -helpfile.
  • One index.html file which creates the HTML frames for display. This is the file you load to display the front page with frames. This file itself contains no text content.
  • Several frame files (*-frame.html) containing lists of packages, classes and interfaces, used when HTML frames are being displayed.
  • A package list file (package-list), used by the -link and -linkoffline options. This is a text file, not HTML, and is not reachable through any links.
  • A style sheet file (stylesheet.css) that controls a limited amount of color, font family, font size, font style and positioning on the generated pages.
  • A doc-files directory that holds any image, example, source code or other files that you want copied to the destination directory. These files are not processed by the Javadoc tool in any manner -- that is, any javadoc tags in them will be ignored. This directory is not generated unless it exists in the source tree.

HTML Frames

The Javadoc tool will generate either two or three HTML frames, as shown in the figure below. It creates the minimum necessary number of frames by omitting the list of packages if there is only one package (or no packages). That is, when you pass a single package name or source files (*.java) belonging to a single package as arguments into the javadoc command, it will create only one frame (C) in the left-hand column -- the list of classes. When you pass into javadoc two or more package names, it creates a third frame (P) listing all packages, as well as an overview page (Detail). This overview page has the filename overview-summary.html. Thus, this file is created only if you pass in two or more package names. You can bypass frames by clicking on the "No Frames" link or entering at overview-summary.html.

If you are unfamiliar with HTML frames, you should be aware that frames can have focus for printing and scrolling. To give a frame focus, click on it. Then on many browsers the arrow keys and page keys will scroll that frame, and the print menu command will print it.

              ------------                  ------------
              |C| Detail |                  |P| Detail |
              | |        |                  | |        |
              | |        |                  |-|        |
              | |        |                  |C|        |
              | |        |                  | |        |
              | |        |                  | |        |
              ------------                  ------------
             javadoc *.java           javadoc java.lang java.awt

Load one of the following two files as the starting page depending on whether you want HTML frames or not:

  • index.html (for frames)
  • overview-summary.html (for no frames)

Generated File Structure

The generated class and interface files are organized in the same directory hierarchy that Java source files and class files are organized. This structure is one directory per subpackage.

For example, the document generated for the class java.applet.Applet class would be located at java/applet/Applet.html. The file structure for the java.applet package follows, given that the destination directory is named apidocs. All files that contain the word "frame" appear in the upper-left or lower-left frames, as noted. All other HTML files appear in the right-hand frame.

NOTE - Directories are shown in bold. The asterisks (*) indicate the files and directories that are omitted when the arguments to javadoc are source filenames (*.java) rather than package names. Also when arguments are source filenames, package-list is created but is empty. The doc-files directory will not be created in the destination unless it exists in the source tree.

apidocs                             Top directory
   index.html                       Initial page that sets up HTML frames
 * overview-summary.html            Lists all packages with first sentence summaries
   overview-tree.html               Lists class hierarchy for all packages
   deprecated-list.html             Lists deprecated API for all packages
   constant-values.html             Lists values of static fields for all packages
   serialized-form.html             Lists serialized form for all packages
 * overview-frame.html              Lists all packages, used in upper-left frame
   allclasses-frame.html            Lists all classes for all packages, used in lower-left frame
   help-doc.html                    Lists user help for how these pages are organized
   index-all.html                   Default index created without -splitindex option
   index-files                      Directory created with -splitindex option
       index-<number>.html          Index files created with -splitindex option
   package-list                     Lists package names, used only for resolving external refs
   stylesheet.css                   HTML style sheet for defining fonts, colors and positions
   java                             Package directory
       applet                       Subpackage directory
            Applet.html             Page for Applet class
            AppletContext.html      Page for AppletContext interface
            AppletStub.html         Page for AppletStub interface
            AudioClip.html          Page for AudioClip interface
          * package-summary.html    Lists classes with first sentence summaries for this package
          * package-frame.html      Lists classes in this package, used in lower left-hand frame
          * package-tree.html       Lists class hierarchy for this package
            package-use             Lists where this package is used
            doc-files               Directory holding image and example files
            class-use               Directory holding pages API is used
                Applet.html         Page for uses of Applet class
                AppletContext.html  Page for uses of AppletContext interface
                AppletStub.html     Page for uses of AppletStub interface
                AudioClip.html      Page for uses of AudioClip interface
   src-html                         Source code directory
       java                         Package directory
           applet                   Subpackage directory
                Applet.html         Page for Applet source code
                AppletContext.html  Page for AppletContext source code
                AppletStub.html     Page for AppletStub source code
                AudioClip.html      Page for AudioClip source code

Generated API Declarations

The Javadoc tool generates a declaration at the start of each class, interface, field, constructor, and method description for that API item. For example, the declaration for the Boolean class is:

public final class Boolean
extends Object
implements Serializable

and the declaration for the Boolean.valueOfmethod is:

public static Boolean valueOf(String s)

The Javadoc tool can include the modifiers public, protected, private, abstract, final, static, transient, and volatile, but not synchronized or native. These last two modifiers are considered implementation detail and not part of the API specification.

Rather than relying on the keyword synchronized, APIs should document their concurrency semantics in the comment's main description, as in "a single Enumeration cannot be used by multiple threads concurrently". The document should not describe how to achieve these semantics. As another example, while Hashtable should be thread-safe, there's no reason to specify that we achieve this by synchronizing all of its exported methods. We should reserve the right to synchronize internally at the bucket level, thus offering higher concurrency.

DOCUMENTATION COMMENTS

The original "Documentation Comment Specification" can be found under related documentation.

Commenting the Source Code

You can include documentation comments ("doc comments") in the source code, ahead of declarations for any class, interface, method, constructor, or field. You can also create doc comments for each package and another one for the overview, though their syntax is slightly different. Doc comments are also known informally as "Javadoc comments" (but this term violates its trademark usage). A doc comment consists of the characters between the characters /** that begin the comment and the characters */ that end it. Leading asterisks are allowed on each line and are described further below. The text in a comment can continue onto multiple lines.

/**
 * This is the typical format of a simple documentation comment
 * that spans two lines.
 */

To save space you can put a comment on one line:

/** This comment takes up only one line. */

Placement of comments - Documentation comments are recognized only when placed immediately before class, interface, constructor, method, or field declarations -- see the class example, method example, and field example. Documentation comments placed in the body of a method are ignored. Only one documentation comment per declaration statement is recognized by the Javadoc tool.

A common mistake is to put an import statement between the class comment and the class declaration. Avoid this, as the Javadoc tool will ignore the class comment.

   /**
    * This is the class comment for the class Whatever.
    */

    import com.sun;   // MISTAKE - Important not to put import statement here

    public class Whatever {
    }

A doc comment is composed of a main description followed by a tag section - The main description begins after the starting delimiter /** and continues until the tag section. The tag section starts with the first block tag, which is defined by the first @ character that begins a line (ignoring leading asterisks, white space, and leading separator /**). It is possible to have a comment with only a tag section and no main description. The main description cannot continue after the tag section begins. The argument to a tag can span multiple lines. There can be any number of tags -- some types of tags can be repeated while others cannot. For example, this @see starts the tag section:

/**
 * This sentence would hold the main description for this doc comment.
 * @see java.lang.Object
 */

Block tags and in-line tags - A tag is a special keyword within a doc comment that the Javadoc tool can process. There are two kinds of tags: block tags, which appear as @tag (also known as "standalone tags"), and in-line tags, which appear within curly braces, as {@tag}. To be interpreted, a block tag must appear at the beginning of a line, ignoring leading asterisks, white space, and separator (/**). This means you can use the @ character elsewhere in the text and it will not be interpreted as the start of a tag. If you want to start a line with the @ character and not have it be interpreted, use the HTML entity &#064;. Each block tag has associated text, which includes any text following the tag up to, but not including, either the next tag, or the end of the doc comment. This associated text can span multiple lines. An in-line tag is allowed and interpreted anywhere that text is allowed. The following example contains the block tag @deprecated and in-line tag {@link}.

/**
 * @deprecated  As of JDK 1.1, replaced by {@link #setBounds(int,int,int,int)}
 */

Comments are written in HTML - The text must be written in HTML, in that they should use HTML entities and can use HTML tags. You can use whichever version of HTML your browser supports; we have written the standard doclet to generate HTML 3.2-compliant code elsewhere (outside of the documentation comments) with the inclusion of cascading style sheets and frames. (We preface each generated file with "HTML 4.0" because of the frame sets.)

For example, entities for the less-than (<) and greater-than (>) symbols should be written &lt; and &gt;. Likewise, the ampersand (&) should be written &amp;. The bold HTML tag <b> is shown in the following example.

Here is a doc comment:

/**
 * This is a <b>doc</b> comment.
 * @see java.lang.Object
 */

Leading asterisks - When javadoc parses a doc comment, leading asterisk (*) characters on each line are discarded; blanks and tabs preceding the initial asterisk (*) characters are also discarded. Starting with 1.4, if you omit the leading asterisk on a line, the leading white space is no longer removed. This enables you to paste code examples directly into a doc comment inside a <PRE> tag, and its indentation will be honored. Spaces are generally interpreted by browsers more uniformly than tabs. Indentation is relative to the left margin (rather than the separator /** or <PRE> tag).

First sentence - The first sentence of each doc comment should be a summary sentence, containing a concise but complete description of the declared entity. This sentence ends at the first period that is followed by a blank, tab, or line terminator, or at the first block tag. The Javadoc tool copies this first sentence to the member summary at the top of the HTML page.

Declaration with multiple fields - Java allows declaring multiple fields in a single statement, but this statement can have only one documentation comment, which is copied for all fields. Therefore if you want individual documentation comments for each field, you must declare each field in a separate statement. For example, the following documentation comment doesn't make sense written as a single declaration and would be better handled as two declarations:

/**
 * The horizontal and vertical distances of point (x,y)
 */
public int x, y;      // Avoid this

The Javadoc tool generates the following documentation from the above code:

public int x
The horizontal and vertical distances of point (x,y)
public int y
The horizontal and vertical distances of point (x,y)

Use header tags carefully - When writing documentation comments for members, it's best not to use HTML heading tags such as <H1> and <H2>, because the Javadoc tool creates an entire structured document and these structural tags might interfere with the formatting of the generated document. However, it is fine to use these headings in class and package comments to provide your own structure.

Automatic Copying of Method Comments

The Javadoc tool has the ability to copy or "inherit" method comments in classes and interfaces under the following two circumstances. Constructors, fields and nested classes do not inherit doc comments.

  • Automatically inherit comment to fill in missing text - When a main description, or @return, @param or @throws tag is missing from a method comment, the Javadoc tool copies the corresponding main description or tag comment from the method it overrides or implements (if any), according to the algorithm below.

    More specifically, when a @param tag for a particular parameter is missing, then the comment for that parameter is copied from the method further up the inheritance hierarchy. When a @throws tag for a particular exception is missing, the @throws tag is copied only if that exception is declared.

    This behavior contrasts with version 1.3 and earlier, where the presence of any main description or tag would prevent all comments from being inherited.

  • Explicitly inherit comment with {@inheritDoc} tag - Insert the inline tag {@inheritDoc} in a method main description or @return, @param or @throws tag comment -- the corresponding inherited main description or tag comment is copied into that spot.

The source file for the inherited method need only be on the path specified by -sourcepath for the doc comment to actually be available to copy. Neither the class nor its package needs to be passed in on the command line. This contrasts with 1.3.x and earlier releases, where the class had to be a documented class

Inherit from classes and interfaces - Inheriting of comments occurs in all three possible cases of inheritance from classes and interfaces:

  • When a method in a class overrides a method in a superclass
  • When a method in an interface overrides a method in a superinterface
  • When a method in a class implements a method in an interface

In the first two cases, for method overrides, the Javadoc tool generates a subheading "Overrides" in the documentation for the overriding method, with a link to the method it is overriding, whether or not the comment is inherited.

In the third case, when a method in a given class implements a method in an interface, the Javadoc tool generates a subheading "Specified by" in the documentation for the overriding method, with a link to the method it is implementing. This happens whether or not the comment is inherited.

Algorithm for Inheriting Method Comments - If a method does not have a doc comment, or has an {@inheritDoc} tag, the Javadoc tool searches for an applicable comment using the following algorithm, which is designed to find the most specific applicable doc comment, giving preference to interfaces over superclasses:

  1. Look in each directly implemented (or extended) interface in the order they appear following the word implements (or extends) in the method declaration. Use the first doc comment found for this method.
  2. If step 1 failed to find a doc comment, recursively apply this entire algorithm to each directly implemented (or extended) interface, in the same order they were examined in step 1.
  3. If step 2 failed to find a doc comment and this is a class other than Object (not an interface):
    1. If the superclass has a doc comment for this method, use it.
    2. If step 3a failed to find a doc comment, recursively apply this entire algorithm to the superclass.

JAVADOC TAGS

The Javadoc tool parses special tags when they are embedded within a Java doc comment. These doc tags enable you to autogenerate a complete, well-formatted API from your source code. The tags start with an "at" sign (@) and are case-sensitive -- they must be typed with the uppercase and lowercase letters as shown. A tag must start at the beginning of a line (after any leading spaces and an optional asterisk) or it is treated as normal text. By convention, tags with the same name are grouped together. For example, put all @see tags together.

Tags come in two types:

  • Block tags - Can be placed only in the tag section that follows the main description. Block tags are of the form: @tag.
  • Inline tags - Can be placed anywhere in the main description or in the comments for block tags. Inline tags are denoted by curly braces: {@tag}.

For information about tags we might introduce in future releases, see Proposed Tags.

The current tags are:

         Tag
Introduced in JDK/SDK @author 1.0 {@code} 1.5 {@docRoot} 1.3 @deprecated 1.0 @exception 1.0 {@inheritDoc} 1.4 {@link} 1.2 {@linkplain} 1.4 {@literal} 1.5 @param 1.0 @return 1.0 @see 1.0 @serial 1.2 @serialData 1.2 @serialField 1.2 @since 1.1 @throws 1.2 {@value} 1.4 @version 1.0

For custom tags, see the -tag option.

@author name-text
Adds an "Author" entry with the specified name-text to the generated docs when the -author option is used. A doc comment may contain multiple @author tags. You can specify one name per @author tag or multiple names per tag. In the former case, the Javadoc tool inserts a comma (,) and space between names. In the latter case, the entire text is simply copied to the generated document without being parsed. Therefore, you can use multiple names per line if you want a localized name separator other than comma.

For more details, see Where Tags Can Be Used and writing @author tags.

@deprecated deprecated-text

Note: Starting with JDK 5.0, you can deprecate a program element using the @Deprecated annotation.

Adds a comment indicating that this API should no longer be used (even though it may continue to work). The Javadoc tool moves the deprecated-text ahead of the main description, placing it in italics and preceding it with a bold warning: "Deprecated". This tag is valid in all doc comments: overview, package, class, interface, constructor, method and field.

The first sentence of deprecated-text should at least tell the user when the API was deprecated and what to use as a replacement. The Javadoc tool copies just the first sentence to the summary section and index. Subsequent sentences can also explain why it has been deprecated. You should include a {@link} tag (for Javadoc 1.2 or later) that points to the replacement API:

For more details, see writing @deprecated tags.

  • For Javadoc 1.2 and later, use a {@link} tag. This creates the link in-line, where you want it. For example:
    /**
 * @deprecated  As of JDK 1.1, replaced by {@link #setBounds(int,int,int,int)}
 */
  • For Javadoc 1.1, the standard format is to create a @see tag (which cannot be in-line) for each @deprecated tag.

For more about deprecation, see The @deprecated tag.

{@code text}
Equivalent to <code>{@literal}</code>.

Displays text in code font without interpreting the text as HTML markup or nested javadoc tags. This enables you to use regular angle brackets (< and >) instead of the HTML entities (&lt; and &gt;) in doc comments, such as in parameter types (<Object>), inequalities (3 < 4), or arrows (<-). For example, the doc comment text:

     {@code A<B>C}

displays in the generated HTML page unchanged, as:

     A<B>C

The noteworthy point is that the <B> is not interpreted as bold and is in code font.

If you want the same functionality without the code font, use {@literal}.

{@docRoot}
Represents the relative path to the generated document's (destination) root directory from any generated page. It is useful when you want to include a file, such as a copyright page or company logo, that you want to reference from all generated pages. Linking to the copyright page from the bottom of each page is common.

This {@docRoot} tag can be used both on the command line and in a doc comment: This tag is valid in all doc comments: overview, package, class, interface, constructor, method and field, including the text portion of any tag (such as @return, @param and @deprecated).

  1. On the command line, where the header/footer/bottom are defined:
       javadoc -bottom '<a href="{@docRoot}/copyright.html">Copyright</a>'

    NOTE - When using {@docRoot} this way in a make file, some makefile programs require special escaping for the brace {} characters. For example, the Inprise MAKE version 5.2 running on Windows requires double braces: {{@docRoot}}. It also requires double (rather than single) quotes to enclose arguments to options such as -bottom (with the quotes around the href argument omitted).

  2. In a doc comment:
       /**
    * See the <a href="{@docRoot}/copyright.html">Copyright</a>.
    */

The reason this tag is needed is because the generated docs are in hierarchical directories, as deep as the number of subpackages. This expression:

  <a href="{@docRoot}/copyright.html">

would resolve to:

  <a href="../../copyright.html">      for java/lang/Object.java

and

  <a href="../../../copyright.html">   for java/lang/ref/Reference.java

@exception class-name description
The @exception tag is a synonym for @throws.

{@inheritDoc}
Inherits (copies) documentation from the "nearest" inheritable class or implementable interface into the current doc comment at this tag's location. This allows you to write more general comments higher up the inheritance tree, and to write around the copied text.

This tag is valid only in these places in a doc comment:

  • In the main description block of a method. In this case, the main description is copied from a class or interface up the hierarchy.
  • In the text arguments of the @return, @param and @throws tags of a method. In this case, the tag text is copied from the corresponding tag up the hierarchy.

See Automatic Copying of Method Comments for a more precise description of how comments are found in the inheritance hierarchy. Note that if this tag is missing, the comment is or is not automatically inherited according to rules described in that section.

{@link package.class#member label}
Inserts an in-line link with visible text label that points to the documentation for the specified package, class or member name of a referenced class. This tag is valid in all doc comments: overview, package, class, interface, constructor, method and field, including the text portion of any tag (such as @return, @param and @deprecated).

This tag is very simliar to @see -- both require the same references and accept exactly the same syntax for package.class#member and label. The main difference is that {@link} generates an in-line link rather than placing the link in the "See Also" section. Also, the {@link} tag begins and ends with curly braces to separate it from the rest of the in-line text. If you need to use "}" inside the label, use the HTML entity notation &#125;

There is no limit to the number of {@link} tags allowed in a sentence. You can use this tag in the main description part of any documentation comment or in the text portion of any tag (such as @deprecated, @return or @param).

For example, here is a comment that refers to the getComponentAt(int, int) method:

Use the {@link #getComponentAt(int, int) getComponentAt} method.

From this, the standard doclet would generate the following HTML (assuming it refers to another class in the same package):

Use the <a href="Component.html#getComponentAt(int, int)">getComponentAt</a> method.

Which appears on the web page as:

Use the getComponentAt method.

You can extend {@link} to link to classes not being documented by using the -link option.

For more details, see writing {@link} tags.

{@linkplain package.class#member label}
Identical to {@link}, except the link's label is displayed in plain text than code font. Useful when the label is plain text. Example:
     Refer to {@linkplain add() the overridden method}.

This would display as:

Refer to the overridden method.

{@literal text}
Displays text without interpreting the text as HTML markup or nested javadoc tags. This enables you to use regular angle brackets (< and >) instead of the HTML entities (&lt; and &gt;) in doc comments, such as in parameter types (<Object>), inequalities (3 < 4), or arrows (<-). For example, the doc comment text:
     {@literal A<B>C}

displays unchanged in the generated HTML page in your browser, as:

     A<B>C

The noteworthy point is that the <B> is not interpreted as bold (and it is not in code font).

If you want the same functionality but with the text in code font, use {@code}.

@param parameter-name description
Adds a parameter with the specified parameter-name followed by the specified description to the "Parameters" section. When writing the doc comment, you may continue the description onto multiple lines. This tag is valid only in a doc comment for a method, constructor or class.

The parameter-name can be the name of a parameter in a method or constructor, or the name of a type parameter of a class, method or constructor. Use angle brackets around this parameter name to specify the use of a type parameter.

Example of a type parameter of a class:

     /**
      * @param <E> Type of element stored in a list
      */
     public interface List<E> extends Collection<E> {
     }

Example of a type parameter of a method:

     /**
      * @param string  the string to be converted
      * @param type    the type to convert the string to
      * @param <T>     the type of the element
      * @param <V>     the value of the element
      */
     <T, V extends T> V convert(String string, Class<T> type) {
     }

For more details, see writing @param tags.

@return description
Adds a "Returns" section with the description text. This text should describe the return type and permissible range of values. This tag is valid only in a doc comment for a method.

For more details, see writing @return tags.

@see reference
Adds a "See Also" heading with a link or text entry that points to reference. A doc comment may contain any number of @see tags, which are all grouped under the same heading. The @see tag has three variations; the third form below is the most common. This tag is valid in any doc comment: overview, package, class, interface, constructor, method or field. For inserting an in-line link within a sentence to a package, class or member, see {@link}.
@see "string"
Adds a text entry for string. No link is generated. The string is a book or other reference to information not available by URL. The Javadoc tool distinguishes this from the previous cases by looking for a double-quote (") as the first character. For example:
     @see "The Java Programming Language"

This generates text such as:

See Also:
"The Java Programming Language"
@see <a href="URL#value">label</a>
Adds a link as defined by URL#value. The URL#value is a relative or absolute URL. The Javadoc tool distinguishes this from other cases by looking for a less-than symbol (<) as the first character. For example:
     @see <a href="spec.html#section">Java Spec</a>
This generates a link such as:
See Also:
Java Spec
@see package.class#member label
Adds a link, with visible text label, that points to the documentation for the specified name in the Java Language that is referenced. The label is optional; if omitted, the name appears instead as the visible text, suitably shortened -- see How a name is displayed. Use -noqualifier to globally remove the package name from this visible text. Use the label when you want the visible text to be different from the auto-generated visible text.

Only in version 1.2, just the name but not the label would automatically appear in <code> HTML tags, Starting with 1.2.2, the <code> is always included around the visible text, whether or not a label is used.

  • package.class#member is any valid program element name that is referenced -- a package, class, interface, constructor, method or field name -- except that the character ahead of the member name should be a hash character (#). The class represents any top-level or nested class or interface. The member represents any constructor, method or field (not a nested class or interface). If this name is in the documented classes, the Javadoc tool will automatically create a link to it. To create links to external referenced classes, use the -link option. Use either of the other two @see forms for referring to documentation of a name that does not belong to a referenced class. This argument is described at greater length below under Specifying a Name.
  • label is optional text that is visible as the link's label. The label can contain whitespace. If label is omitted, then package.class.member will appear, suitably shortened relative to the current class and package -- see How a name is displayed.
  • A space is the delimiter between package.class#member and label. A space inside parentheses does not indicate the start of a label, so spaces may be used between parameters in a method.

Example - In this example, an @see tag (in the Character class) refers to the equals method in the String class. The tag includes both arguments: the name "String#equals(Object)" and the label "equals".

 /**
  * @see String#equals(Object) equals
  */
The standard doclet produces HTML something like this:
<dl>
<dt><b>See Also:</b>
<dd><a href="../../java/lang/String#equals(java.lang.Object)"><code>equals<code></a>
</dl>
Which looks something like this in a browser, where the label is the visible link text:
See Also:
equals

Specifying a name - This package.class#member name can be either fully-qualified, such as java.lang.String#toUpperCase() or not, such as String#toUpperCase() or #toUpperCase(). If less than fully-qualified, the Javadoc tool uses the normal Java compiler search order to find it, further described below in Search order for @see. The name can contain whitespace within parentheses, such as between method arguments.

Of course the advantage of providing shorter, "partially-qualified" names is that they are shorter to type and there is less clutter in the source code. The following table shows the different forms of the name, where Class can be a class or interface, Type can be a class, interface, array, or primitive, and method can be a method or constructor.

Typical forms for @see package.class#member
Referencing a member of the current class
@see #field
@see #method(Type, Type,...)
@see #method(Type argname, Type argname,...)
@see #constructor(Type, Type,...)
@see #constructor(Type argname, Type argname,...)
Referencing another class in the current or imported packages
@see Class#field
@see Class#method(Type, Type,...)
@see Class#method(Type argname, Type argname,...)
@see Class#constructor(Type, Type,...)
@see Class#constructor(Type argname, Type argname,...)
@see Class.NestedClass
@see Class
Referencing an element in another package (fully qualified)
@see package.Class#field
@see package.Class#method(Type, Type,...)
@see package.Class#method(Type argname, Type argname,...)
@see package.Class#constructor(Type, Type,...)
@see package.Class#constructor(Type argname, Type argname,...)
@see package.Class.NestedClass
@see package.Class
@see package

The following notes apply to the above table:

  • The first set of forms (with no class or package) will cause the Javadoc tool to search only through the current class's hierarchy. It will find a member of the current class or interface, one of its superclasses or superinterfaces, or one of its enclosing classes or interfaces (search steps 1-3). It will not search the rest of the current package or other packages (search steps 4-5).
  • If any method or constructor is entered as a name with no parentheses, such as getValue, and if there is no field with the same name, the Javadoc tool will correctly create a link to it, but will print a warning message reminding you to add the parentheses and arguments. If this method is overloaded, the Javadoc tool will link to the first method its search encounters, which is unspecified.
  • Nested classes must be specified as outer.inner, not simply inner, for all forms.
  • As stated, the hash character (#), rather than a dot (.) separates a member from its class. This enables the Javadoc tool to resolve ambiguities, since the dot also separates classes, nested classes, packages, and subpackages. However, the Javadoc tool is generally lenient and will properly parse a dot if you know there is no ambiguity, though it will print a warning.

Search order for @see - the Javadoc tool will process a @see tag that appears in a source file (.java), package file (package.html or package-info.java) or overview file (overview.html). In the latter two files, you must fully-qualify the name you supply with @see. In a source file, you can specify a name that is fully-qualified or partially-qualified.

When the Javadoc tool encounters a @see tag in a .java file that is not fully qualified, it searches for the specified name in the same order as the Java compiler would (except the Javadoc tool will not detect certain namespace ambiguities, since it assumes the source code is free of these errors). This search order is formally defined in Chapter 6, "Names" of the Java Language Specification, Second Edition. The Javadoc tool searches for that name through all related and imported classes and packages. In particular, it searches in this order:

  1. the current class or interface
  2. any enclosing classes and interfaces, searching closest first
  3. any superclasses and superinterfaces, searching closest first
  4. the current package
  5. any imported packages, classes and interfaces, searching in the order of the import statement

The Javadoc tool continues to search recursively through steps 1-3 for each class it encounters until it finds a match. That is, after it searches through the current class and its enclosing class E, it will search through E's superclasses before E's enclosing classes. In steps 4 and 5, the Javadoc tool does not search classes or interfaces within a package in any specified order (that order depends on the particular compiler). In step 5, the Javadoc tool looks in java.lang, since that is automatically imported by all programs.

The Javadoc tool does not necessarily look in subclasses, nor will it look in other packages even if their documentation is being generated in the same run. For example, if the @see tag is in the java.awt.event.KeyEvent class and refers to a name in the java.awt package, javadoc does not look in that package unless that class imports it.

How a name is displayed - If label is omitted, then package.class.member appears. In general, it is suitably shortened relative to the current class and package. By "shortened", we mean the Javadoc tool displays only the minimum name necessary. For example, if the String.toUpperCase() method contains references to a member of the same class and to a member of a different class, the class name is displayed only in the latter case, as shown in the following table.

Use -noqualifier to globally remove the package names.

Type of Reference | Example in String.toUpperCase() | Displays As
@see tag refers to member of the same class, same package | @see String#toLowerCase() | toLowerCase() (omits the package and class names)
@see tag refers to member of a different class, same package | @see Character#toLowerCase(char) | Character.toLowerCase(char) (omits the package name, includes the class name)
@see tag refers to member of a different class, different package | @see java.io.File#exists() | java.io.File.exists() (includes the package and class names)

Examples of @see
The comment to the right shows how the name would be displayed if the @see tag is in a class in another package, such as java.applet.Applet.

                                           See also:
@see java.lang.String                   //  String
@see java.lang.String The String class  //  The String class
@see String                             //  String
@see String#equals(Object)              //  String.equals(Object)
@see String#equals                      //  String.equals(java.lang.Object)
@see java.lang.Object#wait(long)        //  java.lang.Object.wait(long)
@see Character#MAX_RADIX                //  Character.MAX_RADIX
@see <a href="spec.html">Java Spec</a>  //  Java Spec
@see "The Java Programming Language"    //  "The Java Programming Language"
You can extend @see to link to classes not being documented by using the -link option.

For more details, see writing @see tags.

@serial field-description | include | exclude
Used in the doc comment for a default serializable field.

An optional field-description should explain the meaning of the field and list the acceptable values. If needed, the description can span multiple lines. The standard doclet adds this information to the serialized form page.

If a serializable field was added to a class some time after the class was made serializable, a statement should be added to its main description to identify at which version it was added.

The include and exclude arguments identify whether a class or package should be included or excluded from the serialized form page. They work as follows:

  • A public or protected class that implements Serializable is included unless that class (or its package) is marked @serial exclude.
  • A private or package-private class that implements Serializable is excluded unless that class (or its package) is marked @serial include.

Examples: The javax.swing package is marked @serial exclude (in package.html or package-info.java). The public class java.security.BasicPermission is marked @serial exclude. The package-private class java.util.PropertyPermissionCollection is marked @serial include.

The tag @serial at a class level overrides @serial at a package level.

For more information about how to use these tags, along with an example, see "Documenting Serializable Fields and Data for a Class," Section 1.6 of the Java Object Serialization Specification. Also see the Serialization FAQ, which covers common questions, such as "Why do I see javadoc warnings stating that I am missing @serial tags for private fields if I am not running javadoc with the -private switch?". Also see Sun's criteria for including classes in the serialized form specification.

@serialField field-name field-type field-description
Documents an ObjectStreamField component of a Serializable class's serialPersistentFields member. One @serialField tag should be used for each ObjectStreamField component.

@serialData data-description
The data-description documents the types and order of data in the serialized form. Specifically, this data includes the optional data written by the writeObject method and all data (including base classes) written by the Externalizable.writeExternal method.

The @serialData tag can be used in the doc comment for the writeObject, readObject, writeExternal, readExternal, writeReplace, and readResolve methods.

@since since-text
Adds a "Since" heading with the specified since-text to the generated documentation. The text has no special internal structure. This tag is valid in any doc comment: overview, package, class, interface, constructor, method or field. This tag means that this change or feature has existed since the software release specified by the since-text. For example:
    @since 1.5

For source code in the Java platform, this tag indicates the version of the Java platform API specification (not necessarily when it was added to the reference implementation). Multiple @since tags are allowed and are treated like multiple @author tags. You could use multiple tags if the prgram element is used by more than one API.

@throws class-name description
The @throws and @exception tags are synonyms. Adds a "Throws" subheading to the generated documentation, with the class-name and description text. The class-name is the name of the exception that may be thrown by the method. This tag is valid only in the doc comment for a method or constructor. If this class is not fully-specified, the Javadoc tool uses the search order to look up this class. Multiple @throws tags can be used in a given doc comment for the same or different exceptions.

To ensure that all checked exceptions are documented, if a @throws tag does not exist for an exception in the throws clause, the Javadoc tool automatically adds that exception to the HTML output (with no description) as if it were documented with @throws tag.

The @throws documentation is copied from an overridden method to a subclass only when the exception is explicitly declared in the overridden method. The same is true for copying from an interface method to an implementing method. You can use {@inheritDoc} to force @throws to inherit documentation.

For more details, see writing @throws tags.

{@value package.class#field}
When {@value} is used (without any argument) in the doc comment of a static field, it displays the value of that constant:
    /**
     * The value of this constant is {@value}.
     */
    public static final String SCRIPT_START = "<script>"

When used with argument package.class#field in any doc comment, it displays the value of the specified constant:

    /**
     * Evaluates the script starting with {@value #SCRIPT_START}.
     */
    public String evalScript(String script) {
    }

The argument package.class#field takes a form identical to that of the @see argument, except that the member must be a static field.

These values of these constants are also displayed on the Constant Field Values page.

@version version-text
Adds a "Version" subheading with the specified version-text to the generated docs when the -version option is used. This tag is intended to hold the current version number of the software that this code is part of (as opposed to @since, which holds the version number where this code was introduced). The version-text has no special internal structure. To see where the version tag can be used, see Where Tags Can Be Used.

A doc comment may contain multiple @version tags. If it makes sense, you can specify one version number per @version tag or multiple version numbers per tag. In the former case, the Javadoc tool inserts a comma (,) and space between names. In the latter case, the entire text is simply copied to the generated document without being parsed. Therefore, you can use multiple names per line if you want a localized name separator other than comma.

For more details, see writing @version tags.

Where Tags Can Be Used

The following sections describe where the tags can be used. Note that these tags can be used in all doc comments: @see, @since, @deprecated, {@link}, {@linkplain}, and {@docroot}.

Overview Documentation Tags

Overview tags are tags that can appear in the documentation comment for the overview page (which resides in the source file typically named overview.html). Like in any other documentation comments, these tags must appear after the main description.

NOTE - The {@link} tag has a bug in overview documents in version 1.2 -- the text appears properly but has no link. The {@docRoot} tag does not currently work in overview documents.

Overview Tags
@see
@since
 @author
@version
{@link}
{@linkplain}
{@docRoot}

Package Documentation Tags

Package tags are tags that can appear in the documentation comment for a package (which resides in the source file named package.html or package-info.java). The @serial tag can only be used here with the include or exclude argument.

Package Tags
@see
@since
@serial
@author
@version
{@link}
{@linkplain}
{@docRoot}

Class and Interface Documentation Tags

The following are tags that can appear in the documentation comment for a class or interface. The @serial tag can only be used here with the include or exclude argument.

Class/Interface Tags
@see
@since
@deprecated
@serial
@author
@version
{@link}
{@linkplain}
{@docRoot}

An example of a class comment:

/**
 * A class representing a window on the screen.
 * For example:
 * <pre>
 *    Window win = new Window(parent);
 *    win.show();
 * </pre>
 *
 * @author  Sami Shaio
 * @version 1.13, 06/08/06
 * @see     java.awt.BaseWindow
 * @see     java.awt.Button
 */
class Window extends BaseWindow {
   ...
}

Field Documentation Tags

The following are the tags that can appear in the documentation comment for a field.

Field Tags
@see
@since
@deprecated
@serial
@serialField
{@link}
{@linkplain}
{@docRoot}
{@value}

An example of a field comment:

    /**
     * The X-coordinate of the component.
     *
     * @see #getLocation()
     */
    int x = 1263732;

Constructor and Method Documentation Tags

The following are the tags that can appear in the documentation comment for a constructor or method, except for @return, which cannot appear in a constructor, and {@inheritDoc}, which has certain restrictions. The @serialData tag can only be used in the doc comment for certain serialization methods.

Method/Constructor Tags
@see
@since
@deprecated
@param
@return
@throws and @exception
@serialData
{@link}
{@linkplain}
{@inheritDoc}
{@docRoot}

An example of a method doc comment:

    /**
     * Returns the character at the specified index. An index
     * ranges from <code>0</code> to <code>length() - 1</code>.
     *
     * @param     index  the index of the desired character.
     * @return    the desired character.
     * @exception StringIndexOutOfRangeException
     *              if the index is not in the range <code>0</code>
     *              to <code>length()-1</code>.
     * @see       java.lang.Character#charValue()
     */
    public char charAt(int index) {
       ...
    }

OPTIONS

The javadoc tool uses doclets to determine its output. The Javadoc tool uses the default standard doclet unless a custom doclet is specified with the -doclet option. The Javadoc tool provides a set of command-line options that can be used with any doclet -- these options are described below under the sub-heading Javadoc Options. The standard doclet provides an additional set of command-line options that are described below under the sub-heading Options Provided by the Standard Doclet. All option names are case-insensitive, though their arguments can be case-sensitive.

The options are:

-1.1
-author
-bootclasspath
-bottom
-breakiterator
-charset
-classpath
-d
-docencoding
-docfilessubdirs
-doclet
-docletpath
-doctitle
-encoding
-exclude
-excludedocfilessubdir
-extdirs
-footer
-group
 -header
-help
-helpfile
-J
-keywords
-link
-linkoffline
-linksource
-locale
-nocomment
-nodeprecated
-nodeprecatedlist
-nohelp
-noindex
-nonavbar
-noqualifier
-nosince
-notimestamp
-notree
-overview
-package
 -private
-protected
-public
-quiet
-serialwarn
-source
-sourcepath
-splitindex
-stylesheetfile
-subpackages
-tag
-taglet
-tagletpath
-title
-use
-verbose
-version
-windowtitle

Options shown in italic are the Javadoc core options, which are provided by the front end of the Javadoc tool and are available to all doclets. The standard doclet itself provides the non-italic options.

Javadoc Options

-overview path/filename
Specifies that javadoc should retrieve the text for the overview documentation from the "source" file specified by path/filename and place it on the Overview page (overview-summary.html). The path/filename is relative to the -sourcepath.

While you can use any name you want for filename and place it anywhere you want for path, a typical thing to do is to name it overview.html and place it in the source tree at the directory that contains the topmost package directories. In this location, no path is needed when documenting packages, since -sourcepath will point to this file. For example, if the source tree for the java.lang package is /src/classes/java/lang/, then you could place the overview file at /src/classes/overview.html. See Real World Example.

For information about the file specified by path/filename, see overview comment file.

Note that the overview page is created only if you pass into javadoc two or more package names. For further explanation, see HTML Frames.)

The title on the overview page is set by -doctitle.

-public
Shows only public classes and members.

-protected
Shows only protected and public classes and members. This is the default.

-package
Shows only package, protected, and public classes and members.

-private
Shows all classes and members.

-help
Displays the online help, which lists these javadoc and doclet command line options.

-doclet class
Specifies the class file that starts the doclet used in generating the documentation. Use the fully-qualified name. This doclet defines the content and formats the output. If the -doclet option is not used, javadoc uses the standard doclet for generating the default HTML format. This class must contain the start(Root) method. The path to this starting class is defined by the -docletpath option.

For example, to call the MIF doclet, use:

    -doclet com.sun.tools.doclets.mif.MIFDoclet

For full, working examples of running a particular doclet, see Running the MIF Doclet.

-docletpath classpathlist
Specifies the path to the doclet starting class file (specified with the -doclet option) and any jar files it depends on. If the starting class file is in a jar file, then this specifies the path to that jar file, as shown in the example below. You can specify an absolute path or a path relative to the current directory. If classpathlist contains multiple paths or jar files, they should be separated with a colon (:) on Solaris and a semi-colon (;) on Windows. This option is not necessary if the doclet starting class is already in the search path.

Example of path to jar file that contains the starting doclet class file. Notice the jar filename is included.

   -docletpath /home/user/mifdoclet/lib/mifdoclet.jar
Example of path to starting doclet class file. Notice the class filename is omitted.
   -docletpath /home/user/mifdoclet/classes/com/sun/tools/doclets/mif/
For full, working examples of running a particular doclet, see Running the MIF Doclet.

-1.1
This feature has been removed from Javadoc 1.4. There is no replacement for it. This option created documentation with the appearance and functionality of documentation generated by Javadoc 1.1 (it never supported nested classes). If you need this option, use Javadoc 1.2 or 1.3 instead.

-source release
Specifies the version of source code accepted. The following values for release are allowed:
1.5 | javadoc accepts code containing generics and other language features introduced in JDK 1.5. The compiler defaults to the 1.5 behavior if the -source flag is not used.
1.4 | javadoc accepts code containing assertions, which were introduced in JDK 1.4.
1.3 | javadoc does not support assertions, generics, or other language features introduced after JDK 1.3.

Use the value of release corresponding to that used when compiling the code with javac.

-sourcepath sourcepathlist
Specifies the search paths for finding source files (.java) when passing package names or -subpackages into the javadoc command. The sourcepathlist can contain multiple paths by separating them with a colon (:). The Javadoc tool will search in all subdirectories of the specified paths. Note that this option is not only used to locate the source files being documented, but also to find source files that are not being documented but whose comments are inherited by the source files being documented.

Note that you can use the -sourcepath option only when passing package names into the javadoc command -- it will not locate .java files passed into the javadoc command. (To locate .java files, cd to that directory or include the path ahead of each file, as shown at Documenting One or More Classes.) If -sourcepath is omitted, javadoc uses the class path to find the source files (see -classpath). Therefore, the default -sourcepath is the value of class path. If -classpath is omitted and you are passing package names into javadoc, it looks in the current directory (and subdirectories) for the source files.

Set sourcepathlist to the root directory of the source tree for the package you are documenting. For example, suppose you want to document a package called com.mypackage whose source files are located at:

  /home/user/src/com/mypackage/*.java
In this case you would specify the sourcepath to /home/user/src, the directory that contains com/mypackage, and then supply the package name com.mypackage:
  % javadoc -sourcepath /home/user/src/ com.mypackage
This is easy to remember by noticing that if you concatenate the value of sourcepath and the package name together and change the dot to a slash "/", you end up with the full path to the package: /home/user/src/com/mypackage.

To point to two source paths:

  % javadoc -sourcepath /home/user1/src:/home/user2/src com.mypackage

-classpath classpathlist
Specifies the paths where javadoc will look for referenced classes (.class files) -- these are the documented classes plus any classes referenced by those classes. The classpathlist can contain multiple paths by separating them with a colon (:). The Javadoc tool will search in all subdirectories of the specified paths. Follow the instructions in class path documentation for specifying classpathlist.

If -sourcepath is omitted, the Javadoc tool uses -classpath to find the source files as well as class files (for backward compatibility). Therefore, if you want to search for source and class files in separate paths, use both -sourcepath and -classpath.

For example, if you want to document com.mypackage, whose source files reside in the directory /home/user/src/com/mypackage, and if this package relies on a library in /home/user/lib, you would specify:

  % javadoc -classpath /home/user/lib -sourcepath /home/user/src com.mypackage
As with other tools, if you do not specify -classpath, the Javadoc tool uses the CLASSPATH environment variable, if it is set. If both are not set, the Javadoc tool searches for classes from the current directory.

For an in-depth description of how the Javadoc tool uses -classpath to find user classes as it relates to extension classes and bootstrap classes, see How Classes Are Found.

As a special convenience, a class path element containing a basename of * is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR (a java program cannot tell the difference between the two invocations).

For example, if directory foo contains a.jar and b.JAR, then the class path element foo/* is expanded to a A.jar:b.JAR, except that the order of jar files is unspecified. All jar files in the specified directory, even hidden ones, are included in the list. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. The CLASSPATH environment variable, where defined, will be similarly expanded. Any classpath wildcard expansion occurs before the Java virtual machine is started -- no Java program will ever see unexpanded wildcards except by querying the environment. For example; by invoking System.getenv("CLASSPATH").

-subpackages package1:package2:...
Generates documentation from source files in the specified packages and recursively in their subpackages. This option is useful when adding new subpackages to the source code, as they are automatically included. Each package argument is any top-level subpackage (such as java) or fully qualified package (such as javax.swing) that does not need to contain source files. Arguments are separated by colons (on all operating systmes). Wildcards are not needed or allowed. Use -sourcepath to specify where to find the packages. This option is smart about not processing source files that are in the source tree but do not belong to the packages, as described at processing of source files.

For example:

  % javadoc -d docs -sourcepath /home/user/src -subpackages java:javax.swing
This command generates documentation for packages named "java" and "javax.swing" and all their subpackages.

You can use -subpackages in conjunction with -exclude to exclude specific packages.

-exclude packagename1:packagename2:...
Unconditionally excludes the specified packages and their subpackages from the list formed by -subpackages. It excludes those packages even if they would otherwise be included by some previous or later -subpackages option. For example:
  % javadoc -sourcepath /home/user/src -subpackages java -exclude java.net:java.lang
would include java.io, java.util, and java.math (among others), but would exclude packages rooted at java.net and java.lang. Notice this excludes java.lang.ref, a subpackage of java.lang).

-bootclasspath classpathlist
Specifies the paths where the boot classes reside. These are nominally the Java platform classes. The bootclasspath is part of the search path the Javadoc tool will use to look up source and class files. See How Classes Are Found. for more details. Separate directories in classpathlist with colons (:).

-extdirs dirlist
Specifies the directories where extension classes reside. These are any classes that use the Java Extension mechanism. The extdirs is part of the search path the Javadoc tool will use to look up source and class files. See -classpath (above) for more details. Separate directories in dirlist with colons (:).

-verbose
Provides more detailed messages while javadoc is running. Without the verbose option, messages appear for loading the source files, generating the documentation (one message per source file), and sorting. The verbose option causes the printing of additional messages specifying the number of milliseconds to parse each java source file.

-quiet
Shuts off non-error and non-warning messages, leaving only the warnings and errors appear, making them easier to view. Also suppresses the version string.

-breakiterator
Uses the internationalized sentence boundary of java.text.BreakIterator to determine the end of the first sentence for English (all other locales already use BreakIterator), rather than an English language, locale-specific algorithm. By first sentence, we mean the first sentence in the main description of a package, class or member. This sentence is copied to the package, class or member summary, and to the alphabetic index.

From JDK 1.2 forward, the BreakIterator class is already used to determine the end of sentence for all languages but English. Therefore, the -breakiterator option has no effect except for English from 1.2 forward. English has its own default algorithm:

  • English default sentence-break algorithm - Stops at a period followed by a space or a HTML block tag, such as <P>.
  • Breakiterator sentence-break algorithm - In general, stops at a period, question mark or exclamation mark followed by a space if the next word starts with a capital letter. This is meant to handle most abbreviations (such as "The serial no. is valid", but won't handle "Mr. Smith"). Doesn't stop at HTML tags or sentences that begin with numbers or symbols. Stops at the last period in "../filename", even if embedded in an HTML tag.

NOTE: We have removed from 1.5.0 the breakiterator warning messages that were in 1.4.x and have left the default sentence-break algorithm unchanged. That is, the -breakiterator option is not the default in 1.5.0, nor do we expect it to become the default. This is a reversal from our former intention that the default would change in the "next major release" (1.5.0). This means if you have not modified your source code to eliminate the breakiterator warnings in 1.4.x, then you don't have to do anything, and the warnings go away starting with 1.5.0. The reason for this reversal is because any benefit to having breakiterator become the default would be outweighed by the incompatible source change it would require. We regret any extra work and confusion this has caused.

-locale language_country_variant

Important - The -locale option must be placed ahead (to the left) of any options provided by the standard doclet or any other doclet. Otherwise, the navigation bars will appear in English. This is the only command-line option that is order-dependent.

Specifies the locale that javadoc uses when generating documentation. The argument is the name of the locale, as described in java.util.Locale documentation, such as en_US (English, United States) or en_US_WIN (Windows variant).

Specifying a locale causes javadoc to choose the resource files of that locale for messages (strings in the navigation bar, headings for lists and tables, help file contents, comments in stylesheet.css, and so forth). It also specifies the sorting order for lists sorted alphabetically, and the sentence separator to determine the end of the first sentence. It does not determine the locale of the doc comment text specified in the source files of the documented classes.

-encoding name
Specifies the encoding name of the source files, such as EUCJIS/SJIS. If this option is not specified, the platform default converter is used.

Also see -docencoding and -charset.

-J flag
Passes flag directly to the runtime system java that runs javadoc. Notice there must be no space between the J and the flag. For example, if you need to ensure that the system sets aside 32 megabytes of memory in which to process the generated documentation, then you would call the -Xmx option of java as follows (-Xms is optional, as it only sets the size of initial memory, which is useful if you know the minimum amount of memory required):
   % javadoc -J-Xmx32m -J-Xms32m com.mypackage
To tell what version of javadoc you are using, call the "-version" option of java:
   % javadoc -J-version
   java version "1.2"
   Classic VM (build JDK-1.2-V, green threads, sunwjit)
(The version number of the standard doclet appears in its output stream.)

Options Provided by the Standard Doclet

-d directory
Specifies the destination directory where javadoc saves the generated HTML files. (The "d" means "destination.") Omitting this option causes the files to be saved to the current directory. The value directory can be absolute, or relative to the current working directory. As of 1.4, the destination directory is automatically created when javadoc is run.

For example, the following generates the documentation for the package com.mypackage and saves the results in the /home/user/doc/ directory:

  % javadoc -d /home/user/doc com.mypackage

-use
Includes one "Use" page for each documented class and package. The page describes what packages, classes, methods, constructors and fields use any API of the given class or package. Given class C, things that use class C would include subclasses of C, fields declared as C, methods that return C, and methods and constructors with parameters of type C.

For example, let's look at what might appear on the "Use" page for String. The getName() method in the java.awt.Font class returns type String. Therefore, getName() uses String, and you will find that method on the "Use" page for String.

Note that this documents only uses of the API, not the implementation. If a method uses String in its implementation but does not take a string as an argument or return a string, that is not considered a "use" of String.

You can access the generated "Use" page by first going to the class or package, then clicking on the "Use" link in the navigation bar.

-version
Includes the @version text in the generated docs. This text is omitted by default. To tell what version of the Javadoc tool you are using, use the -J-version option.

-author
Includes the @author text in the generated docs.

-splitindex
Splits the index file into multiple files, alphabetically, one file per letter, plus a file for any index entries that start with non-alphabetical characters.

-windowtitle title
Specifies the title to be placed in the HTML <title> tag. This appears in the window title and in any browser bookmarks (favorite places) that someone creates for this page. This title should not contain any HTML tags, as the browser will not properly interpret them. Any internal quotation marks within title may have to be escaped. If -windowtitle is omitted, the Javadoc tool uses the value of -doctitle for this option.
  % javadoc -windowtitle "Java 2 Platform" com.mypackage
-doctitle title
Specifies the title to be placed near the top of the overview summary file. The title will be placed as a centered, level-one heading directly beneath the upper navigation bar. The title may contain html tags and white space, though if it does, it must be enclosed in quotes. Any internal quotation marks within title may have to be escaped.
  % javadoc -doctitle "Java<sup><font size=\"-2\">TM</font></sup>" com.mypackage
-title title
This option no longer exists. It existed only in Beta versions of Javadoc 1.2. It has been renamed to -doctitle. This option is being renamed to make it clear that it defines the document title rather than the window title.

-header header
Specifies the header text to be placed at the top of each output file. The header will be placed to the right of the upper navigation bar. header may contain HTML tags and white space, though if it does, it must be enclosed in quotes. Any internal quotation marks within header may have to be escaped.
  % javadoc -header "<b>Java 2 Platform </b><br>v1.4" com.mypackage

-footer footer
Specifies the footer text to be placed at the bottom of each output file. The footer will be placed to the right of the lower navigation bar. footer may contain html tags and white space, though if it does, it must be enclosed in quotes. Any internal quotation marks within footer may have to be escaped.

-bottom text
Specifies the text to be placed at the bottom of each output file. The text will be placed at the bottom of the page, below the lower navigation bar. The text may contain HTML tags and white space, though if it does, it must be enclosed in quotes. Any internal quotation marks within text may have to be escaped.

-link extdocURL
Creates links to existing javadoc-generated documentation of external referenced classes. It takes one argument:

  • extdocURL is the absolute or relative URL of the directory containing the external javadoc-generated documentation you want to link to. Examples are shown below. The package-list file must be found in this directory (otherwise, use -linkoffline). The Javadoc tool reads the package names from the package-list file and then links to those packages at that URL. When the Javadoc tool is run, the extdocURL value is copied literally into the <A HREF> links that are created. Therefore, extdocURL must be the URL to the directory, not to a file.

    You can use an absolute link for extdocURL to enable your docs to link to a document on any website, or can use a relative link to link only to a relative location. If relative, the value you pass in should be the relative path from the destination directory (specified with -d) to the directory containing the packages being linked to.

    When specifying an absolute link you normally use an http: link. However, if you want to link to a file system that has no web server, you can use a file: link -- however, do this only if everyone wanting to access the generated documentation shares the same file system.

    In all cases, and on all operating systems, you should use a forward slash as the separator, whether the URL is absolute or relative, and "http:" or "file:" based (as specified in the URL Memo).

    Absolute http: based link:
    -link http://<host>/<directory>/<directory>/.../<name>
    Absolute file: based link:
    -link file://<host>/<directory>/<directory>/.../<name>
    Relative link:
    -link <directory>/<directory>/.../<name>

You can specify multiple -link options in a given javadoc run to link to multiple documents.

Choosing between -linkoffline and -link:
Use -link:
  • when using a relative path to the external API document, or
  • when using an absolute URL to the external API document, if your shell allows a program to open a connection to that URL for reading.
Use -linkoffline:
  • when using an absolute URL to the external API document, if your shell does not allow a program to open a connection to that URL for reading. This can occur if you are behind a firewall and the document you want to link to is on the other side.

Example using absolute links to the external docs - Let's say you want to link to the java.lang, java.io and other Java 2 Platform packages at http://java.sun.com/j2se/1.5.0/docs/api, The following command generates documentation for the package com.mypackage with links to the Java 2 Platform packages. The generated documentation will contain links to the Object class, for example, in the class trees. (Other options, such as -sourcepath and -d, are not shown.)

  % javadoc -link http://java.sun.com/j2se/1.5.0/docs/api com.mypackage
Example using relative links to the external docs - Let's say you have two packages whose docs are generated in different runs of the Javadoc tool, and those docs are separated by a relative path. In this example, the packages are com.apipackage, an API, and com.spipackage, an SPI (Service Provide Interface). You want the documentation to reside in docs/api/com/apipackage and docs/spi/com/spipackage. Assuming the API package documentation is already generated, and that docs is the current directory, you would document the SPI package with links to the API documentation by running:
  % javadoc -d ./spi -link ../api com.spipackage

Notice the -link argument is relative to the destination directory (docs/spi).

Details - The -link option enables you to link to classes referenced to by your code but not documented in the current javadoc run. For these links to go to valid pages, you must know where those HTML pages are located, and specify that location with extdocURL. This allows, for instance, third party documentation to link to java.* documentation on http://java.sun.com.

Omit the -link option for javadoc to create links only to API within the documentation it is generating in the current run. (Without the -link option, the Javadoc tool does not create links to documentation for external references, because it does not know if or where that documentation exists.)

This option can create links in several places in the generated documentation.

Another use is for cross-links between sets of packages: Execute javadoc on one set of packages, then run javadoc again on another set of packages, creating links both ways between both sets.

How a Class Must be Referenced - For a link to an external referenced class to actually appear (and not just its text label), the class must be referenced in the following way. It is not sufficient for it to be referenced in the body of a method. It must be referenced in either an import statement or in a declaration. Here are examples of how the class java.io.File can be referenced:

  • In any kind of import statement: by wildcard import, import explicitly by name, or automatically import for java.lang.*. For example, this would suffice:
    import java.io.*;
    In 1.3.x and 1.2.x, only an explicit import by name works -- a wildcard import statement does not work, nor does the automatic import java.lang.*.
  • In a declaration:
    void foo(File f) {}
    The reference and be in the return type or parameter type of a method, constructor, field, class or interface, or in an implements, extends or throws statement.

An important corollary is that when you use the -link option, there may be many links that unintentionally do not appear due to this constraint. (The text would appear without a hypertext link.) You can detect these by the warnings they emit. The most innocuous way to properly reference a class and thereby add the link would be to import that class, as shown above.

Package List - The -link option requires that a file named package-list, which is generated by the Javadoc tool, exist at the URL you specify with -link. The package-list file is a simple text file that lists the names of packages documented at that location. In the earlier example, the Javadoc tool looks for a file named package-list at the given URL, reads in the package names and then links to those packages at that URL.

For example, the package list for the Java 2 Platform 5.0 API is located at http://java.sun.com/j2se/1.5.0/docs/api/package-list. and starts out as follows:

  java.applet
  java.awt
  java.awt.color
  java.awt.datatransfer
  java.awt.dnd
  java.awt.event
  java.awt.font
  etc.

When javadoc is run without the -link option, when it encounters a name that belongs to an external referenced class, it prints the name with no link. However, when the -link option is used, the Javadoc tool searches the package-list file at the specified extdocURL location for that package name. If it finds the package name, it prefixes the name with extdocURL.

In order for there to be no broken links, all of the documentation for the external references must exist at the specified URLs. The Javadoc tool will not check that these pages exist -- only that the package-list exists.

Multiple Links - You can supply multiple -link options to link to any number of external generated documents. Javadoc 1.2 has a known bug which prevents you from supplying more than one -link command. This was fixed in 1.2.2.

Specify a different link option for each external document to link to:

% javadoc -link extdocURL1 -link extdocURL2 ... -link extdocURLn com.mypackage

where extdocURL1, extdocURL2, ... extdocURLn point respectively to the roots of external documents, each of which contains a file named package-list.

Cross-links - Note that "bootstrapping" may be required when cross-linking two or more documents that have not previously been generated. In other words, if package-list does not exist for either document, when you run the Javadoc tool on the first document, the package-list will not yet exist for the second document. Therefore, to create the external links, you must re-generate the first document after generating the second document.

In this case, the purpose of first generating a document is to create its package-list (or you can create it by hand it if you're certain of the package names). Then generate the second document with its external links. The Javadoc tool prints a warning if a needed external package-list file does not exist.

-linkoffline extdocURL packagelistLoc
This option is a variation of -link; they both create links to javadoc-generated documentation for external referenced classes. Use the -linkoffline option when linking to a document on the web when the Javadoc tool itself is "offline" -- that is, it cannot access the document through a web connection.

More specifically, use -linkoffline if the external document's package-list file is not accessible or does not exist at the extdocURL location but does exist at a different location, which can be specified by packageListLoc (typically local). Thus, if extdocURL is accessible only on the World Wide Web, -linkoffline removes the constraint that the Javadoc tool have a web connection when generating the documentation.

Another use is as a "hack" to update docs: After you have run javadoc on a full set of packages, then you can run javadoc again on onlya smaller set of changed packages, so that the updated files can be inserted back into the original set. Examples are given below.

The -linkoffline option takes two arguments -- the first for the string to be embedded in the <a href> links, the second telling it where to find package-list:

  • extdocURL is the absolute or relative URL of the directory containing the external javadoc-generated documentation you want to link to. If relative, the value should be the relative path from the destination directory (specified with -d) to the root of the packages being linked to. For more details, see extdocURL in the -link option.
  • packagelistLoc is the path or URL to the directory containing the package-list file for the external documentation. This can be a URL (http: or file:) or file path, and can be absolute or relative. If relative, make it relative to the current directory from where javadoc was run. Do not include the package-list filename.

You can specify multiple -linkoffline options in a given javadoc run. (Prior to 1.2.2, it could be specified only once.)

Example using absolute links to the external docs - Let's say you want to link to the java.lang, java.io and other Java 2 Platform packages at http://java.sun.com/j2se/1.5.0/docs/api, but your shell does not have web access. You could open the package-list file in a browser at http://java.sun.com/j2se/1.5.0/docs/api/package-list, save it to a local directory, and point to this local copy with the second argument, packagelistLoc. In this example, the package list file has been saved to the current directory "." . The following command generates documentation for the package com.mypackage with links to the Java 2 Platform packages. The generated documentation will contain links to the Object class, for example, in the class trees. (Other necessary options, such as -sourcepath, are not shown.)

% javadoc -linkoffline http://java.sun.com/j2se/1.5.0/docs/api . com.mypackage

Example using relative links to the external docs - It's not very common to use -linkoffline with relative paths, for the simple reason that -link usually suffices. When using -linkoffline, the package-list file is generally local, and when using relative links, the file you are linking to is also generally local. So it is usually unnecessary to give a different path for the two arguments to -linkoffline. When the two arguments are identical, you can use -link. See the -link relative example.

Manually Creating a package-list File - If a package-list file does not yet exist, but you know what package names your document will link to, you can create your own copy of this file by hand and specify its path with packagelistLoc. An example would be the previous case where the package list for com.spipackage did not exist when com.apipackage was first generated. This technique is useful when you need to generate documentation that links to new external documentation whose package names you know, but which is not yet published. This is also a way of creating package-list files for packages generated with Javadoc 1.0 or 1.1, where package-list files were not generated. Likewise, two companies can share their unpublished package-list files, enabling them to release their cross-linked documentation simultaneously.

Linking to Multiple Documents - You can include -linkoffline once for each generated document you want to refer to (each option is shown on a separate line for clarity):

% javadoc -linkoffline extdocURL1 packagelistLoc1 \
          -linkoffline extdocURL2 packagelistLoc2 \
          ...

Updating docs - Another use for -linkoffline option is useful if your project has dozens or hundreds of packages, if you have already run javadoc on the entire tree, and now, in a separate run, you want to quickly make some small changes and re-run javadoc on just a small portion of the source tree. This is somewhat of a hack in that it works properly only if your changes are only to doc comments and not to declarations. If you were to add, remove or change any declarations from the source code, then broken links could show up in the index, package tree, inherited member lists, use page, and other places.

First, you create a new destination directory (call it update) for this new small run. Let's say the original destination directory was named html. In the simplest example, cd to the parent of html. Set the first argument of -linkoffline to the current directory "." and set the second argument to the relative path to html, where it can find package-list, and pass in only the package names of the packages you want to update:

  % javadoc -d update -linkoffline . html com.mypackage
When the Javadoc tool is done, copy these generated class pages in update/com/package (not the overview or index), over the original files in html/com/package.

-linksource
Creates an HTML version of each source file (with line numbers) and adds links to them from the standard HTML documentation. Links are created for classes, interfaces, constructors, methods and fields whose declarations are in a source file. Otherwise, links are not created, such as for default constructors and generated classes.

This option exposes all private implementation details in the included source files, including private classes, private fields, and the bodies of private methods, regardless of the -public, -package, -protected and -private options. Unless you also use the -private option, not all private classes or interfaces will necessarily be accessible via links.

Each link appears on the name of the identifier in its declaration. For example, the link to the source code of the Button class would be on the word "Button":

    public class Button
    extends Component
    implements Accessible
and the link to the source code of the getLabel() method in the Button class would be on the word "getLabel":
    public String getLabel()

-group groupheading packagepattern:packagepattern:...
Separates packages on the overview page into whatever groups you specify, one group per table. You specify each group with a different -group option. The groups appear on the page in the order specified on the command line; packages are alphabetized within a group. For a given -group option, the packages matching the list of packagepattern expressions appear in a table with the heading groupheading.
  • groupheading can be any text, and can include white space. This text is placed in the table heading for the group.
  • packagepattern can be any package name, or can be the start of any package name followed by an asterisk (*). The asterisk is a wildcard meaning "match any characters". This is the only wildcard allowed. Multiple patterns can be included in a group by separating them with colons (:).

NOTE: If using an asterisk in a pattern or pattern list, the pattern list must be inside quotes, such as "java.lang*:java.util"

If you do not supply any -group option, all packages are placed in one group with the heading "Packages". If the all groups do not include all documented packages, any leftover packages appear in a separate group with the heading "Other Packages".

For example, the following option separates the four documented packages into core, extension and other packages. Notice the trailing "dot" does not appear in "java.lang*" -- including the dot, such as "java.lang.*" would omit the java.lang package.

  % javadoc -group "Core Packages" "java.lang*:java.util"
            -group "Extension Packages" "javax.*"
            java.lang java.lang.reflect java.util javax.servlet java.new
This results in the groupings:
Core Packages
java.lang
java.lang.reflect
java.util
Extension Packages
javax.servlet
Other Packages
java.new

-nodeprecated
Prevents the generation of any deprecated API at all in the documentation. This does what -nodeprecatedlist does, plus it does not generate any deprecated API throughout the rest of the documentation. This is useful when writing code and you don't want to be distracted by the deprecated code.

-nodeprecatedlist
Prevents the generation of the file containing the list of deprecated APIs (deprecated-list.html) and the link in the navigation bar to that page. (However, javadoc continues to generate the deprecated API throughout the rest of the document.) This is useful if your source code contains no deprecated API, and you want to make the navigation bar cleaner.

-nosince
Omits from the generated docs the "Since" sections associated with the @since tags.

-notree
Omits the class/interface hierarchy pages from the generated docs. These are the pages you reach using the "Tree" button in the navigation bar. The hierarchy is produced by default.

-noindex
Omits the index from the generated docs. The index is produced by default.

-nohelp
Omits the HELP link in the navigation bars at the top and bottom of each page of output.

-nonavbar
Prevents the generation of the navigation bar, header and footer, otherwise found at the top and bottom of the generated pages. Has no affect on the "bottom" option. The -nonavbar option is useful when you are interested only in the content and have no need for navigation, such as converting the files to PostScript or PDF for print only.

-helpfile path/filename
Specifies the path of an alternate help file path/filename that the HELP link in the top and bottom navigation bars link to. Without this option, the Javadoc tool automatically creates a help file help-doc.html that is hard-coded in the Javadoc tool. This option enables you to override this default. The filename can be any name and is not restricted to help-doc.html -- the Javadoc tool will adjust the links in the navigation bar accordingly. For example:
  % javadoc -helpfile /home/user/myhelp.html java.awt
-stylesheetfile path/filename
Specifies the path of an alternate HTML stylesheet file. Without this option, the Javadoc tool automatically creates a stylesheet file stylesheet.css that is hard-coded in the Javadoc tool. This option enables you to override this default. The filename can be any name and is not restricted to stylesheet.css. For example:
  % javadoc -stylesheetfile /home/user/mystylesheet.css com.mypackage
-serialwarn
Generates compile-time warnings for missing @serial tags. By default, Javadoc 1.2.2 (and later versions) generates no serial warnings. (This is a reversal from earlier versions.) Use this option to display the serial warnings, which helps to properly document default serializable fields and writeExternal methods.

-charset name
Specifies the HTML character set for this document. The name should be a preferred MIME name as given in the IANA Registry. For example:
  % javadoc -charset "iso-8859-1" mypackage
would insert the following line in the head of every generated page:
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
This META tag is described in the HTML standard. (4197265 and 4137321)

Also see -encoding and -docencoding.

-docencoding name
Specifies the encoding of the generated HTML files. The name should be a preferred MIME name as given in the IANA Registry. If you omit this option but use -encoding, then the encoding of the generated HTML files is determined by -encoding. Example:
  % javadoc -docencoding "ISO-8859-1" mypackage
Also see -encoding and -charset.

-keywords
Adds HTML meta keyword tags to the generated file for each class. These tags can help the page be found by search engines that look for meta tags. (Most search engines that search the entire Internet do not look at meta tags, because pages can misuse them; but search engines offered by companies that confine their search to their own website can benefit by looking at meta tags.)

The meta tags include the fully qualified name of the class and the unqualified names of the fields and methods. Constructors are not included because they are identical to the class name. For example, the class String starts with these keywords:

     <META NAME="keywords" CONTENT="java.lang.String class">
     <META NAME="keywords" CONTENT="CASE_INSENSITIVE_ORDER">
     <META NAME="keywords" CONTENT="length()">
     <META NAME="keywords" CONTENT="charAt()">

-tag tagname:Xaoptcmf:"taghead"
Enables the Javadoc tool to interpret a simple, one-argument custom block tag @tagname in doc comments. So the Javadoc tool can "spell-check" tag names, it is important to include a -tag option for every custom tag that is present in the source code, disabling (with X) those that are not being output in the current run.

The colon (:) is always the separator. To use a colon in tagname, see Use of Colon in Tag Name.

The -tag option outputs the tag's heading taghead in bold, followed on the next line by the text from its single argument, as shown in the example below. Like any block tag, this argument's text can contain inline tags, which are also interpreted. The output is similar to standard one-argument tags, such as @return and @author. Omitting taghead causes tagname to appear as the heading.

Placement of tags - The Xaoptcmf part of the argument determines where in the source code the tag is allowed to be placed, and whether the tag can be disabled (using X). You can supply either a, to allow the tag in all places, or any combination of the other letters:

X (disable tag)
a (all)
o (overview)
p (packages)
t (types, that is classes and interfaces)
c (constructors)
m (methods)
f (fields)

Examples of single tags - An example of a tag option for a tag that that can be used anywhere in the source code is:

    -tag todo:a:"To Do:"
If you wanted @todo to be used only with constructors, methods and fields, you would use:
    -tag todo:cmf:"To Do:"
Notice the last colon (:) above is not a parameter separator, but is part of the heading text (as shown below). You would use either tag option for source code that contains the tag @todo, such as:
     @todo The documentation for this method needs work.
Use of Colon in Tag Name - A colon can be used in a tag name if it is escaped with a backslash. For this doc comment:
    /**
     * @ejb:bean
     */
use this tag option:
    -tag ejb\\:bean:a:"EJB Bean:"
Spell-checking tag names (Disabling tags) - Some developers put custom tags in the source code that they don't always want to output. In these cases, it is important to list all tags that are present in the source code, enabling the ones you want to output and disabling the ones you don't want to output. The presence of X disables the tag, while its absence enables the tag. This gives the Javadoc tool enough information to know if a tag it encounters is unknown, probably the results of a typo or a misspelling. It prints a warning in these cases.

You can add X to the placement values already present, so that when you want to enable the tag, you can simply delete the X. For example, if @todo is a tag that you want to suppress on output, you would use:

    -tag todo:Xcmf:"To Do:"
or, if you'd rather keep it simple:
    -tag todo:X

The syntax -tag todo:X works even if @todo is defined by a taglet.

Order of tags - The order of the -tag (and -taglet) options determine the order the tags are output. You can mix the custom tags with the standard tags to intersperse them. The tag options for standard tags are placeholders only for determining the order -- they take only the standard tag's name. (Subheadings for standard tags cannot be altered.) This is illustrated in the following example.

If -tag is missing, then the position of -taglet determines its order. If they are both present, then whichever appears last on the command line determines its order. (This happens because the tags and taglets are processed in the order that they appear on the command line. For example, if -taglet and -tag both have the name "todo", the one that appears last on the command line will determine its order.

Example of a complete set of tags - This example inserts "To Do" after "Parameters" and before "Throws" in the output. By using "X", it also specifies that @example is a tag that might be encountered in the source code that should not be output during this run. Notice that if you use @argfile, you can put the tags on separate lines in an argument file like this (no line continuation characters needed):

   -tag param
   -tag return
   -tag todo:a:"To Do:"
   -tag throws
   -tag see
   -tag example:X

When javadoc parses the doc comments, any tag encountered that is neither a standard tag nor passed in with -tag or -taglet is considered unknown, and a warning is thrown.

The standard tags are initially stored internally in a list in their default order. Whenever -tag options are used, those tags get appended to this list -- standard tags are moved from their default position. Therefore, if a -tag option is omitted for a standard tag, it remains in its default position.

Avoiding Conflicts - If you want to slice out your own namespace, you can use a dot-separated naming convention similar to that used for packages: com.mycompany.todo. Sun will continue to create standard tags whose names do not contain dots. Any tag you create will override the behavior of a tag by the same name defined by Sun. In other words, if you create a tag or taglet @todo, it will always have the same behavior you define, even if Sun later creates a standard tag of the same name.

Annotations vs. Javadoc Tags - In general, if the markup you want to add is intended to affect or produce documentation, it should probably be a javadoc tag; otherwise, it should be an annotation. See Comparing Annotations and Javadoc Tags

You can also create more complex block tags, or custom inline tags with the -taglet option.

-taglet class
Specifies the class file that starts the taglet used in generating the documentation for that tag. Use the fully-qualified name for class. This taglet also defines the number of text arguments that the custom tag has. The taglet accepts those arguments, processes them, and generates the output. For extensive documentation with example taglets, see:
  • Taglet Overview

Taglets are useful for block or inline tags. They can have any number of arguments and implement custom behavior, such as making text bold, formatting bullets, writing out the text to a file, or starting other processes.

Taglets can only determine where a tag should appear and in what form. All other decisions are made by the doclet. So a taglet cannot do things such as remove a class name from the list of included classes. However, it can execute side effects, such as printing the tag's text to a file or triggering another process.

Use the -tagletpath option to specify the path to the taglet. Here is an example that inserts the "To Do" taglet after "Parameters" and ahead of "Throws" in the generated pages:

    -taglet com.sun.tools.doclets.ToDoTaglet
    -tagletpath /home/taglets
    -tag return
    -tag param
    -tag todo
    -tag throws
    -tag see

Alternatively, you can use the -taglet option in place of its -tag option, but that may be harder to read.

-tagletpath tagletpathlist
Specifies the search paths for finding taglet class files (.class). The tagletpathlist can contain multiple paths by separating them with a colon (:). The Javadoc tool will search in all subdirectories of the specified paths.

-docfilessubdirs
Enables deep copying of "doc-files" directories. In other words, subdirectories and all contents are recursively copied to the destination. For example, the directory doc-files/example/images and all its contents would now be copied. There is also an option to exclude subdirectories.

-excludedocfilessubdir name1:name2...
Excludes any "doc-files" subdirectories with the given names. This prevents the copying of SCCS and other source-code-control subdirectories.

-noqualifier all | packagename1:packagename2:...
Omits qualifying package name from ahead of class names in output. The argument to -noqualifier is either "all" (all package qualifiers are omitted) or a colon-separate list of packages, with wildcards, to be removed as qualifiers. The package name is removed from places where class or interface names appear.

The following example omits all package qualifiers:

    -noqualifier all
The following example omits "java.lang" and "java.io" package qualifiers:
    -noqualifier java.lang:java.io
The following example omits package qualifiers starting with "java", and "com.sun" subpackages (but not "javax"):
    -noqualifier java.*:com.sun.*
Where a package qualifier would appear due to the above behavior, the name can be suitably shortened -- see How a name is displayed. This rule is in effect whether or not -noqualifier is used.

-notimestamp
Suppresses the timestamp, which is hidden in an HTML comment in the generated HTML near the top of each page. Useful when you want to run javadoc on two source bases and diff them, as it prevents timestamps from causing a diff (which would otherwise be a diff on every page). The timestamp includes the javadoc version number, and currently looks like this:
     <!-- Generated by javadoc (build 1.5.0-internal) on Tue Jun 22 09:57:24 PDT 2004 -->

-nocomment
Suppress the entire comment body, including the main description and all tags, generating only declarations. This option enables re-using source files originally intended for a different purpose, to produce skeleton HTML documentation at the early stages of a new project.

COMMAND LINE ARGUMENT FILES

To shorten or simplify the javadoc command line, you can specify one or more files that themselves contain arguments to the javadoc command (except -J options). This enables you to create javadoc commands of any length on any operating system.

An argument file can include javac options and source filenames in any combination. The arguments within a file can be space-separated or newline-separated. If a filename contains embedded spaces, put the whole filename in double quotes.

Filenames within an argument file are relative to the current directory, not the location of the argument file. Wildcards (*) are not allowed in these lists (such as for specifying *.java). Use of the '@' character to recursively interpret files is not supported. The -J options are not supported because they are passed to the launcher, which does not support argument files.

When executing javadoc, pass in the path and name of each argument file with the '@' leading character. When javadoc encounters an argument beginning with the character `@', it expands the contents of that file into the argument list.

Example - Single Arg File

You could use a single argument file named "argfile" to hold all Javadoc arguments:

  % javadoc @argfile

This argument file could contain the contents of both files shown in the next example.

Example - Two Arg Files

You can create two argument files -- one for the Javadoc options and the other for the package names or source filenames: (Notice the following lists have no line-continuation characters.)

Create a file named "options" containing:

     -d docs-filelist
     -use
     -splitindex
     -windowtitle 'Java 2 Platform v1.3 API Specification'
     -doctitle 'Java<sup><font size="-2">TM</font></sup> 2 Platform 5.0 API Specification'
     -header '<b>Java 2 Platform </b><br><font size="-1">5.0</font>'
     -bottom 'Copyright 1993-2000 Sun Microsystems, Inc. All Rights Reserved.'
     -group "Core Packages" "java.*"
     -overview /java/pubs/ws/1.5/src/share/classes/overview-core.html
     -sourcepath /java/pubs/ws/1.5/src/share/classes

Create a file named "packages" containing:

     com.mypackage1
     com.mypackage2
     com.mypackage3

You would then run javadoc with:

  % javadoc @options @packages

Example - Arg Files with Paths

The argument files can have paths, but any filenames inside the files are relative to the current working directory (not path1 or path2):

  % javadoc @path1/options @path2/packages

Example - Option Arguments

Here's an example of saving just an argument to a javadoc option in an argument file. We'll use the -bottom option, since it can have a lengthy argument. You could create a file named "bottom" containing its text argument:

'<font size="-1"><a href="http://java.sun.com/cgi-bin/bugreport.cgi">Submit a
bug or feature</a><br><br>Java is a trademark or registered trademark of
Sun Microsystems, Inc. in the US and other countries.<br>Copyright 1993-2000 Sun
Microsystems, Inc. 901 San Antonio Road,<br>Palo Alto, California, 94303, U.S.A.
All Rights Reserved.</font>'

Then run the Javadoc tool with:

  % javadoc -bottom @bottom @packages

Or you could include the -bottom option at the start of the argument file, and then just run it as:

  % javadoc @bottom @packages

Running

RUNNING JAVADOC

Version Numbers - The version number of javadoc can be determined using javadoc -J-version. The version number of the standard doclet appears in its output stream. It can be turned off with -quiet.

Public programmatic interface - To invoke the Javadoc tool from within programs written in the Java language. This interface is in com.sun.tools.javadoc.Main (and javadoc is re-entrant). For more details, see Standard Doclet.

Running Doclets - The instructions given below are for invoking the standard HTML doclet. To invoke a custom doclet, use the -doclet and -docletpath options. For full, working examples of running a particular doclet, see Running the MIF Doclet.

SIMPLE EXAMPLES

You can run javadoc on entire packages or individual source files. Each package name has a corresponding directory name. In the following examples, the source files are located at /home/src/java/awt/*.java. The destination directory is /home/html.

Documenting One or More Packages

To document a package, the source files (*.java) for that package must be located in a directory having the same name as the package. If a package name is made up of several identifiers (separated by dots, such as java.awt.color), each subsequent identifier must correspond to a deeper subdirectory (such as java/awt/color). You may split the source files for a single package among two such directory trees located at different places, as long as -sourcepath points to them both -- for example src1/java/awt/color and src2/java/awt/color.

You can run javadoc either by changing directories (with cd) or by using -sourcepath option. The examples below illustrate both alternatives.

  • Case 1 - Run recursively starting from one or more packages - This example uses -sourcepath so javadoc can be run from any directory and -subpackages (a new 1.4 option) for recursion. It traverses the subpackages of the java directory excluding packages rooted at java.net and java.lang. Notice this excludes java.lang.ref, a subpackage of java.lang).
      % javadoc -d /home/html -sourcepath /home/src -subpackages java -exclude java.net:java.lang

    To also traverse down other package trees, append their names to the -subpackages argument, such as java:javax:org.xml.sax.

  • Case 2 - Run on explicit packages after changing to the "root" source directory - Change to the parent directory of the fully-qualified package. Then run javadoc, supplying names of one or more packages you want to document:
      % cd /home/src/
  % javadoc -d /home/html java.awt java.awt.event
  • Case 3 - Run from any directory on explicit packages in a single directory tree - In this case, it doesn't matter what the current directory is. Run javadoc supplying -sourcepath with the parent directory of the top-level package, and supplying names of one or more packages you want to document:
      % javadoc -d /home/html -sourcepath /home/src java.awt java.awt.event
  • Case 4 - Run from any directory on explicit packages in multiple directory trees - This is the same as case 3, but for packages in separate directory trees. Run javadoc supplying -sourcepath with the path to each tree's root (colon-separated) and supply names of one or more packages you want to document. All source files for a given package do not need to be located under a single root directory -- they just need to be found somewhere along the sourcepath.
      % javadoc -d /home/html -sourcepath /home/src1:/home/src2 java.awt java.awt.event

Result: All cases generate HTML-formatted documentation for the public and protected classes and interfaces in packages java.awt and java.awt.event and save the HTML files in the specified destination directory (/home/html). Because two or more packages are being generated, the document has three HTML frames -- for the list of packages, the list of classes, and the main class pages.

Documenting One or More Classes

The second way to run the Javadoc tool is by passing in one or more source files (.java). You can run javadoc either of the following two ways -- by changing directories (with cd) or by fully-specifying the path to the .java files. Relative paths are relative to the current directory. The -sourcepath option is ignored when passing in source files. You can use command line wildcards, such as asterisk (*), to specify groups of classes.

  • Case 1 - Changing to the source directory - Change to the directory holding the .java files. Then run javadoc, supplying names of one or more source files you want to document.
      % cd /home/src/java/awt
  % javadoc -d /home/html Button.java Canvas.java Graphics*.java
    This example generates HTML-formatted documentation for the classes Button, Canvas and classes beginning with Graphics. Because source files rather than package names were passed in as arguments to javadoc, the document has two frames -- for the list of classes and the main page.
  • Case 2 - Changing to the package root directory - This is useful for documenting individual source files from different subpackages off the same root. Change to the package root directory, and supply the source files with paths from the root.
      % cd /home/src/
  % javadoc -d /home/html java/awt/Button.java java/applet/Applet.java
    This example generates HTML-formatted documentation for the classes Button and Applet.
  • Case 3 - From any directory - In this case, it doesn't matter what the current directory is. Run javadoc supplying the absolute path (or path relative to the current directory) to the .java files you want to document.
      % javadoc -d /home/html /home/src/java/awt/Button.java /home/src/java/awt/Graphics*.java
    This example generates HTML-formatted documentation for the class Button and classes beginning with Graphics.

Documenting Both Packages and Classes

You can document entire packages and individual classes at the same time. Here's an example that mixes two of the previous examples. You can use -sourcepath for the path to the packages but not for the path to the individual classes.

  % javadoc -d /home/html -sourcepath /home/src java.awt /home/src/java/applet/Applet.java

This example generates HTML-formatted documentation for the package java.awt and class Applet. (The Javadoc tool determines the package name for Applet from the package declaration, if any, in the Applet.java source file.)

REAL WORLD EXAMPLE

The Javadoc tool has many useful options, some of which are more commonly used than others. Here is effectively the command we use to run the Javadoc tool on the Java platform API. We use 180MB of memory to generate the documentation for the 1500 (approx.) public and protected classes in the Java 2 Platform, Standard Edition, v1.2.

The same example is shown twice -- first as executed on the command line, then as executed from a makefile. It uses absolute paths in the option arguments, which enables the same javadoc command to be run from any directory.

Command Line Example

This command line example is over 900 characters, which is too long for some shells, such as DOS. You can use a command line argument file (or write a shell script) to workaround this limitation.

% javadoc -sourcepath /java/jdk/src/share/classes            \
    -overview /java/jdk/src/share/classes/overview.html      \
    -d /java/jdk/build/api                                   \
    -use                                                     \
    -splitIndex                                              \
    -windowtitle 'Java 2 Platform 5.0 API Specification'    \
    -doctitle 'Java<sup><font size="-2">TM</font></sup> 2 Platform 5.0 API Specification' \
    -header '<b>Java 2 Platform </b><br><font size="-1">5.0</font>' \
    -bottom '<font size="-1"><a href="http://java.sun.com/cgi-bin/bugreport.cgi">Submit
a bug or feature</a><br><br>Java is a trademark or registered trademark of Sun Microsystems,
Inc. in the US and other countries.<br>Copyright 1993-1999 Sun Microsystems, Inc.
901 San Antonio Road,<br>Palo Alto, California, 94303, U.S.A. All Rights Reserved.</font>' \
    -group "Core Packages" "java.*:com.sun.java.*:org.omg.*" \
    -group "Extension Packages" "javax.*"                    \
    -J-Xmx180m                                               \
    @packages

where packages is the name of a file containing the packages to process, such as java.applet java.lang. None of the options should contain any newline characters between the single quotes. (For example, if you copy and paste this example, delete the newline characters from the -bottom option.) See the other notes listed below.

Makefile Example

This is an example of a GNU makefile. For an example of a Windows makefile, see creating a makefile for Windows.

javadoc -sourcepath $(SRCDIR)              \   /* Sets path for source files     */
        -overview $(SRCDIR)/overview.html  \   /* Sets file for overview text    */
        -d /java/jdk/build/api             \   /* Sets destination directory     */
        -use                               \   /* Adds "Use" files               */
        -splitIndex                        \   /* Splits index A-Z               */
        -windowtitle $(WINDOWTITLE)        \   /* Adds a window title            */
        -doctitle $(DOCTITLE)              \   /* Adds a doc title               */
        -header $(HEADER)                  \   /* Adds running header text       */
        -bottom $(BOTTOM)                  \   /* Adds text at bottom            */
        -group $(GROUPCORE)                \   /* 1st subhead on overview page   */
        -group $(GROUPEXT)                 \   /* 2nd subhead on overview page   */
        -J-Xmx180m                         \   /* Sets memory to 180MB           */
        java.lang java.lang.reflect        \   /* Sets packages to document      */
        java.util java.io java.net         \
        java.applet

WINDOWTITLE = 'Java 2 Platform v1.2 API Specification'
DOCTITLE = 'Java<sup><font size="-2">TM</font></sup> 2 Platform v1.2 API Specification'
HEADER = '<b>Java 2 Platform </b><br><font size="-1">v1.2</font>'
BOTTOM = '<font size="-1"><a href="http://java.sun.com/cgi-bin/bugreport.cgi">Submit
    a bug or feature</a><br><br>Java is a trademark or registered trademark
    of Sun Microsystems, Inc. in the US and other countries.<br>Copyright 1993-1999
    Sun Microsystems, Inc. 901 San Antonio Road,<br>Palo Alto, California, 94303, U.S.A.
    All Rights Reserved.</font>'
GROUPCORE = '"Core Packages" "java.*:com.sun.java.*:org.omg.*"'
GROUPEXT  = '"Extension Packages" "javax.*"'
SRCDIR = '/java/jdk/1.2/src/share/classes'

Single quotes are used to surround makefile arguments.

NOTES

  • If you omit the -windowtitle option, the Javadoc tool copies the doc title to the window title. The -windowtitle text is basically the same as the -doctitle but without HTML tags, to prevent those tags from appearing as raw text in the window title.
  • If you omit the -footer option, as done here, the Javadoc tool copies the header text to the footer.
  • Other important options you might want to use but not needed in this example are -classpath and -link.

TROUBLESHOOTING

General Troubleshooting

  • Javadoc FAQ - Commonly-encountered bugs and troubleshooting tips can be found on the Javadoc FAQ
  • Bugs and Limitations - You can also see some bugs listed at Important Bug Fixes and Changes.
  • Version number - See version numbers.
  • Documents only legal classes - When documenting a package, javadoc only reads files whose names are composed of legal class names. You can prevent javadoc from parsing a file by including, for example, a hyphen "-" in its filename.

Errors and Warnings

Error and warning messages contain the filename and line number to the declaration line rather than to the particular line in the doc comment.

  • "error: cannot read: Class1.java" the Javadoc tool is trying to load the class Class1.java in the current directory. The class name is shown with its path (absolute or relative), which in this case is the same as ./Class1.java.

ENVIRONMENT

CLASSPATH
Environment variable that provides the path which javadoc uses to find user class files. This environment variable is overridden by the -classpath option. Separate directories with a colon, for example:
.:/home/classes:/usr/local/java/classes

SEE ALSO

  • javac
  • java
  • jdb
  • javah
  • javap
  • Javadoc Home Page
  • How to Write Doc Comments for Javadoc
  • Setting the Class Path
  • How Javac and Javadoc Find Classes (tools.jar)

Javadoc is a trademark of Sun Microsystems, Inc. (The javadoc command itself does not require the trademark symbol.)

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


javah - C Header and Stub File Generator

javah produces C header files and C source files from a Java class. These files provide the connective glue that allow your Java and C code to interact.

SYNOPSIS

javah [ options ] fully-qualified-classname. . .
javah_g [ options ] fully-qualified-classname. . .

DESCRIPTION

javah generates C header and source files that are needed to implement native methods. The generated header and source files are used by C programs to reference an object's instance variables from native source code. The .h file contains a struct definition whose layout parallels the layout of the corresponding class. The fields in the struct correspond to instance variables in the class.

The name of the header file and the structure declared within it are derived from the name of the class. If the class passed to javah is inside a package, the package name is prepended to both the header file name and the structure name. Underscores (_) are used as name delimiters.

By default javah creates a header file for each class listed on the command line and puts the files in the current directory. Use the -stubs option to create source files. Use the -o option to concatenate the results for all listed classes into a single file.

The new native method interface, Java Native Interface (JNI), does not require header information or stub files. javah can still be used to generate native method function proptotypes needed for JNI-style native methods. javah produces JNI-style output by default, and places the result in the .h file.

javah_g is a non-optimized version of javah suitable for use with debuggers like jdb.

OPTIONS

-o outputfile
Concatenates the resulting header or source files for all the classes listed on the command line into outputfile. Only one of -o or -d may be used.
-d directory
Sets the directory where javah saves the header files or the stub files. Only one of -d or -o may be used.
-stubs
Causes javah to generate C declarations from the Java object file.
-verbose
Indicates verbose output and causes javah to print a message to stdout concerning the status of the generated files.
-help
Print help message for javah usage.
-version
Print out javah version information.
-jni
Causes javah to create an output file containing JNI-style native method function prototypes. This is the default output, so use of -jni is optional.
-classpath path
Specifies the path javah uses to look up classes. Overrides the default or the CLASSPATH environment variable if it is set. Directories are separated by colons. Thus the general format for path is:
   .:<your_path>
For example:
   .:/home/avh/classes:/usr/local/java/classes

As a special convenience, a class path element containing a basename of * is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR (a java program cannot tell the difference between the two invocations).

For example, if directory foo contains a.jar and b.JAR, then the class path element foo/* is expanded to a A.jar:b.JAR, except that the order of jar files is unspecified. All jar files in the specified directory, even hidden ones, are included in the list. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. The CLASSPATH environment variable, where defined, will be similarly expanded. Any classpath wildcard expansion occurs before the Java virtual machine is started -- no Java program will ever see unexpanded wildcards except by querying the environment. For example; by invoking System.getenv("CLASSPATH").

-bootclasspath path
Specifies path from which to load bootstrap classes. By default, the bootstrap classes are the classes implementing the core Java 2 platform located in jre/lib/rt.jar and several other jar files.
-old
Specifies that old JDK1.0-style header files should be generated.
-force
Specifies that output files should always be written.
-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by colons, for example,
.:/home/avh/classes:/usr/local/java/classes

SEE ALSO

javac, java, jdb, javap, javadoc

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


javap - The Java Class File Disassembler

Disassembles class files.

SYNOPSIS

javap [ options ] class. . .

DESCRIPTION

The javap command disassembles a class file. Its output depends on the options used. If no options are used, javap prints out the package, protected, and public fields and methods of the classes passed to it. javap prints its output to stdout. For example, compile the following class declaration:

import java.awt.*;
import java.applet.*;

public class DocFooter extends Applet {
        String date;
        String email;

        public void init() {
                resize(500,100);
                date = getParameter("LAST_UPDATED");
                email = getParameter("EMAIL");
        }

        public void paint(Graphics g) {
                g.drawString(date + " by ",100, 15);
                g.drawString(email,290,15);
        }
}

The output from javap DocFooter yields:

Compiled from DocFooter.java
public class DocFooter extends java.applet.Applet {
    java.lang.String date;
    java.lang.String email;
    public DocFooter();
    public void init();
    public void paint(java.awt.Graphics);
}

The output from javap -c DocFooter yields:

Compiled from DocFooter.java
public class DocFooter extends java.applet.Applet {
    java.lang.String date;
    java.lang.String email;
    public DocFooter();
    public void init();
    public void paint(java.awt.Graphics);
}

Method DocFooter()
   0 aload_0
   1 invokespecial #1 <Method java.applet.Applet()>
   4 return

Method void init()
   0 aload_0
   1 sipush 500
   4 bipush 100
   6 invokevirtual #2 <Method void resize(int, int)>
   9 aload_0
  10 aload_0
  11 ldc #3 <String "LAST_UPDATED">
  13 invokevirtual #4 <Method java.lang.String getParameter(java.lang.String)>
  16 putfield #5 <Field java.lang.String date>
  19 aload_0
  20 aload_0
  21 ldc #6 <String "EMAIL">
  23 invokevirtual #4 <Method java.lang.String getParameter(java.lang.String)>
  26 putfield #7 <Field java.lang.String email>
  29 return

Method void paint(java.awt.Graphics)
   0 aload_1
   1 new #8 <Class java.lang.StringBuffer>
   4 dup
   5 invokespecial #9 <Method java.lang.StringBuffer()>
   8 aload_0
   9 getfield #5 <Field java.lang.String date>
  12 invokevirtual #10 <Method java.lang.StringBuffer append(java.lang.String)>
  15 ldc #11 <String " by ">
  17 invokevirtual #10 <Method java.lang.StringBuffer append(java.lang.String)>
  20 invokevirtual #12 <Method java.lang.String toString()>
  23 bipush 100
  25 bipush 15
  27 invokevirtual #13 <Method void drawString(java.lang.String, int, int)>
  30 aload_1
  31 aload_0
  32 getfield #7 <Field java.lang.String email>
  35 sipush 290
  38 bipush 15
  40 invokevirtual #13 <Method void drawString(java.lang.String, int, int)>
  43 return

OPTIONS

-help
Prints out help message for javap.
-l
Prints out line and local variable tables.
-b
Ensures backward compatibility with javap in JDK 1.1.
-public
Shows only public classes and members.
-protected
Shows only protected and public classes and members.
-package
Shows only package, protected, and public classes and members. This is the default.
-private
Shows all classes and members.
-Jflag
Pass flag directly to the runtime system. Some examples:
javap -J-version
javap -J-Djava.security.manager -J-Djava.security.policy=MyPolicy MyClassName
-s
Prints internal type signatures.
-c
Prints out disassembled code, i.e., the instructions that comprise the Java bytecodes, for each of the methods in the class. These are documented in the Java Virtual Machine Specification.
-verbose
Prints stack size, number of locals and args for methods.
-classpath path
Specifies the path javap uses to look up classes. Overrides the default or the CLASSPATH environment variable if it is set. Directories are separated by colons. Thus the general format for path is:
   .:<your_path>
For example:
.:/home/avh/classes:/usr/local/java/classes
-bootclasspath path
Specifies path from which to load bootstrap classes. By default, the bootstrap classes are the classes implementing the core Java platform located in jre/lib/rt.jar and several other jar files.
-extdirs dirs
Overrides location at which installed extensions are searched for. The default location for extensions is the value of java.ext.dirs.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by colons, for example, For example:
.:/home/avh/classes:/usr/local/java/classes

SEE ALSO

javac, java, jdb, javah, javadoc

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jdb - The Java Debugger

jdb helps you find and fix bugs in Java language programs.

SYNOPSIS

jdb [ options ] [ class ] [ arguments ]
options
Command-line options, as specified below.
class
Name of the class to begin debugging.
arguments
Arguments passed to the main() method of class.

DESCRIPTION

The Java Debugger, jdb, is a simple command-line debugger for Java classes. It is a demonstration of the Java Platform Debugger Architecture that provides inspection and debugging of a local or remote Java Virtual Machine.

Starting a jdb Session

There are many ways to start a jdb session. The most frequently used way is to have jdb launch a new Java Virtual Machine (VM) with the main class of the application to be debugged. This is done by substituting the command jdb for java in the command line. For example, if your application's main class is MyClass, you use the following command to debug it under JDB:

 % jdb MyClass

When started this way, jdb invokes a second Java VM with any specified parameters, loads the specified class, and stops the VM before executing that class's first instruction.

Another way to use jdb is by attaching it to a Java VM that is already running. Syntax for Starting a VM to which jdb will attach when the VM is running is as follows. This loads in-process debugging libraries and specifies the kind of connection to be made.

-agentlib:jdwp=transport=dt_socket,server=y,suspend=n

For example, the following command will run the MyClass application, and allow jdb to connect to it at a later time.

 % java -agentlib:jdwp=transport=dt_socket,address=8000,server=y,suspend=n MyClass

You can then attach jdb to the VM with the following commmand:

 % jdb -attach 8000

Note that "MyClass" is not specified in the jdb command line in this case because jdb is connecting to an existing VM instead of launching a new one.

There are many other ways to connect the debugger to a VM, and all of them are supported by jdb. The Java Platform Debugger Architecture has additional documentation on these connection options. For information on starting a J2SE 1.4.2 or early VM for use with jdb see 1.4.2 documentation

Basic jdb Commands

The following is a list of the basic jdb commands. The Java debugger supports other commands which you can list using jdb's help command.

help, or ?
The most important jdb command, help displays the list of recognized commands with a brief description.
run
After starting jdb, and setting any necessary breakpoints, you can use this command to start the execution the debugged application. This command is available only when jdb launches the debugged application (as opposed to attaching to an existing VM).
cont
Continues execution of the debugged application after a breakpoint, exception, or step.
print
Displays Java objects and primitive values. For variables or fields of primitive types, the actual value is printed. For objects, a short description is printed. See the dump command below for getting more information about an object.

NOTE: To display local variables, the containing class must have been compiled with the javac -g option.

print supports many simple Java expressions including those with method invocations, for example:

  • print MyClass.myStaticField
  • print myObj.myInstanceField
  • print i + j + k (i, j, k are primities and either fields or local variables)
  • print myObj.myMethod() (if myMethod returns a non-null)
  • print new java.lang.String("Hello").length()
dump
For primitive values, this command is identical to print. For objects, it prints the current value of each field defined in the object. Static and instance fields are included.

The dump command supports the same set of expressions as the print command.

threads
List the threads that are currently running. For each thread, its name and current status are printed, as well as an index that can be used for other commands, for example:
4. (java.lang.Thread)0x1 main      running
In this example, the thread index is 4, the thread is an instance of java.lang.Thread, the thread name is "main", and it is currently running,
thread
Select a thread to be the current thread. Many jdb commands are based on the setting of the current thread. The thread is specified with the thread index described in the threads command above.
where
where with no arguments dumps the stack of the current thread. where all dumps the stack of all threads in the current thread group. where threadindex dumps the stack of the specified thread.

If the current thread is suspended (either through an event such as a breakpoint or through the suspend command), local variables and fields can be displayed with the print and dump commands. The up and down commands select which stack frame is current.

Breakpoints

Breakpoints can be set in jdb at line numbers or at the first instruction of a method, for example:

  • stop at MyClass:22 (sets a breakpoint at the first instruction for line 22 of the source file containing MyClass)
  • stop in java.lang.String.length (sets a breakpoint at the beginnig of the method java.lang.String.length)
  • stop in MyClass.<init> (<init> identifies the MyClass constructor)
  • stop in MyClass.<clinit> (<clinit> identifies the static initialization code for MyClass)

If a method is overloaded, you must also specify its argument types so that the proper method can be selected for a breakpoint. For example, "MyClass.myMethod(int,java.lang.String)", or "MyClass.myMethod()".

The clear command removes breakpoints using a syntax as in "clear MyClass:45". Using the clear or command with no argument displays a list of all breakpoints currently set. The cont command continues execution.

Stepping

The step commands advances execution to the next line whether it is in the current stack frame or a called method. The next command advances execution to the next line in the current stack frame.

Exceptions

When an exception occurs for which there isn't a catch statement anywhere in the throwing thread's call stack, the VM normally prints an exception trace and exits. When running under jdb, however, control returns to jdb at the offending throw. You can then use jdb to diagnose the cause of the exception.

Use the catch command to cause the debugged application to stop at other thrown exceptions, for example: "catch java.io.FileNotFoundException" or "catch mypackage.BigTroubleException. Any exception which is an instance of the specifield class (or of a subclass) will stop the application at the point where it is thrown.

The ignore command negates the effect of a previous catch command.

NOTE: The ignore command does not cause the debugged VM to ignore specific exceptions, only the debugger.

Command Line Options

When you use jdb in place of the Java application launcher on the command line, jdb accepts many of the same options as the java command, including -D, -classpath, and -X<option>.

The following additional options are accepted by jdb:

-help
Displays a help message.
-sourcepath <dir1:dir2:...>
Uses the given path in searching for source files in the specified path. If this option is not specified, the default path of "." is used.
-attach <address>
Attaches the debugger to previously running VM using the default connection mechanism.
-listen <address>
Waits for a running VM to connect at the specified address using standard connector.
-listenany
Waits for a running VM to connect at any available address using standard connector.
-launch
Launches the debugged application immediately upon startup of jdb. This option removes the need for using the run command. The debuged application is launched and then stopped just before the initial application class is loaded. At that point you can set any necessary breakpoints and use the cont to continue execution.
-listconnectors
List the connectors available in this VM
-connect <connector-name>:<name1>=<value1>,...
Connects to target VM using named connector with listed argument values.
-dbgtrace [flags]
Prints info for debugging jdb.
-tclient
Runs the application in the Java HotSpot(tm) VM (Client).
-tserver
Runs the application in the Java HotSpot(tm) VM (Server).
-J option
Pass option to the Java virtual machine used to run jdb. (Options for the application Java virtual machine are passed to the run command.) For example, -J-Xms48m sets the startup memory to 48 megabytes.

Other options are supported for alternate mechanisms for connecting the debugger and the VM it is to debug. The Java Platform Debugger Architecture has additional documentation on these connection alternatives.

Options Forwarded to Debuggee Process

-v -verbose[:class|gc|jni]
Turns on verbose mode.
-D<name>=<value>
Sets a system property.
-classpath <directories separated by ":">
Lists directories in which to look for classes.
-X<option>
Non-standard target VM option

SEE ALSO

javac, java, javah, javap, javadoc.

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


JDK File Structure

JDK and JRE File Structure

 JDK Tools

This page provides an introductory overview of the JDK directories and the files they contain. Note that the file structure of the JRE is identical to that of the JDK's jre directory.

Development Files and Directories

This section describes the most important files and directories required to develop applications for the Java platform.

(Note that some of the directories that are not required include demos, Java source code, and C header files. These are mentioned in the Additional Files and Directories section.)

          jdk1.6.0
   ___________|_________________
  |           |                 |
 bin         lib               jre
  |           |         ________|__________
java*     tools.jar    |                   |
javac*    dt.jar      bin                 lib
javap*                 |       ________ ___|___ _________ ________ _______
javah*               java*    |        |       |         |        |       |
javadoc*                    rt.jar    ext   security   sparc    applet  fonts
                        charsets.jar   |              /     \
                                  localedata.jar  server  client

Assuming the JDK software is installed at /jdk1.6.0, here are some of the most important directories:

/jdk1.6.0
Root directory of the JDK software installation. Contains copyright, license, and README files. Also contains src.zip, the archive of source code for the Java platform.
/jdk1.6.0/bin
Executables for all the development tools contained in the JDK. The PATH environment variable should contain an entry for this directory. For more information on the tools, see JDK Tools.
/jdk1.6.0/lib
Files used by the development tools. Includes tools.jar, which contains non-core classes for support of the tools and utilities in the JDK. Also includes dt.jar, the DesignTime archive of BeanInfo files that tell interactive development environments (IDE's) how to display the Java components and how to let the developer customize them for an application.
/jdk1.6.0/jre
Root directory of the Java runtime environment used by the JDK development tools. The runtime environment is an implementation of the Java platform. This is the directory referred to by the java.home system property.
/jdk1.6.0/jre/bin
Executable files for tools and libraries used by the Java platform. The executable files are identical to files in /jdk1.6.0/bin. The java launcher tool serves as an application launcher (and replaced the old jre tool that shipped with 1.1 versions of the JDK). This directory does not need to be in the PATH environment variable.
/jdk1.6.0/jre/lib
Code libraries, property settings, and resource files used by the Java runtime environment. For example:
  • rt.jar -- the bootstrap classes (the RunTime classes that comprise the Java platform's core API).
  • charsets.jar -- character-conversion classes.
Aside from the ext subdirectory (described below) there are several additional resource subdirectories not described here.
/jdk1.6.0/jre/lib/ext
Default installation directory for Extensions to the Java platform. This is where the JavaHelp jar file goes when it is installed, for example.
  • localedata.jar -- locale data for java.text and java.util.
/jdk1.6.0/jre/lib/security
Contains files used for security management. These include the security policy (java.policy) and security properties (java.security) files.
/jdk1.6.0/jre/lib/sparc
Contains the .so (shared object) files used by the Solaris version of the Java platform.
/jdk1.6.0/jre/lib/sparc/client
Contains the .so file used by the Java HotSpotTM Client Virtual Machine, which is implemented with Java HotSpotTM technology. This is the default VM.
/jdk1.6.0/jre/lib/sparc/server
Contains the .so file used by the Java HotSpotTM Server Virtual Machine.
/jdk1.6.0/jre/lib/applet
Jar files containing support classes for applets can be placed in the lib/applet/ directory. This reduces startup time for large applets by allowing applet classes to be pre-loaded from the local file system by the applet class loader, providing the same protections as if they had been downloaded over the net.
/jdk1.6.0/jre/lib/fonts
Font files for use by platform.

Additional Files and Directories

This section describes the directory structure for the demos, Java source code, and C header files.

                        jdk1.6.0
                 ___________|__________ _________
                |           |          |         |
              demo       include    src.zip     man
             ___|___ _________ __________ ________
            |       |         |          |        |
          applets  jfc       jpda     plugin     jni

The additional files and directories shown above are:

/jdk1.6.0/src.zip
Archive containing source code for the Java platform.
/jdk1.6.0/demo
Examples, with source code, that show you how to program for the Java platform.
/jdk1.6.0/demo/applets
Applets that can be used on a web page.
/jdk1.6.0/demo/jfc
Examples that use Java 2DTM and JFC/Swing components.
/jdk1.6.0/demo/jpda
Examples of using the Java Platform Debugging Architecture. Includes source code for the javadt and jdb utilities.
/jdk1.6.0/demo/plugin
Demos for use with the Java Plug-in product.
/jdk1.6.0/demo/jni
Example classes and C code that demonstrate access to poll(2) functionality from the Java platform.
/jdk1.6.0/include
C-language header files that support native-code programming using the Java Native Interface and the Java Virtual Machine Debugger Interface.
/jdk1.6.0/man
Contains man pages for the JDK tools.

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


keytool - Key and Certificate Management Tool

Manages a keystore (database) of cryptographic keys, X.509 certificate chains, and trusted certificates.

SYNOPSIS

keytool [ commands ]

The keytool command interface has changed in Java SE 6. See the Changes Section for a detailed description. Note that previously defined commands are still supported.

DESCRIPTION

keytool is a key and certificate management utility. It allows users to administer their own public/private key pairs and associated certificates for use in self-authentication (where the user authenticates himself/herself to other users/services) or data integrity and authentication services, using digital signatures. It also allows users to cache the public keys (in the form of certificates) of their communicating peers.

A certificate is a digitally signed statement from one entity (person, company, etc.), saying that the public key (and some other information) of some other entity has a particular value. (See Certificates.) When data is digitally signed, the signature can be verified to check the data integrity and authenticity. Integrity means that the data has not been modified or tampered with, and authenticity means the data indeed comes from whoever claims to have created and signed it.

keytool also enables users to administer secret keys used in symmetric encryption/decryption (e.g. DES).

keytool stores the keys and certificates in a keystore.

COMMAND AND OPTION NOTES

The various commands and their options are listed and described below . Note:

  • All command and option names are preceded by a minus sign (-).

  • The options for each command may be provided in any order.

  • All items not italicized or in braces or square brackets are required to appear as is.

  • Braces surrounding an option generally signify that a default value will be used if the option is not specified on the command line. Braces are also used around the -v, -rfc, and -J options, which only have meaning if they appear on the command line (that is, they don't have any "default" values other than not existing).

  • Brackets surrounding an option signify that the user is prompted for the value(s) if the option is not specified on the command line. (For a -keypass option, if you do not specify the option on the command line, keytool will first attempt to use the keystore password to recover the private/secret key, and if this fails, will then prompt you for the private/secret key password.)

  • Items in italics (option values) represent the actual values that must be supplied. For example, here is the format of the -printcert command:
      keytool -printcert {-file cert_file} {-v}

    When specifying a -printcert command, replace cert_file with the actual file name, as in:

      keytool -printcert -file VScert.cer

  • Option values must be quoted if they contain a blank (space).

  • The -help command is the default. Thus, the command line
      keytool
    is equivalent to
      keytool -help

Option Defaults

Below are the defaults for various option values.
-alias "mykey"

-keyalg
    "DSA" (when using -genkeypair)
    "DES" (when using -genseckey)

-keysize
    1024 (when using -genkeypair)
    56 (when using -genseckey and -keyalg is "DES")
    168 (when using -genseckey and -keyalg is "DESede")

-validity 90

-keystore the file named .keystore in the user's home directory

-storetype the value of the "keystore.type" property in the security properties file,
           which is returned by the static getDefaultType method in java.security.KeyStore

-file stdin if reading, stdout if writing

-protected false
In generating a public/private key pair, the signature algorithm (-sigalg option) is derived from the algorithm of the underlying private key: If the underlying private key is of type "DSA", the -sigalg option defaults to "SHA1withDSA", and if the underlying private key is of type "RSA", -sigalg defaults to "MD5withRSA". Please consult the Java Cryptography Architecture API Specification & Reference for a full list of -keyalg and -sigalg you can choose from.

Common Options

The -v option can appear for all commands except -help. If it appears, it signifies "verbose" mode; more information will be output.

There is also a -Jjavaoption option that may appear for any command. If it appears, the specified javaoption string is passed through directly to the Java interpreter. This option should not contain any spaces. It is useful for adjusting the execution environment or memory usage. For a list of possible interpreter options, type java -h or java -X at the command line.

These options may appear for all commands operating on a keystore:

-storetype storetype
This qualifier specifies the type of keystore to be instantiated.

-keystore keystore
The keystore location.

If the JKS storetype is used and a keystore file does not yet exist, then certain keytool commands may result in a new keystore file being created. For example, if keytool -genkeypair is invoked and the -keystore option is not specified, the default keystore file named .keystore in the user's home directory will be created if it does not already exist. Similarly, if the -keystore ks_file option is specified but ks_file does not exist, then it will be created

Note that the input stream from the -keystore option is passed to the KeyStore.load method. If NONE is specified as the URL, then a null stream is passed to the KeyStore.load method. NONE should be specified if the KeyStore is not file-based (for example, if it resides on a hardware token device).

-storepass storepass
The password which is used to protect the integrity of the keystore.

storepass must be at least 6 characters long. It must be provided to all commands that access the keystore contents. For such commands, if a -storepass option is not provided at the command line, the user is prompted for it.

When retrieving information from the keystore, the password is optional; if no password is given, the integrity of the retrieved information cannot be checked and a warning is displayed.

-providerName provider_name
Used to identify a cryptographic service provider's name when listed in the security properties file.

-providerClass provider_class_name
Used to specify the name of cryptographic service provider's master class file when the service provider is not listed in the security properties file.

-providerArg provider_arg
Used in conjunction with -providerClass. Represents an optional string input argument for the constructor of provider_class_name.

-protected
Either true or false. This value should be specified as true if a password must be given via a protected authentication path such as a dedicated PIN reader.

COMMANDS

Creating or Adding Data to the Keystore

-genkeypair {-alias alias} {-keyalg keyalg} {-keysize keysize} {-sigalg sigalg} [-dname dname] [-keypass keypass] {-validity valDays} {-storetype storetype} {-keystore keystore} [-storepass storepass] {-providerClass provider_class_name {-providerArg provider_arg}} {-v} {-protected} {-Jjavaoption}

Generates a key pair (a public key and associated private key). Wraps the public key into an X.509 v3 self-signed certificate, which is stored as a single-element certificate chain. This certificate chain and the private key are stored in a new keystore entry identified by alias.

keyalg specifies the algorithm to be used to generate the key pair, and keysize specifies the size of each key to be generated. sigalg specifies the algorithm that should be used to sign the self-signed certificate; this algorithm must be compatible with keyalg.

dname specifies the X.500 Distinguished Name to be associated with alias, and is used as the issuer and subject fields in the self-signed certificate. If no distinguished name is provided at the command line, the user will be prompted for one.

keypass is a password used to protect the private key of the generated key pair. If no password is provided, the user is prompted for it. If you press RETURN at the prompt, the key password is set to the same password as that used for the keystore. keypass must be at least 6 characters long.

valDays tells the number of days for which the certificate should be considered valid.

This command was named -genkey in previous releases. This old name is still supported in this release and will be supported in future releases, but for clarify the new name, -genkeypair, is preferred going forward.

-genseckey
  {-alias alias}
  {-keyalg keyalg}
  {-keysize keysize}
  [-keypass keypass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Generates a secret key and stores it in a new KeyStore.SecretKeyEntry identified by alias.

keyalg specifies the algorithm to be used to generate the secret key, and keysize specifies the size of the key to be generated. keypass is a password used to protect the secret key. If no password is provided, the user is prompted for it. If you press RETURN at the prompt, the key password is set to the same password as that used for the keystore. keypass must be at least 6 characters long.

-importcert
  {-alias alias}
  {-file cert_file} [-keypass keypass]
  {-noprompt} {-trustcacerts}
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Reads the certificate or certificate chain (where the latter is supplied in a PKCS#7 formatted reply) from the file cert_file, and stores it in the keystore entry identified by alias. If no file is given, the certificate or PKCS#7 reply is read from stdin.

keytool can import X.509 v1, v2, and v3 certificates, and PKCS#7 formatted certificate chains consisting of certificates of that type. The data to be imported must be provided either in binary encoding format, or in printable encoding format (also known as Base64 encoding) as defined by the Internet RFC 1421 standard. In the latter case, the encoding must be bounded at the beginning by a string that starts with "-----BEGIN", and bounded at the end by a string that starts with "-----END".

You import a certificate for two reasons:

  1. to add it to the list of trusted certificates, or

  2. to import a certificate reply received from a CA as the result of submitting a Certificate Signing Request (see the -certreq command) to that CA.

Which type of import is intended is indicated by the value of the -alias option:

  1. If the alias does not point to a key entry, then keytool assumes you are adding a trusted certificate entry. In this case, the alias should not already exist in the keystore. If the alias does already exist, then keytool outputs an error, since there is already a trusted certificate for that alias, and does not import the certificate.

  2. If the alias points to a key entry, then keytool assumes you are importing a certificate reply.

Importing a New Trusted Certificate

Before adding the certificate to the keystore, keytool tries to verify it by attempting to construct a chain of trust from that certificate to a self-signed certificate (belonging to a root CA), using trusted certificates that are already available in the keystore.

If the -trustcacerts option has been specified, additional certificates are considered for the chain of trust, namely the certificates in a file named "cacerts".

If keytool fails to establish a trust path from the certificate to be imported up to a self-signed certificate (either from the keystore or the "cacerts" file), the certificate information is printed out, and the user is prompted to verify it, e.g., by comparing the displayed certificate fingerprints with the fingerprints obtained from some other (trusted) source of information, which might be the certificate owner himself/herself. Be very careful to ensure the certificate is valid prior to importing it as a "trusted" certificate! -- see WARNING Regarding Importing Trusted Certificates. The user then has the option of aborting the import operation. If the -noprompt option is given, however, there will be no interaction with the user.

Importing a Certificate Reply

When importing a certificate reply, the certificate reply is validated using trusted certificates from the keystore, and optionally using the certificates configured in the "cacerts" keystore file (if the -trustcacerts option was specified).

The methods of determining whether the certificate reply is trusted are described in the following:

  • If the reply is a single X.509 certificate, keytool attempts to establish a trust chain, starting at the certificate reply and ending at a self-signed certificate (belonging to a root CA). The certificate reply and the hierarchy of certificates used to authenticate the certificate reply form the new certificate chain of alias. If a trust chain cannot be established, the certificate reply is not imported. In this case, keytool does not print out the certificate and prompt the user to verify it, because it is very hard (if not impossible) for a user to determine the authenticity of the certificate reply.

  • If the reply is a PKCS#7 formatted certificate chain, the chain is first ordered (with the user certificate first and the self-signed root CA certificate last), before keytool attempts to match the root CA certificate provided in the reply with any of the trusted certificates in the keystore or the "cacerts" keystore file (if the -trustcacerts option was specified). If no match can be found, the information of the root CA certificate is printed out, and the user is prompted to verify it, e.g., by comparing the displayed certificate fingerprints with the fingerprints obtained from some other (trusted) source of information, which might be the root CA itself. The user then has the option of aborting the import operation. If the -noprompt option is given, however, there will be no interaction with the user.

If the public key in the certificate reply matches the user's public key already stored with under alias, the old certificate chain is replaced with the new certificate chain in the reply. The old chain can only be replaced if a valid keypass, the password used to protect the private key of the entry, is supplied. If no password is provided, and the private key password is different from the keystore password, the user is prompted for it.

This command was named -import in previous releases. This old name is still supported in this release and will be supported in future releases, but for clarify the new name, -importcert, is preferred going forward.

-importkeystore
  -srckeystore srckeystore -destkeystore destkeystore
  {-srcstoretype srcstoretype} {-deststoretype deststoretype}
  [-srcstorepass srcstorepass] [-deststorepass deststorepass]
  {-srcprotected} {-destprotected}
  {-srcalias srcalias
    {-destalias destalias}
    [-srckeypass srckeypass]
    [-destkeypass destkeypass]
  }
  {-noprompt}
  {-srcProviderName src_provider_name}
  {-destProviderName dest_provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Imports a single entry or all entries from a source keystore to a destination keystore.

When the srcalias option is provided, the command imports the single entry identified by the alias to the destination keystore. If a destination alias is not provided with destalias, then srcalias is used as the destination alias. If the source entry is protected by a password, srckeypass will be used to recover the entry. If srckeypass is not provided, then keytool will attempt to use srcstorepass to recover the entry. If srcstorepass is either not provided or is incorrect, the user will be prompted for a password. The destination entry will be protected using destkeypass. If destkeypass is not provided, the destination entry will be protected with the source entry password.

If the srcalias option is not provided, then all entries in the source keystore are imported into the destination keystore. Each destination entry will be stored under the alias from the source entry. If the source entry is protected by a password, srcstorepass will be used to recover the entry. If srcstorepass is either not provided or is incorrect, the user will be prompted for a password. If a source keystore entry type is not supported in the destination keystore, or if an error occurs while storing an entry into the destination keystore, the user will be prompted whether to skip the entry and continue, or to quit. The destination entry will be protected with the source entry password.

If the destination alias already exists in the destination keystore, the user is prompted to either overwrite the entry, or to create a new entry under a different alias name.

Note that if -noprompt is provided, the user will not be prompted for a new destination alias. Existing entries will automatically be overwritten with the destination alias name. Finally, entries that can not be imported are automatically skipped and a warning is output.

Exporting Data

-certreq {-alias alias}
  {-sigalg sigalg} {-file certreq_file}
  [-keypass keypass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Generates a Certificate Signing Request (CSR), using the PKCS#10 format.

A CSR is intended to be sent to a certificate authority (CA). The CA will authenticate the certificate requestor (usually off-line) and will return a certificate or certificate chain, used to replace the existing certificate chain (which initially consists of a self-signed certificate) in the keystore.

The private key and X.500 Distinguished Name associated with alias are used to create the PKCS#10 certificate request. In order to access the private key, the appropriate password must be provided, since private keys are protected in the keystore with a password. If keypass is not provided at the command line, and is different from the password used to protect the integrity of the keystore, the user is prompted for it.

sigalg specifies the algorithm that should be used to sign the CSR.

The CSR is stored in the file certreq_file. If no file is given, the CSR is output to stdout.

Use the importcert command to import the response from the CA.

-exportcert
  {-alias alias}
  {-file cert_file}
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-rfc} {-v} {-protected} {-Jjavaoption}

Reads (from the keystore) the certificate associated with alias, and stores it in the file cert_file.

If no file is given, the certificate is output to stdout.

The certificate is by default output in binary encoding, but will instead be output in the printable encoding format, as defined by the Internet RFC 1421 standard, if the -rfc option is specified.

If alias refers to a trusted certificate, that certificate is output. Otherwise, alias refers to a key entry with an associated certificate chain. In that case, the first certificate in the chain is returned. This certificate authenticates the public key of the entity addressed by alias.

This command was named -export in previous releases. This old name is still supported in this release and will be supported in future releases, but for clarify the new name, -exportcert, is preferred going forward.

Displaying Data

-list  {-alias alias}
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v | -rfc} {-protected} {-Jjavaoption}

Prints (to stdout) the contents of the keystore entry identified by alias. If no alias is specified, the contents of the entire keystore are printed.

This command by default prints the MD5 fingerprint of a certificate. If the -v option is specified, the certificate is printed in human-readable format, with additional information such as the owner, issuer, serial number, and any extensions. If the -rfc option is specified, certificate contents are printed using the printable encoding format, as defined by the Internet RFC 1421 standard

You cannot specify both -v and -rfc.

-printcert {-file cert_file} {-v} {-Jjavaoption}

Reads the certificate from the file cert_file, and prints its contents in a human-readable format. If no file is given, the certificate is read from stdin.

The certificate may be either binary encoded or in printable encoding format, as defined by the Internet RFC 1421 standard.

Note: This option can be used independently of a keystore.

Managing the Keystore

-storepasswd [-new new_storepass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-Jjavaoption}

Changes the password used to protect the integrity of the keystore contents. The new password is new_storepass, which must be at least 6 characters long.

-keypasswd {-alias alias}
  [-keypass old_keypass] [-new new_keypass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-Jjavaoption}

Changes the password under which the private/secret key identified by alias is protected, from old_keypass to new_keypass, which must be at least 6 characters long.

If the -keypass option is not provided at the command line, and the key password is different from the keystore password, the user is prompted for it.

If the -new option is not provided at the command line, the user is prompted for it.

-delete
  [-alias alias]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Deletes from the keystore the entry identified by alias. The user is prompted for the alias, if no alias is provided at the command line.

-changealias
  {-alias alias} [-destalias destalias]
  [-keypass keypass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Move an existing keystore entry from the specified alias to a new alias, destalias. If no destination alias is provided, the command will prompt for one. If the original entry is protected with an entry password, the password can be supplied via the "-keypass" option. If no key password is provided, the storepass (if given) will be attempted first. If that attempt fails, the user will be prompted for a password.

Getting Help

-help

Lists the basic commands and their options.

EXAMPLES

Suppose you want to create a keystore for managing your public/private key pair and certificates from entities you trust.

Generating Your Key Pair

The first thing you need to do is create a keystore and generate the key pair. You could use a command such as the following:

    keytool -genkeypair -dname "cn=Mark Jones, ou=JavaSoft, o=Sun, c=US"
      -alias business -keypass kpi135 -keystore /working/mykeystore
      -storepass ab987c -validity 180

(Please note: This must be typed as a single line. Multiple lines are used in the examples just for legibility purposes.)

This command creates the keystore named "mykeystore" in the "working" directory (assuming it doesn't already exist), and assigns it the password "ab987c". It generates a public/private key pair for the entity whose "distinguished name" has a common name of "Mark Jones", organizational unit of "JavaSoft", organization of "Sun" and two-letter country code of "US". It uses the default "DSA" key generation algorithm to create the keys, both 1024 bits long.

It creates a self-signed certificate (using the default "SHA1withDSA" signature algorithm) that includes the public key and the distinguished name information. This certificate will be valid for 180 days, and is associated with the private key in a keystore entry referred to by the alias "business". The private key is assigned the password "kpi135".

The command could be significantly shorter if option defaults were accepted. As a matter of fact, no options are required; defaults are used for unspecified options that have default values, and you are prompted for any required values. Thus, you could simply have the following:

    keytool -genkeypair
In this case, a keystore entry with alias "mykey" is created, with a newly-generated key pair and a certificate that is valid for 90 days. This entry is placed in the keystore named ".keystore" in your home directory. (The keystore is created if it doesn't already exist.) You will be prompted for the distinguished name information, the keystore password, and the private key password.

The rest of the examples assume you executed the -genkeypair command without options specified, and that you responded to the prompts with values equal to those given in the first -genkeypair command, above (a private key password of "kpi135", etc.)

Requesting a Signed Certificate from a Certification Authority

So far all we've got is a self-signed certificate. A certificate is more likely to be trusted by others if it is signed by a Certification Authority (CA). To get such a signature, you first generate a Certificate Signing Request (CSR), via the following:

    keytool -certreq -file MarkJ.csr
This creates a CSR (for the entity identified by the default alias "mykey") and puts the request in the file named "MarkJ.csr". Submit this file to a CA, such as VeriSign, Inc. The CA will authenticate you, the requestor (usually off-line), and then will return a certificate, signed by them, authenticating your public key. (In some cases, they will actually return a chain of certificates, each one authenticating the public key of the signer of the previous certificate in the chain.)

Importing a Certificate for the CA

You need to replace your self-signed certificate with a certificate chain, where each certificate in the chain authenticates the public key of the signer of the previous certificate in the chain, up to a "root" CA.

Before you import the certificate reply from a CA, you need one or more "trusted certificates" in your keystore or in the cacerts keystore file (which is described in importcert command):

  • If the certificate reply is a certificate chain, you just need the top certificate of the chain (that is, the "root" CA certificate authenticating that CA's public key).

  • If the certificate reply is a single certificate, you need a certificate for the issuing CA (the one that signed it), and if that certificate is not self-signed, you need a certificate for its signer, and so on, up to a self-signed "root" CA certificate.

The "cacerts" keystore file ships with five VeriSign root CA certificates, so you probably won't need to import a VeriSign certificate as a trusted certificate in your keystore. But if you request a signed certificate from a different CA, and a certificate authenticating that CA's public key hasn't been added to "cacerts", you will need to import a certificate from the CA as a "trusted certificate".

A certificate from a CA is usually either self-signed, or signed by another CA (in which case you also need a certificate authenticating that CA's public key). Suppose company ABC, Inc., is a CA, and you obtain a file named "ABCCA.cer" that is purportedly a self-signed certificate from ABC, authenticating that CA's public key.

Be very careful to ensure the certificate is valid prior to importing it as a "trusted" certificate! View it first (using the keytool -printcert command, or the keytool -importcert command without the -noprompt option), and make sure that the displayed certificate fingerprint(s) match the expected ones. You can call the person who sent the certificate, and compare the fingerprint(s) that you see with the ones that they show (or that a secure public key repository shows). Only if the fingerprints are equal is it guaranteed that the certificate has not been replaced in transit with somebody else's (for example, an attacker's) certificate. If such an attack took place, and you did not check the certificate before you imported it, you would end up trusting anything the attacker has signed.

If you trust that the certificate is valid, then you can add it to your keystore via the following:

    keytool -importcert -alias abc -file ABCCA.cer
This creates a "trusted certificate" entry in the keystore, with the data from the file "ABCCA.cer", and assigns the alias "abc" to the entry.

Importing the Certificate Reply from the CA

Once you've imported a certificate authenticating the public key of the CA you submitted your certificate signing request to (or there's already such a certificate in the "cacerts" file), you can import the certificate reply and thereby replace your self-signed certificate with a certificate chain. This chain is the one returned by the CA in response to your request (if the CA reply is a chain), or one constructed (if the CA reply is a single certificate) using the certificate reply and trusted certificates that are already available in the keystore where you import the reply or in the "cacerts" keystore file.

For example, suppose you sent your certificate signing request to VeriSign. You can then import the reply via the following, which assumes the returned certificate is named "VSMarkJ.cer":

    keytool -importcert -trustcacerts -file VSMarkJ.cer

Exporting a Certificate Authenticating Your Public Key

Suppose you have used the jarsigner tool to sign a Java ARchive (JAR) file. Clients that want to use the file will want to authenticate your signature.

One way they can do this is by first importing your public key certificate into their keystore as a "trusted" entry. You can export the certificate and supply it to your clients. As an example, you can copy your certificate to a file named MJ.cer via the following, assuming the entry is aliased by "mykey":

    keytool -exportcert -alias mykey -file MJ.cer
Given that certificate, and the signed JAR file, a client can use the jarsigner tool to authenticate your signature.

Importing Keystore

The command "importkeystore" is used to import an entire keystore into another keystore, which means all entries from the source keystore, including keys and certificates, are all imported to the destination keystore within a single command. You can use this command to import entries from a different type of keystore. During the import, all new entries in the destination keystore will have the same alias names and protection passwords (for secret keys and private keys). If keytool has difficulties recover the private keys or secret keys from the source keystore, it will prompt you for a password. If it detects alias duplication, it will ask you for a new one, you can specify a new alias or simply allow keytool to overwrite the existing one.

For example, to import entries from a normal JKS type keystore key.jks into a PKCS #11 type hardware based keystore, you can use the command:

keytool -importkeystore
    -srckeystore key.jks -destkeystore NONE
    -srcstoretype JKS -deststoretype PKCS11
    -srcstorepass changeit -deststorepass topsecret

The importkeystore command can also be used to import a single entry from a source keystore to a destination keystore. In this case, besides the options you see in the above example, you need to specify the alias you want to import. With the srcalias option given, you can also specify the desination alias name in the command line, as well as protection password for a secret/private key and the destination protection password you want. In this way, you can issue a keytool command that will never ask you a question. This makes it very convenient to include a keytool command into a script file, like this:

keytool -importkeystore
    -srckeystore key.jks -destkeystore NONE
    -srcstoretype JKS -deststoretype PKCS11
    -srcstorepass changeit -deststorepass topsecret
    -srcalias myprivatekey -destalias myoldprivatekey
    -srckeypass oldkeypass -destkeypass mynewkeypass
    -noprompt

TERMINOLOGY and WARNINGS

KeyStore

A keystore is a storage facility for cryptographic keys and certificates.

  • KeyStore Entries

    Keystores may have different types of entries. The two most applicable entry types for keytool include:
    1. key entries - each holds very sensitive cryptographic key information, which is stored in a protected format to prevent unauthorized access. Typically, a key stored in this type of entry is a secret key, or a private key accompanied by the certificate "chain" for the corresponding public key. The keytool can handle both types od entry, while jarsigner tool only handle the latter type of entry, that is private keys and their associated certificate chains.

    2. trusted certificate entries - each contains a single public key certificate belonging to another party. It is called a "trusted certificate" because the keystore owner trusts that the public key in the certificate indeed belongs to the identity identified by the "subject" (owner) of the certificate. The issuer of the certificate vouches for this, by signing the certificate.

  • KeyStore Aliases

    All keystore entries (key and trusted certificate entries) are accessed via unique aliases.

    An alias is specified when you add an entity to the keystore using the -genseckey command to generate a secret key, -genkeypair command to generate a key pair (public and private key) or the -importcert command to add a certificate or certificate chain to the list of trusted certificates. Subsequent keytool commands must use this same alias to refer to the entity.

    For example, suppose you use the alias duke to generate a new public/private key pair and wrap the public key into a self-signed certificate (see Certificate Chains) via the following command:

        keytool -genkeypair -alias duke -keypass dukekeypasswd
    This specifies an inital password of "dukekeypasswd" required by subsequent commands to access the private key assocated with the alias duke. If you later want to change duke's private key password, you use a command like the following:
        keytool -keypasswd -alias duke -keypass dukekeypasswd -new newpass
    This changes the password from "dukekeypasswd" to "newpass".

    Please note: A password should not actually be specified on a command line or in a script unless it is for testing purposes, or you are on a secure system. If you don't specify a required password option on a command line, you will be prompted for it.

  • KeyStore Implementation

    The KeyStore class provided in the java.security package supplies well-defined interfaces to access and modify the information in a keystore. It is possible for there to be multiple different concrete implementations, where each implementation is that for a particular type of keystore.

    Currently, two command-line tools (keytool and jarsigner) and a GUI-based tool named Policy Tool make use of keystore implementations. Since KeyStore is publicly available, users can write additional security applications that use it.

    There is a built-in default implementation, provided by Sun Microsystems. It implements the keystore as a file, utilizing a proprietary keystore type (format) named "JKS". It protects each private key with its individual password, and also protects the integrity of the entire keystore with a (possibly different) password.

    Keystore implementations are provider-based. More specifically, the application interfaces supplied by KeyStore are implemented in terms of a "Service Provider Interface" (SPI). That is, there is a corresponding abstract KeystoreSpi class, also in the java.security package, which defines the Service Provider Interface methods that "providers" must implement. (The term "provider" refers to a package or a set of packages that supply a concrete implementation of a subset of services that can be accessed by the Java Security API.) Thus, to provide a keystore implementation, clients must implement a "provider" and supply a KeystoreSpi subclass implementation, as described in How to Implement a Provider for the Java Cryptography Architecture.

    Applications can choose different types of keystore implementations from different providers, using the "getInstance" factory method supplied in the KeyStore class. A keystore type defines the storage and data format of the keystore information, and the algorithms used to protect private/secret keys in the keystore and the integrity of the keystore itself. Keystore implementations of different types are not compatible.

    keytool works on any file-based keystore implementation. (It treats the keytore location that is passed to it at the command line as a filename and converts it to a FileInputStream, from which it loads the keystore information.) The jarsigner and policytool tools, on the other hand, can read a keystore from any location that can be specified using a URL.

    For keytool and jarsigner, you can specify a keystore type at the command line, via the -storetype option. For Policy Tool, you can specify a keystore type via the "Keystore" menu.

    If you don't explicitly specify a keystore type, the tools choose a keystore implementation based simply on the value of the keystore.type property specified in the security properties file. The security properties file is called java.security, and it resides in the security properties directory, java.home/lib/security, where java.home is the runtime environment's directory (the jre directory in the SDK or the top-level directory of the Java 2 Runtime Environment).

    Each tool gets the keystore.type value and then examines all the currently-installed providers until it finds one that implements keystores of that type. It then uses the keystore implementation from that provider.

    The KeyStore class defines a static method named getDefaultType that lets applications and applets retrieve the value of the keystore.type property. The following line of code creates an instance of the default keystore type (as specified in the keystore.type property):

        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());

    The default keystore type is "jks" (the proprietary type of the keystore implementation provided by Sun). This is specified by the following line in the security properties file:

        keystore.type=jks

    To have the tools utilize a keystore implementation other than the default, you can change that line to specify a different keystore type.

    For example, if you have a provider package that supplies a keystore implementation for a keystore type called "pkcs12", change the line to

        keystore.type=pkcs12
    Note: case doesn't matter in keystore type designations. For example, "JKS" would be considered the same as "jks".

Certificate

A certificate (also known as a public-key certificate) is a digitally signed statement from one entity (the issuer), saying that the public key (and some other information) of another entity (the subject) has some specific value.

  • Certificate Terms

    Public Keys
    These are numbers associated with a particular entity, and are intended to be known to everyone who needs to have trusted interactions with that entity. Public keys are used to verify signatures.
    Digitally Signed
    If some data is digitally signed it has been stored with the "identity" of an entity, and a signature that proves that entity knows about the data. The data is rendered unforgeable by signing with the entity's private key.
    Identity
    A known way of addressing an entity. In some systems the identity is the public key, in others it can be anything from a Unix UID to an Email address to an X.509 Distinguished Name.
    Signature
    A signature is computed over some data using the private key of an entity (the signer, which in the case of a certificate is also known as the issuer).
    Private Keys
    These are numbers, each of which is supposed to be known only to the particular entity whose private key it is (that is, it's supposed to be kept secret). Private and public keys exist in pairs in all public key cryptography systems (also referred to as "public key crypto systems"). In a typical public key crypto system, such as DSA, a private key corresponds to exactly one public key. Private keys are used to compute signatures.
    Entity
    An entity is a person, organization, program, computer, business, bank, or something else you are trusting to some degree.

    Basically, public key cryptography requires access to users' public keys. In a large-scale networked environment it is impossible to guarantee that prior relationships between communicating entities have been established or that a trusted repository exists with all used public keys. Certificates were invented as a solution to this public key distribution problem. Now a Certification Authority (CA) can act as a trusted third party. CAs are entities (for example, businesses) that are trusted to sign (issue) certificates for other entities. It is assumed that CAs will only create valid and reliable certificates, as they are bound by legal agreements. There are many public Certification Authorities, such as VeriSign, Thawte, Entrust, and so on. You can also run your own Certification Authority using products such as the Netscape/Microsoft Certificate Servers or the Entrust CA product for your organization.

    Using keytool, it is possible to display, import, and export certificates. It is also possible to generate self-signed certificates.

    keytool currently handles X.509 certificates.

  • X.509 Certificates

    The X.509 standard defines what information can go into a certificate, and describes how to write it down (the data format). All the data in a certificate is encoded using two related standards called ASN.1/DER. Abstract Syntax Notation 1 describes data. The Definite Encoding Rules describe a single way to store and transfer that data.

    All X.509 certificates have the following data, in addition to the signature:

    Version
    This identifies which version of the X.509 standard applies to this certificate, which affects what information can be specified in it. Thus far, three versions are defined. keytool can import and export v1, v2, and v3 certificates. It generates v3 certificates.

    X.509 Version 1 has been available since 1988, is widely deployed, and is the most generic.

    X.509 Version 2 introduced the concept of subject and issuer unique identifiers to handle the possibility of reuse of subject and/or issuer names over time. Most certificate profile documents strongly recommend that names not be reused, and that certificates should not make use of unique identifiers. Version 2 certificates are not widely used.

    X.509 Version 3 is the most recent (1996) and supports the notion of extensions, whereby anyone can define an extension and include it in the certificate. Some common extensions in use today are: KeyUsage (limits the use of the keys to particular purposes such as "signing-only") and AlternativeNames (allows other identities to also be associated with this public key, e.g. DNS names, Email addresses, IP addresses). Extensions can be marked critical to indicate that the extension should be checked and enforced/used. For example, if a certificate has the KeyUsage extension marked critical and set to "keyCertSign" then if this certificate is presented during SSL communication, it should be rejected, as the certificate extension indicates that the associated private key should only be used for signing certificates and not for SSL use.

    Serial Number
    The entity that created the certificate is responsible for assigning it a serial number to distinguish it from other certificates it issues. This information is used in numerous ways, for example when a certificate is revoked its serial number is placed in a Certificate Revocation List (CRL).

    Signature Algorithm Identifier
    This identifies the algorithm used by the CA to sign the certificate.

    Issuer Name
    The X.500 Distinguished Name of the entity that signed the certificate. This is normally a CA. Using this certificate implies trusting the entity that signed this certificate. (Note that in some cases, such as root or top-level CA certificates, the issuer signs its own certificate.)

    Validity Period
    Each certificate is valid only for a limited amount of time. This period is described by a start date and time and an end date and time, and can be as short as a few seconds or almost as long as a century. The validity period chosen depends on a number of factors, such as the strength of the private key used to sign the certificate or the amount one is willing to pay for a certificate. This is the expected period that entities can rely on the public value, if the associated private key has not been compromised.

    Subject Name
    The name of the entity whose public key the certificate identifies. This name uses the X.500 standard, so it is intended to be unique across the Internet. This is the X.500 Distinguished Name (DN) of the entity, for example,
        CN=Java Duke, OU=Java Software Division, O=Sun Microsystems Inc, C=US
    (These refer to the subject's Common Name, Organizational Unit, Organization, and Country.)

    Subject Public Key Information
    This is the public key of the entity being named, together with an algorithm identifier which specifies which public key crypto system this key belongs to and any associated key parameters.

  • Certificate Chains

    keytool can create and manage keystore "key" entries that each contain a private key and an associated certificate "chain". The first certificate in the chain contains the public key corresponding to the private key.

    When keys are first generated (see the -genkeypair command), the chain starts off containing a single element, a self-signed certificate. A self-signed certificate is one for which the issuer (signer) is the same as the subject (the entity whose public key is being authenticated by the certificate). Whenever the -genkeypair command is called to generate a new public/private key pair, it also wraps the public key into a self-signed certificate.

    Later, after a Certificate Signing Request (CSR) has been generated (see the -certreq command) and sent to a Certification Authority (CA), the response from the CA is imported (see -importcert), and the self-signed certificate is replaced by a chain of certificates. At the bottom of the chain is the certificate (reply) issued by the CA authenticating the subject's public key. The next certificate in the chain is one that authenticates the CA's public key.

    In many cases, this is a self-signed certificate (that is, a certificate from the CA authenticating its own public key) and the last certificate in the chain. In other cases, the CA may return a chain of certificates. In this case, the bottom certificate in the chain is the same (a certificate signed by the CA, authenticating the public key of the key entry), but the second certificate in the chain is a certificate signed by a different CA, authenticating the public key of the CA you sent the CSR to. Then, the next certificate in the chain will be a certificate authenticating the second CA's key, and so on, until a self-signed "root" certificate is reached. Each certificate in the chain (after the first) thus authenticates the public key of the signer of the previous certificate in the chain.

    Many CAs only return the issued certificate, with no supporting chain, especially when there is a flat hierarchy (no intermediates CAs). In this case, the certificate chain must be established from trusted certificate information already stored in the keystore.

    A different reply format (defined by the PKCS#7 standard) also includes the supporting certificate chain, in addition to the issued certificate. Both reply formats can be handled by keytool.

    The top-level (root) CA certificate is self-signed. However, the trust into the root's public key does not come from the root certificate itself (anybody could generate a self-signed certificate with the distinguished name of say, the VeriSign root CA!), but from other sources like a newspaper. The root CA public key is widely known. The only reason it is stored in a certificate is because this is the format understood by most tools, so the certificate in this case is only used as a "vehicle" to transport the root CA's public key. Before you add the root CA certificate to your keystore, you should view it (using the -printcert option) and compare the displayed fingerprint with the well-known fingerprint (obtained from a newspaper, the root CA's webpage, etc.).

  • The cacerts Certificates File

    A certificates file named "cacerts" resides in the security properties directory, java.home/lib/security, where java.home is the runtime environment's directory (the jre directory in the SDK or the top-level directory of the Java 2 Runtime Environment).

    The "cacerts" file represents a system-wide keystore with CA certificates. System administrators can configure and manage that file using keytool, specifying "jks" as the keystore type. The "cacerts" keystore file ships with several root CA certificates with the following aliases and X.500 owner distinguished names:

    • Alias: thawtepersonalfreemailca
Owner DN:
              EmailAddress=personal-freemail@thawte.com,
CN=Thawte Personal Freemail CA,
OU=Certification Services Division,
O=Thawte Consulting, L=Cape Town, ST=Western Cape,
              C=ZA
    • Alias: thawtepersonalbasicca
Owner DN:
              EmailAddress=personal-basic@thawte.com,
CN=Thawte Personal Basic CA,
OU=Certification Services Division,
O=Thawte Consulting, L=Cape Town, ST=Western Cape,
              C=ZA
    • Alias: thawtepersonalpremiumca
Owner DN:
              EmailAddress=personal-premium@thawte.com,
CN=Thawte Personal Premium CA,
OU=Certification Services Division,
O=Thawte Consulting, L=Cape Town, ST=Western Cape,
              C=ZA
    • Alias: thawteserverca
      Owner DN: EmailAddress=server-certs@thawte.com,
      CN=Thawte Server CA, OU=Certification Services Division,
      O=Thawte Consulting cc, L=Cape Town, ST=Western Cape, C=ZA
    • Alias: thawtepremiumserverca
Owner DN:
              EmailAddress=premium-server@thawte.com,
CN=Thawte Premium Server CA,
OU=Certification Services Division,
O=Thawte Consulting cc, L=Cape Town, ST=Western Cape,
              C=ZA
    • Alias: verisignclass1ca
      Owner DN: OU=Class 1 Public Primary Certification Authority,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass2ca
      Owner DN: OU=Class 2 Public Primary Certification Authority,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass3ca
      Owner DN: OU=Class 3 Public Primary Certification Authority,
      O="VeriSign, Inc.", C=US
    • Alias: verisignserverca
      Owner DN: OU=Secure Server Certification Authority,
      O="RSA Data Security, Inc.", C=US
    • Alias: verisignclass1g2ca
      Owner DN: OU=VeriSign Trust Network,
      OU="(c) 1998 VeriSign, Inc. - For authorized use only",
      OU=Class 1 Public Primary Certification Authority - G2,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass1g3ca
Owner DN: CN=VeriSign Class 1 Public Primary Certification Authority - G3,
              OU="(c) 1999 VeriSign, Inc. - For authorized use only",
OU=VeriSign Trust Network,
O="VeriSign, Inc.", C=US
    • Alias: verisignclass2g2ca
      Owner DN: OU=VeriSign Trust Network,
      OU="(c) 1998 VeriSign, Inc. - For authorized use only",
      OU=Class 2 Public Primary Certification Authority - G2,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass2g3ca
      Owner DN: CN=VeriSign Class 2 Public Primary Certification Authority - G3,
      OU="(c) 1999 VeriSign, Inc. - For authorized use only",
      OU=VeriSign Trust Network,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass3g2ca
      Owner DN: OU=VeriSign Trust Network,
      OU="(c) 1998 VeriSign, Inc. - For authorized use only",
      OU=Class 3 Public Primary Certification Authority - G2,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass3g3ca
      Owner DN: CN=VeriSign Class 3 Public Primary Certification Authority - G3,
      OU="(c) 1999 VeriSign, Inc. - For authorized use only",
      OU=VeriSign Trust Network,
      O="VeriSign, Inc.", C=US
    • Alias: baltimorecodesigningca
      Owner DN: CN=Baltimore CyberTrust Code Signing Root,
      OU=CyberTrust, O=Baltimore, C=IE
    • Alias: gtecybertrustglobalca
      Owner DN: CN=GTE CyberTrust Global Root,
      OU="GTE CyberTrust Solutions, Inc.", O=GTE Corporation, C=US
    • Alias: baltimorecybertrustca
      Owner DN: CN=Baltimore CyberTrust Root,
      OU=CyberTrust, O=Baltimore, C=IE
    • Alias: gtecybertrust5ca
      Owner DN: CN=GTE CyberTrust Root 5,
      OU="GTE CyberTrust Solutions, Inc.", O=GTE Corporation, C=US
    • Alias: entrustclientca
      Owner DN: CN=Entrust.net Client Certification Authority,
      OU=(c) 1999 Entrust.net Limited,
      OU=www.entrust.net/Client_CA_Info/CPS incorp. by ref. limits liab.,
      O=Entrust.net, C=US
    • Alias: entrustglobalclientca
      Owner DN: CN=Entrust.net Client Certification Authority,
      OU=(c) 2000 Entrust.net Limited,
      OU=www.entrust.net/GCCA_CPS incorp. by ref. (limits liab.),
      O=Entrust.net
    • Alias: entrust2048ca
      Owner DN: CN=Entrust.net Certification Authority (2048),
      OU=(c) 1999 Entrust.net Limited,
      OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.),
      O=Entrust.net
    • Alias: entrustsslca
      Owner DN: CN=Entrust.net Secure Server Certification Authority,
      OU=(c) 1999 Entrust.net Limited,
      OU=www.entrust.net/CPS incorp. by ref. (limits liab.),
      O=Entrust.net, C=US
    • Alias: entrustgsslca
      Owner DN: CN=Entrust.net Secure Server Certification Authority,
      OU=(c) 2000 Entrust.net Limited,
      OU=www.entrust.net/SSL_CPS incorp. by ref. (limits liab.),
      O=Entrust.net
    • Alias: godaddyclass2ca
      Owner DN: OU=Go Daddy Class 2 Certification Authority,
      O="The Go Daddy Group, Inc.", C=US
    • Alias: starfieldclass2ca
      Owner DN: OU=Starfield Class 2 Certification Authority,
      O="Starfield Technologies, Inc.", C=US
    • Alias: valicertclass2ca
      Owner DN: EMAILADDRESS=info@valicert.com,
      CN=http://www.valicert.com/,
      OU=ValiCert Class 2 Policy Validation Authority,
      O="ValiCert, Inc.", L=ValiCert Validation Network
    • Alias: geotrustglobalca
      Owner DN: CN=GeoTrust Global CA,
      O=GeoTrust Inc., C=US
    • Alias: equifaxsecureca
      Owner DN: OU=Equifax Secure Certificate Authority,
      O=Equifax, C=US
    • Alias: equifaxsecureebusinessca1
      Owner DN: CN=Equifax Secure eBusiness CA-1,
      O=Equifax Secure Inc., C=US
    • Alias: equifaxsecureebusinessca2
      Owner DN: OU=Equifax Secure eBusiness CA-2,
      O=Equifax Secure, C=US
    • Alias: equifaxsecureglobalebusinessca1
      Owner DN: CN=Equifax Secure Global eBusiness CA-1,
      O=Equifax Secure Inc., C=US
    • Alias: soneraclass1ca
      Owner DN: CN=Sonera Class1 CA, O=Sonera, C=FI
    • Alias: soneraclass2ca
      Owner DN: CN=Sonera Class2 CA, O=Sonera, C=FI
    • Alias: comodoaaaca
      Owner DN: CN=AAA Certificate Services,
      O=Comodo CA Limited, L=Salford, ST=Greater Manchester, C=GB
    • Alias: addtrustclass1ca
      Owner DN: CN=AddTrust Class 1 CA Root,
      OU=AddTrust TTP Network, O=AddTrust AB, C=SE
    • Alias: addtrustexternalca
      Owner DN: CN=AddTrust External CA Root,
      OU=AddTrust External TTP Network, O=AddTrust AB, C=SE
    • Alias: addtrustqualifiedca
      Owner DN: CN=AddTrust Qualified CA Root,
      OU=AddTrust TTP Network, O=AddTrust AB, C=SE
    • Alias: utnuserfirsthardwareca
      Owner DN: CN=UTN-USERFirst-Hardware,
      OU=http://www.usertrust.com, O=The USERTRUST Network,
      L=Salt Lake City, ST=UT, C=US
    • Alias: utnuserfirstclientauthemailca
      Owner DN: CN=UTN-USERFirst-Client Authentication and Email,
      OU=http://www.usertrust.com, O=The USERTRUST Network,
      L=Salt Lake City, ST=UT, C=US
    • Alias: utndatacorpsgcca
      Owner DN: CN=UTN - DATACorp SGC,
      OU=http://www.usertrust.com, O=The USERTRUST Network,
      L=Salt Lake City, ST=UT, C=US
    • Alias: utnuserfirstobjectca
      Owner DN: CN=UTN-USERFirst-Object,
      OU=http://www.usertrust.com, O=The USERTRUST Network,
      L=Salt Lake City, ST=UT, C=US

    The initial password of the "cacerts" keystore file is "changeit". System administrators should change that password and the default access permission of that file upon installing the SDK.

    IMPORTANT: Verify Your cacerts File
    Since you trust the CAs in the cacerts file as entities for signing and issuing certificates to other entities, you must manage the cacerts file carefully. The cacerts file should contain only certificates of the CAs you trust. It is your responsibility to verify the trusted root CA certificates bundled in the cacerts file and make your own trust decisions. To remove an untrusted CA certificate from the cacerts file, use the delete option of the keytool command. You can find the cacerts file in the JRE installation directory. Contact your system administrator if you do not have permission to edit this file.

  • The Internet RFC 1421 Certificate Encoding Standard

    Certificates are often stored using the printable encoding format defined by the Internet RFC 1421 standard, instead of their binary encoding. This certificate format, also known as "Base 64 encoding", facilitates exporting certificates to other applications by email or through some other mechanism.

    Certificates read by the -importcert and -printcert commands can be in either this format or binary encoded.

    The -exportcert command by default outputs a certificate in binary encoding, but will instead output a certificate in the printable encoding format, if the -rfc option is specified.

    The -list command by default prints the MD5 fingerprint of a certificate. If the -v option is specified, the certificate is printed in human-readable format, while if the -rfc option is specified, the certificate is output in the printable encoding format.

    In its printable encoding format, the encoded certificate is bounded at the beginning by

    -----BEGIN CERTIFICATE-----

    and at the end by

    -----END CERTIFICATE-----

X.500 Distinguished Names

X.500 Distinguished Names are used to identify entities, such as those which are named by the subject and issuer (signer) fields of X.509 certificates. keytool supports the following subparts:
  • commonName - common name of a person, e.g., "Susan Jones"

  • organizationUnit - small organization (e.g, department or division) name, e.g., "Purchasing"

  • organizationName - large organization name, e.g., "ABCSystems, Inc."

  • localityName - locality (city) name, e.g., "Palo Alto"

  • stateName - state or province name, e.g., "California"

  • country - two-letter country code, e.g., "CH"

When supplying a distinguished name string as the value of a -dname option, as for the -genkeypair command, the string must be in the following format:

CN=cName, OU=orgUnit, O=org, L=city, S=state, C=countryCode

where all the italicized items represent actual values and the above keywords are abbreviations for the following:

    CN=commonName
    OU=organizationUnit
    O=organizationName
    L=localityName
    S=stateName
    C=country

A sample distinguished name string is

CN=Mark Smith, OU=JavaSoft, O=Sun, L=Cupertino, S=California, C=US
and a sample command using such a string is
keytool -genkeypair -dname "CN=Mark Smith, OU=JavaSoft, O=Sun, L=Cupertino,
S=California, C=US" -alias mark

Case does not matter for the keyword abbreviations. For example, "CN", "cn", and "Cn" are all treated the same.

Order matters; each subcomponent must appear in the designated order. However, it is not necessary to have all the subcomponents. You may use a subset, for example:

CN=Steve Meier, OU=SunSoft, O=Sun, C=US

If a distinguished name string value contains a comma, the comma must be escaped by a "\" character when you specify the string on a command line, as in

   cn=peter schuster, o=Sun Microsystems\, Inc., o=sun, c=us

It is never necessary to specify a distinguished name string on a command line. If it is needed for a command, but not supplied on the command line, the user is prompted for each of the subcomponents. In this case, a comma does not need to be escaped by a "\".

WARNING Regarding Importing Trusted Certificates

IMPORTANT: Be sure to check a certificate very carefully before importing it as a trusted certificate!

View it first (using the -printcert command, or the -importcert command without the -noprompt option), and make sure that the displayed certificate fingerprint(s) match the expected ones. For example, suppose someone sends or emails you a certificate, and you put it in a file named /tmp/cert. Before you consider adding the certificate to your list of trusted certificates, you can execute a -printcert command to view its fingerprints, as in

  keytool -printcert -file /tmp/cert
    Owner: CN=ll, OU=ll, O=ll, L=ll, S=ll, C=ll
    Issuer: CN=ll, OU=ll, O=ll, L=ll, S=ll, C=ll
    Serial Number: 59092b34
    Valid from: Thu Sep 25 18:01:13 PDT 1997 until: Wed Dec 24 17:01:13 PST 1997
    Certificate Fingerprints:
         MD5:  11:81:AD:92:C8:E5:0E:A2:01:2E:D4:7A:D7:5F:07:6F
         SHA1: 20:B6:17:FA:EF:E5:55:8A:D0:71:1F:E8:D6:9D:C0:37:13:0E:5E:FE
Then call or otherwise contact the person who sent the certificate, and compare the fingerprint(s) that you see with the ones that they show. Only if the fingerprints are equal is it guaranteed that the certificate has not been replaced in transit with somebody else's (for example, an attacker's) certificate. If such an attack took place, and you did not check the certificate before you imported it, you would end up trusting anything the attacker has signed (for example, a JAR file with malicious class files inside).

Note: it is not required that you execute a -printcert command prior to importing a certificate, since before adding a certificate to the list of trusted certificates in the keystore, the -importcert command prints out the certificate information and prompts you to verify it. You then have the option of aborting the import operation. Note, however, this is only the case if you invoke the -importcert command without the -noprompt option. If the -noprompt option is given, there is no interaction with the user.

Warning Regarding Passwords

Most commands operating on a keystore require the store password. Some commands require a private/secret key password.

Passwords can be specified on the command line (in the -storepass and -keypass options, respectively). However, a password should not be specified on a command line or in a script unless it is for testing purposes, or you are on a secure system.

If you don't specify a required password option on a command line, you will be prompted for it.

SEE ALSO

  • jar tool documentation

  • jarsigner tool documentation

  • the Security trail of the Java Tutorial for examples of the use of keytool

CHANGES

The command interface for keytool changed in Java SE 6.

keytool no longer displays password input when entered by users. Since password input can no longer be viewed when entered, users will be prompted to re-enter passwords any time a password is being set or changed (for example, when setting the initial keystore password, or when changing a key password).

Some commands have simply been renamed, and other commands deemed obsolete are no longer listed in this document. All previous commands (both renamed and obsolete) are still supported in this release and will continue to be supported in future releases. The following summarizes all of the changes made to the keytool command interface:

Renamed commands:

  • -export, renamed to -exportcert
  • -genkey, renamed to -genkeypair
  • -import, renamed to -importcert

Commands deemed obsolete and no longer documented:

  • -keyclone
  • -identitydb
  • -selfcert

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


Native-to-ASCII Converter

native2ascii - Native-to-ASCII Converter

Converts a file with native-encoded characters (characters which are non-Latin 1 and non-Unicode) to one with Unicode-encoded characters.

SYNOPSIS

native2ascii [options] [inputfile [outputfile]]

DESCRIPTION

The Java compiler and other Java tools can only process files which contain Latin-1 and/or Unicode-encoded (\udddd notation) characters. native2ascii converts files which contain other character encodings into files containing Latin-1 and/or Unicode-encoded charaters.

If outputfile is omitted, standard output is used for output. If, in addition, inputfile is omitted, standard input is used for input.

OPTIONS

-reverse
Perform the reverse operation: convert a file with Latin-1 and/or Unicode encoded characters to one with native-encoded characters.

-encoding encoding_name
Specify the encoding name which is used by the conversion procedure. The default encoding is taken from System property file.encoding. The encoding_name string must be taken from the first column of the table of supported encodings in the Supported Encodings document.
-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes.

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


policytool - Policy File Admin GUI

policytool - PolicyTool Administration GUI Utility

policytool reads and writes a plain text policy file based on user input via the utility GUI.
  • Synopsis
  • Description
  • Options
  • See Also

SYNOPSIS

Run the policytool Administrator's utility
policytool
Run policytool and load the specified policy file
policytool[-file filename]

where:
file
directs policytool to load a local policy file
filename
The file name

DESCRIPTION

policytool is a GUI that allows users to create and manage policy files. For details, see the Policytool Users Guide.

OPTIONS

file
Loads filename.

SEE ALSO

Default Policy Implementation and Syntax
Policy Tool Users' Guide
Security Permissions
Security Overview

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


rmic - The Java RMI Compiler

rmic generates stub, skeleton, and tie classes for remote objects using either the JRMP or IIOP protocols. Also generates OMG IDL.

SYNOPSIS

rmic [ options ] package-qualified-class-name(s)

DESCRIPTION

The rmic compiler generates stub and skeleton class files (JRMP protocol) and stub and tie class files (IIOP protocol) for remote objects. These classes files are generated from compiled Java programming language classes that are remote object implementation classes. A remote implementation class is a class that implements the interface java.rmi.Remote. The class names in the rmic command must be for classes that have been compiled successfully with the javac command and must be fully package qualified. For example, running rmic on the class file name HelloImpl as shown here:

rmic hello.HelloImpl

creates the HelloImpl_Stub.class file in the hello subdirectory (named for the class's package).

A skeleton for a remote object is a JRMP protocol server-side entity that has a method that dispatches calls to the actual remote object implementation.

A tie for a remote object is a server-side entity similar to a skeleton, but which communicates with the client using the IIOP protocol.

A stub is a client-side proxy for a remote object which is responsible for communicating method invocations on remote objects to the server where the actual remote object implementation resides. A client's reference to a remote object, therefore, is actually a reference to a local stub.

By default, rmic generates stub classes that use the 1.2 JRMP stub protocol version only, as if the -v1.2 option had been specified. (Note that the -vcompat option was the default in releases prior to 5.0.) Use the -iiop option to generate stub and tie classes for the IIOP protocol.

A stub implements only the remote interfaces, not any local interfaces that the remote object also implements. Because a JRMP stub implements the same set of remote interfaces as the remote object itself, a client can use the Java programming language's built-in operators for casting and type checking. For IIOP, the PortableRemoteObject.narrow method must be used.

OPTIONS

-bootclasspath path
Overrides location of bootstrap class files
-classpath path
Specifies the path rmic uses to look up classes. This option overrides the default or the CLASSPATH environment variable if it is set. Directories are separated by colons. Thus the general format for path is:
.:<your_path>
For example:
.:/usr/local/java/classes
-d directory
Specifies the root destination directory for the generated class hierarchy. You can use this option to specify a destination directory for the stub, skeleton, and tie files. For example, the command
% rmic -d /java/classes foo.MyClass
would place the stub and skeleton classes derived from MyClass into the directory /java/classes/foo. If the -d option is not specified, the default behavior is as if "-d ." were specified: the package hierarchy of the target class is created in the current directory, and stub/tie/skeleton files are placed within it. (Note that in some previous versions of rmic, if -d was not specified, then the package hierarchy was not created, and all of the output files were placed directly in the current directory.)
-extdirs path
Overrides location of installed extensions
-g
Enables generation of all debugging information, including local variables. By default, only line number information is generated.

-idl
Causes rmic to generate OMG IDL for the classes specified and any classes referenced. IDL provides a purely declarative, programming language-independent way of specifying an object's API. The IDL is used as a specification for methods and data that can be written in and invoked from any language that provides CORBA bindings. This includes Java and C++ among others. See the Java Language to IDL Mapping (OMG) document for a complete description.

When the -idl option is used, other options also include:

-always or -alwaysgenerate
Forces re-generation even when existing stubs/ties/IDL are newer than the input class.
-factory
Uses factory keyword in generated IDL.
-idlModule fromJavaPackage[.class] toIDLModule
Specifies IDLEntity package mapping. For example: -idlModule foo.bar my::real::idlmod.
-idlFile fromJavaPackage[.class] toIDLFile
Specifies IDLEntity file mapping. For example: -idlFile test.pkg.X TEST16.idl.

-iiop
Causes rmic to generate IIOP stub and tie classes, rather than JRMP stub and skeleton classes. A stub class is a local proxy for a remote object and is used by clients to send calls to a server. Each remote interface requires a stub class, which implements that remote interface. A client's reference to a remote object is actually a reference to a stub. Tie classes are used on the server side to process incoming calls, and dispatch the calls to the proper implementation class. Each implementation class requires a tie class.

Invoking rmic with the -iiop generates stubs and ties that conform to this naming convention:

_<implementationName>_stub.class

_<interfaceName>_tie.class

When the -iiop option is used, other options also include:

-always or -alwaysgenerate
Forces re-generation even when existing stubs/ties/IDL are newer than the input class.
-nolocalstubs
Do not create stubs optimized for same-process clients and servers.
-noValueMethods
Must be used with the -idl option. Prevents addition of valuetype methods and initializers to emitted IDL. These methods and initializers are optional for valuetypes, and are generated unless the -noValueMethods option is specified when using the -idl option.
-poa
Changes the inheritance from org.omg.CORBA_2_3.portable.ObjectImpl to org.omg.PortableServer.Servant.

The PortableServer module for the Portable Object Adapter (POA) defines the native Servant type. In the Java programming language, the Servant type is mapped to the Java org.omg.PortableServer.Servant class. It serves as the base class for all POA servant implementations and provides a number of methods that may be invoked by the application programmer, as well as methods which are invoked by the POA itself and may be overridden by the user to control aspects of servant behavior. Based on the OMG IDL to Java Language Mapping Specification, CORBA V 2.3.1 ptc/00-01-08.pdf.

-J
Used in conjunction with any java option, it passes the option following the -J (no spaces between the -J and the option) on to the java interpreter.
-keep or -keepgenerated
Retains the generated .java source files for the stub, skeleton, and/or tie classes and writes them to the same directory as the .class files.
-nowarn
Turns off warnings. If used the compiler does not print out any warnings.

-vcompat
Generates stub and skeleton classes compatible with both the 1.1 and 1.2 JRMP stub protocol versions. (This option was the default in releases prior to 5.0.) The generated stub classes will use the 1.1 stub protocol version when loaded in a JDK 1.1 virtual machine and will use the 1.2 stub protocol version when loaded into a 1.2 (or later) virtual machine. The generated skeleton classes will support both 1.1 and 1.2 stub protocol versions. The generated classes are relatively large in order to support both modes of operation.
-verbose
Causes the compiler and linker to print out messages about what classes are being compiled and what class files are being loaded.

-v1.1
Generates stub and skeleton classes for the 1.1 JRMP stub protocol version only. Note that this option is only useful for generating stub classes that are serialization-compatible with pre-existing, statically-deployed stub classes that were generated by the rmic tool from JDK 1.1 and that cannot be upgraded (and dynamic class loading is not being used).

-v1.2
(default) Generates stub classes for the 1.2 JRMP stub protocol version only. No skeleton classes are generated with this option because skeleton classes are not used with the 1.2 stub protocol version. The generated stub classes will not work if they are loaded into a JDK 1.1 virtual machine.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by colons. For example,
.:/usr/local/java/classes

SEE ALSO

java, javac, CLASSPATH

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.
Please send comments to: rmi-comments@java.sun.com 		Sun


rmid - The Java RMI Activation System Daemon

rmid starts the activation system daemon that allows objects to be registered and activated in a virtual machine (VM).

SYNOPSIS

rmid [options]

DESCRIPTION

The rmid tool starts the activation system daemon. The activation system daemon must be started before activatable objects can be either registered with the activation system or activated in a VM. See the Java RMI Specification and Activation tutorials for details on how to write programs that use activatable remote objects.

The daemon can be started by executing the rmid command, and specifying a security policy file, as follows:

    rmid -J-Djava.security.policy=rmid.policy

Note: When running Sun's implementation of rmid, by default you will need to specify a security policy file so that rmid can verify whether or not the information in each ActivationGroupDesc is allowed to be used to launch a VM for an activation group. Specifically, the command and options specified by the CommandEnvironment and any Properties passed to an ActivationGroupDesc's constructor must now be explicitly allowed in the security policy file for rmid. The value of the sun.rmi.activation.execPolicy property dictates the policy that rmid uses to determine whether or not the information in an ActivationGroupDesc may be used to launch a VM for an activation group.

Executing rmid by default

  • starts the Activator and an internal registry on the default port, 1098, and
  • binds an ActivationSystem to the name java.rmi.activation.ActivationSystem in this internal registry.

To specify an alternate port for the registry, you must specify the -port option when starting up rmid. For example,

    rmid -J-Djava.security.policy=rmid.policy -port 1099

starts the activation system daemon and a registry on the registry's default port, 1099.

Starting rmid from inetd/xinetd

An alternative to starting rmid from the command line is to configure inetd (Solaris) or xinetd (Linux) to start rmid on demand.

When rmid starts up, it attempts to obtain an inherited channel (inherited from inetd/xinetd) by invoking the System.inheritedChannel method. If the inherited channel is null or not an instance of java.nio.channels.ServerSocketChannel, then rmid assumes that it was not started by inetd/xinetd, and it starts up as described above.

If the inherited channel is a ServerSocketChannel instance, then rmid uses the java.net.ServerSocket obtained from the ServerSocketChannel as the server socket that accepts requests for the remote objects it exports, namely the registry in which the java.rmi.activation.ActivationSystem is bound and the java.rmi.activation.Activator remote object. In this mode, rmid behaves the same as when it is started from the command line, except:

  • Output printed to System.err is redirected to a file. This file is located in the directory specified by the java.io.tmpdir system property (typically /var/tmp or /tmp) with the prefix "rmid-err" and the suffix "tmp".
  • The -port option is disallowed. If this option is specified, rmid will exit with an error message.
  • The -log option is required. If this option is not specified, rmid will exit with an error message.

See the man pages for inetd (Solaris) or xinetd (Linux) for details on how to configure services to be started on demand.

OPTIONS

-C<someCommandLineOption>
Specifies an option that is passed as a command-line argument to each child process (activation group) of rmid when that process is created. For example, you could pass a property to each virtual machine spawned by the activation system daemon:
    rmid -C-Dsome.property=value
This ability to pass command-line arguments to child processes can be useful for debugging. For example, the following command:
    rmid -C-Djava.rmi.server.logCalls=true
will enable server-call logging in all child VMs.

-J<someCommandLineOption>
Specifies an option that is passed to the java interpreter running rmid. For example, to specify that rmid use a policy file named rmid.policy, the -J option can be used to define the java.security.policy property on rmid's command line, for example:
    rmid -J-Djava.security.policy=rmid.policy
-J-Dsun.rmi.activation.execPolicy=<policy>
Specifies the policy that rmid employs to check commands and command-line options used to launch the VM in which an activation group runs. Please note that this option exists only in Sun's implementation of the Java RMI activation daemon. If this property is not specified on the command line, the result is the same as if -J-Dsun.rmi.activation.execPolicy=default were specified. The possible values of <policy> can be default, <policyClassName>, or none:

  • default (or if this property is unspecified)

    The default execPolicy allows rmid to execute commands with specific command-line options only if rmid has been granted permission to execute those commands and options in the security policy file that rmid uses. Only the default activation group implementation can be used with the default execution policy.

    rmid launches a VM for an activation group using the information in the group's registered activation group descriptor, an ActivationGroupDesc. The group descriptor specifies an optional ActivationGroupDesc.CommandEnvironment which includes the command to execute to start the activation group as well as any command line options to be added to the command line. By default, rmid uses the java command found in java.home. The group descriptor also contains properties overrides that are added to the command line as options defined as:

        -D<property>=<value>

    The permission com.sun.rmi.rmid.ExecPermission is used to grant rmid permission to execute a command, specified in the group descriptor's CommandEnvironment to launch an activation group. The permission com.sun.rmi.rmid.ExecOptionPermission is used to allow rmid to use command-line options, specified as properties overrides in the group descriptor or as options in the CommandEnvironment, when launching the activation group.

    When granting rmid permission to execute various commands and options, the permissions ExecPermission and ExecOptionPermission need to be granted universally (i.e., granted to all code sources).

    ExecPermission
    The ExecPermission class represents permission for rmid to execute a specific command to launch an activation group.

    Syntax
    The name of an ExecPermission is the path name of a command to grant rmid permission to execute. A path name that ends in "/*" indicates all the files contained in that directory (where "/" is the file-separator character, File.separatorChar). A path name that ends with "/-" indicates all files and subdirectories contained in that directory (recursively). A path name consisting of the special token "<<ALL FILES>>" matches any file.

    Note: A path name consisting of a single "*" indicates all the files in the current directory, while a path name consisting of a single "-" indicates all the files in the current directory and (recursively) all files and subdirectories contained in the current directory.

    ExecOptionPermission
    The ExecOptionPermission class represents permission for rmid to use a specific command-line option when launching an activation group. The name of an ExecOptionPermission is the value of a command line option.

    Syntax
    Options support a limited wildcard scheme. An asterisk signifies a wildcard match, and it may appear as the option name itself (i.e., it matches any option), or an asterisk may appear at the end of the option name only if the asterisk follows either a "." or "=".

    For example: "*" or "-Dfoo.*" or "-Da.b.c=*" is valid, "*foo" or "-Da*b" or "ab*" is not.

    Policy file for rmid
    When granting rmid permission to execute various commands and options, the permissions ExecPermission and ExecOptionPermission need to be granted universally (i.e., granted to all code sources). It is safe to grant these permissions universally because only rmid checks these permissions.

    An example policy file that grants various execute permissions to rmid is:

    grant {
    permission com.sun.rmi.rmid.ExecPermission
        "/files/apps/java/jdk1.2.2/solaris/bin/java";

    permission com.sun.rmi.rmid.ExecPermission
        "/files/apps/java/jdk1.2.2/solaris/bin/java_g";

    permission com.sun.rmi.rmid.ExecPermission
        "/files/apps/rmidcmds/*";

    permission com.sun.rmi.rmid.ExecOptionPermission
        "-Djava.security.policy=/files/policies/group.policy";

    permission com.sun.rmi.rmid.ExecOptionPermission
        "-Djava.security.debug=*";

    permission com.sun.rmi.rmid.ExecOptionPermission
        "-Dsun.rmi.*";
};
    The first two permissions granted allow rmid to execute the 1.2.2 version of the java and java_g commands, specified by their explicit path names. Note that by default, the version of the java command found in java.home is used (the same one that rmid uses), and does not need to be specified in the policy file. The third permission allows rmid to execute any command in the directory /files/apps/rmidcmds.

    The fourth permission granted, an ExecOptionPermission, allows rmid to launch an activation group that defines the security policy file to be /files/policies/group.policy. The next permission allows the java.security.debug property to be used by an activation group. The last permission allows any property in the sun.rmi property name hierarchy to be used by activation groups.

    To start rmid with a policy file, the java.security.policy property needs to be specified on rmid's command line, for example:

    rmid -J-Djava.security.policy=rmid.policy

  • <policyClassName>

    If the default behavior is not flexible enough, an administrator can provide, when starting rmid, the name of a class whose checkExecCommand method is executed in order to check commands to be executed by rmid.

    The policyClassName specifies a public class with a public, no-argument constructor and an implementation of the following checkExecCommand method:

        public void checkExecCommand(ActivationGroupDesc desc,
                                 String[] command)
        throws SecurityException;
    Before launching an activation group, rmid calls the policy's checkExecCommand method, passing it the activation group descriptor and an array containing the complete command to launch the activation group. If the checkExecCommand throws a SecurityException, rmid will not launch the activation group and an ActivationException will be thrown to the caller attempting to activate the object.

  • none

    If the sun.rmi.activation.execPolicy property value is "none", then rmid will not perform any validation of commands to launch activation groups.

-log dir
Specifies the name of the directory the activation system daemon uses to write its database and associated information. The log directory defaults to creating a directory, log, in the directory in which the rmid command was executed.

-port port
Specifies the port rmid's registry uses. The activation system daemon binds the ActivationSystem, with the name java.rmi.activation.ActivationSystem, in this registry. Thus, the ActivationSystem on the local machine can be obtained using the following Naming.lookup method call:
    import java.rmi.*;
    import java.rmi.activation.*;

    ActivationSystem system; system = (ActivationSystem)
    Naming.lookup("//:port/java.rmi.activation.ActivationSystem");
-stop
Stops the current invocation of rmid, for a port specified by the -port option. If no port is specified, it will stop the rmid running on port 1098.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by colons. For example:
    .:/usr/local/java/classes

SEE ALSO

rmic, CLASSPATH, java

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.
Please send comments to: rmi-comments@java.sun.com 		Sun


rmiregistry - The Java Remote Object Registry

The rmiregistry command starts a remote object registry on the specified port on the current host.

SYNOPSIS

rmiregistry [port]

DESCRIPTION

The rmiregistry command creates and starts a remote object registry on the specified port on the current host. If port is omitted, the registry is started on port 1099. The rmiregistry command produces no output and is typically run in the background. For example:

rmiregistry &

A remote object registry is a bootstrap naming service that is used by RMI servers on the same host to bind remote objects to names. Clients on local and remote hosts can then look up remote objects and make remote method invocations.

The registry is typically used to locate the first remote object on which an application needs to invoke methods. That object in turn will provide application-specific support for finding other objects.

The methods of the java.rmi.registry.LocateRegistry class are used to get a registry operating on the local host or local host and port.

The URL-based methods of the java.rmi.Naming class operate on a registry and can be used to look up a remote object on any host, and on the local host: bind a simple (string) name to a remote object, rebind a new name to a remote object (overriding the old binding), unbind a remote object, and list the URLs bound in the registry.

OPTIONS

-J
Used in conjunction with any java option, it passes the option following the -J (no spaces between the -J and the option) on to the java interpreter.

SEE ALSO

java, java.rmi.registry.LocateRegistry and java.rmi.Naming

Copyright © 2003-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


serialver - The Serial Version Command

The serialver command returns the serialVersionUID.

SYNOPSIS

serialver [ options ] [ classnames ]
options
Command-line options, as specified in this document.
classnames
One or more class names

DESCRIPTION

serialver returns the serialVersionUID for one or more classes in a form suitable for copying into an evolving class. When invoked with no arguments it prints a usage line.

OPTIONS

-classpath <directories and zip/jar files separated by :>
Set search path for application classes and resources.
-show
Displays a simple user interface. Enter the full class name and press either the Enter key or the Show button to display the serialVersionUID.
-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes.

NOTES

The serialver command loads and initializes the specified classes in its virtual machine, and by default, it does not set a security manager. If serialver is to be run with untrusted classes, a security manager can be set with the following option:

-J-Djava.security.manager

and, if necessary, a security policy can be specified with the following option:

-J-Djava.security.policy=<policy file>

SEE ALSO

java.io.ObjectStreamClass

Copyright © 2005-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


Setting the class path

Synopsis

The class path is the path that the Java runtime environment searches for classes and other resource files. The class search path (more commonly known by the shorter name, "class path") can be set using either the -classpath option when calling a JDK tool (the preferred method) or by setting the CLASSPATH environment variable. The -classpath option is preferred because you can set it individually for each application without affecting other applications and without other applications modifying its value.

% sdkTool -classpath classpath1:classpath2...

-or-

% setenv CLASSPATH classpath1:classpath2...

where:

sdkTool
A command-line tool, such as java, javac, javadoc, or apt. For a listing, see JDK Tools.
classpath1:classpath2
Class paths to the .jar, .zip or .class files. Each classpath should end with a filename or directory depending on what you are setting the class path to:
  • For a .jar or .zip file that contains .class files, the class path ends with the name of the .zip or .jar file.
  • For .class files in an unnamed package, the class path ends with the directory that contains the .class files.
  • For .class files in a named package, the class path ends with the directory that contains the "root" package (the first package in the full package name).

Multiple path entries are separated by colons.

The default class path is the current directory. Setting the CLASSPATH variable or using the -classpath command-line option overrides that default, so if you want to include the current directory in the search path, you must include "." in the new settings.

Classpath entries that are neither directories nor archives (.zip or .jar files) nor * are ignored.

Description

The class path tells the JDK tools and applications where to find third-party and user-defined classes -- that is, classes that are not extensions or part of the Java platform. The class path needs to find any classes you've compiled with the javac compiler -- its default is the current directory to conveniently enable those classes to be found.

The JDK, the JVM and other JDK tools find classes by searching the Java platform (bootstrap) classes, any extension classes, and the class path, in that order. (For details on the search strategy, see How Classes Are Found.) Class libraries for most applications will want to take advantage of the extensions mechanism. You only need to set the class path when you want to load a class that's (a) not in the current directory or in any of its subdirectories, and (b) not in a location specified by the extensions mechanism.

If you are upgrading from an older version of the JDK, your startup settings may include CLASSPATH settings that are no longer needed. You should remove any settings that are not application-specific, such as classes.zip. Some third-party applications that use the Java Virtual Machine may modify your CLASSPATH environment variable to include the libaries they use. Such settings can remain.

You can change the class path by using the JDK tools' -classpath option when you invoke the JVM or other JDK tools or by using the CLASSPATH environment variable. Using the -classpath option is preferred over setting CLASSPATH environment variable because you can set it individually for each application without affecting other applications and without other applications modifying its value.

Classes can be stored either in directories (folders) or in archive files. The Java platform classes are stored in rt.jar. For more details on archives and information on how the class path works, see Understanding the class path and package names near the end of this document.

Important Note: Some older versions of the JDK software included a <jdk-dir>/classes entry in the default class path. That directory exists for use by the JDK software, and should not be used for application classes. Application classes should be placed in a directory outside of the JDK direcotry hierarchy. That way, installing a new JDK does not force you to reinstall application classes. For compatibility with older versions, applications that use the <jdk-dir>/classes directory as a class library will run in the current version, but there is no guarantee that they will run in future versions.

Using the JDK tools' -classpath option

The Java tools java, jdb, javac, and javah have a -classpath option which replaces the path or paths specified by the CLASSPATH environment variable while the tool runs. This is the recommended option for changing class path settings, because each application can have the class path it needs without interfering with any other application.

The runtime tool java has a -cp option, as well. This option is an abbreviation for -classpath.

For very special cases, both java and javac have options that let you change the path they use to find their own class libraries. The vast majority of users will never to need to use those options, however.

Using the CLASSPATH environment variable

In general, you will want to use the -classpath command-line option, as explained in the previous section. This section shows you how to set the CLASSPATH environment variable if you want to do that, or clear settings left over from a previous installation.

Setting CLASSPATH

In csh, the CLASSPATH environment variable is modified with the setenv command. The format is:

setenv CLASSPATH path1:path2

In sh, the CLASSPATH environment variable can be modified with these commands:

CLASSPATH = path1:path2:...

export CLASSPATH

Clearing CLASSPATH

If your CLASSPATH environment variable has been set to a value that is not correct, or if your startup file or script is setting an incorrect path, you can unset CLASSPATH in csh by using:

unsetenv CLASSPATH

In sh, you would use:

unset CLASSPATH

These commands unset CLASSPATH for the current shell only. You should also delete or modify your startup settings to ensure that you have the right CLASSPATH settings in future sessions.

Changing Startup Settings

If the CLASSPATH variable is set at system startup, the place to look for it depends on the shell you are running:

Shell | Startup Script
csh, tcsh | Examine your .cshrc file for the setenv command.
sh, ksh | Examine your .profile file for the export command.

Understanding class path wildcards

Class path entries can contain the basename wildcard character *, which is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR. For example, the class path entry foo/* specifies all JAR files in the directory named foo. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. Files will be considered regardless of whether or not they are hidden (that is, have names beginning with '.').

A class path entry that contains * will not match class files. To match both classes and JAR files in a single directory foo, use either foo:foo/* or foo/*:foo. The order chosen determines whether the classes and resources in foo are loaded before JAR files in foo, or vice versa.

Subdirectories are not searched recursively. For example, foo/* looks for JAR files only in foo, not in foo/bar, foo/baz, etc.

The order in which the JAR files in a directory are enumerated in the expanded class path is not specified and may vary from platform to platform and even from moment to moment on the same machine. A well-constructed application should not depend upon any particular order. If a specific order is required then the JAR files can be enumerated explicitly in the class path.

Expansion of wildcards is done early, prior to the invocation of a program's main method, rather than late, during the class-loading process itself. Each element of the input class path containing a wildcard is replaced by the (possibly empty) sequence of elements generated by enumerating the JAR files in the named directory. For example, if the directory foo contains a.jar, b.jar, and c.jar, then the class path foo/* is expanded into foo/a.jar:foo/b.jar:foo/c.jar, and that string would be the value of the system property java.class.path.

The CLASSPATH environment variable is not treated any differently from the -classpath (or -cp) command-line option. That is, wildcards are honored in all these cases. However, class path wildcards are not honored in the Class-Path jar-manifest header.

Understanding the class path and package names

Java classes are organized into packages which are mapped to directories in the file system. But, unlike the file system, whenever you specify a package name, you specify the whole package name -- never part of it. For example, the package name for java.awt.Button is always specified as java.awt.

For example, suppose you want the Java runtime to find a class named Cool.class in the package utility.myapp. If the path to that directory is /java/MyClasses/utility/myapp, you would set the class path so that it contains /java/MyClasses.

To run that app, you could use the following JVM command:

% java -classpath /java/MyClasses utility.myapp.Cool

When the app runs, the JVM uses the class path settings to find any other classes defined in the utility.myapp package that are used by the Cool class.

Note that the entire package name is specified in the command. It is not possible, for example, to set the class path so it contains /java/MyClasses/utility and use the command java myapp.Cool. The class would not be found.

(You may be wondering what defines the package name for a class. The answer is that the package name is part of the class and cannot be modified, except by recompiling the class.)

Note: An interesting consequence of the package specification mechanism is that files which are part of the same package may actually exist in different directories. The package name will be the same for each class, but the path to each file may start from a different directory in the class path.

Folders and archive files

When classes are stored in a directory (folder), like /java/MyClasses/utility/myapp, then the class path entry points to the directory that contains the first element of the package name. (in this case, /java/MyClasses, since the package name is utility.myapp.)

But when classes are stored in an archive file (a .zip or .jar file) the class path entry is the path to and including the .zip or .jar file. For example, to use a class library that is in a .jar file, the command would look something like this:

% java -classpath /java/MyClasses/myclasses.jar utility.myapp.Cool

Multiple specifications

To find class files in the directory /java/MyClasses as well as classes in /java/OtherClasses, you would set the class path to:

% java -classpath /java/MyClasses:/java/OtherClasses ...

Note that the two paths are separated by a colon.

Specification order

The order in which you specify multiple class path entries is important. The Java interpreter will look for classes in the directories in the order they appear in the class path variable. In the example above, the Java interpreter will first look for a needed class in the directory /java/MyClasses. Only if it doesn't find a class with the proper name in that directory will the interpreter look in the /java/OtherClasses directory.

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


appletviewer - The Java Applet Viewer

The appletviewer command allows you to run applets outside of a web browser.

SYNOPSIS

appletviewer [ options ] urls ...

DESCRIPTION

The appletviewer command connects to the documents or resources designated by urls and displays each applet referenced by the documents in its own window. Note: if the documents referred to by urls do not reference any applets with the OBJECT, EMBED, or APPLET tag, then appletviewer does nothing. For details on the HTML tags that appletviewer supports, see AppletViewer Tags.

The Java 2 JDK contains two implementations of the Java virtual machine:

Note: The appletviewer requires encoded URLs according to the escaping mechanism defined in RFC2396. Only encoded URLs are supported. However, file names must be unencoded, as specified in RFC2396.

  • The Java HotSpotTM Client VM
    The Java HotSpot Client VM is the default virtual machine. Its use of Java HotSpot technology gives it superior performance as compared with the Classic VM. Unless special command-line options are used to invoke the Classic VM instead (see below), appletviewer will always launch an applet to run on the Client VM.
  • The Java 2 Classic VM
    The Java 2 Classic VM is essentially the same virtual machine implementation as in version 1.2 of the Java 2 SDK. It may be invoked by using the -classic command-line option, as in this example:
    appletviewer -classic MyApplet.html

OPTIONS

-debug
Starts the applet viewer in the Java debugger, jdb, thus allowing you to debug the applets in the document.
-encoding encoding name
Specifies the input HTML file encoding name.
-J javaoption
Passes through the string javaoption as a single argument to the Java interpreter which runs the appletviewer. The argument should not contain spaces. Multiple argument words must all begin with the prefix -J, which is stripped. This is useful for adjusting the compiler's execution environment or memory usage.

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


extcheck - Jar conflict detection utility

extcheck - A utility to detect jar conflicts

extcheck detects version conflicts between a target jar file and currently installed extension jar files.

SYNOPSIS

extcheck [ -verbose ] targetfile.jar

DESCRIPTION

The extcheck utility checks a specified Jar file for title and version conflicts with any extensions installed in the JavaTM SDK. Before installing an extension, you can use this utility to see if the same or a more recent version of the extension is already installed.

The extcheck utility compares the Specification-title and Specification-version headers in the manifest of targetfile.jar file against the corresponding headers in all Jar files currently installed in the extension directory. (The extension directory is jre\lib\ext by default.) The extcheck utility compares version numbers in the same way as the method java.lang.Package.isCompatibleWith.

If no conflict is detected, the return code is 0.

If the manifest of any of the jar file in the extensions directory has the same Specification-title and the same or a newer Specification-version number, a non-zero error code is returned. A non-zero error code is also returned if targetfile.jar does not have the Specification-title or Specification-version attributes in its manifest.

OPTIONS

-verbose
Lists Jar files in the extension directory as they are checked. Additionally, manifest attributes of the target jar file and any conflicting jar files are also reported.
-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes.

SEE ALSO

jar

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jar-The Java Archive Tool

jar combines multiple files into a single JAR archive file.
  • Synopsis
  • Description
  • Options
  • Command Line Argument Files
  • Examples
  • See Also

SYNOPSIS

Create jar file
jar c[v0M]f jarfile [-C dir] inputfiles [-J option]
jar c[v0]mf manifest jarfile [-C dir] inputfiles [-J option] [-e entrypoint]
jar c[v0M] [-C dir] inputfiles [-J option]
jar c[v0]m manifest [-C dir] inputfiles [-J option]
Update jar file
jar u[v0M]f jarfile [-C dir] inputfiles [-J option]
jar u[v0]mf manifest jarfile [-C dir] inputfiles [-J option] [-e entrypoint]
jar u[v0M] [-C dir] inputfiles [-J option]
jar u[v0]m manifest [-C dir] inputfiles [-J option]
Extract jar file
jar x[v]f jarfile [inputfiles] [-J option]
jar x[v] [inputfiles] [-J option]
List table of contents of jar file
jar t[v]f jarfile [inputfiles] [-J option]
jar t[v] [inputfiles] [-J option]
Add index to jar file
jar i jarfile [-J option]

where:

cuxtiv0Mmf
Options that control the jar command.
jarfile
File name of the Jar file to be created (c), updated (u), extracted (x), or have its table of contents viewed (t). The -f option and filename jarfile are a pair -- if either is present, they must both appear. Note that omitting -f and jarfile accepts jar file from standard input (for x and t) or sends jar file to standard output (for c and u).
inputfiles
Files or directories separated by spaces, to be combined into jarfile (for c and u), or to be extracted (for x) or listed (for t) from jarfile. All directories are processed recursively. The files are compressed unless option -0 (zero) is used.
manifest
Pre-existing manifest file whose name : value pairs are to be included in MANIFEST.MF in the jar file. The -m option and filename manifest are a pair -- if either is present, they must both appear. The letters m and f must appear in the same order that manifest and jarfile appear.
entrypoint
The name of the class that set as the application entry point for stand-alone applications bundled into executable jar file. The -e option and entrypoint are a pair -- if either is present, they must both appear. The letters m, f and e must appear in the same order that manifest, jarfile, entrypoint appear.
-C dir
Temporarily changes directories to dir while processing the following inputfiles argument. Multiple -C dir inputfiles sets are allowed.
-J option
Option passed into the Java runtime environment. (There must be no space between -J and option).

DESCRIPTION

The jar tool combines multiple files into a single JAR archive file. jar is a general-purpose archiving and compression tool, based on ZIP and the ZLIB compression format. However, jar was designed mainly to facilitate the packaging of java applets or applications into a single archive. When the components of an applet or application (.class files, images and sounds) are combined into a single archive, they may be downloaded by a java agent (like a browser) in a single HTTP transaction, rather than requiring a new connection for each piece. This dramatically improves download times. jar also compresses files and so further improves download time. In addition, it allows individual entries in a file to be signed by the applet author so that their origin can be authenticated. The syntax for the jar tool is almost identical to the syntax for the tar command. A jar archive can be used as a class path entry, whether or not it is compressed.

Typical usage to combine files into a jar file is:

C:\Java> jar cf myFile.jar *.class
In this example, all the class files in the current directory are placed into the file named "myFile.jar". A manifest file entry named META-INF/MANIFEST.MF is automatically generated by the jar tool and is always the first entry in the jar file. The manifest file is the place where any meta-information about the archive is stored as name : value pairs. Refer to the JAR file specification for details about how meta-information is stored in the manifest file.

If you have a pre-existing manifest file whose name: value pairs you want the jar tool to include for the new jar archive, you can specify it using the -m option:

C:\Java> jar cmf myManifestFile myFile.jar *.class
An existing manifest file must end with a new line character. jar does not parse the last line of a manifest file if it does not end with a new line character.

Note: A jar command that specifies cfm on the command line instead of cmf (the order of the -m and -f options are reversed), the jar command line must specify the name of the jar archive first, followed by the name of the manifest file:
C:\Java> jar cfm myFile.jar myManifestFile *.class
The manifest is in a text format inspired by RFC822 ASCII format, so it is easy to view and process manifest-file contents.

To extract the files from a jar file, use -x, as in:

C:\Java> jar xf myFile.jar

To extract only certain files from a jar file, supply their filenames:

C:\Java> jar xf myFile.jar foo bar

Beginning with Java 2 SDK v1.3, the jar utility supports JarIndex, which allows application class loaders to load classes more efficiently from jar files. If an application or applet is bundled into multiple jar files, only the necessary jar files will be downloaded and opened to load classes. This performance optimization is enabled by running jar with the -i option. It will generate package location information for the specified main jar file and all the jar files it depends on, which need to be specified in the Class-Path attribute of the main jar file's manifest.

C:\Java> jar i main.jar

In this example, an INDEX.LIST file is inserted into the META-INF directory of main.jar.
The application class loader will use the information stored in this file for efficient class loading. Refer to the JarIndex specification for details about how location information is stored in the index file.

A standard way to copy directories is to first compress files in dir1 to standard out, then extract from standard in to dir2 (omitting f from both jar commands):

C:\Java> (cd dir1; jar c .) | (cd dir2; jar x)

Examples of using the jar tool to operate on jar files and jar file manifests are provided below and in the Jar trail of the Java Tutorial.

OPTIONS

c
Creates a new archive file named jarfile (if f is specified) or to standard output (if f and jarfile are omitted). Add to it the files and directories specified by inputfiles.
u
Updates an existing file jarfile (when f is specified) by adding to it files and directories specified by inputfiles. For example:
jar uf foo.jar foo.class
adds the file foo.class to the existing jar file foo.jar. The -u option can also update the manifest entry, as given by this example:
jar umf manifest foo.jar
updates the foo.jar manifest with the name: value pairs in manifest.
x
Extracts files and directories from jarfile (if f is specified) or standard input (if f and jarfile are omitted). If inputfiles is specified, only those specified files and directories are extracted. Otherwise, all files and directories are extracted. The time and date of the extracted files are those given in the archive.
t
Lists the table of contents from jarfile (if f is specified) or standard input (if f and jarfile are omitted). If inputfiles is specified, only those specified files and directories are listed. Otherwise, all files and directories are listed.
i
Generate index information for the specified jarfile and its dependent jar files. For example:
jar i foo.jar

generates an INDEX.LIST file in foo.jar which contains location information for each package in foo.jarClass-Path attribute of foo.jar. See the index example.

f
Specifies the file jarfile to be created (c), updated (u), extracted (x), indexed (i), or viewed (t). The -f option and filename jarfile are a pair -- if present, they must both appear. Omitting f and jarfile accepts a "jar file" from standard input (for x and t) or sends the "jar file" to standard output (for c and u).
v
Generates verbose output to standard output. Examples shown below.
0
(zero) Store without using ZIP compression.
M
Do not create a manifest file entry (for c and u), or delete a manifest file entry if one exists (for u).
m
Includes name: value attribute pairs from the specified manifest file manifest in the file at META-INF/MANIFEST.MF. A name: value pair is added unless one already exists with the same name, in which case its value is updated.

On the command line, the letters m and f must appear in the same order that manifest and jarfile appear. Example use:

jar cmf myManifestFile myFile.jar *.class
You can add special-purpose name : value attribute pairs to the manifest that aren't contained in the default manifest. For example, you can add attributes specifying vendor information, version information, package sealing, or to make JAR-bundled applications executable. See the JAR Files trail in the Java Tutorial and the Notes for Developers page for examples of using the -m option.

e
Sets entrypoint as the application entry point for stand-alone applications bundled into executable jar file. The use of this option creates or overrides the Main-Class attribute value in the manifest file. This option can be used during creation of jar file or while updating the jar file. This option specifies the application entry point without editing or creating the manifest file.

For example, this command creates Main.jar where the Main-Class attribute value in the manifest is set to Main:
jar cfe Main.jar Main Main.class

The java runtime can directly invoke this application by running the following command:

java -jar Main.jar
If the entrypoint class name is in a package it may use either a dot (".") or slash ("/") character as the delimiter. For example, if Main.class is in a package called foo the entry point can be specified in the following ways:
jar -cfe Main.jar foo/Main foo/Main.class
or
jar -cfe Main.jar foo.Main foo/Main.class
Note: specifying both -m and -e options together when the given manifest also contains the Main-Class attribute results in an ambigous Main.class specification, leading to an error and the jar creation or update operation is aborted.

-C dir
Temporarily changes directories (cd dir) during execution of the jar command while processing the following inputfiles argument. Its operation is intended to be similar to the -C option of the UNIX tar utility. For example:
jar uf foo.jar -C classes bar.class
changes to the classes directory and add the bar.class from that directory to foo.jar. The following command,
jar uf foo.jar -C classes . -C bin xyz.class
changes to the classes directory and adds to foo.jar all files within the classes directory (without creating a classes directory in the jar file), then changes back to the original directory before changing to the bin directory to add xyz.class to foo.jar. If classes holds files bar1 and bar2, then here's what the jar file contains using jar tf foo.jar:
META-INF/

META-INF/MANIFEST.MF

bar1

bar2

xyz.class

-J option
Pass option to the Java runtime environment, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xmx48M sets the maximum memory to 48 megabytes. It is a common convention for -J to pass options to the underlying runtime environment.

COMMAND LINE ARGUMENT FILES

To shorten or simplify the jar command line, you can specify one or more files that themselves contain arguments to the jar command (except -J options). This enables you to create jar commands of any length, overcoming command line limits imposed by the operating system.

An argument file can include options and filenames. The arguments within a file can be space–separated or newline-separated. Filenames within an argument file are relative to the current directory, not relative to the location of the argument file. Wildcards (*) that might otherwise be expanded by the operating system shell are not expanded. Use of the @ character to recursively interpret files is not supported. The -J options are not supported because they are passed to the launcher, which does not support argument files.

When executing jar, pass in the path and name of each argument file with the @ leading character. When jar encounters an argument beginning with the character @, it expands the contents of that file into the argument list.

For example, you can use a single argument file named classes.list to hold the names of the files:

C:\Java> dir /b *.class > classes.list

Then execute the jar command passing in the argfile:

C:\Java> jar cf my.jar @classes.list
An argument file can be passed in with a path, but any filenames inside the argument file that have relative paths are relative to the current working directory, not the path passed in. Here's such an example:
C:\Java> jar @path1/classes.list

EXAMPLES

To add all the files in a particular directory to an archive (overwriting contents if the archive already exists). Enumerating verbosely (with the v option) will tell you more information about the files in the archive, such as their size and last modified date.
C:\Java> dir
12/09/96  12:20a        <DIR>          .
12/09/96  12:17a        <DIR>          ..
12/09/96  12:18a                   946 1.au
12/09/96  12:18a                 1,039 2.au
12/09/96  12:18a                   993 3.au
12/09/96  12:19a                48,072 spacemusic.au
12/09/96  12:19a                   527 at_work.gif
12/09/96  12:19a                12,818 monkey.jpg
12/09/96  12:19a                16,242 Animator.class
12/09/96  12:20a                 3,368 Wave.class
              10 File(s)        91,118 bytes

C:\Java> jar cvf bundle.jar *
adding manifest
adding: 1.au
adding: 2.au
adding: 3.au
adding: Animator.class
adding: Wave.class
adding: at_work.gif
adding: monkey.jpg
adding: spacemusic.au
If you already have separate subdirectories for images, audio files and classes, you can combine them into a single jar file:
C:\Java> dir
12/09/96  12:11a        <DIR>          .
12/09/96  12:17a        <DIR>          ..
12/03/96  06:54p        <DIR>          audio
12/06/96  02:02p        <DIR>          images
12/09/96  12:10a        <DIR>          classes
               5 File(s)        207,360 bytes

C:\Java> jar cvf bundle.jar audio classes images
adding: audio/1.au
adding: audio/2.au
adding: audio/3.au
adding: audio/spacemusic.au
adding: classes/Animator.class
adding: classes/Wave.class
adding: images/monkey.jpg
adding: images/at_work.gif

C:\Java> dir
12/09/96  12:11a        <DIR>          .
12/09/96  12:17a        <DIR>          ..
12/09/96  12:11a               207,360 bundle.jar
12/03/96  06:54p        <DIR>          audio
12/06/96  02:02p        <DIR>          images
12/09/96  12:10a        <DIR>          classes
               6 File(s)        207,360 bytes
To see the entry names in the jarfile, use the "t" option:
C:\Java> jar tf bundle.jar
META-INF/
META-INF/MANIFEST.MF
audio/1.au
audio/2.au
audio/3.au
audio/spacemusic.au
classes/Animator.class
classes/Wave.class
images/monkey.jpg
images/at_work.gif

To add an index file to the jar file for speeding up class loading, use the -i option.

Let's say you split the inter-dependent classes for a stock trade application, into three jar files: main.jar, buy.jar, and sell.jar. If you specify the Class-path attribute in the main.jar manifest as:
Class-Path: buy.jar sell.jar
then you can use the -i option to speed up your application's class loading time:
C:\Java> jar i main.jar
An INDEX.LIST file is inserted to the META-INF directory which will enable the application class loader to download the specified jar files when it is searching for classes or resources.

SEE ALSO

The Jar Overview
The Jar File Specification
The JarIndex Spec
Jar Tutorial on the Java Software web site.
pack200 Reference Page

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jarsigner - JAR Signing and Verification Tool

Generates signatures for Java ARchive (JAR) files, and verifies the signatures of signed JAR files.

SYNOPSIS

jarsigner [ options ] jar-file alias
jarsigner -verify [ options ] jar-file

DESCRIPTION

The jarsigner tool is used for two purposes:
  1. to sign Java ARchive (JAR) files, and
  2. to verify the signatures and integrity of signed JAR files.

The JAR feature enables the packaging of class files, images, sounds, and other digital data in a single file for faster and easier distribution. A tool named jar enables developers to produce JAR files. (Technically, any zip file can also be considered a JAR file, although when created by jar or processed by jarsigner, JAR files also contain a META-INF/MANIFEST.MF file.)

A digital signature is a string of bits that is computed from some data (the data being "signed") and the private key of an entity (a person, company, etc.). Like a handwritten signature, a digital signature has many useful characteristics:

  • Its authenticity can be verified, via a computation that uses the public key corresponding to the private key used to generate the signature.
  • It cannot be forged, assuming the private key is kept secret.
  • It is a function of the data signed and thus can't be claimed to be the signature for other data as well.
  • The signed data cannot be changed; if it is, the signature will no longer verify as being authentic.

In order for an entity's signature to be generated for a file, the entity must first have a public/private key pair associated with it, and also one or more certificates authenticating its public key. A certificate is a digitally signed statement from one entity, saying that the public key of some other entity has a particular value.

jarsigner uses key and certificate information from a keystore to generate digital signatures for JAR files. A keystore is a database of private keys and their associated X.509 certificate chains authenticating the corresponding public keys. The keytool utility is used to create and administer keystores.

jarsigner uses an entity's private key to generate a signature. The signed JAR file contains, among other things, a copy of the certificate from the keystore for the public key corresponding to the private key used to sign the file. jarsigner can verify the digital signature of the signed JAR file using the certificate inside it (in its signature block file).

Starting in J2SE 5.0, jarsigner can generate signatures that include a timestamp, thus enabling systems/deployer (including Java Plug-in) to check whether the JAR file was signed while the signing certificate was still valid. In addition, APIs were added in J2SE 5.0 to allow applications to obtain the timestamp information.

At this time, jarsigner can only sign JAR files created by the SDK jar tool or zip files. (JAR files are the same as zip files, except they also have a META-INF/MANIFEST.MF file. Such a file will automatically be created when jarsigner signs a zip file.)

The default jarsigner behavior is to sign a JAR (or zip) file. Use the -verify option to instead have it verify a signed JAR file.

Compatibility with JDK 1.1

The keytool and jarsigner tools completely replace the javakey tool provided in JDK 1.1. These new tools provide more features than javakey, including the ability to protect the keystore and private keys with passwords, and the ability to verify signatures in addition to generating them.

The new keystore architecture replaces the identity database that javakey created and managed. There is no backwards compatibility between the keystore format and the database format used by javakey in 1.1. However,

  • It is possible to import the information from an identity database into a keystore, via the keytool -identitydb command.
  • jarsigner can sign JAR files also previously signed using javakey.
  • jarsigner can verify JAR files signed using javakey. Thus, it recognizes and can work with signer aliases that are from a JDK 1.1 identity database rather than a Java 2 SDK keystore.
The following table explains how JAR files that were signed in JDK 1.1.x are treated in the Java 2 platform.

JAR File Type

Identity in 1.1 database

Trusted Identity imported into Java 2 Platform keystore from 1.1 database (4)

Policy File grants privileges to Identity/Alias

Privileges Granted

Signed JAR

NO

NO

NO

Default privileges granted to all code.

Unsigned JAR

NO

NO

NO

Default privileges granted to all code.

Signed JAR

NO

YES

NO

Default privileges granted to all code.

Signed JAR

YES/Untrusted

NO

NO

Default privileges granted to all code. (3)

Signed JAR

YES/Untrusted

NO

YES

Default privileges granted to all code. (1,3)

Signed JAR

NO

YES

YES

Default privileges granted to all code plus privileges granted in policy file.

Signed JAR

YES/Trusted

YES

YES

Default privileges granted to all code plus privileges granted in policy file. (2)

Signed JAR

YES/Trusted

NO

NO

All privileges

Signed JAR

YES/Trusted

YES

NO

All privileges (1)

Signed JAR

YES/Trusted

NO

YES

All privileges (1)

Notes:

  1. If an identity/alias is mentioned in the policy file, it must be imported into the keystore for the policy file to have any effect on privileges granted.
  2. The policy file/keystore combination has precedence over a trusted identity in the identity database.
  3. Untrusted identities are ignored in the Java 2 platform.
  4. Only trusted identities can be imported into Java 2 SDK keystores.

Keystore Aliases

All keystore entities are accessed via unique aliases.

When using jarsigner to sign a JAR file, you must specify the alias for the keystore entry containing the private key needed to generate the signature. For example, the following will sign the JAR file named "MyJARFile.jar", using the private key associated with the alias "duke" in the keystore named "mystore" in the "working" directory. Since no output file is specified, it overwrites MyJARFile.jar with the signed JAR file.

    jarsigner -keystore /working/mystore -storepass myspass
      -keypass dukekeypasswd MyJARFile.jar duke

Keystores are protected with a password, so the store password (in this case "myspass") must be specified. You will be prompted for it if you don't specify it on the command line. Similarly, private keys are protected in a keystore with a password, so the private key's password (in this case "dukekeypasswd") must be specified, and you will be prompted for it if you don't specify it on the command line and it isn't the same as the store password.

Keystore Location

jarsigner has a -keystore option for specifying the URL of the keystore to be used. The keystore is by default stored in a file named .keystore in the user's home directory, as determined by the user.home system property. On Solaris systems user.home defaults to the user's home directory.

Note that the input stream from the -keystore option is passed to the KeyStore.load method. If NONE is specified as the URL, then a null stream is passed to the KeyStore.load method. NONE should be specified if the KeyStore is not file-based, for example, if it resides on a hardware token device.

Keystore Implementation

The KeyStore class provided in the java.security package supplies well-defined interfaces to access and modify the information in a keystore. It is possible for there to be multiple different concrete implementations, where each implementation is that for a particular type of keystore.

Currently, there are two command-line tools that make use of keystore implementations (keytool and jarsigner), and also a GUI-based tool named Policy Tool. Since KeyStore is publicly available, Java 2 SDK users can write additional security applications that use it.

There is a built-in default implementation, provided by Sun Microsystems. It implements the keystore as a file, utilizing a proprietary keystore type (format) named "JKS". It protects each private key with its individual password, and also protects the integrity of the entire keystore with a (possibly different) password.

Keystore implementations are provider-based. More specifically, the application interfaces supplied by KeyStore are implemented in terms of a "Service Provider Interface" (SPI). That is, there is a corresponding abstract KeystoreSpi class, also in the java.security package, which defines the Service Provider Interface methods that "providers" must implement. (The term "provider" refers to a package or a set of packages that supply a concrete implementation of a subset of services that can be accessed by the Java Security API.) Thus, to provide a keystore implementation, clients must implement a provider and supply a KeystoreSpi subclass implementation, as described in How to Implement a Provider for the Java Cryptography Architecture.

Applications can choose different types of keystore implementations from different providers, using the "getInstance" factory method supplied in the KeyStore class. A keystore type defines the storage and data format of the keystore information, and the algorithms used to protect private keys in the keystore and the integrity of the keystore itself. Keystore implementations of different types are not compatible.

keytool works on any file-based keystore implementation. (It treats the keytore location that is passed to it at the command line as a filename and converts it to a FileInputStream, from which it loads the keystore information.) The jarsigner and policytool tools, on the other hand, can read a keystore from any location that can be specified using a URL.

For jarsigner and keytool, you can specify a keystore type at the command line, via the -storetype option. For Policy Tool, you can specify a keystore type via the "Change Keystore" command in the Edit menu.

If you don't explicitly specify a keystore type, the tools choose a keystore implementation based simply on the value of the keystore.type property specified in the security properties file. The security properties file is called java.security, and it resides in the SDK security properties directory, java.home/lib/security, where java.home is the runtime environment's directory (the jre directory in the SDK or the top-level directory of the Java 2 Runtime Environment).

Each tool gets the keystore.type value and then examines all the currently-installed providers until it finds one that implements keystores of that type. It then uses the keystore implementation from that provider.

The KeyStore class defines a static method named getDefaultType that lets applications and applets retrieve the value of the keystore.type property. The following line of code creates an instance of the default keystore type (as specified in the keystore.type property):

    KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());

The default keystore type is "jks" (the proprietary type of the keystore implementation provided by Sun). This is specified by the following line in the security properties file:

    keystore.type=jks

Note: Case doesn't matter in keystore type designations. For example, "JKS" would be considered the same as "jks".

To have the tools utilize a keystore implementation other than the default, change that line to specify a different keystore type. For example, if you have a provider package that supplies a keystore implementation for a keystore type called "pkcs12", change the line to

    keystore.type=pkcs12

Note that if you us the PKCS#11 provider package, you should refer to the KeyTool and JarSigner section of the Java PKCS#11 Reference Guide for details.

Supported Algorithms

By default, jarsigner signs a JAR file using either

  • DSA (Digital Signature Algorithm) with the SHA-1 digest algorithm, or
  • the RSA algorithm with the MD5 digest algorithm.

That is, if the signer's public and private keys are DSA keys, jarsigner will sign the JAR file using the "SHA1withDSA" algorithm. If the signer's keys are RSA keys, jarsigner will attempt to sign the JAR file using the "MD5withRSA" algorithm.

These default signature algorithms can be overridden using the -sigalg option.

The Signed JAR File

When jarsigner is used to sign a JAR file, the output signed JAR file is exactly the same as the input JAR file, except that it has two additional files placed in the META-INF directory:

  • a signature file, with a .SF extension, and
  • a signature block file, with a .DSA extension.
The base file names for these two files come from the value of the -sigFile option. For example, if the option appears as
  -sigFile MKSIGN
the files are named "MKSIGN.SF" and "MKSIGN.DSA".

If no -sigfile option appears on the command line, the base file name for the .SF and .DSA files will be the first 8 characters of the alias name specified on the command line, all converted to upper case. If the alias name has fewer than 8 characters, the full alias name is used. If the alias name contains any characters that are not allowed in a signature file name, each such character is converted to an underscore ("_") character in forming the file name. Legal characters include letters, digits, underscores, and hyphens.

The Signature (.SF) File

A signature file (the .SF file) looks similar to the manifest file that is always included in a JAR file when jarsigner is used to sign the file. That is, for each source file included in the JAR file, the .SF file has three lines, just as in the manifest file, listing the following:
  • the file name,
  • the name of the digest algorithm used (SHA), and
  • a SHA digest value.
In the manifest file, the SHA digest value for each source file is the digest (hash) of the binary data in the source file. In the .SF file, on the other hand, the digest value for a given source file is the hash of the three lines in the manifest file for the source file.

The signature file also, by default, includes a header containing a hash of the whole manifest file. The presence of the header enables verification optimization, as described in JAR File Verification.

The Signature Block (.DSA) File

The .SF file is signed and the signature is placed in the .DSA file. The .DSA file also contains, encoded inside it, the certificate or certificate chain from the keystore which authenticates the public key corresponding to the private key used for signing.

Signature Timestamp

As of the J2SE 5.0 release, the jarsigner tool can now generate and store a signature timestamp when signing a JAR file. In addition, jarsigner supports alternative signing mechanisms. This behavior is optional and is controlled by the user at the time of signing through these options:
  • -tsa url
  • -tsacert alias
  • -altsigner class
  • -altsignerpath classpathlist
Each of these options is detailed in the Options section below.

JAR File Verification

A successful JAR file verification occurs if the signature(s) are valid, and none of the files that were in the JAR file when the signatures were generated have been changed since then. JAR file verification involves the following steps:

  1. Verify the signature of the .SF file itself.

    That is, the verification ensures that the signature stored in each signature block (.DSA) file was in fact generated using the private key corresponding to the public key whose certificate (or certificate chain) also appears in the .DSA file. It also ensures that the signature is a valid signature of the corresponding signature (.SF) file, and thus the .SF file has not been tampered with.

  2. Verify the digest listed in each entry in the .SF file with each corresponding section in the manifest.

    The .SF file by default includes a header containing a hash of the entire manifest file. When the header is present, then the verification can check to see whether or not the hash in the header indeed matches the hash of the manifest file. If that is the case, verification proceeds to the next step.

    If that is not the case, a less optimized verification is required to ensure that the hash in each source file information section in the .SF file equals the hash of its corresponding section in the manifest file (see The Signature (.SF) File).

    One reason the hash of the manifest file that is stored in the .SF file header may not equal the hash of the current manifest file would be because one or more files were added to the JAR file (using the jar tool) after the signature (and thus the .SF file) was generated. When the jar tool is used to add files, the manifest file is changed (sections are added to it for the new files), but the .SF file is not. A verification is still considered successful if none of the files that were in the JAR file when the signature was generated have been changed since then, which is the case if the hashes in the non-header sections of the .SF file equal the hashes of the corresponding sections in the manifest file.

  3. Read each file in the JAR file that has an entry in the .SF file. While reading, compute the file's digest, and then compare the result with the digest for this file in the manifest section. The digests should be the same, or verification fails.

If any serious verification failures occur during the verification process, the process is stopped and a security exception is thrown. It is caught and displayed by jarsigner.

Multiple Signatures for a JAR File

A JAR file can be signed by multiple people simply by running the jarsigner tool on the file multiple times, specifying the alias for a different person each time, as in:
  jarsigner myBundle.jar susan
  jarsigner myBundle.jar kevin
When a JAR file is signed multiple times, there are multiple .SF and .DSA files in the resulting JAR file, one pair for each signature. Thus, in the example above, the output JAR file includes files with the following names:
  SUSAN.SF
  SUSAN.DSA
  KEVIN.SF
  KEVIN.DSA
Note: It is also possible for a JAR file to have mixed signatures, some generated by the JDK 1.1 javakey tool and others by jarsigner. That is, jarsigner can be used to sign JAR files already previously signed using javakey.

OPTIONS

The various jarsigner options are listed and described below. Note:

  • All option names are preceded by a minus sign (-).
  • The options may be provided in any order.
  • Items in italics (option values) represent the actual values that must be supplied.
  • The -keystore, -storepass, -keypass, -sigfile, -sigalg, -digestalg, and -signedjar options are only relevant when signing a JAR file, not when verifying a signed JAR file. Similarly, an alias is only specified on the command line when signing a JAR file.
-keystore url
Specifies the URL that tells the keystore location. This defaults to the file .keystore in the user's home directory, as determined by the "user.home" system property.

A keystore is required when signing, so you must explicitly specify one if the default keystore does not exist (or you want to use one other than the default).

A keystore is not required when verifying, but if one is specified, or the default exists, and the -verbose option was also specified, additional information is output regarding whether or not any of the certificates used to verify the JAR file are contained in that keystore.

Note: the -keystore argument can actually be a file name (and path) specification rather than a URL, in which case it will be treated the same as a "file:" URL. That is,

  -keystore filePathAndName
is treated as equivalent to
  -keystore file:filePathAndName
If the Sun PKCS#11 provider has been configured in the java.security security properties file (located in the JRE's $JAVA_HOME/lib/security directory), then keytool and jarsigner can operate on the PKCS#11 token by specifying these options:
  • -keystore NONE
  • -storetype PKCS11
For example, this command lists the contents of the configured PKCS#11 token:
   jarsigner -keystore NONE -storetype PKCS11 -list
-storetype storetype
Specifies the type of keystore to be instantiated. The default keystore type is the one that is specified as the value of the "keystore.type" property in the security properties file, which is returned by the static getDefaultType method in java.security.KeyStore.

The PIN for a PCKS#11 token can also be specified using the -storepass option. If none has been specified, keytool and jarsigner will prompt for the token PIN. If the token has a protected authentication path (such as a dedicated PIN-pad or a biometric reader), then the -protected option must be specified and no password options can be specified.

-storepass password
Specifies the password which is required to access the keystore. This is only needed when signing (not verifying) a JAR file. In that case, if a -storepass option is not provided at the command line, the user is prompted for the password.

Note: The password shouldn't be specified on the command line or in a script unless it is for testing purposes, or you are on a secure system.

-keypass password
Specifies the password used to protect the private key of the keystore entry addressed by the alias specified on the command line. The password is required when using jarsigner to sign a JAR file. If no password is provided on the command line, and the required password is different from the store password, the user is prompted for it.

Note: The password shouldn't be specified on the command line or in a script unless it is for testing purposes, or you are on a secure system.

-sigfile file
Specifies the base file name to be used for the generated .SF and .DSA files. For example, if file is "DUKESIGN", the generated .SF and .DSA files will be named "DUKESIGN.SF" and "DUKESIGN.DSA", and will be placed in the "META-INF" directory of the signed JAR file.

The characters in file must come from the set "a-zA-Z0-9_-". That is, only letters, numbers, underscore, and hyphen characters are allowed. Note: All lowercase characters will be converted to uppercase for the .SF and .DSA file names.

If no -sigfile option appears on the command line, the base file name for the .SF and .DSA files will be the first 8 characters of the alias name specified on the command line, all converted to upper case. If the alias name has fewer than 8 characters, the full alias name is used. If the alias name contains any characters that are not legal in a signature file name, each such character is converted to an underscore ("_") character in forming the file name.

-sigalg algorithm
Specifies the name of the signature algorithm to use to sign the JAR file.

See Appendix A of the Java Cryptography Architecture for a list of standard signature algorithm names. This algorithm must be compatible with the private key used to sign the JAR file. If this option is not specified, SHA1withDSA or MD5withRSA will be used depending on the type of private key. There must either be a statically installed provider supplying an implementation of the specified algorithm or the user must specify one with the -providerClass option, otherwise the command will not succeed.

-digestalg algorithm
Specifies the name of the message digest algorithm to use when digesting the entries of a jar file.

See Appendix A of the Java Cryptography Architecture for a list of standard message digest algorithm names. If this option is not specified, SHA-1 will be used. There must either be a statically installed provider supplying an implementation of the specified algorithm or the user must specify one with the -providerClass option, otherwise the command will not succeed.

-signedjar file
Specifies the name to be used for the signed JAR file.

If no name is specified on the command line, the name used is the same as the input JAR file name (the name of the JAR file to be signed); in other words, that file is overwritten with the signed JAR file.

-verify
If this appears on the command line, the specified JAR file will be verified, not signed. If the verification is successful, "jar verified" will be displayed. If you try to verify an unsigned JAR file, or a JAR file signed with an unsupported algorithm (e.g., RSA when you don't have an RSA provider installed), the following is displayed: "jar is unsigned. (signatures missing or not parsable)"

It is possible to verify JAR files signed using either jarsigner or the JDK 1.1 javakey tool, or both.

For further information on verification, see JAR File Verification.

-certs
If this appears on the command line, along with the -verify and -verbose options, the output includes certificate information for each signer of the JAR file. This information includes
  • the name of the type of certificate (stored in the .DSA file) that certifies the signer's public key
  • if the certificate is an X.509 certificate (more specifically, an instance of java.security.cert.X509Certificate): the distinguished name of the signer

The keystore is also examined. If no keystore value is specified on the command line, the default keystore file (if any) will be checked. If the public key certificate for a signer matches an entry in the keystore, then the following information will also be displayed:

  • in parentheses, the alias name for the keystore entry for that signer. If the signer actually comes from a JDK 1.1 identity database instead of from a keystore, the alias name will appear in brackets instead of parentheses.
-verbose
If this appears on the command line, it indicates "verbose" mode, which causes jarsigner to output extra information as to the progress of the JAR signing or verification.
-internalsf
In the past, the .DSA (signature block) file generated when a JAR file was signed used to include a complete encoded copy of the .SF file (signature file) also generated. This behavior has been changed. To reduce the overall size of the output JAR file, the .DSA file by default doesn't contain a copy of the .SF file anymore. But if -internalsf appears on the command line, the old behavior is utilized. This option is mainly useful for testing; in practice, it should not be used, since doing so eliminates a useful optimization.
-sectionsonly
If this appears on the command line, the .SF file (signature file) generated when a JAR file is signed does not include a header containing a hash of the whole manifest file. It just contains information and hashes related to each individual source file included in the JAR file, as described in The Signature (.SF) File .

By default, this header is added, as an optimization. When the header is present, then whenever the JAR file is verified, the verification can first check to see whether or not the hash in the header indeed matches the hash of the whole manifest file. If so, verification proceeds to the next step. If not, it is necessary to do a less optimized verification that the hash in each source file information section in the .SF file equals the hash of its corresponding section in the manifest file.

For further information, see JAR File Verification.

This option is mainly useful for testing; in practice, it should not be used, since doing so eliminates a useful optimization.

-provider provider-class-name
Used to specify the name of cryptographic service provider's master class file when the service provider is not listed in the security properties file, java.security.

Used in conjunction with the -providerArg ConfigFilePath option, keytool and jarsigner will install the provider dynamically (where ConfigFilePath is the path to the token configuration file). Here's an example of a command to list a PKCS#11 keystore when the Sun PKCS#11 provider has not been configured in the security properties file.

jarsigner -keystore NONE -storetype PKCS11 \
          -providerClass sun.security.pkcs11.SunPKCS11 \
          -providerArg /foo/bar/token.config \
          -list
-providerName providerName
If more than one provider has been configured in the java.security security properties file, you can use the -providerName option to target a specific provider instance. The argument to this option is the name of the provider.

For the Sun PKCS#11 provider, providerName is of the form SunPKCS11-TokenName, where TokenName is the name suffix that the provider instance has been configured with, as detailed in the configuration attributes table. For example, the following command lists the contents of the PKCS#11 keystore provider instance with name suffix SmartCard:

jarsigner -keystore NONE -storetype PKCS11 \
        -providerName SunPKCS11-SmartCard \
        -list
-J javaoption
Passes through the specified javaoption string directly to the Java interpreter. (jarsigner is actually a "wrapper" around the interpreter.) This option should not contain any spaces. It is useful for adjusting the execution environment or memory usage. For a list of possible interpreter options, type java -h or java -X at the command line.

-tsa url
If "-tsa http://example.tsa.url" appears on the command line when signing a JAR file then a timestamp is generated for the signature. The URL, http://example.tsa.url, identifies the location of the Time Stamping Authority (TSA). It overrides any URL found via the -tsacert option. The -tsa option does not require the TSA's public key certificate to be present in the keystore.

To generate the timestamp, jarsigner communicates with the TSA using the Time-Stamp Protocol (TSP) defined in RFC 3161. If successful, the timestamp token returned by the TSA is stored along with the signature in the signature block file.

-tsacert alias
If "-tsacert alias" appears on the command line when signing a JAR file then a timestamp is generated for the signature. The alias identifies the TSA's public key certificate in the keystore that is currently in effect. The entry's certificate is examined for a Subject Information Access extension that contains a URL identifying the location of the TSA.

The TSA's public key certificate must be present in the keystore when using -tsacert.

-altsigner class
Specifies that an alternative signing mechanism be used. The fully-qualified class name identifies a class file that extends the com.sun.jarsigner.ContentSigner abstract class. The path to this class file is defined by the -altsignerpath option. If the -altsigner option is used, jarsigner uses the signing mechanism provided by the specified class. Otherwise, jarsigner uses its default signing mechanism.

For example, to use the signing mechanism provided by a class named com.sun.sun.jarsigner.AuthSigner, use the jarsigner option "-altsigner com.sun.jarsigner.AuthSigner"

-altsignerpath classpathlist
Specifies the path to the class file (the class file name is specified with the -altsigner option described above) and any JAR files it depends on. If the class file is in a JAR file, then this specifies the path to that JAR file, as shown in the example below.

An absolute path or a path relative to the current directory may be specified. If classpathlist contains multiple paths or JAR files, they should be separated with a colon (:) on Solaris and a semi-colon (;) on Windows. This option is not necessary if the class is already in the search path.

Example of specifying the path to a jar file that contains the class file:

-altsignerpath /home/user/lib/authsigner.jar
Note that the JAR file name is included.

Example of specifying the path to the jar file that contains the class file:

-altsignerpath /home/user/classes/com/sun/tools/jarsigner/
Note that the JAR file name is omitted.

EXAMPLES

Signing a JAR File

Suppose you have a JAR file named "bundle.jar" and you'd like to sign it using the private key of the user whose keystore alias is "jane" in the keystore named "mystore" in the "working" directory. Suppose the keystore password is "myspass" and the password for jane's private key is "j638klm". You can use the following to sign the JAR file and name the signed JAR file "sbundle.jar":

    jarsigner -keystore /working/mystore -storepass myspass
      -keypass j638klm -signedjar sbundle.jar bundle.jar jane

Note that there is no -sigfile specified in the command above, so the generated .SF and .DSA files to be placed in the signed JAR file will have default names based on the alias name. That is, they will be named JANE.SF and JANE.DSA.

If you want to be prompted for the store password and the private key password, you could shorten the above command to

    jarsigner -keystore /working/mystore
      -signedjar sbundle.jar bundle.jar jane
If the keystore to be used is the default keystore (the one named ".keystore" in your home directory), you don't need to specify a keystore, as in:
    jarsigner -signedjar sbundle.jar bundle.jar jane
Finally, if you want the signed JAR file to simply overwrite the input JAR file (bundle.jar), you don't need to specify a -signedjar option:
    jarsigner bundle.jar jane

Verifying a Signed JAR File

To verify a signed JAR file, that is, to verify that the signature is valid and the JAR file has not been tampered with, use a command such as the following:
    jarsigner -verify sbundle.jar

If the verification is successful,

    jar verified.
is displayed. Otherwise, an error message appears.

You can get more information if you use the -verbose option. A sample use of jarsigner with the -verbose option is shown below, along with sample output:

    jarsigner -verify -verbose sbundle.jar

           198 Fri Sep 26 16:14:06 PDT 1997 META-INF/MANIFEST.MF
           199 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.SF
          1013 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.DSA
    smk   2752 Fri Sep 26 16:12:30 PDT 1997 AclEx.class
    smk    849 Fri Sep 26 16:12:46 PDT 1997 test.class

      s = signature was verified
      m = entry is listed in manifest
      k = at least one certificate was found in keystore

    jar verified.

Verification with Certificate Information

If you specify the -certs option when verifying, along with the -verify and -verbose options, the output includes certificate information for each signer of the JAR file, including the certificate type, the signer distinguished name information (iff it's an X.509 certificate), and, in parentheses, the keystore alias for the signer if the public key certificate in the JAR file matches that in a keystore entry. For example,
    jarsigner -keystore /working/mystore -verify -verbose -certs myTest.jar

           198 Fri Sep 26 16:14:06 PDT 1997 META-INF/MANIFEST.MF
           199 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.SF
          1013 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.DSA
           208 Fri Sep 26 16:23:30 PDT 1997 META-INF/JAVATEST.SF
          1087 Fri Sep 26 16:23:30 PDT 1997 META-INF/JAVATEST.DSA
    smk   2752 Fri Sep 26 16:12:30 PDT 1997 Tst.class

      X.509, CN=Test Group, OU=Java Software, O=Sun Microsystems, L=CUP, S=CA, C=US (javatest)
      X.509, CN=Jane Smith, OU=Java Software, O=Sun, L=cup, S=ca, C=us (jane)

      s = signature was verified
      m = entry is listed in manifest
      k = at least one certificate was found in keystore

    jar verified.
If the certificate for a signer is not an X.509 certificate, there is no distinguished name information. In that case, just the certificate type and the alias are shown. For example, if the certificate is a PGP certificate, and the alias is "bob", you'd get
      PGP, (bob)

Verification of a JAR File that Includes Identity Database Signers

If a JAR file has been signed using the JDK 1.1 javakey tool, and thus the signer is an alias in an identity database, the verification output includes an "i" symbol. If the JAR file has been signed by both an alias in an identity database and an alias in a keystore, both "k" and "i" appear.

When the -certs option is used, any identity database aliases are shown in square brackets rather than the parentheses used for keystore aliases. For example:

    jarsigner -keystore /working/mystore -verify -verbose -certs writeFile.jar

           198 Fri Sep 26 16:14:06 PDT 1997 META-INF/MANIFEST.MF
           199 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.SF
          1013 Fri Sep 26 16:22:10 PDT 1997 META-INF/JANE.DSA
           199 Fri Sep 27 12:22:30 PDT 1997 META-INF/DUKE.SF
          1013 Fri Sep 27 12:22:30 PDT 1997 META-INF/DUKE.DSA
   smki   2752 Fri Sep 26 16:12:30 PDT 1997 writeFile.html

      X.509, CN=Jane Smith, OU=Java Software, O=Sun, L=cup, S=ca, C=us (jane)
      X.509, CN=Duke, OU=Java Software, O=Sun, L=cup, S=ca, C=us [duke]

      s = signature was verified
      m = entry is listed in manifest
      k = at least one certificate was found in keystore
      i = at least one certificate was found in identity scope

    jar verified.
Note that the alias "duke" is in brackets to denote that it is an identity database alias, not a keystore alias.

SEE ALSO

  • jar tool documentation
  • keytool tool documentation
  • the Security trail of the Java Tutorial for examples of the use of the jarsigner tool

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


java - the Java application launcher

  • Synopsis
  • Description
  • Options
  • See Also

SYNOPSIS

    java [ options ] class [ argument ... ]
    java [ options ] -jar file.jar [ argument ... ]
    javaw [ options ] class [ argument ... ]
    javaw [ options ] -jar file.jar [ argument ... ]
options
Command-line options.
class
Name of the class to be invoked.
file.jar
Name of the jar file to be invoked. Used only with -jar.
argument
Argument passed to the main function.

DESCRIPTION

The java tool launches a Java application. It does this by starting a Java runtime environment, loading a specified class, and invoking that class's main method.

The method must be declared public and static, it must not return any value, and it must accept a String array as a para meter. The method declaration must look like the following:

    public static void main(String args[])
By default, the first non-option argument is the name of the class to be invoked. A fully-qualified class name should be used. If the -jar option is specified, the first non-option argume nt is the name of a JAR archive containing class and resource f iles for the application, with the startup class indicated by the Main-Class manifest header.

The Java runtime searches for the startup class, and other classes used, in three sets of locations: the bootstrap class path, the installed extensions, and the user class path.

Non-option arguments after the class name or JAR file name are passed to the main function.

The javaw command is identical to java, except that with javaw there is no associated console window. Use javaw when you don't want a command prompt window to appear. The javaw launcher will, however, display a dialog box with error information if a launch fails for some reason.

OPTIONS

The launcher has a set of standard options that are supported on the current runtime environment and will be supported in future releases. In addition, the default Java HotSpot VMs provide a set of non-standard options that are subject to change in future releases.

Standard Options

-client

Select the Java HotSpot Client VM. A 64-bit capable jdk currently ignores this option and instead uses the Java HotSpot Server VM.

For default VM selection, see Server-Class Machine Detection

-server

Select the Java HotSpot Server VM. On a 64-bit capable jdk only the Java HotSpot Server VM is supported so the -server option is implicit. This is subject to change in a future release.

For default VM selection, see Server-Class Machine Detection

-agentlib:libname[=options]
Load native agent library libname, e.g.

-agentlib:hprof

-agentlib:jdwp=help

-agentlib:hprof=help

For more information, see JVMTI Agent Command Line Options.

-agentpath:pathname[=options]
Load a native agent library by full pathname. For more information, see JVMTI Agent Command Line Options.
-classpath classpath
-cp classpath
Specify a list of directories, JAR archives, and ZIP archives to search for class files. Class path entries are separated by semicolons (;). Specifying -classpath or -cp overrides any setting of the CLASSPATH environment variable.

If -classpath and -cp are not used and CLASSPATH is not set, the user class path consists of the current directory (.).

As a special convenience, a class path element containing a basename of * is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR (a java program cannot tell the difference between the two invocations).

For example, if directory foo contains a.jar and b.JAR, then the class path element foo/* is expanded to a A.jar:b.JAR, except that the order of jar files is unspecified. All jar files in the specified directory, even hidden ones, are included in the list. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. The CLASSPATH environment variable, where defined, will be similarly expanded. Any classpath wildcard expansion occurs before the Java virtual machine is started -- no Java program will ever see unexpanded wildcards except by querying the environment. For example; by invoking System.getenv("CLASSPATH").

For more information on class paths, see Setting the Class Path.

-D property=value
Set a system property value. If value is a string that contains spaces, you must enclose the string in double quotes:
        java -Dfoo="some string" SomeClass
-enableassertions[:<package name>"..." | :<class name> ]
-ea[:<package name>"..." | :<class name> ]
Enable assertions. Assertions are disabled by default.

With no arguments, enableassertions or -ea enables assertions. With one argument ending in "...", the switch enables assertions in the specified package and any subpackages. If the argument is simply "...", the switch enables assertions in the unnamed package in the current working directory. With one argument not ending in "...", the switch enables assertions in the specified class.

If a single command line contains multiple instances of these switches, they are processed in order before loading any classes. So, for example, to run a program with assertions enabled only in package com.wombat.fruitbat (and any subpackages), the following command could be used:

java -ea:com.wombat.fruitbat... <Main Class>

The -enableassertions and -ea switches apply to all s loaders and to system classes (which do not have a class loader). There is one exception to this rule: in their no-argument form, the switches do not apply to system. This makes it easy to turn on asserts in all classes except for system classes. A separate switch is provided to enable asserts in all system classes; see -enablesystemassertions below.

-disableassertions[:<package name>"..." | :<class ; ]
-da[:<package name>"..." | :<class name> ]
Disable assertions. This is the default.

With no arguments, disableassertions or -da disables assertions. With one argument ending in "...", the switch disables assertions in the specified package and any subpackages. If the argument is simply "...", the switch disables assertions in the unnamed package in the rent working directory. With one argument not ending in "...", the switch disables assertions in the specified class.

To run a program with assertions enabled in package com.wombat.fruitbat but disabled in class com.wombat.fruitbat.Brickbat, the following command could be used:

java -ea:com.wombat.fruitbat... -da:com.wombat.fruitbat.Brickbat lt;Main Class>

The -disableassertions and -da switches apply to all ss loaders and to system classes (which do not have a class loader). There is one exception to this rule: in their no-argument form, the switches do not apply to system. This makes it easy to turn on asserts in all classes except for system classes. A separate switch is provided to enable asserts in all system classes; see -disablesystemassertions below.

-enablesystemassertions
-esa
Enable asserts in all system classes (sets the default assertion status for system classes to true).
-disablesystemassertions
-dsa
Disables asserts in all system classes.

-jar
Execute a program encapsulated in a JAR file. The first argument is the name of a JAR file instead of a startup class name. In order for this option to work, the manifest of the JAR file must contain a line of the form Main-Class: classname. Here, classname identifies the class having the public static void main(String[] args) method that serves as your application's starting point. See the Jar tool reference page and the Jar trail of the Java Tutorial for information about working with Jar files and Jar-file manifests.

When you use this option, the JAR file is the source of all user classes, and other user class path settings are ignored.

-javaagent:jarpath[=options]
Load a Java programming language agent, see java.lang.instrument.
-verbose
-verbose:class
Display information about each class loaded.
-verbose:gc
Report on each garbage collection event.
-verbose:jni
Report information about use of native methods and other Java Native Interface activity.
-version
Display version information and exit.
-version:release
Specifies that the version specified by release is required by the class or jar file specified on the command line. If the version of the java command invoked does not meet this specification and an appropriate implementation is found on the system, the appropriate implementation will be used.

release not only can specify an exact version, but can also specify a list of versions called a version string. A version string is an ordered list of version ranges separated by spaces. A version range is either a version-id, a version-id followed by a star (*), a version-id followed by a plus sign (+) , or two version-ranges combined using an ampersand (&). The star means prefix match, the plus sign means this version or greater, and the ampersand means the logical anding of the two version-ranges. For example:

-version:"1.5.0_04 1.5*&1.5.1_02+"
The meaning of the above is that the class or jar file requires either version 1.5.0_02, or a version with 1.5 as a version-id prefix and that is not less than 1.5.1_02. The exact syntax and definition of version strings may be found in Appendix A of the Java Network Launching Protocol & API Specification (JSR-56).

For jar files, the usual preference is to specify version requirements in the jar file manifest rather than on the command line.

See the following NOTES section for important policy information on the use of this option.

-showversion
Display version information and continue.
-?
-help
Display usage information and exit.
-X
Display information about non-standard options and exit.

Non-Standard Options

-Xint
Operate in interpreted-only mode. Compilation to native code is disabled, and all bytecodes are executed by the interpreter. The performance benefits offered by the Java HotSpot Client VM's adaptive compiler will not be present in this mode.
-Xbatch
Disable background compilation. Normally the VM will compile the method as a background task, running the method in interpreter mode until the background compilation is finished. The -Xbatch flag disables background compilation so that compilation of all methods proceeds as a foreground task until completed.
-Xbootclasspath:bootclasspath
Specify a semicolon-separated list of directories, JAR archives, and ZIP archives to search for boot class files. These are used in place of the boot class files included in the Java 2 SDK. Note: Applications that use this option for the purpose of overriding a class in rt.jar should not be deployed as doing so would contravene the Java 2 Runtime Environment binary code license.
-Xbootclasspath/a:path
Specify a semicolon-separated path of directires, JAR archives, and ZIP archives to append to the default bootstrap class path.
-Xbootclasspath/p:path
Specify a semicolon-separated path of directires, JAR archives, and ZIP archives to prepend in front of the default bootstrap class path. Note: Applications that use this option for the purpose of overriding a class in rt.jar should not be deployed as doing so would contravene the Java 2 Runtime Environment binary code license.
-Xcheck:jni
Perform additional checks for Java Native Interface (JNI) functions. Specifically, the Java Virtual Machine validates the parameters passed to the JNI function as well as the runtime environment data before processing the JNI request. Any invalid data encountered indicates a problem in the native code, and the Java Virtual Machine will terminate with a fatal error in such cases. Expect a performance degradation when this option is used.
-Xfuture
Perform strict class-file format checks. For purposes of backwards compatibility, the default format checks performed by the Java 2 SDK's virtual machine are no stricter than the checks performed by 1.1.x versions of the JDK software. The -Xfuture flag turns on stricter class-file format checks that enforce closer conformance to the class-file format specification. Developers are encouraged to use this flag when developing new code because the stricter checks will become the default in future releases of the Java application launcher.
-Xnoclassgc
Disable class garbage collection. Use of this option will prevent memory recovery from loaded classes thus increasing overall memory usage. This could cause OutOfMemoryError to be thrown in some applications.
-Xincgc
Enable the incremental garbage collector. The incremental garbage collector, which is off by default, will reduce the occasional long garbage-collection pauses during program execution. The incremental garbage collector will at times execute concurrently with the program and during such times will reduce the processor capacity available to the program.
-Xloggc:file
Report on each garbage collection event, as with -verbose:gc, but log this data to file. In addition to the information -verbose:gc gives, each reported event will be preceeded by the time (in seconds) since the first garbage-collection event.

Always use a local file system for storage of this file to avoid stalling the JVM due to network latency. The file may be truncated in the case of a full file system and logging will continue on the truncated file. This option overrides -verbose:gc if both are given on the command line.

-Xms n
Specify the initial size, in bytes, of the memory allocation pool. This value must be a multiple of 1024 greater than 1MB. Append the letter k or K to indicate kilobytes, or m or M to indicate megabytes. The default value is chosen at runtime based on system configuration. For more information, see HotSpot Ergonomics
Examples:
       -Xms6291456
       -Xms6144k
       -Xms6m
-Xmx n
Specify the maximum size, in bytes, of the memory allocation pool. This value must a multiple of 1024 greater than 2MB. Append the letter k or K to indicate kilobytes, or m or M to indicate megabytes. The default value is chosen at runtime based on system configuration. For more information, see HotSpot Ergonomics
Examples:
       -Xmx83886080
       -Xmx81920k
       -Xmx80m
-Xprof
Profiles the running program, and sends profiling data to standard output. This option is provided as a utility that is useful in program development and is not intended to be be used in production systems.
-Xrs
Reduces usage of operating-system signals by the Java virtual machine (JVM). This option is available beginning with J2SE 1.3.1.

In J2SE 1.3.0, the Shutdown Hooks facility was added to allow orderly shutdown of a Java application. The intent was to allow user cleanup code (such as closing database connections) to run at shutdown, even if the JVM terminates abruptly.

The JVM watches for console control events to implement shutdown hooks for abnormal JVM termination. Specifically, the JVM registers a console control handler which begins shutdown-hook processing and returns TRUE for CTRL_C_EVENT, CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, and CTRL_SHUTDOWN_EVENT.

The JVM uses a similar mechanism to implement the pre-1.2 feature of dumping thread stacks for debugging purposes. Sun's JVM uses CTRL_BREAK_EVENT to perform thread dumps.

If the JVM is run as a service (for example, the servlet engine for a web server), it can receive CTRL_LOGOFF_EVENT but should not initiate shutdown since the operating system will not actually terminate the process. To avoid possible interference such as this, the -Xrs command-line option has been added beginning with J2SE 1.3.1. When the -Xrs option is used on Sun's JVM, the JVM does not install a console control handler, implying that it does not watch for or process CTRL_C_EVENT, CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, or CTRL_SHUTDOWN_EVENT.

There are two consequences of specifying -Xrs:

  • Ctrl-Break thread dumps are not available.
  • User code is responsible for causing shutdown hooks to run, for example by calling System.exit() when the JVM is to be terminated.
-Xss n
Set thread stack size.
NOTES: The -version:release command line option places no restrictions on the complexity of the release specification. However, only a restricted subset of the possible release specifications represent sound policy and only these are fully supported. These policies are:

  1. Any version, represented by not using this option.

  2. Any version greater than an arbitrarily precise version-id. For example:
    "1.5.0_03+"

    Would utilize any version greater than 1.5.0_03. This is useful for a case where an interface was introduced (or a bug fixed) in the release specified.

  3. A version greater than an arbitrarily precise version-id, bounded by the upper bound of that release family. For example:
    "1.5.0_03+&1.5*"
  4. "Or" expressions of items 2. or 3. above. For example:
    "1.4.2_05+&1.4* 1.5+"
    Similar to item 2. this is useful when a change was introduced in a release (1.5) but also made available in updates to previous releases.

SEE ALSO

  • javac - the Java programming language compiler
  • jdb - Java Application Debugger
  • javah - C Header and Stub File Generator
  • jar - JAR Archive Tool
  • The Java Extensions Framework
  • Security Features.
  • HotSpot VM Specific Options.

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


javac - Java programming language compiler

  • Synopsis
  • Description
  • Options
  • Command Line Argument Files
  • Annotation Processing
  • Searching for Types
  • Programmatic Interface
  • Examples
  • See Also

SYNOPSIS

    javac [ options ] [ sourcefiles ] [ classes ] [ @argfiles ]

Arguments may be in any order.

options
Command-line options.
sourcefiles
One or more source files to be compiled (such as MyClass.java).
classes
One or more classes to be processed for annotations (such as MyPackage.MyClass).
@argfiles
One or more files that lists options and source files. The -J options are not allowed in these files.

DESCRIPTION

The javac tool reads class and interface definitions, written in the Java programming language, and compiles them into bytecode class files. It can also process annotations in Java source files and classes.

There are two ways to pass source code file names to javac:

  • For a small number of source files, simply list the file names on the command line.
  • For a large number of source files, list the file names in a file, separated by blanks or line breaks. Then use the list file name on the javac command line, preceded by an @ character.

Source code file names must have .java suffixes, class file names must have .class suffixes, and both source and class files must have root names that identify the class. For example, a class called MyClass would be written in a source file called MyClass.java and compiled into a bytecode class file called MyClass.class.

Inner class definitions produce additional class files. These class files have names combining the inner and outer class names, such as MyClass$MyInnerClass.class.

You should arrange source files in a directory tree that reflects their package tree. For example, if you keep all your source files in C:\workspace, the source code for com.mysoft.mypack.MyClass should be in C:\workspace\com\mysoft\mypack\MyClass.java.

By default, the compiler puts each class file in the same directory as its source file. You can specify a separate destination directory with -d (see Options, below).

OPTIONS

The compiler has a set of standard options that are supported on the current development environment and will be supported in future releases. An additional set of non-standard options are specific to the current virtual machine and compiler implementations and are subject to change in the future. Non-standard options begin with -X.

Standard Options

-A key[=value]
Options to pass to annotation processors. These are not interpreted by javac directly, but are made available for use by individual processors. key should be one or more identifiers separated by ".".
-cp path or -classpath path
Specify where to find user class files, and (optionally) annotation processors and source files. This classpath overrides the user class path in the CLASSPATH environment variable. If neither CLASSPATH, -cp nor -classpath is specified, the user class path consists of the current directory. See Setting the Class Path for more details.

If the -sourcepath option is not specified, the user class path is also searched for source files.

If the -processorpath option is not specified, the classpath is also searched for annotation processors.

As a special convenience, a class path element containing a basename of * is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR.

For example, if directory foo contains a.jar and b.JAR, then the class path element foo/* is expanded to A.jar;b.JAR, except that the order of jar files is unspecified. All jar files in the specified directory, even hidden ones, are included in the list. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. The CLASSPATH environment variable, where defined, will be similarly expanded. Note: Depending of the configuration of your command line environment, you may have to quote the wild card character, for example, javac -cp "*.jar" MyClass.java.

-Djava.ext.dirs=directories
Override the location of installed extensions.
-Djava.endorsed.dirs=directories
Override the location of endorsed standards path.
-d directory
Set the destination directory for class files. The directory must already exist; javac will not create it. If a class is part of a package, javac puts the class file in a subdirectory reflecting the package name, creating directories as needed. For example, if you specify -d C:\myclasses and the class is called com.mypackage.MyClass, then the class file is called C:\myclasses\com\mypackage\MyClass.class.

If -d is not specified, javac puts each class files in the same directory as the source file from which it was generated.

Note: The directory specified by -d is not automatically added to your user class path.

-deprecation
Show a description of each use or override of a deprecated member or class. Without -deprecation, javac shows a summary of the source files that use or override deprecated members or classes. -deprecation is shorthand for -Xlint:deprecation.
-encoding encoding
Set the source file encoding name, such as EUC-JP and UTF-8. If -encoding is not specified, the platform default converter is used.
-g
Generate all debugging information, including local variables. By default, only line number and source file information is generated.
-g:none
Do not generate any debugging information.
-g:{keyword list}
Generate only some kinds of debugging information, specified by a comma separated list of keywords. Valid keywords are:
source
Source file debugging information
lines
Line number debugging information
vars
Local variable debugging information
-help
Print a synopsis of standard options.
-implicit:{class,none}
Controls the generation of class files for implicitly loaded source files. To automatically generate class files, use -implicit:class. To suppress class file generation, use -implicit:none. If this option is not specified, the default is to automatically generate class files. In this case, the compiler will issue a warning if any such class files are generated when also doing annotation processing. The warning will not be issued if this option is set explicitly. See Searching For Types.
-nowarn
Disable warning messages. This has the same meaning as -Xlint:none.
-proc: {none,only}
Controls whether annotation processing and/or compilation is done. -proc:none means that compilation takes place without annotation processing. -proc:only means that only annotation processing is done, without any subsequent compilation.
-processor class1[,class2,class3...]
Names of the annotation processors to run. This bypasses the default discovery process.
-processorpath path
Specify where to find annotation processors; if this option is not used, the classpath will be searched for processors.
-s dir
Specify the directory where to place generated source files. The directory must already exist; javac will not create it. If a class is part of a package, the compiler puts the source file in a subdirectory reflecting the package name, creating directories as needed. For example, if you specify -s C:\mysrc and the class is called com.mypackage.MyClass, then the source file will be placed in C:\mysrc\com\mypackage\MyClass.java.
-source release
Specifies the version of source code accepted. The following values for release are allowed:
1.3
The compiler does not support assertions, generics, or other language features introduced after JDK 1.3.
1.4
The compiler accepts code containing assertions, which were introduced in JDK 1.4.
1.5
The compiler accepts code containing generics and other language features introduced in JDK 5.
5
Synonym for 1.5.
1.6
This is the default value. No language changes were introduced in Java SE 6. However, encoding errors in source files are now reported as errors, instead of warnings, as previously.
6
Synonym for 1.6.

-sourcepath sourcepath
Specify the source code path to search for class or interface definitions. As with the user class path, source path entries are separated by semicolons (;) and can be directories, JAR archives, or ZIP archives. If packages are used, the local path name within the directory or archive must reflect the package name.

Note: Classes found through the classpath may be subject to automatic recompilation if their sources are also found. See Searching For Types.

-verbose
Verbose output. This includes information about each class loaded and each source file compiled.
-X
Display information about non-standard options and exit.

Cross-Compilation Options

By default, classes are compiled against the bootstrap and extension classes of the platform that javac shipped with. But javac also supports cross-compiling, where classes are compiled against a bootstrap and extension classes of a different Java platform implementation. It is important to use -bootclasspath and -extdirs when cross-compiling; see Cross-Compilation Example below.

-target version
Generate class files that target a specified version of the VM. Class files will run on the specified target and on later versions, but not on earlier versions of the VM. Valid targets are 1.1 1.2 1.3 1.4 1.5 (also 5) and 1.6 (also 6).

The default for -target depends on the value of -source:

  • If -source is not specified, the value of -target is 1.6
  • If -source is 1.2, the value of -target is 1.4
  • If -source is 1.3, the value of -target is 1.4
  • For all other values of -source, the value of -target is the value of -source.

-bootclasspath bootclasspath
Cross-compile against the specified set of boot classes. As with the user class path, boot class path entries are separated by semicolons (;) and can be directories, JAR archives, or ZIP archives.
-extdirs directories
Cross-compile against the specified extension directories. Directories is a semicolon-separated list of directories. Each JAR archive in the specified directories is searched for class files.

Non-Standard Options

-Xbootclasspath/p:path
Prepend to the bootstrap class path.
-Xbootclasspath/a:path
Append to the bootstrap class path.
-Xbootclasspath/:path
Override location of bootstrap class files.
-Xlint
Enable all recommended warnings. In this release, all available warnings are recommended.
-Xlint:none
Disable all warnings not mandated by the Java Language Specification.
-Xlint:-name
Disable warning name, where name is one of the warning names supported for -Xlint:name, below.
-Xlint:unchecked
Give more detail for unchecked conversion warnings that are mandated by the Java Language Specification.
-Xlint:path
Warn about nonexistent path (classpath, sourcepath, etc) directories.
-Xlint:serial
Warn about missing serialVersionUID definitions on serializable classes.
-Xlint:finally
Warn about finally clauses that cannot complete normally.
-Xlint:fallthrough
Check switch blocks for fall-through cases and provide a warning message for any that are found. Fall-through cases are cases in a switch block, other than the last case in the block, whose code does not include a break statement, allowing code execution to "fall through" from that case to the next case. For example, the code following the case 1 label in this switch block does not end with a break statement:
switch (x) {
case 1:
       System.out.println("1");
       //  No  break;  statement here.
case 2:
       System.out.println("2");
}
If the -Xlint:fallthrough flag were used when compiling this code, the compiler would emit a warning about "possible fall-through into case," along with the line number of the case in question.
-Xmaxerrors number
Set the maximum number of errors to print.
-Xmaxwarns number
Set the maximum number of warnings to print.
-Xstdout filename
Send compiler messages to the named file. By default, compiler messages go to System.err.
-Xprefer:{newer,source}
Specify which file to read when both a source file and class file are found for a type. (See Searching For Types). If -Xprefer:newer is used, it reads the newer of the source or class file for a type (default). If the -Xprefer:source option is used, it reads source file. Use -Xprefer:source when you want to be sure that any annotation processors can access annotations declared with a retention policy of SOURCE.
-Xprint
Print out textual representation of specified types for debugging purposes; perform neither annotation processing nor compilation. The format of the output may change.
-XprintProcessorInfo
Print information about which annotations a processor is asked to process.
-XprintRounds
Print information about initial and subsequent annotation processing rounds.

The -J Option

-J option
Pass option to the java launcher called by javac. For example, -J-Xms48m sets the startup memory to 48 megabytes. Although it does not begin with -X, it is not a `standard option' of javac. It is a common convention for -J to pass options to the underlying VM executing applications written in Java.

Note: CLASSPATH, -classpath, -bootclasspath, and -extdirs do not specify the classes used to run javac. Fiddling with the implementation of the compiler in this way is usually pointless and always risky. If you do need to do this, use the -J option to pass through options to the underlying java launcher.

COMMAND LINE ARGUMENT FILES

To shorten or simplify the javac command line, you can specify one or more files that themselves contain arguments to the javac command (except -J options). This enables you to create javac commands of any length on any operating system.

An argument file can include javac options and source filenames in any combination. The arguments within a file can be space-separated or newline-separated. If a filename contains embedded spaces, put the whole filename in double quotes, and double each backslash ("My Files\\Stuff.java").

Filenames within an argument file are relative to the current directory, not the location of the argument file. Wildcards (*) are not allowed in these lists (such as for specifying *.java). Use of the '@' character to recursively interpret files is not supported. The -J options are not supported because they are passed to the launcher, which does not support argument files.

When executing javac, pass in the path and name of each argument file with the '@' leading character. When javac encounters an argument beginning with the character `@', it expands the contents of that file into the argument list.

Example - Single Arg File

You could use a single argument file named "argfile" to hold all javac arguments:

  C:> javac @argfile

This argument file could contain the contents of both files shown in the next example.

Example - Two Arg Files

You can create two argument files -- one for the javac options and the other for the source filenames: (Notice the following lists have no line-continuation characters.)

Create a file named "options" containing:

     -d classes
     -g
     -sourcepath C:\java\pubs\ws\1.3\src\share\classes

Create a file named "classes" containing:

     MyClass1.java
     MyClass2.java
     MyClass3.java

You would then run javac with:

  C:> javac @options @classes

Example - Arg Files with Paths

The argument files can have paths, but any filenames inside the files are relative to the current working directory (not path1 or path2):

  C:> javac @path1\options @path2\classes

ANNOTATION PROCESSING

javac provides direct support for annotation processing, superseding the need for the separate annotation processing tool, apt.

The API for annotation processors is defined in the javax.annotation.processing and javax.lang.model packages and subpackages.

Overview of annotation processing

Unless annotation processing is disabled with the -proc:none option, the compiler searches for any annotation processors that are available. The search path can be specified with the -processorpath option; if it is not given, the user class path is used. Processors are located by means of service provider-configuration files named META_INF/services/javax.annotation.processing.Processor on the search path. Such files should contain the names of any annotation processors to be used, listed one per line. Alternatively, processors can be specified explicitly, using the -processor option.

After scanning the source files and classes on the command line to determine what annotations are present, the compiler queries the processors to determine what annotations they process. When a match is found, the processor will be invoked. A processor may "claim" the annotations it processes, in which case no further attempt is made to find any processors for those annotations. Once all annotations have been claimed, the compiler does not look for additional processors.

If any processors generate any new source files, another round of annotation processing will occur: any newly generated source files will be scanned, and the annotations processed as before. Any processors invoked on previous rounds will also be invoked on all subsequent rounds. This continues until no new source files are generated.

After a round occurs where no new source files are generated, the annotation processors will be invoked one last time, to give them a chance to complete any work they may need to do. Finally, unless the -proc:only option is used, the compiler will compile the original and all the generated source files.

Implicitly loaded source files

To compile a set of source files, the compiler may need to implicitly load additional source files. (See Searching For Types). Such files are currently not subject to annotation processing. By default, the compiler will give a warning if annotation processing has occurred and any implicitly loaded source files are compiled. See the -implicit option for ways to suppress the warning.

SEARCHING FOR TYPES

When compiling a source file, the compiler often needs information about a type whose definition did not appear in the source files given on the command line. The compiler needs type information for every class or interface used, extended, or implemented in the source file. This includes classes and interfaces not explicitly mentioned in the source file but which provide information through inheritance.

For example, when you subclass java.applet.Applet, you are also using Applet's ancestor classes: java.awt.Panel, java.awt.Container, java.awt.Component, and java.lang.Object.

When the compiler needs type information, it looks for a source file or class file which defines the type. The compiler searches for class files first in the bootstrap and extension classes, then in the user class path (which by default is the current directory). The user class path is defined by setting the CLASSPATH environment variable or by using the -classpath command line option. (For details, see Setting the Class Path).

If you set the -sourcepath option, the compiler searches the indicated path for source files; otherwise the compiler searches the user class path for both class files and source files.

You can specify different bootstrap or extension classes with the -bootclasspath and -extdirs options; see Cross-Compilation Options below.

A successful type search may produce a class file, a source file, or both. If both are found, you can use the -Xprefer option to instruct the compiler which to use. If newer is given, the compiler will use the newer of the two files. If source is given, it will use the source file. The default is newer.

If a type search finds a source file for a required type, either by itself, or as a result of the setting for -Xprefer, the compiler will read the source file to get the information it needs. In addition, it will by default compile the source file as well. You can use the -implicit option to specify the behavior. If none is given, no class files will be generated for the source file. If class is given, class files will be generated for the source file.

The compiler may not discover the need for some type information until after annotation processing is complete. If the type information is found in a source file and no -implicit option is given, the compiler will give a warning that the file is being compiled without being subject to annotation processing. To disable the warning, either specify the file on the command line (so that it will be subject to annotation processing) or use the -implicit option to specify whether or not class files should be generated for such source files.

PROGRAMMATIC INTERFACE

javac supports the new Java Compiler API defined by the classes and interfaces in the javax.tools package.

Example

To perform a compilation using arguments as you would give on the command line, you can use the following:

JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
int rc = javac.run(null, null, null, args);

This will write any diagnostics to the standard output stream, and return the exit code that javac would give when invoked from the command line.

You can use other methods on the javax.tools.JavaCompiler interface to handle diagnostics, control where files are read from and written to, and so on.

Old Interface

Note: This API is retained for backwards compatibility only; all new code should use the Java Compiler API, described above.

The com.sun.tools.javac.Main class provides two static methods to invoke the compiler from a program:

public static int compile(String[] args);
public static int compile(String[] args, PrintWriter out);

The args parameter represents any of the command line arguments that would normally be passed to the javac program and are outlined in the above Synopsis section.

The out parameter indicates where the compiler's diagnostic output is directed.

The return value is equivalent to the exit value from javac.

Note that all other classes and methods found in a package whose name starts with com.sun.tools.javac (informally known as sub-packages of com.sun.tools.javac) are strictly internal and subject to change at any time.

EXAMPLES

Compiling a Simple Program

One source file, Hello.java, defines a class called greetings.Hello. The greetings directory is the package directory both for the source file and the class file and is off the current directory. This allows us to use the default user class path. It also makes it unnecessary to specify a separate destination directory with -d.

C:> dir
greetings/
C:> dir greetings
Hello.java
C:> cat greetings\Hello.java
package greetings;

public class Hello {
    public static void main(String[] args) {
        for (int i=0; i < args.length; i++) {
            System.out.println("Hello " + args[i]);
        }
    }
}
C:> javac greetings\Hello.java
C:> dir greetings
Hello.class   Hello.java
C:> java greetings.Hello World Universe Everyone
Hello World
Hello Universe
Hello Everyone

Compiling Multiple Source Files

This example compiles all the source files in the package greetings.

C:> dir
greetings\
C:> dir greetings
Aloha.java         GutenTag.java      Hello.java         Hi.java
C:> javac greetings\*.java
C:> dir greetings
Aloha.class         GutenTag.class      Hello.class         Hi.class
Aloha.java          GutenTag.java       Hello.java          Hi.java

Specifying a User Class Path

Having changed one of the source files in the previous example, we recompile it:

C:> cd
\examples
C:> javac greetings\Hi.java

Since greetings.Hi refers to other classes in the greetings package, the compiler needs to find these other classes. The example above works, because our default user class path happens to be the directory containing the package directory. But suppose we want to recompile this file and not worry about which directory we're in? Then we need to add \examples to the user class path. We can do this by setting CLASSPATH, but here we'll use the -classpath option.

C:>javac -classpath \examples \examples\greetings\Hi.java

If we change greetings.Hi again, to use a banner utility, that utility also needs to be accessible through the user class path.

C:>javac -classpath \examples;\lib\Banners.jar \
        \examples\greetings\Hi.java

To execute a class in greetings, we need access both to greetings and to the classes it uses.

C:>java -classpath \examples;\lib\Banners.jar greetings.Hi

Separating Source Files and Class Files

It often makes sense to keep source files and class files in separate directories, especially on large projects. We use -d to indicate the separate class file destination. Since the source files are not in the user class path, we use -sourcepath to help the compiler find them.

C:> dir
classes\  lib\      src\
C:> dir src
farewells\
C:> dir src\farewells
Base.java      GoodBye.java
C:> dir lib
Banners.jar
C:> dir classes
C:> javac -sourcepath src -classpath classes;lib\Banners.jar \
        src\farewells\GoodBye.java -d classes
C:> dir classes
farewells\
C:> dir classes\farewells
Base.class      GoodBye.class

Note: The compiler compiled src\farewells\Base.java, even though we didn't specify it on the command line. To trace automatic compiles, use the -verbose option.

Cross-Compilation Example

Here we use javac to compile code that will run on a 1.5 VM.

% javac -target 1.5 -bootclasspath jdk1.5.0\lib\rt.jar \
        -extdirs "" OldCode.java

The -target 1.5 option ensures that the generated class files will be compatible with 1.5 VMs. By default, javac compiles for JDK 6.

The Java Platform JDK's javac would also by default compile against its own bootstrap classes, so we need to tell javac to compile against JDK 1.5 bootstrap classes instead. We do this with -bootclasspath and -extdirs. Failing to do this might allow compilation against a Java Platform API that would not be present on a 1.5 VM and would fail at runtime.

SEE ALSO

  • javac Guide
  • java - the Java Application Launcher
  • jdb - Java Application Debugger
  • javah - C Header and Stub File Generator
  • javap - Class File Disassembler
  • javadoc - API Documentation Generator
  • jar - JAR Archive Tool
  • The Java Extensions Framework

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


javadoc - The Java API Documentation Generator

Generates HTML pages of API documentation from Java source files. This document contains JavadocTM examples for Microsoft Windows.

CONTENTS

Reference Guide
  • Synopsis
  • Description
    • Processing of Source Files
    • Javadoc Doclets
    • Related Documentation
    • Terminology
  • Source Files
    • Class Source Code Files
    • Package Comment Files
    • Overview Comment File
    • Miscellaneous Unprocessed Files
    • Test Files and Template Files
  • Generated Files
    • Generated API Declarations
  • Documentation Comments
    • Commenting the Source Code
    • Automatic Copying of Method Comments
  • Javadoc Tags (@tag)
    • Where Tags Can Be Used
  • Options (-option)
    • Javadoc Options
    • Options Provided by the Standard Doclet
  • Command Line Argument Files
Running
  • Running Javadoc
  • Simple Examples
    • Documenting One or More Packages
    • Documenting One or More Classes
    • Documenting Both Packages and Classes
  • Real World Example
    • Command Line Example
    • Makefile Example
  • Troubleshooting
    • General Troubleshooting
    • Errors and Warnings
  • Environment
    • CLASSPATH
  • Troubleshooting
  • See Also

Reference Guide

SYNOPSIS

javadoc [ options ] [ packagenames ] [ sourcefilenames ] [ -subpackages pkg1:pkg2:... ] [ @argfiles ]

Arguments can be in any order. See processing of Source Files for details on how the Javadoc tool determines which ".java" files to process.

options
Command-line options, as specified in this document. To see a typical use of javadoc options, see Real-World Example.
packagenames
A series of names of packages, separated by spaces, such as java.lang java.lang.reflect java.awt. You must separately specify each package you want to document. Wildcards are not allowed; use -subpackages for recursion. The Javadoc tool uses -sourcepath to look for these package names. See Example - Documenting One or More Packages
sourcefilenames
A series of source file names, separated by spaces, each of which can begin with a path and contain a wildcard such as asterisk (*). The Javadoc tool will process every file whose name ends with ".java", and whose name, when stripped of that suffix, is actually a legal class name (see Identifiers). Therefore, you can name files with dashes (such as X-Buffer), or other illegal characters, to prevent them from being documented. This is useful for test files and template files The path that precedes the source file name determines where javadoc will look for the file. (The Javadoc tool does not use -sourcepath to look for these source file names.) Relative paths are relative to the current directory, so passing in Button.java is identical to ./Button.java. A source file name with an absolute path and a wildcard, for example, is /home/src/java/awt/Graphics*.java. See Example - Documenting One or More Classes. You can also mix packagenames and sourcefilenames, as in Example - Documenting Both Packages and Classes
-subpackages pkg1:pkg2:...
Generates documentation from source files in the specified packages and recursively in their subpackages. An alternative to supplying packagenames or sourcefilenames.
@argfiles
One or more files that contain a list of Javadoc options, packagenames and sourcefilenames in any order. Wildcards (*) and -J options are not allowed in these files.

DESCRIPTION

The JavadocTM tool parses the declarations and documentation comments in a set of Java source files and produces a corresponding set of HTML pages describing (by default) the public and protected classes, nested classes (but not anonymous inner classes), interfaces, constructors, methods, and fields. You can use it to generate the API (Application Programming Interface) documentation or the implementation documentation for a set of source files.

You can run the Javadoc tool on entire packages, individual source files, or both. When documenting entire packages, you can either use -subpackages for traversing recursively down from a top-level directory, or pass in an explicit list of package names. When documenting individual source files, you pass in a list of source (.java) filenames. Examples are given at the end of this document. How Javadoc processes source files is covered next.

Processing of source files

The Javadoc tool processes files that end in ".java" plus other files described under Source Files. If you run the Javadoc tool by explicitly passing in individual source filenames, you can determine exactly which ".java" files are processed. However, that is not how most developers want to work, as it is simpler to pass in package names. The Javadoc tool can be run three ways without explicitly specifying the source filenames. You can (1) pass in package names, (2) use -subpackages, and (3) use wildcards with source filenames (*.java). In these cases, the Javadoc tool processes a ".java" file only if it fulfills all of the following requirements:
  • Its name, after stripping off the ".java" suffix, is actually a legal class name (see Identifiers for legal characters)
  • Its directory path relative to the root of the source tree is actually a legal package name (after converting its separators to dots)
  • Its package statement contains the legal package name (specified in the previous bullet)

Processing of links - During a run, the Javadoc tool automatically adds cross-reference links to package, class and member names that are being documented as part of that run. Links appear in several places:

  • Declarations (return types, argument types, field types)
  • "See Also" sections generated from @see tags
  • In-line text generated from {@link} tags
  • Exception names generated from @throws tags
  • "Specified by" links to members in interfaces and "Overrides" links to members in classes
  • Summary tables listing packages, classes and members
  • Package and class inheritance trees
  • The index
You can add hyperlinks to existing text for classes not included on the command line (but generated separately) by way of the -link and -linkoffline options.

Other processing details - The Javadoc tool produces one complete document each time it is run; it cannot do incremental builds -- that is, it cannot modify or directly incorporate results from previous runs of the Javadoc tool. However, it can link to results from other runs, as just mentioned.

As implemented, the Javadoc tool requires and relies on the java compiler to do its job. The Javadoc tool calls part of javac to compile the declarations, ignoring the member implementation. It builds a rich internal representation of the classes, including the class hierarchy, and "use" relationships, then generates the HTML from that. The Javadoc tool also picks up user-supplied documentation from documentation comments in the source code.

In fact, the Javadoc tool will run on .java source files that are pure stub files with no method bodies. This means you can write documentation comments and run the Javadoc tool in the earliest stages of design while creating the API, before writing the implementation.

Relying on the compiler ensures that the HTML output corresponds exactly with the actual implementation, which may rely on implicit, rather than explicit, source code. For example, the Javadoc tool documents default constructors (section 8.6.7 of Java Language Specification) that are present in the .class files but not in the source code.

In many cases, the Javadoc tool allows you to generate documentation for source files whose code is incomplete or erroneous. This is a benefit that enables you to generate documentation before all debugging and troubleshooting is done. For example, according to the Java Language Specification, a class that contains an abstract method should itself be declared abstract. The Javadoc tool does not check for this, and would proceed without a warning, whereas the javac compiler stops on this error. The Javadoc tool does do some primitive checking of doc comments. Use the DocCheck doclet to check the doc comments more thoroughly.

When the Javadoc tool builds its internal structure for the documentation, it loads all referenced classes. Because of this, the Javadoc tool must be able to find all referenced classes, whether bootstrap classes, extensions, or user classes. For more about this, see How Classes Are Found. Generally speaking, classes you create must either be loaded as an extension or in the Javadoc tool's class path.

Javadoc Doclets

You can customize the content and format of the Javadoc tool's output by using doclets. The Javadoc tool has a default "built-in" doclet, called the standard doclet, that generates HTML-formatted API documentation. You can modify or subclass the standard doclet, or write your own doclet to generate HTML, XML, MIF, RTF or whatever output format you'd like. Information about doclets and their use is at the following locations:
  • Javadoc Doclets
  • The -doclet command-line option
When a custom doclet is not specified with the -doclet command line option, the Javadoc tool will use the default standard doclet. The javadoc tool has several command line options that are available regardless of which doclet is being used. The standard doclet adds a supplementary set of command line options. Both sets of options are described below in the options section.

Related Documentation and Doclets

  • Javadoc Enhancements for details about improvements added in Javadoc.
  • Javadoc FAQ for answers to common questions, information about Javadoc-related tools, and workarounds for bugs.
  • How to Write Doc Comments for Javadoc for more information about Sun conventions for writing documentation comments.
  • Requirements for Writing API Specifications - Standard requirements used when writing the Java 2 Platform Specification. It can be useful whether you are writing API specifications in source file documentation comments or in other formats. It covers requirements for packages, classes, interfaces, fields and methods to satisfy testable assertions.
  • Documentation Comment Specification - The original specification on documentation comments, Chapter 18, Documentation Comments, in the Java Language Specification, First Edition, by James Gosling, Bill Joy, and Guy Steele. (This chapter was removed from the second edition.)
  • DocCheck Doclet - Checks doc comments in source files and generates a report listing the errors and irregularities it finds. It is part of the Sun Doc Check Utilities.
  • MIF Doclet - Can automate the generation of API documentation in MIF, FrameMaker and PDF formats. MIF is Adobe FrameMaker's interchange format.

Terminology

The terms documentation comment, doc comment, main description, tag, block tag, and in-line tag are described at Documentation Comments. These other terms have specific meanings within the context of the Javadoc tool:
generated document
The document generated by the javadoc tool from the doc comments in Java source code. The default generated document is in HTML and is created by the standard doclet.

name
A name of a program element written in the Java Language -- that is, the name of a package, class, interface, field, constructor or method. A name can be fully-qualified, such as java.lang.String.equals(java.lang.Object), or partially-qualified, such as equals(Object).

documented classes
The classes and interfaces for which detailed documentation is generated during a javadoc run. To be documented, the source files must be available, their source filenames or package names must be passed into the javadoc command, and they must not be filtered out by their access modifier (public, protected, package-private or private). We also refer to these as the classes included in the javadoc output, or the included classes.

included classes
Classes and interfaces whose details are documented during a run of the Javadoc tool. Same as documented classes.

excluded classes
Classes and interfaces whose details are not documented during a run of the Javadoc tool.

referenced classes
The classes and interfaces that are explicitly referred to in the definition (implementation) or doc comments of the documented classes and interfaces. Examples of references include return type, parameter type, cast type, extended class, implemented interface, imported classes, classes used in method bodies, @see, {@link}, {@linkplain}, and {@inheritDoc} tags. (Notice this definition has changed since 1.3.) When the Javadoc tool is run, it should load into memory all of the referenced classes in javadoc's bootclasspath and classpath. (The Javadoc tool prints a "Class not found" warning for referenced classes not found.) The Javadoc tool can derive enough information from the .class files to determine their existence and the fully-qualified names of their members.

external referenced classes
The referenced classes whose documentation is not being generated during a javadoc run. In other words, these classes are not passed into the Javadoc tool on the command line. Links in the generated documentation to those classes are said to be external references or external links. For example, if you run the Javadoc tool on only the java.awt package, then any class in java.lang, such as Object, is an external referenced class. External referenced classes can be linked to using the -link and -linkoffline options. An important property of an external referenced class is that its source comments are normally not available to the Javadoc run. In this case, these comments cannot be inherited.

SOURCE FILES

The Javadoc tool will generate output originating from four different types of "source" files: Java language source files for classes (.java), package comment files, overview comment files, and miscellaneous unprocessed files. This section also covers test files and template files that can also be in the source tree, but which you want to be sure not to document.

Class Source Code Files

Each class or interface and its members can have their own documentation comments, contained in a .java file. For more details about these doc comments, see Documentation Comments.

Package Comment Files

Each package can have its own documentation comment, contained in its own "source" file, that the Javadoc tool will merge into the package summary page that it generates. You typically include in this comment any documentation that applies to the entire package.

To create a package comment file, you have a choice of two files to place your comments:

  • package-info.java - Can contain a package declaration, package annotations, package comments and Javadoc tags. This file is new in JDK 5.0, and is preferred over package.html.
  • package.html - Can contain only package comments and Javadoc tags, no package annotations.
A package may have a single package.html file or a single package-info.java file but not both. Place either file in the package directory in the source tree along with your .java files.

package-info.java This file can contain a package comment of the following structure -- the comment is placed before the package declaration:

File: java/applet/package-info.java

/** * Provides the classes necessary to create an applet and the classes an applet uses * to communicate with its applet context. * <p> * The applet framework involves two entities: * the applet and the applet context. An applet is an embeddable window (see the * {@link java.awt.Panel} class) with a few extra methods that the applet context * can use to initialize, start, and stop the applet. * * @since 1.0 * @see java.awt */ package java.lang.applet;

Note that while the comment separators /** and /* must be present, the leading asterisks on the intermediate lines can be omitted. package.html - This file can contain a package comment of the following structure -- the comment is placed in the <body> element:

File: java/applet/package.html

<HTML> <BODY> Provides the classes necessary to create an applet and the classes an applet uses to communicate with its applet context. <p> The applet framework involves two entities: the applet and the applet context. An applet is an embeddable window (see the {@link java.awt.Panel} class) with a few extra methods that the applet context can use to initialize, start, and stop the applet. @since 1.0 @see java.awt </BODY> </HTML>

Notice this is just a normal HTML file and does not include a package declaration. The content of the package comment file is written in HTML, like all other comments, with one exception: The documentation comment should not include the comment separators /** and */ or leading asterisks. When writing the comment, you should make the first sentence a summary about the package, and not put a title or any other text between <body> and the first sentence. You can include package tags; as with any documentation comment, all block tags must appear after the main description. If you add a @see tag in a package comment file, it must have a fully-qualified name. For more details, see the example of package.html.

Processing of package comment file - When the Javadoc tool runs, it will automatically look for the package comment file; if found, the Javadoc tool does the following:

  • Copies the comment for processing. (For package.html, copies all content between <body> and </body> HTML tags. You can include a <head> section to put a <title>, source file copyright statement, or other information, but none of these will appear in the generated documentation.)
  • Processes any package tags that are present.
  • Inserts the processed text at the bottom of the package summary page it generates, as shown in Package Summary.
  • Copies the first sentence of the package comment to the top of the package summary page. It also adds the package name and this first sentence to the list of packages on the overview page, as shown in Overview Summary. The end-of-sentence is determined by the same rules used for the end of the first sentence of class and member main descriptions.

Overview Comment File

Each application or set of packages that you are documenting can have its own overview documentation comment, kept in its own "source" file, that the Javadoc tool will merge into the overview page that it generates. You typically include in this comment any documentation that applies to the entire application or set of packages.

To create an overview comment file, you can name the file anything you want, typically overview.html and place it anywhere, typically at the top level of the source tree. For example, if the source files for the java.applet package are contained in C:\user\src\java\applet directory, you could create an overview comment file at C:\user\src\overview.html.

Notice you can have multiple overview comment files for the same set of source files, in case you want to run javadoc multiple times on different sets of packages. For example, you could run javadoc once with -private for internal documentation and again without that option for public documentation. In this case, you could describe the documentation as public or internal in the first sentence of each overview comment file.

The content of the overview comment file is one big documentation comment, written in HTML, like the package comment file described previously. See that description for details. To re-iterate, when writing the comment, you should make the first sentence a summary about the application or set of packages, and not put a title or any other text between <body> and the first sentence. You can include overview tags; as with any documentation comment, all tags except in-line tags, such as {@link}, must appear after the main description. If you add a @see tag, it must have a fully-qualified name.

When you run the Javadoc tool, you specify the overview comment file name with the -overview option. The file is then processed similar to that of a package comment file.

  • Copies all content between <body> and </body> tags for processing.
  • Processes any overview tags that are present.
  • Inserts the processed text at the bottom of the overview page it generates, as shown in Overview Summary.
  • Copies the first sentence of the overview comment to the top of the overview summary page.

Miscellaneous Unprocessed Files

You can also include in your source any miscellaneous files that you want the Javadoc tool to copy to the destination directory. These typically includes graphic files, example Java source (.java) and class (.class) files, and self-standing HTML files whose content would overwhelm the documentation comment of a normal Java source file.

To include unprocessed files, put them in a directory called doc-files which can be a subdirectory of any package directory that contains source files. You can have one such subdirectory for each package. You might include images, example code, source files, .class files, applets and HTML files. For example, if you want to include the image of a button button.gif in the java.awt.Button class documentation, you place that file in the /home/user/src/java/awt/doc-files/ directory. Notice the doc-files directory should not be located at /home/user/src/java/doc-files because java is not a package -- that is, it does not directly contain any source files.

All links to these unprocessed files must be hard-coded, because the Javadoc tool does not look at the files -- it simply copies the directory and all its contents to the destination. For example, the link in the Button.java doc comment might look like:

    /**
     * This button looks like this:
     * <img src="doc-files/Button.gif">
     */

Test Files and Template Files

Some developers have indicated they want to store test files and templates files in the source tree near their corresponding source files. That is, they would like to put them in the same directory, or a subdirectory, of those source files.

If you run the Javadoc tool by explicitly passing in individual source filenames, you can deliberately omit test and templates files and prevent them from being processed. However, if you are passing in package names or wildcards, you need to follow certain rules to ensure these test files and templates files are not processed.

Test files differ from template files in that the former are legal, compilable source files, while the latter are not, but may end with ".java".

Test files - Often developers want to put compilable, runnable test files for a given package in the same directory as the source files for that package. But they want the test files to belong to a package other than the source file package, such as the unnamed package (so the test files have no package statement or a different package statement from the source). In this scenario, when the source is being documented by specifying its package name specified on the command line, the test files will cause warnings or errors. You need to put such test files in a subdirectory. For example, if you want to add test files for source files in com.package1, put them in a subdirectory that would be an invalid package name (because it contains a hyphen):

    com/package1/test-files/
The test directory will be skipped by the Javadoc tool with no warnings.

If your test files contain doc comments, you can set up a separate run of the Javadoc tool to produce documentation of the test files by passing in their test source filenames with wildcards, such as com/package1/test-files/*.java.

Templates for source files - Template files have names that often end in ".java" and are not compilable. If you have a template for a source file that you want to keep in the source directory, you can name it with a dash (such as Buffer-Template.java), or any other illegal Java character, to prevent it from being processed. This relies on the fact that the Javadoc tool will only process source files whose name, when stripped of the ".java" suffix, is actually a legal class name (see Identifiers).

GENERATED FILES

By default, javadoc uses a standard doclet that generates HTML-formatted documentation. This doclet generates the following kinds of files (where each HTML "page" corresponds to a separate file). Note that javadoc generates files with two types of names: those named after classes/interfaces, and those that are not (such as package-summary.html). Files in the latter group contain hyphens to prevent filename conflicts with those in the former group.

Basic Content Pages

  • One class or interface page (classname.html) for each class or interface it is documenting.
  • One package page (package-summary.html) for each package it is documenting. The Javadoc tool will include any HTML text provided in a file named package.html or package-info.java in the package directory of the source tree.
  • One overview page (overview-summary.html) for the entire set of packages. This is the front page of the generated document. The Javadoc tool will include any HTML text provided in a file specified with the -overview option. Note that this file is created only if you pass into javadoc two or more package names. For further explanation, see HTML Frames.)

Cross-Reference Pages

  • One class hierarchy page for the entire set of packages (overview-tree.html). To view this, click on "Overview" in the navigation bar, then click on "Tree".
  • One class hierarchy page for each package (package-tree.html) To view this, go to a particular package, class or interface page; click "Tree" to display the hierarchy for that package.
  • One "use" page for each package (package-use.html) and a separate one for each class and interface (class-use/classname.html). This page describes what packages, classes, methods, constructors and fields use any part of the given class, interface or package. Given a class or interface A, its "use" page includes subclasses of A, fields declared as A, methods that return A, and methods and constructors with parameters of type A. You can access this page by first going to the package, class or interface, then clicking on the "Use" link in the navigation bar.
  • A deprecated API page (deprecated-list.html) listing all deprecated names. (A deprecated name is not recommended for use, generally due to improvements, and a replacement name is usually given. Deprecated APIs may be removed in future implementations.)
  • A constant field values page (constant-values.html) for the values of static fields.
  • A serialized form page (serialized-form.html) for information about serializable and externalizable classes. Each such class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class comment. The standard doclet automatically generates a serialized form page: any class (public or non-public) that implements Serializable is included, along with readObject and writeObject methods, the fields that are serialized, and the doc comments from the @serial, @serialField, and @serialData tags. Public serializable classes can be excluded by marking them (or their package) with @serial exclude, and package-private serializable classes can be included by marking them (or their package) with @serial include. As of 1.4, you can generate the complete serialized form for public and private classes by running javadoc without specifying the -private option.
  • An index (index-*.html) of all class, interface, constructor, field and method names, alphabetically arranged. This is internationalized for Unicode and can be generated as a single file or as a separate file for each starting character (such as A-Z for English).

Support Files

  • A help page (help-doc.html) that describes the navigation bar and the above pages. You can provide your own custom help file to override the default using -helpfile.
  • One index.html file which creates the HTML frames for display. This is the file you load to display the front page with frames. This file itself contains no text content.
  • Several frame files (*-frame.html) containing lists of packages, classes and interfaces, used when HTML frames are being displayed.
  • A package list file (package-list), used by the -link and -linkoffline options. This is a text file, not HTML, and is not reachable through any links.
  • A style sheet file (stylesheet.css) that controls a limited amount of color, font family, font size, font style and positioning on the generated pages.
  • A doc-files directory that holds any image, example, source code or other files that you want copied to the destination directory. These files are not processed by the Javadoc tool in any manner -- that is, any javadoc tags in them will be ignored. This directory is not generated unless it exists in the source tree.

HTML Frames

The Javadoc tool will generate either two or three HTML frames, as shown in the figure below. It creates the minimum necessary number of frames by omitting the list of packages if there is only one package (or no packages). That is, when you pass a single package name or source files (*.java) belonging to a single package as arguments into the javadoc command, it will create only one frame (C) in the left-hand column -- the list of classes. When you pass into javadoc two or more package names, it creates a third frame (P) listing all packages, as well as an overview page (Detail). This overview page has the filename overview-summary.html. Thus, this file is created only if you pass in two or more package names. You can bypass frames by clicking on the "No Frames" link or entering at overview-summary.html.

If you are unfamiliar with HTML frames, you should be aware that frames can have focus for printing and scrolling. To give a frame focus, click on it. Then on many browsers the arrow keys and page keys will scroll that frame, and the print menu command will print it.

              ------------                  ------------
              |C| Detail |                  |P| Detail |
              | |        |                  | |        |
              | |        |                  |-|        |
              | |        |                  |C|        |
              | |        |                  | |        |
              | |        |                  | |        |
              ------------                  ------------
             javadoc *.java           javadoc java.lang java.awt
Load one of the following two files as the starting page depending on whether you want HTML frames or not:
  • index.html (for frames)
  • overview-summary.html (for no frames)
Generated File Structure

The generated class and interface files are organized in the same directory hierarchy that Java source files and class files are organized. This structure is one directory per subpackage.

For example, the document generated for the class java.applet.Applet class would be located at java\applet\Applet.html. The file structure for the java.applet package follows, given that the destination directory is named apidocs. All files that contain the word "frame" appear in the upper-left or lower-left frames, as noted. All other HTML files appear in the right-hand frame.

NOTE - Directories are shown in bold. The asterisks (*) indicate the files and directories that are omitted when the arguments to javadoc are source filenames (*.java) rather than package names. Also when arguments are source filenames, package-list is created but is empty. The doc-files directory will not be created in the destination unless it exists in the source tree.

apidocs                             Top directory
   index.html                       Initial page that sets up HTML frames
 * overview-summary.html            Lists all packages with first sentence summaries
   overview-tree.html               Lists class hierarchy for all packages
   deprecated-list.html             Lists deprecated API for all packages
   constant-values.html             Lists values of static fields for all packages
   serialized-form.html             Lists serialized form for all packages
 * overview-frame.html              Lists all packages, used in upper-left frame
   allclasses-frame.html            Lists all classes for all packages, used in lower-left frame
   help-doc.html                    Lists user help for how these pages are organized
   index-all.html                   Default index created without -splitindex option
   index-files                      Directory created with -splitindex option
       index-<number>.html          Index files created with -splitindex option
   package-list                     Lists package names, used only for resolving external refs
   stylesheet.css                   HTML style sheet for defining fonts, colors and positions
   java                             Package directory
       applet                       Subpackage directory
            Applet.html             Page for Applet class
            AppletContext.html      Page for AppletContext interface
            AppletStub.html         Page for AppletStub interface
            AudioClip.html          Page for AudioClip interface
          * package-summary.html    Lists classes with first sentence summaries for this package
          * package-frame.html      Lists classes in this package, used in lower left-hand frame
          * package-tree.html       Lists class hierarchy for this package
            package-use             Lists where this package is used
            doc-files               Directory holding image and example files
            class-use               Directory holding pages API is used
                Applet.html         Page for uses of Applet class
                AppletContext.html  Page for uses of AppletContext interface
                AppletStub.html     Page for uses of AppletStub interface
                AudioClip.html      Page for uses of AudioClip interface
   src-html                         Source code directory
       java                         Package directory
           applet                   Subpackage directory
                Applet.html         Page for Applet source code
                AppletContext.html  Page for AppletContext source code
                AppletStub.html     Page for AppletStub source code
                AudioClip.html      Page for AudioClip source code

Generated API Declarations

The Javadoc tool generates a declaration at the start of each class, interface, field, constructor, and method description for that API item. For example, the declaration for the Boolean class is:

public final class Boolean
extends Object
implements Serializable

and the declaration for the Boolean.valueOfmethod is:

public static Boolean valueOf(String s)

The Javadoc tool can include the modifiers public, protected, private, abstract, final, static, transient, and volatile, but not synchronized or native. These last two modifiers are considered implementation detail and not part of the API specification.

Rather than relying on the keyword synchronized, APIs should document their concurrency semantics in the comment's main description, as in "a single Enumeration cannot be used by multiple threads concurrently". The document should not describe how to achieve these semantics. As another example, while Hashtable should be thread-safe, there's no reason to specify that we achieve this by synchronizing all of its exported methods. We should reserve the right to synchronize internally at the bucket level, thus offering higher concurrency.

DOCUMENTATION COMMENTS

The original "Documentation Comment Specification" can be found under related documentation.

Commenting the Source Code

You can include documentation comments ("doc comments") in the source code, ahead of declarations for any class, interface, method, constructor, or field. You can also create doc comments for each package and another one for the overview, though their syntax is slightly different. Doc comments are also known informally as "Javadoc comments" (but this term violates its trademark usage). A doc comment consists of the characters between the characters /** that begin the comment and the characters */ that end it. Leading asterisks are allowed on each line and are described further below. The text in a comment can continue onto multiple lines.
/**
 * This is the typical format of a simple documentation comment
 * that spans two lines.
 */
To save space you can put a comment on one line:
/** This comment takes up only one line. */
Placement of comments - Documentation comments are recognized only when placed immediately before class, interface, constructor, method, or field declarations -- see the class example, method example, and field example. Documentation comments placed in the body of a method are ignored. Only one documentation comment per declaration statement is recognized by the Javadoc tool.

A common mistake is to put an import statement between the class comment and the class declaration. Avoid this, as the Javadoc tool will ignore the class comment.

   /**
    * This is the class comment for the class Whatever.
    */

    import com.sun;   // MISTAKE - Important not to put import statement here

    public class Whatever {
    }
A doc comment is composed of a main description followed by a tag section - The main description begins after the starting delimiter /** and continues until the tag section. The tag section starts with the first block tag, which is defined by the first @ character that begins a line (ignoring leading asterisks, white space, and leading separator /**). It is possible to have a comment with only a tag section and no main description. The main description cannot continue after the tag section begins. The argument to a tag can span multiple lines. There can be any number of tags -- some types of tags can be repeated while others cannot. For example, this @see starts the tag section:
/**
 * This sentence would hold the main description for this doc comment.
 * @see java.lang.Object
 */
Block tags and in-line tags - A tag is a special keyword within a doc comment that the Javadoc tool can process. There are two kinds of tags: block tags, which appear as @tag (also known as "standalone tags"), and in-line tags, which appear within curly braces, as {@tag}. To be interpreted, a block tag must appear at the beginning of a line, ignoring leading asterisks, white space, and separator (/**). This means you can use the @ character elsewhere in the text and it will not be interpreted as the start of a tag. If you want to start a line with the @ character and not have it be interpreted, use the HTML entity &#064;. Each block tag has associated text, which includes any text following the tag up to, but not including, either the next tag, or the end of the doc comment. This associated text can span multiple lines. An in-line tag is allowed and interpreted anywhere that text is allowed. The following example contains the block tag @deprecated and in-line tag {@link}.
/**
 * @deprecated  As of JDK 1.1, replaced by {@link #setBounds(int,int,int,int)}
 */

Comments are written in HTML - The text must be written in HTML, in that they should use HTML entities and can use HTML tags. You can use whichever version of HTML your browser supports; we have written the standard doclet to generate HTML 3.2-compliant code elsewhere (outside of the documentation comments) with the inclusion of cascading style sheets and frames. (We preface each generated file with "HTML 4.0" because of the frame sets.)

For example, entities for the less-than (<) and greater-than (>) symbols should be written &lt; and &gt;. Likewise, the ampersand (&) should be written &amp;. The bold HTML tag <b> is shown in the following example.

Here is a doc comment:

/**
 * This is a <b>doc</b> comment.
 * @see java.lang.Object
 */

Leading asterisks - When javadoc parses a doc comment, leading asterisk (*) characters on each line are discarded; blanks and tabs preceding the initial asterisk (*) characters are also discarded. Starting with 1.4, if you omit the leading asterisk on a line, the leading white space is no longer removed. This enables you to paste code examples directly into a doc comment inside a <PRE> tag, and its indentation will be honored. Spaces are generally interpreted by browsers more uniformly than tabs. Indentation is relative to the left margin (rather than the separator /** or <PRE> tag).

First sentence - The first sentence of each doc comment should be a summary sentence, containing a concise but complete description of the declared entity. This sentence ends at the first period that is followed by a blank, tab, or line terminator, or at the first block tag. The Javadoc tool copies this first sentence to the member summary at the top of the HTML page.

Declaration with multiple fields - Java allows declaring multiple fields in a single statement, but this statement can have only one documentation comment, which is copied for all fields. Therefore if you want individual documentation comments for each field, you must declare each field in a separate statement. For example, the following documentation comment doesn't make sense written as a single declaration and would be better handled as two declarations:

/**
 * The horizontal and vertical distances of point (x,y)
 */
public int x, y;      // Avoid this
The Javadoc tool generates the following documentation from the above code:
public int x
The horizontal and vertical distances of point (x,y)
public int y
The horizontal and vertical distances of point (x,y)
Use header tags carefully - When writing documentation comments for members, it's best not to use HTML heading tags such as <H1> and <H2>, because the Javadoc tool creates an entire structured document and these structural tags might interfere with the formatting of the generated document. However, it is fine to use these headings in class and package comments to provide your own structure.

Automatic Copying of Method Comments

The Javadoc tool has the ability to copy or "inherit" method comments in classes and interfaces under the following two circumstances. Constructors, fields and nested classes do not inherit doc comments.
  • Automatically inherit comment to fill in missing text - When a main description, or @return, @param or @throws tag is missing from a method comment, the Javadoc tool copies the corresponding main description or tag comment from the method it overrides or implements (if any), according to the algorithm below.

    More specifically, when a @param tag for a particular parameter is missing, then the comment for that parameter is copied from the method further up the inheritance hierarchy. When a @throws tag for a particular exception is missing, the @throws tag is copied only if that exception is declared.

    This behavior contrasts with version 1.3 and earlier, where the presence of any main description or tag would prevent all comments from being inherited.

  • Explicitly inherit comment with {@inheritDoc} tag - Insert the inline tag {@inheritDoc} in a method main description or @return, @param or @throws tag comment -- the corresponding inherited main description or tag comment is copied into that spot.

The source file for the inherited method need only be on the path specified by -sourcepath for the doc comment to actually be available to copy. Neither the class nor its package needs to be passed in on the command line. This contrasts with 1.3.x and earlier releases, where the class had to be a documented class

Inherit from classes and interfaces - Inheriting of comments occurs in all three possible cases of inheritance from classes and interfaces:

  • When a method in a class overrides a method in a superclass
  • When a method in an interface overrides a method in a superinterface
  • When a method in a class implements a method in an interface

In the first two cases, for method overrides, the Javadoc tool generates a subheading "Overrides" in the documentation for the overriding method, with a link to the method it is overriding, whether or not the comment is inherited.

In the third case, when a method in a given class implements a method in an interface, the Javadoc tool generates a subheading "Specified by" in the documentation for the overriding method, with a link to the method it is implementing. This happens whether or not the comment is inherited.

Algorithm for Inheriting Method Comments - If a method does not have a doc comment, or has an {@inheritDoc} tag, the Javadoc tool searches for an applicable comment using the following algorithm, which is designed to find the most specific applicable doc comment, giving preference to interfaces over superclasses:

  1. Look in each directly implemented (or extended) interface in the order they appear following the word implements (or extends) in the method declaration. Use the first doc comment found for this method.
  2. If step 1 failed to find a doc comment, recursively apply this entire algorithm to each directly implemented (or extended) interface, in the same order they were examined in step 1.
  3. If step 2 failed to find a doc comment and this is a class other than Object (not an interface):
    1. If the superclass has a doc comment for this method, use it.
    2. If step 3a failed to find a doc comment, recursively apply this entire algorithm to the superclass.

JAVADOC TAGS

The Javadoc tool parses special tags when they are embedded within a Java doc comment. These doc tags enable you to autogenerate a complete, well-formatted API from your source code. The tags start with an "at" sign (@) and are case-sensitive -- they must be typed with the uppercase and lowercase letters as shown. A tag must start at the beginning of a line (after any leading spaces and an optional asterisk) or it is treated as normal text. By convention, tags with the same name are grouped together. For example, put all @see tags together.

Tags come in two types:

  • Block tags - Can be placed only in the tag section that follows the main description. Block tags are of the form: @tag.
  • Inline tags - Can be placed anywhere in the main description or in the comments for block tags. Inline tags are denoted by curly braces: {@tag}.
For information about tags we might introduce in future releases, see Proposed Tags.

The current tags are:

Tag | Introduced in JDK/SDK
@author | 1.0
{@code} | 1.5
{@docRoot} | 1.3
@deprecated | 1.0
@exception | 1.0
{@inheritDoc} | 1.4
{@link} | 1.2
{@linkplain} | 1.4
{@literal} | 1.5
@param | 1.0
@return | 1.0
@see | 1.0
@serial | 1.2
@serialData | 1.2
@serialField | 1.2
@since | 1.1
@throws | 1.2
{@value} | 1.4
@version | 1.0

For custom tags, see the -tag option.

@author name-text
Adds an "Author" entry with the specified name-text to the generated docs when the -author option is used. A doc comment may contain multiple @author tags. You can specify one name per @author tag or multiple names per tag. In the former case, the Javadoc tool inserts a comma (,) and space between names. In the latter case, the entire text is simply copied to the generated document without being parsed. Therefore, you can use multiple names per line if you want a localized name separator other than comma.

For more details, see Where Tags Can Be Used and writing @author tags.

@deprecated deprecated-text
Note: Starting with JDK 5.0, you can deprecate a program element using the @Deprecated annotation.
Adds a comment indicating that this API should no longer be used (even though it may continue to work). The Javadoc tool moves the deprecated-text ahead of the main description, placing it in italics and preceding it with a bold warning: "Deprecated". This tag is valid in all doc comments: overview, package, class, interface, constructor, method and field.

The first sentence of deprecated-text should at least tell the user when the API was deprecated and what to use as a replacement. The Javadoc tool copies just the first sentence to the summary section and index. Subsequent sentences can also explain why it has been deprecated. You should include a {@link} tag (for Javadoc 1.2 or later) that points to the replacement API:

For more details, see writing @deprecated tags.

  • For Javadoc 1.2 and later, use a {@link} tag. This creates the link in-line, where you want it. For example:
    /**
 * @deprecated  As of JDK 1.1, replaced by {@link #setBounds(int,int,int,int)}
 */
  • For Javadoc 1.1, the standard format is to create a @see tag (which cannot be in-line) for each @deprecated tag.

For more about deprecation, see The @deprecated tag.

{@code text}
Equivalent to <code>{@literal}</code>.

Displays text in code font without interpreting the text as HTML markup or nested javadoc tags. This enables you to use regular angle brackets (< and >) instead of the HTML entities (&lt; and &gt;) in doc comments, such as in parameter types (<Object>), inequalities (3 < 4), or arrows (<-). For example, the doc comment text:

     {@code A<B>C}
displays in the generated HTML page unchanged, as:
     A<B>C
The noteworthy point is that the <B> is not interpreted as bold and is in code font.

If you want the same functionality without the code font, use {@literal}.

{@docRoot}
Represents the relative path to the generated document's (destination) root directory from any generated page. It is useful when you want to include a file, such as a copyright page or company logo, that you want to reference from all generated pages. Linking to the copyright page from the bottom of each page is common.

This {@docRoot} tag can be used both on the command line and in a doc comment: This tag is valid in all doc comments: overview, package, class, interface, constructor, method and field, including the text portion of any tag (such as @return, @param and @deprecated).

  1. On the command line, where the header/footer/bottom are defined:
       javadoc -bottom '<a href="{@docRoot}/copyright.html">Copyright</a>'
    NOTE - When using {@docRoot} this way in a make file, some makefile programs require special escaping for the brace {} characters. For example, the Inprise MAKE version 5.2 running on Windows requires double braces: {{@docRoot}}. It also requires double (rather than single) quotes to enclose arguments to options such as -bottom (with the quotes around the href argument omitted).
  2. In a doc comment:
       /**
    * See the <a href="{@docRoot}/copyright.html">Copyright</a>.
    */
The reason this tag is needed is because the generated docs are in hierarchical directories, as deep as the number of subpackages. This expression:
  <a href="{@docRoot}/copyright.html">
would resolve to:
  <a href="../../copyright.html">      for java/lang/Object.java
and
  <a href="../../../copyright.html">   for java/lang/ref/Reference.java

@exception class-name description
The @exception tag is a synonym for @throws.

{@inheritDoc}
Inherits (copies) documentation from the "nearest" inheritable class or implementable interface into the current doc comment at this tag's location. This allows you to write more general comments higher up the inheritance tree, and to write around the copied text.

This tag is valid only in these places in a doc comment:

  • In the main description block of a method. In this case, the main description is copied from a class or interface up the hierarchy.
  • In the text arguments of the @return, @param and @throws tags of a method. In this case, the tag text is copied from the corresponding tag up the hierarchy.

See Automatic Copying of Method Comments for a more precise description of how comments are found in the inheritance hierarchy. Note that if this tag is missing, the comment is or is not automatically inherited according to rules described in that section.

{@link package.class#member label}
Inserts an in-line link with visible text label that points to the documentation for the specified package, class or member name of a referenced class. This tag is valid in all doc comments: overview, package, class, interface, constructor, method and field, including the text portion of any tag (such as @return, @param and @deprecated).

This tag is very simliar to @see -- both require the same references and accept exactly the same syntax for package.class#member and label. The main difference is that {@link} generates an in-line link rather than placing the link in the "See Also" section. Also, the {@link} tag begins and ends with curly braces to separate it from the rest of the in-line text. If you need to use "}" inside the label, use the HTML entity notation &#125;

There is no limit to the number of {@link} tags allowed in a sentence. You can use this tag in the main description part of any documentation comment or in the text portion of any tag (such as @deprecated, @return or @param).

For example, here is a comment that refers to the getComponentAt(int, int) method:

Use the {@link #getComponentAt(int, int) getComponentAt} method.
From this, the standard doclet would generate the following HTML (assuming it refers to another class in the same package):
Use the <a href="Component.html#getComponentAt(int, int)">getComponentAt</a> method.
Which appears on the web page as:
Use the getComponentAt method.
You can extend {@link} to link to classes not being documented by using the -link option.

For more details, see writing {@link} tags.

{@linkplain package.class#member label}
Identical to {@link}, except the link's label is displayed in plain text than code font. Useful when the label is plain text. Example:
     Refer to {@linkplain add() the overridden method}.
This would display as:
Refer to the overridden method.
{@literal text}
Displays text without interpreting the text as HTML markup or nested javadoc tags. This enables you to use regular angle brackets (< and >) instead of the HTML entities (&lt; and &gt;) in doc comments, such as in parameter types (<Object>), inequalities (3 < 4), or arrows (<-). For example, the doc comment text:
     {@literal A<B>C}
displays unchanged in the generated HTML page in your browser, as:

     A<B>C

The noteworthy point is that the <B> is not interpreted as bold (and it is not in code font).

If you want the same functionality but with the text in code font, use {@code}.

@param parameter-name description
Adds a parameter with the specified parameter-name followed by the specified description to the "Parameters" section. When writing the doc comment, you may continue the description onto multiple lines. This tag is valid only in a doc comment for a method, constructor or class.

The parameter-name can be the name of a parameter in a method or constructor, or the name of a type parameter of a class, method or constructor. Use angle brackets around this parameter name to specify the use of a type parameter.

Example of a type parameter of a class:

     /**
      * @param <E> Type of element stored in a list
      */
     public interface List<E> extends Collection<E> {
     }

Example of a type parameter of a method:

     /**
      * @param string  the string to be converted
      * @param type    the type to convert the string to
      * @param <T>     the type of the element
      * @param <V>     the value of the element
      */
     <T, V extends T> V convert(String string, Class<T> type) {
     }
For more details, see writing @param tags.

@return description
Adds a "Returns" section with the description text. This text should describe the return type and permissible range of values. This tag is valid only in a doc comment for a method.

For more details, see writing @return tags.

@see reference
Adds a "See Also" heading with a link or text entry that points to reference. A doc comment may contain any number of @see tags, which are all grouped under the same heading. The @see tag has three variations; the third form below is the most common. This tag is valid in any doc comment: overview, package, class, interface, constructor, method or field. For inserting an in-line link within a sentence to a package, class or member, see {@link}.
@see "string"
Adds a text entry for string. No link is generated. The string is a book or other reference to information not available by URL. The Javadoc tool distinguishes this from the previous cases by looking for a double-quote (") as the first character. For example:
     @see "The Java Programming Language"
This generates text such as:
See Also:
"The Java Programming Language"
@see <a href="URL#value">label</a>
Adds a link as defined by URL#value. The URL#value is a relative or absolute URL. The Javadoc tool distinguishes this from other cases by looking for a less-than symbol (<) as the first character. For example:
     @see <a href="spec.html#section">Java Spec</a>
This generates a link such as:
See Also:
Java Spec
@see package.class#member label
Adds a link, with visible text label, that points to the documentation for the specified name in the Java Language that is referenced. The label is optional; if omitted, the name appears instead as the visible text, suitably shortened -- see How a name is displayed. Use -noqualifier to globally remove the package name from this visible text. Use the label when you want the visible text to be different from the auto-generated visible text.

Only in version 1.2, just the name but not the label would automatically appear in <code> HTML tags, Starting with 1.2.2, the <code> is always included around the visible text, whether or not a label is used.

  • package.class#member is any valid program element name that is referenced -- a package, class, interface, constructor, method or field name -- except that the character ahead of the member name should be a hash character (#). The class represents any top-level or nested class or interface. The member represents any constructor, method or field (not a nested class or interface). If this name is in the documented classes, the Javadoc tool will automatically create a link to it. To create links to external referenced classes, use the -link option. Use either of the other two @see forms for referring to documentation of a name that does not belong to a referenced class. This argument is described at greater length below under Specifying a Name.
  • label is optional text that is visible as the link's label. The label can contain whitespace. If label is omitted, then package.class.member will appear, suitably shortened relative to the current class and package -- see How a name is displayed.
  • A space is the delimiter between package.class#member and label. A space inside parentheses does not indicate the start of a label, so spaces may be used between parameters in a method.

Example - In this example, an @see tag (in the Character class) refers to the equals method in the String class. The tag includes both arguments: the name "String#equals(Object)" and the label "equals".

 /**
  * @see String#equals(Object) equals
  */
The standard doclet produces HTML something like this:
<dl>
<dt><b>See Also:</b>
<dd><a href="../../java/lang/String#equals(java.lang.Object)"><code>equals<code></a>
</dl>
Which looks something like this in a browser, where the label is the visible link text:
See Also:
equals

Specifying a name - This package.class#member name can be either fully-qualified, such as java.lang.String#toUpperCase() or not, such as String#toUpperCase() or #toUpperCase(). If less than fully-qualified, the Javadoc tool uses the normal Java compiler search order to find it, further described below in Search order for @see. The name can contain whitespace within parentheses, such as between method arguments.

Of course the advantage of providing shorter, "partially-qualified" names is that they are shorter to type and there is less clutter in the source code. The following table shows the different forms of the name, where Class can be a class or interface, Type can be a class, interface, array, or primitive, and method can be a method or constructor.

Typical forms for @see package.class#member
Referencing a member of the current class
@see #field
@see #method(Type, Type,...)
@see #method(Type argname, Type argname,...)
@see #constructor(Type, Type,...)
@see #constructor(Type argname, Type argname,...)

Referencing another class in the current or imported packages
@see Class#field
@see Class#method(Type, Type,...)
@see Class#method(Type argname, Type argname,...)
@see Class#constructor(Type, Type,...)
@see Class#constructor(Type argname, Type argname,...)
@see Class.NestedClass
@see Class

Referencing an element in another package (fully qualified)
@see package.Class#field
@see package.Class#method(Type, Type,...)
@see package.Class#method(Type argname, Type argname,...)
@see package.Class#constructor(Type, Type,...)
@see package.Class#constructor(Type argname, Type argname,...)
@see package.Class.NestedClass
@see package.Class
@see package

The following notes apply to the above table:

  • The first set of forms (with no class or package) will cause the Javadoc tool to search only through the current class's hierarchy. It will find a member of the current class or interface, one of its superclasses or superinterfaces, or one of its enclosing classes or interfaces (search steps 1-3). It will not search the rest of the current package or other packages (search steps 4-5).
  • If any method or constructor is entered as a name with no parentheses, such as getValue, and if there is no field with the same name, the Javadoc tool will correctly create a link to it, but will print a warning message reminding you to add the parentheses and arguments. If this method is overloaded, the Javadoc tool will link to the first method its search encounters, which is unspecified.
  • Nested classes must be specified as outer.inner, not simply inner, for all forms.
  • As stated, the hash character (#), rather than a dot (.) separates a member from its class. This enables the Javadoc tool to resolve ambiguities, since the dot also separates classes, nested classes, packages, and subpackages. However, the Javadoc tool is generally lenient and will properly parse a dot if you know there is no ambiguity, though it will print a warning.

Search order for @see - the Javadoc tool will process a @see tag that appears in a source file (.java), package file (package.html or package-info.java) or overview file (overview.html). In the latter two files, you must fully-qualify the name you supply with @see. In a source file, you can specify a name that is fully-qualified or partially-qualified.

When the Javadoc tool encounters a @see tag in a .java file that is not fully qualified, it searches for the specified name in the same order as the Java compiler would (except the Javadoc tool will not detect certain namespace ambiguities, since it assumes the source code is free of these errors). This search order is formally defined in Chapter 6, "Names" of the Java Language Specification, Second Edition. The Javadoc tool searches for that name through all related and imported classes and packages. In particular, it searches in this order:

  1. the current class or interface
  2. any enclosing classes and interfaces, searching closest first
  3. any superclasses and superinterfaces, searching closest first
  4. the current package
  5. any imported packages, classes and interfaces, searching in the order of the import statement

The Javadoc tool continues to search recursively through steps 1-3 for each class it encounters until it finds a match. That is, after it searches through the current class and its enclosing class E, it will search through E's superclasses before E's enclosing classes. In steps 4 and 5, the Javadoc tool does not search classes or interfaces within a package in any specified order (that order depends on the particular compiler). In step 5, the Javadoc tool looks in java.lang, since that is automatically imported by all programs.

The Javadoc tool does not necessarily look in subclasses, nor will it look in other packages even if their documentation is being generated in the same run. For example, if the @see tag is in the java.awt.event.KeyEvent class and refers to a name in the java.awt package, javadoc does not look in that package unless that class imports it.

How a name is displayed - If label is omitted, then package.class.member appears. In general, it is suitably shortened relative to the current class and package. By "shortened", we mean the Javadoc tool displays only the minimum name necessary. For example, if the String.toUpperCase() method contains references to a member of the same class and to a member of a different class, the class name is displayed only in the latter case, as shown in the following table.

Use -noqualifier to globally remove the package names.

Type of Reference Example in String.toUpperCase() Displays As
@see tag refers to member of the same class, same package @see String#toLowerCase()
 toLowerCase()
(omits the package and class names)
@see tag refers to member of a different class, same package @see Character#toLowerCase(char)
 Character.toLowerCase(char)
(omits the package name, includes the class name)
@see tag refers to member of a different class, different package @see java.io.File#exists()
 java.io.File.exists()
(includes the package and class names)

Examples of @see
The comment to the right shows how the name would be displayed if the @see tag is in a class in another package, such as java.applet.Applet.

                                           See also:
@see java.lang.String                   //  String
@see java.lang.String The String class  //  The String class
@see String                             //  String
@see String#equals(Object)              //  String.equals(Object)
@see String#equals                      //  String.equals(java.lang.Object)
@see java.lang.Object#wait(long)        //  java.lang.Object.wait(long)
@see Character#MAX_RADIX                //  Character.MAX_RADIX
@see <a href="spec.html">Java Spec</a>  //  Java Spec
@see "The Java Programming Language"    //  "The Java Programming Language"
You can extend @see to link to classes not being documented by using the -link option.

For more details, see writing @see tags.

@serial field-description | include | exclude
Used in the doc comment for a default serializable field.

An optional field-description should explain the meaning of the field and list the acceptable values. If needed, the description can span multiple lines. The standard doclet adds this information to the serialized form page.

If a serializable field was added to a class some time after the class was made serializable, a statement should be added to its main description to identify at which version it was added.

The include and exclude arguments identify whether a class or package should be included or excluded from the serialized form page. They work as follows:

  • A public or protected class that implements Serializable is included unless that class (or its package) is marked @serial exclude.
  • A private or package-private class that implements Serializable is excluded unless that class (or its package) is marked @serial include.

Examples: The javax.swing package is marked @serial exclude (in package.html or package-info.java). The public class java.security.BasicPermission is marked @serial exclude. The package-private class java.util.PropertyPermissionCollection is marked @serial include.

The tag @serial at a class level overrides @serial at a package level.

For more information about how to use these tags, along with an example, see "Documenting Serializable Fields and Data for a Class," Section 1.6 of the Java Object Serialization Specification. Also see the Serialization FAQ, which covers common questions, such as "Why do I see javadoc warnings stating that I am missing @serial tags for private fields if I am not running javadoc with the -private switch?". Also see Sun's criteria for including classes in the serialized form specification.

@serialField field-name field-type field-description
Documents an ObjectStreamField component of a Serializable class's serialPersistentFields member. One @serialField tag should be used for each ObjectStreamField component.

@serialData data-description
The data-description documents the types and order of data in the serialized form. Specifically, this data includes the optional data written by the writeObject method and all data (including base classes) written by the Externalizable.writeExternal method.

The @serialData tag can be used in the doc comment for the writeObject, readObject, writeExternal, readExternal, writeReplace, and readResolve methods.

@since since-text
Adds a "Since" heading with the specified since-text to the generated documentation. The text has no special internal structure. This tag is valid in any doc comment: overview, package, class, interface, constructor, method or field. This tag means that this change or feature has existed since the software release specified by the since-text. For example:
    @since 1.5
For source code in the Java platform, this tag indicates the version of the Java platform API specification (not necessarily when it was added to the reference implementation). Multiple @since tags are allowed and are treated like multiple @author tags. You could use multiple tags if the prgram element is used by more than one API.

@throws class-name description
The @throws and @exception tags are synonyms. Adds a "Throws" subheading to the generated documentation, with the class-name and description text. The class-name is the name of the exception that may be thrown by the method. This tag is valid only in the doc comment for a method or constructor. If this class is not fully-specified, the Javadoc tool uses the search order to look up this class. Multiple @throws tags can be used in a given doc comment for the same or different exceptions.

To ensure that all checked exceptions are documented, if a @throws tag does not exist for an exception in the throws clause, the Javadoc tool automatically adds that exception to the HTML output (with no description) as if it were documented with @throws tag.

The @throws documentation is copied from an overridden method to a subclass only when the exception is explicitly declared in the overridden method. The same is true for copying from an interface method to an implementing method. You can use {@inheritDoc} to force @throws to inherit documentation.

For more details, see writing @throws tags.

{@value package.class#field}
When {@value} is used (without any argument) in the doc comment of a static field, it displays the value of that constant:
    /**
     * The value of this constant is {@value}.
     */
    public static final String SCRIPT_START = "<script>"
When used with argument package.class#field in any doc comment, it displays the value of the specified constant:
    /**
     * Evaluates the script starting with {@value #SCRIPT_START}.
     */
    public String evalScript(String script) {
    }
The argument package.class#field takes a form identical to that of the @see argument, except that the member must be a static field.

These values of these constants are also displayed on the Constant Field Values page.

@version version-text
Adds a "Version" subheading with the specified version-text to the generated docs when the -version option is used. This tag is intended to hold the current version number of the software that this code is part of (as opposed to @since, which holds the version number where this code was introduced). The version-text has no special internal structure. To see where the version tag can be used, see Where Tags Can Be Used.

A doc comment may contain multiple @version tags. If it makes sense, you can specify one version number per @version tag or multiple version numbers per tag. In the former case, the Javadoc tool inserts a comma (,) and space between names. In the latter case, the entire text is simply copied to the generated document without being parsed. Therefore, you can use multiple names per line if you want a localized name separator other than comma.

For more details, see writing @version tags.

Where Tags Can Be Used

The following sections describe where the tags can be used. Note that these tags can be used in all doc comments: @see, @since, @deprecated, {@link}, {@linkplain}, and {@docroot}.

Overview Documentation Tags

Overview tags are tags that can appear in the documentation comment for the overview page (which resides in the source file typically named overview.html). Like in any other documentation comments, these tags must appear after the main description.

NOTE - The {@link} tag has a bug in overview documents in version 1.2 -- the text appears properly but has no link. The {@docRoot} tag does not currently work in overview documents.

Overview Tags
@see
@since
@author
@version
{@link}
{@linkplain}
{@docRoot}

Package Documentation Tags

Package tags are tags that can appear in the documentation comment for a package (which resides in the source file named package.html or package-info.java). The @serial tag can only be used here with the include or exclude argument.
Package Tags
@see
@since
@serial
@author
@version
{@link}
{@linkplain}
{@docRoot}

Class and Interface Documentation Tags

The following are tags that can appear in the documentation comment for a class or interface. The @serial tag can only be used here with the include or exclude argument.
Class/Interface Tags
@see
@since
@deprecated
@serial
@author
@version
{@link}
{@linkplain}
{@docRoot}

An example of a class comment:

/**
 * A class representing a window on the screen.
 * For example:
 * <pre>
 *    Window win = new Window(parent);
 *    win.show();
 * </pre>
 *
 * @author  Sami Shaio
 * @version 1.14, 10/18/06
 * @see     java.awt.BaseWindow
 * @see     java.awt.Button
 */
class Window extends BaseWindow {
   ...
}

Field Documentation Tags

The following are the tags that can appear in the documentation comment for a field.
Field Tags
@see
@since
@deprecated
@serial
@serialField
{@link}
{@linkplain}
{@docRoot}
{@value}

An example of a field comment:

    /**
     * The X-coordinate of the component.
     *
     * @see #getLocation()
     */
    int x = 1263732;

Constructor and Method Documentation Tags

The following are the tags that can appear in the documentation comment for a constructor or method, except for @return, which cannot appear in a constructor, and {@inheritDoc}, which has certain restrictions. The @serialData tag can only be used in the doc comment for certain serialization methods.
Method/Constructor Tags
@see
@since
@deprecated
@param
@return
@throws and @exception
@serialData
{@link}
{@linkplain}
{@inheritDoc}
{@docRoot}

An example of a method doc comment:

    /**
     * Returns the character at the specified index. An index
     * ranges from <code>0</code> to <code>length() - 1</code>.
     *
     * @param     index  the index of the desired character.
     * @return    the desired character.
     * @exception StringIndexOutOfRangeException
     *              if the index is not in the range <code>0</code>
     *              to <code>length()-1</code>.
     * @see       java.lang.Character#charValue()
     */
    public char charAt(int index) {
       ...
    }

OPTIONS

The javadoc tool uses doclets to determine its output. The Javadoc tool uses the default standard doclet unless a custom doclet is specified with the -doclet option. The Javadoc tool provides a set of command-line options that can be used with any doclet -- these options are described below under the sub-heading Javadoc Options. The standard doclet provides an additional set of command-line options that are described below under the sub-heading Options Provided by the Standard Doclet. All option names are case-insensitive, though their arguments can be case-sensitive.

The options are:

-1.1
-author
-bootclasspath
-bottom
-breakiterator
-charset
-classpath
-d
-docencoding
-docfilessubdirs
-doclet
-docletpath
-doctitle
-encoding
-exclude
-excludedocfilessubdir
-extdirs
-footer
-group
 -header
-help
-helpfile
-J
-keywords
-link
-linkoffline
-linksource
-locale
-nocomment
-nodeprecated
-nodeprecatedlist
-nohelp
-noindex
-nonavbar
-noqualifier
-nosince
-notimestamp
-notree
-overview
-package
 -private
-protected
-public
-quiet
-serialwarn
-source
-sourcepath
-splitindex
-stylesheetfile
-subpackages
-tag
-taglet
-tagletpath
-title
-use
-verbose
-version
-windowtitle
Options shown in italic are the Javadoc core options, which are provided by the front end of the Javadoc tool and are available to all doclets. The standard doclet itself provides the non-italic options.

Javadoc Options

-overview path\filename
Specifies that javadoc should retrieve the text for the overview documentation from the "source" file specified by path/filename and place it on the Overview page (overview-summary.html). The path/filename is relative to the -sourcepath.

While you can use any name you want for filename and place it anywhere you want for path, a typical thing to do is to name it overview.html and place it in the source tree at the directory that contains the topmost package directories. In this location, no path is needed when documenting packages, since -sourcepath will point to this file. For example, if the source tree for the java.lang package is C:\src\classes\java\lang\, then you could place the overview file at C:\src\classes\overview.html. See Real World Example.

For information about the file specified by path/filename, see overview comment file.

Note that the overview page is created only if you pass into javadoc two or more package names. For further explanation, see HTML Frames.)

The title on the overview page is set by -doctitle.

-public
Shows only public classes and members.

-protected
Shows only protected and public classes and members. This is the default.

-package
Shows only package, protected, and public classes and members.

-private
Shows all classes and members.

-help
Displays the online help, which lists these javadoc and doclet command line options.

-doclet class
Specifies the class file that starts the doclet used in generating the documentation. Use the fully-qualified name. This doclet defines the content and formats the output. If the -doclet option is not used, javadoc uses the standard doclet for generating the default HTML format. This class must contain the start(Root) method. The path to this starting class is defined by the -docletpath option.

For example, to call the MIF doclet, use:

    -doclet com.sun.tools.doclets.mif.MIFDoclet

For full, working examples of running a particular doclet, see Running the MIF Doclet.

-docletpath classpathlist
Specifies the path to the doclet starting class file (specified with the -doclet option) and any jar files it depends on. If the starting class file is in a jar file, then this specifies the path to that jar file, as shown in the example below. You can specify an absolute path or a path relative to the current directory. If classpathlist contains multiple paths or jar files, they should be separated with a colon (:) on Solaris and a semi-colon (;) on Windows. This option is not necessary if the doclet starting class is already in the search path.

Example of path to jar file that contains the starting doclet class file. Notice the jar filename is included.

   -docletpath C:\user\mifdoclet\lib\mifdoclet.jar
Example of path to starting doclet class file. Notice the class filename is omitted.
   -docletpath C:\user\mifdoclet\classes\com\sun\tools\doclets\mif\
For full, working examples of running a particular doclet, see Running the MIF Doclet.

-1.1
This feature has been removed from Javadoc 1.4. There is no replacement for it. This option created documentation with the appearance and functionality of documentation generated by Javadoc 1.1 (it never supported nested classes). If you need this option, use Javadoc 1.2 or 1.3 instead.

-source release
Specifies the version of source code accepted. The following values for release are allowed:
1.5 | javadoc accepts code containing generics and other language features introduced in JDK 1.5. The compiler defaults to the 1.5 behavior if the -source flag is not used.
1.4 | javadoc accepts code containing assertions, which were introduced in JDK 1.4.
1.3 | javadoc does not support assertions, generics, or other language features introduced after JDK 1.3.

Use the value of release corresponding to that used when compiling the code with javac.

-sourcepath sourcepathlist
Specifies the search paths for finding source files (.java) when passing package names or -subpackages into the javadoc command. The sourcepathlist can contain multiple paths by separating them with a semicolon (;). The Javadoc tool will search in all subdirectories of the specified paths. Note that this option is not only used to locate the source files being documented, but also to find source files that are not being documented but whose comments are inherited by the source files being documented.

Note that you can use the -sourcepath option only when passing package names into the javadoc command -- it will not locate .java files passed into the javadoc command. (To locate .java files, cd to that directory or include the path ahead of each file, as shown at Documenting One or More Classes.) If -sourcepath is omitted, javadoc uses the class path to find the source files (see -classpath). Therefore, the default -sourcepath is the value of class path. If -classpath is omitted and you are passing package names into javadoc, it looks in the current directory (and subdirectories) for the source files.

Set sourcepathlist to the root directory of the source tree for the package you are documenting. For example, suppose you want to document a package called com.mypackage whose source files are located at:

C:\user\src\com\mypackage\*.java
In this case you would specify the sourcepath to C:\user\src, the directory that contains com\mypackage, and then supply the package name com.mypackage:
  C:> javadoc -sourcepath C:\user\src com.mypackage
This is easy to remember by noticing that if you concatenate the value of sourcepath and the package name together and change the dot to a backslash "\", you end up with the full path to the package: C:\user\src\com\mypackage.

To point to two source paths:

  C:> javadoc -sourcepath C:\user1\src;C:\user2\src com.mypackage

-classpath classpathlist
Specifies the paths where javadoc will look for referenced classes (.class files) -- these are the documented classes plus any classes referenced by those classes. The classpathlist can contain multiple paths by separating them with a semicolon (;). The Javadoc tool will search in all subdirectories of the specified paths. Follow the instructions in class path documentation for specifying classpathlist.

If -sourcepath is omitted, the Javadoc tool uses -classpath to find the source files as well as class files (for backward compatibility). Therefore, if you want to search for source and class files in separate paths, use both -sourcepath and -classpath.

For example, if you want to document com.mypackage, whose source files reside in the directory C:\user\src\com\mypackage, and if this package relies on a library in C:\user\lib, you would specify:

  C:> javadoc -classpath \user\lib -sourcepath \user\src com.mypackage
As with other tools, if you do not specify -classpath, the Javadoc tool uses the CLASSPATH environment variable, if it is set. If both are not set, the Javadoc tool searches for classes from the current directory.

For an in-depth description of how the Javadoc tool uses -classpath to find user classes as it relates to extension classes and bootstrap classes, see How Classes Are Found.

As a special convenience, a class path element containing a basename of * is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR (a java program cannot tell the difference between the two invocations).

For example, if directory foo contains a.jar and b.JAR, then the class path element foo/* is expanded to a A.jar:b.JAR, except that the order of jar files is unspecified. All jar files in the specified directory, even hidden ones, are included in the list. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. The CLASSPATH environment variable, where defined, will be similarly expanded. Any classpath wildcard expansion occurs before the Java virtual machine is started -- no Java program will ever see unexpanded wildcards except by querying the environment. For example; by invoking System.getenv("CLASSPATH").

-subpackages package1:package2:...
Generates documentation from source files in the specified packages and recursively in their subpackages. This option is useful when adding new subpackages to the source code, as they are automatically included. Each package argument is any top-level subpackage (such as java) or fully qualified package (such as javax.swing) that does not need to contain source files. Arguments are separated by colons (on all operating systmes). Wildcards are not needed or allowed. Use -sourcepath to specify where to find the packages. This option is smart about not processing source files that are in the source tree but do not belong to the packages, as described at processing of source files.

For example:

  C:> javadoc -d docs -sourcepath C:\user\src -subpackages java:javax.swing
This command generates documentation for packages named "java" and "javax.swing" and all their subpackages.

You can use -subpackages in conjunction with -exclude to exclude specific packages.

-exclude packagename1:packagename2:...
Unconditionally excludes the specified packages and their subpackages from the list formed by -subpackages. It excludes those packages even if they would otherwise be included by some previous or later -subpackages option. For example:
  C:> javadoc -sourcepath C:\user\src -subpackages java -exclude java.net:java.lang
would include java.io, java.util, and java.math (among others), but would exclude packages rooted at java.net and java.lang. Notice this excludes java.lang.ref, a subpackage of java.lang).

-bootclasspath classpathlist
Specifies the paths where the boot classes reside. These are nominally the Java platform classes. The bootclasspath is part of the search path the Javadoc tool will use to look up source and class files. See How Classes Are Found. for more details. Separate directories in classpathlist with semicolons (;).

-extdirs dirlist
Specifies the directories where extension classes reside. These are any classes that use the Java Extension mechanism. The extdirs is part of the search path the Javadoc tool will use to look up source and class files. See -classpath (above) for more details. Separate directories in dirlist with semicolons (;).

-verbose
Provides more detailed messages while javadoc is running. Without the verbose option, messages appear for loading the source files, generating the documentation (one message per source file), and sorting. The verbose option causes the printing of additional messages specifying the number of milliseconds to parse each java source file.

-quiet
Shuts off non-error and non-warning messages, leaving only the warnings and errors appear, making them easier to view. Also suppresses the version string.

-breakiterator
Uses the internationalized sentence boundary of java.text.BreakIterator to determine the end of the first sentence for English (all other locales already use BreakIterator), rather than an English language, locale-specific algorithm. By first sentence, we mean the first sentence in the main description of a package, class or member. This sentence is copied to the package, class or member summary, and to the alphabetic index.

From JDK 1.2 forward, the BreakIterator class is already used to determine the end of sentence for all languages but English. Therefore, the -breakiterator option has no effect except for English from 1.2 forward. English has its own default algorithm:

  • English default sentence-break algorithm - Stops at a period followed by a space or a HTML block tag, such as <P>.
  • Breakiterator sentence-break algorithm - In general, stops at a period, question mark or exclamation mark followed by a space if the next word starts with a capital letter. This is meant to handle most abbreviations (such as "The serial no. is valid", but won't handle "Mr. Smith"). Doesn't stop at HTML tags or sentences that begin with numbers or symbols. Stops at the last period in "../filename", even if embedded in an HTML tag.
NOTE: We have removed from 1.5.0 the breakiterator warning messages that were in 1.4.x and have left the default sentence-break algorithm unchanged. That is, the -breakiterator option is not the default in 1.5.0, nor do we expect it to become the default. This is a reversal from our former intention that the default would change in the "next major release" (1.5.0). This means if you have not modified your source code to eliminate the breakiterator warnings in 1.4.x, then you don't have to do anything, and the warnings go away starting with 1.5.0. The reason for this reversal is because any benefit to having breakiterator become the default would be outweighed by the incompatible source change it would require. We regret any extra work and confusion this has caused.
-locale language_country_variant
Important - The -locale option must be placed ahead (to the left) of any options provided by the standard doclet or any other doclet. Otherwise, the navigation bars will appear in English. This is the only command-line option that is order-dependent.
Specifies the locale that javadoc uses when generating documentation. The argument is the name of the locale, as described in java.util.Locale documentation, such as en_US (English, United States) or en_US_WIN (Windows variant).

Specifying a locale causes javadoc to choose the resource files of that locale for messages (strings in the navigation bar, headings for lists and tables, help file contents, comments in stylesheet.css, and so forth). It also specifies the sorting order for lists sorted alphabetically, and the sentence separator to determine the end of the first sentence. It does not determine the locale of the doc comment text specified in the source files of the documented classes.

-encoding name
Specifies the encoding name of the source files, such as EUCJIS/SJIS. If this option is not specified, the platform default converter is used.

Also see -docencoding and -charset.

-J flag
Passes flag directly to the runtime system java that runs javadoc. Notice there must be no space between the J and the flag. For example, if you need to ensure that the system sets aside 32 megabytes of memory in which to process the generated documentation, then you would call the -Xmx option of java as follows (-Xms is optional, as it only sets the size of initial memory, which is useful if you know the minimum amount of memory required):
   C:> javadoc -J-Xmx32m -J-Xms32m com.mypackage
To tell what version of javadoc you are using, call the "-version" option of java:
   C:> javadoc -J-version
   java version "1.2"
   Classic VM (build JDK-1.2-V, green threads, sunwjit)
(The version number of the standard doclet appears in its output stream.)

Options Provided by the Standard Doclet

-d directory
Specifies the destination directory where javadoc saves the generated HTML files. (The "d" means "destination.") Omitting this option causes the files to be saved to the current directory. The value directory can be absolute, or relative to the current working directory. As of 1.4, the destination directory is automatically created when javadoc is run.

For example, the following generates the documentation for the package com.mypackage and saves the results in the C:\user\doc\ directory:

  C:> javadoc -d \user\doc com.mypackage

-use
Includes one "Use" page for each documented class and package. The page describes what packages, classes, methods, constructors and fields use any API of the given class or package. Given class C, things that use class C would include subclasses of C, fields declared as C, methods that return C, and methods and constructors with parameters of type C.

For example, let's look at what might appear on the "Use" page for String. The getName() method in the java.awt.Font class returns type String. Therefore, getName() uses String, and you will find that method on the "Use" page for String.

Note that this documents only uses of the API, not the implementation. If a method uses String in its implementation but does not take a string as an argument or return a string, that is not considered a "use" of String.

You can access the generated "Use" page by first going to the class or package, then clicking on the "Use" link in the navigation bar.

-version
Includes the @version text in the generated docs. This text is omitted by default. To tell what version of the Javadoc tool you are using, use the -J-version option.

-author
Includes the @author text in the generated docs.

-splitindex
Splits the index file into multiple files, alphabetically, one file per letter, plus a file for any index entries that start with non-alphabetical characters.

-windowtitle title
Specifies the title to be placed in the HTML <title> tag. This appears in the window title and in any browser bookmarks (favorite places) that someone creates for this page. This title should not contain any HTML tags, as the browser will not properly interpret them. Any internal quotation marks within title may have to be escaped. If -windowtitle is omitted, the Javadoc tool uses the value of -doctitle for this option.
  C:> javadoc -windowtitle "Java 2 Platform" com.mypackage
-doctitle title
Specifies the title to be placed near the top of the overview summary file. The title will be placed as a centered, level-one heading directly beneath the upper navigation bar. The title may contain html tags and white space, though if it does, it must be enclosed in quotes. Any internal quotation marks within title may have to be escaped.
  C:> javadoc -doctitle "Java<sup><font size=\"-2\">TM</font></sup>" com.mypackage
-title title
This option no longer exists. It existed only in Beta versions of Javadoc 1.2. It has been renamed to -doctitle. This option is being renamed to make it clear that it defines the document title rather than the window title.

-header header
Specifies the header text to be placed at the top of each output file. The header will be placed to the right of the upper navigation bar. header may contain HTML tags and white space, though if it does, it must be enclosed in quotes. Any internal quotation marks within header may have to be escaped.
  C:> javadoc -header "<b>Java 2 Platform </b><br>v1.4" com.mypackage

-footer footer
Specifies the footer text to be placed at the bottom of each output file. The footer will be placed to the right of the lower navigation bar. footer may contain html tags and white space, though if it does, it must be enclosed in quotes. Any internal quotation marks within footer may have to be escaped.

-bottom text
Specifies the text to be placed at the bottom of each output file. The text will be placed at the bottom of the page, below the lower navigation bar. The text may contain HTML tags and white space, though if it does, it must be enclosed in quotes. Any internal quotation marks within text may have to be escaped.

-link extdocURL
Creates links to existing javadoc-generated documentation of external referenced classes. It takes one argument:

  • extdocURL is the absolute or relative URL of the directory containing the external javadoc-generated documentation you want to link to. Examples are shown below. The package-list file must be found in this directory (otherwise, use -linkoffline). The Javadoc tool reads the package names from the package-list file and then links to those packages at that URL. When the Javadoc tool is run, the extdocURL value is copied literally into the <A HREF> links that are created. Therefore, extdocURL must be the URL to the directory, not to a file.

    You can use an absolute link for extdocURL to enable your docs to link to a document on any website, or can use a relative link to link only to a relative location. If relative, the value you pass in should be the relative path from the destination directory (specified with -d) to the directory containing the packages being linked to.

    When specifying an absolute link you normally use an http: link. However, if you want to link to a file system that has no web server, you can use a file: link -- however, do this only if everyone wanting to access the generated documentation shares the same file system.

    In all cases, and on all operating systems, you should use a forward slash as the separator, whether the URL is absolute or relative, and "http:" or "file:" based (as specified in the URL Memo).

    Absolute http: based link:
    -link http://<host>/<directory>/<directory>/.../<name>
    Absolute file: based link:
    -link file://<host>/<directory>/<directory>/.../<name>
    Relative link:
    -link <directory>/<directory>/.../<name>

You can specify multiple -link options in a given javadoc run to link to multiple documents.

Choosing between -linkoffline and -link:
Use -link:
  • when using a relative path to the external API document, or
  • when using an absolute URL to the external API document, if your shell allows a program to open a connection to that URL for reading.
Use -linkoffline:
  • when using an absolute URL to the external API document, if your shell does not allow a program to open a connection to that URL for reading. This can occur if you are behind a firewall and the document you want to link to is on the other side.

Example using absolute links to the external docs - Let's say you want to link to the java.lang, java.io and other Java 2 Platform packages at http://java.sun.com/j2se/1.5.0/docs/api, The following command generates documentation for the package com.mypackage with links to the Java 2 Platform packages. The generated documentation will contain links to the Object class, for example, in the class trees. (Other options, such as -sourcepath and -d, are not shown.)

  C:> javadoc -link http://java.sun.com/j2se/1.5.0/docs/api com.mypackage
Example using relative links to the external docs - Let's say you have two packages whose docs are generated in different runs of the Javadoc tool, and those docs are separated by a relative path. In this example, the packages are com.apipackage, an API, and com.spipackage, an SPI (Service Provide Interface). You want the documentation to reside in docs/api/com/apipackage and docs/spi/com/spipackage. Assuming the API package documentation is already generated, and that docs is the current directory, you would document the SPI package with links to the API documentation by running:
  C:> javadoc -d ./spi -link ../api com.spipackage

Notice the -link argument is relative to the destination directory (docs/spi).

Details - The -link option enables you to link to classes referenced to by your code but not documented in the current javadoc run. For these links to go to valid pages, you must know where those HTML pages are located, and specify that location with extdocURL. This allows, for instance, third party documentation to link to java.* documentation on http://java.sun.com.

Omit the -link option for javadoc to create links only to API within the documentation it is generating in the current run. (Without the -link option, the Javadoc tool does not create links to documentation for external references, because it does not know if or where that documentation exists.)

This option can create links in several places in the generated documentation.

Another use is for cross-links between sets of packages: Execute javadoc on one set of packages, then run javadoc again on another set of packages, creating links both ways between both sets.

How a Class Must be Referenced - For a link to an external referenced class to actually appear (and not just its text label), the class must be referenced in the following way. It is not sufficient for it to be referenced in the body of a method. It must be referenced in either an import statement or in a declaration. Here are examples of how the class java.io.File can be referenced:

  • In any kind of import statement: by wildcard import, import explicitly by name, or automatically import for java.lang.*. For example, this would suffice:
    import java.io.*;
    In 1.3.x and 1.2.x, only an explicit import by name works -- a wildcard import statement does not work, nor does the automatic import java.lang.*.
  • In a declaration:
    void foo(File f) {}
    The reference and be in the return type or parameter type of a method, constructor, field, class or interface, or in an implements, extends or throws statement.

An important corollary is that when you use the -link option, there may be many links that unintentionally do not appear due to this constraint. (The text would appear without a hypertext link.) You can detect these by the warnings they emit. The most innocuous way to properly reference a class and thereby add the link would be to import that class, as shown above.

Package List - The -link option requires that a file named package-list, which is generated by the Javadoc tool, exist at the URL you specify with -link. The package-list file is a simple text file that lists the names of packages documented at that location. In the earlier example, the Javadoc tool looks for a file named package-list at the given URL, reads in the package names and then links to those packages at that URL.

For example, the package list for the Java 2 Platform 5.0 API is located at http://java.sun.com/j2se/1.5.0/docs/api/package-list. and starts out as follows:

  java.applet
  java.awt
  java.awt.color
  java.awt.datatransfer
  java.awt.dnd
  java.awt.event
  java.awt.font
  etc.

When javadoc is run without the -link option, when it encounters a name that belongs to an external referenced class, it prints the name with no link. However, when the -link option is used, the Javadoc tool searches the package-list file at the specified extdocURL location for that package name. If it finds the package name, it prefixes the name with extdocURL.

In order for there to be no broken links, all of the documentation for the external references must exist at the specified URLs. The Javadoc tool will not check that these pages exist -- only that the package-list exists.

Multiple Links - You can supply multiple -link options to link to any number of external generated documents. Javadoc 1.2 has a known bug which prevents you from supplying more than one -link command. This was fixed in 1.2.2.

Specify a different link option for each external document to link to:

C:> javadoc -link extdocURL1 -link extdocURL2 ... -link extdocURLn com.mypackage

where extdocURL1, extdocURL2, ... extdocURLn point respectively to the roots of external documents, each of which contains a file named package-list.

Cross-links - Note that "bootstrapping" may be required when cross-linking two or more documents that have not previously been generated. In other words, if package-list does not exist for either document, when you run the Javadoc tool on the first document, the package-list will not yet exist for the second document. Therefore, to create the external links, you must re-generate the first document after generating the second document.

In this case, the purpose of first generating a document is to create its package-list (or you can create it by hand it if you're certain of the package names). Then generate the second document with its external links. The Javadoc tool prints a warning if a needed external package-list file does not exist.

-linkoffline extdocURL packagelistLoc
This option is a variation of -link; they both create links to javadoc-generated documentation for external referenced classes. Use the -linkoffline option when linking to a document on the web when the Javadoc tool itself is "offline" -- that is, it cannot access the document through a web connection.

More specifically, use -linkoffline if the external document's package-list file is not accessible or does not exist at the extdocURL location but does exist at a different location, which can be specified by packageListLoc (typically local). Thus, if extdocURL is accessible only on the World Wide Web, -linkoffline removes the constraint that the Javadoc tool have a web connection when generating the documentation.

Another use is as a "hack" to update docs: After you have run javadoc on a full set of packages, then you can run javadoc again on onlya smaller set of changed packages, so that the updated files can be inserted back into the original set. Examples are given below.

The -linkoffline option takes two arguments -- the first for the string to be embedded in the <a href> links, the second telling it where to find package-list:

  • extdocURL is the absolute or relative URL of the directory containing the external javadoc-generated documentation you want to link to. If relative, the value should be the relative path from the destination directory (specified with -d) to the root of the packages being linked to. For more details, see extdocURL in the -link option.
  • packagelistLoc is the path or URL to the directory containing the package-list file for the external documentation. This can be a URL (http: or file:) or file path, and can be absolute or relative. If relative, make it relative to the current directory from where javadoc was run. Do not include the package-list filename.

You can specify multiple -linkoffline options in a given javadoc run. (Prior to 1.2.2, it could be specified only once.)

Example using absolute links to the external docs - Let's say you want to link to the java.lang, java.io and other Java 2 Platform packages at http://java.sun.com/j2se/1.5.0/docs/api, but your shell does not have web access. You could open the package-list file in a browser at http://java.sun.com/j2se/1.5.0/docs/api/package-list, save it to a local directory, and point to this local copy with the second argument, packagelistLoc. In this example, the package list file has been saved to the current directory "." . The following command generates documentation for the package com.mypackage with links to the Java 2 Platform packages. The generated documentation will contain links to the Object class, for example, in the class trees. (Other necessary options, such as -sourcepath, are not shown.)

C:> javadoc -linkoffline http://java.sun.com/j2se/1.5.0/docs/api . com.mypackage

Example using relative links to the external docs - It's not very common to use -linkoffline with relative paths, for the simple reason that -link usually suffices. When using -linkoffline, the package-list file is generally local, and when using relative links, the file you are linking to is also generally local. So it is usually unnecessary to give a different path for the two arguments to -linkoffline. When the two arguments are identical, you can use -link. See the -link relative example.

Manually Creating a package-list File - If a package-list file does not yet exist, but you know what package names your document will link to, you can create your own copy of this file by hand and specify its path with packagelistLoc. An example would be the previous case where the package list for com.spipackage did not exist when com.apipackage was first generated. This technique is useful when you need to generate documentation that links to new external documentation whose package names you know, but which is not yet published. This is also a way of creating package-list files for packages generated with Javadoc 1.0 or 1.1, where package-list files were not generated. Likewise, two companies can share their unpublished package-list files, enabling them to release their cross-linked documentation simultaneously.

Linking to Multiple Documents - You can include -linkoffline once for each generated document you want to refer to (each option is shown on a separate line for clarity):

C:> javadoc -linkoffline extdocURL1 packagelistLoc1 \
          -linkoffline extdocURL2 packagelistLoc2 \
          ...

Updating docs - Another use for -linkoffline option is useful if your project has dozens or hundreds of packages, if you have already run javadoc on the entire tree, and now, in a separate run, you want to quickly make some small changes and re-run javadoc on just a small portion of the source tree. This is somewhat of a hack in that it works properly only if your changes are only to doc comments and not to declarations. If you were to add, remove or change any declarations from the source code, then broken links could show up in the index, package tree, inherited member lists, use page, and other places.

First, you create a new destination directory (call it update) for this new small run. Let's say the original destination directory was named html. In the simplest example, cd to the parent of html. Set the first argument of -linkoffline to the current directory "." and set the second argument to the relative path to html, where it can find package-list, and pass in only the package names of the packages you want to update:

  C:> javadoc -d update -linkoffline . html com.mypackage
When the Javadoc tool is done, copy these generated class pages in update\com\package (not the overview or index), over the original files in html\com\package.

-linksource
Creates an HTML version of each source file (with line numbers) and adds links to them from the standard HTML documentation. Links are created for classes, interfaces, constructors, methods and fields whose declarations are in a source file. Otherwise, links are not created, such as for default constructors and generated classes.

This option exposes all private implementation details in the included source files, including private classes, private fields, and the bodies of private methods, regardless of the -public, -package, -protected and -private options. Unless you also use the -private option, not all private classes or interfaces will necessarily be accessible via links.

Each link appears on the name of the identifier in its declaration. For example, the link to the source code of the Button class would be on the word "Button":

    public class Button
    extends Component
    implements Accessible
and the link to the source code of the getLabel() method in the Button class would be on the word "getLabel":
    public String getLabel()

-group groupheading packagepattern:packagepattern:...
Separates packages on the overview page into whatever groups you specify, one group per table. You specify each group with a different -group option. The groups appear on the page in the order specified on the command line; packages are alphabetized within a group. For a given -group option, the packages matching the list of packagepattern expressions appear in a table with the heading groupheading.
  • groupheading can be any text, and can include white space. This text is placed in the table heading for the group.
  • packagepattern can be any package name, or can be the start of any package name followed by an asterisk (*). The asterisk is a wildcard meaning "match any characters". This is the only wildcard allowed. Multiple patterns can be included in a group by separating them with colons (:).
NOTE: If using an asterisk in a pattern or pattern list, the pattern list must be inside quotes, such as "java.lang*:java.util"

If you do not supply any -group option, all packages are placed in one group with the heading "Packages". If the all groups do not include all documented packages, any leftover packages appear in a separate group with the heading "Other Packages".

For example, the following option separates the four documented packages into core, extension and other packages. Notice the trailing "dot" does not appear in "java.lang*" -- including the dot, such as "java.lang.*" would omit the java.lang package.

  C:> javadoc -group "Core Packages" "java.lang*:java.util"
            -group "Extension Packages" "javax.*"
            java.lang java.lang.reflect java.util javax.servlet java.new
This results in the groupings:
Core Packages
java.lang
java.lang.reflect
java.util
Extension Packages
javax.servlet
Other Packages
java.new

-nodeprecated
Prevents the generation of any deprecated API at all in the documentation. This does what -nodeprecatedlist does, plus it does not generate any deprecated API throughout the rest of the documentation. This is useful when writing code and you don't want to be distracted by the deprecated code.

-nodeprecatedlist
Prevents the generation of the file containing the list of deprecated APIs (deprecated-list.html) and the link in the navigation bar to that page. (However, javadoc continues to generate the deprecated API throughout the rest of the document.) This is useful if your source code contains no deprecated API, and you want to make the navigation bar cleaner.

-nosince
Omits from the generated docs the "Since" sections associated with the @since tags.

-notree
Omits the class/interface hierarchy pages from the generated docs. These are the pages you reach using the "Tree" button in the navigation bar. The hierarchy is produced by default.

-noindex
Omits the index from the generated docs. The index is produced by default.

-nohelp
Omits the HELP link in the navigation bars at the top and bottom of each page of output.

-nonavbar
Prevents the generation of the navigation bar, header and footer, otherwise found at the top and bottom of the generated pages. Has no affect on the "bottom" option. The -nonavbar option is useful when you are interested only in the content and have no need for navigation, such as converting the files to PostScript or PDF for print only.

-helpfile path\filename
Specifies the path of an alternate help file path\filename that the HELP link in the top and bottom navigation bars link to. Without this option, the Javadoc tool automatically creates a help file help-doc.html that is hard-coded in the Javadoc tool. This option enables you to override this default. The filename can be any name and is not restricted to help-doc.html -- the Javadoc tool will adjust the links in the navigation bar accordingly. For example:
  C:> javadoc -helpfile C:\user\myhelp.html java.awt
-stylesheetfile path\filename
Specifies the path of an alternate HTML stylesheet file. Without this option, the Javadoc tool automatically creates a stylesheet file stylesheet.css that is hard-coded in the Javadoc tool. This option enables you to override this default. The filename can be any name and is not restricted to stylesheet.css. For example:
  C:> javadoc -stylesheetfile C:\user\mystylesheet.css com.mypackage
-serialwarn
Generates compile-time warnings for missing @serial tags. By default, Javadoc 1.2.2 (and later versions) generates no serial warnings. (This is a reversal from earlier versions.) Use this option to display the serial warnings, which helps to properly document default serializable fields and writeExternal methods.

-charset name
Specifies the HTML character set for this document. The name should be a preferred MIME name as given in the IANA Registry. For example:
  C:> javadoc -charset "iso-8859-1" mypackage
would insert the following line in the head of every generated page:
   <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
This META tag is described in the HTML standard. (4197265 and 4137321)

Also see -encoding and -docencoding.

-docencoding name
Specifies the encoding of the generated HTML files. The name should be a preferred MIME name as given in the IANA Registry. If you omit this option but use -encoding, then the encoding of the generated HTML files is determined by -encoding. Example:
  % javadoc -docencoding "ISO-8859-1" mypackage
Also see -encoding and -charset.

-keywords
Adds HTML meta keyword tags to the generated file for each class. These tags can help the page be found by search engines that look for meta tags. (Most search engines that search the entire Internet do not look at meta tags, because pages can misuse them; but search engines offered by companies that confine their search to their own website can benefit by looking at meta tags.)

The meta tags include the fully qualified name of the class and the unqualified names of the fields and methods. Constructors are not included because they are identical to the class name. For example, the class String starts with these keywords:

     <META NAME="keywords" CONTENT="java.lang.String class">
     <META NAME="keywords" CONTENT="CASE_INSENSITIVE_ORDER">
     <META NAME="keywords" CONTENT="length()">
     <META NAME="keywords" CONTENT="charAt()">

-tag tagname:Xaoptcmf:"taghead"
Enables the Javadoc tool to interpret a simple, one-argument custom block tag @tagname in doc comments. So the Javadoc tool can "spell-check" tag names, it is important to include a -tag option for every custom tag that is present in the source code, disabling (with X) those that are not being output in the current run.

The colon (:) is always the separator. To use a colon in tagname, see Use of Colon in Tag Name.

The -tag option outputs the tag's heading taghead in bold, followed on the next line by the text from its single argument, as shown in the example below. Like any block tag, this argument's text can contain inline tags, which are also interpreted. The output is similar to standard one-argument tags, such as @return and @author. Omitting taghead causes tagname to appear as the heading.

Placement of tags - The Xaoptcmf part of the argument determines where in the source code the tag is allowed to be placed, and whether the tag can be disabled (using X). You can supply either a, to allow the tag in all places, or any combination of the other letters:

X (disable tag)
a (all)
o (overview)
p (packages)
t (types, that is classes and interfaces)
c (constructors)
m (methods)
f (fields)

Examples of single tags - An example of a tag option for a tag that that can be used anywhere in the source code is:

    -tag todo:a:"To Do:"
If you wanted @todo to be used only with constructors, methods and fields, you would use:
    -tag todo:cmf:"To Do:"
Notice the last colon (:) above is not a parameter separator, but is part of the heading text (as shown below). You would use either tag option for source code that contains the tag @todo, such as:
     @todo The documentation for this method needs work.
This line would produce output something like:
To Do:
The documentation for this method needs work.
Use of Colon in Tag Name - A colon can be used in a tag name if it is escaped with a backslash. For this doc comment:
    /**
     * @ejb:bean
     */
use this tag option:
    -tag ejb\:bean:a:"EJB Bean:"
Spell-checking tag names (Disabling tags) - Some developers put custom tags in the source code that they don't always want to output. In these cases, it is important to list all tags that are present in the source code, enabling the ones you want to output and disabling the ones you don't want to output. The presence of X disables the tag, while its absence enables the tag. This gives the Javadoc tool enough information to know if a tag it encounters is unknown, probably the results of a typo or a misspelling. It prints a warning in these cases.

You can add X to the placement values already present, so that when you want to enable the tag, you can simply delete the X. For example, if @todo is a tag that you want to suppress on output, you would use:

    -tag todo:Xcmf:"To Do:"
or, if you'd rather keep it simple:
    -tag todo:X

The syntax -tag todo:X works even if @todo is defined by a taglet.

Order of tags - The order of the -tag (and -taglet) options determine the order the tags are output. You can mix the custom tags with the standard tags to intersperse them. The tag options for standard tags are placeholders only for determining the order -- they take only the standard tag's name. (Subheadings for standard tags cannot be altered.) This is illustrated in the following example.

If -tag is missing, then the position of -taglet determines its order. If they are both present, then whichever appears last on the command line determines its order. (This happens because the tags and taglets are processed in the order that they appear on the command line. For example, if -taglet and -tag both have the name "todo", the one that appears last on the command line will determine its order.

Example of a complete set of tags - This example inserts "To Do" after "Parameters" and before "Throws" in the output. By using "X", it also specifies that @example is a tag that might be encountered in the source code that should not be output during this run. Notice that if you use @argfile, you can put the tags on separate lines in an argument file like this (no line continuation characters needed):

   -tag param
   -tag return
   -tag todo:a:"To Do:"
   -tag throws
   -tag see
   -tag example:X

When javadoc parses the doc comments, any tag encountered that is neither a standard tag nor passed in with -tag or -taglet is considered unknown, and a warning is thrown.

The standard tags are initially stored internally in a list in their default order. Whenever -tag options are used, those tags get appended to this list -- standard tags are moved from their default position. Therefore, if a -tag option is omitted for a standard tag, it remains in its default position.

Avoiding Conflicts - If you want to slice out your own namespace, you can use a dot-separated naming convention similar to that used for packages: com.mycompany.todo. Sun will continue to create standard tags whose names do not contain dots. Any tag you create will override the behavior of a tag by the same name defined by Sun. In other words, if you create a tag or taglet @todo, it will always have the same behavior you define, even if Sun later creates a standard tag of the same name.

Annotations vs. Javadoc Tags - In general, if the markup you want to add is intended to affect or produce documentation, it should probably be a javadoc tag; otherwise, it should be an annotation. See Comparing Annotations and Javadoc Tags

You can also create more complex block tags, or custom inline tags with the -taglet option.

-taglet class
Specifies the class file that starts the taglet used in generating the documentation for that tag. Use the fully-qualified name for class. This taglet also defines the number of text arguments that the custom tag has. The taglet accepts those arguments, processes them, and generates the output. For extensive documentation with example taglets, see:
  • Taglet Overview

Taglets are useful for block or inline tags. They can have any number of arguments and implement custom behavior, such as making text bold, formatting bullets, writing out the text to a file, or starting other processes.

Taglets can only determine where a tag should appear and in what form. All other decisions are made by the doclet. So a taglet cannot do things such as remove a class name from the list of included classes. However, it can execute side effects, such as printing the tag's text to a file or triggering another process.

Use the -tagletpath option to specify the path to the taglet. Here is an example that inserts the "To Do" taglet after "Parameters" and ahead of "Throws" in the generated pages:

    -taglet com.sun.tools.doclets.ToDoTaglet
    -tagletpath /home/taglets
    -tag return
    -tag param
    -tag todo
    -tag throws
    -tag see

Alternatively, you can use the -taglet option in place of its -tag option, but that may be harder to read.

-tagletpath tagletpathlist
Specifies the search paths for finding taglet class files (.class). The tagletpathlist can contain multiple paths by separating them with a colon (:). The Javadoc tool will search in all subdirectories of the specified paths.

-docfilessubdirs
Enables deep copying of "doc-files" directories. In other words, subdirectories and all contents are recursively copied to the destination. For example, the directory doc-files/example/images and all its contents would now be copied. There is also an option to exclude subdirectories.

-excludedocfilessubdir name1:name2...
Excludes any "doc-files" subdirectories with the given names. This prevents the copying of SCCS and other source-code-control subdirectories.

-noqualifier all | packagename1:packagename2:...
Omits qualifying package name from ahead of class names in output. The argument to -noqualifier is either "all" (all package qualifiers are omitted) or a colon-separate list of packages, with wildcards, to be removed as qualifiers. The package name is removed from places where class or interface names appear.

The following example omits all package qualifiers:

    -noqualifier all
The following example omits "java.lang" and "java.io" package qualifiers:
    -noqualifier java.lang:java.io
The following example omits package qualifiers starting with "java", and "com.sun" subpackages (but not "javax"):
    -noqualifier java.*:com.sun.*
Where a package qualifier would appear due to the above behavior, the name can be suitably shortened -- see How a name is displayed. This rule is in effect whether or not -noqualifier is used.

-notimestamp
Suppresses the timestamp, which is hidden in an HTML comment in the generated HTML near the top of each page. Useful when you want to run javadoc on two source bases and diff them, as it prevents timestamps from causing a diff (which would otherwise be a diff on every page). The timestamp includes the javadoc version number, and currently looks like this:
     <!-- Generated by javadoc (build 1.5.0-internal) on Tue Jun 22 09:57:24 PDT 2004 -->

-nocomment
Suppress the entire comment body, including the main description and all tags, generating only declarations. This option enables re-using source files originally intended for a different purpose, to produce skeleton HTML documentation at the early stages of a new project.

COMMAND LINE ARGUMENT FILES

To shorten or simplify the javadoc command line, you can specify one or more files that themselves contain arguments to the javadoc command (except -J options). This enables you to create javadoc commands of any length on any operating system.

An argument file can include javadoc options and source filenames in any combination. The arguments within a file can be space-separated or newline-separated. If a filename contains embedded spaces, put the whole filename in double quotes, and double each backslash ("My Files\\Stuff.java").

Filenames within an argument file are relative to the current directory, not the location of the argument file. Wildcards (*) are not allowed in these lists (such as for specifying *.java). Use of the '@' character to recursively interpret files is not supported. The -J options are not supported because they are passed to the launcher, which does not support argument files.

When executing javadoc, pass in the path and name of each argument file with the '@' leading character. When javadoc encounters an argument beginning with the character `@', it expands the contents of that file into the argument list.

Example - Single Arg File

You could use a single argument file named "argfile" to hold all Javadoc arguments:
  C:> javadoc @argfile
This argument file could contain the contents of both files shown in the next example.

Example - Two Arg Files

You can create two argument files -- one for the Javadoc options and the other for the package names or source filenames: (Notice the following lists have no line-continuation characters.)

Create a file named "options" containing:

     -d docs-filelist
     -use
     -splitindex
     -windowtitle 'Java 2 Platform v1.3 API Specification'
     -doctitle 'Java<sup><font size="-2">TM</font></sup> 2 Platform 5.0 API Specification'
     -header '<b>Java 2 Platform </b><br><font size="-1">5.0</font>'
     -bottom 'Copyright 1993-2000 Sun Microsystems, Inc. All Rights Reserved.'
     -group "Core Packages" "java.*"
     -overview \java\pubs\ws\1.5\src\share\classes\overview-core.html
     -sourcepath \java\pubs\ws\1.5\src\share\classes

Create a file named "packages" containing:

     com.mypackage1
     com.mypackage2
     com.mypackage3
You would then run javadoc with:
  C:> javadoc @options @packages

Example - Arg Files with Paths

The argument files can have paths, but any filenames inside the files are relative to the current working directory (not path1 or path2):
  C:> javadoc @path1\options @path2\packages

Example - Option Arguments

Here's an example of saving just an argument to a javadoc option in an argument file. We'll use the -bottom option, since it can have a lengthy argument. You could create a file named "bottom" containing its text argument:

'<font size="-1"><a href="http://java.sun.com/cgi-bin/bugreport.cgi">Submit a
bug or feature</a><br><br>Java is a trademark or registered trademark of
Sun Microsystems, Inc. in the US and other countries.<br>Copyright 1993-2000 Sun
Microsystems, Inc. 901 San Antonio Road,<br>Palo Alto, California, 94303, U.S.A.
All Rights Reserved.</font>'
Then run the Javadoc tool with:
  C:> javadoc -bottom @bottom @packages
Or you could include the -bottom option at the start of the argument file, and then just run it as:
  C:> javadoc @bottom @packages

Running

RUNNING JAVADOC

Version Numbers - The version number of javadoc can be determined using javadoc -J-version. The version number of the standard doclet appears in its output stream. It can be turned off with -quiet.

Public programmatic interface - To invoke the Javadoc tool from within programs written in the Java language. This interface is in com.sun.tools.javadoc.Main (and javadoc is re-entrant). For more details, see Standard Doclet.

Running Doclets - The instructions given below are for invoking the standard HTML doclet. To invoke a custom doclet, use the -doclet and -docletpath options. For full, working examples of running a particular doclet, see Running the MIF Doclet.

SIMPLE EXAMPLES

You can run javadoc on entire packages or individual source files. Each package name has a corresponding directory name. In the following examples, the source files are located at C:\home\src\java\awt\*java. The destination directory is C:\home\html.

Documenting One or More Packages

To document a package, the source files (*.java) for that package must be located in a directory having the same name as the package. If a package name is made up of several identifiers (separated by dots, such as java.awt.color), each subsequent identifier must correspond to a deeper subdirectory (such as java/awt/color). You may split the source files for a single package among two such directory trees located at different places, as long as -sourcepath points to them both -- for example src1\java\awt\color and src2\java\awt\color.

You can run javadoc either by changing directories (with cd) or by using -sourcepath option. The examples below illustrate both alternatives.

  • Case 1 - Run recursively starting from one or more packages - This example uses -sourcepath so javadoc can be run from any directory and -subpackages (a new 1.4 option) for recursion. It traverses the subpackages of the java directory excluding packages rooted at java.net and java.lang. Notice this excludes java.lang.ref, a subpackage of java.lang).
      % javadoc -d \home\html -sourcepath \home\src -subpackages java -exclude java.net:java.lang

    To also traverse down other package trees, append their names to the -subpackages argument, such as java:javax:org.xml.sax.

  • Case 2 - Run on explicit packages after changing to the "root" source directory - Change to the parent directory of the fully-qualified package. Then run javadoc, supplying names of one or more packages you want to document:
      C:> cd C:\home\src\
  C:> javadoc -d C:\home\html java.awt java.awt.event
  • Case 3 - Run from any directory on explicit packages in a single directory tree - In this case, it doesn't matter what the current directory is. Run javadoc supplying -sourcepath with the parent directory of the top-level package, and supplying names of one or more packages you want to document:
      C:> javadoc -d C:\home\html -sourcepath C:\home\src java.awt java.awt.event
  • Case 4 - Run from any directory on explicit packages in multiple directory trees - This is the same as case 3, but for packages in separate directory trees. Run javadoc supplying -sourcepath with the path to each tree's root (colon-separated) and supply names of one or more packages you want to document. All source files for a given package do not need to be located under a single root directory -- they just need to be found somewhere along the sourcepath.
      C:> javadoc -d C:\home\html -sourcepath C:\home\src1;C:\home\src2 java.awt java.awt.event
Result: All cases generate HTML-formatted documentation for the public and protected classes and interfaces in packages java.awt and java.awt.event and save the HTML files in the specified destination directory (C:\home\html). Because two or more packages are being generated, the document has three HTML frames -- for the list of packages, the list of classes, and the main class pages.

Documenting One or More Classes

The second way to run the Javadoc tool is by passing in one or more source files (.java). You can run javadoc either of the following two ways -- by changing directories (with cd) or by fully-specifying the path to the .java files. Relative paths are relative to the current directory. The -sourcepath option is ignored when passing in source files. You can use command line wildcards, such as asterisk (*), to specify groups of classes.
  • Case 1 - Changing to the source directory - Change to the directory holding the .java files. Then run javadoc, supplying names of one or more source files you want to document.
      C:> cd C:\home\src\java\awt
  C:> javadoc -d C:\home\html Button.java Canvas.java Graphics*.java
    This example generates HTML-formatted documentation for the classes Button, Canvas and classes beginning with Graphics. Because source files rather than package names were passed in as arguments to javadoc, the document has two frames -- for the list of classes and the main page.
  • Case 2 - Changing to the package root directory - This is useful for documenting individual source files from different subpackages off the same root. Change to the package root directory, and supply the source files with paths from the root.
      C:> cd C:\home\src
  C:> javadoc -d \home\html java\awt\Button.java java\applet\Applet.java
    This example generates HTML-formatted documentation for the classes Button and Applet.
  • Case 3 - From any directory - In this case, it doesn't matter what the current directory is. Run javadoc supplying the absolute path (or path relative to the current directory) to the .java files you want to document.
      C:> javadoc -d C:\home\html C:\home\src\java\awt\Button.java C:\home\src\java\awt\Graphics*.java
    This example generates HTML-formatted documentation for the class Button and classes beginning with Graphics.

Documenting Both Packages and Classes

You can document entire packages and individual classes at the same time. Here's an example that mixes two of the previous examples. You can use -sourcepath for the path to the packages but not for the path to the individual classes.
  C:> javadoc -d C:\home\html -sourcepath C:\home\src java.awt C:\home\src\java\applet\Applet.java
This example generates HTML-formatted documentation for the package java.awt and class Applet. (The Javadoc tool determines the package name for Applet from the package declaration, if any, in the Applet.java source file.)

REAL WORLD EXAMPLE

The Javadoc tool has many useful options, some of which are more commonly used than others. Here is effectively the command we use to run the Javadoc tool on the Java platform API. We use 180MB of memory to generate the documentation for the 1500 (approx.) public and protected classes in the Java 2 Platform, Standard Edition, v1.2.

The same example is shown twice -- first as executed on the command line, then as executed from a makefile. It uses absolute paths in the option arguments, which enables the same javadoc command to be run from any directory.

Command Line Example

This command line example is over 900 characters, which is too long for some shells, such as DOS. You can use a command line argument file (or write a shell script) to workaround this limitation.
C:> javadoc -sourcepath \java\jdk\src\share\classes            ^
    -overview \java\jdk\src\share\classes\overview.html      ^
    -d \java\jdk\build\api                                   ^
    -use                                                     ^
    -splitIndex                                              ^
    -windowtitle 'Java 2 Platform 5.0 API Specification'    ^
    -doctitle 'Java<sup><font size="-2">TM</font></sup> 2 Platform 5.0 API Specification' ^
    -header '<b>Java 2 Platform </b><br><font size="-1">5.0</font>' ^
    -bottom '<font size="-1"><a href="http://java.sun.com/cgi-bin/bugreport.cgi">Submit
a bug or feature</a><br><br>Java is a trademark or registered trademark of Sun Microsystems,
Inc. in the US and other countries.<br>Copyright 1993-1999 Sun Microsystems, Inc.
901 San Antonio Road,<br>Palo Alto, California, 94303, U.S.A. All Rights Reserved.</font>' ^
    -group "Core Packages" "java.*:com.sun.java.*:org.omg.*" ^
    -group "Extension Packages" "javax.*"                    ^
    -J-Xmx180m                                               ^
    @packages
where packages is the name of a file containing the packages to process, such as java.applet java.lang. None of the options should contain any newline characters between the single quotes. (For example, if you copy and paste this example, delete the newline characters from the -bottom option.) See the other notes listed below.

Makefile Example

This is an example of a GNU makefile. For an example of a Windows makefile, see creating a makefile for Windows.
javadoc -sourcepath $(SRCDIR)              ^   /* Sets path for source files     */
        -overview $(SRCDIR)\overview.html  ^   /* Sets file for overview text    */
        -d \java\jdk\build\api             ^   /* Sets destination directory     */
        -use                               ^   /* Adds "Use" files               */
        -splitIndex                        ^   /* Splits index A-Z               */
        -windowtitle $(WINDOWTITLE)        ^   /* Adds a window title            */
        -doctitle $(DOCTITLE)              ^   /* Adds a doc title               */
        -header $(HEADER)                  ^   /* Adds running header text       */
        -bottom $(BOTTOM)                  ^   /* Adds text at bottom            */
        -group $(GROUPCORE)                ^   /* 1st subhead on overview page   */
        -group $(GROUPEXT)                 ^   /* 2nd subhead on overview page   */
        -J-Xmx180m                         ^   /* Sets memory to 180MB           */
        java.lang java.lang.reflect        ^   /* Sets packages to document      */
        java.util java.io java.net         ^
        java.applet

WINDOWTITLE = 'Java 2 Platform v1.2 API Specification'
DOCTITLE = 'Java<sup><font size="-2">TM</font></sup> 2 Platform v1.2 API Specification'
HEADER = '<b>Java 2 Platform </b><br><font size="-1">v1.2</font>'
BOTTOM = '<font size="-1"><a href="http://java.sun.com/cgi-bin/bugreport.cgi">Submit
    a bug or feature</a><br><br>Java is a trademark or registered trademark
    of Sun Microsystems, Inc. in the US and other countries.<br>Copyright 1993-1999
    Sun Microsystems, Inc. 901 San Antonio Road,<br>Palo Alto, California, 94303, U.S.A.
    All Rights Reserved.</font>'
GROUPCORE = '"Core Packages" "java.*:com.sun.java.*:org.omg.*"'
GROUPEXT  = '"Extension Packages" "javax.*"'
SRCDIR = '/java/jdk/1.2/src/share/classes'

Single quotes are used to surround makefile arguments.

NOTES

  • If you omit the -windowtitle option, the Javadoc tool copies the doc title to the window title. The -windowtitle text is basically the same as the -doctitle but without HTML tags, to prevent those tags from appearing as raw text in the window title.
  • If you omit the -footer option, as done here, the Javadoc tool copies the header text to the footer.
  • Other important options you might want to use but not needed in this example are -classpath and -link.

TROUBLESHOOTING

General Troubleshooting

  • Javadoc FAQ - Commonly-encountered bugs and troubleshooting tips can be found on the Javadoc FAQ
  • Bugs and Limitations - You can also see some bugs listed at Important Bug Fixes and Changes.
  • Version number - See version numbers.
  • Documents only legal classes - When documenting a package, javadoc only reads files whose names are composed of legal class names. You can prevent javadoc from parsing a file by including, for example, a hyphen "-" in its filename.

Errors and Warnings

Error and warning messages contain the filename and line number to the declaration line rather than to the particular line in the doc comment.
  • "error: cannot read: Class1.java" the Javadoc tool is trying to load the class Class1.java in the current directory. The class name is shown with its path (absolute or relative), which in this case is the same as ./Class1.java.

ENVIRONMENT

CLASSPATH
Environment variable that provides the path which javadoc uses to find user class files. This environment variable is overridden by the -classpath option. Separate directories with a semicolon, for example:
.;C:\classes;C:\home\java\classes

SEE ALSO

  • javac
  • java
  • jdb
  • javah
  • javap
  • Javadoc Home Page
  • How to Write Doc Comments for Javadoc
  • Setting the Class Path
  • How Javac and Javadoc Find Classes (tools.jar)

JavadocTM is a trademark of Sun Microsystems, Inc. (The javadoc command itself does not require the trademark symbol.)

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

Feedback 		Sun
Java Software


javah - C Header and Stub File Generator

javah produces C header files and C source files from a Java class. These files provide the connective glue that allow your Java and C code to interact.

SYNOPSIS

javah [ options ] fully-qualified-classname. . .
javah_g [ options ] fully-qualified-classname. . .

DESCRIPTION

javah generates C header and source files that are needed to implement native methods. The generated header and source files are used by C programs to reference an object's instance variables from native source code. The .h file contains a struct definition whose layout parallels the layout of the corresponding class. The fields in the struct correspond to instance variables in the class.

The name of the header file and the structure declared within it are derived from the name of the class. If the class passed to javah is inside a package, the package name is prepended to both the header file name and the structure name. Underscores (_) are used as name delimiters.

By default javah creates a header file for each class listed on the command line and puts the files in the current directory. Use the -stubs option to create source files. Use the -o option to concatenate the results for all listed classes into a single file.

The new native method interface, Java Native Interface (JNI), does not require header information or stub files. javah can still be used to generate native method function proptotypes needed for JNI-style native methods. javah produces JNI-style output by default, and places the result in the .h file.

javah_g is a non-optimized version of javah suitable for use with debuggers like jdb.

OPTIONS

-o outputfile
Concatenates the resulting header or source files for all the classes listed on the command line into outputfile. Only one of -o or -d may be used.
-d directory
Sets the directory where javah saves the header files or the stub files. Only one of -d or -o may be used.
-stubs
Causes javah to generate C declarations from the Java object file.
-verbose
Indicates verbose output and causes javah to print a message to stdout concerning the status of the generated files.
-help
Print help message for javah usage.
-version
Print out javah version information.
-jni
Causes javah to create an output file containing JNI-style native method function prototypes. This is the default output, so use of -jni is optional.
-classpath path
Specifies the path javah uses to look up classes. Overrides the default or the CLASSPATH environment variable if it is set. Directories are separated by semi-colons. Thus the general format for path is:
   .;<your_path>
For example:
   .;C:\users\dac\classes;C:\tools\java\classes

As a special convenience, a class path element containing a basename of * is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR (a java program cannot tell the difference between the two invocations).

For example, if directory foo contains a.jar and b.JAR, then the class path element foo/* is expanded to a A.jar:b.JAR, except that the order of jar files is unspecified. All jar files in the specified directory, even hidden ones, are included in the list. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory. The CLASSPATH environment variable, where defined, will be similarly expanded. Any classpath wildcard expansion occurs before the Java virtual machine is started -- no Java program will ever see unexpanded wildcards except by querying the environment. For example; by invoking System.getenv("CLASSPATH").

-bootclasspath path
Specifies path from which to load bootstrap classes. By default, the bootstrap classes are the classes implementing the core Java platform located in jre\lib\rt.jar and several other jar files.
-old
Specifies that old JDK1.0-style header files should be generated.
-force
Specifies that output files should always be written.
-J option
Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by semi-colons, for example,
   .;C:\users\dac\classes;C:\tools\java\classes

SEE ALSO

javac, java, jdb, javap, javadoc

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


javap - The Java Class File Disassembler

Disassembles class files.

SYNOPSIS

   javap [ options ] class. . .

DESCRIPTION

The javap command disassembles a class file. Its output depends on the options used. If no options are used, javap prints out the package, protected, and public fields and methods of the classes passed to it. javap prints its output to stdout. For example, compile the following class declaration:
   import java.awt.*;
   import java.applet.*;

   public class DocFooter extends Applet {
        String date;
        String email;

        public void init() {
                resize(500,100);
                date = getParameter("LAST_UPDATED");
                email = getParameter("EMAIL");
        }

        public void paint(Graphics g) {
                g.drawString(date + " by ",100, 15);
                g.drawString(email,290,15);
        }
   }
The output from javap DocFooter yields:
Compiled from DocFooter.java
public class DocFooter extends java.applet.Applet {
    java.lang.String date;
    java.lang.String email;
    public DocFooter();
    public void init();
    public void paint(java.awt.Graphics);
}
The output from javap -c DocFooter yields:
Compiled from DocFooter.java
public class DocFooter extends java.applet.Applet {
    java.lang.String date;
    java.lang.String email;
    public DocFooter();
    public void init();
    public void paint(java.awt.Graphics);
}

Method DocFooter()
   0 aload_0
   1 invokespecial #1 <Method java.applet.Applet()>
   4 return

Method void init()
   0 aload_0
   1 sipush 500
   4 bipush 100
   6 invokevirtual #2 <Method void resize(int, int)>
   9 aload_0
  10 aload_0
  11 ldc #3 <String "LAST_UPDATED">
  13 invokevirtual #4 <Method java.lang.String getParameter(java.lang.String)>
  16 putfield #5 <Field java.lang.String date>
  19 aload_0
  20 aload_0
  21 ldc #6 <String "EMAIL">
  23 invokevirtual #4 <Method java.lang.String getParameter(java.lang.String)>
  26 putfield #7 <Field java.lang.String email>
  29 return

Method void paint(java.awt.Graphics)
   0 aload_1
   1 new #8 <Class java.lang.StringBuffer>
   4 dup
   5 invokespecial #9 <Method java.lang.StringBuffer()>
   8 aload_0
   9 getfield #5 <Field java.lang.String date>
  12 invokevirtual #10 <Method java.lang.StringBuffer append(java.lang.String)>
  15 ldc #11 <String " by ">
  17 invokevirtual #10 <Method java.lang.StringBuffer append(java.lang.String)>
  20 invokevirtual #12 <Method java.lang.String toString()>
  23 bipush 100
  25 bipush 15
  27 invokevirtual #13 <Method void drawString(java.lang.String, int, int)>
  30 aload_1
  31 aload_0
  32 getfield #7 <Field java.lang.String email>
  35 sipush 290
  38 bipush 15
  40 invokevirtual #13 <Method void drawString(java.lang.String, int, int)>
  43 return

OPTIONS

-help
Prints out help message for javap.
-l
Prints out line and local variable tables.
-b
Ensures backward compatibility with javap in JDK 1.1.
-public
Shows only public classes and members.
-protected
Shows only protected and public classes and members.
-package
Shows only package, protected, and public classes and members. This is the default.
-private
Shows all classes and members.
-Jflag
Pass flag directly to the runtime system. Some examples:
javap -J-version
javap -J-Djava.security.manager -J-Djava.security.policy=MyPolicy MyClassName
-s
Prints internal type signatures.
-c
Prints out disassembled code, i.e., the instructions that comprise the Java bytecodes, for each of the methods in the class. These are documented in the Java Virtual Machine Specification.
-verbose
Prints stack size, number of locals and args for methods.
-classpath path
Specifies the path javap uses to look up classes. Overrides the default or the CLASSPATH environment variable if it is set. Directories are separated by semi-colons. Thus the general format for path is:
   .;<your_path>
For example:
   .;C:\usrs\dac\classes;C:\tools\java\classes
-bootclasspath path
Specifies path from which to load bootstrap classes. By default, the bootstrap classes are the classes implementing the core Java platform located in jre\lib\rt.jar and several other jar files.
-extdirs dirs
Overrides location at which installed extensions are searched for. The default location for extensions is the value of java.ext.dirs.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by semi-colons, for example, For example:
   .;C:\usrs\dac\classes;C:\tools\java\classes

SEE ALSO

javac, java, jdb, javah

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


jdb - The Java Debugger

jdb helps you find and fix bugs in Java language programs.

SYNOPSIS

jdb [ options ] [ class ] [ arguments ]
options
Command-line options, as specified below.
class
Name of the class to begin debugging.
arguments
Arguments passed to the main() method of class.

DESCRIPTION

The Java Debugger, jdb, is a simple command-line debugger for Java classes. It is a demonstration of the Java Platform Debugger Architecture that provides inspection and debugging of a local or remote Java Virtual Machine.

Starting a jdb Session

There are many ways to start a jdb session. The most frequently used way is to have jdb launch a new Java Virtual Machine (VM) with the main class of the application to be debugged. This is done by substituting the command jdb for java in the command line. For example, if your application's main class is MyClass, you use the following command to debug it under JDB:
C:\> jdb MyClass
When started this way, jdb invokes a second Java VM with any specified parameters, loads the specified class, and stops the VM before executing that class's first instruction.

Another way to use jdb is by attaching it to a Java VM that is already running. A VM that is to be debugged with jdb must be started with the following options:

Option | Purpose
-agentlib:jdwp=transport=dt_shmem,server=y,suspend=n | Loads in-process debugging libraries and specifies the kind of connection to be made.

For example, the following command will run the MyClass application, and allow jdb to connect to it at a later time.

C:\> java -agentlib:jdwp=transport=dt_shmem,address=jdbconn,server=y,suspend=n MyClass
You can then attach jdb to the VM with the following commmand:
C:\> jdb -attach jdbconn
Note that "MyClass" is not specified in the jdb command line in this case because jdb is connecting to an existing VM instead of launching a new one.

There are many other ways to connect the debugger to a VM, and all of them are supported by jdb. The Java Platform Debugger Architecture has additional documentation on these connection options. For information on starting a J2SE 1.4.2 or early VM for use with jdb see 1.4.2 documentation

Basic jdb Commands

The following is a list of the basic jdb commands. The Java debugger supports other commands which you can list using jdb's help command.
help, or ?
The most important jdb command, help displays the list of recognized commands with a brief description.
run
After starting jdb, and setting any necessary breakpoints, you can use this command to start the execution the debugged application. This command is available only when jdb launches the debugged application (as opposed to attaching to an existing VM).
cont
Continues execution of the debugged application after a breakpoint, exception, or step.
print
Displays Java objects and primitive values. For variables or fields of primitive types, the actual value is printed. For objects, a short description is printed. See the dump command below for getting more information about an object.

NOTE: To display local variables, the containing class must have been compiled with the javac -g option.

print supports many simple Java expressions including those with method invocations, for example:

  • print MyClass.myStaticField
  • print myObj.myInstanceField
  • print i + j + k (i, j, k are primities and either fields or local variables)
  • print myObj.myMethod() (if myMethod returns a non-null)
  • print new java.lang.String("Hello").length()
dump
For primitive values, this command is identical to print. For objects, it prints the current value of each field defined in the object. Static and instance fields are included.

The dump command supports the same set of expressions as the print command.

threads
List the threads that are currently running. For each thread, its name and current status are printed, as well as an index that can be used for other commands, for example:
4. (java.lang.Thread)0x1 main      running
In this example, the thread index is 4, the thread is an instance of java.lang.Thread, the thread name is "main", and it is currently running,
thread
Select a thread to be the current thread. Many jdb commands are based on the setting of the current thread. The thread is specified with the thread index described in the threads command above.
where
where with no arguments dumps the stack of the current thread. where all dumps the stack of all threads in the current thread group. where threadindex dumps the stack of the specified thread.

If the current thread is suspended (either through an event such as a breakpoint or through the suspend command), local variables and fields can be displayed with the print and dump commands. The up and down commands select which stack frame is current.

Breakpoints

Breakpoints can be set in jdb at line numbers or at the first instruction of a method, for example:
  • stop at MyClass:22 (sets a breakpoint at the first instruction for line 22 of the source file containing MyClass)
  • stop in java.lang.String.length (sets a breakpoint at the beginnig of the method java.lang.String.length)
  • stop in MyClass.<init> (<init> identifies the MyClass constructor)
  • stop in MyClass.<clinit> (<clinit> identifies the static initialization code for MyClass)

If a method is overloaded, you must also specify its argument types so that the proper method can be selected for a breakpoint. For example, "MyClass.myMethod(int,java.lang.String)", or "MyClass.myMethod()".

The clear command removes breakpoints using a syntax as in "clear MyClass:45". Using the clear or command with no argument displays a list of all breakpoints currently set. The cont command continues execution.

Stepping

The step commands advances execution to the next line whether it is in the current stack frame or a called method. The next command advances execution to the next line in the current stack frame.

Exceptions

When an exception occurs for which there isn't a catch statement anywhere in the throwing thread's call stack, the VM normally prints an exception trace and exits. When running under jdb, however, control returns to jdb at the offending throw. You can then use jdb to diagnose the cause of the exception.

Use the catch command to cause the debugged application to stop at other thrown exceptions, for example: "catch java.io.FileNotFoundException" or "catch mypackage.BigTroubleException. Any exception which is an instance of the specifield class (or of a subclass) will stop the application at the point where it is thrown.

The ignore command negates the effect of a previous catch command.

NOTE: The ignore command does not cause the debugged VM to ignore specific exceptions, only the debugger.

Command Line Options

When you use jdb in place of the Java application launcher on the command line, jdb accepts many of the same options as the java command, including -D, -classpath, and -X<option>.

The following additional options are accepted by jdb:

-help
Displays a help message.
-sourcepath <dir1:dir2:...>
Uses the given path in searching for source files in the specified path. If this option is not specified, the default path of "." is used.
-attach <address>
Attaches the debugger to previously running VM using the default connection mechanism.
-listen <address>
Waits for a running VM to connect at the specified address using standard connector.
-listenany
Waits for a running VM to connect at any available address using standard connector.
-launch
Launches the debugged application immediately upon startup of jdb. This option removes the need for using the run command. The debuged application is launched and then stopped just before the initial application class is loaded. At that point you can set any necessary breakpoints and use the cont to continue execution.
-listconnectors
List the connectors available in this VM
-connect <connector-name>:<name1>=<value1>,...
Connects to target VM using named connector with listed argument values.
-dbgtrace [flags]
Prints info for debugging jdb.
-tclient
Runs the application in the Java HotSpot(tm) VM (Client).
-tserver
Runs the application in the Java HotSpot(tm) VM (Server).
-J option
Pass option to the Java virtual machine used to run jdb. (Options for the application Java virtual machine are passed to the run command.) For example, -J-Xms48m sets the startup memory to 48 megabytes.

Other options are supported for alternate mechanisms for connecting the debugger and the VM it is to debug. The Java Platform Debugger Architecture has additional documentation on these connection alternatives.

Options Forwarded to Debuggee Process

-v -verbose[:class|gc|jni]
Turns on verbose mode.
-D<name>=<value>
Sets a system property.
-classpath <directories separated by ":">
Lists directories in which to look for classes.
-X<option>
Non-standard target VM option

SEE ALSO

javac, java, javah, javap, javadoc.

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


JDK File Structure for Windows

JDK and JRE File Structure

 JDK Tools

This page provides an introductory overview of the JDK directories and the files they contain. Note that the file structure of the JRE is identical to that of the JDK's jre directory.

Development Files and Directories

This section describes the most important files and directories required to develop applications for the Java platform.

(Note that some of the directories that are not required include demos, Java source code, and C header files. These are mentioned in the Additional Files and Directories section.)

               jdk1.6.0
        ___________|____________________
       |           |                    |
      bin         lib                  jre
       |           |          __________|_____________________
   java.exe    tools.jar     |                                |
   javac.exe   dt.jar       bin                              lib
   javap.exe            _____|____ __________         ________|_______ ________ ________
   javah.exe           |          |          |       |        |       |        |        |
   javadoc.exe     java.exe    client      server  rt.jar    ext  security  applet    fonts
                   java.dll       |          |   charsets.jar |
                   awt.dll     jvm.dll    jvm.dll        localedata.jar

Assuming the JDK software is installed at c:\jdk1.6.0, here are some of the most important directories:

c:\jdk1.6.0
Root directory of the JDK software installation. Contains copyright, license, and README files. Also contains src.zip, the archive of source code for the Java platform.
c:\jdk1.6.0\bin
Executable files for the development tools contained in the Java Development Kit. The PATH environment variable should contain an entry for this directory. For more information on the tools, see the JDK Tools.
c:\jdk1.6.0\lib
Files used by the development tools. These include tools.jar, which contains non-core classes for support of the tools and utilities in the JDK. Also includes dt.jar, the DesignTime archive of BeanInfo files that tell interactive development environments (IDE's) how to display the Java components and how to let the developer customize them for an application.
c:\jdk1.6.0\jre
Root directory of the Java runtime environment used by the JDK development tools. The runtime environment is an implementation of the Java platform. This is the directory represented by the java.home system property.
c:\jdk1.6.0\jre\bin
Executable files and DLLs for tools and libraries used by the Java platform. The executable files are identical to files in /jdk1.6.0/bin. The java launcher tool serves as an application launcher (and replaced the old jre tool that shipped with 1.1 versions of the JDK). This directory does not need to be in the PATH environment variable.
c:\jdk1.6.0\jre\bin\client
Contains the DLL files used by the Java HotSpotTM Client Virtual Machine.
c:\jdk1.6.0\jre\bin\server
Contains the DLL files used by the Java HotSpotTM Server Virtual Machine.
c:\jdk1.6.0\jre\lib
Code libraries, property settings, and resource files used by the Java runtime environment. For example:
  • rt.jar -- the bootstrap classes (the RunTime classes that comprise the Java platform's core API).
  • charsets.jar -- character conversion classes.
Aside from the ext subdirectory (described below) there are several additional resource subdirectories not described here.
c:\jdk1.6.0\jre\lib\ext
Default installation directory for Extensions to the Java platform.
  • localedata.jar -- locale data for java.text and java.util.
c:\jdk1.6.0\jre\lib\security
Contains files used for security management. These include the security policy (java.policy) and security properties (java.security) files.
c:\jdk1.6.0\jre\lib\applet
Jar files containing support classes for applets can be placed in the lib/applet/ directory. This reduces startup time for large applets by allowing applet classes to be pre-loaded from the local file system by the applet class loader, providing the same protections as if they had been downloaded over the net.
c:\jdk1.6.0\jre\lib\fonts
Contains TrueType font files for use by the platform.

Additional Files and Directories

This section describes the directory structure for the demos, Java source code, and C header files.

                        jdk1.6.0
                 ___________|__________
                |           |          |
              demo      include     src.zip
             ___|___ _________ __________
            |       |         |          |
          applets  jfc       jpda      plugin

The additional directories shown above are:

c:\jdk1.6.0\src.zip
Archive containing source code for the Java platform.
c:\jdk1.6.0\demo
Examples, with source code, that show you how to program for the Java platform.
c:\jdk1.6.0\demo\applets
Applets that can be used on a web page.
c:\jdk1.6.0\demo\jfc
Examples that use Java 2DTM and JFC\Swing functionality.
c:\jdk1.6.0\demo\jpda
Examples of using the Java Platform Debugging Architecture. Includes source code for the javadt and jdb utilities.
c:\jdk1.6.0\demo\plugin
Contains demos for use with the Java Plug-in product.
c:\jdk1.6.0\include
C-language header files that support native-code programming using the Java Native Interface and the Java Virtual Machine Debugger Interface.

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


keytool - Key and Certificate Management Tool

Manages a keystore (database) of cryptographic keys, X.509 certificate chains, and trusted certificates.

SYNOPSIS

keytool [ commands ]

The keytool command interface has changed in Java SE 6. See the Changes Section for a detailed description. Note that previously defined commands are still supported.

DESCRIPTION

keytool is a key and certificate management utility. It allows users to administer their own public/private key pairs and associated certificates for use in self-authentication (where the user authenticates himself/herself to other users/services) or data integrity and authentication services, using digital signatures. It also allows users to cache the public keys (in the form of certificates) of their communicating peers.

A certificate is a digitally signed statement from one entity (person, company, etc.), saying that the public key (and some other information) of some other entity has a particular value. (See Certificates.) When data is digitally signed, the signature can be verified to check the data integrity and authenticity. Integrity means that the data has not been modified or tampered with, and authenticity means the data indeed comes from whoever claims to have created and signed it.

keytool also enables users to administer secret keys used in symmetric encryption/decryption (e.g. DES).

keytool stores the keys and certificates in a keystore.

COMMAND AND OPTION NOTES

The various commands and their options are listed and described below . Note:

  • All command and option names are preceded by a minus sign (-).

  • The options for each command may be provided in any order.

  • All items not italicized or in braces or square brackets are required to appear as is.

  • Braces surrounding an option generally signify that a default value will be used if the option is not specified on the command line. Braces are also used around the -v, -rfc, and -J options, which only have meaning if they appear on the command line (that is, they don't have any "default" values other than not existing).

  • Brackets surrounding an option signify that the user is prompted for the value(s) if the option is not specified on the command line. (For a -keypass option, if you do not specify the option on the command line, keytool will first attempt to use the keystore password to recover the private/secret key, and if this fails, will then prompt you for the private/secret key password.)

  • Items in italics (option values) represent the actual values that must be supplied. For example, here is the format of the -printcert command:
      keytool -printcert {-file cert_file} {-v}

    When specifying a -printcert command, replace cert_file with the actual file name, as in:

      keytool -printcert -file VScert.cer

  • Option values must be quoted if they contain a blank (space).

  • The -help command is the default. Thus, the command line
      keytool
    is equivalent to
      keytool -help

Option Defaults

Below are the defaults for various option values.
-alias "mykey"

-keyalg
    "DSA" (when using -genkeypair)
    "DES" (when using -genseckey)

-keysize
    1024 (when using -genkeypair)
    56 (when using -genseckey and -keyalg is "DES")
    168 (when using -genseckey and -keyalg is "DESede")

-validity 90

-keystore the file named .keystore in the user's home directory

-storetype the value of the "keystore.type" property in the security properties file,
           which is returned by the static getDefaultType method in java.security.KeyStore

-file stdin if reading, stdout if writing

-protected false
In generating a public/private key pair, the signature algorithm (-sigalg option) is derived from the algorithm of the underlying private key: If the underlying private key is of type "DSA", the -sigalg option defaults to "SHA1withDSA", and if the underlying private key is of type "RSA", -sigalg defaults to "MD5withRSA". Please consult the Java Cryptography Architecture API Specification & Reference for a full list of -keyalg and -sigalg you can choose from.

Common Options

The -v option can appear for all commands except -help. If it appears, it signifies "verbose" mode; more information will be output.

There is also a -Jjavaoption option that may appear for any command. If it appears, the specified javaoption string is passed through directly to the Java interpreter. This option should not contain any spaces. It is useful for adjusting the execution environment or memory usage. For a list of possible interpreter options, type java -h or java -X at the command line.

These options may appear for all commands operating on a keystore:

-storetype storetype
This qualifier specifies the type of keystore to be instantiated.

-keystore keystore
The keystore location.

If the JKS storetype is used and a keystore file does not yet exist, then certain keytool commands may result in a new keystore file being created. For example, if keytool -genkeypair is invoked and the -keystore option is not specified, the default keystore file named .keystore in the user's home directory will be created if it does not already exist. Similarly, if the -keystore ks_file option is specified but ks_file does not exist, then it will be created

Note that the input stream from the -keystore option is passed to the KeyStore.load method. If NONE is specified as the URL, then a null stream is passed to the KeyStore.load method. NONE should be specified if the KeyStore is not file-based (for example, if it resides on a hardware token device).

-storepass storepass
The password which is used to protect the integrity of the keystore.

storepass must be at least 6 characters long. It must be provided to all commands that access the keystore contents. For such commands, if a -storepass option is not provided at the command line, the user is prompted for it.

When retrieving information from the keystore, the password is optional; if no password is given, the integrity of the retrieved information cannot be checked and a warning is displayed.

-providerName provider_name
Used to identify a cryptographic service provider's name when listed in the security properties file.

-providerClass provider_class_name
Used to specify the name of cryptographic service provider's master class file when the service provider is not listed in the security properties file.

-providerArg provider_arg
Used in conjunction with -providerClass. Represents an optional string input argument for the constructor of provider_class_name.

-protected
Either true or false. This value should be specified as true if a password must be given via a protected authentication path such as a dedicated PIN reader.

COMMANDS

Creating or Adding Data to the Keystore

-genkeypair {-alias alias} {-keyalg keyalg} {-keysize keysize} {-sigalg sigalg} [-dname dname] [-keypass keypass] {-validity valDays} {-storetype storetype} {-keystore keystore} [-storepass storepass] {-providerClass provider_class_name {-providerArg provider_arg}} {-v} {-protected} {-Jjavaoption}

Generates a key pair (a public key and associated private key). Wraps the public key into an X.509 v3 self-signed certificate, which is stored as a single-element certificate chain. This certificate chain and the private key are stored in a new keystore entry identified by alias.

keyalg specifies the algorithm to be used to generate the key pair, and keysize specifies the size of each key to be generated. sigalg specifies the algorithm that should be used to sign the self-signed certificate; this algorithm must be compatible with keyalg.

dname specifies the X.500 Distinguished Name to be associated with alias, and is used as the issuer and subject fields in the self-signed certificate. If no distinguished name is provided at the command line, the user will be prompted for one.

keypass is a password used to protect the private key of the generated key pair. If no password is provided, the user is prompted for it. If you press RETURN at the prompt, the key password is set to the same password as that used for the keystore. keypass must be at least 6 characters long.

valDays tells the number of days for which the certificate should be considered valid.

This command was named -genkey in previous releases. This old name is still supported in this release and will be supported in future releases, but for clarify the new name, -genkeypair, is preferred going forward.

-genseckey
  {-alias alias}
  {-keyalg keyalg}
  {-keysize keysize}
  [-keypass keypass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Generates a secret key and stores it in a new KeyStore.SecretKeyEntry identified by alias.

keyalg specifies the algorithm to be used to generate the secret key, and keysize specifies the size of the key to be generated. keypass is a password used to protect the secret key. If no password is provided, the user is prompted for it. If you press RETURN at the prompt, the key password is set to the same password as that used for the keystore. keypass must be at least 6 characters long.

-importcert
  {-alias alias}
  {-file cert_file} [-keypass keypass]
  {-noprompt} {-trustcacerts}
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Reads the certificate or certificate chain (where the latter is supplied in a PKCS#7 formatted reply) from the file cert_file, and stores it in the keystore entry identified by alias. If no file is given, the certificate or PKCS#7 reply is read from stdin.

keytool can import X.509 v1, v2, and v3 certificates, and PKCS#7 formatted certificate chains consisting of certificates of that type. The data to be imported must be provided either in binary encoding format, or in printable encoding format (also known as Base64 encoding) as defined by the Internet RFC 1421 standard. In the latter case, the encoding must be bounded at the beginning by a string that starts with "-----BEGIN", and bounded at the end by a string that starts with "-----END".

You import a certificate for two reasons:

  1. to add it to the list of trusted certificates, or

  2. to import a certificate reply received from a CA as the result of submitting a Certificate Signing Request (see the -certreq command) to that CA.

Which type of import is intended is indicated by the value of the -alias option:

  1. If the alias does not point to a key entry, then keytool assumes you are adding a trusted certificate entry. In this case, the alias should not already exist in the keystore. If the alias does already exist, then keytool outputs an error, since there is already a trusted certificate for that alias, and does not import the certificate.

  2. If the alias points to a key entry, then keytool assumes you are importing a certificate reply.

Importing a New Trusted Certificate

Before adding the certificate to the keystore, keytool tries to verify it by attempting to construct a chain of trust from that certificate to a self-signed certificate (belonging to a root CA), using trusted certificates that are already available in the keystore.

If the -trustcacerts option has been specified, additional certificates are considered for the chain of trust, namely the certificates in a file named "cacerts".

If keytool fails to establish a trust path from the certificate to be imported up to a self-signed certificate (either from the keystore or the "cacerts" file), the certificate information is printed out, and the user is prompted to verify it, e.g., by comparing the displayed certificate fingerprints with the fingerprints obtained from some other (trusted) source of information, which might be the certificate owner himself/herself. Be very careful to ensure the certificate is valid prior to importing it as a "trusted" certificate! -- see WARNING Regarding Importing Trusted Certificates. The user then has the option of aborting the import operation. If the -noprompt option is given, however, there will be no interaction with the user.

Importing a Certificate Reply

When importing a certificate reply, the certificate reply is validated using trusted certificates from the keystore, and optionally using the certificates configured in the "cacerts" keystore file (if the -trustcacerts option was specified).

The methods of determining whether the certificate reply is trusted are described in the following:

  • If the reply is a single X.509 certificate, keytool attempts to establish a trust chain, starting at the certificate reply and ending at a self-signed certificate (belonging to a root CA). The certificate reply and the hierarchy of certificates used to authenticate the certificate reply form the new certificate chain of alias. If a trust chain cannot be established, the certificate reply is not imported. In this case, keytool does not print out the certificate and prompt the user to verify it, because it is very hard (if not impossible) for a user to determine the authenticity of the certificate reply.

  • If the reply is a PKCS#7 formatted certificate chain, the chain is first ordered (with the user certificate first and the self-signed root CA certificate last), before keytool attempts to match the root CA certificate provided in the reply with any of the trusted certificates in the keystore or the "cacerts" keystore file (if the -trustcacerts option was specified). If no match can be found, the information of the root CA certificate is printed out, and the user is prompted to verify it, e.g., by comparing the displayed certificate fingerprints with the fingerprints obtained from some other (trusted) source of information, which might be the root CA itself. The user then has the option of aborting the import operation. If the -noprompt option is given, however, there will be no interaction with the user.

If the public key in the certificate reply matches the user's public key already stored with under alias, the old certificate chain is replaced with the new certificate chain in the reply. The old chain can only be replaced if a valid keypass, the password used to protect the private key of the entry, is supplied. If no password is provided, and the private key password is different from the keystore password, the user is prompted for it.

This command was named -import in previous releases. This old name is still supported in this release and will be supported in future releases, but for clarify the new name, -importcert, is preferred going forward.

-importkeystore
  -srckeystore srckeystore -destkeystore destkeystore
  {-srcstoretype srcstoretype} {-deststoretype deststoretype}
  [-srcstorepass srcstorepass] [-deststorepass deststorepass]
  {-srcprotected} {-destprotected}
  {-srcalias srcalias
    {-destalias destalias}
    [-srckeypass srckeypass]
    [-destkeypass destkeypass]
  }
  {-noprompt}
  {-srcProviderName src_provider_name}
  {-destProviderName dest_provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Imports a single entry or all entries from a source keystore to a destination keystore.

When the srcalias option is provided, the command imports the single entry identified by the alias to the destination keystore. If a destination alias is not provided with destalias, then srcalias is used as the destination alias. If the source entry is protected by a password, srckeypass will be used to recover the entry. If srckeypass is not provided, then keytool will attempt to use srcstorepass to recover the entry. If srcstorepass is either not provided or is incorrect, the user will be prompted for a password. The destination entry will be protected using destkeypass. If destkeypass is not provided, the destination entry will be protected with the source entry password.

If the srcalias option is not provided, then all entries in the source keystore are imported into the destination keystore. Each destination entry will be stored under the alias from the source entry. If the source entry is protected by a password, srcstorepass will be used to recover the entry. If srcstorepass is either not provided or is incorrect, the user will be prompted for a password. If a source keystore entry type is not supported in the destination keystore, or if an error occurs while storing an entry into the destination keystore, the user will be prompted whether to skip the entry and continue, or to quit. The destination entry will be protected with the source entry password.

If the destination alias already exists in the destination keystore, the user is prompted to either overwrite the entry, or to create a new entry under a different alias name.

Note that if -noprompt is provided, the user will not be prompted for a new destination alias. Existing entries will automatically be overwritten with the destination alias name. Finally, entries that can not be imported are automatically skipped and a warning is output.

Exporting Data

-certreq {-alias alias}
  {-sigalg sigalg} {-file certreq_file}
  [-keypass keypass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Generates a Certificate Signing Request (CSR), using the PKCS#10 format.

A CSR is intended to be sent to a certificate authority (CA). The CA will authenticate the certificate requestor (usually off-line) and will return a certificate or certificate chain, used to replace the existing certificate chain (which initially consists of a self-signed certificate) in the keystore.

The private key and X.500 Distinguished Name associated with alias are used to create the PKCS#10 certificate request. In order to access the private key, the appropriate password must be provided, since private keys are protected in the keystore with a password. If keypass is not provided at the command line, and is different from the password used to protect the integrity of the keystore, the user is prompted for it.

sigalg specifies the algorithm that should be used to sign the CSR.

The CSR is stored in the file certreq_file. If no file is given, the CSR is output to stdout.

Use the importcert command to import the response from the CA.

-exportcert
  {-alias alias}
  {-file cert_file}
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-rfc} {-v} {-protected} {-Jjavaoption}

Reads (from the keystore) the certificate associated with alias, and stores it in the file cert_file.

If no file is given, the certificate is output to stdout.

The certificate is by default output in binary encoding, but will instead be output in the printable encoding format, as defined by the Internet RFC 1421 standard, if the -rfc option is specified.

If alias refers to a trusted certificate, that certificate is output. Otherwise, alias refers to a key entry with an associated certificate chain. In that case, the first certificate in the chain is returned. This certificate authenticates the public key of the entity addressed by alias.

This command was named -export in previous releases. This old name is still supported in this release and will be supported in future releases, but for clarify the new name, -exportcert, is preferred going forward.

Displaying Data

-list  {-alias alias}
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v | -rfc} {-protected} {-Jjavaoption}

Prints (to stdout) the contents of the keystore entry identified by alias. If no alias is specified, the contents of the entire keystore are printed.

This command by default prints the MD5 fingerprint of a certificate. If the -v option is specified, the certificate is printed in human-readable format, with additional information such as the owner, issuer, serial number, and any extensions. If the -rfc option is specified, certificate contents are printed using the printable encoding format, as defined by the Internet RFC 1421 standard

You cannot specify both -v and -rfc.

-printcert {-file cert_file} {-v} {-Jjavaoption}

Reads the certificate from the file cert_file, and prints its contents in a human-readable format. If no file is given, the certificate is read from stdin.

The certificate may be either binary encoded or in printable encoding format, as defined by the Internet RFC 1421 standard.

Note: This option can be used independently of a keystore.

Managing the Keystore

-storepasswd [-new new_storepass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-Jjavaoption}

Changes the password used to protect the integrity of the keystore contents. The new password is new_storepass, which must be at least 6 characters long.

-keypasswd {-alias alias}
  [-keypass old_keypass] [-new new_keypass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-Jjavaoption}

Changes the password under which the private/secret key identified by alias is protected, from old_keypass to new_keypass, which must be at least 6 characters long.

If the -keypass option is not provided at the command line, and the key password is different from the keystore password, the user is prompted for it.

If the -new option is not provided at the command line, the user is prompted for it.

-delete
  [-alias alias]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Deletes from the keystore the entry identified by alias. The user is prompted for the alias, if no alias is provided at the command line.

-changealias
  {-alias alias} [-destalias destalias]
  [-keypass keypass]
  {-storetype storetype}
  {-keystore keystore} [-storepass storepass]
  {-providerName provider_name}
  {-providerClass provider_class_name {-providerArg provider_arg}}
  {-v} {-protected} {-Jjavaoption}

Move an existing keystore entry from the specified alias to a new alias, destalias. If no destination alias is provided, the command will prompt for one. If the original entry is protected with an entry password, the password can be supplied via the "-keypass" option. If no key password is provided, the storepass (if given) will be attempted first. If that attempt fails, the user will be prompted for a password.

Getting Help

-help

Lists the basic commands and their options.

EXAMPLES

Suppose you want to create a keystore for managing your public/private key pair and certificates from entities you trust.

Generating Your Key Pair

The first thing you need to do is create a keystore and generate the key pair. You could use a command such as the following:

    keytool -genkeypair -dname "cn=Mark Jones, ou=JavaSoft, o=Sun, c=US"
      -alias business -keypass kpi135 -keystore C:\working\mykeystore
      -storepass ab987c -validity 180

(Please note: This must be typed as a single line. Multiple lines are used in the examples just for legibility purposes.)

This command creates the keystore named "mykeystore" in the "C:\working" directory (assuming it doesn't already exist), and assigns it the password "ab987c". It generates a public/private key pair for the entity whose "distinguished name" has a common name of "Mark Jones", organizational unit of "JavaSoft", organization of "Sun" and two-letter country code of "US". It uses the default "DSA" key generation algorithm to create the keys, both 1024 bits long.

It creates a self-signed certificate (using the default "SHA1withDSA" signature algorithm) that includes the public key and the distinguished name information. This certificate will be valid for 180 days, and is associated with the private key in a keystore entry referred to by the alias "business". The private key is assigned the password "kpi135".

The command could be significantly shorter if option defaults were accepted. As a matter of fact, no options are required; defaults are used for unspecified options that have default values, and you are prompted for any required values. Thus, you could simply have the following:

    keytool -genkeypair
In this case, a keystore entry with alias "mykey" is created, with a newly-generated key pair and a certificate that is valid for 90 days. This entry is placed in the keystore named ".keystore" in your home directory. (The keystore is created if it doesn't already exist.) You will be prompted for the distinguished name information, the keystore password, and the private key password.

The rest of the examples assume you executed the -genkeypair command without options specified, and that you responded to the prompts with values equal to those given in the first -genkeypair command, above (a private key password of "kpi135", etc.)

Requesting a Signed Certificate from a Certification Authority

So far all we've got is a self-signed certificate. A certificate is more likely to be trusted by others if it is signed by a Certification Authority (CA). To get such a signature, you first generate a Certificate Signing Request (CSR), via the following:

    keytool -certreq -file MarkJ.csr
This creates a CSR (for the entity identified by the default alias "mykey") and puts the request in the file named "MarkJ.csr". Submit this file to a CA, such as VeriSign, Inc. The CA will authenticate you, the requestor (usually off-line), and then will return a certificate, signed by them, authenticating your public key. (In some cases, they will actually return a chain of certificates, each one authenticating the public key of the signer of the previous certificate in the chain.)

Importing a Certificate for the CA

You need to replace your self-signed certificate with a certificate chain, where each certificate in the chain authenticates the public key of the signer of the previous certificate in the chain, up to a "root" CA.

Before you import the certificate reply from a CA, you need one or more "trusted certificates" in your keystore or in the cacerts keystore file (which is described in importcert command):

  • If the certificate reply is a certificate chain, you just need the top certificate of the chain (that is, the "root" CA certificate authenticating that CA's public key).

  • If the certificate reply is a single certificate, you need a certificate for the issuing CA (the one that signed it), and if that certificate is not self-signed, you need a certificate for its signer, and so on, up to a self-signed "root" CA certificate.

The "cacerts" keystore file ships with five VeriSign root CA certificates, so you probably won't need to import a VeriSign certificate as a trusted certificate in your keystore. But if you request a signed certificate from a different CA, and a certificate authenticating that CA's public key hasn't been added to "cacerts", you will need to import a certificate from the CA as a "trusted certificate".

A certificate from a CA is usually either self-signed, or signed by another CA (in which case you also need a certificate authenticating that CA's public key). Suppose company ABC, Inc., is a CA, and you obtain a file named "ABCCA.cer" that is purportedly a self-signed certificate from ABC, authenticating that CA's public key.

Be very careful to ensure the certificate is valid prior to importing it as a "trusted" certificate! View it first (using the keytool -printcert command, or the keytool -importcert command without the -noprompt option), and make sure that the displayed certificate fingerprint(s) match the expected ones. You can call the person who sent the certificate, and compare the fingerprint(s) that you see with the ones that they show (or that a secure public key repository shows). Only if the fingerprints are equal is it guaranteed that the certificate has not been replaced in transit with somebody else's (for example, an attacker's) certificate. If such an attack took place, and you did not check the certificate before you imported it, you would end up trusting anything the attacker has signed.

If you trust that the certificate is valid, then you can add it to your keystore via the following:

    keytool -importcert -alias abc -file ABCCA.cer
This creates a "trusted certificate" entry in the keystore, with the data from the file "ABCCA.cer", and assigns the alias "abc" to the entry.

Importing the Certificate Reply from the CA

Once you've imported a certificate authenticating the public key of the CA you submitted your certificate signing request to (or there's already such a certificate in the "cacerts" file), you can import the certificate reply and thereby replace your self-signed certificate with a certificate chain. This chain is the one returned by the CA in response to your request (if the CA reply is a chain), or one constructed (if the CA reply is a single certificate) using the certificate reply and trusted certificates that are already available in the keystore where you import the reply or in the "cacerts" keystore file.

For example, suppose you sent your certificate signing request to VeriSign. You can then import the reply via the following, which assumes the returned certificate is named "VSMarkJ.cer":

    keytool -importcert -trustcacerts -file VSMarkJ.cer

Exporting a Certificate Authenticating Your Public Key

Suppose you have used the jarsigner tool to sign a Java ARchive (JAR) file. Clients that want to use the file will want to authenticate your signature.

One way they can do this is by first importing your public key certificate into their keystore as a "trusted" entry. You can export the certificate and supply it to your clients. As an example, you can copy your certificate to a file named MJ.cer via the following, assuming the entry is aliased by "mykey":

    keytool -exportcert -alias mykey -file MJ.cer
Given that certificate, and the signed JAR file, a client can use the jarsigner tool to authenticate your signature.

Importing Keystore

The command "importkeystore" is used to import an entire keystore into another keystore, which means all entries from the source keystore, including keys and certificates, are all imported to the destination keystore within a single command. You can use this command to import entries from a different type of keystore. During the import, all new entries in the destination keystore will have the same alias names and protection passwords (for secret keys and private keys). If keytool has difficulties recover the private keys or secret keys from the source keystore, it will prompt you for a password. If it detects alias duplication, it will ask you for a new one, you can specify a new alias or simply allow keytool to overwrite the existing one.

For example, to import entries from a normal JKS type keystore key.jks into a PKCS #11 type hardware based keystore, you can use the command:

keytool -importkeystore
    -srckeystore key.jks -destkeystore NONE
    -srcstoretype JKS -deststoretype PKCS11
    -srcstorepass changeit -deststorepass topsecret

The importkeystore command can also be used to import a single entry from a source keystore to a destination keystore. In this case, besides the options you see in the above example, you need to specify the alias you want to import. With the srcalias option given, you can also specify the desination alias name in the command line, as well as protection password for a secret/private key and the destination protection password you want. In this way, you can issue a keytool command that will never ask you a question. This makes it very convenient to include a keytool command into a script file, like this:

keytool -importkeystore
    -srckeystore key.jks -destkeystore NONE
    -srcstoretype JKS -deststoretype PKCS11
    -srcstorepass changeit -deststorepass topsecret
    -srcalias myprivatekey -destalias myoldprivatekey
    -srckeypass oldkeypass -destkeypass mynewkeypass
    -noprompt

TERMINOLOGY and WARNINGS

KeyStore

A keystore is a storage facility for cryptographic keys and certificates.

  • KeyStore Entries

    Keystores may have different types of entries. The two most applicable entry types for keytool include:
    1. key entries - each holds very sensitive cryptographic key information, which is stored in a protected format to prevent unauthorized access. Typically, a key stored in this type of entry is a secret key, or a private key accompanied by the certificate "chain" for the corresponding public key. The keytool can handle both types od entry, while jarsigner tool only handle the latter type of entry, that is private keys and their associated certificate chains.

    2. trusted certificate entries - each contains a single public key certificate belonging to another party. It is called a "trusted certificate" because the keystore owner trusts that the public key in the certificate indeed belongs to the identity identified by the "subject" (owner) of the certificate. The issuer of the certificate vouches for this, by signing the certificate.

  • KeyStore Aliases

    All keystore entries (key and trusted certificate entries) are accessed via unique aliases.

    An alias is specified when you add an entity to the keystore using the -genseckey command to generate a secret key, -genkeypair command to generate a key pair (public and private key) or the -importcert command to add a certificate or certificate chain to the list of trusted certificates. Subsequent keytool commands must use this same alias to refer to the entity.

    For example, suppose you use the alias duke to generate a new public/private key pair and wrap the public key into a self-signed certificate (see Certificate Chains) via the following command:

        keytool -genkeypair -alias duke -keypass dukekeypasswd
    This specifies an inital password of "dukekeypasswd" required by subsequent commands to access the private key assocated with the alias duke. If you later want to change duke's private key password, you use a command like the following:
        keytool -keypasswd -alias duke -keypass dukekeypasswd -new newpass
    This changes the password from "dukekeypasswd" to "newpass".

    Please note: A password should not actually be specified on a command line or in a script unless it is for testing purposes, or you are on a secure system. If you don't specify a required password option on a command line, you will be prompted for it.

  • KeyStore Implementation

    The KeyStore class provided in the java.security package supplies well-defined interfaces to access and modify the information in a keystore. It is possible for there to be multiple different concrete implementations, where each implementation is that for a particular type of keystore.

    Currently, two command-line tools (keytool and jarsigner) and a GUI-based tool named Policy Tool make use of keystore implementations. Since KeyStore is publicly available, users can write additional security applications that use it.

    There is a built-in default implementation, provided by Sun Microsystems. It implements the keystore as a file, utilizing a proprietary keystore type (format) named "JKS". It protects each private key with its individual password, and also protects the integrity of the entire keystore with a (possibly different) password.

    Keystore implementations are provider-based. More specifically, the application interfaces supplied by KeyStore are implemented in terms of a "Service Provider Interface" (SPI). That is, there is a corresponding abstract KeystoreSpi class, also in the java.security package, which defines the Service Provider Interface methods that "providers" must implement. (The term "provider" refers to a package or a set of packages that supply a concrete implementation of a subset of services that can be accessed by the Java Security API.) Thus, to provide a keystore implementation, clients must implement a "provider" and supply a KeystoreSpi subclass implementation, as described in How to Implement a Provider for the Java Cryptography Architecture.

    Applications can choose different types of keystore implementations from different providers, using the "getInstance" factory method supplied in the KeyStore class. A keystore type defines the storage and data format of the keystore information, and the algorithms used to protect private/secret keys in the keystore and the integrity of the keystore itself. Keystore implementations of different types are not compatible.

    keytool works on any file-based keystore implementation. (It treats the keytore location that is passed to it at the command line as a filename and converts it to a FileInputStream, from which it loads the keystore information.) The jarsigner and policytool tools, on the other hand, can read a keystore from any location that can be specified using a URL.

    For keytool and jarsigner, you can specify a keystore type at the command line, via the -storetype option. For Policy Tool, you can specify a keystore type via the "Keystore" menu.

    If you don't explicitly specify a keystore type, the tools choose a keystore implementation based simply on the value of the keystore.type property specified in the security properties file. The security properties file is called java.security, and it resides in the security properties directory, java.home\lib\security, where java.home is the runtime environment's directory (the jre directory in the SDK or the top-level directory of the Java 2 Runtime Environment).

    Each tool gets the keystore.type value and then examines all the currently-installed providers until it finds one that implements keystores of that type. It then uses the keystore implementation from that provider.

    The KeyStore class defines a static method named getDefaultType that lets applications and applets retrieve the value of the keystore.type property. The following line of code creates an instance of the default keystore type (as specified in the keystore.type property):

        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());

    The default keystore type is "jks" (the proprietary type of the keystore implementation provided by Sun). This is specified by the following line in the security properties file:

        keystore.type=jks

    To have the tools utilize a keystore implementation other than the default, you can change that line to specify a different keystore type.

    For example, if you have a provider package that supplies a keystore implementation for a keystore type called "pkcs12", change the line to

        keystore.type=pkcs12
    Note: case doesn't matter in keystore type designations. For example, "JKS" would be considered the same as "jks".

Certificate

A certificate (also known as a public-key certificate) is a digitally signed statement from one entity (the issuer), saying that the public key (and some other information) of another entity (the subject) has some specific value.

  • Certificate Terms

    Public Keys
    These are numbers associated with a particular entity, and are intended to be known to everyone who needs to have trusted interactions with that entity. Public keys are used to verify signatures.
    Digitally Signed
    If some data is digitally signed it has been stored with the "identity" of an entity, and a signature that proves that entity knows about the data. The data is rendered unforgeable by signing with the entity's private key.
    Identity
    A known way of addressing an entity. In some systems the identity is the public key, in others it can be anything from a Unix UID to an Email address to an X.509 Distinguished Name.
    Signature
    A signature is computed over some data using the private key of an entity (the signer, which in the case of a certificate is also known as the issuer).
    Private Keys
    These are numbers, each of which is supposed to be known only to the particular entity whose private key it is (that is, it's supposed to be kept secret). Private and public keys exist in pairs in all public key cryptography systems (also referred to as "public key crypto systems"). In a typical public key crypto system, such as DSA, a private key corresponds to exactly one public key. Private keys are used to compute signatures.
    Entity
    An entity is a person, organization, program, computer, business, bank, or something else you are trusting to some degree.

    Basically, public key cryptography requires access to users' public keys. In a large-scale networked environment it is impossible to guarantee that prior relationships between communicating entities have been established or that a trusted repository exists with all used public keys. Certificates were invented as a solution to this public key distribution problem. Now a Certification Authority (CA) can act as a trusted third party. CAs are entities (for example, businesses) that are trusted to sign (issue) certificates for other entities. It is assumed that CAs will only create valid and reliable certificates, as they are bound by legal agreements. There are many public Certification Authorities, such as VeriSign, Thawte, Entrust, and so on. You can also run your own Certification Authority using products such as the Netscape/Microsoft Certificate Servers or the Entrust CA product for your organization.

    Using keytool, it is possible to display, import, and export certificates. It is also possible to generate self-signed certificates.

    keytool currently handles X.509 certificates.

  • X.509 Certificates

    The X.509 standard defines what information can go into a certificate, and describes how to write it down (the data format). All the data in a certificate is encoded using two related standards called ASN.1/DER. Abstract Syntax Notation 1 describes data. The Definite Encoding Rules describe a single way to store and transfer that data.

    All X.509 certificates have the following data, in addition to the signature:

    Version
    This identifies which version of the X.509 standard applies to this certificate, which affects what information can be specified in it. Thus far, three versions are defined. keytool can import and export v1, v2, and v3 certificates. It generates v3 certificates.

    X.509 Version 1 has been available since 1988, is widely deployed, and is the most generic.

    X.509 Version 2 introduced the concept of subject and issuer unique identifiers to handle the possibility of reuse of subject and/or issuer names over time. Most certificate profile documents strongly recommend that names not be reused, and that certificates should not make use of unique identifiers. Version 2 certificates are not widely used.

    X.509 Version 3 is the most recent (1996) and supports the notion of extensions, whereby anyone can define an extension and include it in the certificate. Some common extensions in use today are: KeyUsage (limits the use of the keys to particular purposes such as "signing-only") and AlternativeNames (allows other identities to also be associated with this public key, e.g. DNS names, Email addresses, IP addresses). Extensions can be marked critical to indicate that the extension should be checked and enforced/used. For example, if a certificate has the KeyUsage extension marked critical and set to "keyCertSign" then if this certificate is presented during SSL communication, it should be rejected, as the certificate extension indicates that the associated private key should only be used for signing certificates and not for SSL use.

    Serial Number
    The entity that created the certificate is responsible for assigning it a serial number to distinguish it from other certificates it issues. This information is used in numerous ways, for example when a certificate is revoked its serial number is placed in a Certificate Revocation List (CRL).

    Signature Algorithm Identifier
    This identifies the algorithm used by the CA to sign the certificate.

    Issuer Name
    The X.500 Distinguished Name of the entity that signed the certificate. This is normally a CA. Using this certificate implies trusting the entity that signed this certificate. (Note that in some cases, such as root or top-level CA certificates, the issuer signs its own certificate.)

    Validity Period
    Each certificate is valid only for a limited amount of time. This period is described by a start date and time and an end date and time, and can be as short as a few seconds or almost as long as a century. The validity period chosen depends on a number of factors, such as the strength of the private key used to sign the certificate or the amount one is willing to pay for a certificate. This is the expected period that entities can rely on the public value, if the associated private key has not been compromised.

    Subject Name
    The name of the entity whose public key the certificate identifies. This name uses the X.500 standard, so it is intended to be unique across the Internet. This is the X.500 Distinguished Name (DN) of the entity, for example,
        CN=Java Duke, OU=Java Software Division, O=Sun Microsystems Inc, C=US
    (These refer to the subject's Common Name, Organizational Unit, Organization, and Country.)

    Subject Public Key Information
    This is the public key of the entity being named, together with an algorithm identifier which specifies which public key crypto system this key belongs to and any associated key parameters.

  • Certificate Chains

    keytool can create and manage keystore "key" entries that each contain a private key and an associated certificate "chain". The first certificate in the chain contains the public key corresponding to the private key.

    When keys are first generated (see the -genkeypair command), the chain starts off containing a single element, a self-signed certificate. A self-signed certificate is one for which the issuer (signer) is the same as the subject (the entity whose public key is being authenticated by the certificate). Whenever the -genkeypair command is called to generate a new public/private key pair, it also wraps the public key into a self-signed certificate.

    Later, after a Certificate Signing Request (CSR) has been generated (see the -certreq command) and sent to a Certification Authority (CA), the response from the CA is imported (see -importcert), and the self-signed certificate is replaced by a chain of certificates. At the bottom of the chain is the certificate (reply) issued by the CA authenticating the subject's public key. The next certificate in the chain is one that authenticates the CA's public key.

    In many cases, this is a self-signed certificate (that is, a certificate from the CA authenticating its own public key) and the last certificate in the chain. In other cases, the CA may return a chain of certificates. In this case, the bottom certificate in the chain is the same (a certificate signed by the CA, authenticating the public key of the key entry), but the second certificate in the chain is a certificate signed by a different CA, authenticating the public key of the CA you sent the CSR to. Then, the next certificate in the chain will be a certificate authenticating the second CA's key, and so on, until a self-signed "root" certificate is reached. Each certificate in the chain (after the first) thus authenticates the public key of the signer of the previous certificate in the chain.

    Many CAs only return the issued certificate, with no supporting chain, especially when there is a flat hierarchy (no intermediates CAs). In this case, the certificate chain must be established from trusted certificate information already stored in the keystore.

    A different reply format (defined by the PKCS#7 standard) also includes the supporting certificate chain, in addition to the issued certificate. Both reply formats can be handled by keytool.

    The top-level (root) CA certificate is self-signed. However, the trust into the root's public key does not come from the root certificate itself (anybody could generate a self-signed certificate with the distinguished name of say, the VeriSign root CA!), but from other sources like a newspaper. The root CA public key is widely known. The only reason it is stored in a certificate is because this is the format understood by most tools, so the certificate in this case is only used as a "vehicle" to transport the root CA's public key. Before you add the root CA certificate to your keystore, you should view it (using the -printcert option) and compare the displayed fingerprint with the well-known fingerprint (obtained from a newspaper, the root CA's webpage, etc.).

  • The cacerts Certificates File

    A certificates file named "cacerts" resides in the security properties directory, java.home\lib\security, where java.home is the runtime environment's directory (the jre directory in the SDK or the top-level directory of the Java 2 Runtime Environment).

    The "cacerts" file represents a system-wide keystore with CA certificates. System administrators can configure and manage that file using keytool, specifying "jks" as the keystore type. The "cacerts" keystore file ships with several root CA certificates with the following aliases and X.500 owner distinguished names:

    • Alias: thawtepersonalfreemailca
Owner DN:
              EmailAddress=personal-freemail@thawte.com,
CN=Thawte Personal Freemail CA,
OU=Certification Services Division,
O=Thawte Consulting, L=Cape Town, ST=Western Cape,
              C=ZA
    • Alias: thawtepersonalbasicca
Owner DN:
              EmailAddress=personal-basic@thawte.com,
CN=Thawte Personal Basic CA,
OU=Certification Services Division,
O=Thawte Consulting, L=Cape Town, ST=Western Cape,
              C=ZA
    • Alias: thawtepersonalpremiumca
Owner DN:
              EmailAddress=personal-premium@thawte.com,
CN=Thawte Personal Premium CA,
OU=Certification Services Division,
O=Thawte Consulting, L=Cape Town, ST=Western Cape,
              C=ZA
    • Alias: thawteserverca
      Owner DN: EmailAddress=server-certs@thawte.com,
      CN=Thawte Server CA, OU=Certification Services Division,
      O=Thawte Consulting cc, L=Cape Town, ST=Western Cape, C=ZA
    • Alias: thawtepremiumserverca
Owner DN:
              EmailAddress=premium-server@thawte.com,
CN=Thawte Premium Server CA,
OU=Certification Services Division,
O=Thawte Consulting cc, L=Cape Town, ST=Western Cape,
              C=ZA
    • Alias: verisignclass1ca
      Owner DN: OU=Class 1 Public Primary Certification Authority,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass2ca
      Owner DN: OU=Class 2 Public Primary Certification Authority,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass3ca
      Owner DN: OU=Class 3 Public Primary Certification Authority,
      O="VeriSign, Inc.", C=US
    • Alias: verisignserverca
      Owner DN: OU=Secure Server Certification Authority,
      O="RSA Data Security, Inc.", C=US
    • Alias: verisignclass1g2ca
      Owner DN: OU=VeriSign Trust Network,
      OU="(c) 1998 VeriSign, Inc. - For authorized use only",
      OU=Class 1 Public Primary Certification Authority - G2,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass1g3ca
Owner DN: CN=VeriSign Class 1 Public Primary Certification Authority - G3,
              OU="(c) 1999 VeriSign, Inc. - For authorized use only",
OU=VeriSign Trust Network,
O="VeriSign, Inc.", C=US
    • Alias: verisignclass2g2ca
      Owner DN: OU=VeriSign Trust Network,
      OU="(c) 1998 VeriSign, Inc. - For authorized use only",
      OU=Class 2 Public Primary Certification Authority - G2,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass2g3ca
      Owner DN: CN=VeriSign Class 2 Public Primary Certification Authority - G3,
      OU="(c) 1999 VeriSign, Inc. - For authorized use only",
      OU=VeriSign Trust Network,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass3g2ca
      Owner DN: OU=VeriSign Trust Network,
      OU="(c) 1998 VeriSign, Inc. - For authorized use only",
      OU=Class 3 Public Primary Certification Authority - G2,
      O="VeriSign, Inc.", C=US
    • Alias: verisignclass3g3ca
      Owner DN: CN=VeriSign Class 3 Public Primary Certification Authority - G3,
      OU="(c) 1999 VeriSign, Inc. - For authorized use only",
      OU=VeriSign Trust Network,
      O="VeriSign, Inc.", C=US
    • Alias: baltimorecodesigningca
      Owner DN: CN=Baltimore CyberTrust Code Signing Root,
      OU=CyberTrust, O=Baltimore, C=IE
    • Alias: gtecybertrustglobalca
      Owner DN: CN=GTE CyberTrust Global Root,
      OU="GTE CyberTrust Solutions, Inc.", O=GTE Corporation, C=US
    • Alias: baltimorecybertrustca
      Owner DN: CN=Baltimore CyberTrust Root,
      OU=CyberTrust, O=Baltimore, C=IE
    • Alias: gtecybertrust5ca
      Owner DN: CN=GTE CyberTrust Root 5,
      OU="GTE CyberTrust Solutions, Inc.", O=GTE Corporation, C=US
    • Alias: entrustclientca
      Owner DN: CN=Entrust.net Client Certification Authority,
      OU=(c) 1999 Entrust.net Limited,
      OU=www.entrust.net/Client_CA_Info/CPS incorp. by ref. limits liab.,
      O=Entrust.net, C=US
    • Alias: entrustglobalclientca
      Owner DN: CN=Entrust.net Client Certification Authority,
      OU=(c) 2000 Entrust.net Limited,
      OU=www.entrust.net/GCCA_CPS incorp. by ref. (limits liab.),
      O=Entrust.net
    • Alias: entrust2048ca
      Owner DN: CN=Entrust.net Certification Authority (2048),
      OU=(c) 1999 Entrust.net Limited,
      OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.),
      O=Entrust.net
    • Alias: entrustsslca
      Owner DN: CN=Entrust.net Secure Server Certification Authority,
      OU=(c) 1999 Entrust.net Limited,
      OU=www.entrust.net/CPS incorp. by ref. (limits liab.),
      O=Entrust.net, C=US
    • Alias: entrustgsslca
      Owner DN: CN=Entrust.net Secure Server Certification Authority,
      OU=(c) 2000 Entrust.net Limited,
      OU=www.entrust.net/SSL_CPS incorp. by ref. (limits liab.),
      O=Entrust.net
    • Alias: godaddyclass2ca
      Owner DN: OU=Go Daddy Class 2 Certification Authority,
      O="The Go Daddy Group, Inc.", C=US
    • Alias: starfieldclass2ca
      Owner DN: OU=Starfield Class 2 Certification Authority,
      O="Starfield Technologies, Inc.", C=US
    • Alias: valicertclass2ca
      Owner DN: EMAILADDRESS=info@valicert.com,
      CN=http://www.valicert.com/,
      OU=ValiCert Class 2 Policy Validation Authority,
      O="ValiCert, Inc.", L=ValiCert Validation Network
    • Alias: geotrustglobalca
      Owner DN: CN=GeoTrust Global CA,
      O=GeoTrust Inc., C=US
    • Alias: equifaxsecureca
      Owner DN: OU=Equifax Secure Certificate Authority,
      O=Equifax, C=US
    • Alias: equifaxsecureebusinessca1
      Owner DN: CN=Equifax Secure eBusiness CA-1,
      O=Equifax Secure Inc., C=US
    • Alias: equifaxsecureebusinessca2
      Owner DN: OU=Equifax Secure eBusiness CA-2,
      O=Equifax Secure, C=US
    • Alias: equifaxsecureglobalebusinessca1
      Owner DN: CN=Equifax Secure Global eBusiness CA-1,
      O=Equifax Secure Inc., C=US
    • Alias: soneraclass1ca
      Owner DN: CN=Sonera Class1 CA, O=Sonera, C=FI
    • Alias: soneraclass2ca
      Owner DN: CN=Sonera Class2 CA, O=Sonera, C=FI
    • Alias: comodoaaaca
      Owner DN: CN=AAA Certificate Services,
      O=Comodo CA Limited, L=Salford, ST=Greater Manchester, C=GB
    • Alias: addtrustclass1ca
      Owner DN: CN=AddTrust Class 1 CA Root,
      OU=AddTrust TTP Network, O=AddTrust AB, C=SE
    • Alias: addtrustexternalca
      Owner DN: CN=AddTrust External CA Root,
      OU=AddTrust External TTP Network, O=AddTrust AB, C=SE
    • Alias: addtrustqualifiedca
      Owner DN: CN=AddTrust Qualified CA Root,
      OU=AddTrust TTP Network, O=AddTrust AB, C=SE
    • Alias: utnuserfirsthardwareca
      Owner DN: CN=UTN-USERFirst-Hardware,
      OU=http://www.usertrust.com, O=The USERTRUST Network,
      L=Salt Lake City, ST=UT, C=US
    • Alias: utnuserfirstclientauthemailca
      Owner DN: CN=UTN-USERFirst-Client Authentication and Email,
      OU=http://www.usertrust.com, O=The USERTRUST Network,
      L=Salt Lake City, ST=UT, C=US
    • Alias: utndatacorpsgcca
      Owner DN: CN=UTN - DATACorp SGC,
      OU=http://www.usertrust.com, O=The USERTRUST Network,
      L=Salt Lake City, ST=UT, C=US
    • Alias: utnuserfirstobjectca
      Owner DN: CN=UTN-USERFirst-Object,
      OU=http://www.usertrust.com, O=The USERTRUST Network,
      L=Salt Lake City, ST=UT, C=US

    The initial password of the "cacerts" keystore file is "changeit". System administrators should change that password and the default access permission of that file upon installing the SDK.

    IMPORTANT: Verify Your cacerts File
    Since you trust the CAs in the cacerts file as entities for signing and issuing certificates to other entities, you must manage the cacerts file carefully. The cacerts file should contain only certificates of the CAs you trust. It is your responsibility to verify the trusted root CA certificates bundled in the cacerts file and make your own trust decisions. To remove an untrusted CA certificate from the cacerts file, use the delete option of the keytool command. You can find the cacerts file in the JRE installation directory. Contact your system administrator if you do not have permission to edit this file.

  • The Internet RFC 1421 Certificate Encoding Standard

    Certificates are often stored using the printable encoding format defined by the Internet RFC 1421 standard, instead of their binary encoding. This certificate format, also known as "Base 64 encoding", facilitates exporting certificates to other applications by email or through some other mechanism.

    Certificates read by the -importcert and -printcert commands can be in either this format or binary encoded.

    The -exportcert command by default outputs a certificate in binary encoding, but will instead output a certificate in the printable encoding format, if the -rfc option is specified.

    The -list command by default prints the MD5 fingerprint of a certificate. If the -v option is specified, the certificate is printed in human-readable format, while if the -rfc option is specified, the certificate is output in the printable encoding format.

    In its printable encoding format, the encoded certificate is bounded at the beginning by

    -----BEGIN CERTIFICATE-----

    and at the end by

    -----END CERTIFICATE-----

X.500 Distinguished Names

X.500 Distinguished Names are used to identify entities, such as those which are named by the subject and issuer (signer) fields of X.509 certificates. keytool supports the following subparts:
  • commonName - common name of a person, e.g., "Susan Jones"

  • organizationUnit - small organization (e.g, department or division) name, e.g., "Purchasing"

  • organizationName - large organization name, e.g., "ABCSystems, Inc."

  • localityName - locality (city) name, e.g., "Palo Alto"

  • stateName - state or province name, e.g., "California"

  • country - two-letter country code, e.g., "CH"

When supplying a distinguished name string as the value of a -dname option, as for the -genkeypair command, the string must be in the following format:

CN=cName, OU=orgUnit, O=org, L=city, S=state, C=countryCode

where all the italicized items represent actual values and the above keywords are abbreviations for the following:

    CN=commonName
    OU=organizationUnit
    O=organizationName
    L=localityName
    S=stateName
    C=country

A sample distinguished name string is

CN=Mark Smith, OU=JavaSoft, O=Sun, L=Cupertino, S=California, C=US
and a sample command using such a string is
keytool -genkeypair -dname "CN=Mark Smith, OU=JavaSoft, O=Sun, L=Cupertino,
S=California, C=US" -alias mark

Case does not matter for the keyword abbreviations. For example, "CN", "cn", and "Cn" are all treated the same.

Order matters; each subcomponent must appear in the designated order. However, it is not necessary to have all the subcomponents. You may use a subset, for example:

CN=Steve Meier, OU=SunSoft, O=Sun, C=US

If a distinguished name string value contains a comma, the comma must be escaped by a "\" character when you specify the string on a command line, as in

   cn=peter schuster, o=Sun Microsystems\, Inc., o=sun, c=us

It is never necessary to specify a distinguished name string on a command line. If it is needed for a command, but not supplied on the command line, the user is prompted for each of the subcomponents. In this case, a comma does not need to be escaped by a "\".

WARNING Regarding Importing Trusted Certificates

IMPORTANT: Be sure to check a certificate very carefully before importing it as a trusted certificate!

View it first (using the -printcert command, or the -importcert command without the -noprompt option), and make sure that the displayed certificate fingerprint(s) match the expected ones. For example, suppose someone sends or emails you a certificate, and you put it in a file named C:\temp\cert. Before you consider adding the certificate to your list of trusted certificates, you can execute a -printcert command to view its fingerprints, as in

  keytool -printcert -file C:\temp\cert
    Owner: CN=ll, OU=ll, O=ll, L=ll, S=ll, C=ll
    Issuer: CN=ll, OU=ll, O=ll, L=ll, S=ll, C=ll
    Serial Number: 59092b34
    Valid from: Thu Sep 25 18:01:13 PDT 1997 until: Wed Dec 24 17:01:13 PST 1997
    Certificate Fingerprints:
         MD5:  11:81:AD:92:C8:E5:0E:A2:01:2E:D4:7A:D7:5F:07:6F
         SHA1: 20:B6:17:FA:EF:E5:55:8A:D0:71:1F:E8:D6:9D:C0:37:13:0E:5E:FE
Then call or otherwise contact the person who sent the certificate, and compare the fingerprint(s) that you see with the ones that they show. Only if the fingerprints are equal is it guaranteed that the certificate has not been replaced in transit with somebody else's (for example, an attacker's) certificate. If such an attack took place, and you did not check the certificate before you imported it, you would end up trusting anything the attacker has signed (for example, a JAR file with malicious class files inside).

Note: it is not required that you execute a -printcert command prior to importing a certificate, since before adding a certificate to the list of trusted certificates in the keystore, the -importcert command prints out the certificate information and prompts you to verify it. You then have the option of aborting the import operation. Note, however, this is only the case if you invoke the -importcert command without the -noprompt option. If the -noprompt option is given, there is no interaction with the user.

Warning Regarding Passwords

Most commands operating on a keystore require the store password. Some commands require a private/secret key password.

Passwords can be specified on the command line (in the -storepass and -keypass options, respectively). However, a password should not be specified on a command line or in a script unless it is for testing purposes, or you are on a secure system.

If you don't specify a required password option on a command line, you will be prompted for it.

SEE ALSO

  • jar tool documentation

  • jarsigner tool documentation

  • the Security trail of the Java Tutorial for examples of the use of keytool

CHANGES

The command interface for keytool changed in Java SE 6.

keytool no longer displays password input when entered by users. Since password input can no longer be viewed when entered, users will be prompted to re-enter passwords any time a password is being set or changed (for example, when setting the initial keystore password, or when changing a key password).

Some commands have simply been renamed, and other commands deemed obsolete are no longer listed in this document. All previous commands (both renamed and obsolete) are still supported in this release and will continue to be supported in future releases. The following summarizes all of the changes made to the keytool command interface:

Renamed commands:

  • -export, renamed to -exportcert
  • -genkey, renamed to -genkeypair
  • -import, renamed to -importcert

Commands deemed obsolete and no longer documented:

  • -keyclone
  • -identitydb
  • -selfcert

Copyright © 2002-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


kinit - Kerberos tool

kinit - Obtain and cache Kerberos ticket-granting ticket

kinit is used to obtain and cache Kerberos ticket-granting tickets. This tool is similar in functionality to the kinit tool that are commonly found in other Kerberos implementations, such as SEAM and MIT Reference implementations.

The user must be registered as a principal with the Key Distribution Center (KDC) prior to running kinit.

SYNOPSIS

kinit [ commands ] <principal name> [<password>]

DESCRIPTION

By default, on the Windows platform a cache file named <USER_HOME>\krb5cc_<USER_NAME> will be generated. <uid> is the user identification number of the user logged into the system. By default, for all Unix platforms a cache file named/tmp/krb5cc_<uid> is generated.

<USER_HOME> is obtained from the java.lang.System property user.home. <USER_NAME> is obtained from java.lang.System property user.name. If <USER_HOME> is null, the cache file would be stored in the current directory that the program is running from. <USER_NAME> is the operating system's login username. This username could be different than the user's principal name. For example on Windows NT, it could be c:\winnt\profiles\duke\krb5cc_duke, in which duke is the <USER_NAME> and c:\winnt\profiles\duke is the <USER_HOME>.

By default, the keytab name is retrieved from the Kerberos configuration file. If the keytab name is not specifed in the Kerberos configuration file, the name is assumed to be <USER_HOME>\krb5.keytab

If you do not specify the password using the password option on the command line, kinit will prompt you for the password.

Note: password is provided only for testing purposes. Do not place your password in a script or provide your password on the command line. Doing so will compromise your password.

For more information see the man pages for kinit.

COMMANDS

Usage: kinit [-fp] [-c <cache_name>] [-k] [-t <keytab_filename>] [<principal>] [<password>] [-help]

Command Option | Description
-f | Issue a forwardable ticket.
-p | Issue a proxiable ticket.
-c <cache_name> | The cache name (i.e., FILE:d:\temp\mykrb5cc).
-k | Use keytab
-t <keytab_filename> | The keytab name (i.e, d:\winnt\profiles\duke\krb5.keytab).
<principal> | The principal name (i.e., duke@java.sun.com).
<password> The principal's Kerberos password.
(DO NOT SPECIFY ON COMMAND LINE OR IN A SCRIPT.)
-help | Displays instructions.

EXAMPLES

Requesting credentials valid for authentication from the current client host, for the default services, storing the credentials cache in the default location (c:\winnt\profiles\duke\krb5cc_duke):

kinit duke@JAVA.SUN.COM

Requesting proxiable credentials for a different principal and storing these credentials in a specified file cache:

kinit -p -c FILE:c:\winnt\profiles\duke\credentials\krb5cc_cafebeef cafebeef@JAVA.SUN.COM

Requesting proxiable and forwardable credentials for a different principal and storing these credentials in a specified file cache:

kinit -f -p -c FILE:c:\winnt\profiles\duke\credentials\krb5cc_cafebeef cafebeef@JAVA.SUN.COM

Displaying the help menu for kinit:

kinit -help

SECURITY ALERT

The password flag is for testing purposes only. Do not specify your password on the command line. Doing so is a security hole since an attacker could discover your password while running the Unix ps command, for example.


klist - Kerberos tool

klist - Kerberos display entries in credentials cache and keytab

klist allows the user to view entries in the local credentials cache and key table.

SYNOPSIS

klist [ commands ]

DESCRIPTION

klist displays the entries in the local credentials cache and key table. After the user has modified the credentials cache with kinit or modified the keytab with ktab, the only way to verify the changes is to view the contents of the credentials cache and/or keytab using klist. klist does not change the Kerberos database.

COMMANDS

Usage: klist [-c [-fe]] [-k [-tK]] [<name>] [-help]

Command Option | Description
-c | Specifes that the credential cache entries are to be listed.
-k | Specifies that the key tab entries are to be listed.
<name> | Specifies the credential cache name or the keytab name. If the name is not specified default values for cache name and the keytab are used. The default values for the cache and the keytab are specified in the man page for kinit.
-help | Displays instructions.
If the -c option is specified (options for credential cache):
-f | Shows credentials flags.
-e | Shows the encryption type.
If the -k option is specified (options available for keytabs):
-t | Shows keytab entry timestamps.
-K | Shows keytab entry DES keys.

EXAMPLES

List entries in the keytable specified including keytab entry timestamps and DES keys:
klist -k -t -K FILE:\temp\mykrb5cc
List entries in the credentials cache specified including credentials flag and address list:
klist -c -f FILE:\temp\mykrb5cc


ktab - Kerberos tool

ktab - Kerberos key table manager

ktab allows the user to manage the principal names and service keys stored in a local key table. Principal and key pairs listed in the keytab allow services running on a host to authenticate themselves to the Key Distribution Center (KDC). Before a server can be setup to use Kerberos, the user must setup a keytab on the host running the server. Note that any updates made to the keytab using ktab do not affect the Kerberos database. If you change the keys in the keytab, you must also make the corresponding changes to the Kerberos database.

SYNOPSIS

ktab [ commands ]

DESCRIPTION

ktab manages principal name and key pairs in the key table. ktab allows the user to list, add, update or delete principal names and key pairs in the key table. None of these operations affect the Kerberos database.

Keytab
A keytab is a host's copy of its own keylist, which is analogous to a user's password. An application server that needs to authenticate itself to the Key Distribution Center (KDC) must have a keytab which contains its own principal and key. Just as it is important for users to protect their passwords, it is equally important for hosts to protect their keytabs. You should always store keytab files on the local disk and make them readable only by root. You should never send a keytab file over a network in the clear.

COMMANDS

Usage: The command line options are not case-sensitive.

ktab -help

ktab -l [-k <keytab_name>]

ktab [-a <principal_name> <password>] [-k <keytab_name>]

ktab [-d <principal_name>] [-k <keytab_name>]

Command Option | Description
-l | List the keytab name and entries.
-a <principal_name> <password> | Add an entry to the keytab. No changes are made to the Kerberos database. (DO NOT SPECIFY YOUR PASSWORD ON COMMAND LINE OR IN A SCRIPT.)
-d <principal_name> | Delete an entry from the keytab. No changes are made to the Kerberos database.
-k <keytab_name> | Specify keytab name and path with the prefix FILE:
-help | Displays instructions.

EXAMPLES

To list all the entries in the default keytable:
ktab -l
To add a new principal to the key table (note that you will be prompted for your password):
ktab -a duke@java.sun.com
To delete a principal from the key table:
ktab -d duke@java.sun.com

SECURITY ALERT

Do not specify your password on the command line. Doing so is a security hole. For example, an attacker could discover your password while running the Unix ps command.


policytool - Policy File Admin GUI

policytool - PolicyTool Administration GUI Utility

policytool reads and writes a plain text policy file based on user input via the utility GUI.
  • Synopsis
  • Description
  • Options
  • See Also

SYNOPSIS

Run the policytool Administrator's utility
policytool
Run policytool and load the specified policy file
policytool[-file][filename]

where:
file
directs policytool to load a local policy file
filename
The file name

DESCRIPTION

policytool is an Administrator's GUI that allows system administrators to manage the contents of local policy files. A policy file is a plain-text file with a .policy extension, that maps remote requestors by domain, to permission objects. For details, see Default Policy Implementation and Syntax.

OPTIONS

file
Loads filename.

SEE ALSO

Default Policy Implementation and Syntax
Policy Tool Users' Guide
Security Permissions
Security Overview
Security Architecture

Copyright © 2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


rmic - The Java RMI Compiler

rmic generates stub, skeleton, and tie classes for remote objects using either the JRMP or IIOP protocols. Also generates OMG IDL.

SYNOPSIS

rmic [ options ] package-qualified-class-name(s)

DESCRIPTION

The rmic compiler generates stub and skeleton class files (JRMP protocol) and stub and tie class files (IIOP protocol) for remote objects. These classes files are generated from compiled Java programming language classes that are remote object implementation classes. A remote implementation class is a class that implements the interface java.rmi.Remote. The class names in the rmic command must be for classes that have been compiled successfully with the javac command and must be fully package qualified. For example, running rmic on the class file name HelloImpl as shown here:
rmic hello.HelloImpl
creates the HelloImpl_Stub.class file in the hello subdirectory (named for the class's package).

A skeleton for a remote object is a JRMP protocol server-side entity that has a method that dispatches calls to the actual remote object implementation.

A tie for a remote object is a server-side entity similar to a skeleton, but which communicates with the client using the IIOP protocol.

A stub is a client-side proxy for a remote object which is responsible for communicating method invocations on remote objects to the server where the actual remote object implementation resides. A client's reference to a remote object, therefore, is actually a reference to a local stub.

By default, rmic generates stub classes that use the 1.2 JRMP stub protocol version only, as if the -v1.2 option had been specified. (Note that the -vcompat option was the default in releases prior to 5.0.) Use the -iiop option to generate stub and tie classes for the IIOP protocol.

A stub implements only the remote interfaces, not any local interfaces that the remote object also implements. Because a JRMP stub implements the same set of remote interfaces as the remote object itself, a client can use the Java programming language's built-in operators for casting and type checking. For IIOP, the PortableRemoteObject.narrow method must be used.

OPTIONS

-bootclasspath path
Overrides location of bootstrap class files
-classpath path
Specifies the path rmic uses to look up classes. This option overrides the default or the CLASSPATH environment variable if it is set. Directories are separated by semicolons. Thus the general format for path is:
.;<your_path>
For example:
.;C:\usr\local\java\classes
-d directory
Specifies the root destination directory for the generated class hierarchy. You can use this option to specify a destination directory for the stub, skeleton, and tie files. For example, the command
% rmic -d C:\java\classes foo.MyClass
would place the stub and skeleton classes derived from MyClass into the directory C:\java\classes\foo. If the -d option is not specified, the default behavior is as if "-d ." were specified: the package hierarchy of the target class is created in the current directory, and stub/tie/skeleton files are placed within it. (Note that in some previous versions of rmic, if -d was not specified, then the package hierarchy was not created, and all of the output files were placed directly in the current directory.)
-extdirs path
Overrides location of installed extensions
-g
Enables generation of all debugging information, including local variables. By default, only line number information is generated.

-idl
Causes rmic to generate OMG IDL for the classes specified and any classes referenced. IDL provides a purely declarative, programming language-independent way of specifying an object's API. The IDL is used as a specification for methods and data that can be written in and invoked from any language that provides CORBA bindings. This includes Java and C++ among others. See the Java Language to IDL Mapping (OMG) document for a complete description.

When the -idl option is used, other options also include:

-always or -alwaysgenerate
Forces re-generation even when existing stubs/ties/IDL are newer than the input class.
-factory
Uses factory keyword in generated IDL.
-idlModule fromJavaPackage[.class] toIDLModule
Specifies IDLEntity package mapping. For example: -idlModule foo.bar my::real::idlmod.
-idlFile fromJavaPackage[.class] toIDLFile
Specifies IDLEntity file mapping. For example: -idlFile test.pkg.X TEST16.idl.

-iiop
Causes rmic to generate IIOP stub and tie classes, rather than JRMP stub and skeleton classes. A stub class is a local proxy for a remote object and is used by clients to send calls to a server. Each remote interface requires a stub class, which implements that remote interface. A client's reference to a remote object is actually a reference to a stub. Tie classes are used on the server side to process incoming calls, and dispatch the calls to the proper implementation class. Each implementation class requires a tie class.

Invoking rmic with the -iiop generates stubs and ties that conform to this naming convention:

_<implementationName>_stub.class

_<interfaceName>_tie.class

When the -iiop option is used, other options also include:

-always or -alwaysgenerate
Forces re-generation even when existing stubs/ties/IDL are newer than the input class.
-nolocalstubs
Do not create stubs optimized for same-process clients and servers.
-noValueMethods
Must be used with the -idl option. Prevents addition of valuetype methods and initializers to emitted IDL. These methods and initializers are optional for valuetypes, and are generated unless the -noValueMethods option is specified when using the -idl option.
-poa
Changes the inheritance from org.omg.CORBA_2_3.portable.ObjectImpl to org.omg.PortableServer.Servant.

The PortableServer module for the Portable Object Adapter (POA) defines the native Servant type. In the Java programming language, the Servant type is mapped to the Java org.omg.PortableServer.Servant class. It serves as the base class for all POA servant implementations and provides a number of methods that may be invoked by the application programmer, as well as methods which are invoked by the POA itself and may be overridden by the user to control aspects of servant behavior. Based on the OMG IDL to Java Language Mapping Specification, CORBA V 2.3.1 ptc/00-01-08.pdf.

-J
Used in conjunction with any java option, it passes the option following the -J (no spaces between the -J and the option) on to the java interpreter.
-keep or -keepgenerated
Retains the generated .java source files for the stub, skeleton, and/or tie classes and writes them to the same directory as the .class files.
-nowarn
Turns off warnings. If used the compiler does not print out any warnings.

-vcompat
Generates stub and skeleton classes compatible with both the 1.1 and 1.2 JRMP stub protocol versions. (This option was the default in releases prior to 5.0.) The generated stub classes will use the 1.1 stub protocol version when loaded in a JDK 1.1 virtual machine and will use the 1.2 stub protocol version when loaded into a 1.2 (or later) virtual machine. The generated skeleton classes will support both 1.1 and 1.2 stub protocol versions. The generated classes are relatively large in order to support both modes of operation.
-verbose
Causes the compiler and linker to print out messages about what classes are being compiled and what class files are being loaded.

-v1.1
Generates stub and skeleton classes for the 1.1 JRMP stub protocol version only. Note that this option is only useful for generating stub classes that are serialization-compatible with pre-existing, statically-deployed stub classes that were generated by the rmic tool from JDK 1.1 and that cannot be upgraded (and dynamic class loading is not being used).

-v1.2
(default) Generates stub classes for the 1.2 JRMP stub protocol version only. No skeleton classes are generated with this option because skeleton classes are not used with the 1.2 stub protocol version. The generated stub classes will not work if they are loaded into a JDK 1.1 virtual machine.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by semicolons. For example,
.;C:\usr\local\java\classes

SEE ALSO

java, javac, CLASSPATH
Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.
Please send comments to: rmi-comments@java.sun.com 		Sun


rmid - The Java RMI Activation System Daemon

rmid starts the activation system daemon that allows objects to be registered and activated in a Java virtual machine (JVM).

SYNOPSIS

rmid [options]

DESCRIPTION

The rmid tool starts the activation system daemon. The activation system daemon must be started before activatable objects can be either registered with the activation system or activated in a JVM. See the RMI Specification and Activation tutorials for details on how to write programs that use activatable remote objects.

The daemon can be started by executing the rmid command, and specifying a security policy file, as follows:

    rmid -J-Djava.security.policy=rmid.policy

Note: When running Sun's implementation of rmid, by default you will need to specify a security policy file so that rmid can verify whether or not the information in each ActivationGroupDesc is allowed to be used to launch a JVM for an activation group. Specifically, the command and options specified by the CommandEnvironment and any Properties passed to an ActivationGroupDesc's constructor must now be explicitly allowed in the security policy file for rmid. The value of the sun.rmi.activation.execPolicy property dictates the policy that rmid uses to determine whether or not the information in an ActivationGroupDesc may be used to launch a JVM for an activation group.

Executing rmid by default

  • starts the Activator and an internal registry on the default port, 1098, and
  • binds an ActivationSystem to the name java.rmi.activation.ActivationSystem in this internal registry.
To specify an alternate port for the registry, you must specify the -port option when starting up rmid. For example,
    rmid -J-Djava.security.policy=rmid.policy -port 1099
starts the activation system daemon and a registry on the registry's default port, 1099.

OPTIONS

-C<someCommandLineOption>
Specifies an option that is passed as a command-line argument to each child process (activation group) of rmid when that process is created. For example, you could pass a property to each Java virtual machine spawned by the activation system daemon:
    rmid -C-Dsome.property=value
This ability to pass command-line arguments to child processes can be useful for debugging. For example, the following command:
    rmid -C-Djava.rmi.server.logCalls=true
will enable server-call logging in all child JVMs.

-J<someCommandLineOption>
Specifies an option that is passed to the java interpreter running rmid. For example, to specify that rmid use a policy file named rmid.policy, the -J option can be used to define the java.security.policy property on rmid's command line, for example:
    rmid -J-Djava.security.policy=rmid.policy
-J-Dsun.rmi.activation.execPolicy=<policy>
Specifies the policy that rmid employs to check commands and command-line options used to launch the JVM in which an activation group runs. Please note that this option exists only in Sun's implementation of the RMI activation daemon. If this property is not specified on the command line, the result is the same as if -J-Dsun.rmi.activation.execPolicy=default were specified. The possible values of <policy> can be default, <policyClassName>, or none:

  • default (or if this property is unspecified)

    The default execPolicy allows rmid to execute commands with specific command-line options only if rmid has been granted permission to execute those commands and options in the security policy file that rmid uses. Only the default activation group implementation can be used with the default execution policy.

    rmid launches a JVM for an activation group using the information in the group's registered activation group descriptor, an ActivationGroupDesc. The group descriptor specifies an optional ActivationGroupDesc.CommandEnvironment which includes the command to execute to start the activation group as well as any command line options to be added to the command line. By default, rmid uses the java command found in java.home. The group descriptor also contains properties overrides that are added to the command line as options defined as:

        -D<property>=<value>

    The permission com.sun.rmi.rmid.ExecPermission is used to grant rmid permission to execute a command, specified in the group descriptor's CommandEnvironment to launch an activation group. The permission com.sun.rmi.rmid.ExecOptionPermission is used to allow rmid to use command-line options, specified as properties overrides in the group descriptor or as options in the CommandEnvironment, when launching the activation group.

    When granting rmid permission to execute various commands and options, the permissions ExecPermission and ExecOptionPermission need to be granted universally (i.e., granted to all code sources).

    ExecPermission
    The ExecPermission class represents permission for rmid to execute a specific command to launch an activation group.

    Syntax
    The name of an ExecPermission is the path name of a command to grant rmid permission to execute. A path name that ends in "\*" indicates all the files contained in that directory (where "\" is the file-separator character, File.separatorChar). A path name that ends with "\-" indicates all files and subdirectories contained in that directory (recursively). A path name consisting of the special token "<<ALL FILES>>" matches any file.

    Note: A path name consisting of a single "*" indicates all the files in the current directory, while a path name consisting of a single "-" indicates all the files in the current directory and (recursively) all files and subdirectories contained in the current directory.

    ExecOptionPermission
    The ExecOptionPermission class represents permission for rmid to use a specific command-line option when launching an activation group. The name of an ExecOptionPermission is the value of a command line option.

    Syntax
    Options support a limited wildcard scheme. An asterisk signifies a wildcard match, and it may appear as the option name itself (i.e., it matches any option), or an asterisk may appear at the end of the option name only if the asterisk follows either a "." or "=".

    For example: "*" or "-Dfoo.*" or "-Da.b.c=*" is valid, "*foo" or "-Da*b" or "ab*" is not.

    Policy file for rmid
    When granting rmid permission to execute various commands and options, the permissions ExecPermission and ExecOptionPermission need to be granted universally (i.e., granted to all code sources). It is safe to grant these permissions universally because only rmid checks these permissions.

    An example policy file that grants various execute permissions to rmid is:

    grant {
    permission com.sun.rmi.rmid.ExecPermission
        "c:\\files\\apps\\java\\jdk1.2.2\\win\\bin\\java";

    permission com.sun.rmi.rmid.ExecPermission
        "c:\\files\\apps\\java\\jdk1.2.2\\win\\bin\\java_g";

    permission com.sun.rmi.rmid.ExecPermission
        "c:\\files\\apps\\rmidcmds\\*";

    permission com.sun.rmi.rmid.ExecOptionPermission
        "-Djava.security.policy=c:\\files\\policies\\group.policy";

    permission com.sun.rmi.rmid.ExecOptionPermission
        "-Djava.security.debug=*";

    permission com.sun.rmi.rmid.ExecOptionPermission
        "-Dsun.rmi.*";
};
    The first two permissions granted allow rmid to execute the 1.2.2 version of the java and java_g commands, specified by their explicit path names. Note that by default, the version of the java command found in java.home is used (the same one that rmid uses), and does not need to be specified in the policy file. The third permission allows rmid to execute any command in the directory c:\files\apps\rmidcmds\.

    The fourth permission granted, an ExecOptionPermission, allows rmid to launch an activation group that defines the security policy file to be c:\files\policies\group.policy. The next permission allows the java.security.debug property to be used by an activation group. The last permission allows any property in the sun.rmi property name hierarchy to be used by activation groups.

    To start rmid with a policy file, the java.security.policy property needs to be specified on rmid's command line, for example:

    rmid -J-Djava.security.policy=rmid.policy

  • <policyClassName>

    If the default behavior is not flexible enough, an administrator can provide, when starting rmid, the name of a class whose checkExecCommand method is executed in order to check commands to be executed by rmid.

    The policyClassName specifies a public class with a public, no-argument constructor and an implementation of the following checkExecCommand method:

        public void checkExecCommand(ActivationGroupDesc desc,
                                 String[] command)
        throws SecurityException;
    Before launching an activation group, rmid calls the policy's checkExecCommand method, passing it the activation group descriptor and an array containing the complete command to launch the activation group. If the checkExecCommand throws a SecurityException, rmid will not launch the activation group and an ActivationException will be thrown to the caller attempting to activate the object.

  • none

    If the sun.rmi.activation.execPolicy property value is "none", then rmid will not perform any validation of commands to launch activation groups.

-log dir
Specifies the name of the directory the activation system daemon uses to write its database and associated information. The log directory defaults to creating a directory, log, in the directory in which the rmid command was executed.

-port port
Specifies the port rmid's registry uses. The activation system daemon binds the ActivationSystem, with the name java.rmi.activation.ActivationSystem, in this registry. Thus, the ActivationSystem on the local machine can be obtained using the following Naming.lookup method call:
    import java.rmi.*;
    import java.rmi.activation.*;

    ActivationSystem system; system = (ActivationSystem)
    Naming.lookup("//:port/java.rmi.activation.ActivationSystem");
-stop
Stops the current invocation of rmid, for a port specified by the -port option. If no port is specified, it will stop the rmid running on port 1098.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by colons on UNIX and Macintosh and by semicolons on Win95. For example:
    .;C:\usr\local\java\classes

SEE ALSO

rmic, CLASSPATH, java

Copyright © 2003-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


rmiregistry - The Java Remote Object Registry

The rmiregistry command starts a remote object registry on the specified port on the current host.

SYNOPSIS

rmiregistry [port]

DESCRIPTION

The rmiregistry command creates and starts a remote object registry on the specified port on the current host. If port is omitted, the registry is started on port 1099. The rmiregistry command produces no output and is typically run in the background. For example:

start rmiregistry

A remote object registry is a bootstrap naming service that is used by RMI servers on the same host to bind remote objects to names. Clients on local and remote hosts can then look up remote objects and make remote method invocations.

The registry is typically used to locate the first remote object on which an application needs to invoke methods. That object in turn will provide application-specific support for finding other objects.

The methods of the java.rmi.registry.LocateRegistry class are used to get a registry operating on the local host or local host and port.

The URL-based methods of the java.rmi.Naming class operate on a registry and can be used to look up a remote object on any host, and on the local host: bind a simple (string) name to a remote object, rebind a new name to a remote object (overriding the old binding), unbind a remote object, and list the URLs bound in the registry.

OPTIONS

-J
Used in conjunction with any java option, it passes the option following the -J (no spaces between the -J and the option) on to the java interpreter.

SEE ALSO

java, java.rmi.registry.LocateRegistry and java.rmi.Naming

Copyright © 2003-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


Setting the class path

Synopsis

The class path is the path that the Java runtime environment searches for classes and other resource files. The class search path (more commonly known by the shorter name, "class path") can be set using either the -classpath option when calling a JDK tool (the preferred method) or by setting the CLASSPATH environment variable. The -classpath option is preferred because you can set it individually for each application without affecting other applications and without other applications modifying its value.

C:> sdkTool -classpath classpath1;classpath2...

-or-

C:> set CLASSPATH=classpath1;classpath2...

where:

sdkTool
A command-line tool, such as java, javac, javadoc, or apt. For a listing, see JDK Tools.
classpath1;classpath2
Class paths to the .jar, .zip or .class files. Each classpath should end with a filename or directory depending on what you are setting the class path to:
  • For a .jar or .zip file that contains .class files, the class path ends with the name of the .zip or .jar file.
  • For .class files in an unnamed package, the class path ends with the directory that contains the .class files.
  • For .class files in a named package, the class path ends with the directory that contains the "root" package (the first package in the full package name).

Multiple path entries are separated by semi-colons. With the set command, it's important to omit spaces from around the equals sign (=).

The default class path is the current directory. Setting the CLASSPATH variable or using the -classpath command-line option overrides that default, so if you want to include the current directory in the search path, you must include "." in the new settings.

Classpath entries that are neither directories nor archives (.zip or .jar files) nor * are ignored.

Description

The class path tells JDK tools and applications where to find third-party and user-defined classes -- that is, classes that are not Java extensions or part of the Java platform. The class path needs to find any classes you've compiled with the javac compiler -- its default is the current directory to conveniently enable those classes to be found.

The JDK, the JVM and other JDK tools find classes by searching the Java platform (bootstrap) classes, any extension classes, and the class path, in that order. (For details on the search strategy, see How Classes Are Found.) Class libraries for most applications will want to take advantage of the extensions mechanism. You only need to set the class path when you want to load a class that's (a) not in the current directory or in any of its subdirectories, and (b) not in a location specified by the extensions mechanism.

If you are upgrading from an older version of the JDK, your startup settings may include CLASSPATH settings that are no longer needed. You should remove any settings that are not application-specific, such as classes.zip. Some third-party applications that use the Java Virtual Machine may modify your CLASSPATH environment variable to include the libaries they use. Such settings can remain.

You can change the class path by using the JDK tools' -classpath option when you invoke the JVM or other JDK tools or by using the CLASSPATH environment variable. Using the -classpath option is preferred over setting CLASSPATH environment variable because you can set it individually for each application without affecting other applications and without other applications modifying its value.

Classes can be stored either in directories (folders) or in archive files. The Java platform classes are stored in rt.jar. For more details on archives and information on how the class path works, see Understanding the class path and package names near the end of this document.

Important Note: Some older versions of the JDK sofware included a <jdk-dir>/classes entry in the default class path. That directory exists for use by the JDK software, and should not be used for application classes. Application classes should be placed in a directory outside of the JDK directory hierarcy. That way, installing a new JDK does not force you to reinstall application classes. For compatibility with older versions, applications that use the <jdk-dir>/classes directory as a class library will run in the current version, but there is no guarantee that they will run in future versions.

Using the JDK tools' -classpath option

The JDK tools java, jdb, javac, and javah have a -classpath option which replaces the path or paths specified by the CLASSPATH environment variable while the tool runs. This is the recommended option for changing class path settings, because each application can have the class path it needs without interfering with any other application.

The runtime tool java has a -cp option, as well. This option is an abbreviation for -classpath.

For very special cases, both java and javac have options that let you change the path they use to find their own class libraries. The vast majority of users will never to need to use those options, however.

Using the CLASSPATH environment variable

In general, you will want to use the -classpath command-line option, as explained in the previous section. This section shows you how to set the CLASSPATH environment variable if you want to do that, or clear settings left over from a previous installation.

Setting CLASSPATH

The CLASSPATH environment variable is modified with the set command. The format is:

set CLASSPATH=path1;path2 ...

The paths should begin with the letter specifying the drive, for example, C:\. That way, the classes will still be found if you happen to switch to a different drive. (If the path entries start with backslash (\) and you are on drive D:, for example, then the classes will be expected on D:, rather thanC:.)

Clearing CLASSPATH

If your CLASSPATH environment variable has been set to a value that is not correct, or if your startup file or script is setting an incorrect path, you can unset CLASSPATH by using:

C:> set CLASSPATH=

This command unsets CLASSPATH for the current command prompt window only. You should also delete or modify your startup settings to ensure that you have the right CLASSPATH settings in future sessions.

Changing Startup Settings

If the CLASSPATH variable is set at system startup, the place to look for it depends on your operating system:
Operating System | Method
Windows 95 and 98 | Examine autoexec.bat for the set command.
Other (Windows NT, Windows 2000, ...) | The CLASSPATH environment variable can be set using the System utility in the Control Panel.

Understanding class path wildcards

Class path entries can contain the basename wildcard character *, which is considered equivalent to specifying a list of all the files in the directory with the extension .jar or .JAR. For example, the class path entry foo/* specifies all JAR files in the directory named foo. A classpath entry consisting simply of * expands to a list of all the jar files in the current directory.

A class path entry that contains * will not match class files. To match both classes and JAR files in a single directory foo, use either foo;foo/* or foo/*;foo. The order chosen determines whether the classes and resources in foo are loaded before JAR files in foo, or vice versa.

Subdirectories are not searched recursively. For example, foo/* looks for JAR files only in foo, not in foo/bar, foo/baz, etc.

The order in which the JAR files in a directory are enumerated in the expanded class path is not specified and may vary from platform to platform and even from moment to moment on the same machine. A well-constructed application should not depend upon any particular order. If a specific order is required then the JAR files can be enumerated explicitly in the class path.

Expansion of wildcards is done early, prior to the invocation of a program's main method, rather than late, during the class-loading process itself. Each element of the input class path containing a wildcard is replaced by the (possibly empty) sequence of elements generated by enumerating the JAR files in the named directory. For example, if the directory foo contains a.jar, b.jar, and c.jar, then the class path foo/* is expanded into foo/a.jar;foo/b.jar;foo/c.jar, and that string would be the value of the system property java.class.path.

The CLASSPATH environment variable is not treated any differently from the -classpath (or -cp) command-line option. That is, wildcards are honored in all these cases. However, class path wildcards are not honored in the Class-Path jar-manifest header.

Understanding the class path and package names

Java classes are organized into packages which are mapped to directories in the file system. But, unlike the file system, whenever you specify a package name, you specify the whole package name -- never part of it. For example, the package name for java.awt.Button is always specified as java.awt.

For example, suppose you want the Java runtime to find a class named Cool.class in the package utility.myapp. If the path to that directory is C:\java\MyClasses\utility\myapp, you would set the class path so that it contains C:\java\MyClasses.

To run that app, you could use the following JVM command:

C:> java -classpath C:\java\MyClasses utility.myapp.Cool

When the app runs, the JVM uses the class path settings to find any other classes defined in the utility.myapp package that are used by the Cool class.

Note that the entire package name is specified in the command. It is not possible, for example, to set the class path so it contains C:\java\MyClasses\utility and use the command java myapp.Cool. The class would not be found.

(You may be wondering what defines the package name for a class. The answer is that the package name is part of the class and cannot be modified, except by recompiling the class.)

Note: An interesting consequence of the package specification mechanism is that files which are part of the same package may actually exist in different directories. The package name will be the same for each class, but the path to each file may start from a different directory in the class path.

Folders and archive files

When classes are stored in a directory (folder), like c:\java\MyClasses\utility\myapp, then the class path entry points to the directory that contains the first element of the package name. (in this case, C:\java\MyClasses, since the package name is utility.myapp.)

But when classes are stored in an archive file (a .zip or .jar file) the class path entry is the path to and including the .zip or .jar file. For example, to use a class library that is in a .jar file, the command would look something like this:

C:> java -classpath C:\java\MyClasses\myclasses.jar utility.myapp.Cool

Multiple specifications

To find class files in the directory C:\java\MyClasses as well as classes in C:\java\OtherClasses, you would set the class path to:

C:> java -classpath C:\java\MyClasses;C:\java\OtherClasses ...

Note that the two paths are separated by a semicolon.

Specification order

The order in which you specify multiple class path entries is important. The Java interpreter will look for classes in the directories in the order they appear in the class path variable. In the example above, the Java interpreter will first look for a needed class in the directory C:\java\MyClasses. Only if it doesn't find a class with the proper name in that directory will the interpreter look in the C:\java\OtherClasses directory.

Copyright © 2004-2006 Sun Microsystems, Inc. All Rights Reserved.

 Sun
Java Software


Not found

Sorry, this page is not available.

Click Here to go Back


Overview List

API Specification">
Java™ Platform
Standard Ed. 6
All Classes

Packages
java.applet
java.awt
java.awt.color
java.awt.datatransfer
java.awt.dnd
java.awt.event
java.awt.font
java.awt.geom
java.awt.im
java.awt.im.spi
java.awt.image
java.awt.image.renderable
java.awt.print
java.beans
java.beans.beancontext
java.io
java.lang
java.lang.annotation
java.lang.instrument
java.lang.management
java.lang.ref
java.lang.reflect
java.math
java.net
java.nio
java.nio.channels
java.nio.channels.spi
java.nio.charset
java.nio.charset.spi
java.rmi
java.rmi.activation
java.rmi.dgc
java.rmi.registry
java.rmi.server
java.security
java.security.acl
java.security.cert
java.security.interfaces
java.security.spec
java.sql
java.text
java.text.spi
java.util
java.util.concurrent
java.util.concurrent.atomic
java.util.concurrent.locks
java.util.jar
java.util.logging
java.util.prefs
java.util.regex
java.util.spi
java.util.zip
javax.accessibility
javax.activation
javax.activity
javax.annotation
javax.annotation.processing
javax.crypto
javax.crypto.interfaces
javax.crypto.spec
javax.imageio
javax.imageio.event
javax.imageio.metadata
javax.imageio.plugins.bmp
javax.imageio.plugins.jpeg
javax.imageio.spi
javax.imageio.stream
javax.jws
javax.jws.soap
javax.lang.model
javax.lang.model.element
javax.lang.model.type
javax.lang.model.util
javax.management
javax.management.loading
javax.management.modelmbean
javax.management.monitor
javax.management.openmbean
javax.management.relation
javax.management.remote
javax.management.remote.rmi
javax.management.timer
javax.naming
javax.naming.directory
javax.naming.event
javax.naming.ldap
javax.naming.spi
javax.net
javax.net.ssl
javax.print
javax.print.attribute
javax.print.attribute.standard
javax.print.event
javax.rmi
javax.rmi.CORBA
javax.rmi.ssl
javax.script
javax.security.auth
javax.security.auth.callback
javax.security.auth.kerberos
javax.security.auth.login
javax.security.auth.spi
javax.security.auth.x500
javax.security.cert
javax.security.sasl
javax.sound.midi
javax.sound.midi.spi
javax.sound.sampled
javax.sound.sampled.spi
javax.sql
javax.sql.rowset
javax.sql.rowset.serial
javax.sql.rowset.spi
javax.swing
javax.swing.border
javax.swing.colorchooser
javax.swing.event
javax.swing.filechooser
javax.swing.plaf
javax.swing.plaf.basic
javax.swing.plaf.metal
javax.swing.plaf.multi
javax.swing.plaf.synth
javax.swing.table
javax.swing.text
javax.swing.text.html
javax.swing.text.html.parser
javax.swing.text.rtf
javax.swing.tree
javax.swing.undo
javax.tools
javax.transaction
javax.transaction.xa
javax.xml
javax.xml.bind
javax.xml.bind.annotation
javax.xml.bind.annotation.adapters
javax.xml.bind.attachment
javax.xml.bind.helpers
javax.xml.bind.util
javax.xml.crypto
javax.xml.crypto.dom
javax.xml.crypto.dsig
javax.xml.crypto.dsig.dom
javax.xml.crypto.dsig.keyinfo
javax.xml.crypto.dsig.spec
javax.xml.datatype
javax.xml.namespace
javax.xml.parsers
javax.xml.soap
javax.xml.stream
javax.xml.stream.events
javax.xml.stream.util
javax.xml.transform
javax.xml.transform.dom
javax.xml.transform.sax
javax.xml.transform.stax
javax.xml.transform.stream
javax.xml.validation
javax.xml.ws
javax.xml.ws.handler
javax.xml.ws.handler.soap
javax.xml.ws.http
javax.xml.ws.soap
javax.xml.ws.spi
javax.xml.xpath
org.ietf.jgss
org.omg.CORBA
org.omg.CORBA_2_3
org.omg.CORBA_2_3.portable
org.omg.CORBA.DynAnyPackage
org.omg.CORBA.ORBPackage
org.omg.CORBA.portable
org.omg.CORBA.TypeCodePackage
org.omg.CosNaming
org.omg.CosNaming.NamingContextExtPackage
org.omg.CosNaming.NamingContextPackage
org.omg.Dynamic
org.omg.DynamicAny
org.omg.DynamicAny.DynAnyFactoryPackage
org.omg.DynamicAny.DynAnyPackage
org.omg.IOP
org.omg.IOP.CodecFactoryPackage
org.omg.IOP.CodecPackage
org.omg.Messaging
org.omg.PortableInterceptor
org.omg.PortableInterceptor.ORBInitInfoPackage
org.omg.PortableServer
org.omg.PortableServer.CurrentPackage
org.omg.PortableServer.POAManagerPackage
org.omg.PortableServer.POAPackage
org.omg.PortableServer.portable
org.omg.PortableServer.ServantLocatorPackage
org.omg.SendingContext
org.omg.stub.java.rmi
org.w3c.dom
org.w3c.dom.bootstrap
org.w3c.dom.events
org.w3c.dom.ls
org.xml.sax
org.xml.sax.ext
org.xml.sax.helpers


_-Index

Overview Package Class Use Tree Deprecated Index Help
Java™ Platform
Standard Ed. 6
PREV LETTER NEXT LETTER FRAMES NO FRAMES
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z _

_

_ACTIVE - Static variable in class org.omg.PortableServer.POAManagerPackage.State
_ADD_OVERRIDE - Static variable in class org.omg.CORBA.SetOverrideType
The int constant for the enum value ADD_OVERRIDE.
_all_interfaces(POA, byte[]) - Method in class org.omg.CosNaming.BindingIteratorPOA
_all_interfaces(POA, byte[]) - Method in class org.omg.CosNaming.NamingContextExtPOA
_all_interfaces(POA, byte[]) - Method in class org.omg.CosNaming.NamingContextPOA
_all_interfaces(POA, byte[]) - Method in class org.omg.PortableServer.Servant
Used by the ORB to obtain complete type information from the servant.
_all_interfaces(POA, byte[]) - Method in class org.omg.PortableServer.ServantActivatorPOA
_all_interfaces(POA, byte[]) - Method in class org.omg.PortableServer.ServantLocatorPOA
_BindingIteratorImplBase - Class in org.omg.CosNaming
_BindingIteratorImplBase() - Constructor for class org.omg.CosNaming._BindingIteratorImplBase
_BindingIteratorStub - Class in org.omg.CosNaming
The BindingIterator interface allows a client to iterate through the bindings using the next_one or next_n operations.
_BindingIteratorStub() - Constructor for class org.omg.CosNaming._BindingIteratorStub
_COMPLETED_MAYBE - Static variable in class org.omg.CORBA.CompletionStatus
The constant indicating that a method completed running before a SystemException was thrown.
_COMPLETED_NO - Static variable in class org.omg.CORBA.CompletionStatus
The constant indicating that a method completed running before a SystemException was thrown.
_COMPLETED_YES - Static variable in class org.omg.CORBA.CompletionStatus
The constant indicating that a method completed running before a SystemException was thrown.
_create_request(Context, String, NVList, NamedValue) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_create_request(Context, String, NVList, NamedValue, ExceptionList, ContextList) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_create_request(Context, String, NVList, NamedValue) - Method in interface org.omg.CORBA.Object
Creates a Request instance initialized with the given context, method name, list of arguments, and container for the method's return value.
_create_request(Context, String, NVList, NamedValue, ExceptionList, ContextList) - Method in interface org.omg.CORBA.Object
Creates a Request instance initialized with the given context, method name, list of arguments, container for the method's return value, list of possible exceptions, and list of context strings needing to be resolved.
_create_request(Context, String, NVList, NamedValue) - Method in class org.omg.CORBA.portable.ObjectImpl
Creates a Request object that contains the given context, method, argument list, and container for the result.
_create_request(Context, String, NVList, NamedValue, ExceptionList, ContextList) - Method in class org.omg.CORBA.portable.ObjectImpl
Creates a Request object that contains the given context, method, argument list, container for the result, exceptions, and list of property names to be used in resolving the context strings.
_default_POA() - Method in class org.omg.PortableServer.Servant
Returns the root POA from the ORB instance associated with the servant.
_DISCARDING - Static variable in class org.omg.PortableServer.POAManagerPackage.State
_dk_AbstractInterface - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Alias - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_all - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Array - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Attribute - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Constant - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Enum - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Exception - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Fixed - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Interface - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Module - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Native - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_none - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Operation - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Primitive - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Repository - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Sequence - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_String - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Struct - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Typedef - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Union - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Value - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_ValueBox - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_ValueMember - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_dk_Wstring - Static variable in class org.omg.CORBA.DefinitionKind
The constant that indicates that an Interface Repository object does not have a definition kind.
_duplicate() - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_duplicate() - Method in interface org.omg.CORBA.Object
Returns a duplicate of this CORBA object reference.
_duplicate() - Method in class org.omg.CORBA.portable.ObjectImpl
Returns a duplicate of this ObjectImpl object.
_DynAnyFactoryStub - Class in org.omg.DynamicAny
DynAny objects can be created by invoking operations on the DynAnyFactory object.
_DynAnyFactoryStub() - Constructor for class org.omg.DynamicAny._DynAnyFactoryStub
_DynAnyStub - Class in org.omg.DynamicAny
Any values can be dynamically interpreted (traversed) and constructed through DynAny objects.
_DynAnyStub() - Constructor for class org.omg.DynamicAny._DynAnyStub
_DynArrayStub - Class in org.omg.DynamicAny
DynArray objects support the manipulation of IDL arrays.
_DynArrayStub() - Constructor for class org.omg.DynamicAny._DynArrayStub
_DynEnumStub - Class in org.omg.DynamicAny
DynEnum objects support the manipulation of IDL enumerated values.
_DynEnumStub() - Constructor for class org.omg.DynamicAny._DynEnumStub
_DynFixedStub - Class in org.omg.DynamicAny
DynFixed objects support the manipulation of IDL fixed values.
_DynFixedStub() - Constructor for class org.omg.DynamicAny._DynFixedStub
_DynSequenceStub - Class in org.omg.DynamicAny
DynSequence objects support the manipulation of IDL sequences.
_DynSequenceStub() - Constructor for class org.omg.DynamicAny._DynSequenceStub
_DynStructStub - Class in org.omg.DynamicAny
DynStruct objects support the manipulation of IDL struct and exception values.
_DynStructStub() - Constructor for class org.omg.DynamicAny._DynStructStub
_DynUnionStub - Class in org.omg.DynamicAny
DynUnion objects support the manipulation of IDL unions.
_DynUnionStub() - Constructor for class org.omg.DynamicAny._DynUnionStub
_DynValueStub - Class in org.omg.DynamicAny
DynValue objects support the manipulation of IDL non-boxed value types.
_DynValueStub() - Constructor for class org.omg.DynamicAny._DynValueStub
_get_codebase() - Method in class org.omg.CORBA_2_3.portable.ObjectImpl
Returns the codebase for this object reference.
_get_delegate() - Method in class org.omg.CORBA.portable.ObjectImpl
Retrieves the reference to the vendor-specific Delegate object to which this ObjectImpl object delegates all methods invoked on it.
_get_delegate() - Method in class org.omg.PortableServer.Servant
Gets the ORB vendor-specific implementation of PortableServer::Servant.
_get_domain_managers() - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method does not apply to local objects and is therefore not implemented.
_get_domain_managers() - Method in interface org.omg.CORBA.Object
Retrieves the DomainManagers of this object.
_get_domain_managers() - Method in class org.omg.CORBA.portable.ObjectImpl
Retrieves a list of the domain managers for this ObjectImpl object.
_get_interface() - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method does not apply to local objects and is therefore not implemented.
_get_interface_def() - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_get_interface_def() - Method in interface org.omg.CORBA.Object
Obtains an InterfaceDef for the object implementation referenced by this object reference.
_get_interface_def() - Method in class org.omg.CORBA.portable.ObjectImpl
Retrieves the interface definition for this ObjectImpl object.
_get_interface_def() - Method in class org.omg.PortableServer.Servant
Returns an InterfaceDef object as a CORBA::Object that defines the runtime type of the CORBA::Object implemented by the Servant.
_get_policy(int) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method does not apply to local objects and is therefore not implemented.
_get_policy(int) - Method in interface org.omg.CORBA.Object
Returns the Policy object of the specified type which applies to this object.
_get_policy(int) - Method in class org.omg.CORBA.portable.ObjectImpl
Retrieves the Policy object for this ObjectImpl object that has the given policy type.
_hash(int) - Method in class org.omg.CORBA.LocalObject
Returns a hash value that is consistent for the lifetime of the object, using the given number as the maximum.
_hash(int) - Method in interface org.omg.CORBA.Object
Returns an ORB-internal identifier for this object reference.
_hash(int) - Method in class org.omg.CORBA.portable.ObjectImpl
Retrieves the hash code that serves as an ORB-internal identifier for this ObjectImpl object.
_HOLDING - Static variable in class org.omg.PortableServer.POAManagerPackage.State
_IDLTypeStub - Class in org.omg.CORBA
The Stub for IDLType.
_IDLTypeStub() - Constructor for class org.omg.CORBA._IDLTypeStub
Constructs a default _IDLTypeStub object.
_IDLTypeStub(Delegate) - Constructor for class org.omg.CORBA._IDLTypeStub
Constructs an _IDLTypeStub object initialized with the given Delegate object.
_ids() - Method in class org.omg.CORBA._IDLTypeStub
_ids() - Method in class org.omg.CORBA._PolicyStub
_ids() - Method in class org.omg.CORBA.DynamicImplementation
Deprecated.
_ids() - Method in class org.omg.CORBA.portable.ObjectImpl
Retrieves a string array containing the repository identifiers supported by this ObjectImpl object.
_ids() - Method in class org.omg.CosNaming._BindingIteratorImplBase
_ids() - Method in class org.omg.CosNaming._BindingIteratorStub
_ids() - Method in class org.omg.CosNaming._NamingContextExtStub
_ids() - Method in class org.omg.CosNaming._NamingContextImplBase
_ids() - Method in class org.omg.CosNaming._NamingContextStub
_ids() - Method in class org.omg.DynamicAny._DynAnyFactoryStub
_ids() - Method in class org.omg.DynamicAny._DynAnyStub
_ids() - Method in class org.omg.DynamicAny._DynArrayStub
_ids() - Method in class org.omg.DynamicAny._DynEnumStub
_ids() - Method in class org.omg.DynamicAny._DynFixedStub
_ids() - Method in class org.omg.DynamicAny._DynSequenceStub
_ids() - Method in class org.omg.DynamicAny._DynStructStub
_ids() - Method in class org.omg.DynamicAny._DynUnionStub
_ids() - Method in class org.omg.DynamicAny._DynValueStub
_ids() - Method in class org.omg.PortableServer._ServantActivatorStub
_ids() - Method in class org.omg.PortableServer._ServantLocatorStub
_ids() - Method in class org.omg.stub.java.rmi._Remote_Stub
Returns an array of repository ids that an object implements.
_IMPLICIT_ACTIVATION - Static variable in class org.omg.PortableServer.ImplicitActivationPolicyValue
_INACTIVE - Static variable in class org.omg.PortableServer.POAManagerPackage.State
_invoke(OutputStream) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_invoke(String, InputStream, ResponseHandler) - Method in interface org.omg.CORBA.portable.InvokeHandler
Invoked by the ORB to dispatch a request to the servant.
_invoke(OutputStream) - Method in class org.omg.CORBA.portable.ObjectImpl
Invokes an operation and returns an InputStream object for reading the response.
_invoke(String, InputStream, ResponseHandler) - Method in class org.omg.CosNaming.BindingIteratorPOA
_invoke(String, InputStream, ResponseHandler) - Method in class org.omg.CosNaming.NamingContextExtPOA
_invoke(String, InputStream, ResponseHandler) - Method in class org.omg.CosNaming.NamingContextPOA
_invoke(String, InputStream, ResponseHandler) - Method in class org.omg.PortableServer.ServantActivatorPOA
_invoke(String, InputStream, ResponseHandler) - Method in class org.omg.PortableServer.ServantLocatorPOA
_is_a(String) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method does not apply to local objects and is therefore not implemented.
_is_a(String) - Method in interface org.omg.CORBA.Object
Checks whether this object is an instance of a class that implements the given interface.
_is_a(String) - Method in class org.omg.CORBA.portable.ObjectImpl
Checks whether the object identified by the given repository identifier is an ObjectImpl object.
_is_a(String) - Method in class org.omg.PortableServer.Servant
Checks to see if the specified repository_id is present on the list returned by _all_interfaces() or is the repository_id for the generic CORBA Object.
_is_equivalent(Object) - Method in class org.omg.CORBA.LocalObject
Determines whether the two object references are equivalent, so far as the ORB can easily determine.
_is_equivalent(Object) - Method in interface org.omg.CORBA.Object
Determines whether the two object references are equivalent, so far as the ORB can easily determine.
_is_equivalent(Object) - Method in class org.omg.CORBA.portable.ObjectImpl
Checks whether the the given ObjectImpl object is equivalent to this ObjectImpl object.
_is_local() - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_is_local() - Method in class org.omg.CORBA.portable.ObjectImpl
Checks whether this ObjectImpl object is implemented by a local servant.
_missing_node - Static variable in class org.omg.CosNaming.NamingContextPackage.NotFoundReason
_MULTIPLE_ID - Static variable in class org.omg.PortableServer.IdUniquenessPolicyValue
_NamingContextExtStub - Class in org.omg.CosNaming
NamingContextExt is the extension of NamingContext which contains a set of name bindings in which each name is unique and is part of Interoperable Naming Service.
_NamingContextExtStub() - Constructor for class org.omg.CosNaming._NamingContextExtStub
_NamingContextImplBase - Class in org.omg.CosNaming
_NamingContextImplBase() - Constructor for class org.omg.CosNaming._NamingContextImplBase
_NamingContextStub - Class in org.omg.CosNaming
A naming context is an object that contains a set of name bindings in which each name is unique.
_NamingContextStub() - Constructor for class org.omg.CosNaming._NamingContextStub
_ncontext - Static variable in class org.omg.CosNaming.BindingType
_NO_IMPLICIT_ACTIVATION - Static variable in class org.omg.PortableServer.ImplicitActivationPolicyValue
_nobject - Static variable in class org.omg.CosNaming.BindingType
_non_existent() - Method in class org.omg.CORBA.LocalObject
Always returns false.
_non_existent() - Method in interface org.omg.CORBA.Object
Determines whether the server object for this object reference has been destroyed.
_non_existent() - Method in class org.omg.CORBA.portable.ObjectImpl
Checks whether the server object for this ObjectImpl object has been destroyed.
_non_existent() - Method in class org.omg.PortableServer.Servant
Checks for the existence of an Object.
_NON_RETAIN - Static variable in class org.omg.PortableServer.ServantRetentionPolicyValue
_not_context - Static variable in class org.omg.CosNaming.NamingContextPackage.NotFoundReason
_not_object - Static variable in class org.omg.CosNaming.NamingContextPackage.NotFoundReason
_object_id() - Method in class org.omg.PortableServer.Servant
Allows easy execution of common methods, equivalent to calling PortableServer::Current::get_object_id.
_opsClass - Static variable in class org.omg.DynamicAny._DynAnyFactoryStub
_opsClass - Static variable in class org.omg.DynamicAny._DynAnyStub
_opsClass - Static variable in class org.omg.DynamicAny._DynArrayStub
_opsClass - Static variable in class org.omg.DynamicAny._DynEnumStub
_opsClass - Static variable in class org.omg.DynamicAny._DynFixedStub
_opsClass - Static variable in class org.omg.DynamicAny._DynSequenceStub
_opsClass - Static variable in class org.omg.DynamicAny._DynStructStub
_opsClass - Static variable in class org.omg.DynamicAny._DynUnionStub
_opsClass - Static variable in class org.omg.DynamicAny._DynValueStub
_opsClass - Static variable in class org.omg.PortableServer._ServantActivatorStub
_opsClass - Static variable in class org.omg.PortableServer._ServantLocatorStub
_orb() - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_orb() - Method in class org.omg.CORBA.portable.ObjectImpl
Returns a reference to the ORB associated with this object and its delegate.
_orb() - Method in class org.omg.PortableServer.Servant
Returns the instance of the ORB currently associated with the Servant (convenience method).
_ORB_CTRL_MODEL - Static variable in class org.omg.PortableServer.ThreadPolicyValue
_PARAM_IN - Static variable in class org.omg.CORBA.ParameterMode
_PARAM_INOUT - Static variable in class org.omg.CORBA.ParameterMode
_PARAM_OUT - Static variable in class org.omg.CORBA.ParameterMode
_PERSISTENT - Static variable in class org.omg.PortableServer.LifespanPolicyValue
_poa() - Method in class org.omg.PortableServer.Servant
Allows easy execution of common methods, equivalent to PortableServer::Current:get_POA.
_PolicyStub - Class in org.omg.CORBA
The Stub for Policy.
_PolicyStub() - Constructor for class org.omg.CORBA._PolicyStub
Constructors NOTE: If the default constructor is used, the object is useless until _set_delegate (...) is called.
_PolicyStub(Delegate) - Constructor for class org.omg.CORBA._PolicyStub
Constructs a _PolicyStub object initialized with the given Delegate object.
_postEdit(UndoableEdit) - Method in class javax.swing.undo.UndoableEditSupport
Called only from postEdit and endUpdate.
_read(InputStream) - Method in class org.omg.CORBA.AnyHolder
Reads from input and initalizes the value in the Holder with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.AnySeqHolder
_read(InputStream) - Method in class org.omg.CORBA.BooleanHolder
Reads unmarshalled data from input and assigns it to this BooleanHolder object's value field.
_read(InputStream) - Method in class org.omg.CORBA.BooleanSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.ByteHolder
Reads from input and initalizes the value in this ByteHolder object with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.CharHolder
Reads from input and initalizes the value in this CharHolder object with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.CharSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.CurrentHolder
_read(InputStream) - Method in class org.omg.CORBA.DoubleHolder
Read a double value from the input stream and store it in the value member.
_read(InputStream) - Method in class org.omg.CORBA.DoubleSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.FixedHolder
Read a fixed point value from the input stream and store it in the value member.
_read(InputStream) - Method in class org.omg.CORBA.FloatHolder
Read a float from an input stream and initialize the value member with the float value.
_read(InputStream) - Method in class org.omg.CORBA.FloatSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.IntHolder
Reads unmarshalled data from input and assigns it to the value field in this IntHolder object.
_read(InputStream) - Method in class org.omg.CORBA.LongHolder
Reads from input and initalizes the value in the Holder with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.LongLongSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.LongSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.ObjectHolder
Reads from input and initalizes the value in this ObjectHolder object with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.OctetSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.ParameterModeHolder
_read(InputStream) - Method in class org.omg.CORBA.PolicyErrorHolder
_read(InputStream) - Method in class org.omg.CORBA.PolicyHolder
_read(InputStream) - Method in class org.omg.CORBA.PolicyListHolder
_read(InputStream) - Method in interface org.omg.CORBA.portable.Streamable
Reads data from istream and initalizes the value field of the Holder with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.PrincipalHolder
Deprecated.
_read(InputStream) - Method in class org.omg.CORBA.ServiceInformationHolder
Reads unmarshalled data from the input stream in and assigns it to the value field in this ServiceInformationHolder object.
_read(InputStream) - Method in class org.omg.CORBA.ShortHolder
Reads from input and initalizes the value in this ShortHolder object with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.ShortSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.StringHolder
Reads the unmarshalled data from input and assigns it to the value field of this StringHolder object.
_read(InputStream) - Method in class org.omg.CORBA.StringSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.TypeCodeHolder
Reads from input and initalizes the value in this TypeCodeHolder object with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.ULongLongSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.ULongSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.UnknownUserExceptionHolder
_read(InputStream) - Method in class org.omg.CORBA.UShortSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.ValueBaseHolder
Reads from input and initalizes the value in the Holder with the unmarshalled data.
_read(InputStream) - Method in class org.omg.CORBA.WCharSeqHolder
_read(InputStream) - Method in class org.omg.CORBA.WrongTransactionHolder
_read(InputStream) - Method in class org.omg.CORBA.WStringSeqHolder
_read(InputStream) - Method in class org.omg.CosNaming.BindingHolder
_read(InputStream) - Method in class org.omg.CosNaming.BindingIteratorHolder
_read(InputStream) - Method in class org.omg.CosNaming.BindingListHolder
_read(InputStream) - Method in class org.omg.CosNaming.BindingTypeHolder
_read(InputStream) - Method in class org.omg.CosNaming.NameComponentHolder
_read(InputStream) - Method in class org.omg.CosNaming.NameHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextExtHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextPackage.AlreadyBoundHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextPackage.CannotProceedHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextPackage.InvalidNameHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextPackage.NotEmptyHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextPackage.NotFoundHolder
_read(InputStream) - Method in class org.omg.CosNaming.NamingContextPackage.NotFoundReasonHolder
_read(InputStream) - Method in class org.omg.IOP.IORHolder
_read(InputStream) - Method in class org.omg.IOP.MultipleComponentProfileHolder
_read(InputStream) - Method in class org.omg.IOP.ServiceContextHolder
_read(InputStream) - Method in class org.omg.IOP.ServiceContextListHolder
_read(InputStream) - Method in class org.omg.IOP.TaggedComponentHolder
_read(InputStream) - Method in class org.omg.IOP.TaggedProfileHolder
_read(InputStream) - Method in class org.omg.PortableInterceptor.IORInterceptor_3_0Holder
_read(InputStream) - Method in class org.omg.PortableInterceptor.ObjectReferenceFactoryHolder
_read(InputStream) - Method in class org.omg.PortableInterceptor.ObjectReferenceTemplateHolder
_read(InputStream) - Method in class org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHolder
_read(InputStream) - Method in class org.omg.PortableServer.ServantLocatorPackage.CookieHolder
_release() - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_release() - Method in interface org.omg.CORBA.Object
Signals that the caller is done using this object reference, so internal ORB resources associated with this object reference can be released.
_release() - Method in class org.omg.CORBA.portable.ObjectImpl
Releases the resources associated with this ObjectImpl object.
_releaseReply(InputStream) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_releaseReply(InputStream) - Method in class org.omg.CORBA.portable.ObjectImpl
Releases the given reply stream back to the ORB when unmarshalling has completed after a call to the method _invoke.
_Remote_Stub - Class in org.omg.stub.java.rmi
This class provides the Stub for the Remote Type.
_Remote_Stub() - Constructor for class org.omg.stub.java.rmi._Remote_Stub
_request(String) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_request(String, boolean) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_request(String) - Method in interface org.omg.CORBA.Object
Creates a Request instance for use in the Dynamic Invocation Interface.
_request(String) - Method in class org.omg.CORBA.portable.ObjectImpl
Creates a Request object containing the given method that can be used with the Dynamic Invocation Interface.
_request(String, boolean) - Method in class org.omg.CORBA.portable.ObjectImpl
Returns an OutputStream object to use for marshalling the arguments of the given method.
_RETAIN - Static variable in class org.omg.PortableServer.ServantRetentionPolicyValue
_servant_postinvoke(ServantObject) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_servant_postinvoke(ServantObject) - Method in class org.omg.CORBA.portable.ObjectImpl
Is called by the local stub after it has invoked an operation on the local servant that was previously retrieved from a call to the method _servant_preinvoke.
_servant_preinvoke(String, Class) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method is the default implementation of the org.omg.CORBA.Object method.
_servant_preinvoke(String, Class) - Method in class org.omg.CORBA.portable.ObjectImpl
Returns a Java reference to the local servant that should be used for sending a request for the method specified.
_ServantActivatorStub - Class in org.omg.PortableServer
When the POA has the RETAIN policy it uses servant managers that are ServantActivators.
_ServantActivatorStub() - Constructor for class org.omg.PortableServer._ServantActivatorStub
_ServantLocatorStub - Class in org.omg.PortableServer
When the POA has the NON_RETAIN policy it uses servant managers that are ServantLocators.
_ServantLocatorStub() - Constructor for class org.omg.PortableServer._ServantLocatorStub
_set_delegate(Delegate) - Method in class org.omg.CORBA.portable.ObjectImpl
Sets the Delegate for this ObjectImpl instance to the given Delegate object.
_set_delegate(Delegate) - Method in class org.omg.PortableServer.Servant
Supports the Java ORB portability interfaces by providing a method for classes that support ORB portability through delegation to set their delegate.
_SET_OVERRIDE - Static variable in class org.omg.CORBA.SetOverrideType
The int constant for the enum value SET_OVERRIDE.
_set_policy_override(Policy[], SetOverrideType) - Method in class org.omg.CORBA.LocalObject
Throws an org.omg.CORBA.NO_IMPLEMENT exception with the message "This is a locally constrained object." This method does not apply to local objects and is therefore not implemented.
_set_policy_override(Policy[], SetOverrideType) - Method in interface org.omg.CORBA.Object
Returns a new Object with the given policies either replacing any existing policies in this Object or with the given policies added to the existing ones, depending on the value of the given SetOverrideType object.
_set_policy_override(Policy[], SetOverrideType) - Method in class org.omg.CORBA.portable.ObjectImpl
Sets this ObjectImpl object's override type for the given policies to the given instance of SetOverrideType.
_SINGLE_THREAD_MODEL - Static variable in class org.omg.PortableServer.ThreadPolicyValue
_SYSTEM_ID - Static variable in class org.omg.PortableServer.IdAssignmentPolicyValue
_this() - Method in class org.omg.CosNaming.BindingIteratorPOA
_this(ORB) - Method in class org.omg.CosNaming.BindingIteratorPOA
_this() - Method in class org.omg.CosNaming.NamingContextExtPOA
_this(ORB) - Method in class org.omg.CosNaming.NamingContextExtPOA
_this() - Method in class org.omg.CosNaming.NamingContextPOA
_this(ORB) - Method in class org.omg.CosNaming.NamingContextPOA
_this() - Method in class org.omg.PortableServer.ServantActivatorPOA
_this(ORB) - Method in class org.omg.PortableServer.ServantActivatorPOA
_this() - Method in class org.omg.PortableServer.ServantLocatorPOA
_this(ORB) - Method in class org.omg.PortableServer.ServantLocatorPOA
_this_object() - Method in class org.omg.PortableServer.Servant
Allows the servant to obtain the object reference for the target CORBA object it is incarnating for that request.
_this_object(ORB) - Method in class org.omg.PortableServer.Servant
Allows the servant to obtain the object reference for the target CORBA Object it is incarnating for that request.
_tk_abstract_interface - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type abstract interface.
_tk_alias - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type alias.
_tk_any - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type any.
_tk_array - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type array.
_tk_boolean - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type boolean.
_tk_char - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type char.
_tk_double - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type double.
_tk_enum - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type enum.
_tk_except - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type except.
_tk_fixed - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type fixed.
_tk_float - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type float.
_tk_long - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type long.
_tk_longdouble - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type longdouble.
_tk_longlong - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type longlong.
_tk_native - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type native.
_tk_null - Static variable in class org.omg.CORBA.TCKind
The int constant for a null IDL data type.
_tk_objref - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type objref.
_tk_octet - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type octet.
_tk_Principal - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type Principal.
_tk_sequence - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type sequence.
_tk_short - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type short.
_tk_string - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type string.
_tk_struct - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type struct.
_tk_TypeCode - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type TypeCode.
_tk_ulong - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type ulong.
_tk_ulonglong - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type ulonglong.
_tk_union - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type union.
_tk_ushort - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type ushort.
_tk_value - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type value.
_tk_value_box - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type value_box.
_tk_void - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type void.
_tk_wchar - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type wchar.
_tk_wstring - Static variable in class org.omg.CORBA.TCKind
The int constant for the IDL data type wstring.
_TRANSIENT - Static variable in class org.omg.PortableServer.LifespanPolicyValue
_truncatable_ids() - Method in interface org.omg.CORBA.portable.ValueBase
Provides truncatable repository ids.
_type() - Method in class org.omg.CORBA.AnyHolder
Returns the TypeCode object corresponding to the value held in this AnyHolder object.
_type() - Method in class org.omg.CORBA.AnySeqHolder
_type() - Method in class org.omg.CORBA.BooleanHolder
Retrieves the TypeCode object that corresponds to the value held in this BooleanHolder object.
_type() - Method in class org.omg.CORBA.BooleanSeqHolder
_type() - Method in class org.omg.CORBA.ByteHolder
Returns the TypeCode corresponding to the value held in this ByteHolder object.
_type() - Method in class org.omg.CORBA.CharHolder
Returns the TypeCode object corresponding to the value held in this CharHolder object.
_type() - Method in class org.omg.CORBA.CharSeqHolder
_type() - Method in class org.omg.CORBA.CurrentHolder
_type() - Method in class org.omg.CORBA.DoubleHolder
Return the TypeCode of this holder object.
_type() - Method in class org.omg.CORBA.DoubleSeqHolder
_type() - Method in class org.omg.CORBA.FixedHolder
Return the TypeCode of this holder object.
_type() - Method in class org.omg.CORBA.FloatHolder
Return the TypeCode of this Streamable.
_type() - Method in class org.omg.CORBA.FloatSeqHolder
_type() - Method in class org.omg.CORBA.IntHolder
Retrieves the TypeCode object that corresponds to the value held in this IntHolder object's value field.
_type() - Method in class org.omg.CORBA.LongHolder
Returns the TypeCode object corresponding to the value held in the Holder.
_type() - Method in class org.omg.CORBA.LongLongSeqHolder
_type() - Method in class org.omg.CORBA.LongSeqHolder
_type() - Method in class org.omg.CORBA.ObjectHolder
Returns the TypeCode corresponding to the value held in this ObjectHolder object
_type() - Method in class org.omg.CORBA.OctetSeqHolder
_type() - Method in class org.omg.CORBA.ParameterModeHolder
_type() - Method in class org.omg.CORBA.PolicyErrorHolder
_type() - Method in class org.omg.CORBA.PolicyHolder
_type() - Method in class org.omg.CORBA.PolicyListHolder
_type() - Method in interface org.omg.CORBA.portable.Streamable
Retrieves the TypeCode object corresponding to the value in the value field of the Holder.
_type() - Method in class org.omg.CORBA.PrincipalHolder
Deprecated.
_type() - Method in class org.omg.CORBA.ServiceInformationHolder
Retrieves the TypeCode object that corresponds to the value held in this ServiceInformationHolder object's value field.
_type() - Method in class org.omg.CORBA.ShortHolder
Returns the TypeCode corresponding to the value held in this ShortHolder object.
_type() - Method in class org.omg.CORBA.ShortSeqHolder
_type() - Method in class org.omg.CORBA.StringHolder
Retrieves the TypeCode object that corresponds to the value held in this StringHolder object.
_type() - Method in class org.omg.CORBA.StringSeqHolder
_type() - Method in class org.omg.CORBA.TypeCodeHolder
Returns the TypeCode corresponding to the value held in this TypeCodeHolder object.
_type() - Method in class org.omg.CORBA.ULongLongSeqHolder
_type() - Method in class org.omg.CORBA.ULongSeqHolder
_type() - Method in class org.omg.CORBA.UnknownUserExceptionHolder
_type() - Method in class org.omg.CORBA.UShortSeqHolder
_type() - Method in class org.omg.CORBA.ValueBaseHolder
Returns the TypeCode object corresponding to the value held in the Holder.
_type() - Method in class org.omg.CORBA.WCharSeqHolder
_type() - Method in class org.omg.CORBA.WrongTransactionHolder
_type() - Method in class org.omg.CORBA.WStringSeqHolder
_type() - Method in class org.omg.CosNaming.BindingHolder
_type() - Method in class org.omg.CosNaming.BindingIteratorHolder
_type() - Method in class org.omg.CosNaming.BindingListHolder
_type() - Method in class org.omg.CosNaming.BindingTypeHolder
_type() - Method in class org.omg.CosNaming.NameComponentHolder
_type() - Method in class org.omg.CosNaming.NameHolder
_type() - Method in class org.omg.CosNaming.NamingContextExtHolder
_type() - Method in class org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHolder
_type() - Method in class org.omg.CosNaming.NamingContextHolder
_type() - Method in class org.omg.CosNaming.NamingContextPackage.AlreadyBoundHolder
_type() - Method in class org.omg.CosNaming.NamingContextPackage.CannotProceedHolder
_type() - Method in class org.omg.CosNaming.NamingContextPackage.InvalidNameHolder
_type() - Method in class org.omg.CosNaming.NamingContextPackage.NotEmptyHolder
_type() - Method in class org.omg.CosNaming.NamingContextPackage.NotFoundHolder
_type() - Method in class org.omg.CosNaming.NamingContextPackage.NotFoundReasonHolder
_type() - Method in class org.omg.IOP.IORHolder
_type() - Method in class org.omg.IOP.MultipleComponentProfileHolder
_type() - Method in class org.omg.IOP.ServiceContextHolder
_type() - Method in class org.omg.IOP.ServiceContextListHolder
_type() - Method in class org.omg.IOP.TaggedComponentHolder
_type() - Method in class org.omg.IOP.TaggedProfileHolder
_type() - Method in class org.omg.PortableInterceptor.IORInterceptor_3_0Holder
_type() - Method in class org.omg.PortableInterceptor.ObjectReferenceFactoryHolder
_type() - Method in class org.omg.PortableInterceptor.ObjectReferenceTemplateHolder
_type() - Method in class org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHolder
_type() - Method in class org.omg.PortableServer.ServantLocatorPackage.CookieHolder
_UNIQUE_ID - Static variable in class org.omg.PortableServer.IdUniquenessPolicyValue
_USE_ACTIVE_OBJECT_MAP_ONLY - Static variable in class org.omg.PortableServer.RequestProcessingPolicyValue
_USE_DEFAULT_SERVANT - Static variable in class org.omg.PortableServer.RequestProcessingPolicyValue
_USE_SERVANT_MANAGER - Static variable in class org.omg.PortableServer.RequestProcessingPolicyValue
_USER_ID - Static variable in class org.omg.PortableServer.IdAssignmentPolicyValue
_write(OutputStream) - Method in class org.omg.CORBA.AnyHolder
Marshals to output the value in this AnyHolder object.
_write(OutputStream) - Method in class org.omg.CORBA.AnySeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.BooleanHolder
Marshals the value in this BooleanHolder object's value field to the output stream output.
_write(OutputStream) - Method in class org.omg.CORBA.BooleanSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.ByteHolder
Marshals to output the value in this ByteHolder object.
_write(OutputStream) - Method in class org.omg.CORBA.CharHolder
Marshals to output the value in this CharHolder object.
_write(OutputStream) - Method in class org.omg.CORBA.CharSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.CurrentHolder
_write(OutputStream) - Method in class org.omg.CORBA.DoubleHolder
Write the double value stored in this holder to an OutputStream.
_write(OutputStream) - Method in class org.omg.CORBA.DoubleSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.FixedHolder
Write the fixed point value stored in this holder to an OutputStream.
_write(OutputStream) - Method in class org.omg.CORBA.FloatHolder
Write the float value into an output stream.
_write(OutputStream) - Method in class org.omg.CORBA.FloatSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.IntHolder
Marshals the value in this IntHolder object's value field to the output stream output.
_write(OutputStream) - Method in class org.omg.CORBA.LongHolder
Marshals to output the value in the Holder.
_write(OutputStream) - Method in class org.omg.CORBA.LongLongSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.LongSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.ObjectHolder
Marshals to output the value in this ObjectHolder object.
_write(OutputStream) - Method in class org.omg.CORBA.OctetSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.ParameterModeHolder
_write(OutputStream) - Method in class org.omg.CORBA.PolicyErrorHolder
_write(OutputStream) - Method in class org.omg.CORBA.PolicyHolder
_write(OutputStream) - Method in class org.omg.CORBA.PolicyListHolder
_write(OutputStream) - Method in interface org.omg.CORBA.portable.Streamable
Marshals to ostream the value in the value field of the Holder.
_write(OutputStream) - Method in class org.omg.CORBA.PrincipalHolder
Deprecated.
_write(OutputStream) - Method in class org.omg.CORBA.ServiceInformationHolder
Marshals the value in this ServiceInformationHolder object's value field to the output stream out.
_write(OutputStream) - Method in class org.omg.CORBA.ShortHolder
Marshals to output the value in this ShortHolder object.
_write(OutputStream) - Method in class org.omg.CORBA.ShortSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.StringHolder
Marshals the value held by this StringHolder object to the output stream output.
_write(OutputStream) - Method in class org.omg.CORBA.StringSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.TypeCodeHolder
Marshals to output the value in this TypeCodeHolder object.
_write(OutputStream) - Method in class org.omg.CORBA.ULongLongSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.ULongSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.UnknownUserExceptionHolder
_write(OutputStream) - Method in class org.omg.CORBA.UShortSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.ValueBaseHolder
Marshals to output the value in the Holder.
_write(OutputStream) - Method in class org.omg.CORBA.WCharSeqHolder
_write(OutputStream) - Method in class org.omg.CORBA.WrongTransactionHolder
_write(OutputStream) - Method in class org.omg.CORBA.WStringSeqHolder
_write(OutputStream) - Method in class org.omg.CosNaming.BindingHolder
_write(OutputStream) - Method in class org.omg.CosNaming.BindingIteratorHolder
_write(OutputStream) - Method in class org.omg.CosNaming.BindingListHolder
_write(OutputStream) - Method in class org.omg.CosNaming.BindingTypeHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NameComponentHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NameHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextExtHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextPackage.AlreadyBoundHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextPackage.CannotProceedHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextPackage.InvalidNameHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextPackage.NotEmptyHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextPackage.NotFoundHolder
_write(OutputStream) - Method in class org.omg.CosNaming.NamingContextPackage.NotFoundReasonHolder
_write(OutputStream) - Method in class org.omg.IOP.IORHolder
_write(OutputStream) - Method in class org.omg.IOP.MultipleComponentProfileHolder
_write(OutputStream) - Method in class org.omg.IOP.ServiceContextHolder
_write(OutputStream) - Method in class org.omg.IOP.ServiceContextListHolder
_write(OutputStream) - Method in class org.omg.IOP.TaggedComponentHolder
_write(OutputStream) - Method in class org.omg.IOP.TaggedProfileHolder
_write(OutputStream) - Method in class org.omg.PortableInterceptor.IORInterceptor_3_0Holder
_write(OutputStream) - Method in class org.omg.PortableInterceptor.ObjectReferenceFactoryHolder
_write(OutputStream) - Method in class org.omg.PortableInterceptor.ObjectReferenceTemplateHolder
_write(OutputStream) - Method in class org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHolder
_write(OutputStream) - Method in class org.omg.PortableServer.ServantLocatorPackage.CookieHolder
Overview Package Class Use Tree Deprecated Index Help
Java™ Platform
Standard Ed. 6
PREV LETTER NEXT LETTER FRAMES NO FRAMES
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z _
Submit a bug or feature
For further API reference and developer documentation, see Java SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Copyright 2006 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.


 java.applet
Interfaces
AppletContext
AppletStub
AudioClip
Classes
Applet


 java.awt
Interfaces
ActiveEvent
Adjustable
Composite
CompositeContext
ItemSelectable
KeyEventDispatcher
KeyEventPostProcessor
LayoutManager
LayoutManager2
MenuContainer
Paint
PaintContext
PrintGraphics
Shape
Stroke
Transparency
Classes
AlphaComposite
AWTEvent
AWTEventMulticaster
AWTKeyStroke
AWTPermission
BasicStroke
BorderLayout
BufferCapabilities
BufferCapabilities.FlipContents
Button
Canvas
CardLayout
Checkbox
CheckboxGroup
CheckboxMenuItem
Choice
Color
Component
ComponentOrientation
Container
ContainerOrderFocusTraversalPolicy
Cursor
DefaultFocusTraversalPolicy
DefaultKeyboardFocusManager
Desktop
Dialog
Dimension
DisplayMode
Event
EventQueue
FileDialog
FlowLayout
FocusTraversalPolicy
Font
FontMetrics
Frame
GradientPaint
Graphics
Graphics2D
GraphicsConfigTemplate
GraphicsConfiguration
GraphicsDevice
GraphicsEnvironment
GridBagConstraints
GridBagLayout
GridBagLayoutInfo
GridLayout
Image
ImageCapabilities
Insets
JobAttributes
JobAttributes.DefaultSelectionType
JobAttributes.DestinationType
JobAttributes.DialogType
JobAttributes.MultipleDocumentHandlingType
JobAttributes.SidesType
KeyboardFocusManager
Label
LinearGradientPaint
List
MediaTracker
Menu
MenuBar
MenuComponent
MenuItem
MenuShortcut
MouseInfo
MultipleGradientPaint
PageAttributes
PageAttributes.ColorType
PageAttributes.MediaType
PageAttributes.OrientationRequestedType
PageAttributes.OriginType
PageAttributes.PrintQualityType
Panel
Point
PointerInfo
Polygon
PopupMenu
PrintJob
RadialGradientPaint
Rectangle
RenderingHints
RenderingHints.Key
Robot
Scrollbar
ScrollPane
ScrollPaneAdjustable
SplashScreen
SystemColor
SystemTray
TextArea
TextComponent
TextField
TexturePaint
Toolkit
TrayIcon
Window
Enums
Component.BaselineResizeBehavior
Desktop.Action
Dialog.ModalExclusionType
Dialog.ModalityType
MultipleGradientPaint.ColorSpaceType
MultipleGradientPaint.CycleMethod
TrayIcon.MessageType
Exceptions
AWTException
FontFormatException
HeadlessException
IllegalComponentStateException
Errors
AWTError


 java.awt.color
Classes
ColorSpace
ICC_ColorSpace
ICC_Profile
ICC_ProfileGray
ICC_ProfileRGB
Exceptions
CMMException
ProfileDataException


 java.awt.datatransfer
Interfaces
ClipboardOwner
FlavorListener
FlavorMap
FlavorTable
Transferable
Classes
Clipboard
DataFlavor
FlavorEvent
StringSelection
SystemFlavorMap
Exceptions
MimeTypeParseException
UnsupportedFlavorException


 java.awt.dnd
Interfaces
Autoscroll
DragGestureListener
DragSourceListener
DragSourceMotionListener
DropTargetListener
Classes
DnDConstants
DragGestureEvent
DragGestureRecognizer
DragSource
DragSourceAdapter
DragSourceContext
DragSourceDragEvent
DragSourceDropEvent
DragSourceEvent
DropTarget
DropTarget.DropTargetAutoScroller
DropTargetAdapter
DropTargetContext
DropTargetDragEvent
DropTargetDropEvent
DropTargetEvent
MouseDragGestureRecognizer
Exceptions
InvalidDnDOperationException


 java.awt.event
Interfaces
ActionListener
AdjustmentListener
AWTEventListener
ComponentListener
ContainerListener
FocusListener
HierarchyBoundsListener
HierarchyListener
InputMethodListener
ItemListener
KeyListener
MouseListener
MouseMotionListener
MouseWheelListener
TextListener
WindowFocusListener
WindowListener
WindowStateListener
Classes
ActionEvent
AdjustmentEvent
AWTEventListenerProxy
ComponentAdapter
ComponentEvent
ContainerAdapter
ContainerEvent
FocusAdapter
FocusEvent
HierarchyBoundsAdapter
HierarchyEvent
InputEvent
InputMethodEvent
InvocationEvent
ItemEvent
KeyAdapter
KeyEvent
MouseAdapter
MouseEvent
MouseMotionAdapter
MouseWheelEvent
PaintEvent
TextEvent
WindowAdapter
WindowEvent


 java.awt.font
Interfaces
MultipleMaster
OpenType
Classes
FontRenderContext
GlyphJustificationInfo
GlyphMetrics
GlyphVector
GraphicAttribute
ImageGraphicAttribute
LayoutPath
LineBreakMeasurer
LineMetrics
NumericShaper
ShapeGraphicAttribute
TextAttribute
TextHitInfo
TextLayout
TextLayout.CaretPolicy
TextMeasurer
TransformAttribute


 java.awt.geom
Interfaces
PathIterator
Classes
AffineTransform
Arc2D
Arc2D.Double
Arc2D.Float
Area
CubicCurve2D
CubicCurve2D.Double
CubicCurve2D.Float
Dimension2D
Ellipse2D
Ellipse2D.Double
Ellipse2D.Float
FlatteningPathIterator
GeneralPath
Line2D
Line2D.Double
Line2D.Float
Path2D
Path2D.Double
Path2D.Float
Point2D
Point2D.Double
Point2D.Float
QuadCurve2D
QuadCurve2D.Double
QuadCurve2D.Float
Rectangle2D
Rectangle2D.Double
Rectangle2D.Float
RectangularShape
RoundRectangle2D
RoundRectangle2D.Double
RoundRectangle2D.Float
Exceptions
IllegalPathStateException
NoninvertibleTransformException


 java.awt.im
Interfaces
InputMethodRequests
Classes
InputContext
InputMethodHighlight
InputSubset


 java.awt.im.spi
Interfaces
InputMethod
InputMethodContext
InputMethodDescriptor


 java.awt.image
Interfaces
BufferedImageOp
ImageConsumer
ImageObserver
ImageProducer
RasterOp
RenderedImage
TileObserver
WritableRenderedImage
Classes
AffineTransformOp
AreaAveragingScaleFilter
BandCombineOp
BandedSampleModel
BufferedImage
BufferedImageFilter
BufferStrategy
ByteLookupTable
ColorConvertOp
ColorModel
ComponentColorModel
ComponentSampleModel
ConvolveOp
CropImageFilter
DataBuffer
DataBufferByte
DataBufferDouble
DataBufferFloat
DataBufferInt
DataBufferShort
DataBufferUShort
DirectColorModel
FilteredImageSource
ImageFilter
IndexColorModel
Kernel
LookupOp
LookupTable
MemoryImageSource
MultiPixelPackedSampleModel
PackedColorModel
PixelGrabber
PixelInterleavedSampleModel
Raster
ReplicateScaleFilter
RescaleOp
RGBImageFilter
SampleModel
ShortLookupTable
SinglePixelPackedSampleModel
VolatileImage
WritableRaster
Exceptions
ImagingOpException
RasterFormatException


 java.awt.image.renderable
Interfaces
ContextualRenderedImageFactory
RenderableImage
RenderedImageFactory
Classes
ParameterBlock
RenderableImageOp
RenderableImageProducer
RenderContext


 java.awt.print
Interfaces
Pageable
Printable
PrinterGraphics
Classes
Book
PageFormat
Paper
PrinterJob
Exceptions
PrinterAbortException
PrinterException
PrinterIOException


 java.beans
Interfaces
AppletInitializer
BeanInfo
Customizer
DesignMode
ExceptionListener
PropertyChangeListener
PropertyEditor
VetoableChangeListener
Visibility
Classes
BeanDescriptor
Beans
DefaultPersistenceDelegate
Encoder
EventHandler
EventSetDescriptor
Expression
FeatureDescriptor
IndexedPropertyChangeEvent
IndexedPropertyDescriptor
Introspector
MethodDescriptor
ParameterDescriptor
PersistenceDelegate
PropertyChangeEvent
PropertyChangeListenerProxy
PropertyChangeSupport
PropertyDescriptor
PropertyEditorManager
PropertyEditorSupport
SimpleBeanInfo
Statement
VetoableChangeListenerProxy
VetoableChangeSupport
XMLDecoder
XMLEncoder
Exceptions
IntrospectionException
PropertyVetoException
Annotation Types
ConstructorProperties


 java.beans.beancontext
Interfaces
BeanContext
BeanContextChild
BeanContextChildComponentProxy
BeanContextContainerProxy
BeanContextMembershipListener
BeanContextProxy
BeanContextServiceProvider
BeanContextServiceProviderBeanInfo
BeanContextServiceRevokedListener
BeanContextServices
BeanContextServicesListener
Classes
BeanContextChildSupport
BeanContextEvent
BeanContextMembershipEvent
BeanContextServiceAvailableEvent
BeanContextServiceRevokedEvent
BeanContextServicesSupport
BeanContextServicesSupport.BCSSServiceProvider
BeanContextSupport
BeanContextSupport.BCSIterator


 java.io
Interfaces
Closeable
DataInput
DataOutput
Externalizable
FileFilter
FilenameFilter
Flushable
ObjectInput
ObjectInputValidation
ObjectOutput
ObjectStreamConstants
Serializable
Classes
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
ByteArrayInputStream
ByteArrayOutputStream
CharArrayReader
CharArrayWriter
Console
DataInputStream
DataOutputStream
File
FileDescriptor
FileInputStream
FileOutputStream
FilePermission
FileReader
FileWriter
FilterInputStream
FilterOutputStream
FilterReader
FilterWriter
InputStream
InputStreamReader
LineNumberInputStream
LineNumberReader
ObjectInputStream
ObjectInputStream.GetField
ObjectOutputStream
ObjectOutputStream.PutField
ObjectStreamClass
ObjectStreamField
OutputStream
OutputStreamWriter
PipedInputStream
PipedOutputStream
PipedReader
PipedWriter
PrintStream
PrintWriter
PushbackInputStream
PushbackReader
RandomAccessFile
Reader
SequenceInputStream
SerializablePermission
StreamTokenizer
StringBufferInputStream
StringReader
StringWriter
Writer
Exceptions
CharConversionException
EOFException
FileNotFoundException
InterruptedIOException
InvalidClassException
InvalidObjectException
IOException
NotActiveException
NotSerializableException
ObjectStreamException
OptionalDataException
StreamCorruptedException
SyncFailedException
UnsupportedEncodingException
UTFDataFormatException
WriteAbortedException
Errors
IOError


 java.lang
Interfaces
Appendable
CharSequence
Cloneable
Comparable
Iterable
Readable
Runnable
Thread.UncaughtExceptionHandler
Classes
Boolean
Byte
Character
Character.Subset
Character.UnicodeBlock
Class
ClassLoader
Compiler
Double
Enum
Float
InheritableThreadLocal
Integer
Long
Math
Number
Object
Package
Process
ProcessBuilder
Runtime
RuntimePermission
SecurityManager
Short
StackTraceElement
StrictMath
String
StringBuffer
StringBuilder
System
Thread
ThreadGroup
ThreadLocal
Throwable
Void
Enums
Thread.State
Exceptions
ArithmeticException
ArrayIndexOutOfBoundsException
ArrayStoreException
ClassCastException
ClassNotFoundException
CloneNotSupportedException
EnumConstantNotPresentException
Exception
IllegalAccessException
IllegalArgumentException
IllegalMonitorStateException
IllegalStateException
IllegalThreadStateException
IndexOutOfBoundsException
InstantiationException
InterruptedException
NegativeArraySizeException
NoSuchFieldException
NoSuchMethodException
NullPointerException
NumberFormatException
RuntimeException
SecurityException
StringIndexOutOfBoundsException
TypeNotPresentException
UnsupportedOperationException
Errors
AbstractMethodError
AssertionError
ClassCircularityError
ClassFormatError
Error
ExceptionInInitializerError
IllegalAccessError
IncompatibleClassChangeError
InstantiationError
InternalError
LinkageError
NoClassDefFoundError
NoSuchFieldError
NoSuchMethodError
OutOfMemoryError
StackOverflowError
ThreadDeath
UnknownError
UnsatisfiedLinkError
UnsupportedClassVersionError
VerifyError
VirtualMachineError
Annotation Types
Deprecated
Override
SuppressWarnings


 java.lang.annotation
Interfaces
Annotation
Enums
ElementType
RetentionPolicy
Exceptions
AnnotationTypeMismatchException
IncompleteAnnotationException
Errors
AnnotationFormatError
Annotation Types
Documented
Inherited
Retention
Target


 java.lang.instrument
Interfaces
ClassFileTransformer
Instrumentation
Classes
ClassDefinition
Exceptions
IllegalClassFormatException
UnmodifiableClassException


 java.lang.management
Interfaces
ClassLoadingMXBean
CompilationMXBean
GarbageCollectorMXBean
MemoryManagerMXBean
MemoryMXBean
MemoryPoolMXBean
OperatingSystemMXBean
RuntimeMXBean
ThreadMXBean
Classes
LockInfo
ManagementFactory
ManagementPermission
MemoryNotificationInfo
MemoryUsage
MonitorInfo
ThreadInfo
Enums
MemoryType


 java.lang.ref
Classes
PhantomReference
Reference
ReferenceQueue
SoftReference
WeakReference


 java.lang.reflect
Interfaces
AnnotatedElement
GenericArrayType
GenericDeclaration
InvocationHandler
Member
ParameterizedType
Type
TypeVariable
WildcardType
Classes
AccessibleObject
Array
Constructor
Field
Method
Modifier
Proxy
ReflectPermission
Exceptions
InvocationTargetException
MalformedParameterizedTypeException
UndeclaredThrowableException
Errors
GenericSignatureFormatError


 java.math
Classes
BigDecimal
BigInteger
MathContext
Enums
RoundingMode


 java.net
Interfaces
ContentHandlerFactory
CookiePolicy
CookieStore
DatagramSocketImplFactory
FileNameMap
SocketImplFactory
SocketOptions
URLStreamHandlerFactory
Classes
Authenticator
CacheRequest
CacheResponse
ContentHandler
CookieHandler
CookieManager
DatagramPacket
DatagramSocket
DatagramSocketImpl
HttpCookie
HttpURLConnection
IDN
Inet4Address
Inet6Address
InetAddress
InetSocketAddress
InterfaceAddress
JarURLConnection
MulticastSocket
NetPermission
NetworkInterface
PasswordAuthentication
Proxy
ProxySelector
ResponseCache
SecureCacheResponse
ServerSocket
Socket
SocketAddress
SocketImpl
SocketPermission
URI
URL
URLClassLoader
URLConnection
URLDecoder
URLEncoder
URLStreamHandler
Enums
Authenticator.RequestorType
Proxy.Type
Exceptions
BindException
ConnectException
HttpRetryException
MalformedURLException
NoRouteToHostException
PortUnreachableException
ProtocolException
SocketException
SocketTimeoutException
UnknownHostException
UnknownServiceException
URISyntaxException


 java.nio
Classes
Buffer
ByteBuffer
ByteOrder
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
MappedByteBuffer
ShortBuffer
Exceptions
BufferOverflowException
BufferUnderflowException
InvalidMarkException
ReadOnlyBufferException


 java.nio.channels
Interfaces
ByteChannel
Channel
GatheringByteChannel
InterruptibleChannel
ReadableByteChannel
ScatteringByteChannel
WritableByteChannel
Classes
Channels
DatagramChannel
FileChannel
FileChannel.MapMode
FileLock
Pipe
Pipe.SinkChannel
Pipe.SourceChannel
SelectableChannel
SelectionKey
Selector
ServerSocketChannel
SocketChannel
Exceptions
AlreadyConnectedException
AsynchronousCloseException
CancelledKeyException
ClosedByInterruptException
ClosedChannelException
ClosedSelectorException
ConnectionPendingException
FileLockInterruptionException
IllegalBlockingModeException
IllegalSelectorException
NoConnectionPendingException
NonReadableChannelException
NonWritableChannelException
NotYetBoundException
NotYetConnectedException
OverlappingFileLockException
UnresolvedAddressException
UnsupportedAddressTypeException


 java.nio.channels.spi
Classes
AbstractInterruptibleChannel
AbstractSelectableChannel
AbstractSelectionKey
AbstractSelector
SelectorProvider


 java.nio.charset
Classes
Charset
CharsetDecoder
CharsetEncoder
CoderResult
CodingErrorAction
Exceptions
CharacterCodingException
IllegalCharsetNameException
MalformedInputException
UnmappableCharacterException
UnsupportedCharsetException
Errors
CoderMalfunctionError


 java.nio.charset.spi
Classes
CharsetProvider


 java.rmi
Interfaces
Remote
Classes
MarshalledObject
Naming
RMISecurityManager
Exceptions
AccessException
AlreadyBoundException
ConnectException
ConnectIOException
MarshalException
NoSuchObjectException
NotBoundException
RemoteException
RMISecurityException
ServerError
ServerException
ServerRuntimeException
StubNotFoundException
UnexpectedException
UnknownHostException
UnmarshalException


 java.rmi.activation
Interfaces
ActivationInstantiator
ActivationMonitor
ActivationSystem
Activator
Classes
Activatable
ActivationDesc
ActivationGroup
ActivationGroup_Stub
ActivationGroupDesc
ActivationGroupDesc.CommandEnvironment
ActivationGroupID
ActivationID
Exceptions
ActivateFailedException
ActivationException
UnknownGroupException
UnknownObjectException


 java.rmi.dgc
Interfaces
DGC
Classes
Lease
VMID


 java.rmi.registry
Interfaces
Registry
RegistryHandler
Classes
LocateRegistry


 java.rmi.server
Interfaces
LoaderHandler
RemoteCall
RemoteRef
RMIClientSocketFactory
RMIFailureHandler
RMIServerSocketFactory
ServerRef
Skeleton
Unreferenced
Classes
LogStream
ObjID
Operation
RemoteObject
RemoteObjectInvocationHandler
RemoteServer
RemoteStub
RMIClassLoader
RMIClassLoaderSpi
RMISocketFactory
UID
UnicastRemoteObject
Exceptions
ExportException
ServerCloneException
ServerNotActiveException
SkeletonMismatchException
SkeletonNotFoundException
SocketSecurityException


 java.security
Interfaces
Certificate
DomainCombiner
Guard
Key
KeyStore.Entry
KeyStore.LoadStoreParameter
KeyStore.ProtectionParameter
Policy.Parameters
Principal
PrivateKey
PrivilegedAction
PrivilegedExceptionAction
PublicKey
Classes
AccessControlContext
AccessController
AlgorithmParameterGenerator
AlgorithmParameterGeneratorSpi
AlgorithmParameters
AlgorithmParametersSpi
AllPermission
AuthProvider
BasicPermission
CodeSigner
CodeSource
DigestInputStream
DigestOutputStream
GuardedObject
Identity
IdentityScope
KeyFactory
KeyFactorySpi
KeyPair
KeyPairGenerator
KeyPairGeneratorSpi
KeyRep
KeyStore
KeyStore.Builder
KeyStore.CallbackHandlerProtection
KeyStore.PasswordProtection
KeyStore.PrivateKeyEntry
KeyStore.SecretKeyEntry
KeyStore.TrustedCertificateEntry
KeyStoreSpi
MessageDigest
MessageDigestSpi
Permission
PermissionCollection
Permissions
Policy
PolicySpi
ProtectionDomain
Provider
Provider.Service
SecureClassLoader
SecureRandom
SecureRandomSpi
Security
SecurityPermission
Signature
SignatureSpi
SignedObject
Signer
Timestamp
UnresolvedPermission
URIParameter
Enums
KeyRep.Type
Exceptions
AccessControlException
DigestException
GeneralSecurityException
InvalidAlgorithmParameterException
InvalidKeyException
InvalidParameterException
KeyException
KeyManagementException
KeyStoreException
NoSuchAlgorithmException
NoSuchProviderException
PrivilegedActionException
ProviderException
SignatureException
UnrecoverableEntryException
UnrecoverableKeyException


 java.security.acl
Interfaces
Acl
AclEntry
Group
Owner
Permission
Exceptions
AclNotFoundException
LastOwnerException
NotOwnerException


 java.security.cert
Interfaces
CertPathBuilderResult
CertPathParameters
CertPathValidatorResult
CertSelector
CertStoreParameters
CRLSelector
PolicyNode
X509Extension
Classes
Certificate
Certificate.CertificateRep
CertificateFactory
CertificateFactorySpi
CertPath
CertPath.CertPathRep
CertPathBuilder
CertPathBuilderSpi
CertPathValidator
CertPathValidatorSpi
CertStore
CertStoreSpi
CollectionCertStoreParameters
CRL
LDAPCertStoreParameters
PKIXBuilderParameters
PKIXCertPathBuilderResult
PKIXCertPathChecker
PKIXCertPathValidatorResult
PKIXParameters
PolicyQualifierInfo
TrustAnchor
X509Certificate
X509CertSelector
X509CRL
X509CRLEntry
X509CRLSelector
Exceptions
CertificateEncodingException
CertificateException
CertificateExpiredException
CertificateNotYetValidException
CertificateParsingException
CertPathBuilderException
CertPathValidatorException
CertStoreException
CRLException


 java.security.interfaces
Interfaces
DSAKey
DSAKeyPairGenerator
DSAParams
DSAPrivateKey
DSAPublicKey
ECKey
ECPrivateKey
ECPublicKey
RSAKey
RSAMultiPrimePrivateCrtKey
RSAPrivateCrtKey
RSAPrivateKey
RSAPublicKey


 java.security.spec
Interfaces
AlgorithmParameterSpec
ECField
KeySpec
Classes
DSAParameterSpec
DSAPrivateKeySpec
DSAPublicKeySpec
ECFieldF2m
ECFieldFp
ECGenParameterSpec
ECParameterSpec
ECPoint
ECPrivateKeySpec
ECPublicKeySpec
EllipticCurve
EncodedKeySpec
MGF1ParameterSpec
PKCS8EncodedKeySpec
PSSParameterSpec
RSAKeyGenParameterSpec
RSAMultiPrimePrivateCrtKeySpec
RSAOtherPrimeInfo
RSAPrivateCrtKeySpec
RSAPrivateKeySpec
RSAPublicKeySpec
X509EncodedKeySpec
Exceptions
InvalidKeySpecException
InvalidParameterSpecException


 java.sql
Interfaces
Array
Blob
CallableStatement
Clob
Connection
DatabaseMetaData
Driver
NClob
ParameterMetaData
PreparedStatement
Ref
ResultSet
ResultSetMetaData
RowId
Savepoint
SQLData
SQLInput
SQLOutput
SQLXML
Statement
Struct
Wrapper
Classes
Date
DriverManager
DriverPropertyInfo
SQLPermission
Time
Timestamp
Types
Enums
ClientInfoStatus
RowIdLifetime
Exceptions
BatchUpdateException
DataTruncation
SQLClientInfoException
SQLDataException
SQLException
SQLFeatureNotSupportedException
SQLIntegrityConstraintViolationException
SQLInvalidAuthorizationSpecException
SQLNonTransientConnectionException
SQLNonTransientException
SQLRecoverableException
SQLSyntaxErrorException
SQLTimeoutException
SQLTransactionRollbackException
SQLTransientConnectionException
SQLTransientException
SQLWarning


 java.text
Interfaces
AttributedCharacterIterator
CharacterIterator
Classes
Annotation
AttributedCharacterIterator.Attribute
AttributedString
Bidi
BreakIterator
ChoiceFormat
CollationElementIterator
CollationKey
Collator
DateFormat
DateFormat.Field
DateFormatSymbols
DecimalFormat
DecimalFormatSymbols
FieldPosition
Format
Format.Field
MessageFormat
MessageFormat.Field
Normalizer
NumberFormat
NumberFormat.Field
ParsePosition
RuleBasedCollator
SimpleDateFormat
StringCharacterIterator
Enums
Normalizer.Form
Exceptions
ParseException


 java.text.spi
Classes
BreakIteratorProvider
CollatorProvider
DateFormatProvider
DateFormatSymbolsProvider
DecimalFormatSymbolsProvider
NumberFormatProvider


 java.util
Interfaces
Collection
Comparator
Deque
Enumeration
EventListener
Formattable
Iterator
List
ListIterator
Map
Map.Entry
NavigableMap
NavigableSet
Observer
Queue
RandomAccess
Set
SortedMap
SortedSet
Classes
AbstractCollection
AbstractList
AbstractMap
AbstractMap.SimpleEntry
AbstractMap.SimpleImmutableEntry
AbstractQueue
AbstractSequentialList
AbstractSet
ArrayDeque
ArrayList
Arrays
BitSet
Calendar
Collections
Currency
Date
Dictionary
EnumMap
EnumSet
EventListenerProxy
EventObject
FormattableFlags
Formatter
GregorianCalendar
HashMap
HashSet
Hashtable
IdentityHashMap
LinkedHashMap
LinkedHashSet
LinkedList
ListResourceBundle
Locale
Observable
PriorityQueue
Properties
PropertyPermission
PropertyResourceBundle
Random
ResourceBundle
ResourceBundle.Control
Scanner
ServiceLoader
SimpleTimeZone
Stack
StringTokenizer
Timer
TimerTask
TimeZone
TreeMap
TreeSet
UUID
Vector
WeakHashMap
Enums
Formatter.BigDecimalLayoutForm
Exceptions
ConcurrentModificationException
DuplicateFormatFlagsException
EmptyStackException
FormatFlagsConversionMismatchException
FormatterClosedException
IllegalFormatCodePointException
IllegalFormatConversionException
IllegalFormatException
IllegalFormatFlagsException
IllegalFormatPrecisionException
IllegalFormatWidthException
InputMismatchException
InvalidPropertiesFormatException
MissingFormatArgumentException
MissingFormatWidthException
MissingResourceException
NoSuchElementException
TooManyListenersException
UnknownFormatConversionException
UnknownFormatFlagsException
Errors
ServiceConfigurationError


 java.util.concurrent
Interfaces
BlockingDeque
BlockingQueue
Callable
CompletionService
ConcurrentMap
ConcurrentNavigableMap
Delayed
Executor
ExecutorService
Future
RejectedExecutionHandler
RunnableFuture
RunnableScheduledFuture
ScheduledExecutorService
ScheduledFuture
ThreadFactory
Classes
AbstractExecutorService
ArrayBlockingQueue
ConcurrentHashMap
ConcurrentLinkedQueue
ConcurrentSkipListMap
ConcurrentSkipListSet
CopyOnWriteArrayList
CopyOnWriteArraySet
CountDownLatch
CyclicBarrier
DelayQueue
Exchanger
ExecutorCompletionService
Executors
FutureTask
LinkedBlockingDeque
LinkedBlockingQueue
PriorityBlockingQueue
ScheduledThreadPoolExecutor
Semaphore
SynchronousQueue
ThreadPoolExecutor
ThreadPoolExecutor.AbortPolicy
ThreadPoolExecutor.CallerRunsPolicy
ThreadPoolExecutor.DiscardOldestPolicy
ThreadPoolExecutor.DiscardPolicy
Enums
TimeUnit
Exceptions
BrokenBarrierException
CancellationException
ExecutionException
RejectedExecutionException
TimeoutException


 java.util.concurrent.atomic
Classes
AtomicBoolean
AtomicInteger
AtomicIntegerArray
AtomicIntegerFieldUpdater
AtomicLong
AtomicLongArray
AtomicLongFieldUpdater
AtomicMarkableReference
AtomicReference
AtomicReferenceArray
AtomicReferenceFieldUpdater
AtomicStampedReference


 java.util.concurrent.locks
Interfaces
Condition
Lock
ReadWriteLock
Classes
AbstractOwnableSynchronizer
AbstractQueuedLongSynchronizer
AbstractQueuedSynchronizer
LockSupport
ReentrantLock
ReentrantReadWriteLock
ReentrantReadWriteLock.ReadLock
ReentrantReadWriteLock.WriteLock


 java.util.jar
Interfaces
Pack200.Packer
Pack200.Unpacker
Classes
Attributes
Attributes.Name
JarEntry
JarFile
JarInputStream
JarOutputStream
Manifest
Pack200
Exceptions
JarException


 java.util.logging
Interfaces
Filter
LoggingMXBean
Classes
ConsoleHandler
ErrorManager
FileHandler
Formatter
Handler
Level
Logger
LoggingPermission
LogManager
LogRecord
MemoryHandler
SimpleFormatter
SocketHandler
StreamHandler
XMLFormatter


 java.util.prefs
Interfaces
NodeChangeListener
PreferenceChangeListener
PreferencesFactory
Classes
AbstractPreferences
NodeChangeEvent
PreferenceChangeEvent
Preferences
Exceptions
BackingStoreException
InvalidPreferencesFormatException


 java.util.regex
Interfaces
MatchResult
Classes
Matcher
Pattern
Exceptions
PatternSyntaxException


 java.util.spi
Classes
CurrencyNameProvider
LocaleNameProvider
LocaleServiceProvider
TimeZoneNameProvider


 java.util.zip
Interfaces
Checksum
Classes
Adler32
CheckedInputStream
CheckedOutputStream
CRC32
Deflater
DeflaterInputStream
DeflaterOutputStream
GZIPInputStream
GZIPOutputStream
Inflater
InflaterInputStream
InflaterOutputStream
ZipEntry
ZipFile
ZipInputStream
ZipOutputStream
Exceptions
DataFormatException
ZipException
Errors
ZipError


 javax.accessibility
Interfaces
Accessible
AccessibleAction
AccessibleComponent
AccessibleEditableText
AccessibleExtendedComponent
AccessibleExtendedTable
AccessibleExtendedText
AccessibleHypertext
AccessibleIcon
AccessibleKeyBinding
AccessibleSelection
AccessibleStreamable
AccessibleTable
AccessibleTableModelChange
AccessibleText
AccessibleValue
Classes
AccessibleAttributeSequence
AccessibleBundle
AccessibleContext
AccessibleHyperlink
AccessibleRelation
AccessibleRelationSet
AccessibleResourceBundle
AccessibleRole
AccessibleState
AccessibleStateSet
AccessibleTextSequence


 javax.activation
Interfaces
CommandObject
DataContentHandler
DataContentHandlerFactory
DataSource
Classes
ActivationDataFlavor
CommandInfo
CommandMap
DataHandler
FileDataSource
FileTypeMap
MailcapCommandMap
MimeType
MimeTypeParameterList
MimetypesFileTypeMap
URLDataSource
Exceptions
MimeTypeParseException
UnsupportedDataTypeException


 javax.activity
Exceptions
ActivityCompletedException
ActivityRequiredException
InvalidActivityException


 javax.annotation
Enums
Resource.AuthenticationType
Annotation Types
Generated
PostConstruct
PreDestroy
Resource
Resources


 javax.annotation.processing
Interfaces
Completion
Filer
Messager
ProcessingEnvironment
Processor
RoundEnvironment
Classes
AbstractProcessor
Completions
Exceptions
FilerException
Annotation Types
SupportedAnnotationTypes
SupportedOptions
SupportedSourceVersion


 javax.crypto
Interfaces
SecretKey
Classes
Cipher
CipherInputStream
CipherOutputStream
CipherSpi
EncryptedPrivateKeyInfo
ExemptionMechanism
ExemptionMechanismSpi
KeyAgreement
KeyAgreementSpi
KeyGenerator
KeyGeneratorSpi
Mac
MacSpi
NullCipher
SealedObject
SecretKeyFactory
SecretKeyFactorySpi
Exceptions
BadPaddingException
ExemptionMechanismException
IllegalBlockSizeException
NoSuchPaddingException
ShortBufferException


 javax.crypto.interfaces
Interfaces
DHKey
DHPrivateKey
DHPublicKey
PBEKey


 javax.crypto.spec
Classes
DESedeKeySpec
DESKeySpec
DHGenParameterSpec
DHParameterSpec
DHPrivateKeySpec
DHPublicKeySpec
IvParameterSpec
OAEPParameterSpec
PBEKeySpec
PBEParameterSpec
PSource
PSource.PSpecified
RC2ParameterSpec
RC5ParameterSpec
SecretKeySpec


 javax.imageio
Interfaces
IIOParamController
ImageTranscoder
Classes
IIOImage
IIOParam
ImageIO
ImageReader
ImageReadParam
ImageTypeSpecifier
ImageWriteParam
ImageWriter
Exceptions
IIOException


 javax.imageio.event
Interfaces
IIOReadProgressListener
IIOReadUpdateListener
IIOReadWarningListener
IIOWriteProgressListener
IIOWriteWarningListener


 javax.imageio.metadata
Interfaces
IIOMetadataController
IIOMetadataFormat
Classes
IIOMetadata
IIOMetadataFormatImpl
IIOMetadataNode
Exceptions
IIOInvalidTreeException


 javax.imageio.plugins.bmp
Classes
BMPImageWriteParam


 javax.imageio.plugins.jpeg
Classes
JPEGHuffmanTable
JPEGImageReadParam
JPEGImageWriteParam
JPEGQTable


 javax.imageio.spi
Interfaces
RegisterableService
ServiceRegistry.Filter
Classes
IIORegistry
IIOServiceProvider
ImageInputStreamSpi
ImageOutputStreamSpi
ImageReaderSpi
ImageReaderWriterSpi
ImageTranscoderSpi
ImageWriterSpi
ServiceRegistry


 javax.imageio.stream
Interfaces
ImageInputStream
ImageOutputStream
Classes
FileCacheImageInputStream
FileCacheImageOutputStream
FileImageInputStream
FileImageOutputStream
IIOByteBuffer
ImageInputStreamImpl
ImageOutputStreamImpl
MemoryCacheImageInputStream
MemoryCacheImageOutputStream


 javax.jws
Enums
WebParam.Mode
Annotation Types
HandlerChain
Oneway
WebMethod
WebParam
WebResult
WebService


 javax.jws.soap
Enums
SOAPBinding.ParameterStyle
SOAPBinding.Style
SOAPBinding.Use
Annotation Types
InitParam
SOAPBinding
SOAPMessageHandler
SOAPMessageHandlers


 javax.lang.model
Enums
SourceVersion


 javax.lang.model.element
Interfaces
AnnotationMirror
AnnotationValue
AnnotationValueVisitor
Element
ElementVisitor
ExecutableElement
Name
PackageElement
TypeElement
TypeParameterElement
VariableElement
Enums
ElementKind
Modifier
NestingKind
Exceptions
UnknownAnnotationValueException
UnknownElementException


 javax.lang.model.type
Interfaces
ArrayType
DeclaredType
ErrorType
ExecutableType
NoType
NullType
PrimitiveType
ReferenceType
TypeMirror
TypeVariable
TypeVisitor
WildcardType
Enums
TypeKind
Exceptions
MirroredTypeException
MirroredTypesException
UnknownTypeException


 javax.lang.model.util
Interfaces
Elements
Types
Classes
AbstractAnnotationValueVisitor6
AbstractElementVisitor6
AbstractTypeVisitor6
ElementFilter
ElementKindVisitor6
ElementScanner6
SimpleAnnotationValueVisitor6
SimpleElementVisitor6
SimpleTypeVisitor6
TypeKindVisitor6


 javax.management
Interfaces
Descriptor
DescriptorAccess
DescriptorRead
DynamicMBean
MBeanRegistration
MBeanServer
MBeanServerConnection
MBeanServerDelegateMBean
NotificationBroadcaster
NotificationEmitter
NotificationFilter
NotificationListener
PersistentMBean
QueryExp
ValueExp
Classes
Attribute
AttributeChangeNotification
AttributeChangeNotificationFilter
AttributeList
AttributeValueExp
DefaultLoaderRepository
ImmutableDescriptor
JMX
MBeanAttributeInfo
MBeanConstructorInfo
MBeanFeatureInfo
MBeanInfo
MBeanNotificationInfo
MBeanOperationInfo
MBeanParameterInfo
MBeanPermission
MBeanServerBuilder
MBeanServerDelegate
MBeanServerFactory
MBeanServerInvocationHandler
MBeanServerNotification
MBeanServerPermission
MBeanTrustPermission
Notification
NotificationBroadcasterSupport
NotificationFilterSupport
ObjectInstance
ObjectName
Query
QueryEval
StandardEmitterMBean
StandardMBean
StringValueExp
Exceptions
AttributeNotFoundException
BadAttributeValueExpException
BadBinaryOpValueExpException
BadStringOperationException
InstanceAlreadyExistsException
InstanceNotFoundException
IntrospectionException
InvalidApplicationException
InvalidAttributeValueException
JMException
JMRuntimeException
ListenerNotFoundException
MalformedObjectNameException
MBeanException
MBeanRegistrationException
NotCompliantMBeanException
OperationsException
ReflectionException
RuntimeErrorException
RuntimeMBeanException
RuntimeOperationsException
ServiceNotFoundException
Annotation Types
DescriptorKey
MXBean


 javax.management.loading
Interfaces
ClassLoaderRepository
MLetMBean
PrivateClassLoader
Classes
DefaultLoaderRepository
MLet
MLetContent
PrivateMLet


 javax.management.modelmbean
Interfaces
ModelMBean
ModelMBeanInfo
ModelMBeanNotificationBroadcaster
Classes
DescriptorSupport
ModelMBeanAttributeInfo
ModelMBeanConstructorInfo
ModelMBeanInfoSupport
ModelMBeanNotificationInfo
ModelMBeanOperationInfo
RequiredModelMBean
Exceptions
InvalidTargetObjectTypeException
XMLParseException


 javax.management.monitor
Interfaces
CounterMonitorMBean
GaugeMonitorMBean
MonitorMBean
StringMonitorMBean
Classes
CounterMonitor
GaugeMonitor
Monitor
MonitorNotification
StringMonitor
Exceptions
MonitorSettingException


 javax.management.openmbean
Interfaces
CompositeData
CompositeDataView
OpenMBeanAttributeInfo
OpenMBeanConstructorInfo
OpenMBeanInfo
OpenMBeanOperationInfo
OpenMBeanParameterInfo
TabularData
Classes
ArrayType
CompositeDataInvocationHandler
CompositeDataSupport
CompositeType
OpenMBeanAttributeInfoSupport
OpenMBeanConstructorInfoSupport
OpenMBeanInfoSupport
OpenMBeanOperationInfoSupport
OpenMBeanParameterInfoSupport
OpenType
SimpleType
TabularDataSupport
TabularType
Exceptions
InvalidKeyException
InvalidOpenTypeException
KeyAlreadyExistsException
OpenDataException


 javax.management.relation
Interfaces
Relation
RelationServiceMBean
RelationSupportMBean
RelationType
Classes
MBeanServerNotificationFilter
RelationNotification
RelationService
RelationSupport
RelationTypeSupport
Role
RoleInfo
RoleList
RoleResult
RoleStatus
RoleUnresolved
RoleUnresolvedList
Exceptions
InvalidRelationIdException
InvalidRelationServiceException
InvalidRelationTypeException
InvalidRoleInfoException
InvalidRoleValueException
RelationException
RelationNotFoundException
RelationServiceNotRegisteredException
RelationTypeNotFoundException
RoleInfoNotFoundException
RoleNotFoundException


 javax.management.remote
Interfaces
JMXAddressable
JMXAuthenticator
JMXConnector
JMXConnectorProvider
JMXConnectorServerMBean
JMXConnectorServerProvider
MBeanServerForwarder
Classes
JMXConnectionNotification
JMXConnectorFactory
JMXConnectorServer
JMXConnectorServerFactory
JMXPrincipal
JMXServiceURL
NotificationResult
SubjectDelegationPermission
TargetedNotification
Exceptions
JMXProviderException
JMXServerErrorException


 javax.management.remote.rmi
Interfaces
RMIConnection
RMIServer
Classes
RMIConnectionImpl
RMIConnectionImpl_Stub
RMIConnector
RMIConnectorServer
RMIIIOPServerImpl
RMIJRMPServerImpl
RMIServerImpl
RMIServerImpl_Stub


 javax.management.timer
Interfaces
TimerMBean
Classes
Timer
TimerNotification


 javax.naming
Interfaces
Context
Name
NameParser
NamingEnumeration
Referenceable
Classes
BinaryRefAddr
Binding
CompositeName
CompoundName
InitialContext
LinkRef
NameClassPair
RefAddr
Reference
StringRefAddr
Exceptions
AuthenticationException
AuthenticationNotSupportedException
CannotProceedException
CommunicationException
ConfigurationException
ContextNotEmptyException
InsufficientResourcesException
InterruptedNamingException
InvalidNameException
LimitExceededException
LinkException
LinkLoopException
MalformedLinkException
NameAlreadyBoundException
NameNotFoundException
NamingException
NamingSecurityException
NoInitialContextException
NoPermissionException
NotContextException
OperationNotSupportedException
PartialResultException
ReferralException
ServiceUnavailableException
SizeLimitExceededException
TimeLimitExceededException


 javax.naming.directory
Interfaces
Attribute
Attributes
DirContext
Classes
BasicAttribute
BasicAttributes
InitialDirContext
ModificationItem
SearchControls
SearchResult
Exceptions
AttributeInUseException
AttributeModificationException
InvalidAttributeIdentifierException
InvalidAttributesException
InvalidAttributeValueException
InvalidSearchControlsException
InvalidSearchFilterException
NoSuchAttributeException
SchemaViolationException


 javax.naming.event
Interfaces
EventContext
EventDirContext
NamespaceChangeListener
NamingListener
ObjectChangeListener
Classes
NamingEvent
NamingExceptionEvent


 javax.naming.ldap
Interfaces
Control
ExtendedRequest
ExtendedResponse
HasControls
LdapContext
UnsolicitedNotification
UnsolicitedNotificationListener
Classes
BasicControl
ControlFactory
InitialLdapContext
LdapName
ManageReferralControl
PagedResultsControl
PagedResultsResponseControl
Rdn
SortControl
SortKey
SortResponseControl
StartTlsRequest
StartTlsResponse
UnsolicitedNotificationEvent
Exceptions
LdapReferralException


 javax.naming.spi
Interfaces
DirObjectFactory
DirStateFactory
InitialContextFactory
InitialContextFactoryBuilder
ObjectFactory
ObjectFactoryBuilder
Resolver
StateFactory
Classes
DirectoryManager
DirStateFactory.Result
NamingManager
ResolveResult


 javax.net
Classes
ServerSocketFactory
SocketFactory


 javax.net.ssl
Interfaces
HandshakeCompletedListener
HostnameVerifier
KeyManager
ManagerFactoryParameters
SSLSession
SSLSessionBindingListener
SSLSessionContext
TrustManager
X509KeyManager
X509TrustManager
Classes
CertPathTrustManagerParameters
HandshakeCompletedEvent
HttpsURLConnection
KeyManagerFactory
KeyManagerFactorySpi
KeyStoreBuilderParameters
SSLContext
SSLContextSpi
SSLEngine
SSLEngineResult
SSLParameters
SSLPermission
SSLServerSocket
SSLServerSocketFactory
SSLSessionBindingEvent
SSLSocket
SSLSocketFactory
TrustManagerFactory
TrustManagerFactorySpi
X509ExtendedKeyManager
Enums
SSLEngineResult.HandshakeStatus
SSLEngineResult.Status
Exceptions
SSLException
SSLHandshakeException
SSLKeyException
SSLPeerUnverifiedException
SSLProtocolException


 javax.print
Interfaces
AttributeException
CancelablePrintJob
Doc
DocPrintJob
FlavorException
MultiDoc
MultiDocPrintJob
MultiDocPrintService
PrintService
URIException
Classes
DocFlavor
DocFlavor.BYTE_ARRAY
DocFlavor.CHAR_ARRAY
DocFlavor.INPUT_STREAM
DocFlavor.READER
DocFlavor.SERVICE_FORMATTED
DocFlavor.STRING
DocFlavor.URL
PrintServiceLookup
ServiceUI
ServiceUIFactory
SimpleDoc
StreamPrintService
StreamPrintServiceFactory
Exceptions
PrintException


 javax.print.attribute
Interfaces
Attribute
AttributeSet
DocAttribute
DocAttributeSet
PrintJobAttribute
PrintJobAttributeSet
PrintRequestAttribute
PrintRequestAttributeSet
PrintServiceAttribute
PrintServiceAttributeSet
SupportedValuesAttribute
Classes
AttributeSetUtilities
DateTimeSyntax
EnumSyntax
HashAttributeSet
HashDocAttributeSet
HashPrintJobAttributeSet
HashPrintRequestAttributeSet
HashPrintServiceAttributeSet
IntegerSyntax
ResolutionSyntax
SetOfIntegerSyntax
Size2DSyntax
TextSyntax
URISyntax
Exceptions
UnmodifiableSetException


 javax.print.attribute.standard
Classes
Chromaticity
ColorSupported
Compression
Copies
CopiesSupported
DateTimeAtCompleted
DateTimeAtCreation
DateTimeAtProcessing
Destination
DocumentName
Fidelity
Finishings
JobHoldUntil
JobImpressions
JobImpressionsCompleted
JobImpressionsSupported
JobKOctets
JobKOctetsProcessed
JobKOctetsSupported
JobMediaSheets
JobMediaSheetsCompleted
JobMediaSheetsSupported
JobMessageFromOperator
JobName
JobOriginatingUserName
JobPriority
JobPrioritySupported
JobSheets
JobState
JobStateReason
JobStateReasons
Media
MediaName
MediaPrintableArea
MediaSize
MediaSize.Engineering
MediaSize.ISO
MediaSize.JIS
MediaSize.NA
MediaSize.Other
MediaSizeName
MediaTray
MultipleDocumentHandling
NumberOfDocuments
NumberOfInterveningJobs
NumberUp
NumberUpSupported
OrientationRequested
OutputDeviceAssigned
PageRanges
PagesPerMinute
PagesPerMinuteColor
PDLOverrideSupported
PresentationDirection
PrinterInfo
PrinterIsAcceptingJobs
PrinterLocation
PrinterMakeAndModel
PrinterMessageFromOperator
PrinterMoreInfo
PrinterMoreInfoManufacturer
PrinterName
PrinterResolution
PrinterState
PrinterStateReason
PrinterStateReasons
PrinterURI
PrintQuality
QueuedJobCount
ReferenceUriSchemesSupported
RequestingUserName
Severity
SheetCollate
Sides


 javax.print.event
Interfaces
PrintJobAttributeListener
PrintJobListener
PrintServiceAttributeListener
Classes
PrintEvent
PrintJobAdapter
PrintJobAttributeEvent
PrintJobEvent
PrintServiceAttributeEvent


 javax.rmi
Classes
PortableRemoteObject


 javax.rmi.CORBA
Interfaces
PortableRemoteObjectDelegate
StubDelegate
Tie
UtilDelegate
ValueHandler
ValueHandlerMultiFormat
Classes
ClassDesc
Stub
Util


 javax.rmi.ssl
Classes
SslRMIClientSocketFactory
SslRMIServerSocketFactory


 javax.script
Interfaces
Bindings
Compilable
Invocable
ScriptContext
ScriptEngine
ScriptEngineFactory
Classes
AbstractScriptEngine
CompiledScript
ScriptEngineManager
SimpleBindings
SimpleScriptContext
Exceptions
ScriptException


 javax.security.auth
Interfaces
Destroyable
Refreshable
Classes
AuthPermission
Policy
PrivateCredentialPermission
Subject
SubjectDomainCombiner
Exceptions
DestroyFailedException
RefreshFailedException


 javax.security.auth.callback
Interfaces
Callback
CallbackHandler
Classes
ChoiceCallback
ConfirmationCallback
LanguageCallback
NameCallback
PasswordCallback
TextInputCallback
TextOutputCallback
Exceptions
UnsupportedCallbackException


 javax.security.auth.kerberos
Classes
DelegationPermission
KerberosKey
KerberosPrincipal
KerberosTicket
ServicePermission


 javax.security.auth.login
Interfaces
Configuration.Parameters
Classes
AppConfigurationEntry
AppConfigurationEntry.LoginModuleControlFlag
Configuration
ConfigurationSpi
LoginContext
Exceptions
AccountException
AccountExpiredException
AccountLockedException
AccountNotFoundException
CredentialException
CredentialExpiredException
CredentialNotFoundException
FailedLoginException
LoginException


 javax.security.auth.spi
Interfaces
LoginModule


 javax.security.auth.x500
Classes
X500Principal
X500PrivateCredential


 javax.security.cert
Classes
Certificate
X509Certificate
Exceptions
CertificateEncodingException
CertificateException
CertificateExpiredException
CertificateNotYetValidException
CertificateParsingException


 javax.security.sasl
Interfaces
SaslClient
SaslClientFactory
SaslServer
SaslServerFactory
Classes
AuthorizeCallback
RealmCallback
RealmChoiceCallback
Sasl
Exceptions
AuthenticationException
SaslException


 javax.sound.midi
Interfaces
ControllerEventListener
MetaEventListener
MidiChannel
MidiDevice
Receiver
Sequencer
Soundbank
Synthesizer
Transmitter
Classes
Instrument
MetaMessage
MidiDevice.Info
MidiEvent
MidiFileFormat
MidiMessage
MidiSystem
Patch
Sequence
Sequencer.SyncMode
ShortMessage
SoundbankResource
SysexMessage
Track
VoiceStatus
Exceptions
InvalidMidiDataException
MidiUnavailableException


 javax.sound.midi.spi
Classes
MidiDeviceProvider
MidiFileReader
MidiFileWriter
SoundbankReader


 javax.sound.sampled
Interfaces
Clip
DataLine
Line
LineListener
Mixer
Port
SourceDataLine
TargetDataLine
Classes
AudioFileFormat
AudioFileFormat.Type
AudioFormat
AudioFormat.Encoding
AudioInputStream
AudioPermission
AudioSystem
BooleanControl
BooleanControl.Type
CompoundControl
CompoundControl.Type
Control
Control.Type
DataLine.Info
EnumControl
EnumControl.Type
FloatControl
FloatControl.Type
Line.Info
LineEvent
LineEvent.Type
Mixer.Info
Port.Info
ReverbType
Exceptions
LineUnavailableException
UnsupportedAudioFileException


 javax.sound.sampled.spi
Classes
AudioFileReader
AudioFileWriter
FormatConversionProvider
MixerProvider


 javax.sql
Interfaces
CommonDataSource
ConnectionEventListener
ConnectionPoolDataSource
DataSource
PooledConnection
RowSet
RowSetInternal
RowSetListener
RowSetMetaData
RowSetReader
RowSetWriter
StatementEventListener
XAConnection
XADataSource
Classes
ConnectionEvent
RowSetEvent
StatementEvent


 javax.sql.rowset
Interfaces
CachedRowSet
FilteredRowSet
JdbcRowSet
Joinable
JoinRowSet
Predicate
WebRowSet
Classes
BaseRowSet
RowSetMetaDataImpl
Exceptions
RowSetWarning


 javax.sql.rowset.serial
Classes
SerialArray
SerialBlob
SerialClob
SerialDatalink
SerialJavaObject
SerialRef
SerialStruct
SQLInputImpl
SQLOutputImpl
Exceptions
SerialException


 javax.sql.rowset.spi
Interfaces
SyncResolver
TransactionalWriter
XmlReader
XmlWriter
Classes
SyncFactory
SyncProvider
Exceptions
SyncFactoryException
SyncProviderException


 javax.swing
Interfaces
Action
BoundedRangeModel
ButtonModel
CellEditor
ComboBoxEditor
ComboBoxModel
DesktopManager
Icon
JComboBox.KeySelectionManager
ListCellRenderer
ListModel
ListSelectionModel
MenuElement
MutableComboBoxModel
Renderer
RootPaneContainer
Scrollable
ScrollPaneConstants
SingleSelectionModel
SpinnerModel
SwingConstants
UIDefaults.ActiveValue
UIDefaults.LazyValue
WindowConstants
Classes
AbstractAction
AbstractButton
AbstractCellEditor
AbstractListModel
AbstractSpinnerModel
ActionMap
BorderFactory
Box
Box.Filler
BoxLayout
ButtonGroup
CellRendererPane
ComponentInputMap
DebugGraphics
DefaultBoundedRangeModel
DefaultButtonModel
DefaultCellEditor
DefaultComboBoxModel
DefaultDesktopManager
DefaultFocusManager
DefaultListCellRenderer
DefaultListCellRenderer.UIResource
DefaultListModel
DefaultListSelectionModel
DefaultRowSorter
DefaultRowSorter.ModelWrapper
DefaultSingleSelectionModel
FocusManager
GrayFilter
GroupLayout
ImageIcon
InputMap
InputVerifier
InternalFrameFocusTraversalPolicy
JApplet
JButton
JCheckBox
JCheckBoxMenuItem
JColorChooser
JComboBox
JComponent
JDesktopPane
JDialog
JEditorPane
JFileChooser
JFormattedTextField
JFormattedTextField.AbstractFormatter
JFormattedTextField.AbstractFormatterFactory
JFrame
JInternalFrame
JInternalFrame.JDesktopIcon
JLabel
JLayeredPane
JList
JList.DropLocation
JMenu
JMenuBar
JMenuItem
JOptionPane
JPanel
JPasswordField
JPopupMenu
JPopupMenu.Separator
JProgressBar
JRadioButton
JRadioButtonMenuItem
JRootPane
JScrollBar
JScrollPane
JSeparator
JSlider
JSpinner
JSpinner.DateEditor
JSpinner.DefaultEditor
JSpinner.ListEditor
JSpinner.NumberEditor
JSplitPane
JTabbedPane
JTable
JTable.DropLocation
JTextArea
JTextField
JTextPane
JToggleButton
JToggleButton.ToggleButtonModel
JToolBar
JToolBar.Separator
JToolTip
JTree
JTree.DropLocation
JTree.DynamicUtilTreeNode
JTree.EmptySelectionModel
JViewport
JWindow
KeyStroke
LayoutFocusTraversalPolicy
LayoutStyle
LookAndFeel
MenuSelectionManager
OverlayLayout
Popup
PopupFactory
ProgressMonitor
ProgressMonitorInputStream
RepaintManager
RowFilter
RowFilter.Entry
RowSorter
RowSorter.SortKey
ScrollPaneLayout
ScrollPaneLayout.UIResource
SizeRequirements
SizeSequence
SortingFocusTraversalPolicy
SpinnerDateModel
SpinnerListModel
SpinnerNumberModel
Spring
SpringLayout
SpringLayout.Constraints
SwingUtilities
SwingWorker
Timer
ToolTipManager
TransferHandler
TransferHandler.DropLocation
TransferHandler.TransferSupport
UIDefaults
UIDefaults.LazyInputMap
UIDefaults.ProxyLazyValue
UIManager
UIManager.LookAndFeelInfo
ViewportLayout
Enums
DropMode
GroupLayout.Alignment
JTable.PrintMode
LayoutStyle.ComponentPlacement
RowFilter.ComparisonType
SortOrder
SwingWorker.StateValue
Exceptions
UnsupportedLookAndFeelException


 javax.swing.border
Interfaces
Border
Classes
AbstractBorder
BevelBorder
CompoundBorder
EmptyBorder
EtchedBorder
LineBorder
MatteBorder
SoftBevelBorder
TitledBorder


 javax.swing.colorchooser
Interfaces
ColorSelectionModel
Classes
AbstractColorChooserPanel
ColorChooserComponentFactory
DefaultColorSelectionModel


 javax.swing.event
Interfaces
AncestorListener
CaretListener
CellEditorListener
ChangeListener
DocumentEvent
DocumentEvent.ElementChange
DocumentListener
HyperlinkListener
InternalFrameListener
ListDataListener
ListSelectionListener
MenuDragMouseListener
MenuKeyListener
MenuListener
MouseInputListener
PopupMenuListener
RowSorterListener
TableColumnModelListener
TableModelListener
TreeExpansionListener
TreeModelListener
TreeSelectionListener
TreeWillExpandListener
UndoableEditListener
Classes
AncestorEvent
CaretEvent
ChangeEvent
DocumentEvent.EventType
EventListenerList
HyperlinkEvent
HyperlinkEvent.EventType
InternalFrameAdapter
InternalFrameEvent
ListDataEvent
ListSelectionEvent
MenuDragMouseEvent
MenuEvent
MenuKeyEvent
MouseInputAdapter
PopupMenuEvent
RowSorterEvent
SwingPropertyChangeSupport
TableColumnModelEvent
TableModelEvent
TreeExpansionEvent
TreeModelEvent
TreeSelectionEvent
UndoableEditEvent
Enums
RowSorterEvent.Type


 javax.swing.filechooser
Classes
FileFilter
FileNameExtensionFilter
FileSystemView
FileView


 javax.swing.plaf
Interfaces
UIResource
Classes
ActionMapUIResource
BorderUIResource
BorderUIResource.BevelBorderUIResource
BorderUIResource.CompoundBorderUIResource
BorderUIResource.EmptyBorderUIResource
BorderUIResource.EtchedBorderUIResource
BorderUIResource.LineBorderUIResource
BorderUIResource.MatteBorderUIResource
BorderUIResource.TitledBorderUIResource
ButtonUI
ColorChooserUI
ColorUIResource
ComboBoxUI
ComponentInputMapUIResource
ComponentUI
DesktopIconUI
DesktopPaneUI
DimensionUIResource
FileChooserUI
FontUIResource
IconUIResource
InputMapUIResource
InsetsUIResource
InternalFrameUI
LabelUI
ListUI
MenuBarUI
MenuItemUI
OptionPaneUI
PanelUI
PopupMenuUI
ProgressBarUI
RootPaneUI
ScrollBarUI
ScrollPaneUI
SeparatorUI
SliderUI
SpinnerUI
SplitPaneUI
TabbedPaneUI
TableHeaderUI
TableUI
TextUI
ToolBarUI
ToolTipUI
TreeUI
ViewportUI


 javax.swing.plaf.basic
Interfaces
ComboPopup
Classes
BasicArrowButton
BasicBorders
BasicBorders.ButtonBorder
BasicBorders.FieldBorder
BasicBorders.MarginBorder
BasicBorders.MenuBarBorder
BasicBorders.RadioButtonBorder
BasicBorders.RolloverButtonBorder
BasicBorders.SplitPaneBorder
BasicBorders.ToggleButtonBorder
BasicButtonListener
BasicButtonUI
BasicCheckBoxMenuItemUI
BasicCheckBoxUI
BasicColorChooserUI
BasicComboBoxEditor
BasicComboBoxEditor.UIResource
BasicComboBoxRenderer
BasicComboBoxRenderer.UIResource
BasicComboBoxUI
BasicComboPopup
BasicDesktopIconUI
BasicDesktopPaneUI
BasicDirectoryModel
BasicEditorPaneUI
BasicFileChooserUI
BasicFormattedTextFieldUI
BasicGraphicsUtils
BasicHTML
BasicIconFactory
BasicInternalFrameTitlePane
BasicInternalFrameUI
BasicLabelUI
BasicListUI
BasicLookAndFeel
BasicMenuBarUI
BasicMenuItemUI
BasicMenuUI
BasicOptionPaneUI
BasicOptionPaneUI.ButtonAreaLayout
BasicPanelUI
BasicPasswordFieldUI
BasicPopupMenuSeparatorUI
BasicPopupMenuUI
BasicProgressBarUI
BasicRadioButtonMenuItemUI
BasicRadioButtonUI
BasicRootPaneUI
BasicScrollBarUI
BasicScrollPaneUI
BasicSeparatorUI
BasicSliderUI
BasicSpinnerUI
BasicSplitPaneDivider
BasicSplitPaneUI
BasicTabbedPaneUI
BasicTableHeaderUI
BasicTableUI
BasicTextAreaUI
BasicTextFieldUI
BasicTextPaneUI
BasicTextUI
BasicTextUI.BasicCaret
BasicTextUI.BasicHighlighter
BasicToggleButtonUI
BasicToolBarSeparatorUI
BasicToolBarUI
BasicToolTipUI
BasicTreeUI
BasicViewportUI
DefaultMenuLayout


 javax.swing.plaf.metal
Classes
DefaultMetalTheme
MetalBorders
MetalBorders.ButtonBorder
MetalBorders.Flush3DBorder
MetalBorders.InternalFrameBorder
MetalBorders.MenuBarBorder
MetalBorders.MenuItemBorder
MetalBorders.OptionDialogBorder
MetalBorders.PaletteBorder
MetalBorders.PopupMenuBorder
MetalBorders.RolloverButtonBorder
MetalBorders.ScrollPaneBorder
MetalBorders.TableHeaderBorder
MetalBorders.TextFieldBorder
MetalBorders.ToggleButtonBorder
MetalBorders.ToolBarBorder
MetalButtonUI
MetalCheckBoxIcon
MetalCheckBoxUI
MetalComboBoxButton
MetalComboBoxEditor
MetalComboBoxEditor.UIResource
MetalComboBoxIcon
MetalComboBoxUI
MetalDesktopIconUI
MetalFileChooserUI
MetalIconFactory
MetalIconFactory.FileIcon16
MetalIconFactory.FolderIcon16
MetalIconFactory.PaletteCloseIcon
MetalIconFactory.TreeControlIcon
MetalIconFactory.TreeFolderIcon
MetalIconFactory.TreeLeafIcon
MetalInternalFrameTitlePane
MetalInternalFrameUI
MetalLabelUI
MetalLookAndFeel
MetalMenuBarUI
MetalPopupMenuSeparatorUI
MetalProgressBarUI
MetalRadioButtonUI
MetalRootPaneUI
MetalScrollBarUI
MetalScrollButton
MetalScrollPaneUI
MetalSeparatorUI
MetalSliderUI
MetalSplitPaneUI
MetalTabbedPaneUI
MetalTextFieldUI
MetalTheme
MetalToggleButtonUI
MetalToolBarUI
MetalToolTipUI
MetalTreeUI
OceanTheme


 javax.swing.plaf.multi
Classes
MultiButtonUI
MultiColorChooserUI
MultiComboBoxUI
MultiDesktopIconUI
MultiDesktopPaneUI
MultiFileChooserUI
MultiInternalFrameUI
MultiLabelUI
MultiListUI
MultiLookAndFeel
MultiMenuBarUI
MultiMenuItemUI
MultiOptionPaneUI
MultiPanelUI
MultiPopupMenuUI
MultiProgressBarUI
MultiRootPaneUI
MultiScrollBarUI
MultiScrollPaneUI
MultiSeparatorUI
MultiSliderUI
MultiSpinnerUI
MultiSplitPaneUI
MultiTabbedPaneUI
MultiTableHeaderUI
MultiTableUI
MultiTextUI
MultiToolBarUI
MultiToolTipUI
MultiTreeUI
MultiViewportUI


 javax.swing.plaf.synth
Interfaces
SynthConstants
Classes
ColorType
Region
SynthContext
SynthGraphicsUtils
SynthLookAndFeel
SynthPainter
SynthStyle
SynthStyleFactory


 javax.swing.table
Interfaces
TableCellEditor
TableCellRenderer
TableColumnModel
TableModel
Classes
AbstractTableModel
DefaultTableCellRenderer
DefaultTableCellRenderer.UIResource
DefaultTableColumnModel
DefaultTableModel
JTableHeader
TableColumn
TableRowSorter
TableStringConverter


 javax.swing.text
Interfaces
AbstractDocument.AttributeContext
AbstractDocument.Content
AttributeSet
AttributeSet.CharacterAttribute
AttributeSet.ColorAttribute
AttributeSet.FontAttribute
AttributeSet.ParagraphAttribute
Caret
Document
Element
Highlighter
Highlighter.Highlight
Highlighter.HighlightPainter
Keymap
MutableAttributeSet
Position
Style
StyledDocument
TabableView
TabExpander
ViewFactory
Classes
AbstractDocument
AbstractDocument.ElementEdit
AbstractWriter
AsyncBoxView
BoxView
ComponentView
CompositeView
DateFormatter
DefaultCaret
DefaultEditorKit
DefaultEditorKit.BeepAction
DefaultEditorKit.CopyAction
DefaultEditorKit.CutAction
DefaultEditorKit.DefaultKeyTypedAction
DefaultEditorKit.InsertBreakAction
DefaultEditorKit.InsertContentAction
DefaultEditorKit.InsertTabAction
DefaultEditorKit.PasteAction
DefaultFormatter
DefaultFormatterFactory
DefaultHighlighter
DefaultHighlighter.DefaultHighlightPainter
DefaultStyledDocument
DefaultStyledDocument.AttributeUndoableEdit
DefaultStyledDocument.ElementSpec
DefaultTextUI
DocumentFilter
DocumentFilter.FilterBypass
EditorKit
ElementIterator
FieldView
FlowView
FlowView.FlowStrategy
GapContent
GlyphView
GlyphView.GlyphPainter
IconView
InternationalFormatter
JTextComponent
JTextComponent.DropLocation
JTextComponent.KeyBinding
LabelView
LayeredHighlighter
LayeredHighlighter.LayerPainter
LayoutQueue
MaskFormatter
NavigationFilter
NavigationFilter.FilterBypass
NumberFormatter
ParagraphView
PasswordView
PlainDocument
PlainView
Position.Bias
Segment
SimpleAttributeSet
StringContent
StyleConstants
StyleConstants.CharacterConstants
StyleConstants.ColorConstants
StyleConstants.FontConstants
StyleConstants.ParagraphConstants
StyleContext
StyledEditorKit
StyledEditorKit.AlignmentAction
StyledEditorKit.BoldAction
StyledEditorKit.FontFamilyAction
StyledEditorKit.FontSizeAction
StyledEditorKit.ForegroundAction
StyledEditorKit.ItalicAction
StyledEditorKit.StyledTextAction
StyledEditorKit.UnderlineAction
TableView
TabSet
TabStop
TextAction
Utilities
View
WrappedPlainView
ZoneView
Exceptions
BadLocationException
ChangedCharSetException


 javax.swing.text.html
Classes
BlockView
CSS
CSS.Attribute
FormSubmitEvent
FormView
HTML
HTML.Attribute
HTML.Tag
HTML.UnknownTag
HTMLDocument
HTMLDocument.Iterator
HTMLEditorKit
HTMLEditorKit.HTMLFactory
HTMLEditorKit.HTMLTextAction
HTMLEditorKit.InsertHTMLTextAction
HTMLEditorKit.LinkController
HTMLEditorKit.Parser
HTMLEditorKit.ParserCallback
HTMLFrameHyperlinkEvent
HTMLWriter
ImageView
InlineView
ListView
MinimalHTMLWriter
ObjectView
Option
ParagraphView
StyleSheet
StyleSheet.BoxPainter
StyleSheet.ListPainter
Enums
FormSubmitEvent.MethodType


 javax.swing.text.html.parser
Interfaces
DTDConstants
Classes
AttributeList
ContentModel
DocumentParser
DTD
Element
Entity
Parser
ParserDelegator
TagElement


 javax.swing.text.rtf
Classes
RTFEditorKit


 javax.swing.tree
Interfaces
MutableTreeNode
RowMapper
TreeCellEditor
TreeCellRenderer
TreeModel
TreeNode
TreeSelectionModel
Classes
AbstractLayoutCache
AbstractLayoutCache.NodeDimensions
DefaultMutableTreeNode
DefaultTreeCellEditor
DefaultTreeCellRenderer
DefaultTreeModel
DefaultTreeSelectionModel
FixedHeightLayoutCache
TreePath
VariableHeightLayoutCache
Exceptions
ExpandVetoException


 javax.swing.undo
Interfaces
StateEditable
UndoableEdit
Classes
AbstractUndoableEdit
CompoundEdit
StateEdit
UndoableEditSupport
UndoManager
Exceptions
CannotRedoException
CannotUndoException


 javax.tools
Interfaces
Diagnostic
DiagnosticListener
FileObject
JavaCompiler
JavaCompiler.CompilationTask
JavaFileManager
JavaFileManager.Location
JavaFileObject
OptionChecker
StandardJavaFileManager
Tool
Classes
DiagnosticCollector
ForwardingFileObject
ForwardingJavaFileManager
ForwardingJavaFileObject
SimpleJavaFileObject
ToolProvider
Enums
Diagnostic.Kind
JavaFileObject.Kind
StandardLocation


 javax.transaction
Exceptions
InvalidTransactionException
TransactionRequiredException
TransactionRolledbackException


 javax.transaction.xa
Interfaces
XAResource
Xid
Exceptions
XAException


 javax.xml
Classes
XMLConstants


 javax.xml.bind
Interfaces
DatatypeConverterInterface
Element
Marshaller
NotIdentifiableEvent
ParseConversionEvent
PrintConversionEvent
Unmarshaller
UnmarshallerHandler
ValidationEvent
ValidationEventHandler
ValidationEventLocator
Validator
Classes
Binder
DatatypeConverter
JAXBContext
JAXBElement
JAXBElement.GlobalScope
JAXBIntrospector
Marshaller.Listener
SchemaOutputResolver
Unmarshaller.Listener
Exceptions
JAXBException
MarshalException
PropertyException
TypeConstraintException
UnmarshalException
ValidationException


 javax.xml.bind.annotation
Interfaces
DomHandler
Classes
W3CDomHandler
XmlElement.DEFAULT
XmlElementDecl.GLOBAL
XmlElementRef.DEFAULT
XmlSchemaType.DEFAULT
XmlType.DEFAULT
Enums
XmlAccessOrder
XmlAccessType
XmlNsForm
Annotation Types
XmlAccessorOrder
XmlAccessorType
XmlAnyAttribute
XmlAnyElement
XmlAttachmentRef
XmlAttribute
XmlElement
XmlElementDecl
XmlElementRef
XmlElementRefs
XmlElements
XmlElementWrapper
XmlEnum
XmlEnumValue
XmlID
XmlIDREF
XmlInlineBinaryData
XmlList
XmlMimeType
XmlMixed
XmlNs
XmlRegistry
XmlRootElement
XmlSchema
XmlSchemaType
XmlSchemaTypes
XmlTransient
XmlType
XmlValue


 javax.xml.bind.annotation.adapters
Classes
CollapsedStringAdapter
HexBinaryAdapter
NormalizedStringAdapter
XmlAdapter
XmlJavaTypeAdapter.DEFAULT
Annotation Types
XmlJavaTypeAdapter
XmlJavaTypeAdapters


 javax.xml.bind.attachment
Classes
AttachmentMarshaller
AttachmentUnmarshaller


 javax.xml.bind.helpers
Classes
AbstractMarshallerImpl
AbstractUnmarshallerImpl
DefaultValidationEventHandler
NotIdentifiableEventImpl
ParseConversionEventImpl
PrintConversionEventImpl
ValidationEventImpl
ValidationEventLocatorImpl


 javax.xml.bind.util
Classes
JAXBResult
JAXBSource
ValidationEventCollector


 javax.xml.crypto
Interfaces
AlgorithmMethod
Data
KeySelectorResult
NodeSetData
URIDereferencer
URIReference
XMLCryptoContext
XMLStructure
Classes
KeySelector
KeySelector.Purpose
OctetStreamData
Exceptions
KeySelectorException
MarshalException
NoSuchMechanismException
URIReferenceException


 javax.xml.crypto.dom
Interfaces
DOMURIReference
Classes
DOMCryptoContext
DOMStructure


 javax.xml.crypto.dsig
Interfaces
CanonicalizationMethod
DigestMethod
Manifest
Reference
SignatureMethod
SignatureProperties
SignatureProperty
SignedInfo
Transform
XMLObject
XMLSignature
XMLSignature.SignatureValue
XMLSignContext
XMLValidateContext
Classes
TransformService
XMLSignatureFactory
Exceptions
TransformException
XMLSignatureException


 javax.xml.crypto.dsig.dom
Classes
DOMSignContext
DOMValidateContext


 javax.xml.crypto.dsig.keyinfo
Interfaces
KeyInfo
KeyName
KeyValue
PGPData
RetrievalMethod
X509Data
X509IssuerSerial
Classes
KeyInfoFactory


 javax.xml.crypto.dsig.spec
Interfaces
C14NMethodParameterSpec
DigestMethodParameterSpec
SignatureMethodParameterSpec
TransformParameterSpec
Classes
ExcC14NParameterSpec
HMACParameterSpec
XPathFilter2ParameterSpec
XPathFilterParameterSpec
XPathType
XPathType.Filter
XSLTTransformParameterSpec


 javax.xml.datatype
Classes
DatatypeConstants
DatatypeConstants.Field
DatatypeFactory
Duration
XMLGregorianCalendar
Exceptions
DatatypeConfigurationException


 javax.xml.namespace
Interfaces
NamespaceContext
Classes
QName


 javax.xml.parsers
Classes
DocumentBuilder
DocumentBuilderFactory
SAXParser
SAXParserFactory
Exceptions
ParserConfigurationException
Errors
FactoryConfigurationError


 javax.xml.soap
Interfaces
Detail
DetailEntry
Name
Node
SOAPBody
SOAPBodyElement
SOAPConstants
SOAPElement
SOAPEnvelope
SOAPFault
SOAPFaultElement
SOAPHeader
SOAPHeaderElement
Text
Classes
AttachmentPart
MessageFactory
MimeHeader
MimeHeaders
SAAJMetaFactory
SAAJResult
SOAPConnection
SOAPConnectionFactory
SOAPElementFactory
SOAPFactory
SOAPMessage
SOAPPart
Exceptions
SOAPException


 javax.xml.stream
Interfaces
EventFilter
Location
StreamFilter
XMLEventReader
XMLEventWriter
XMLReporter
XMLResolver
XMLStreamConstants
XMLStreamReader
XMLStreamWriter
Classes
XMLEventFactory
XMLInputFactory
XMLOutputFactory
Exceptions
XMLStreamException
Errors
FactoryConfigurationError


 javax.xml.stream.events
Interfaces
Attribute
Characters
Comment
DTD
EndDocument
EndElement
EntityDeclaration
EntityReference
Namespace
NotationDeclaration
ProcessingInstruction
StartDocument
StartElement
XMLEvent


 javax.xml.stream.util
Interfaces
XMLEventAllocator
XMLEventConsumer
Classes
EventReaderDelegate
StreamReaderDelegate


 javax.xml.transform
Interfaces
ErrorListener
Result
Source
SourceLocator
Templates
URIResolver
Classes
OutputKeys
Transformer
TransformerFactory
Exceptions
TransformerConfigurationException
TransformerException
Errors
TransformerFactoryConfigurationError


 javax.xml.transform.dom
Interfaces
DOMLocator
Classes
DOMResult
DOMSource


 javax.xml.transform.sax
Interfaces
TemplatesHandler
TransformerHandler
Classes
SAXResult
SAXSource
SAXTransformerFactory


 javax.xml.transform.stax
Classes
StAXResult
StAXSource


 javax.xml.transform.stream
Classes
StreamResult
StreamSource


 javax.xml.validation
Classes
Schema
SchemaFactory
SchemaFactoryLoader
TypeInfoProvider
Validator
ValidatorHandler


 javax.xml.ws
Interfaces
AsyncHandler
Binding
BindingProvider
Dispatch
LogicalMessage
Provider
Response
WebServiceContext
Classes
Endpoint
Holder
Service
WebServicePermission
Enums
Service.Mode
Exceptions
ProtocolException
WebServiceException
Annotation Types
BindingType
RequestWrapper
ResponseWrapper
ServiceMode
WebEndpoint
WebFault
WebServiceClient
WebServiceProvider
WebServiceRef
WebServiceRefs


 javax.xml.ws.handler
Interfaces
Handler
HandlerResolver
LogicalHandler
LogicalMessageContext
MessageContext
PortInfo
Enums
MessageContext.Scope


 javax.xml.ws.handler.soap
Interfaces
SOAPHandler
SOAPMessageContext


 javax.xml.ws.http
Interfaces
HTTPBinding
Exceptions
HTTPException


 javax.xml.ws.soap
Interfaces
SOAPBinding
Exceptions
SOAPFaultException


 javax.xml.ws.spi
Classes
Provider
ServiceDelegate


 javax.xml.xpath
Interfaces
XPath
XPathExpression
XPathFunction
XPathFunctionResolver
XPathVariableResolver
Classes
XPathConstants
XPathFactory
Exceptions
XPathException
XPathExpressionException
XPathFactoryConfigurationException
XPathFunctionException


 org.ietf.jgss
Interfaces
GSSContext
GSSCredential
GSSName
Classes
ChannelBinding
GSSManager
MessageProp
Oid
Exceptions
GSSException


 org.omg.CORBA
Interfaces
ARG_IN
ARG_INOUT
ARG_OUT
BAD_POLICY
BAD_POLICY_TYPE
BAD_POLICY_VALUE
CTX_RESTRICT_SCOPE
Current
CurrentOperations
CustomMarshal
DataInputStream
DataOutputStream
DomainManager
DomainManagerOperations
DynAny
DynArray
DynEnum
DynFixed
DynSequence
DynStruct
DynUnion
DynValue
IDLType
IDLTypeOperations
IRObject
IRObjectOperations
Object
OMGVMCID
Policy
PolicyOperations
PRIVATE_MEMBER
PUBLIC_MEMBER
UNSUPPORTED_POLICY
UNSUPPORTED_POLICY_VALUE
VM_ABSTRACT
VM_CUSTOM
VM_NONE
VM_TRUNCATABLE
Classes
_IDLTypeStub
_PolicyStub
Any
AnyHolder
AnySeqHelper
AnySeqHolder
BooleanHolder
BooleanSeqHelper
BooleanSeqHolder
ByteHolder
CharHolder
CharSeqHelper
CharSeqHolder
CompletionStatus
CompletionStatusHelper
Context
ContextList
CurrentHelper
CurrentHolder
DefinitionKind
DefinitionKindHelper
DoubleHolder
DoubleSeqHelper
DoubleSeqHolder
DynamicImplementation
Environment
ExceptionList
FieldNameHelper
FixedHolder
FloatHolder
FloatSeqHelper
FloatSeqHolder
IdentifierHelper
IDLTypeHelper
IntHolder
LocalObject
LongHolder
LongLongSeqHelper
LongLongSeqHolder
LongSeqHelper
LongSeqHolder
NamedValue
NameValuePair
NameValuePairHelper
NVList
ObjectHelper
ObjectHolder
OctetSeqHelper
OctetSeqHolder
ORB
ParameterMode
ParameterModeHelper
ParameterModeHolder
PolicyErrorCodeHelper
PolicyErrorHelper
PolicyErrorHolder
PolicyHelper
PolicyHolder
PolicyListHelper
PolicyListHolder
PolicyTypeHelper
Principal
PrincipalHolder
RepositoryIdHelper
Request
ServerRequest
ServiceDetail
ServiceDetailHelper
ServiceInformation
ServiceInformationHelper
ServiceInformationHolder
SetOverrideType
SetOverrideTypeHelper
ShortHolder
ShortSeqHelper
ShortSeqHolder
StringHolder
StringSeqHelper
StringSeqHolder
StringValueHelper
StructMember
StructMemberHelper
TCKind
TypeCode
TypeCodeHolder
ULongLongSeqHelper
ULongLongSeqHolder
ULongSeqHelper
ULongSeqHolder
UnionMember
UnionMemberHelper
UnknownUserExceptionHelper
UnknownUserExceptionHolder
UShortSeqHelper
UShortSeqHolder
ValueBaseHelper
ValueBaseHolder
ValueMember
ValueMemberHelper
VersionSpecHelper
VisibilityHelper
WCharSeqHelper
WCharSeqHolder
WrongTransactionHelper
WrongTransactionHolder
WStringSeqHelper
WStringSeqHolder
WStringValueHelper
Exceptions
ACTIVITY_COMPLETED
ACTIVITY_REQUIRED
BAD_CONTEXT
BAD_INV_ORDER
BAD_OPERATION
BAD_PARAM
BAD_QOS
BAD_TYPECODE
Bounds
CODESET_INCOMPATIBLE
COMM_FAILURE
DATA_CONVERSION
FREE_MEM
IMP_LIMIT
INITIALIZE
INTERNAL
INTF_REPOS
INV_FLAG
INV_IDENT
INV_OBJREF
INV_POLICY
INVALID_ACTIVITY
INVALID_TRANSACTION
MARSHAL
NO_IMPLEMENT
NO_MEMORY
NO_PERMISSION
NO_RESOURCES
NO_RESPONSE
OBJ_ADAPTER
OBJECT_NOT_EXIST
PERSIST_STORE
PolicyError
REBIND
SystemException
TIMEOUT
TRANSACTION_MODE
TRANSACTION_REQUIRED
TRANSACTION_ROLLEDBACK
TRANSACTION_UNAVAILABLE
TRANSIENT
UNKNOWN
UnknownUserException
UserException
WrongTransaction


 org.omg.CORBA.DynAnyPackage
Exceptions
Invalid
InvalidSeq
InvalidValue
TypeMismatch


 org.omg.CORBA.ORBPackage
Exceptions
InconsistentTypeCode
InvalidName


 org.omg.CORBA.portable
Interfaces
BoxedValueHelper
CustomValue
IDLEntity
InvokeHandler
ResponseHandler
Streamable
StreamableValue
ValueBase
ValueFactory
ValueInputStream
ValueOutputStream
Classes
Delegate
InputStream
ObjectImpl
OutputStream
ServantObject
Exceptions
ApplicationException
IndirectionException
RemarshalException
UnknownException


 org.omg.CORBA.TypeCodePackage
Exceptions
BadKind
Bounds


 org.omg.CORBA_2_3
Classes
ORB


 org.omg.CORBA_2_3.portable
Classes
Delegate
InputStream
ObjectImpl
OutputStream


 org.omg.CosNaming
Interfaces
BindingIterator
BindingIteratorOperations
NamingContext
NamingContextExt
NamingContextExtOperations
NamingContextOperations
Classes
_BindingIteratorImplBase
_BindingIteratorStub
_NamingContextExtStub
_NamingContextImplBase
_NamingContextStub
Binding
BindingHelper
BindingHolder
BindingIteratorHelper
BindingIteratorHolder
BindingIteratorPOA
BindingListHelper
BindingListHolder
BindingType
BindingTypeHelper
BindingTypeHolder
IstringHelper
NameComponent
NameComponentHelper
NameComponentHolder
NameHelper
NameHolder
NamingContextExtHelper
NamingContextExtHolder
NamingContextExtPOA
NamingContextHelper
NamingContextHolder
NamingContextPOA


 org.omg.CosNaming.NamingContextExtPackage
Classes
AddressHelper
InvalidAddressHelper
InvalidAddressHolder
StringNameHelper
URLStringHelper
Exceptions
InvalidAddress


 org.omg.CosNaming.NamingContextPackage
Classes
AlreadyBoundHelper
AlreadyBoundHolder
CannotProceedHelper
CannotProceedHolder
InvalidNameHelper
InvalidNameHolder
NotEmptyHelper
NotEmptyHolder
NotFoundHelper
NotFoundHolder
NotFoundReason
NotFoundReasonHelper
NotFoundReasonHolder
Exceptions
AlreadyBound
CannotProceed
InvalidName
NotEmpty
NotFound


 org.omg.Dynamic
Classes
Parameter


 org.omg.DynamicAny
Interfaces
DynAny
DynAnyFactory
DynAnyFactoryOperations
DynAnyOperations
DynArray
DynArrayOperations
DynEnum
DynEnumOperations
DynFixed
DynFixedOperations
DynSequence
DynSequenceOperations
DynStruct
DynStructOperations
DynUnion
DynUnionOperations
DynValue
DynValueBox
DynValueBoxOperations
DynValueCommon
DynValueCommonOperations
DynValueOperations
Classes
_DynAnyFactoryStub
_DynAnyStub
_DynArrayStub
_DynEnumStub
_DynFixedStub
_DynSequenceStub
_DynStructStub
_DynUnionStub
_DynValueStub
AnySeqHelper
DynAnyFactoryHelper
DynAnyHelper
DynAnySeqHelper
DynArrayHelper
DynEnumHelper
DynFixedHelper
DynSequenceHelper
DynStructHelper
DynUnionHelper
DynValueHelper
FieldNameHelper
NameDynAnyPair
NameDynAnyPairHelper
NameDynAnyPairSeqHelper
NameValuePair
NameValuePairHelper
NameValuePairSeqHelper


 org.omg.DynamicAny.DynAnyFactoryPackage
Classes
InconsistentTypeCodeHelper
Exceptions
InconsistentTypeCode


 org.omg.DynamicAny.DynAnyPackage
Classes
InvalidValueHelper
TypeMismatchHelper
Exceptions
InvalidValue
TypeMismatch


 org.omg.IOP
Interfaces
Codec
CodecFactory
CodecFactoryOperations
CodecOperations
CodeSets
ENCODING_CDR_ENCAPS
ExceptionDetailMessage
RMICustomMaxStreamFormat
TAG_ALTERNATE_IIOP_ADDRESS
TAG_CODE_SETS
TAG_INTERNET_IOP
TAG_JAVA_CODEBASE
TAG_MULTIPLE_COMPONENTS
TAG_ORB_TYPE
TAG_POLICIES
TAG_RMI_CUSTOM_MAX_STREAM_FORMAT
TransactionService
Classes
CodecFactoryHelper
ComponentIdHelper
Encoding
IOR
IORHelper
IORHolder
MultipleComponentProfileHelper
MultipleComponentProfileHolder
ProfileIdHelper
ServiceContext
ServiceContextHelper
ServiceContextHolder
ServiceContextListHelper
ServiceContextListHolder
ServiceIdHelper
TaggedComponent
TaggedComponentHelper
TaggedComponentHolder
TaggedProfile
TaggedProfileHelper
TaggedProfileHolder


 org.omg.IOP.CodecFactoryPackage
Classes
UnknownEncodingHelper
Exceptions
UnknownEncoding


 org.omg.IOP.CodecPackage
Classes
FormatMismatchHelper
InvalidTypeForEncodingHelper
TypeMismatchHelper
Exceptions
FormatMismatch
InvalidTypeForEncoding
TypeMismatch


 org.omg.Messaging
Interfaces
SYNC_WITH_TRANSPORT
Classes
SyncScopeHelper


 org.omg.PortableInterceptor
Interfaces
ACTIVE
ClientRequestInfo
ClientRequestInfoOperations
ClientRequestInterceptor
ClientRequestInterceptorOperations
Current
CurrentOperations
DISCARDING
HOLDING
INACTIVE
Interceptor
InterceptorOperations
IORInfo
IORInfoOperations
IORInterceptor
IORInterceptor_3_0
IORInterceptor_3_0Operations
IORInterceptorOperations
LOCATION_FORWARD
NON_EXISTENT
ObjectReferenceFactory
ObjectReferenceTemplate
ORBInitializer
ORBInitializerOperations
ORBInitInfo
ORBInitInfoOperations
PolicyFactory
PolicyFactoryOperations
RequestInfo
RequestInfoOperations
ServerRequestInfo
ServerRequestInfoOperations
ServerRequestInterceptor
ServerRequestInterceptorOperations
SUCCESSFUL
SYSTEM_EXCEPTION
TRANSPORT_RETRY
UNKNOWN
USER_EXCEPTION
Classes
AdapterManagerIdHelper
AdapterNameHelper
AdapterStateHelper
CurrentHelper
ForwardRequestHelper
InvalidSlotHelper
IORInterceptor_3_0Helper
IORInterceptor_3_0Holder
ObjectIdHelper
ObjectReferenceFactoryHelper
ObjectReferenceFactoryHolder
ObjectReferenceTemplateHelper
ObjectReferenceTemplateHolder
ObjectReferenceTemplateSeqHelper
ObjectReferenceTemplateSeqHolder
ORBIdHelper
ServerIdHelper
Exceptions
ForwardRequest
InvalidSlot


 org.omg.PortableInterceptor.ORBInitInfoPackage
Classes
DuplicateNameHelper
InvalidNameHelper
ObjectIdHelper
Exceptions
DuplicateName
InvalidName


 org.omg.PortableServer
Interfaces
AdapterActivator
AdapterActivatorOperations
Current
CurrentOperations
ID_ASSIGNMENT_POLICY_ID
ID_UNIQUENESS_POLICY_ID
IdAssignmentPolicy
IdAssignmentPolicyOperations
IdUniquenessPolicy
IdUniquenessPolicyOperations
IMPLICIT_ACTIVATION_POLICY_ID
ImplicitActivationPolicy
ImplicitActivationPolicyOperations
LIFESPAN_POLICY_ID
LifespanPolicy
LifespanPolicyOperations
POA
POAManager
POAManagerOperations
POAOperations
REQUEST_PROCESSING_POLICY_ID
RequestProcessingPolicy
RequestProcessingPolicyOperations
SERVANT_RETENTION_POLICY_ID
ServantActivator
ServantActivatorOperations
ServantLocator
ServantLocatorOperations
ServantManager
ServantManagerOperations
ServantRetentionPolicy
ServantRetentionPolicyOperations
THREAD_POLICY_ID
ThreadPolicy
ThreadPolicyOperations
Classes
_ServantActivatorStub
_ServantLocatorStub
CurrentHelper
DynamicImplementation
ForwardRequestHelper
IdAssignmentPolicyValue
IdUniquenessPolicyValue
ImplicitActivationPolicyValue
LifespanPolicyValue
POAHelper
RequestProcessingPolicyValue
Servant
ServantActivatorHelper
ServantActivatorPOA
ServantLocatorHelper
ServantLocatorPOA
ServantRetentionPolicyValue
ThreadPolicyValue
Exceptions
ForwardRequest


 org.omg.PortableServer.CurrentPackage
Classes
NoContextHelper
Exceptions
NoContext


 org.omg.PortableServer.POAManagerPackage
Classes
AdapterInactiveHelper
State
Exceptions
AdapterInactive


 org.omg.PortableServer.POAPackage
Classes
AdapterAlreadyExistsHelper
AdapterNonExistentHelper
InvalidPolicyHelper
NoServantHelper
ObjectAlreadyActiveHelper
ObjectNotActiveHelper
ServantAlreadyActiveHelper
ServantNotActiveHelper
WrongAdapterHelper
WrongPolicyHelper
Exceptions
AdapterAlreadyExists
AdapterNonExistent
InvalidPolicy
NoServant
ObjectAlreadyActive
ObjectNotActive
ServantAlreadyActive
ServantNotActive
WrongAdapter
WrongPolicy


 org.omg.PortableServer.portable
Interfaces
Delegate


 org.omg.PortableServer.ServantLocatorPackage
Classes
CookieHolder


 org.omg.SendingContext
Interfaces
RunTime
RunTimeOperations


_Remote_Stub

Overview Package Class Use Tree Deprecated Index Help
Java™ Platform
Standard Ed. 6
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

org.omg.stub.java.rmi
Class _Remote_Stub

java.lang.Object
    extended by  org.omg.CORBA.portable.ObjectImpl
        extended by  org.omg.CORBA_2_3.portable.ObjectImpl
            extended by  javax.rmi.CORBA.Stub
                extended by  org.omg.stub.java.rmi._Remote_Stub
All Implemented Interfaces:
Serializable, Remote, Object
public final class _Remote_Stub
extends Stub
implements Remote

This class provides the Stub for the Remote Type. The class is generated by the rmic compiler, and is still under works at OMG. It's contents are subject to change without notice as the specification evolves.

Constructor Summary
_Remote_Stub()
Method Summary
 String[] _ids()
Returns an array of repository ids that an object implements.
Methods inherited from class javax.rmi.CORBA.Stub
connect, equals, hashCode, toString
Methods inherited from class org.omg.CORBA_2_3.portable.ObjectImpl
_get_codebase
Methods inherited from class org.omg.CORBA.portable.ObjectImpl
_create_request, _create_request, _duplicate, _get_delegate, _get_domain_managers, _get_interface_def, _get_policy, _hash, _invoke, _is_a, _is_equivalent, _is_local, _non_existent, _orb, _release, _releaseReply, _request, _request, _servant_postinvoke, _servant_preinvoke, _set_delegate, _set_policy_override
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

_Remote_Stub

public _Remote_Stub()
Method Detail

_ids

public String[] _ids()
Returns an array of repository ids that an object implements. The string at index zero represents the most derived interface. The last id, for the generic CORBA object is (i.e., IDL:omg.org/CORBA/Object:1.0") is implied and not present.

Specified by:
_ids in class ObjectImpl
Returns:
an array of repository ids that an object implements.
Overview Package Class Use Tree Deprecated Index Help
Java™ Platform
Standard Ed. 6
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD
Submit a bug or feature
For further API reference and developer documentation, see Java SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Copyright 2006 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.


 org.omg.stub.java.rmi
Classes
_Remote_Stub


 org.w3c.dom
Interfaces
Attr
CDATASection
CharacterData
Comment
Document
DocumentFragment
DocumentType
DOMConfiguration
DOMError
DOMErrorHandler
DOMImplementation
DOMImplementationList
DOMImplementationSource
DOMLocator
DOMStringList
Element
Entity
EntityReference
NamedNodeMap
NameList
Node
NodeList
Notation
ProcessingInstruction
Text
TypeInfo
UserDataHandler
Exceptions
DOMException


 org.w3c.dom.bootstrap
Classes
DOMImplementationRegistry


 org.w3c.dom.events
Interfaces
DocumentEvent
Event
EventListener
EventTarget
MouseEvent
MutationEvent
UIEvent
Exceptions
EventException


 org.w3c.dom.ls
Interfaces
DOMImplementationLS
LSInput
LSLoadEvent
LSOutput
LSParser
LSParserFilter
LSProgressEvent
LSResourceResolver
LSSerializer
LSSerializerFilter
Exceptions
LSException


 org.xml.sax
Interfaces
AttributeList
Attributes
ContentHandler
DocumentHandler
DTDHandler
EntityResolver
ErrorHandler
Locator
Parser
XMLFilter
XMLReader
Classes
HandlerBase
InputSource
Exceptions
SAXException
SAXNotRecognizedException
SAXNotSupportedException
SAXParseException


 org.xml.sax.ext
Interfaces
Attributes2
DeclHandler
EntityResolver2
LexicalHandler
Locator2
Classes
Attributes2Impl
DefaultHandler2
Locator2Impl


 org.xml.sax.helpers
Classes
AttributeListImpl
AttributesImpl
DefaultHandler
LocatorImpl
NamespaceSupport
ParserAdapter
ParserFactory
XMLFilterImpl
XMLReaderAdapter
XMLReaderFactory


Occurences of 1 - Introduction

1 - Introduction occurences:
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction
1 - Introduction


Occurences of 1 Introduction

1 Introduction occurences:
1 Introduction
1 Introduction


Occurences of 10 - RMI Wire Protocol

10 - RMI Wire Protocol occurences:
10 - RMI Wire Protocol
10 - RMI Wire Protocol
10 - RMI Wire Protocol
10 - RMI Wire Protocol
10 - RMI Wire Protocol
10 - RMI Wire Protocol
10 - RMI Wire Protocol


Occurences of 2 - Attributes

2 - Attributes occurences:
2 - Attributes
2 - Attributes
2 - Attributes
2 - Attributes
2 - Attributes
2 - Attributes
2 - Attributes


Occurences of 2 - Distributed Object Model

2 - Distributed Object Model occurences:
2 - Distributed Object Model
2 - Distributed Object Model
2 - Distributed Object Model
2 - Distributed Object Model
2 - Distributed Object Model
2 - Distributed Object Model
2 - Distributed Object Model
2 - Distributed Object Model


Occurences of 2 - Goals

2 - Goals occurences:
2 - Goals
2 - Goals


Occurences of 3 - RMI System Overview

3 - RMI System Overview occurences:
3 - RMI System Overview
3 - RMI System Overview
3 - RMI System Overview
3 - RMI System Overview
3 - RMI System Overview
3 - RMI System Overview


Occurences of 3 - Specifying Document Types

3 - Specifying Document Types occurences:
3 - Specifying Document Types
3 - Specifying Document Types
3 - Specifying Document Types
3 - Specifying Document Types
3 - Specifying Document Types


Occurences of 3 - Writing Image I/O Applications

3 - Writing Image I/O Applications occurences:
3 - Writing Image I/O Applications
3 - Writing Image I/O Applications
3 - Writing Image I/O Applications
3 - Writing Image I/O Applications
3 - Writing Image I/O Applications
3 - Writing Image I/O Applications
3 - Writing Image I/O Applications
3 - Writing Image I/O Applications


Occurences of 4 - Client Interfaces

4 - Client Interfaces occurences:
4 - Client Interfaces
4 - Client Interfaces
4 - Client Interfaces
4 - Client Interfaces


Occurences of 4 - Printing and Streaming Documents

4 - Printing and Streaming Documents occurences:
4 - Printing and Streaming Documents
4 - Printing and Streaming Documents
4 - Printing and Streaming Documents
4 - Printing and Streaming Documents
4 - Printing and Streaming Documents
4 - Printing and Streaming Documents
4 - Printing and Streaming Documents
4 - Printing and Streaming Documents


Occurences of 4 - Writing Image I/O Plug-ins

4 - Writing Image I/O Plug-ins occurences:
4 - Writing Image I/O Plug-ins
4 - Writing Image I/O Plug-ins
4 - Writing Image I/O Plug-ins
4 - Writing Image I/O Plug-ins
4 - Writing Image I/O Plug-ins
4 - Writing Image I/O Plug-ins


Occurences of 5 - Printing and Streaming 2D Graphics

5 - Printing and Streaming 2D Graphics occurences:
5 - Printing and Streaming 2D Graphics
5 - Printing and Streaming 2D Graphics
5 - Printing and Streaming 2D Graphics


Occurences of 5 - Server Interfaces

5 - Server Interfaces occurences:
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces
5 - Server Interfaces


Occurences of 6 - Registry Interfaces

6 - Registry Interfaces occurences:
6 - Registry Interfaces
6 - Registry Interfaces
6 - Registry Interfaces
6 - Registry Interfaces


Occurences of 7 - Remote Object Activation

7 - Remote Object Activation occurences:
7 - Remote Object Activation
7 - Remote Object Activation
7 - Remote Object Activation
7 - Remote Object Activation
7 - Remote Object Activation


Occurences of 8 - Stub/Skeleton Interfaces

8 - Stub/Skeleton Interfaces occurences:
8 - Stub/Skeleton Interfaces
8 - Stub/Skeleton Interfaces
8 - Stub/Skeleton Interfaces
8 - Stub/Skeleton Interfaces
8 - Stub/Skeleton Interfaces
8 - Stub/Skeleton Interfaces
8 - Stub/Skeleton Interfaces


Occurences of 9 - Garbage Collector Interfaces

9 - Garbage Collector Interfaces occurences:
9 - Garbage Collector Interfaces
9 - Garbage Collector Interfaces
9 - Garbage Collector Interfaces
9 - Garbage Collector Interfaces
9 - Garbage Collector Interfaces
9 - Garbage Collector Interfaces


Occurences of A

A occurences:
java.awt.A
javax.print.attribute.standard.A
javax.print.attribute.standard.A
javax.swing.text.html.A


Occurences of A0

A0 occurences:
java.awt.A0
javax.print.attribute.standard.A0


Occurences of A1

A1 occurences:
java.awt.A1
javax.print.attribute.standard.A1


Occurences of A10

A10 occurences:
java.awt.A10
javax.print.attribute.standard.A10


Occurences of A2

A2 occurences:
java.awt.A2
javax.print.attribute.standard.A2


Occurences of A3

A3 occurences:
java.awt.A3
javax.print.attribute.standard.A3


Occurences of A4

A4 occurences:
java.awt.A4
javax.print.attribute.standard.A4


Occurences of A5

A5 occurences:
java.awt.A5
javax.print.attribute.standard.A5


Occurences of A6

A6 occurences:
java.awt.A6
javax.print.attribute.standard.A6


Occurences of A7

A7 occurences:
java.awt.A7
javax.print.attribute.standard.A7


Occurences of A8

A8 occurences:
java.awt.A8
javax.print.attribute.standard.A8


Occurences of A9

A9 occurences:
java.awt.A9
javax.print.attribute.standard.A9


Occurences of abort

abort occurences:
java.net.CacheRequest.abort()
javax.imageio.ImageReader.abort()
javax.imageio.ImageWriter.abort()
javax.security.auth.spi.LoginModule.abort()
org.w3c.dom.ls.LSParser.abort()


Occurences of ABORTED

ABORTED occurences:
java.awt.ABORTED
javax.print.attribute.standard.ABORTED


Occurences of abortRequested

abortRequested occurences:
javax.imageio.ImageReader.abortRequested()
javax.imageio.ImageWriter.abortRequested()


Occurences of abs

abs occurences:
java.lang.Math.abs(double)
java.lang.Math.abs(float)
java.lang.Math.abs(int)
java.lang.Math.abs(long)
java.lang.StrictMath.abs(double)
java.lang.StrictMath.abs(float)
java.lang.StrictMath.abs(int)
java.lang.StrictMath.abs(long)
java.math.BigDecimal.abs()
java.math.BigDecimal.abs(java.math.MathContext)
java.math.BigInteger.abs()


Occurences of AbsentInformationException (constructors)

AbsentInformationException (constructors) occurences:
com.sun.jdi.AbsentInformationException()
com.sun.jdi.AbsentInformationException(java.lang.String)


Occurences of absolutePath

absolutePath occurences:
java.util.prefs.AbstractPreferences.absolutePath()
java.util.prefs.Preferences.absolutePath()


Occurences of ABSTRACT

ABSTRACT occurences:
com.sun.mirror.declaration.ABSTRACT
java.lang.reflect.ABSTRACT
javax.lang.model.element.ABSTRACT


Occurences of AbstractAction (constructors)

AbstractAction (constructors) occurences:
javax.swing.AbstractAction()
javax.swing.AbstractAction(java.lang.String)
javax.swing.AbstractAction(java.lang.String, javax.swing.Icon)


Occurences of AbstractDocument (constructors)

AbstractDocument (constructors) occurences:
javax.swing.text.AbstractDocument(javax.swing.text.AbstractDocument.Content)
javax.swing.text.AbstractDocument(javax.swing.text.AbstractDocument.Content, javax.swing.text.AbstractDocument.AttributeContext)


Occurences of AbstractMap.SimpleEntry (constructors)

AbstractMap.SimpleEntry (constructors) occurences:
java.util.AbstractMap.SimpleEntry(java.lang.Object,java.lang.Object)
java.util.AbstractMap.SimpleEntry(java.util.Map.Entry)
java.util.AbstractMap.SimpleEntry(K, V)


Occurences of AbstractMap.SimpleImmutableEntry (constructors)

AbstractMap.SimpleImmutableEntry (constructors) occurences:
java.util.AbstractMap.SimpleImmutableEntry(java.lang.Object,java.lang.Object)
java.util.AbstractMap.SimpleImmutableEntry(java.util.Map.Entry)
java.util.AbstractMap.SimpleImmutableEntry(K, V)


Occurences of AbstractMethodError (constructors)

AbstractMethodError (constructors) occurences:
java.lang.AbstractMethodError()
java.lang.AbstractMethodError(java.lang.String)


Occurences of AbstractScriptEngine (constructors)

AbstractScriptEngine (constructors) occurences:
javax.script.AbstractScriptEngine()
javax.script.AbstractScriptEngine(javax.script.Bindings)


Occurences of AbstractWriter (constructors)

AbstractWriter (constructors) occurences:
javax.swing.text.AbstractWriter(java.io.Writer, javax.swing.text.Document)
javax.swing.text.AbstractWriter(java.io.Writer, javax.swing.text.Document, int, int)
javax.swing.text.AbstractWriter(java.io.Writer, javax.swing.text.Element)
javax.swing.text.AbstractWriter(java.io.Writer, javax.swing.text.Element, int, int)


Occurences of accept

accept occurences:
com.sun.jdi.connect.ListeningConnector.accept(java.util.Map)
com.sun.jdi.connect.spi.TransportService.accept(com.sun.jdi.connect.spi.TransportService.ListenKey, long, long)
com.sun.mirror.declaration.Declaration.accept(com.sun.mirror.util.DeclarationVisitor)
com.sun.mirror.type.TypeMirror.accept(com.sun.mirror.util.TypeVisitor)
com.sun.source.tree.Tree.accept(com.sun.source.tree.TreeVisitor, D)
com.sun.source.tree.Tree.accept(com.sun.source.tree.TreeVisitor,java.lang.Object)
java.awt.ContainerOrderFocusTraversalPolicy.accept(java.awt.Component)
java.awt.DefaultFocusTraversalPolicy.accept(java.awt.Component)
java.io.FileFilter.accept(java.io.File)
java.io.FilenameFilter.accept(java.io.File, java.lang.String)
java.net.ServerSocket.accept()
java.net.SocketImpl.accept(java.net.SocketImpl)
java.nio.channels.ServerSocketChannel.accept()
javax.lang.model.element.AnnotationValue.accept(javax.lang.model.element.AnnotationValueVisitor, P)
javax.lang.model.element.AnnotationValue.accept(javax.lang.model.element.AnnotationValueVisitor,java.lang.Object)
javax.lang.model.element.Element.accept(javax.lang.model.element.ElementVisitor, P)
javax.lang.model.element.Element.accept(javax.lang.model.element.ElementVisitor,java.lang.Object)
javax.lang.model.type.TypeMirror.accept(javax.lang.model.type.TypeVisitor, P)
javax.lang.model.type.TypeMirror.accept(javax.lang.model.type.TypeVisitor,java.lang.Object)
javax.swing.filechooser.FileFilter.accept(java.io.File)
javax.swing.filechooser.FileNameExtensionFilter.accept(java.io.File)
javax.swing.JFileChooser.accept(java.io.File)
javax.swing.LayoutFocusTraversalPolicy.accept(java.awt.Component)
javax.swing.plaf.basic.BasicFileChooserUI.AcceptAllFileFilter.accept(java.io.File)
javax.swing.SortingFocusTraversalPolicy.accept(java.awt.Component)
javax.xml.stream.EventFilter.accept(javax.xml.stream.events.XMLEvent)
javax.xml.stream.StreamFilter.accept(javax.xml.stream.XMLStreamReader)


Occurences of acceptChanges

acceptChanges occurences:
javax.sql.rowset.CachedRowSet.acceptChanges()
javax.sql.rowset.CachedRowSet.acceptChanges(java.sql.Connection)


Occurences of acceptDrag

acceptDrag occurences:
java.awt.dnd.DropTargetContext.acceptDrag(int)
java.awt.dnd.DropTargetDragEvent.acceptDrag(int)


Occurences of acceptDrop

acceptDrop occurences:
java.awt.dnd.DropTargetContext.acceptDrop(int)
java.awt.dnd.DropTargetDropEvent.acceptDrop(int)


Occurences of acceptSecContext

acceptSecContext occurences:
org.ietf.jgss.GSSContext.acceptSecContext(byte[], int, int)
org.ietf.jgss.GSSContext.acceptSecContext(java.io.InputStream, java.io.OutputStream)


Occurences of AccessControlContext (constructors)

AccessControlContext (constructors) occurences:
java.security.AccessControlContext(java.security.AccessControlContext, java.security.DomainCombiner)
java.security.AccessControlContext(java.security.ProtectionDomain[])


Occurences of AccessControlException (constructors)

AccessControlException (constructors) occurences:
java.security.AccessControlException(java.lang.String)
java.security.AccessControlException(java.lang.String, java.security.Permission)


Occurences of AccessException (constructors)

AccessException (constructors) occurences:
java.rmi.AccessException(java.lang.String)
java.rmi.AccessException(java.lang.String, java.lang.Exception)


Occurences of Accessibility - New Features

Accessibility - New Features occurences:
Accessibility - New Features
Accessibility - New Features


Occurences of Accessible

Accessible occurences:
com.sun.jdi.Accessible
javax.accessibility.Accessible


Occurences of accessibleContainerHandler

accessibleContainerHandler occurences:
java.awt.accessibleContainerHandler
javax.swing.accessibleContainerHandler


Occurences of accessibleContext

accessibleContext occurences:
javax.swing.accessibleContext
javax.swing.accessibleContext
javax.swing.accessibleContext
javax.swing.accessibleContext
javax.swing.accessibleContext
javax.swing.accessibleContext
javax.swing.accessibleContext
javax.swing.accessibleContext
javax.swing.accessibleContext


Occurences of AccessibleRelation (constructors)

AccessibleRelation (constructors) occurences:
javax.accessibility.AccessibleRelation(java.lang.String)
javax.accessibility.AccessibleRelation(java.lang.String, java.lang.Object)
javax.accessibility.AccessibleRelation(java.lang.String, java.lang.Object[])


Occurences of AccessibleRelationSet (constructors)

AccessibleRelationSet (constructors) occurences:
javax.accessibility.AccessibleRelationSet()
javax.accessibility.AccessibleRelationSet(javax.accessibility.AccessibleRelation[])


Occurences of AccessibleStateSet (constructors)

AccessibleStateSet (constructors) occurences:
javax.accessibility.AccessibleStateSet()
javax.accessibility.AccessibleStateSet(javax.accessibility.AccessibleState[])


Occurences of AccountException (constructors)

AccountException (constructors) occurences:
javax.security.auth.login.AccountException()
javax.security.auth.login.AccountException(java.lang.String)


Occurences of AccountExpiredException (constructors)

AccountExpiredException (constructors) occurences:
javax.security.auth.login.AccountExpiredException()
javax.security.auth.login.AccountExpiredException(java.lang.String)


Occurences of AccountLockedException (constructors)

AccountLockedException (constructors) occurences:
javax.security.auth.login.AccountLockedException()
javax.security.auth.login.AccountLockedException(java.lang.String)


Occurences of AccountNotFoundException (constructors)

AccountNotFoundException (constructors) occurences:
javax.security.auth.login.AccountNotFoundException()
javax.security.auth.login.AccountNotFoundException(java.lang.String)


Occurences of Acknowledgments

Acknowledgments occurences:
Acknowledgments
Acknowledgments


Occurences of acos

acos occurences:
java.lang.Math.acos(double)
java.lang.StrictMath.acos(double)


Occurences of acquire

acquire occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.acquire(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(int)
java.util.concurrent.Semaphore.acquire()
java.util.concurrent.Semaphore.acquire(int)


Occurences of acquireInterruptibly

acquireInterruptibly occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.acquireInterruptibly(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(int)


Occurences of acquireShared

acquireShared occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.acquireShared(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireShared(int)


Occurences of acquireSharedInterruptibly

acquireSharedInterruptibly occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.acquireSharedInterruptibly(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(int)


Occurences of acquireUninterruptibly

acquireUninterruptibly occurences:
java.util.concurrent.Semaphore.acquireUninterruptibly()
java.util.concurrent.Semaphore.acquireUninterruptibly(int)


Occurences of action

action occurences:
java.awt.Component.action(java.awt.Event, java.lang.Object)
javax.jws.WebMethod.action()


Occurences of ACTION

ACTION occurences:
javax.management.ACTION
javax.swing.text.html.ACTION


Occurences of actionCommand

actionCommand occurences:
javax.swing.actionCommand
javax.swing.actionCommand


Occurences of ActionEvent (constructors)

ActionEvent (constructors) occurences:
java.awt.event.ActionEvent(java.lang.Object, int, java.lang.String)
java.awt.event.ActionEvent(java.lang.Object, int, java.lang.String, int)
java.awt.event.ActionEvent(java.lang.Object, int, java.lang.String, long, int)


Occurences of actionPerformed

actionPerformed occurences:
java.awt.AWTEventMulticaster.actionPerformed(java.awt.event.ActionEvent)
java.awt.dnd.DropTarget.DropTargetAutoScroller.actionPerformed(java.awt.event.ActionEvent)
java.awt.event.ActionListener.actionPerformed(java.awt.event.ActionEvent)
java.awt.List.AccessibleAWTList.actionPerformed(java.awt.event.ActionEvent)
javax.swing.DefaultCellEditor.EditorDelegate.actionPerformed(java.awt.event.ActionEvent)
javax.swing.JComboBox.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicDesktopPaneUI.CloseAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicDesktopPaneUI.MaximizeAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicDesktopPaneUI.MinimizeAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicDesktopPaneUI.NavigateAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicDesktopPaneUI.OpenAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicFileChooserUI.ApproveSelectionAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicFileChooserUI.CancelSelectionAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicFileChooserUI.ChangeToParentDirectoryAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicFileChooserUI.GoHomeAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicFileChooserUI.NewFolderAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicFileChooserUI.UpdateAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.CloseAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.IconifyAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.MaximizeAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.MoveAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.RestoreAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.SizeAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicOptionPaneUI.ButtonActionListener.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicScrollBarUI.ScrollListener.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicSliderUI.ActionScroller.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicSliderUI.ScrollListener.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicSplitPaneUI.KeyboardDownRightHandler.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicSplitPaneUI.KeyboardEndHandler.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicSplitPaneUI.KeyboardHomeHandler.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicSplitPaneUI.KeyboardResizeToggleHandler.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicSplitPaneUI.KeyboardUpLeftHandler.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicTreeUI.ComponentHandler.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeCancelEditingAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeHomeAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeIncrementAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreePageAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeToggleAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeTraverseAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.plaf.metal.MetalFileChooserUI.DirectoryComboBoxAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.DefaultEditorKit.BeepAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.DefaultEditorKit.CopyAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.DefaultEditorKit.CutAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.DefaultEditorKit.DefaultKeyTypedAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.DefaultEditorKit.InsertBreakAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.DefaultEditorKit.InsertContentAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.DefaultEditorKit.InsertTabAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.DefaultEditorKit.PasteAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.html.FormView.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.html.HTMLEditorKit.InsertHTMLTextAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.StyledEditorKit.AlignmentAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.StyledEditorKit.BoldAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.StyledEditorKit.FontFamilyAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.StyledEditorKit.FontSizeAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.StyledEditorKit.ForegroundAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.StyledEditorKit.ItalicAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.text.StyledEditorKit.UnderlineAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.ToolTipManager.insideTimerAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.ToolTipManager.outsideTimerAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.ToolTipManager.stillInsideTimerAction.actionPerformed(java.awt.event.ActionEvent)
javax.swing.tree.DefaultTreeCellEditor.actionPerformed(java.awt.event.ActionEvent)


Occurences of actionPropertyChanged

actionPropertyChanged occurences:
javax.swing.AbstractButton.actionPropertyChanged(javax.swing.Action, java.lang.String)
javax.swing.JComboBox.actionPropertyChanged(javax.swing.Action, java.lang.String)
javax.swing.JMenuItem.actionPropertyChanged(javax.swing.Action, java.lang.String)
javax.swing.JTextField.actionPropertyChanged(javax.swing.Action, java.lang.String)


Occurences of Activatable (constructors)

Activatable (constructors) occurences:
java.rmi.activation.Activatable(java.lang.String, java.rmi.MarshalledObject, boolean, int)
java.rmi.activation.Activatable(java.lang.String, java.rmi.MarshalledObject, boolean, int, java.rmi.server.RMIClientSocketFactory, java.rmi.server.RMIServerSocketFactory)
java.rmi.activation.Activatable(java.rmi.activation.ActivationID, int)
java.rmi.activation.Activatable(java.rmi.activation.ActivationID, int, java.rmi.server.RMIClientSocketFactory, java.rmi.server.RMIServerSocketFactory)


Occurences of activate

activate occurences:
java.awt.im.spi.InputMethod.activate()
java.beans.AppletInitializer.activate(java.applet.Applet)
java.rmi.activation.ActivationID.activate(boolean)
java.rmi.activation.Activator.activate(java.rmi.activation.ActivationID, boolean)
javax.imageio.IIOParamController.activate(javax.imageio.IIOParam)
javax.imageio.metadata.IIOMetadataController.activate(javax.imageio.metadata.IIOMetadata)
org.omg.PortableServer.POAManagerOperations.activate()


Occurences of activateController

activateController occurences:
javax.imageio.IIOParam.activateController()
javax.imageio.metadata.IIOMetadata.activateController()


Occurences of ActivateFailedException (constructors)

ActivateFailedException (constructors) occurences:
java.rmi.activation.ActivateFailedException(java.lang.String)
java.rmi.activation.ActivateFailedException(java.lang.String, java.lang.Exception)


Occurences of activateFrame

activateFrame occurences:
javax.swing.DefaultDesktopManager.activateFrame(javax.swing.JInternalFrame)
javax.swing.DesktopManager.activateFrame(javax.swing.JInternalFrame)
javax.swing.plaf.basic.BasicInternalFrameUI.activateFrame(javax.swing.JInternalFrame)


Occurences of activation

activation occurences:
java.rmi.activation
javax.activation


Occurences of ActivationDataFlavor (constructors)

ActivationDataFlavor (constructors) occurences:
javax.activation.ActivationDataFlavor(java.lang.Class, java.lang.String)
javax.activation.ActivationDataFlavor(java.lang.Class, java.lang.String, java.lang.String)
javax.activation.ActivationDataFlavor(java.lang.String, java.lang.String)


Occurences of ActivationDesc (constructors)

ActivationDesc (constructors) occurences:
java.rmi.activation.ActivationDesc(java.lang.String, java.lang.String, java.rmi.MarshalledObject)
java.rmi.activation.ActivationDesc(java.lang.String, java.lang.String, java.rmi.MarshalledObject, boolean)
java.rmi.activation.ActivationDesc(java.rmi.activation.ActivationGroupID, java.lang.String, java.lang.String, java.rmi.MarshalledObject)
java.rmi.activation.ActivationDesc(java.rmi.activation.ActivationGroupID, java.lang.String, java.lang.String, java.rmi.MarshalledObject, boolean)


Occurences of ActivationException (constructors)

ActivationException (constructors) occurences:
java.rmi.activation.ActivationException()
java.rmi.activation.ActivationException(java.lang.String)
java.rmi.activation.ActivationException(java.lang.String, java.lang.Throwable)


Occurences of ActivationGroupDesc (constructors)

ActivationGroupDesc (constructors) occurences:
java.rmi.activation.ActivationGroupDesc(java.lang.String, java.lang.String, java.rmi.MarshalledObject, java.util.Properties, java.rmi.activation.ActivationGroupDesc.CommandEnvironment)
java.rmi.activation.ActivationGroupDesc(java.util.Properties, java.rmi.activation.ActivationGroupDesc.CommandEnvironment)


Occurences of ACTIVE

ACTIVE occurences:
javax.accessibility.ACTIVE
org.omg.PortableInterceptor.ACTIVE
org.omg.PortableServer.POAManagerPackage.ACTIVE


Occurences of activeCount

activeCount occurences:
java.lang.Thread.activeCount()
java.lang.ThreadGroup.activeCount()


Occurences of activeObject

activeObject occurences:
java.rmi.activation.ActivationGroup.activeObject(java.rmi.activation.ActivationID, java.rmi.MarshalledObject)
java.rmi.activation.ActivationGroup.activeObject(java.rmi.activation.ActivationID, java.rmi.Remote)
java.rmi.activation.ActivationMonitor.activeObject(java.rmi.activation.ActivationID, java.rmi.MarshalledObject)


Occurences of ActivityCompletedException (constructors)

ActivityCompletedException (constructors) occurences:
javax.activity.ActivityCompletedException()
javax.activity.ActivityCompletedException(java.lang.String)
javax.activity.ActivityCompletedException(java.lang.String, java.lang.Throwable)
javax.activity.ActivityCompletedException(java.lang.Throwable)


Occurences of ActivityRequiredException (constructors)

ActivityRequiredException (constructors) occurences:
javax.activity.ActivityRequiredException()
javax.activity.ActivityRequiredException(java.lang.String)
javax.activity.ActivityRequiredException(java.lang.String, java.lang.Throwable)
javax.activity.ActivityRequiredException(java.lang.Throwable)


Occurences of ACTIVITY_COMPLETED (constructors)

ACTIVITY_COMPLETED (constructors) occurences:
org.omg.CORBA.ACTIVITY_COMPLETED()
org.omg.CORBA.ACTIVITY_COMPLETED(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.ACTIVITY_COMPLETED(java.lang.String)
org.omg.CORBA.ACTIVITY_COMPLETED(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of ACTIVITY_REQUIRED (constructors)

ACTIVITY_REQUIRED (constructors) occurences:
org.omg.CORBA.ACTIVITY_REQUIRED()
org.omg.CORBA.ACTIVITY_REQUIRED(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.ACTIVITY_REQUIRED(java.lang.String)
org.omg.CORBA.ACTIVITY_REQUIRED(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of AdapterAlreadyExists (constructors)

AdapterAlreadyExists (constructors) occurences:
org.omg.PortableServer.POAPackage.AdapterAlreadyExists()
org.omg.PortableServer.POAPackage.AdapterAlreadyExists(java.lang.String)


Occurences of AdapterInactive (constructors)

AdapterInactive (constructors) occurences:
org.omg.PortableServer.POAManagerPackage.AdapterInactive()
org.omg.PortableServer.POAManagerPackage.AdapterInactive(java.lang.String)


Occurences of AdapterNonExistent (constructors)

AdapterNonExistent (constructors) occurences:
org.omg.PortableServer.POAPackage.AdapterNonExistent()
org.omg.PortableServer.POAPackage.AdapterNonExistent(java.lang.String)


Occurences of adapter_name

adapter_name occurences:
org.omg.PortableInterceptor.ObjectReferenceTemplate.adapter_name()
org.omg.PortableInterceptor.ServerRequestInfoOperations.adapter_name()


Occurences of add

add occurences:
java.awt.AWTEventMulticaster.add(java.awt.event.ActionListener, java.awt.event.ActionListener)
java.awt.AWTEventMulticaster.add(java.awt.event.AdjustmentListener, java.awt.event.AdjustmentListener)
java.awt.AWTEventMulticaster.add(java.awt.event.ComponentListener, java.awt.event.ComponentListener)
java.awt.AWTEventMulticaster.add(java.awt.event.ContainerListener, java.awt.event.ContainerListener)
java.awt.AWTEventMulticaster.add(java.awt.event.FocusListener, java.awt.event.FocusListener)
java.awt.AWTEventMulticaster.add(java.awt.event.HierarchyBoundsListener, java.awt.event.HierarchyBoundsListener)
java.awt.AWTEventMulticaster.add(java.awt.event.HierarchyListener, java.awt.event.HierarchyListener)
java.awt.AWTEventMulticaster.add(java.awt.event.InputMethodListener, java.awt.event.InputMethodListener)
java.awt.AWTEventMulticaster.add(java.awt.event.ItemListener, java.awt.event.ItemListener)
java.awt.AWTEventMulticaster.add(java.awt.event.KeyListener, java.awt.event.KeyListener)
java.awt.AWTEventMulticaster.add(java.awt.event.MouseListener, java.awt.event.MouseListener)
java.awt.AWTEventMulticaster.add(java.awt.event.MouseMotionListener, java.awt.event.MouseMotionListener)
java.awt.AWTEventMulticaster.add(java.awt.event.MouseWheelListener, java.awt.event.MouseWheelListener)
java.awt.AWTEventMulticaster.add(java.awt.event.TextListener, java.awt.event.TextListener)
java.awt.AWTEventMulticaster.add(java.awt.event.WindowFocusListener, java.awt.event.WindowFocusListener)
java.awt.AWTEventMulticaster.add(java.awt.event.WindowListener, java.awt.event.WindowListener)
java.awt.AWTEventMulticaster.add(java.awt.event.WindowStateListener, java.awt.event.WindowStateListener)
java.awt.Choice.add(java.lang.String)
java.awt.Component.add(java.awt.PopupMenu)
java.awt.Container.add(java.awt.Component)
java.awt.Container.add(java.awt.Component, int)
java.awt.Container.add(java.awt.Component, java.lang.Object)
java.awt.Container.add(java.awt.Component, java.lang.Object, int)
java.awt.Container.add(java.lang.String, java.awt.Component)
java.awt.geom.Area.add(java.awt.geom.Area)
java.awt.geom.Rectangle2D.add(double, double)
java.awt.geom.Rectangle2D.add(java.awt.geom.Point2D)
java.awt.geom.Rectangle2D.add(java.awt.geom.Rectangle2D)
java.awt.image.renderable.ParameterBlock.add(byte)
java.awt.image.renderable.ParameterBlock.add(char)
java.awt.image.renderable.ParameterBlock.add(double)
java.awt.image.renderable.ParameterBlock.add(float)
java.awt.image.renderable.ParameterBlock.add(int)
java.awt.image.renderable.ParameterBlock.add(java.lang.Object)
java.awt.image.renderable.ParameterBlock.add(long)
java.awt.image.renderable.ParameterBlock.add(short)
java.awt.List.add(java.lang.String)
java.awt.List.add(java.lang.String, int)
java.awt.Menu.add(java.awt.MenuItem)
java.awt.Menu.add(java.lang.String)
java.awt.MenuBar.add(java.awt.Menu)
java.awt.Rectangle.add(int, int)
java.awt.Rectangle.add(java.awt.Point)
java.awt.Rectangle.add(java.awt.Rectangle)
java.awt.RenderingHints.add(java.awt.RenderingHints)
java.awt.SystemTray.add(java.awt.TrayIcon)
java.beans.beancontext.BeanContextSupport.add(java.lang.Object)
java.math.BigDecimal.add(java.math.BigDecimal)
java.math.BigDecimal.add(java.math.BigDecimal, java.math.MathContext)
java.math.BigInteger.add(java.math.BigInteger)
java.net.CookieStore.add(java.net.URI, java.net.HttpCookie)
java.security.PermissionCollection.add(java.security.Permission)
java.security.Permissions.add(java.security.Permission)
java.util.AbstractCollection.add(E)
java.util.AbstractCollection.add(java.lang.Object)
java.util.AbstractList.add(E)
java.util.AbstractList.add(int, E)
java.util.AbstractList.add(int,java.lang.Object)
java.util.AbstractList.add(java.lang.Object)
java.util.AbstractQueue.add(E)
java.util.AbstractQueue.add(java.lang.Object)
java.util.AbstractSequentialList.add(int, E)
java.util.AbstractSequentialList.add(int,java.lang.Object)
java.util.ArrayDeque.add(E)
java.util.ArrayDeque.add(java.lang.Object)
java.util.ArrayList.add(E)
java.util.ArrayList.add(int, E)
java.util.ArrayList.add(int,java.lang.Object)
java.util.ArrayList.add(java.lang.Object)
java.util.Calendar.add(int, int)
java.util.Collection.add(E)
java.util.Collection.add(java.lang.Object)
java.util.concurrent.ArrayBlockingQueue.add(E)
java.util.concurrent.ArrayBlockingQueue.add(java.lang.Object)
java.util.concurrent.BlockingDeque.add(E)
java.util.concurrent.BlockingDeque.add(java.lang.Object)
java.util.concurrent.BlockingQueue.add(E)
java.util.concurrent.BlockingQueue.add(java.lang.Object)
java.util.concurrent.ConcurrentLinkedQueue.add(E)
java.util.concurrent.ConcurrentLinkedQueue.add(java.lang.Object)
java.util.concurrent.ConcurrentSkipListSet.add(E)
java.util.concurrent.ConcurrentSkipListSet.add(java.lang.Object)
java.util.concurrent.CopyOnWriteArrayList.add(E)
java.util.concurrent.CopyOnWriteArrayList.add(int, E)
java.util.concurrent.CopyOnWriteArrayList.add(int,java.lang.Object)
java.util.concurrent.CopyOnWriteArrayList.add(java.lang.Object)
java.util.concurrent.CopyOnWriteArraySet.add(E)
java.util.concurrent.CopyOnWriteArraySet.add(java.lang.Object)
java.util.concurrent.DelayQueue.add(E)
java.util.concurrent.DelayQueue.add(java.util.concurrent.Delayed)
java.util.concurrent.LinkedBlockingDeque.add(E)
java.util.concurrent.LinkedBlockingDeque.add(java.lang.Object)
java.util.concurrent.PriorityBlockingQueue.add(E)
java.util.concurrent.PriorityBlockingQueue.add(java.lang.Object)
java.util.Deque.add(E)
java.util.Deque.add(java.lang.Object)
java.util.GregorianCalendar.add(int, int)
java.util.HashSet.add(E)
java.util.HashSet.add(java.lang.Object)
java.util.LinkedList.add(E)
java.util.LinkedList.add(int, E)
java.util.LinkedList.add(int,java.lang.Object)
java.util.LinkedList.add(java.lang.Object)
java.util.List.add(E)
java.util.List.add(int, E)
java.util.List.add(int,java.lang.Object)
java.util.List.add(java.lang.Object)
java.util.ListIterator.add(E)
java.util.ListIterator.add(java.lang.Object)
java.util.PriorityQueue.add(E)
java.util.PriorityQueue.add(java.lang.Object)
java.util.Queue.add(E)
java.util.Queue.add(java.lang.Object)
java.util.Set.add(E)
java.util.Set.add(java.lang.Object)
java.util.TreeSet.add(E)
java.util.TreeSet.add(java.lang.Object)
java.util.Vector.add(E)
java.util.Vector.add(int, E)
java.util.Vector.add(int,java.lang.Object)
java.util.Vector.add(java.lang.Object)
javax.accessibility.AccessibleRelationSet.add(javax.accessibility.AccessibleRelation)
javax.accessibility.AccessibleStateSet.add(javax.accessibility.AccessibleState)
javax.management.AttributeList.add(int, java.lang.Object)
javax.management.AttributeList.add(int, javax.management.Attribute)
javax.management.AttributeList.add(java.lang.Object)
javax.management.AttributeList.add(javax.management.Attribute)
javax.management.relation.RoleList.add(int, java.lang.Object)
javax.management.relation.RoleList.add(int, javax.management.relation.Role)
javax.management.relation.RoleList.add(java.lang.Object)
javax.management.relation.RoleList.add(javax.management.relation.Role)
javax.management.relation.RoleUnresolvedList.add(int, java.lang.Object)
javax.management.relation.RoleUnresolvedList.add(int, javax.management.relation.RoleUnresolved)
javax.management.relation.RoleUnresolvedList.add(java.lang.Object)
javax.management.relation.RoleUnresolvedList.add(javax.management.relation.RoleUnresolved)
javax.naming.CompositeName.add(int, java.lang.String)
javax.naming.CompositeName.add(java.lang.String)
javax.naming.CompoundName.add(int, java.lang.String)
javax.naming.CompoundName.add(java.lang.String)
javax.naming.directory.Attribute.add(int, java.lang.Object)
javax.naming.directory.Attribute.add(java.lang.Object)
javax.naming.directory.BasicAttribute.add(int, java.lang.Object)
javax.naming.directory.BasicAttribute.add(java.lang.Object)
javax.naming.ldap.LdapName.add(int, java.lang.String)
javax.naming.ldap.LdapName.add(int, javax.naming.ldap.Rdn)
javax.naming.ldap.LdapName.add(java.lang.String)
javax.naming.ldap.LdapName.add(javax.naming.ldap.Rdn)
javax.naming.Name.add(int, java.lang.String)
javax.naming.Name.add(java.lang.String)
javax.naming.Reference.add(int, javax.naming.RefAddr)
javax.naming.Reference.add(javax.naming.RefAddr)
javax.print.attribute.AttributeSet.add(javax.print.attribute.Attribute)
javax.print.attribute.DocAttributeSet.add(javax.print.attribute.Attribute)
javax.print.attribute.HashAttributeSet.add(javax.print.attribute.Attribute)
javax.print.attribute.PrintJobAttributeSet.add(javax.print.attribute.Attribute)
javax.print.attribute.PrintRequestAttributeSet.add(javax.print.attribute.Attribute)
javax.print.attribute.PrintServiceAttributeSet.add(javax.print.attribute.Attribute)
javax.print.attribute.standard.JobStateReasons.add(javax.print.attribute.standard.JobStateReason)
javax.sound.midi.Track.add(javax.sound.midi.MidiEvent)
javax.swing.ButtonGroup.add(javax.swing.AbstractButton)
javax.swing.DefaultListModel.add(int, java.lang.Object)
javax.swing.event.EventListenerList.add(java.lang.Class, T)
javax.swing.event.EventListenerList.add(java.lang.Class,java.util.EventListener)
javax.swing.JMenu.add(java.awt.Component)
javax.swing.JMenu.add(java.awt.Component, int)
javax.swing.JMenu.add(java.lang.String)
javax.swing.JMenu.add(javax.swing.Action)
javax.swing.JMenu.add(javax.swing.JMenuItem)
javax.swing.JMenuBar.add(javax.swing.JMenu)
javax.swing.JPopupMenu.add(java.lang.String)
javax.swing.JPopupMenu.add(javax.swing.Action)
javax.swing.JPopupMenu.add(javax.swing.JMenuItem)
javax.swing.JTabbedPane.add(java.awt.Component)
javax.swing.JTabbedPane.add(java.awt.Component, int)
javax.swing.JTabbedPane.add(java.awt.Component, java.lang.Object)
javax.swing.JTabbedPane.add(java.awt.Component, java.lang.Object, int)
javax.swing.JTabbedPane.add(java.lang.String, java.awt.Component)
javax.swing.JToolBar.add(javax.swing.Action)
javax.swing.tree.DefaultMutableTreeNode.add(javax.swing.tree.MutableTreeNode)
javax.xml.datatype.Duration.add(javax.xml.datatype.Duration)
javax.xml.datatype.XMLGregorianCalendar.add(javax.xml.datatype.Duration)
javax.xml.stream.util.XMLEventConsumer.add(javax.xml.stream.events.XMLEvent)
javax.xml.stream.XMLEventWriter.add(javax.xml.stream.events.XMLEvent)
javax.xml.stream.XMLEventWriter.add(javax.xml.stream.XMLEventReader)
org.ietf.jgss.GSSCredential.add(org.ietf.jgss.GSSName, int, int, org.ietf.jgss.Oid, int)
org.omg.CORBA.ContextList.add(java.lang.String)
org.omg.CORBA.ExceptionList.add(org.omg.CORBA.TypeCode)
org.omg.CORBA.NVList.add(int)


Occurences of addAccessibleSelection

addAccessibleSelection occurences:
java.awt.List.AccessibleAWTList.addAccessibleSelection(int)
java.awt.MenuComponent.AccessibleAWTMenuComponent.addAccessibleSelection(int)
javax.accessibility.AccessibleSelection.addAccessibleSelection(int)
javax.swing.JComboBox.AccessibleJComboBox.addAccessibleSelection(int)
javax.swing.JList.AccessibleJList.addAccessibleSelection(int)
javax.swing.JMenu.AccessibleJMenu.addAccessibleSelection(int)
javax.swing.JMenuBar.AccessibleJMenuBar.addAccessibleSelection(int)
javax.swing.JTabbedPane.AccessibleJTabbedPane.addAccessibleSelection(int)
javax.swing.JTable.AccessibleJTable.addAccessibleSelection(int)
javax.swing.JTree.AccessibleJTree.addAccessibleSelection(int)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.addAccessibleSelection(int)


Occurences of addActionListener

addActionListener occurences:
java.awt.Button.addActionListener(java.awt.event.ActionListener)
java.awt.List.addActionListener(java.awt.event.ActionListener)
java.awt.MenuItem.addActionListener(java.awt.event.ActionListener)
java.awt.TextField.addActionListener(java.awt.event.ActionListener)
java.awt.TrayIcon.addActionListener(java.awt.event.ActionListener)
javax.swing.AbstractButton.addActionListener(java.awt.event.ActionListener)
javax.swing.ButtonModel.addActionListener(java.awt.event.ActionListener)
javax.swing.ComboBoxEditor.addActionListener(java.awt.event.ActionListener)
javax.swing.DefaultButtonModel.addActionListener(java.awt.event.ActionListener)
javax.swing.JComboBox.addActionListener(java.awt.event.ActionListener)
javax.swing.JFileChooser.addActionListener(java.awt.event.ActionListener)
javax.swing.JTextField.addActionListener(java.awt.event.ActionListener)
javax.swing.plaf.basic.BasicComboBoxEditor.addActionListener(java.awt.event.ActionListener)
javax.swing.Timer.addActionListener(java.awt.event.ActionListener)


Occurences of addAdjustmentListener

addAdjustmentListener occurences:
java.awt.Adjustable.addAdjustmentListener(java.awt.event.AdjustmentListener)
java.awt.Scrollbar.addAdjustmentListener(java.awt.event.AdjustmentListener)
java.awt.ScrollPaneAdjustable.addAdjustmentListener(java.awt.event.AdjustmentListener)
javax.swing.JScrollBar.addAdjustmentListener(java.awt.event.AdjustmentListener)


Occurences of addAll

addAll occurences:
java.beans.beancontext.BeanContextSupport.addAll(java.util.Collection)
java.util.AbstractCollection.addAll(java.util.Collection)
java.util.AbstractList.addAll(int, java.util.Collection)
java.util.AbstractQueue.addAll(java.util.Collection)
java.util.AbstractSequentialList.addAll(int, java.util.Collection)
java.util.ArrayList.addAll(int, java.util.Collection)
java.util.ArrayList.addAll(java.util.Collection)
java.util.Collection.addAll(java.util.Collection)
java.util.Collections.addAll(java.util.Collection, T...)
java.util.Collections.addAll(java.util.Collection,java.lang.Object[])
java.util.concurrent.CopyOnWriteArrayList.addAll(int, java.util.Collection)
java.util.concurrent.CopyOnWriteArrayList.addAll(java.util.Collection)
java.util.concurrent.CopyOnWriteArraySet.addAll(java.util.Collection)
java.util.LinkedList.addAll(int, java.util.Collection)
java.util.LinkedList.addAll(java.util.Collection)
java.util.List.addAll(int, java.util.Collection)
java.util.List.addAll(java.util.Collection)
java.util.Set.addAll(java.util.Collection)
java.util.TreeSet.addAll(java.util.Collection)
java.util.Vector.addAll(int, java.util.Collection)
java.util.Vector.addAll(java.util.Collection)
javax.accessibility.AccessibleRelationSet.addAll(javax.accessibility.AccessibleRelation[])
javax.accessibility.AccessibleStateSet.addAll(javax.accessibility.AccessibleState[])
javax.management.AttributeList.addAll(int, java.util.Collection)
javax.management.AttributeList.addAll(int, javax.management.AttributeList)
javax.management.AttributeList.addAll(java.util.Collection)
javax.management.AttributeList.addAll(javax.management.AttributeList)
javax.management.relation.RoleList.addAll(int, java.util.Collection)
javax.management.relation.RoleList.addAll(int, javax.management.relation.RoleList)
javax.management.relation.RoleList.addAll(java.util.Collection)
javax.management.relation.RoleList.addAll(javax.management.relation.RoleList)
javax.management.relation.RoleUnresolvedList.addAll(int, java.util.Collection)
javax.management.relation.RoleUnresolvedList.addAll(int, javax.management.relation.RoleUnresolvedList)
javax.management.relation.RoleUnresolvedList.addAll(java.util.Collection)
javax.management.relation.RoleUnresolvedList.addAll(javax.management.relation.RoleUnresolvedList)
javax.naming.CompositeName.addAll(int, javax.naming.Name)
javax.naming.CompositeName.addAll(javax.naming.Name)
javax.naming.CompoundName.addAll(int, javax.naming.Name)
javax.naming.CompoundName.addAll(javax.naming.Name)
javax.naming.ldap.LdapName.addAll(int, java.util.List)
javax.naming.ldap.LdapName.addAll(int, javax.naming.Name)
javax.naming.ldap.LdapName.addAll(java.util.List)
javax.naming.ldap.LdapName.addAll(javax.naming.Name)
javax.naming.Name.addAll(int, javax.naming.Name)
javax.naming.Name.addAll(javax.naming.Name)
javax.print.attribute.AttributeSet.addAll(javax.print.attribute.AttributeSet)
javax.print.attribute.DocAttributeSet.addAll(javax.print.attribute.AttributeSet)
javax.print.attribute.HashAttributeSet.addAll(javax.print.attribute.AttributeSet)
javax.print.attribute.PrintJobAttributeSet.addAll(javax.print.attribute.AttributeSet)
javax.print.attribute.PrintRequestAttributeSet.addAll(javax.print.attribute.AttributeSet)
javax.print.attribute.PrintServiceAttributeSet.addAll(javax.print.attribute.AttributeSet)


Occurences of addAndGet

addAndGet occurences:
java.util.concurrent.atomic.AtomicInteger.addAndGet(int)
java.util.concurrent.atomic.AtomicIntegerArray.addAndGet(int, int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.addAndGet(java.lang.Object,int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.addAndGet(T, int)
java.util.concurrent.atomic.AtomicLong.addAndGet(long)
java.util.concurrent.atomic.AtomicLongArray.addAndGet(int, long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.addAndGet(java.lang.Object,long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.addAndGet(T, long)


Occurences of addAttribute

addAttribute occurences:
java.text.AttributedString.addAttribute(java.text.AttributedCharacterIterator.Attribute, java.lang.Object)
java.text.AttributedString.addAttribute(java.text.AttributedCharacterIterator.Attribute, java.lang.Object, int, int)
javax.imageio.metadata.IIOMetadataFormatImpl.addAttribute(java.lang.String, java.lang.String, int, boolean, int, int)
javax.imageio.metadata.IIOMetadataFormatImpl.addAttribute(java.lang.String, java.lang.String, int, boolean, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.addAttribute(java.lang.String, java.lang.String, int, boolean, java.lang.String, java.lang.String, java.lang.String, boolean, boolean)
javax.imageio.metadata.IIOMetadataFormatImpl.addAttribute(java.lang.String, java.lang.String, int, boolean, java.lang.String, java.util.List)
javax.swing.text.AbstractDocument.AbstractElement.addAttribute(java.lang.Object, java.lang.Object)
javax.swing.text.AbstractDocument.AttributeContext.addAttribute(javax.swing.text.AttributeSet, java.lang.Object, java.lang.Object)
javax.swing.text.html.StyleSheet.addAttribute(javax.swing.text.AttributeSet, java.lang.Object, java.lang.Object)
javax.swing.text.MutableAttributeSet.addAttribute(java.lang.Object, java.lang.Object)
javax.swing.text.SimpleAttributeSet.addAttribute(java.lang.Object, java.lang.Object)
javax.swing.text.StyleContext.addAttribute(javax.swing.text.AttributeSet, java.lang.Object, java.lang.Object)
javax.swing.text.StyleContext.NamedStyle.addAttribute(java.lang.Object, java.lang.Object)
javax.xml.soap.SOAPElement.addAttribute(javax.xml.namespace.QName, java.lang.String)
javax.xml.soap.SOAPElement.addAttribute(javax.xml.soap.Name, java.lang.String)
org.xml.sax.ext.Attributes2Impl.addAttribute(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.helpers.AttributeListImpl.addAttribute(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.helpers.AttributesImpl.addAttribute(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)


Occurences of addAttributeChangeNotificationListener

addAttributeChangeNotificationListener occurences:
javax.management.modelmbean.ModelMBeanNotificationBroadcaster.addAttributeChangeNotificationListener(javax.management.NotificationListener, java.lang.String, java.lang.Object)
javax.management.modelmbean.RequiredModelMBean.addAttributeChangeNotificationListener(javax.management.NotificationListener, java.lang.String, java.lang.Object)


Occurences of addAttributes

addAttributes occurences:
java.text.AttributedString.addAttributes(java.util.Map, int, int)
javax.swing.text.AbstractDocument.AbstractElement.addAttributes(javax.swing.text.AttributeSet)
javax.swing.text.AbstractDocument.AttributeContext.addAttributes(javax.swing.text.AttributeSet, javax.swing.text.AttributeSet)
javax.swing.text.html.StyleSheet.addAttributes(javax.swing.text.AttributeSet, javax.swing.text.AttributeSet)
javax.swing.text.MutableAttributeSet.addAttributes(javax.swing.text.AttributeSet)
javax.swing.text.SimpleAttributeSet.addAttributes(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.addAttributes(javax.swing.text.AttributeSet, javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.NamedStyle.addAttributes(javax.swing.text.AttributeSet)


Occurences of addBatch

addBatch occurences:
java.sql.PreparedStatement.addBatch()
java.sql.Statement.addBatch(java.lang.String)


Occurences of addBeanContextMembershipListener

addBeanContextMembershipListener occurences:
java.beans.beancontext.BeanContext.addBeanContextMembershipListener(java.beans.beancontext.BeanContextMembershipListener)
java.beans.beancontext.BeanContextSupport.addBeanContextMembershipListener(java.beans.beancontext.BeanContextMembershipListener)


Occurences of addBeanContextServicesListener

addBeanContextServicesListener occurences:
java.beans.beancontext.BeanContextServices.addBeanContextServicesListener(java.beans.beancontext.BeanContextServicesListener)
java.beans.beancontext.BeanContextServicesSupport.addBeanContextServicesListener(java.beans.beancontext.BeanContextServicesListener)


Occurences of addBodyElement

addBodyElement occurences:
javax.xml.soap.SOAPBody.addBodyElement(javax.xml.namespace.QName)
javax.xml.soap.SOAPBody.addBodyElement(javax.xml.soap.Name)


Occurences of addCellEditorListener

addCellEditorListener occurences:
javax.swing.AbstractCellEditor.addCellEditorListener(javax.swing.event.CellEditorListener)
javax.swing.CellEditor.addCellEditorListener(javax.swing.event.CellEditorListener)
javax.swing.tree.DefaultTreeCellEditor.addCellEditorListener(javax.swing.event.CellEditorListener)


Occurences of addChangeListener

addChangeListener occurences:
javax.swing.AbstractButton.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.AbstractSpinnerModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.BoundedRangeModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.ButtonModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.colorchooser.ColorSelectionModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.colorchooser.DefaultColorSelectionModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.DefaultBoundedRangeModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.DefaultButtonModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.DefaultSingleSelectionModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.JProgressBar.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.JSlider.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.JSpinner.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.JTabbedPane.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.JViewport.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.MenuSelectionManager.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.SingleSelectionModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.SpinnerModel.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.Caret.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.DefaultCaret.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.Style.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.StyleContext.addChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.StyleContext.NamedStyle.addChangeListener(javax.swing.event.ChangeListener)


Occurences of addChildElement

addChildElement occurences:
javax.imageio.metadata.IIOMetadataFormatImpl.addChildElement(java.lang.String, java.lang.String)
javax.xml.soap.SOAPElement.addChildElement(java.lang.String)
javax.xml.soap.SOAPElement.addChildElement(java.lang.String, java.lang.String)
javax.xml.soap.SOAPElement.addChildElement(java.lang.String, java.lang.String, java.lang.String)
javax.xml.soap.SOAPElement.addChildElement(javax.xml.namespace.QName)
javax.xml.soap.SOAPElement.addChildElement(javax.xml.soap.Name)
javax.xml.soap.SOAPElement.addChildElement(javax.xml.soap.SOAPElement)


Occurences of addClassExclusionFilter

addClassExclusionFilter occurences:
com.sun.jdi.request.ClassPrepareRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.ClassUnloadRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.ExceptionRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.MethodEntryRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.MethodExitRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.MonitorContendedEnteredRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.MonitorContendedEnterRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.MonitorWaitedRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.MonitorWaitRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.StepRequest.addClassExclusionFilter(java.lang.String)
com.sun.jdi.request.WatchpointRequest.addClassExclusionFilter(java.lang.String)


Occurences of addClassFilter

addClassFilter occurences:
com.sun.jdi.request.ClassPrepareRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.ClassPrepareRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.ClassUnloadRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.ExceptionRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.ExceptionRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.MethodEntryRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.MethodEntryRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.MethodExitRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.MethodExitRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.MonitorContendedEnteredRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.MonitorContendedEnteredRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.MonitorContendedEnterRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.MonitorContendedEnterRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.MonitorWaitedRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.MonitorWaitedRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.MonitorWaitRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.MonitorWaitRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.StepRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.StepRequest.addClassFilter(java.lang.String)
com.sun.jdi.request.WatchpointRequest.addClassFilter(com.sun.jdi.ReferenceType)
com.sun.jdi.request.WatchpointRequest.addClassFilter(java.lang.String)


Occurences of addColumn

addColumn occurences:
javax.swing.JTable.addColumn(javax.swing.table.TableColumn)
javax.swing.table.DefaultTableColumnModel.addColumn(javax.swing.table.TableColumn)
javax.swing.table.DefaultTableModel.addColumn(java.lang.Object)
javax.swing.table.DefaultTableModel.addColumn(java.lang.Object, java.lang.Object[])
javax.swing.table.DefaultTableModel.addColumn(java.lang.Object, java.util.Vector)
javax.swing.table.TableColumnModel.addColumn(javax.swing.table.TableColumn)


Occurences of addColumnModelListener

addColumnModelListener occurences:
javax.swing.table.DefaultTableColumnModel.addColumnModelListener(javax.swing.event.TableColumnModelListener)
javax.swing.table.TableColumnModel.addColumnModelListener(javax.swing.event.TableColumnModelListener)


Occurences of addComponent

addComponent occurences:
javax.swing.GroupLayout.Group.addComponent(java.awt.Component)
javax.swing.GroupLayout.Group.addComponent(java.awt.Component, int, int, int)
javax.swing.GroupLayout.ParallelGroup.addComponent(java.awt.Component)
javax.swing.GroupLayout.ParallelGroup.addComponent(java.awt.Component, int, int, int)
javax.swing.GroupLayout.ParallelGroup.addComponent(java.awt.Component, javax.swing.GroupLayout.Alignment)
javax.swing.GroupLayout.ParallelGroup.addComponent(java.awt.Component, javax.swing.GroupLayout.Alignment, int, int, int)
javax.swing.GroupLayout.SequentialGroup.addComponent(boolean, java.awt.Component)
javax.swing.GroupLayout.SequentialGroup.addComponent(boolean, java.awt.Component, int, int, int)
javax.swing.GroupLayout.SequentialGroup.addComponent(java.awt.Component)
javax.swing.GroupLayout.SequentialGroup.addComponent(java.awt.Component, int, int, int)


Occurences of addConnectionNotificationListener

addConnectionNotificationListener occurences:
javax.management.remote.JMXConnector.addConnectionNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.remote.rmi.RMIConnector.addConnectionNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)


Occurences of addConsumer

addConsumer occurences:
java.awt.image.FilteredImageSource.addConsumer(java.awt.image.ImageConsumer)
java.awt.image.ImageProducer.addConsumer(java.awt.image.ImageConsumer)
java.awt.image.MemoryImageSource.addConsumer(java.awt.image.ImageConsumer)
java.awt.image.renderable.RenderableImageProducer.addConsumer(java.awt.image.ImageConsumer)


Occurences of addContainerGap

addContainerGap occurences:
javax.swing.GroupLayout.SequentialGroup.addContainerGap()
javax.swing.GroupLayout.SequentialGroup.addContainerGap(int, int)


Occurences of addContent

addContent occurences:
javax.swing.text.html.HTMLDocument.HTMLReader.addContent(char[], int, int)
javax.swing.text.html.HTMLDocument.HTMLReader.addContent(char[], int, int, boolean)


Occurences of addCustomEntriesToTable

addCustomEntriesToTable occurences:
javax.swing.plaf.metal.MetalTheme.addCustomEntriesToTable(javax.swing.UIDefaults)
javax.swing.plaf.metal.OceanTheme.addCustomEntriesToTable(javax.swing.UIDefaults)


Occurences of addDetailEntry

addDetailEntry occurences:
javax.xml.soap.Detail.addDetailEntry(javax.xml.namespace.QName)
javax.xml.soap.Detail.addDetailEntry(javax.xml.soap.Name)


Occurences of addDirtyRegion

addDirtyRegion occurences:
javax.swing.RepaintManager.addDirtyRegion(java.applet.Applet, int, int, int, int)
javax.swing.RepaintManager.addDirtyRegion(java.awt.Window, int, int, int, int)
javax.swing.RepaintManager.addDirtyRegion(javax.swing.JComponent, int, int, int, int)


Occurences of addDocumentListener

addDocumentListener occurences:
javax.swing.text.AbstractDocument.addDocumentListener(javax.swing.event.DocumentListener)
javax.swing.text.DefaultStyledDocument.addDocumentListener(javax.swing.event.DocumentListener)
javax.swing.text.Document.addDocumentListener(javax.swing.event.DocumentListener)


Occurences of addDragSourceListener

addDragSourceListener occurences:
java.awt.dnd.DragSource.addDragSourceListener(java.awt.dnd.DragSourceListener)
java.awt.dnd.DragSourceContext.addDragSourceListener(java.awt.dnd.DragSourceListener)


Occurences of addEdit

addEdit occurences:
javax.swing.text.AbstractDocument.DefaultDocumentEvent.addEdit(javax.swing.undo.UndoableEdit)
javax.swing.undo.AbstractUndoableEdit.addEdit(javax.swing.undo.UndoableEdit)
javax.swing.undo.CompoundEdit.addEdit(javax.swing.undo.UndoableEdit)
javax.swing.undo.UndoableEdit.addEdit(javax.swing.undo.UndoableEdit)
javax.swing.undo.UndoManager.addEdit(javax.swing.undo.UndoableEdit)


Occurences of addElement

addElement occurences:
java.util.Vector.addElement(E)
java.util.Vector.addElement(java.lang.Object)
javax.imageio.metadata.IIOMetadataFormatImpl.addElement(java.lang.String, java.lang.String, int)
javax.imageio.metadata.IIOMetadataFormatImpl.addElement(java.lang.String, java.lang.String, int, int)
javax.swing.DefaultComboBoxModel.addElement(java.lang.Object)
javax.swing.DefaultListModel.addElement(java.lang.Object)
javax.swing.MutableComboBoxModel.addElement(java.lang.Object)


Occurences of addFault

addFault occurences:
javax.xml.soap.SOAPBody.addFault()
javax.xml.soap.SOAPBody.addFault(javax.xml.namespace.QName, java.lang.String)
javax.xml.soap.SOAPBody.addFault(javax.xml.namespace.QName, java.lang.String, java.util.Locale)
javax.xml.soap.SOAPBody.addFault(javax.xml.soap.Name, java.lang.String)
javax.xml.soap.SOAPBody.addFault(javax.xml.soap.Name, java.lang.String, java.util.Locale)


Occurences of addFirst

addFirst occurences:
java.util.ArrayDeque.addFirst(E)
java.util.ArrayDeque.addFirst(java.lang.Object)
java.util.concurrent.BlockingDeque.addFirst(E)
java.util.concurrent.BlockingDeque.addFirst(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.addFirst(E)
java.util.concurrent.LinkedBlockingDeque.addFirst(java.lang.Object)
java.util.Deque.addFirst(E)
java.util.Deque.addFirst(java.lang.Object)
java.util.LinkedList.addFirst(E)
java.util.LinkedList.addFirst(java.lang.Object)


Occurences of addFocusListener

addFocusListener occurences:
java.awt.Component.addFocusListener(java.awt.event.FocusListener)
java.awt.Component.AccessibleAWTComponent.addFocusListener(java.awt.event.FocusListener)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.addFocusListener(java.awt.event.FocusListener)
java.awt.MenuComponent.AccessibleAWTMenuComponent.addFocusListener(java.awt.event.FocusListener)
javax.accessibility.AccessibleComponent.addFocusListener(java.awt.event.FocusListener)
javax.swing.JList.AccessibleJList.AccessibleJListChild.addFocusListener(java.awt.event.FocusListener)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.addFocusListener(java.awt.event.FocusListener)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.addFocusListener(java.awt.event.FocusListener)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.addFocusListener(java.awt.event.FocusListener)


Occurences of addGap

addGap occurences:
javax.swing.GroupLayout.Group.addGap(int)
javax.swing.GroupLayout.Group.addGap(int, int, int)
javax.swing.GroupLayout.ParallelGroup.addGap(int)
javax.swing.GroupLayout.ParallelGroup.addGap(int, int, int)
javax.swing.GroupLayout.SequentialGroup.addGap(int)
javax.swing.GroupLayout.SequentialGroup.addGap(int, int, int)


Occurences of addGroup

addGroup occurences:
javax.swing.GroupLayout.Group.addGroup(javax.swing.GroupLayout.Group)
javax.swing.GroupLayout.ParallelGroup.addGroup(javax.swing.GroupLayout.Alignment, javax.swing.GroupLayout.Group)
javax.swing.GroupLayout.ParallelGroup.addGroup(javax.swing.GroupLayout.Group)
javax.swing.GroupLayout.SequentialGroup.addGroup(boolean, javax.swing.GroupLayout.Group)
javax.swing.GroupLayout.SequentialGroup.addGroup(javax.swing.GroupLayout.Group)


Occurences of addHeader

addHeader occurences:
javax.xml.soap.MimeHeaders.addHeader(java.lang.String, java.lang.String)
javax.xml.soap.SOAPEnvelope.addHeader()


Occurences of addHeaderElement

addHeaderElement occurences:
javax.xml.soap.SOAPHeader.addHeaderElement(javax.xml.namespace.QName)
javax.xml.soap.SOAPHeader.addHeaderElement(javax.xml.soap.Name)


Occurences of addHighlight

addHighlight occurences:
javax.swing.text.DefaultHighlighter.addHighlight(int, int, javax.swing.text.Highlighter.HighlightPainter)
javax.swing.text.Highlighter.addHighlight(int, int, javax.swing.text.Highlighter.HighlightPainter)


Occurences of addIfAbsent

addIfAbsent occurences:
java.util.concurrent.CopyOnWriteArrayList.addIfAbsent(E)
java.util.concurrent.CopyOnWriteArrayList.addIfAbsent(java.lang.Object)


Occurences of addImage

addImage occurences:
java.awt.MediaTracker.addImage(java.awt.Image, int)
java.awt.MediaTracker.addImage(java.awt.Image, int, int, int)


Occurences of addImpl

addImpl occurences:
java.awt.Container.addImpl(java.awt.Component, java.lang.Object, int)
java.awt.ScrollPane.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.AbstractButton.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.CellRendererPane.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JApplet.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JDesktopPane.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JDialog.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JFrame.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JInternalFrame.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JLayeredPane.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JRootPane.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JSplitPane.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JToolBar.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JViewport.addImpl(java.awt.Component, java.lang.Object, int)
javax.swing.JWindow.addImpl(java.awt.Component, java.lang.Object, int)


Occurences of addInputMethodListener

addInputMethodListener occurences:
java.awt.Component.addInputMethodListener(java.awt.event.InputMethodListener)
javax.swing.text.JTextComponent.addInputMethodListener(java.awt.event.InputMethodListener)


Occurences of addInstanceFilter

addInstanceFilter occurences:
com.sun.jdi.request.BreakpointRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.ExceptionRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.MethodEntryRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.MethodExitRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.MonitorContendedEnteredRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.MonitorContendedEnterRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.MonitorWaitedRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.MonitorWaitRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.StepRequest.addInstanceFilter(com.sun.jdi.ObjectReference)
com.sun.jdi.request.WatchpointRequest.addInstanceFilter(com.sun.jdi.ObjectReference)


Occurences of addIssuerName

addIssuerName occurences:
java.security.cert.X509CRLSelector.addIssuerName(byte[])
java.security.cert.X509CRLSelector.addIssuerName(java.lang.String)


Occurences of addItem

addItem occurences:
java.awt.Choice.addItem(java.lang.String)
java.awt.List.addItem(java.lang.String)
java.awt.List.addItem(java.lang.String, int)
javax.swing.JComboBox.addItem(java.lang.Object)


Occurences of addItemListener

addItemListener occurences:
java.awt.Checkbox.addItemListener(java.awt.event.ItemListener)
java.awt.CheckboxMenuItem.addItemListener(java.awt.event.ItemListener)
java.awt.Choice.addItemListener(java.awt.event.ItemListener)
java.awt.ItemSelectable.addItemListener(java.awt.event.ItemListener)
java.awt.List.addItemListener(java.awt.event.ItemListener)
javax.swing.AbstractButton.addItemListener(java.awt.event.ItemListener)
javax.swing.ButtonModel.addItemListener(java.awt.event.ItemListener)
javax.swing.DefaultButtonModel.addItemListener(java.awt.event.ItemListener)
javax.swing.JComboBox.addItemListener(java.awt.event.ItemListener)


Occurences of addLast

addLast occurences:
java.util.ArrayDeque.addLast(E)
java.util.ArrayDeque.addLast(java.lang.Object)
java.util.concurrent.BlockingDeque.addLast(E)
java.util.concurrent.BlockingDeque.addLast(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.addLast(E)
java.util.concurrent.LinkedBlockingDeque.addLast(java.lang.Object)
java.util.Deque.addLast(E)
java.util.Deque.addLast(java.lang.Object)
java.util.LinkedList.addLast(E)
java.util.LinkedList.addLast(java.lang.Object)


Occurences of addLayoutComponent

addLayoutComponent occurences:
java.awt.BorderLayout.addLayoutComponent(java.awt.Component, java.lang.Object)
java.awt.BorderLayout.addLayoutComponent(java.lang.String, java.awt.Component)
java.awt.CardLayout.addLayoutComponent(java.awt.Component, java.lang.Object)
java.awt.CardLayout.addLayoutComponent(java.lang.String, java.awt.Component)
java.awt.FlowLayout.addLayoutComponent(java.lang.String, java.awt.Component)
java.awt.GridBagLayout.addLayoutComponent(java.awt.Component, java.lang.Object)
java.awt.GridBagLayout.addLayoutComponent(java.lang.String, java.awt.Component)
java.awt.GridLayout.addLayoutComponent(java.lang.String, java.awt.Component)
java.awt.LayoutManager.addLayoutComponent(java.lang.String, java.awt.Component)
java.awt.LayoutManager2.addLayoutComponent(java.awt.Component, java.lang.Object)
javax.swing.BoxLayout.addLayoutComponent(java.awt.Component, java.lang.Object)
javax.swing.BoxLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.GroupLayout.addLayoutComponent(java.awt.Component, java.lang.Object)
javax.swing.GroupLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.JRootPane.RootLayout.addLayoutComponent(java.awt.Component, java.lang.Object)
javax.swing.JRootPane.RootLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.JSpinner.DefaultEditor.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.OverlayLayout.addLayoutComponent(java.awt.Component, java.lang.Object)
javax.swing.OverlayLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.plaf.basic.BasicComboBoxUI.ComboBoxLayoutManager.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.TitlePaneLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.plaf.basic.BasicInternalFrameUI.InternalFrameLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.plaf.basic.BasicOptionPaneUI.ButtonAreaLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.plaf.basic.BasicScrollBarUI.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.plaf.basic.BasicSplitPaneDivider.DividerLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.addLayoutComponent(java.awt.Component, java.lang.Object)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.plaf.basic.BasicTabbedPaneUI.TabbedPaneLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.ScrollPaneLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.SpringLayout.addLayoutComponent(java.awt.Component, java.lang.Object)
javax.swing.SpringLayout.addLayoutComponent(java.lang.String, java.awt.Component)
javax.swing.ViewportLayout.addLayoutComponent(java.lang.String, java.awt.Component)


Occurences of addListDataListener

addListDataListener occurences:
javax.swing.AbstractListModel.addListDataListener(javax.swing.event.ListDataListener)
javax.swing.ListModel.addListDataListener(javax.swing.event.ListDataListener)


Occurences of addListSelectionListener

addListSelectionListener occurences:
javax.swing.DefaultListSelectionModel.addListSelectionListener(javax.swing.event.ListSelectionListener)
javax.swing.JList.addListSelectionListener(javax.swing.event.ListSelectionListener)
javax.swing.ListSelectionModel.addListSelectionListener(javax.swing.event.ListSelectionListener)


Occurences of addMenuKeyListener

addMenuKeyListener occurences:
javax.swing.JMenuItem.addMenuKeyListener(javax.swing.event.MenuKeyListener)
javax.swing.JPopupMenu.addMenuKeyListener(javax.swing.event.MenuKeyListener)


Occurences of addMimeHeader

addMimeHeader occurences:
javax.xml.soap.AttachmentPart.addMimeHeader(java.lang.String, java.lang.String)
javax.xml.soap.SOAPPart.addMimeHeader(java.lang.String, java.lang.String)


Occurences of addMouseListener

addMouseListener occurences:
java.awt.Component.addMouseListener(java.awt.event.MouseListener)
java.awt.TrayIcon.addMouseListener(java.awt.event.MouseListener)


Occurences of addMouseMotionListener

addMouseMotionListener occurences:
java.awt.Component.addMouseMotionListener(java.awt.event.MouseMotionListener)
java.awt.TrayIcon.addMouseMotionListener(java.awt.event.MouseMotionListener)


Occurences of addMtomAttachment

addMtomAttachment occurences:
javax.xml.bind.attachment.AttachmentMarshaller.addMtomAttachment(byte[], int, int, java.lang.String, java.lang.String, java.lang.String)
javax.xml.bind.attachment.AttachmentMarshaller.addMtomAttachment(javax.activation.DataHandler, java.lang.String, java.lang.String)


Occurences of addNamingListener

addNamingListener occurences:
javax.naming.event.EventContext.addNamingListener(java.lang.String, int, javax.naming.event.NamingListener)
javax.naming.event.EventContext.addNamingListener(javax.naming.Name, int, javax.naming.event.NamingListener)
javax.naming.event.EventDirContext.addNamingListener(java.lang.String, java.lang.String, java.lang.Object[], javax.naming.directory.SearchControls, javax.naming.event.NamingListener)
javax.naming.event.EventDirContext.addNamingListener(java.lang.String, java.lang.String, javax.naming.directory.SearchControls, javax.naming.event.NamingListener)
javax.naming.event.EventDirContext.addNamingListener(javax.naming.Name, java.lang.String, java.lang.Object[], javax.naming.directory.SearchControls, javax.naming.event.NamingListener)
javax.naming.event.EventDirContext.addNamingListener(javax.naming.Name, java.lang.String, javax.naming.directory.SearchControls, javax.naming.event.NamingListener)


Occurences of addNodeChangeListener

addNodeChangeListener occurences:
java.util.prefs.AbstractPreferences.addNodeChangeListener(java.util.prefs.NodeChangeListener)
java.util.prefs.Preferences.addNodeChangeListener(java.util.prefs.NodeChangeListener)


Occurences of addNotification

addNotification occurences:
javax.management.timer.Timer.addNotification(java.lang.String, java.lang.String, java.lang.Object, java.util.Date)
javax.management.timer.Timer.addNotification(java.lang.String, java.lang.String, java.lang.Object, java.util.Date, long)
javax.management.timer.Timer.addNotification(java.lang.String, java.lang.String, java.lang.Object, java.util.Date, long, long)
javax.management.timer.Timer.addNotification(java.lang.String, java.lang.String, java.lang.Object, java.util.Date, long, long, boolean)
javax.management.timer.TimerMBean.addNotification(java.lang.String, java.lang.String, java.lang.Object, java.util.Date)
javax.management.timer.TimerMBean.addNotification(java.lang.String, java.lang.String, java.lang.Object, java.util.Date, long)
javax.management.timer.TimerMBean.addNotification(java.lang.String, java.lang.String, java.lang.Object, java.util.Date, long, long)
javax.management.timer.TimerMBean.addNotification(java.lang.String, java.lang.String, java.lang.Object, java.util.Date, long, long, boolean)


Occurences of addNotificationListener

addNotificationListener occurences:
javax.management.MBeanServer.addNotificationListener(javax.management.ObjectName, javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.MBeanServer.addNotificationListener(javax.management.ObjectName, javax.management.ObjectName, javax.management.NotificationFilter, java.lang.Object)
javax.management.MBeanServerConnection.addNotificationListener(javax.management.ObjectName, javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.MBeanServerConnection.addNotificationListener(javax.management.ObjectName, javax.management.ObjectName, javax.management.NotificationFilter, java.lang.Object)
javax.management.MBeanServerDelegate.addNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.modelmbean.RequiredModelMBean.addNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.NotificationBroadcaster.addNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.NotificationBroadcasterSupport.addNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.remote.rmi.RMIConnection.addNotificationListener(javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.addNotificationListener(javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.addNotificationListener(javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.StandardEmitterMBean.addNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)


Occurences of addNotificationListeners

addNotificationListeners occurences:
javax.management.remote.rmi.RMIConnection.addNotificationListeners(javax.management.ObjectName[], java.rmi.MarshalledObject[], javax.security.auth.Subject[])
javax.management.remote.rmi.RMIConnectionImpl.addNotificationListeners(javax.management.ObjectName[], java.rmi.MarshalledObject[], javax.security.auth.Subject[])
javax.management.remote.rmi.RMIConnectionImpl_Stub.addNotificationListeners(javax.management.ObjectName[], java.rmi.MarshalledObject[], javax.security.auth.Subject[])


Occurences of addNotify

addNotify occurences:
java.awt.Button.addNotify()
java.awt.Canvas.addNotify()
java.awt.Checkbox.addNotify()
java.awt.CheckboxMenuItem.addNotify()
java.awt.Choice.addNotify()
java.awt.Component.addNotify()
java.awt.Container.addNotify()
java.awt.Dialog.addNotify()
java.awt.dnd.DropTarget.addNotify(java.awt.peer.ComponentPeer)
java.awt.dnd.DropTargetContext.addNotify(java.awt.dnd.peer.DropTargetContextPeer)
java.awt.FileDialog.addNotify()
java.awt.Frame.addNotify()
java.awt.Label.addNotify()
java.awt.List.addNotify()
java.awt.Menu.addNotify()
java.awt.MenuBar.addNotify()
java.awt.MenuItem.addNotify()
java.awt.Panel.addNotify()
java.awt.PopupMenu.addNotify()
java.awt.Scrollbar.addNotify()
java.awt.ScrollPane.addNotify()
java.awt.TextArea.addNotify()
java.awt.TextComponent.addNotify()
java.awt.TextField.addNotify()
java.awt.Window.addNotify()
javax.swing.JComponent.addNotify()
javax.swing.JMenuBar.addNotify()
javax.swing.JRootPane.addNotify()
javax.swing.JTable.addNotify()
javax.swing.plaf.metal.MetalInternalFrameTitlePane.addNotify()


Occurences of addObjectValue

addObjectValue occurences:
javax.imageio.metadata.IIOMetadataFormatImpl.addObjectValue(java.lang.String, java.lang.Class, boolean, T)
javax.imageio.metadata.IIOMetadataFormatImpl.addObjectValue(java.lang.String, java.lang.Class, boolean, T, java.util.List)
javax.imageio.metadata.IIOMetadataFormatImpl.addObjectValue(java.lang.String, java.lang.Class, int, int)
javax.imageio.metadata.IIOMetadataFormatImpl.addObjectValue(java.lang.String, java.lang.Class, T, java.lang.Comparable, java.lang.Comparable, boolean, boolean)
javax.imageio.metadata.IIOMetadataFormatImpl.addObjectValue(java.lang.String,java.lang.Class,boolean,java.lang.Object)
javax.imageio.metadata.IIOMetadataFormatImpl.addObjectValue(java.lang.String,java.lang.Class,boolean,java.lang.Object,java.util.List)
javax.imageio.metadata.IIOMetadataFormatImpl.addObjectValue(java.lang.String,java.lang.Class,java.lang.Object,java.lang.Comparable,java.lang.Comparable,boolean,boolean)


Occurences of addObservedObject

addObservedObject occurences:
javax.management.monitor.Monitor.addObservedObject(javax.management.ObjectName)
javax.management.monitor.MonitorMBean.addObservedObject(javax.management.ObjectName)


Occurences of addPathToName

addPathToName occurences:
java.security.cert.X509CertSelector.addPathToName(int, byte[])
java.security.cert.X509CertSelector.addPathToName(int, java.lang.String)


Occurences of addPopupMenuListener

addPopupMenuListener occurences:
javax.swing.JComboBox.addPopupMenuListener(javax.swing.event.PopupMenuListener)
javax.swing.JPopupMenu.addPopupMenuListener(javax.swing.event.PopupMenuListener)


Occurences of addPort

addPort occurences:
javax.xml.ws.Service.addPort(javax.xml.namespace.QName, java.lang.String, java.lang.String)
javax.xml.ws.spi.ServiceDelegate.addPort(javax.xml.namespace.QName, java.lang.String, java.lang.String)


Occurences of addPreferenceChangeListener

addPreferenceChangeListener occurences:
java.util.prefs.AbstractPreferences.addPreferenceChangeListener(java.util.prefs.PreferenceChangeListener)
java.util.prefs.Preferences.addPreferenceChangeListener(java.util.prefs.PreferenceChangeListener)


Occurences of addPreferredGap

addPreferredGap occurences:
javax.swing.GroupLayout.SequentialGroup.addPreferredGap(javax.swing.JComponent, javax.swing.JComponent, javax.swing.LayoutStyle.ComponentPlacement)
javax.swing.GroupLayout.SequentialGroup.addPreferredGap(javax.swing.JComponent, javax.swing.JComponent, javax.swing.LayoutStyle.ComponentPlacement, int, int)
javax.swing.GroupLayout.SequentialGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement)
javax.swing.GroupLayout.SequentialGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement, int, int)


Occurences of addPropertyChangeListener

addPropertyChangeListener occurences:
com.sun.tools.jconsole.JConsoleContext.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.Component.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.Component.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.awt.Component.AccessibleAWTComponent.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.Container.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.Container.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.awt.Container.AccessibleAWTContainer.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.KeyboardFocusManager.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.KeyboardFocusManager.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.awt.SystemTray.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.awt.Toolkit.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.awt.Window.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.Window.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.beans.beancontext.BeanContextChild.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.beans.beancontext.BeanContextChildSupport.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.beans.Customizer.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.beans.PropertyChangeSupport.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.beans.PropertyChangeSupport.addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.beans.PropertyEditor.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.beans.PropertyEditorSupport.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.util.jar.Pack200.Packer.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.util.jar.Pack200.Unpacker.addPropertyChangeListener(java.beans.PropertyChangeListener)
java.util.logging.LogManager.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.accessibility.AccessibleContext.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.AbstractAction.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.Action.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.JComponent.AccessibleJComponent.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.JList.AccessibleJList.AccessibleJListChild.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.plaf.basic.BasicDirectoryModel.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.SwingWorker.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.table.TableColumn.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.tree.DefaultTreeSelectionModel.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.tree.TreeSelectionModel.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.UIDefaults.addPropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.UIManager.addPropertyChangeListener(java.beans.PropertyChangeListener)


Occurences of addRelation

addRelation occurences:
javax.management.relation.RelationService.addRelation(javax.management.ObjectName)
javax.management.relation.RelationServiceMBean.addRelation(javax.management.ObjectName)


Occurences of addRelationType

addRelationType occurences:
javax.management.relation.RelationService.addRelationType(javax.management.relation.RelationType)
javax.management.relation.RelationServiceMBean.addRelationType(javax.management.relation.RelationType)


Occurences of address

address occurences:
com.sun.jdi.connect.spi.TransportService.ListenKey.address()
java.net.address
java.net.Proxy.address()


Occurences of addRow

addRow occurences:
javax.swing.table.DefaultTableModel.addRow(java.lang.Object[])
javax.swing.table.DefaultTableModel.addRow(java.util.Vector)


Occurences of addRowSet

addRowSet occurences:
javax.sql.rowset.JoinRowSet.addRowSet(javax.sql.RowSet, int)
javax.sql.rowset.JoinRowSet.addRowSet(javax.sql.RowSet, java.lang.String)
javax.sql.rowset.JoinRowSet.addRowSet(javax.sql.rowset.Joinable)
javax.sql.rowset.JoinRowSet.addRowSet(javax.sql.RowSet[], int[])
javax.sql.rowset.JoinRowSet.addRowSet(javax.sql.RowSet[], java.lang.String[])


Occurences of addRowSetListener

addRowSetListener occurences:
javax.sql.RowSet.addRowSetListener(javax.sql.RowSetListener)
javax.sql.rowset.BaseRowSet.addRowSetListener(javax.sql.RowSetListener)


Occurences of addSelectionInterval

addSelectionInterval occurences:
javax.swing.DefaultListSelectionModel.addSelectionInterval(int, int)
javax.swing.JList.addSelectionInterval(int, int)
javax.swing.JTree.addSelectionInterval(int, int)
javax.swing.ListSelectionModel.addSelectionInterval(int, int)


Occurences of addSelectionPath

addSelectionPath occurences:
javax.swing.JTree.addSelectionPath(javax.swing.tree.TreePath)
javax.swing.tree.DefaultTreeSelectionModel.addSelectionPath(javax.swing.tree.TreePath)
javax.swing.tree.TreeSelectionModel.addSelectionPath(javax.swing.tree.TreePath)


Occurences of addSelectionPaths

addSelectionPaths occurences:
javax.swing.JTree.addSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.JTree.EmptySelectionModel.addSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.tree.DefaultTreeSelectionModel.addSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.tree.TreeSelectionModel.addSelectionPaths(javax.swing.tree.TreePath[])


Occurences of addSeparator

addSeparator occurences:
java.awt.Menu.addSeparator()
javax.swing.JMenu.addSeparator()
javax.swing.JPopupMenu.addSeparator()
javax.swing.JToolBar.addSeparator()
javax.swing.JToolBar.addSeparator(java.awt.Dimension)


Occurences of addService

addService occurences:
java.beans.beancontext.BeanContextServices.addService(java.lang.Class, java.beans.beancontext.BeanContextServiceProvider)
java.beans.beancontext.BeanContextServicesSupport.addService(java.lang.Class, java.beans.beancontext.BeanContextServiceProvider)
java.beans.beancontext.BeanContextServicesSupport.addService(java.lang.Class, java.beans.beancontext.BeanContextServiceProvider, boolean)


Occurences of addSource

addSource occurences:
java.awt.image.renderable.ParameterBlock.addSource(java.lang.Object)
org.w3c.dom.bootstrap.DOMImplementationRegistry.addSource(org.w3c.dom.DOMImplementationSource)


Occurences of addStyle

addStyle occurences:
javax.swing.JTextPane.addStyle(java.lang.String, javax.swing.text.Style)
javax.swing.text.DefaultStyledDocument.addStyle(java.lang.String, javax.swing.text.Style)
javax.swing.text.StyleContext.addStyle(java.lang.String, javax.swing.text.Style)
javax.swing.text.StyledDocument.addStyle(java.lang.String, javax.swing.text.Style)


Occurences of addSubComponents

addSubComponents occurences:
javax.swing.plaf.basic.BasicInternalFrameTitlePane.addSubComponents()
javax.swing.plaf.metal.MetalInternalFrameTitlePane.addSubComponents()


Occurences of addSubjectAlternativeName

addSubjectAlternativeName occurences:
java.security.cert.X509CertSelector.addSubjectAlternativeName(int, byte[])
java.security.cert.X509CertSelector.addSubjectAlternativeName(int, java.lang.String)


Occurences of addSystemMenuItems

addSystemMenuItems occurences:
javax.swing.plaf.basic.BasicInternalFrameTitlePane.addSystemMenuItems(javax.swing.JMenu)
javax.swing.plaf.metal.MetalInternalFrameTitlePane.addSystemMenuItems(javax.swing.JMenu)


Occurences of addTab

addTab occurences:
javax.swing.JTabbedPane.addTab(java.lang.String, java.awt.Component)
javax.swing.JTabbedPane.addTab(java.lang.String, javax.swing.Icon, java.awt.Component)
javax.swing.JTabbedPane.addTab(java.lang.String, javax.swing.Icon, java.awt.Component, java.lang.String)


Occurences of addTableModelListener

addTableModelListener occurences:
javax.swing.table.AbstractTableModel.addTableModelListener(javax.swing.event.TableModelListener)
javax.swing.table.TableModel.addTableModelListener(javax.swing.event.TableModelListener)


Occurences of addThreadFilter

addThreadFilter occurences:
com.sun.jdi.request.BreakpointRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.ExceptionRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.MethodEntryRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.MethodExitRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.MonitorContendedEnteredRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.MonitorContendedEnterRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.MonitorWaitedRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.MonitorWaitRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.ThreadDeathRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.ThreadStartRequest.addThreadFilter(com.sun.jdi.ThreadReference)
com.sun.jdi.request.WatchpointRequest.addThreadFilter(com.sun.jdi.ThreadReference)


Occurences of addTileObserver

addTileObserver occurences:
java.awt.image.BufferedImage.addTileObserver(java.awt.image.TileObserver)
java.awt.image.WritableRenderedImage.addTileObserver(java.awt.image.TileObserver)


Occurences of addTo

addTo occurences:
javax.xml.datatype.Duration.addTo(java.util.Calendar)
javax.xml.datatype.Duration.addTo(java.util.Date)


Occurences of addToEnvironment

addToEnvironment occurences:
javax.naming.Context.addToEnvironment(java.lang.String, java.lang.Object)
javax.naming.InitialContext.addToEnvironment(java.lang.String, java.lang.Object)


Occurences of addTransformer

addTransformer occurences:
java.lang.instrument.Instrumentation.addTransformer(java.lang.instrument.ClassFileTransformer)
java.lang.instrument.Instrumentation.addTransformer(java.lang.instrument.ClassFileTransformer, boolean)


Occurences of addTreeModelListener

addTreeModelListener occurences:
javax.swing.tree.DefaultTreeModel.addTreeModelListener(javax.swing.event.TreeModelListener)
javax.swing.tree.TreeModel.addTreeModelListener(javax.swing.event.TreeModelListener)


Occurences of addTreeSelectionListener

addTreeSelectionListener occurences:
javax.swing.JTree.addTreeSelectionListener(javax.swing.event.TreeSelectionListener)
javax.swing.tree.DefaultTreeSelectionModel.addTreeSelectionListener(javax.swing.event.TreeSelectionListener)
javax.swing.tree.TreeSelectionModel.addTreeSelectionListener(javax.swing.event.TreeSelectionListener)


Occurences of addUndoableEditListener

addUndoableEditListener occurences:
javax.swing.text.AbstractDocument.addUndoableEditListener(javax.swing.event.UndoableEditListener)
javax.swing.text.Document.addUndoableEditListener(javax.swing.event.UndoableEditListener)
javax.swing.undo.UndoableEditSupport.addUndoableEditListener(javax.swing.event.UndoableEditListener)


Occurences of addUpgradeHeaderElement

addUpgradeHeaderElement occurences:
javax.xml.soap.SOAPHeader.addUpgradeHeaderElement(java.lang.String)
javax.xml.soap.SOAPHeader.addUpgradeHeaderElement(java.lang.String[])
javax.xml.soap.SOAPHeader.addUpgradeHeaderElement(java.util.Iterator)


Occurences of addURL

addURL occurences:
java.net.URLClassLoader.addURL(java.net.URL)
javax.management.loading.MLet.addURL(java.lang.String)
javax.management.loading.MLet.addURL(java.net.URL)
javax.management.loading.MLetMBean.addURL(java.lang.String)
javax.management.loading.MLetMBean.addURL(java.net.URL)


Occurences of addVetoableChangeListener

addVetoableChangeListener occurences:
java.awt.KeyboardFocusManager.addVetoableChangeListener(java.beans.VetoableChangeListener)
java.awt.KeyboardFocusManager.addVetoableChangeListener(java.lang.String, java.beans.VetoableChangeListener)
java.beans.beancontext.BeanContextChild.addVetoableChangeListener(java.lang.String, java.beans.VetoableChangeListener)
java.beans.beancontext.BeanContextChildSupport.addVetoableChangeListener(java.lang.String, java.beans.VetoableChangeListener)
java.beans.VetoableChangeSupport.addVetoableChangeListener(java.beans.VetoableChangeListener)
java.beans.VetoableChangeSupport.addVetoableChangeListener(java.lang.String, java.beans.VetoableChangeListener)
javax.swing.JComponent.addVetoableChangeListener(java.beans.VetoableChangeListener)


Occurences of AdjustmentEvent (constructors)

AdjustmentEvent (constructors) occurences:
java.awt.event.AdjustmentEvent(java.awt.Adjustable, int, int, int)
java.awt.event.AdjustmentEvent(java.awt.Adjustable, int, int, int, boolean)


Occurences of adjustmentValueChanged

adjustmentValueChanged occurences:
java.awt.AWTEventMulticaster.adjustmentValueChanged(java.awt.event.AdjustmentEvent)
java.awt.event.AdjustmentListener.adjustmentValueChanged(java.awt.event.AdjustmentEvent)


Occurences of adjustRow

adjustRow occurences:
javax.swing.text.FlowView.FlowStrategy.adjustRow(javax.swing.text.FlowView, int, int, int)
javax.swing.text.ParagraphView.adjustRow(javax.swing.text.ParagraphView.Row, int, int)


Occurences of Advanced JGSS Security Programming

Advanced JGSS Security Programming occurences:
Advanced JGSS Security Programming
Advanced JGSS Security Programming
Advanced JGSS Security Programming
Advanced JGSS Security Programming
Advanced JGSS Security Programming
Advanced JGSS Security Programming


Occurences of AffineTransform (constructors)

AffineTransform (constructors) occurences:
java.awt.geom.AffineTransform()
java.awt.geom.AffineTransform(double, double, double, double, double, double)
java.awt.geom.AffineTransform(double[])
java.awt.geom.AffineTransform(float, float, float, float, float, float)
java.awt.geom.AffineTransform(float[])
java.awt.geom.AffineTransform(java.awt.geom.AffineTransform)


Occurences of AffineTransformOp (constructors)

AffineTransformOp (constructors) occurences:
java.awt.image.AffineTransformOp(java.awt.geom.AffineTransform, int)
java.awt.image.AffineTransformOp(java.awt.geom.AffineTransform, java.awt.RenderingHints)


Occurences of after

after occurences:
java.sql.Timestamp.after(java.sql.Timestamp)
java.util.Calendar.after(java.lang.Object)
java.util.Date.after(java.util.Date)


Occurences of AgentInitializationException (constructors)

AgentInitializationException (constructors) occurences:
com.sun.tools.attach.AgentInitializationException()
com.sun.tools.attach.AgentInitializationException(java.lang.String)
com.sun.tools.attach.AgentInitializationException(java.lang.String, int)


Occurences of AgentLoadException (constructors)

AgentLoadException (constructors) occurences:
com.sun.tools.attach.AgentLoadException()
com.sun.tools.attach.AgentLoadException(java.lang.String)


Occurences of aliases

aliases occurences:
java.nio.charset.Charset.aliases()
java.security.KeyStore.aliases()


Occurences of ALIGN_CENTER

ALIGN_CENTER occurences:
javax.swing.text.ALIGN_CENTER
javax.swing.text.ALIGN_CENTER


Occurences of ALIGN_LEFT

ALIGN_LEFT occurences:
javax.swing.text.ALIGN_LEFT
javax.swing.text.ALIGN_LEFT


Occurences of ALIGN_RIGHT

ALIGN_RIGHT occurences:
javax.swing.text.ALIGN_RIGHT
javax.swing.text.ALIGN_RIGHT


Occurences of ALL

ALL occurences:
java.awt.ALL
java.util.logging.ALL


Occurences of All Classes

All Classes occurences:
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes
All Classes


Occurences of allClasses

allClasses occurences:
com.sun.javadoc.PackageDoc.allClasses()
com.sun.javadoc.PackageDoc.allClasses(boolean)
com.sun.jdi.VirtualMachine.allClasses()


Occurences of allKeys

allKeys occurences:
javax.swing.ActionMap.allKeys()
javax.swing.InputMap.allKeys()


Occurences of allLineLocations

allLineLocations occurences:
com.sun.jdi.Method.allLineLocations()
com.sun.jdi.Method.allLineLocations(java.lang.String, java.lang.String)
com.sun.jdi.ReferenceType.allLineLocations()
com.sun.jdi.ReferenceType.allLineLocations(java.lang.String, java.lang.String)


Occurences of allocate

allocate occurences:
java.nio.ByteBuffer.allocate(int)
java.nio.CharBuffer.allocate(int)
java.nio.DoubleBuffer.allocate(int)
java.nio.FloatBuffer.allocate(int)
java.nio.IntBuffer.allocate(int)
java.nio.LongBuffer.allocate(int)
java.nio.ShortBuffer.allocate(int)
javax.xml.stream.util.XMLEventAllocator.allocate(javax.xml.stream.XMLStreamReader)
javax.xml.stream.util.XMLEventAllocator.allocate(javax.xml.stream.XMLStreamReader, javax.xml.stream.util.XMLEventConsumer)


Occurences of AllPermission (constructors)

AllPermission (constructors) occurences:
java.security.AllPermission()
java.security.AllPermission(java.lang.String, java.lang.String)


Occurences of allRowsChanged

allRowsChanged occurences:
javax.swing.DefaultRowSorter.allRowsChanged()
javax.swing.RowSorter.allRowsChanged()


Occurences of AlreadyBound (constructors)

AlreadyBound (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.AlreadyBound()
org.omg.CosNaming.NamingContextPackage.AlreadyBound(java.lang.String)


Occurences of AlreadyBoundException (constructors)

AlreadyBoundException (constructors) occurences:
java.rmi.AlreadyBoundException()
java.rmi.AlreadyBoundException(java.lang.String)


Occurences of AlreadyBoundHolder (constructors)

AlreadyBoundHolder (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.AlreadyBoundHolder()
org.omg.CosNaming.NamingContextPackage.AlreadyBoundHolder(org.omg.CosNaming.NamingContextPackage.AlreadyBound)


Occurences of ALT_MASK

ALT_MASK occurences:
java.awt.ALT_MASK
java.awt.event.ALT_MASK
java.awt.event.ALT_MASK


Occurences of AM_PM

AM_PM occurences:
java.text.AM_PM
java.util.AM_PM


Occurences of ancestorMoved

ancestorMoved occurences:
java.awt.AWTEventMulticaster.ancestorMoved(java.awt.event.HierarchyEvent)
java.awt.event.HierarchyBoundsAdapter.ancestorMoved(java.awt.event.HierarchyEvent)
java.awt.event.HierarchyBoundsListener.ancestorMoved(java.awt.event.HierarchyEvent)
javax.swing.event.AncestorListener.ancestorMoved(javax.swing.event.AncestorEvent)


Occurences of ancestorResized

ancestorResized occurences:
java.awt.AWTEventMulticaster.ancestorResized(java.awt.event.HierarchyEvent)
java.awt.event.HierarchyBoundsAdapter.ancestorResized(java.awt.event.HierarchyEvent)
java.awt.event.HierarchyBoundsListener.ancestorResized(java.awt.event.HierarchyEvent)


Occurences of ANCESTOR_MOVED

ANCESTOR_MOVED occurences:
java.awt.event.ANCESTOR_MOVED
javax.swing.event.ANCESTOR_MOVED


Occurences of and

and occurences:
com.sun.mirror.util.DeclarationFilter.and(com.sun.mirror.util.DeclarationFilter)
java.math.BigInteger.and(java.math.BigInteger)
java.util.BitSet.and(java.util.BitSet)
javax.management.Query.and(javax.management.QueryExp, javax.management.QueryExp)


Occurences of andNot

andNot occurences:
java.math.BigInteger.andNot(java.math.BigInteger)
java.util.BitSet.andNot(java.util.BitSet)


Occurences of Annotation

Annotation occurences:
java.lang.annotation.Annotation
java.text.Annotation


Occurences of annotation

annotation occurences:
java.lang.annotation
javax.annotation
javax.xml.bind.annotation


Occurences of AnnotationFormatError (constructors)

AnnotationFormatError (constructors) occurences:
java.lang.annotation.AnnotationFormatError(java.lang.String)
java.lang.annotation.AnnotationFormatError(java.lang.String, java.lang.Throwable)
java.lang.annotation.AnnotationFormatError(java.lang.Throwable)


Occurences of AnnotationMirror

AnnotationMirror occurences:
com.sun.mirror.declaration.AnnotationMirror
javax.lang.model.element.AnnotationMirror


Occurences of annotations

annotations occurences:
com.sun.javadoc.PackageDoc.annotations()
com.sun.javadoc.Parameter.annotations()
com.sun.javadoc.ProgramElementDoc.annotations()


Occurences of annotationType

annotationType occurences:
com.sun.javadoc.AnnotationDesc.annotationType()
java.lang.annotation.Annotation.annotationType()
java.lang.annotation.IncompleteAnnotationException.annotationType()


Occurences of AnnotationValue

AnnotationValue occurences:
com.sun.javadoc.AnnotationValue
com.sun.mirror.declaration.AnnotationValue
javax.lang.model.element.AnnotationValue


Occurences of ANNOTATION_TYPE

ANNOTATION_TYPE occurences:
java.lang.annotation.ANNOTATION_TYPE
javax.lang.model.element.ANNOTATION_TYPE


Occurences of annotation_type_element_detail

annotation_type_element_detail occurences:
java.beans.annotation_type_element_detail
java.lang.annotation.annotation_type_element_detail
java.lang.annotation.annotation_type_element_detail
java.lang.annotation_type_element_detail
javax.annotation.annotation_type_element_detail
javax.annotation.annotation_type_element_detail
javax.annotation.processing.annotation_type_element_detail
javax.annotation.processing.annotation_type_element_detail
javax.annotation.processing.annotation_type_element_detail
javax.jws.annotation_type_element_detail
javax.jws.soap.annotation_type_element_detail
javax.jws.soap.annotation_type_element_detail
javax.jws.soap.annotation_type_element_detail
javax.management.annotation_type_element_detail
javax.xml.bind.annotation.adapters.annotation_type_element_detail
javax.xml.bind.annotation.adapters.annotation_type_element_detail
javax.xml.bind.annotation.annotation_type_element_detail
javax.xml.bind.annotation.annotation_type_element_detail
javax.xml.bind.annotation.annotation_type_element_detail
javax.xml.bind.annotation.annotation_type_element_detail
javax.xml.bind.annotation.annotation_type_element_detail
javax.xml.bind.annotation.annotation_type_element_detail
javax.xml.bind.annotation.annotation_type_element_detail
javax.xml.bind.annotation.annotation_type_element_detail
javax.xml.ws.annotation_type_element_detail


Occurences of annotation_type_optional_element_summary

annotation_type_optional_element_summary occurences:
javax.annotation.annotation_type_optional_element_summary
javax.annotation.annotation_type_optional_element_summary
javax.jws.annotation_type_optional_element_summary
javax.jws.annotation_type_optional_element_summary
javax.jws.annotation_type_optional_element_summary
javax.jws.annotation_type_optional_element_summary
javax.jws.annotation_type_optional_element_summary
javax.jws.soap.annotation_type_optional_element_summary
javax.jws.soap.annotation_type_optional_element_summary
javax.management.annotation_type_optional_element_summary
javax.xml.bind.annotation.adapters.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.bind.annotation.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary
javax.xml.ws.annotation_type_optional_element_summary


Occurences of annotation_type_required_element_summary

annotation_type_required_element_summary occurences:
java.beans.annotation_type_required_element_summary
java.lang.annotation.annotation_type_required_element_summary
java.lang.annotation.annotation_type_required_element_summary
java.lang.annotation_type_required_element_summary
javax.annotation.annotation_type_required_element_summary
javax.annotation.annotation_type_required_element_summary
javax.annotation.processing.annotation_type_required_element_summary
javax.annotation.processing.annotation_type_required_element_summary
javax.annotation.processing.annotation_type_required_element_summary
javax.jws.annotation_type_required_element_summary
javax.jws.soap.annotation_type_required_element_summary
javax.jws.soap.annotation_type_required_element_summary
javax.jws.soap.annotation_type_required_element_summary
javax.management.annotation_type_required_element_summary
javax.xml.bind.annotation.adapters.annotation_type_required_element_summary
javax.xml.bind.annotation.adapters.annotation_type_required_element_summary
javax.xml.bind.annotation.annotation_type_required_element_summary
javax.xml.bind.annotation.annotation_type_required_element_summary
javax.xml.bind.annotation.annotation_type_required_element_summary
javax.xml.bind.annotation.annotation_type_required_element_summary
javax.xml.bind.annotation.annotation_type_required_element_summary
javax.xml.bind.annotation.annotation_type_required_element_summary
javax.xml.bind.annotation.annotation_type_required_element_summary
javax.xml.bind.annotation.annotation_type_required_element_summary
javax.xml.ws.annotation_type_required_element_summary


Occurences of AnyHolder (constructors)

AnyHolder (constructors) occurences:
org.omg.CORBA.AnyHolder()
org.omg.CORBA.AnyHolder(org.omg.CORBA.Any)


Occurences of AnySeqHelper

AnySeqHelper occurences:
org.omg.CORBA.AnySeqHelper
org.omg.DynamicAny.AnySeqHelper


Occurences of AnySeqHelper (constructors)

AnySeqHelper (constructors) occurences:
org.omg.CORBA.AnySeqHelper()
org.omg.DynamicAny.AnySeqHelper()


Occurences of AnySeqHolder (constructors)

AnySeqHolder (constructors) occurences:
org.omg.CORBA.AnySeqHolder()
org.omg.CORBA.AnySeqHolder(org.omg.CORBA.Any[])


Occurences of API Help

API Help occurences:
API Help
API Help
API Help
API Help
API Help
API Help
API Help


Occurences of append

append occurences:
java.awt.geom.Path2D.append(java.awt.geom.PathIterator, boolean)
java.awt.geom.Path2D.append(java.awt.Shape, boolean)
java.awt.geom.Path2D.Double.append(java.awt.geom.PathIterator, boolean)
java.awt.geom.Path2D.Float.append(java.awt.geom.PathIterator, boolean)
java.awt.print.Book.append(java.awt.print.Printable, java.awt.print.PageFormat)
java.awt.print.Book.append(java.awt.print.Printable, java.awt.print.PageFormat, int)
java.awt.TextArea.append(java.lang.String)
java.io.CharArrayWriter.append(char)
java.io.CharArrayWriter.append(java.lang.CharSequence)
java.io.CharArrayWriter.append(java.lang.CharSequence, int, int)
java.io.PrintStream.append(char)
java.io.PrintStream.append(java.lang.CharSequence)
java.io.PrintStream.append(java.lang.CharSequence, int, int)
java.io.PrintWriter.append(char)
java.io.PrintWriter.append(java.lang.CharSequence)
java.io.PrintWriter.append(java.lang.CharSequence, int, int)
java.io.StringWriter.append(char)
java.io.StringWriter.append(java.lang.CharSequence)
java.io.StringWriter.append(java.lang.CharSequence, int, int)
java.io.Writer.append(char)
java.io.Writer.append(java.lang.CharSequence)
java.io.Writer.append(java.lang.CharSequence, int, int)
java.lang.Appendable.append(char)
java.lang.Appendable.append(java.lang.CharSequence)
java.lang.Appendable.append(java.lang.CharSequence, int, int)
java.lang.StringBuffer.append(boolean)
java.lang.StringBuffer.append(char)
java.lang.StringBuffer.append(char[])
java.lang.StringBuffer.append(char[], int, int)
java.lang.StringBuffer.append(double)
java.lang.StringBuffer.append(float)
java.lang.StringBuffer.append(int)
java.lang.StringBuffer.append(java.lang.CharSequence)
java.lang.StringBuffer.append(java.lang.CharSequence, int, int)
java.lang.StringBuffer.append(java.lang.Object)
java.lang.StringBuffer.append(java.lang.String)
java.lang.StringBuffer.append(java.lang.StringBuffer)
java.lang.StringBuffer.append(long)
java.lang.StringBuilder.append(boolean)
java.lang.StringBuilder.append(char)
java.lang.StringBuilder.append(char[])
java.lang.StringBuilder.append(char[], int, int)
java.lang.StringBuilder.append(double)
java.lang.StringBuilder.append(float)
java.lang.StringBuilder.append(int)
java.lang.StringBuilder.append(java.lang.CharSequence)
java.lang.StringBuilder.append(java.lang.CharSequence, int, int)
java.lang.StringBuilder.append(java.lang.Object)
java.lang.StringBuilder.append(java.lang.String)
java.lang.StringBuilder.append(java.lang.StringBuffer)
java.lang.StringBuilder.append(long)
java.nio.CharBuffer.append(char)
java.nio.CharBuffer.append(java.lang.CharSequence)
java.nio.CharBuffer.append(java.lang.CharSequence, int, int)
javax.swing.JTextArea.append(java.lang.String)
javax.swing.text.View.append(javax.swing.text.View)


Occurences of appendChild

appendChild occurences:
javax.imageio.metadata.IIOMetadataNode.appendChild(org.w3c.dom.Node)
org.w3c.dom.Node.appendChild(org.w3c.dom.Node)


Occurences of appendCodePoint

appendCodePoint occurences:
java.lang.StringBuffer.appendCodePoint(int)
java.lang.StringBuilder.appendCodePoint(int)


Occurences of appendRemainingComponent

appendRemainingComponent occurences:
javax.naming.NamingException.appendRemainingComponent(java.lang.String)
javax.naming.spi.ResolveResult.appendRemainingComponent(java.lang.String)


Occurences of appendRemainingName

appendRemainingName occurences:
javax.naming.NamingException.appendRemainingName(javax.naming.Name)
javax.naming.spi.ResolveResult.appendRemainingName(javax.naming.Name)


Occurences of APPLET

APPLET occurences:
javax.naming.APPLET
javax.swing.text.html.APPLET


Occurences of applet

applet occurences:
java.applet
javax.swing.text.html.parser.applet


Occurences of appletviewer - The Java Applet Viewer

appletviewer - The Java Applet Viewer occurences:
appletviewer - The Java Applet Viewer
appletviewer - The Java Applet Viewer


Occurences of APPLICATION

APPLICATION occurences:
javax.annotation.APPLICATION
javax.xml.ws.handler.APPLICATION


Occurences of apply

apply occurences:
javax.management.AttributeValueExp.apply(javax.management.ObjectName)
javax.management.ObjectName.apply(javax.management.ObjectName)
javax.management.QueryExp.apply(javax.management.ObjectName)
javax.management.StringValueExp.apply(javax.management.ObjectName)
javax.management.ValueExp.apply(javax.management.ObjectName)


Occurences of applyComponentOrientation

applyComponentOrientation occurences:
java.awt.Component.applyComponentOrientation(java.awt.ComponentOrientation)
java.awt.Container.applyComponentOrientation(java.awt.ComponentOrientation)
javax.swing.JMenu.applyComponentOrientation(java.awt.ComponentOrientation)


Occurences of applyLocalizedPattern

applyLocalizedPattern occurences:
java.text.DecimalFormat.applyLocalizedPattern(java.lang.String)
java.text.SimpleDateFormat.applyLocalizedPattern(java.lang.String)


Occurences of applyPattern

applyPattern occurences:
java.text.ChoiceFormat.applyPattern(java.lang.String)
java.text.DecimalFormat.applyPattern(java.lang.String)
java.text.MessageFormat.applyPattern(java.lang.String)
java.text.SimpleDateFormat.applyPattern(java.lang.String)


Occurences of applyResourceBundle

applyResourceBundle occurences:
java.awt.Window.applyResourceBundle(java.lang.String)
java.awt.Window.applyResourceBundle(java.util.ResourceBundle)


Occurences of APRIL

APRIL occurences:
java.util.APRIL
javax.xml.datatype.APRIL


Occurences of ARABIC

ARABIC occurences:
java.awt.font.ARABIC
java.lang.ARABIC


Occurences of Arc2D.Double (constructors)

Arc2D.Double (constructors) occurences:
java.awt.geom.Arc2D.Double()
java.awt.geom.Arc2D.Double(double, double, double, double, double, double, int)
java.awt.geom.Arc2D.Double(int)
java.awt.geom.Arc2D.Double(java.awt.geom.Rectangle2D, double, double, int)


Occurences of Arc2D.Float (constructors)

Arc2D.Float (constructors) occurences:
java.awt.geom.Arc2D.Float()
java.awt.geom.Arc2D.Float(float, float, float, float, float, float, int)
java.awt.geom.Arc2D.Float(int)
java.awt.geom.Arc2D.Float(java.awt.geom.Rectangle2D, float, float, int)


Occurences of archeight

archeight occurences:
java.awt.geom.archeight
java.awt.geom.archeight


Occurences of arcwidth

arcwidth occurences:
java.awt.geom.arcwidth
java.awt.geom.arcwidth


Occurences of Area (constructors)

Area (constructors) occurences:
java.awt.geom.Area()
java.awt.geom.Area(java.awt.Shape)


Occurences of areFocusTraversalKeysSet

areFocusTraversalKeysSet occurences:
java.awt.Component.areFocusTraversalKeysSet(int)
java.awt.Container.areFocusTraversalKeysSet(int)


Occurences of areTablesSet

areTablesSet occurences:
javax.imageio.plugins.jpeg.JPEGImageReadParam.areTablesSet()
javax.imageio.plugins.jpeg.JPEGImageWriteParam.areTablesSet()


Occurences of arguments

arguments occurences:
com.sun.jdi.Method.arguments()
org.omg.CORBA.Request.arguments()
org.omg.CORBA.ServerRequest.arguments(org.omg.CORBA.NVList)
org.omg.PortableInterceptor.ORBInitInfoOperations.arguments()
org.omg.PortableInterceptor.RequestInfoOperations.arguments()


Occurences of ArithmeticException (constructors)

ArithmeticException (constructors) occurences:
java.lang.ArithmeticException()
java.lang.ArithmeticException(java.lang.String)


Occurences of ARMED

ARMED occurences:
javax.accessibility.ARMED
javax.swing.ARMED


Occurences of ARRAY

ARRAY occurences:
java.sql.ARRAY
javax.lang.model.type.ARRAY


Occurences of Array

Array occurences:
java.lang.reflect.Array
java.sql.Array


Occurences of array

array occurences:
java.nio.Buffer.array()
java.nio.ByteBuffer.array()
java.nio.CharBuffer.array()
java.nio.DoubleBuffer.array()
java.nio.FloatBuffer.array()
java.nio.IntBuffer.array()
java.nio.LongBuffer.array()
java.nio.ShortBuffer.array()
javax.swing.text.array


Occurences of ArrayBlockingQueue (constructors)

ArrayBlockingQueue (constructors) occurences:
java.util.concurrent.ArrayBlockingQueue(int)
java.util.concurrent.ArrayBlockingQueue(int, boolean)
java.util.concurrent.ArrayBlockingQueue(int, boolean, java.util.Collection)


Occurences of ArrayDeque (constructors)

ArrayDeque (constructors) occurences:
java.util.ArrayDeque()
java.util.ArrayDeque(int)
java.util.ArrayDeque(java.util.Collection)


Occurences of ArrayIndexOutOfBoundsException (constructors)

ArrayIndexOutOfBoundsException (constructors) occurences:
java.lang.ArrayIndexOutOfBoundsException()
java.lang.ArrayIndexOutOfBoundsException(int)
java.lang.ArrayIndexOutOfBoundsException(java.lang.String)


Occurences of ArrayList (constructors)

ArrayList (constructors) occurences:
java.util.ArrayList()
java.util.ArrayList(int)
java.util.ArrayList(java.util.Collection)


Occurences of arrayOffset

arrayOffset occurences:
java.nio.Buffer.arrayOffset()
java.nio.ByteBuffer.arrayOffset()
java.nio.CharBuffer.arrayOffset()
java.nio.DoubleBuffer.arrayOffset()
java.nio.FloatBuffer.arrayOffset()
java.nio.IntBuffer.arrayOffset()
java.nio.LongBuffer.arrayOffset()
java.nio.ShortBuffer.arrayOffset()


Occurences of ArrayStoreException (constructors)

ArrayStoreException (constructors) occurences:
java.lang.ArrayStoreException()
java.lang.ArrayStoreException(java.lang.String)


Occurences of ArrayType

ArrayType occurences:
com.sun.jdi.ArrayType
com.sun.mirror.type.ArrayType
javax.lang.model.type.ArrayType
javax.management.openmbean.ArrayType


Occurences of ArrayType (constructors)

ArrayType (constructors) occurences:
javax.management.openmbean.ArrayType(int, javax.management.openmbean.OpenType)
javax.management.openmbean.ArrayType(javax.management.openmbean.SimpleType, boolean)


Occurences of asClassDoc

asClassDoc occurences:
com.sun.javadoc.ParameterizedType.asClassDoc()
com.sun.javadoc.Type.asClassDoc()


Occurences of asElement

asElement occurences:
javax.lang.model.type.DeclaredType.asElement()
javax.lang.model.type.TypeVariable.asElement()
javax.lang.model.util.Types.asElement(javax.lang.model.type.TypeMirror)


Occurences of asin

asin occurences:
java.lang.Math.asin(double)
java.lang.StrictMath.asin(double)


Occurences of asksAllowsChildren

asksAllowsChildren occurences:
javax.swing.tree.asksAllowsChildren
javax.swing.tree.DefaultTreeModel.asksAllowsChildren()


Occurences of asList

asList occurences:
java.util.Arrays.asList(java.lang.Object[])
java.util.Arrays.asList(T...)
javax.management.AttributeList.asList()
javax.management.relation.RoleList.asList()
javax.management.relation.RoleUnresolvedList.asList()


Occurences of asReadOnlyBuffer

asReadOnlyBuffer occurences:
java.nio.ByteBuffer.asReadOnlyBuffer()
java.nio.CharBuffer.asReadOnlyBuffer()
java.nio.DoubleBuffer.asReadOnlyBuffer()
java.nio.FloatBuffer.asReadOnlyBuffer()
java.nio.IntBuffer.asReadOnlyBuffer()
java.nio.LongBuffer.asReadOnlyBuffer()
java.nio.ShortBuffer.asReadOnlyBuffer()


Occurences of assembleSystemMenu

assembleSystemMenu occurences:
javax.swing.plaf.basic.BasicInternalFrameTitlePane.assembleSystemMenu()
javax.swing.plaf.metal.MetalInternalFrameTitlePane.assembleSystemMenu()


Occurences of AssertionError (constructors)

AssertionError (constructors) occurences:
java.lang.AssertionError()
java.lang.AssertionError(boolean)
java.lang.AssertionError(char)
java.lang.AssertionError(double)
java.lang.AssertionError(float)
java.lang.AssertionError(int)
java.lang.AssertionError(java.lang.Object)
java.lang.AssertionError(long)


Occurences of assign

assign occurences:
org.omg.CORBA.DynAny.assign(org.omg.CORBA.DynAny)
org.omg.DynamicAny.DynAnyOperations.assign(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynAnyStub.assign(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynArrayStub.assign(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynEnumStub.assign(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynFixedStub.assign(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynSequenceStub.assign(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynStructStub.assign(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynUnionStub.assign(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynValueStub.assign(org.omg.DynamicAny.DynAny)


Occurences of atan

atan occurences:
java.lang.Math.atan(double)
java.lang.StrictMath.atan(double)


Occurences of atan2

atan2 occurences:
java.lang.Math.atan2(double, double)
java.lang.StrictMath.atan2(double, double)


Occurences of AtomicBoolean (constructors)

AtomicBoolean (constructors) occurences:
java.util.concurrent.atomic.AtomicBoolean()
java.util.concurrent.atomic.AtomicBoolean(boolean)


Occurences of AtomicInteger (constructors)

AtomicInteger (constructors) occurences:
java.util.concurrent.atomic.AtomicInteger()
java.util.concurrent.atomic.AtomicInteger(int)


Occurences of AtomicIntegerArray (constructors)

AtomicIntegerArray (constructors) occurences:
java.util.concurrent.atomic.AtomicIntegerArray(int)
java.util.concurrent.atomic.AtomicIntegerArray(int[])


Occurences of AtomicLong (constructors)

AtomicLong (constructors) occurences:
java.util.concurrent.atomic.AtomicLong()
java.util.concurrent.atomic.AtomicLong(long)


Occurences of AtomicLongArray (constructors)

AtomicLongArray (constructors) occurences:
java.util.concurrent.atomic.AtomicLongArray(int)
java.util.concurrent.atomic.AtomicLongArray(long[])


Occurences of AtomicMarkableReference (constructors)

AtomicMarkableReference (constructors) occurences:
java.util.concurrent.atomic.AtomicMarkableReference(java.lang.Object,boolean)
java.util.concurrent.atomic.AtomicMarkableReference(V, boolean)


Occurences of AtomicReference (constructors)

AtomicReference (constructors) occurences:
java.util.concurrent.atomic.AtomicReference()
java.util.concurrent.atomic.AtomicReference(java.lang.Object)
java.util.concurrent.atomic.AtomicReference(V)


Occurences of AtomicReferenceArray (constructors)

AtomicReferenceArray (constructors) occurences:
java.util.concurrent.atomic.AtomicReferenceArray(E[])
java.util.concurrent.atomic.AtomicReferenceArray(int)
java.util.concurrent.atomic.AtomicReferenceArray(java.lang.Object[])


Occurences of AtomicStampedReference (constructors)

AtomicStampedReference (constructors) occurences:
java.util.concurrent.atomic.AtomicStampedReference(java.lang.Object,int)
java.util.concurrent.atomic.AtomicStampedReference(V, int)


Occurences of attach

attach occurences:
com.sun.jdi.connect.AttachingConnector.attach(java.util.Map)
com.sun.jdi.connect.spi.TransportService.attach(java.lang.String, long, long)
com.sun.tools.attach
com.sun.tools.attach.VirtualMachine.attach(com.sun.tools.attach.VirtualMachineDescriptor)
com.sun.tools.attach.VirtualMachine.attach(java.lang.String)
java.nio.channels.SelectionKey.attach(java.lang.Object)


Occurences of Attach API

Attach API occurences:
Attach API
Attach API


Occurences of attachment

attachment occurences:
java.nio.channels.SelectionKey.attachment()
javax.xml.bind.attachment


Occurences of AttachNotSupportedException (constructors)

AttachNotSupportedException (constructors) occurences:
com.sun.tools.attach.AttachNotSupportedException()
com.sun.tools.attach.AttachNotSupportedException(java.lang.String)


Occurences of AttachPermission (constructors)

AttachPermission (constructors) occurences:
com.sun.tools.attach.AttachPermission(java.lang.String)
com.sun.tools.attach.AttachPermission(java.lang.String, java.lang.String)


Occurences of attachVirtualMachine

attachVirtualMachine occurences:
com.sun.tools.attach.spi.AttachProvider.attachVirtualMachine(com.sun.tools.attach.VirtualMachineDescriptor)
com.sun.tools.attach.spi.AttachProvider.attachVirtualMachine(java.lang.String)


Occurences of attemptMark

attemptMark occurences:
java.util.concurrent.atomic.AtomicMarkableReference.attemptMark(java.lang.Object,boolean)
java.util.concurrent.atomic.AtomicMarkableReference.attemptMark(V, boolean)


Occurences of attemptStamp

attemptStamp occurences:
java.util.concurrent.atomic.AtomicStampedReference.attemptStamp(java.lang.Object,int)
java.util.concurrent.atomic.AtomicStampedReference.attemptStamp(V, int)


Occurences of attr

attr occurences:
javax.management.Query.attr(java.lang.String)
javax.management.Query.attr(java.lang.String, java.lang.String)


Occurences of Attribute

Attribute occurences:
javax.management.Attribute
javax.naming.directory.Attribute
javax.print.attribute.Attribute
javax.xml.stream.events.Attribute


Occurences of attributeDecl

attributeDecl occurences:
org.xml.sax.ext.DeclHandler.attributeDecl(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.ext.DefaultHandler2.attributeDecl(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)


Occurences of AttributedString (constructors)

AttributedString (constructors) occurences:
java.text.AttributedString(java.lang.String)
java.text.AttributedString(java.lang.String, java.util.Map)
java.text.AttributedString(java.text.AttributedCharacterIterator)
java.text.AttributedString(java.text.AttributedCharacterIterator, int, int)
java.text.AttributedString(java.text.AttributedCharacterIterator, int, int, java.text.AttributedCharacterIterator.Attribute[])


Occurences of AttributeInUseException (constructors)

AttributeInUseException (constructors) occurences:
javax.naming.directory.AttributeInUseException()
javax.naming.directory.AttributeInUseException(java.lang.String)


Occurences of AttributeList

AttributeList occurences:
javax.management.AttributeList
javax.swing.text.html.parser.AttributeList
org.xml.sax.AttributeList


Occurences of AttributeList (constructors)

AttributeList (constructors) occurences:
javax.management.AttributeList()
javax.management.AttributeList(int)
javax.management.AttributeList(java.util.List)
javax.management.AttributeList(javax.management.AttributeList)
javax.swing.text.html.parser.AttributeList(java.lang.String)
javax.swing.text.html.parser.AttributeList(java.lang.String, int, int, java.lang.String, java.util.Vector, javax.swing.text.html.parser.AttributeList)


Occurences of AttributeListImpl (constructors)

AttributeListImpl (constructors) occurences:
org.xml.sax.helpers.AttributeListImpl()
org.xml.sax.helpers.AttributeListImpl(org.xml.sax.AttributeList)


Occurences of AttributeModificationException (constructors)

AttributeModificationException (constructors) occurences:
javax.naming.directory.AttributeModificationException()
javax.naming.directory.AttributeModificationException(java.lang.String)


Occurences of AttributeNotFoundException (constructors)

AttributeNotFoundException (constructors) occurences:
javax.management.AttributeNotFoundException()
javax.management.AttributeNotFoundException(java.lang.String)


Occurences of Attributes

Attributes occurences:
java.util.jar.Attributes
javax.naming.directory.Attributes
org.xml.sax.Attributes


Occurences of Attributes (constructors)

Attributes (constructors) occurences:
java.util.jar.Attributes()
java.util.jar.Attributes(int)
java.util.jar.Attributes(java.util.jar.Attributes)


Occurences of Attributes2Impl (constructors)

Attributes2Impl (constructors) occurences:
org.xml.sax.ext.Attributes2Impl()
org.xml.sax.ext.Attributes2Impl(org.xml.sax.Attributes)


Occurences of AttributeSet

AttributeSet occurences:
javax.print.attribute.AttributeSet
javax.swing.text.AttributeSet


Occurences of AttributesImpl (constructors)

AttributesImpl (constructors) occurences:
org.xml.sax.helpers.AttributesImpl()
org.xml.sax.helpers.AttributesImpl(org.xml.sax.Attributes)


Occurences of attributeUpdate

attributeUpdate occurences:
javax.print.event.PrintJobAttributeListener.attributeUpdate(javax.print.event.PrintJobAttributeEvent)
javax.print.event.PrintServiceAttributeListener.attributeUpdate(javax.print.event.PrintServiceAttributeEvent)


Occurences of AttributeValueExp (constructors)

AttributeValueExp (constructors) occurences:
javax.management.AttributeValueExp()
javax.management.AttributeValueExp(java.lang.String)


Occurences of AudioFileFormat (constructors)

AudioFileFormat (constructors) occurences:
javax.sound.sampled.AudioFileFormat(javax.sound.sampled.AudioFileFormat.Type, int, javax.sound.sampled.AudioFormat, int)
javax.sound.sampled.AudioFileFormat(javax.sound.sampled.AudioFileFormat.Type, javax.sound.sampled.AudioFormat, int)
javax.sound.sampled.AudioFileFormat(javax.sound.sampled.AudioFileFormat.Type, javax.sound.sampled.AudioFormat, int, java.util.Map)


Occurences of AudioFormat (constructors)

AudioFormat (constructors) occurences:
javax.sound.sampled.AudioFormat(float, int, int, boolean, boolean)
javax.sound.sampled.AudioFormat(javax.sound.sampled.AudioFormat.Encoding, float, int, int, int, float, boolean)
javax.sound.sampled.AudioFormat(javax.sound.sampled.AudioFormat.Encoding, float, int, int, int, float, boolean, java.util.Map)


Occurences of AudioInputStream (constructors)

AudioInputStream (constructors) occurences:
javax.sound.sampled.AudioInputStream(java.io.InputStream, javax.sound.sampled.AudioFormat, long)
javax.sound.sampled.AudioInputStream(javax.sound.sampled.TargetDataLine)


Occurences of AudioPermission (constructors)

AudioPermission (constructors) occurences:
javax.sound.sampled.AudioPermission(java.lang.String)
javax.sound.sampled.AudioPermission(java.lang.String, java.lang.String)


Occurences of AUGUST

AUGUST occurences:
java.util.AUGUST
javax.xml.datatype.AUGUST


Occurences of AuthenticationException

AuthenticationException occurences:
javax.naming.AuthenticationException
javax.security.sasl.AuthenticationException


Occurences of AuthenticationException (constructors)

AuthenticationException (constructors) occurences:
javax.naming.AuthenticationException()
javax.naming.AuthenticationException(java.lang.String)
javax.security.sasl.AuthenticationException()
javax.security.sasl.AuthenticationException(java.lang.String)
javax.security.sasl.AuthenticationException(java.lang.String, java.lang.Throwable)


Occurences of AuthenticationNotSupportedException (constructors)

AuthenticationNotSupportedException (constructors) occurences:
javax.naming.AuthenticationNotSupportedException()
javax.naming.AuthenticationNotSupportedException(java.lang.String)


Occurences of AuthPermission (constructors)

AuthPermission (constructors) occurences:
javax.security.auth.AuthPermission(java.lang.String)
javax.security.auth.AuthPermission(java.lang.String, java.lang.String)


Occurences of AUTOSENSE

AUTOSENSE occurences:
javax.print.AUTOSENSE
javax.print.AUTOSENSE
javax.print.AUTOSENSE


Occurences of available

available occurences:
java.io.BufferedInputStream.available()
java.io.ByteArrayInputStream.available()
java.io.FileInputStream.available()
java.io.FilterInputStream.available()
java.io.InputStream.available()
java.io.LineNumberInputStream.available()
java.io.ObjectInput.available()
java.io.ObjectInputStream.available()
java.io.PipedInputStream.available()
java.io.PushbackInputStream.available()
java.io.SequenceInputStream.available()
java.io.StringBufferInputStream.available()
java.net.SocketImpl.available()
java.util.zip.DeflaterInputStream.available()
java.util.zip.InflaterInputStream.available()
java.util.zip.ZipInputStream.available()
javax.crypto.CipherInputStream.available()
javax.sound.sampled.AudioInputStream.available()
javax.sound.sampled.DataLine.available()


Occurences of availableLocales

availableLocales occurences:
javax.imageio.availableLocales
javax.imageio.availableLocales


Occurences of avoidingGui

avoidingGui occurences:
java.beans.beancontext.BeanContextSupport.avoidingGui()
java.beans.Visibility.avoidingGui()


Occurences of await

await occurences:
java.util.concurrent.CountDownLatch.await()
java.util.concurrent.CountDownLatch.await(long, java.util.concurrent.TimeUnit)
java.util.concurrent.CyclicBarrier.await()
java.util.concurrent.CyclicBarrier.await(long, java.util.concurrent.TimeUnit)
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.await()
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.await(long, java.util.concurrent.TimeUnit)
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.await()
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.await(long, java.util.concurrent.TimeUnit)
java.util.concurrent.locks.Condition.await()
java.util.concurrent.locks.Condition.await(long, java.util.concurrent.TimeUnit)


Occurences of awaitNanos

awaitNanos occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.awaitNanos(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.awaitNanos(long)
java.util.concurrent.locks.Condition.awaitNanos(long)


Occurences of awaitTermination

awaitTermination occurences:
java.util.concurrent.ExecutorService.awaitTermination(long, java.util.concurrent.TimeUnit)
java.util.concurrent.ThreadPoolExecutor.awaitTermination(long, java.util.concurrent.TimeUnit)


Occurences of awaitUninterruptibly

awaitUninterruptibly occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.awaitUninterruptibly()
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.awaitUninterruptibly()
java.util.concurrent.locks.Condition.awaitUninterruptibly()


Occurences of awaitUntil

awaitUntil occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.awaitUntil(java.util.Date)
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.awaitUntil(java.util.Date)
java.util.concurrent.locks.Condition.awaitUntil(java.util.Date)


Occurences of AWT Enhancements

AWT Enhancements occurences:
AWT Enhancements
AWT Enhancements


Occurences of AWTEvent (constructors)

AWTEvent (constructors) occurences:
java.awt.AWTEvent(java.awt.Event)
java.awt.AWTEvent(java.lang.Object, int)


Occurences of AWTKeyStroke (constructors)

AWTKeyStroke (constructors) occurences:
java.awt.AWTKeyStroke()
java.awt.AWTKeyStroke(char, int, int, boolean)


Occurences of AWTPermission (constructors)

AWTPermission (constructors) occurences:
java.awt.AWTPermission(java.lang.String)
java.awt.AWTPermission(java.lang.String, java.lang.String)


Occurences of B

B occurences:
java.awt.B
javax.print.attribute.standard.B
javax.print.attribute.standard.B
javax.swing.text.html.B


Occurences of B0

B0 occurences:
java.awt.B0
javax.print.attribute.standard.B0
javax.print.attribute.standard.B0


Occurences of B1

B1 occurences:
java.awt.B1
javax.print.attribute.standard.B1
javax.print.attribute.standard.B1


Occurences of B10

B10 occurences:
java.awt.B10
javax.print.attribute.standard.B10
javax.print.attribute.standard.B10


Occurences of B2

B2 occurences:
java.awt.B2
javax.print.attribute.standard.B2
javax.print.attribute.standard.B2


Occurences of B3

B3 occurences:
java.awt.B3
javax.print.attribute.standard.B3
javax.print.attribute.standard.B3


Occurences of B4

B4 occurences:
java.awt.B4
javax.print.attribute.standard.B4
javax.print.attribute.standard.B4


Occurences of B5

B5 occurences:
java.awt.B5
javax.print.attribute.standard.B5
javax.print.attribute.standard.B5


Occurences of B6

B6 occurences:
java.awt.B6
javax.print.attribute.standard.B6
javax.print.attribute.standard.B6


Occurences of B7

B7 occurences:
java.awt.B7
javax.print.attribute.standard.B7
javax.print.attribute.standard.B7


Occurences of B8

B8 occurences:
java.awt.B8
javax.print.attribute.standard.B8
javax.print.attribute.standard.B8


Occurences of B9

B9 occurences:
java.awt.B9
javax.print.attribute.standard.B9
javax.print.attribute.standard.B9


Occurences of BACKGROUND

BACKGROUND occurences:
java.awt.BACKGROUND
java.awt.font.BACKGROUND
javax.swing.plaf.synth.BACKGROUND
javax.swing.text.html.BACKGROUND
javax.swing.text.html.BACKGROUND


Occurences of BackingStoreException (constructors)

BackingStoreException (constructors) occurences:
java.util.prefs.BackingStoreException(java.lang.String)
java.util.prefs.BackingStoreException(java.lang.Throwable)


Occurences of BadKind (constructors)

BadKind (constructors) occurences:
org.omg.CORBA.TypeCodePackage.BadKind()
org.omg.CORBA.TypeCodePackage.BadKind(java.lang.String)


Occurences of BadPaddingException (constructors)

BadPaddingException (constructors) occurences:
javax.crypto.BadPaddingException()
javax.crypto.BadPaddingException(java.lang.String)


Occurences of BAD_CONTEXT (constructors)

BAD_CONTEXT (constructors) occurences:
org.omg.CORBA.BAD_CONTEXT()
org.omg.CORBA.BAD_CONTEXT(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.BAD_CONTEXT(java.lang.String)
org.omg.CORBA.BAD_CONTEXT(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of BAD_INV_ORDER (constructors)

BAD_INV_ORDER (constructors) occurences:
org.omg.CORBA.BAD_INV_ORDER()
org.omg.CORBA.BAD_INV_ORDER(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.BAD_INV_ORDER(java.lang.String)
org.omg.CORBA.BAD_INV_ORDER(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of BAD_OPERATION (constructors)

BAD_OPERATION (constructors) occurences:
org.omg.CORBA.BAD_OPERATION()
org.omg.CORBA.BAD_OPERATION(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.BAD_OPERATION(java.lang.String)
org.omg.CORBA.BAD_OPERATION(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of BAD_PARAM (constructors)

BAD_PARAM (constructors) occurences:
org.omg.CORBA.BAD_PARAM()
org.omg.CORBA.BAD_PARAM(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.BAD_PARAM(java.lang.String)
org.omg.CORBA.BAD_PARAM(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of BAD_QOS (constructors)

BAD_QOS (constructors) occurences:
org.omg.CORBA.BAD_QOS()
org.omg.CORBA.BAD_QOS(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.BAD_QOS(java.lang.String)
org.omg.CORBA.BAD_QOS(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of BAD_TYPECODE (constructors)

BAD_TYPECODE (constructors) occurences:
org.omg.CORBA.BAD_TYPECODE()
org.omg.CORBA.BAD_TYPECODE(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.BAD_TYPECODE(java.lang.String)
org.omg.CORBA.BAD_TYPECODE(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of BandedSampleModel (constructors)

BandedSampleModel (constructors) occurences:
java.awt.image.BandedSampleModel(int, int, int, int)
java.awt.image.BandedSampleModel(int, int, int, int, int[], int[])


Occurences of BASELINE

BASELINE occurences:
java.awt.BASELINE
javax.swing.BASELINE
javax.swing.BASELINE


Occurences of BasicArrowButton (constructors)

BasicArrowButton (constructors) occurences:
javax.swing.plaf.basic.BasicArrowButton(int)
javax.swing.plaf.basic.BasicArrowButton(int, java.awt.Color, java.awt.Color, java.awt.Color, java.awt.Color)


Occurences of BasicAttribute (constructors)

BasicAttribute (constructors) occurences:
javax.naming.directory.BasicAttribute(java.lang.String)
javax.naming.directory.BasicAttribute(java.lang.String, boolean)
javax.naming.directory.BasicAttribute(java.lang.String, java.lang.Object)
javax.naming.directory.BasicAttribute(java.lang.String, java.lang.Object, boolean)


Occurences of BasicAttributes (constructors)

BasicAttributes (constructors) occurences:
javax.naming.directory.BasicAttributes()
javax.naming.directory.BasicAttributes(boolean)
javax.naming.directory.BasicAttributes(java.lang.String, java.lang.Object)
javax.naming.directory.BasicAttributes(java.lang.String, java.lang.Object, boolean)


Occurences of BasicControl (constructors)

BasicControl (constructors) occurences:
javax.naming.ldap.BasicControl(java.lang.String)
javax.naming.ldap.BasicControl(java.lang.String, boolean, byte[])


Occurences of BasicPermission (constructors)

BasicPermission (constructors) occurences:
java.security.BasicPermission(java.lang.String)
java.security.BasicPermission(java.lang.String, java.lang.String)


Occurences of BasicScrollBarUI.ScrollListener (constructors)

BasicScrollBarUI.ScrollListener (constructors) occurences:
javax.swing.plaf.basic.BasicScrollBarUI.ScrollListener()
javax.swing.plaf.basic.BasicScrollBarUI.ScrollListener(int, boolean)


Occurences of BasicSliderUI.ScrollListener (constructors)

BasicSliderUI.ScrollListener (constructors) occurences:
javax.swing.plaf.basic.BasicSliderUI.ScrollListener()
javax.swing.plaf.basic.BasicSliderUI.ScrollListener(int, boolean)


Occurences of BasicStroke (constructors)

BasicStroke (constructors) occurences:
java.awt.BasicStroke()
java.awt.BasicStroke(float)
java.awt.BasicStroke(float, int, int)
java.awt.BasicStroke(float, int, int, float)
java.awt.BasicStroke(float, int, int, float, float[], float)


Occurences of BatchUpdateException (constructors)

BatchUpdateException (constructors) occurences:
java.sql.BatchUpdateException()
java.sql.BatchUpdateException(int[])
java.sql.BatchUpdateException(int[], java.lang.Throwable)
java.sql.BatchUpdateException(java.lang.String, int[])
java.sql.BatchUpdateException(java.lang.String, int[], java.lang.Throwable)
java.sql.BatchUpdateException(java.lang.String, java.lang.String, int, int[])
java.sql.BatchUpdateException(java.lang.String, java.lang.String, int, int[], java.lang.Throwable)
java.sql.BatchUpdateException(java.lang.String, java.lang.String, int[])
java.sql.BatchUpdateException(java.lang.String, java.lang.String, int[], java.lang.Throwable)
java.sql.BatchUpdateException(java.lang.Throwable)


Occurences of bcsPreDeserializationHook

bcsPreDeserializationHook occurences:
java.beans.beancontext.BeanContextServicesSupport.bcsPreDeserializationHook(java.io.ObjectInputStream)
java.beans.beancontext.BeanContextSupport.bcsPreDeserializationHook(java.io.ObjectInputStream)


Occurences of bcsPreSerializationHook

bcsPreSerializationHook occurences:
java.beans.beancontext.BeanContextServicesSupport.bcsPreSerializationHook(java.io.ObjectOutputStream)
java.beans.beancontext.BeanContextSupport.bcsPreSerializationHook(java.io.ObjectOutputStream)


Occurences of be

be occurences:
java.nio.channels.spi.be
java.nio.channels.spi.be


Occurences of BeanContextChildSupport (constructors)

BeanContextChildSupport (constructors) occurences:
java.beans.beancontext.BeanContextChildSupport()
java.beans.beancontext.BeanContextChildSupport(java.beans.beancontext.BeanContextChild)


Occurences of BeanContextMembershipEvent (constructors)

BeanContextMembershipEvent (constructors) occurences:
java.beans.beancontext.BeanContextMembershipEvent(java.beans.beancontext.BeanContext, java.lang.Object[])
java.beans.beancontext.BeanContextMembershipEvent(java.beans.beancontext.BeanContext, java.util.Collection)


Occurences of BeanContextServicesSupport (constructors)

BeanContextServicesSupport (constructors) occurences:
java.beans.beancontext.BeanContextServicesSupport()
java.beans.beancontext.BeanContextServicesSupport(java.beans.beancontext.BeanContextServices)
java.beans.beancontext.BeanContextServicesSupport(java.beans.beancontext.BeanContextServices, java.util.Locale)
java.beans.beancontext.BeanContextServicesSupport(java.beans.beancontext.BeanContextServices, java.util.Locale, boolean)
java.beans.beancontext.BeanContextServicesSupport(java.beans.beancontext.BeanContextServices, java.util.Locale, boolean, boolean)


Occurences of BeanContextSupport (constructors)

BeanContextSupport (constructors) occurences:
java.beans.beancontext.BeanContextSupport()
java.beans.beancontext.BeanContextSupport(java.beans.beancontext.BeanContext)
java.beans.beancontext.BeanContextSupport(java.beans.beancontext.BeanContext, java.util.Locale)
java.beans.beancontext.BeanContextSupport(java.beans.beancontext.BeanContext, java.util.Locale, boolean)
java.beans.beancontext.BeanContextSupport(java.beans.beancontext.BeanContext, java.util.Locale, boolean, boolean)


Occurences of BeanDescriptor (constructors)

BeanDescriptor (constructors) occurences:
java.beans.BeanDescriptor(java.lang.Class)
java.beans.BeanDescriptor(java.lang.Class, java.lang.Class)


Occurences of before

before occurences:
java.sql.Timestamp.before(java.sql.Timestamp)
java.util.Calendar.before(java.lang.Object)
java.util.Date.before(java.util.Date)


Occurences of begin

begin occurences:
java.nio.channels.spi.AbstractInterruptibleChannel.begin()
java.nio.channels.spi.AbstractSelector.begin()


Occurences of beginDraggingFrame

beginDraggingFrame occurences:
javax.swing.DefaultDesktopManager.beginDraggingFrame(javax.swing.JComponent)
javax.swing.DesktopManager.beginDraggingFrame(javax.swing.JComponent)


Occurences of beginResizingFrame

beginResizingFrame occurences:
javax.swing.DefaultDesktopManager.beginResizingFrame(javax.swing.JComponent, int)
javax.swing.DesktopManager.beginResizingFrame(javax.swing.JComponent, int)


Occurences of BENGALI

BENGALI occurences:
java.awt.font.BENGALI
java.lang.BENGALI


Occurences of BevelBorder (constructors)

BevelBorder (constructors) occurences:
javax.swing.border.BevelBorder(int)
javax.swing.border.BevelBorder(int, java.awt.Color, java.awt.Color)
javax.swing.border.BevelBorder(int, java.awt.Color, java.awt.Color, java.awt.Color, java.awt.Color)


Occurences of Bidi (constructors)

Bidi (constructors) occurences:
java.text.Bidi(char[], int, byte[], int, int, int)
java.text.Bidi(java.lang.String, int)
java.text.Bidi(java.text.AttributedCharacterIterator)


Occurences of BigDecimal (constructors)

BigDecimal (constructors) occurences:
java.math.BigDecimal(char[])
java.math.BigDecimal(char[], int, int)
java.math.BigDecimal(char[], int, int, java.math.MathContext)
java.math.BigDecimal(char[], java.math.MathContext)
java.math.BigDecimal(double)
java.math.BigDecimal(double, java.math.MathContext)
java.math.BigDecimal(int)
java.math.BigDecimal(int, java.math.MathContext)
java.math.BigDecimal(java.lang.String)
java.math.BigDecimal(java.lang.String, java.math.MathContext)
java.math.BigDecimal(java.math.BigInteger)
java.math.BigDecimal(java.math.BigInteger, int)
java.math.BigDecimal(java.math.BigInteger, int, java.math.MathContext)
java.math.BigDecimal(java.math.BigInteger, java.math.MathContext)
java.math.BigDecimal(long)
java.math.BigDecimal(long, java.math.MathContext)


Occurences of BigInteger (constructors)

BigInteger (constructors) occurences:
java.math.BigInteger(byte[])
java.math.BigInteger(int, byte[])
java.math.BigInteger(int, int, java.util.Random)
java.math.BigInteger(int, java.util.Random)
java.math.BigInteger(java.lang.String)
java.math.BigInteger(java.lang.String, int)


Occurences of BinaryRefAddr (constructors)

BinaryRefAddr (constructors) occurences:
javax.naming.BinaryRefAddr(java.lang.String, byte[])
javax.naming.BinaryRefAddr(java.lang.String, byte[], int, int)


Occurences of binarySearch

binarySearch occurences:
java.util.Arrays.binarySearch(byte[], byte)
java.util.Arrays.binarySearch(byte[], int, int, byte)
java.util.Arrays.binarySearch(char[], char)
java.util.Arrays.binarySearch(char[], int, int, char)
java.util.Arrays.binarySearch(double[], double)
java.util.Arrays.binarySearch(double[], int, int, double)
java.util.Arrays.binarySearch(float[], float)
java.util.Arrays.binarySearch(float[], int, int, float)
java.util.Arrays.binarySearch(int[], int)
java.util.Arrays.binarySearch(int[], int, int, int)
java.util.Arrays.binarySearch(java.lang.Object[], int, int, java.lang.Object)
java.util.Arrays.binarySearch(java.lang.Object[], java.lang.Object)
java.util.Arrays.binarySearch(java.lang.Object[],int,int,java.lang.Object,java.util.Comparator)
java.util.Arrays.binarySearch(java.lang.Object[],java.lang.Object,java.util.Comparator)
java.util.Arrays.binarySearch(long[], int, int, long)
java.util.Arrays.binarySearch(long[], long)
java.util.Arrays.binarySearch(short[], int, int, short)
java.util.Arrays.binarySearch(short[], short)
java.util.Arrays.binarySearch(T[], int, int, T, java.util.Comparator)
java.util.Arrays.binarySearch(T[], T, java.util.Comparator)
java.util.Collections.binarySearch(java.util.List, T)
java.util.Collections.binarySearch(java.util.List, T, java.util.Comparator)
java.util.Collections.binarySearch(java.util.List,java.lang.Object)
java.util.Collections.binarySearch(java.util.List,java.lang.Object,java.util.Comparator)


Occurences of bind

bind occurences:
java.net.DatagramSocket.bind(java.net.SocketAddress)
java.net.DatagramSocketImpl.bind(int, java.net.InetAddress)
java.net.ServerSocket.bind(java.net.SocketAddress)
java.net.ServerSocket.bind(java.net.SocketAddress, int)
java.net.Socket.bind(java.net.SocketAddress)
java.net.SocketImpl.bind(java.net.InetAddress, int)
java.rmi.Naming.bind(java.lang.String, java.rmi.Remote)
java.rmi.registry.Registry.bind(java.lang.String, java.rmi.Remote)
javax.naming.Context.bind(java.lang.String, java.lang.Object)
javax.naming.Context.bind(javax.naming.Name, java.lang.Object)
javax.naming.directory.DirContext.bind(java.lang.String, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.directory.DirContext.bind(javax.naming.Name, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.bind(java.lang.String, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.bind(javax.naming.Name, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.InitialContext.bind(java.lang.String, java.lang.Object)
javax.naming.InitialContext.bind(javax.naming.Name, java.lang.Object)
javax.xml.bind
org.omg.CosNaming.NamingContextOperations.bind(org.omg.CosNaming.NameComponent[], org.omg.CORBA.Object)
org.omg.CosNaming._NamingContextExtStub.bind(org.omg.CosNaming.NameComponent[], org.omg.CORBA.Object)
org.omg.CosNaming._NamingContextStub.bind(org.omg.CosNaming.NameComponent[], org.omg.CORBA.Object)


Occurences of BindException (constructors)

BindException (constructors) occurences:
java.net.BindException()
java.net.BindException(java.lang.String)


Occurences of Binding

Binding occurences:
javax.naming.Binding
javax.xml.ws.Binding
org.omg.CosNaming.Binding


Occurences of Binding (constructors)

Binding (constructors) occurences:
javax.naming.Binding(java.lang.String, java.lang.Object)
javax.naming.Binding(java.lang.String, java.lang.Object, boolean)
javax.naming.Binding(java.lang.String, java.lang.String, java.lang.Object)
javax.naming.Binding(java.lang.String, java.lang.String, java.lang.Object, boolean)
org.omg.CosNaming.Binding()
org.omg.CosNaming.Binding(org.omg.CosNaming.NameComponent[], org.omg.CosNaming.BindingType)


Occurences of BindingHolder (constructors)

BindingHolder (constructors) occurences:
org.omg.CosNaming.BindingHolder()
org.omg.CosNaming.BindingHolder(org.omg.CosNaming.Binding)


Occurences of BindingIteratorHolder (constructors)

BindingIteratorHolder (constructors) occurences:
org.omg.CosNaming.BindingIteratorHolder()
org.omg.CosNaming.BindingIteratorHolder(org.omg.CosNaming.BindingIterator)


Occurences of BindingListHolder (constructors)

BindingListHolder (constructors) occurences:
org.omg.CosNaming.BindingListHolder()
org.omg.CosNaming.BindingListHolder(org.omg.CosNaming.Binding[])


Occurences of BindingType

BindingType occurences:
javax.xml.ws.BindingType
org.omg.CosNaming.BindingType


Occurences of BindingTypeHolder (constructors)

BindingTypeHolder (constructors) occurences:
org.omg.CosNaming.BindingTypeHolder()
org.omg.CosNaming.BindingTypeHolder(org.omg.CosNaming.BindingType)


Occurences of bind_context

bind_context occurences:
org.omg.CosNaming.NamingContextOperations.bind_context(org.omg.CosNaming.NameComponent[], org.omg.CosNaming.NamingContext)
org.omg.CosNaming._NamingContextExtStub.bind_context(org.omg.CosNaming.NameComponent[], org.omg.CosNaming.NamingContext)
org.omg.CosNaming._NamingContextStub.bind_context(org.omg.CosNaming.NameComponent[], org.omg.CosNaming.NamingContext)


Occurences of bind_new_context

bind_new_context occurences:
org.omg.CosNaming.NamingContextOperations.bind_new_context(org.omg.CosNaming.NameComponent[])
org.omg.CosNaming._NamingContextExtStub.bind_new_context(org.omg.CosNaming.NameComponent[])
org.omg.CosNaming._NamingContextStub.bind_new_context(org.omg.CosNaming.NameComponent[])


Occurences of bitCount

bitCount occurences:
java.lang.Integer.bitCount(int)
java.lang.Long.bitCount(long)
java.math.BigInteger.bitCount()


Occurences of BitSet (constructors)

BitSet (constructors) occurences:
java.util.BitSet()
java.util.BitSet(int)


Occurences of Blob

Blob occurences:
Blob
java.sql.Blob


Occurences of blockingLock

blockingLock occurences:
java.nio.channels.SelectableChannel.blockingLock()
java.nio.channels.spi.AbstractSelectableChannel.blockingLock()


Occurences of BMPImageWriteParam (constructors)

BMPImageWriteParam (constructors) occurences:
javax.imageio.plugins.bmp.BMPImageWriteParam()
javax.imageio.plugins.bmp.BMPImageWriteParam(java.util.Locale)


Occurences of BOOLEAN

BOOLEAN occurences:
com.sun.mirror.type.BOOLEAN
java.sql.BOOLEAN
javax.lang.model.type.BOOLEAN
javax.management.openmbean.BOOLEAN
javax.xml.xpath.BOOLEAN


Occurences of Boolean (constructors)

Boolean (constructors) occurences:
java.lang.Boolean(boolean)
java.lang.Boolean(java.lang.String)


Occurences of BooleanControl (constructors)

BooleanControl (constructors) occurences:
javax.sound.sampled.BooleanControl(javax.sound.sampled.BooleanControl.Type, boolean)
javax.sound.sampled.BooleanControl(javax.sound.sampled.BooleanControl.Type, boolean, java.lang.String, java.lang.String)


Occurences of BooleanHolder (constructors)

BooleanHolder (constructors) occurences:
org.omg.CORBA.BooleanHolder()
org.omg.CORBA.BooleanHolder(boolean)


Occurences of BooleanSeqHolder (constructors)

BooleanSeqHolder (constructors) occurences:
org.omg.CORBA.BooleanSeqHolder()
org.omg.CORBA.BooleanSeqHolder(boolean[])


Occurences of booleanValue

booleanValue occurences:
com.sun.jdi.connect.Connector.BooleanArgument.booleanValue()
com.sun.jdi.PrimitiveValue.booleanValue()
java.lang.Boolean.booleanValue()


Occurences of border

border occurences:
javax.swing.border
javax.swing.border.border
javax.swing.tree.border


Occurences of BORDER

BORDER occurences:
javax.swing.text.html.BORDER
javax.swing.text.html.BORDER


Occurences of borderInsets

borderInsets occurences:
javax.swing.plaf.metal.borderInsets
javax.swing.plaf.metal.borderInsets
javax.swing.plaf.metal.borderInsets
javax.swing.plaf.metal.borderInsets


Occurences of BorderLayout (constructors)

BorderLayout (constructors) occurences:
java.awt.BorderLayout()
java.awt.BorderLayout(int, int)


Occurences of borderSelectionColor

borderSelectionColor occurences:
javax.swing.tree.borderSelectionColor
javax.swing.tree.borderSelectionColor


Occurences of BorderUIResource.BevelBorderUIResource (constructors)

BorderUIResource.BevelBorderUIResource (constructors) occurences:
javax.swing.plaf.BorderUIResource.BevelBorderUIResource(int)
javax.swing.plaf.BorderUIResource.BevelBorderUIResource(int, java.awt.Color, java.awt.Color)
javax.swing.plaf.BorderUIResource.BevelBorderUIResource(int, java.awt.Color, java.awt.Color, java.awt.Color, java.awt.Color)


Occurences of BorderUIResource.EmptyBorderUIResource (constructors)

BorderUIResource.EmptyBorderUIResource (constructors) occurences:
javax.swing.plaf.BorderUIResource.EmptyBorderUIResource(int, int, int, int)
javax.swing.plaf.BorderUIResource.EmptyBorderUIResource(java.awt.Insets)


Occurences of BorderUIResource.EtchedBorderUIResource (constructors)

BorderUIResource.EtchedBorderUIResource (constructors) occurences:
javax.swing.plaf.BorderUIResource.EtchedBorderUIResource()
javax.swing.plaf.BorderUIResource.EtchedBorderUIResource(int)
javax.swing.plaf.BorderUIResource.EtchedBorderUIResource(int, java.awt.Color, java.awt.Color)
javax.swing.plaf.BorderUIResource.EtchedBorderUIResource(java.awt.Color, java.awt.Color)


Occurences of BorderUIResource.LineBorderUIResource (constructors)

BorderUIResource.LineBorderUIResource (constructors) occurences:
javax.swing.plaf.BorderUIResource.LineBorderUIResource(java.awt.Color)
javax.swing.plaf.BorderUIResource.LineBorderUIResource(java.awt.Color, int)


Occurences of BorderUIResource.MatteBorderUIResource (constructors)

BorderUIResource.MatteBorderUIResource (constructors) occurences:
javax.swing.plaf.BorderUIResource.MatteBorderUIResource(int, int, int, int, java.awt.Color)
javax.swing.plaf.BorderUIResource.MatteBorderUIResource(int, int, int, int, javax.swing.Icon)
javax.swing.plaf.BorderUIResource.MatteBorderUIResource(javax.swing.Icon)


Occurences of BorderUIResource.TitledBorderUIResource (constructors)

BorderUIResource.TitledBorderUIResource (constructors) occurences:
javax.swing.plaf.BorderUIResource.TitledBorderUIResource(java.lang.String)
javax.swing.plaf.BorderUIResource.TitledBorderUIResource(javax.swing.border.Border)
javax.swing.plaf.BorderUIResource.TitledBorderUIResource(javax.swing.border.Border, java.lang.String)
javax.swing.plaf.BorderUIResource.TitledBorderUIResource(javax.swing.border.Border, java.lang.String, int, int)
javax.swing.plaf.BorderUIResource.TitledBorderUIResource(javax.swing.border.Border, java.lang.String, int, int, java.awt.Font)
javax.swing.plaf.BorderUIResource.TitledBorderUIResource(javax.swing.border.Border, java.lang.String, int, int, java.awt.Font, java.awt.Color)


Occurences of BOTTOM

BOTTOM occurences:
javax.print.attribute.standard.BOTTOM
javax.swing.border.BOTTOM
javax.swing.BOTTOM
javax.swing.BOTTOM


Occurences of bottom

bottom occurences:
java.awt.bottom
javax.swing.border.bottom


Occurences of BOTTOM_ALIGNMENT

BOTTOM_ALIGNMENT occurences:
java.awt.BOTTOM_ALIGNMENT
java.awt.font.BOTTOM_ALIGNMENT


Occurences of bounds

bounds occurences:
com.sun.javadoc.TypeVariable.bounds()
java.awt.bounds
java.awt.Component.bounds()


Occurences of Bounds

Bounds occurences:
org.omg.CORBA.Bounds
org.omg.CORBA.TypeCodePackage.Bounds


Occurences of Bounds (constructors)

Bounds (constructors) occurences:
org.omg.CORBA.Bounds()
org.omg.CORBA.Bounds(java.lang.String)
org.omg.CORBA.TypeCodePackage.Bounds()
org.omg.CORBA.TypeCodePackage.Bounds(java.lang.String)


Occurences of breaksFlow

breaksFlow occurences:
javax.swing.text.html.HTML.Tag.breaksFlow()
javax.swing.text.html.parser.TagElement.breaksFlow()


Occurences of breakView

breakView occurences:
javax.swing.text.GlyphView.breakView(int, int, float, float)
javax.swing.text.html.InlineView.breakView(int, int, float, float)
javax.swing.text.ParagraphView.breakView(int, float, java.awt.Shape)
javax.swing.text.View.breakView(int, int, float, float)


Occurences of BROKEN

BROKEN occurences:
java.io.BROKEN
java.io.BROKEN


Occurences of BrokenBarrierException (constructors)

BrokenBarrierException (constructors) occurences:
java.util.concurrent.BrokenBarrierException()
java.util.concurrent.BrokenBarrierException(java.lang.String)


Occurences of buf

buf occurences:
java.io.buf
java.io.buf
java.io.buf
java.io.buf
java.io.buf
java.io.buf
java.io.buf
java.util.zip.buf
java.util.zip.buf
java.util.zip.buf
java.util.zip.buf


Occurences of buffer

buffer occurences:
java.io.buffer
java.io.buffer
javax.swing.text.buffer


Occurences of BufferedImage (constructors)

BufferedImage (constructors) occurences:
java.awt.image.BufferedImage(int, int, int)
java.awt.image.BufferedImage(int, int, int, java.awt.image.IndexColorModel)
java.awt.image.BufferedImage(java.awt.image.ColorModel, java.awt.image.WritableRaster, boolean, java.util.Hashtable)


Occurences of BufferedInputStream (constructors)

BufferedInputStream (constructors) occurences:
java.io.BufferedInputStream(java.io.InputStream)
java.io.BufferedInputStream(java.io.InputStream, int)


Occurences of BufferedOutputStream (constructors)

BufferedOutputStream (constructors) occurences:
java.io.BufferedOutputStream(java.io.OutputStream)
java.io.BufferedOutputStream(java.io.OutputStream, int)


Occurences of BufferedReader (constructors)

BufferedReader (constructors) occurences:
java.io.BufferedReader(java.io.Reader)
java.io.BufferedReader(java.io.Reader, int)


Occurences of BufferedWriter (constructors)

BufferedWriter (constructors) occurences:
java.io.BufferedWriter(java.io.Writer)
java.io.BufferedWriter(java.io.Writer, int)


Occurences of bumps

bumps occurences:
javax.swing.plaf.metal.bumps
javax.swing.plaf.metal.bumps


Occurences of Button (constructors)

Button (constructors) occurences:
java.awt.Button()
java.awt.Button(java.lang.String)


Occurences of BYTE

BYTE occurences:
com.sun.mirror.type.BYTE
javax.lang.model.type.BYTE
javax.management.openmbean.BYTE


Occurences of Byte (constructors)

Byte (constructors) occurences:
java.lang.Byte(byte)
java.lang.Byte(java.lang.String)


Occurences of ByteArrayInputStream (constructors)

ByteArrayInputStream (constructors) occurences:
java.io.ByteArrayInputStream(byte[])
java.io.ByteArrayInputStream(byte[], int, int)


Occurences of ByteArrayOutputStream (constructors)

ByteArrayOutputStream (constructors) occurences:
java.io.ByteArrayOutputStream()
java.io.ByteArrayOutputStream(int)


Occurences of ByteHolder (constructors)

ByteHolder (constructors) occurences:
org.omg.CORBA.ByteHolder()
org.omg.CORBA.ByteHolder(byte)


Occurences of ByteLookupTable (constructors)

ByteLookupTable (constructors) occurences:
java.awt.image.ByteLookupTable(int, byte[])
java.awt.image.ByteLookupTable(int, byte[][])


Occurences of byteValue

byteValue occurences:
com.sun.jdi.PrimitiveValue.byteValue()
java.lang.Byte.byteValue()
java.lang.Double.byteValue()
java.lang.Float.byteValue()
java.lang.Integer.byteValue()
java.lang.Long.byteValue()
java.lang.Number.byteValue()
java.lang.Short.byteValue()


Occurences of C

C occurences:
java.awt.C
javax.print.attribute.standard.C
javax.print.attribute.standard.C


Occurences of C3

C3 occurences:
java.awt.C3
javax.print.attribute.standard.C3


Occurences of C4

C4 occurences:
java.awt.C4
javax.print.attribute.standard.C4


Occurences of C5

C5 occurences:
java.awt.C5
javax.print.attribute.standard.C5


Occurences of C6

C6 occurences:
java.awt.C6
javax.print.attribute.standard.C6


Occurences of cae

cae occurences:
java.nio.charset.cae
java.nio.charset.cae


Occurences of calculateAlignedPositions

calculateAlignedPositions occurences:
javax.swing.SizeRequirements.calculateAlignedPositions(int, javax.swing.SizeRequirements, javax.swing.SizeRequirements[], int[], int[])
javax.swing.SizeRequirements.calculateAlignedPositions(int, javax.swing.SizeRequirements, javax.swing.SizeRequirements[], int[], int[], boolean)


Occurences of calculateIndex

calculateIndex occurences:
javax.management.openmbean.TabularData.calculateIndex(javax.management.openmbean.CompositeData)
javax.management.openmbean.TabularDataSupport.calculateIndex(javax.management.openmbean.CompositeData)


Occurences of calculateMajorAxisRequirements

calculateMajorAxisRequirements occurences:
javax.swing.text.BoxView.calculateMajorAxisRequirements(int, javax.swing.SizeRequirements)
javax.swing.text.html.BlockView.calculateMajorAxisRequirements(int, javax.swing.SizeRequirements)


Occurences of calculateMaxTabHeight

calculateMaxTabHeight occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.calculateMaxTabHeight(int)
javax.swing.plaf.metal.MetalTabbedPaneUI.calculateMaxTabHeight(int)


Occurences of calculateMinorAxisRequirements

calculateMinorAxisRequirements occurences:
javax.swing.text.BoxView.calculateMinorAxisRequirements(int, javax.swing.SizeRequirements)
javax.swing.text.FlowView.calculateMinorAxisRequirements(int, javax.swing.SizeRequirements)
javax.swing.text.html.BlockView.calculateMinorAxisRequirements(int, javax.swing.SizeRequirements)
javax.swing.text.html.ParagraphView.calculateMinorAxisRequirements(int, javax.swing.SizeRequirements)
javax.swing.text.TableView.calculateMinorAxisRequirements(int, javax.swing.SizeRequirements)


Occurences of calculateTiledPositions

calculateTiledPositions occurences:
javax.swing.SizeRequirements.calculateTiledPositions(int, javax.swing.SizeRequirements, javax.swing.SizeRequirements[], int[], int[])
javax.swing.SizeRequirements.calculateTiledPositions(int, javax.swing.SizeRequirements, javax.swing.SizeRequirements[], int[], int[], boolean)


Occurences of Calendar (constructors)

Calendar (constructors) occurences:
java.util.Calendar()
java.util.Calendar(java.util.TimeZone, java.util.Locale)


Occurences of call

call occurences:
java.util.concurrent.Callable.call()
javax.tools.JavaCompiler.CompilationTask.call()
javax.xml.soap.SOAPConnection.call(javax.xml.soap.SOAPMessage, java.lang.Object)


Occurences of callable

callable occurences:
java.util.concurrent.Executors.callable(java.lang.Runnable)
java.util.concurrent.Executors.callable(java.lang.Runnable, T)
java.util.concurrent.Executors.callable(java.lang.Runnable,java.lang.Object)
java.util.concurrent.Executors.callable(java.security.PrivilegedAction)
java.util.concurrent.Executors.callable(java.security.PrivilegedExceptionAction)


Occurences of CallableStatement

CallableStatement occurences:
CallableStatement
java.sql.CallableStatement


Occurences of cancel

cancel occurences:
java.awt.print.PrinterJob.cancel()
java.nio.channels.SelectionKey.cancel()
java.nio.channels.spi.AbstractSelectionKey.cancel()
java.sql.Statement.cancel()
java.util.concurrent.Future.cancel(boolean)
java.util.concurrent.FutureTask.cancel(boolean)
java.util.Timer.cancel()
java.util.TimerTask.cancel()
javax.print.CancelablePrintJob.cancel()
javax.swing.SwingWorker.cancel(boolean)


Occurences of cancelCellEditing

cancelCellEditing occurences:
javax.swing.AbstractCellEditor.cancelCellEditing()
javax.swing.CellEditor.cancelCellEditing()
javax.swing.DefaultCellEditor.cancelCellEditing()
javax.swing.DefaultCellEditor.EditorDelegate.cancelCellEditing()
javax.swing.tree.DefaultTreeCellEditor.cancelCellEditing()


Occurences of cancelEditing

cancelEditing occurences:
javax.swing.JTree.cancelEditing()
javax.swing.plaf.basic.BasicTreeUI.cancelEditing(javax.swing.JTree)
javax.swing.plaf.multi.MultiTreeUI.cancelEditing(javax.swing.JTree)
javax.swing.plaf.TreeUI.cancelEditing(javax.swing.JTree)


Occurences of cancelLatestCommittedText

cancelLatestCommittedText occurences:
Class ActiveClient.ActiveClient.cancelLatestCommittedText(java.text.AttributedCharacterIterator.Attribute[])
java.awt.im.InputMethodRequests.cancelLatestCommittedText(java.text.AttributedCharacterIterator.Attribute[])


Occurences of CancellationException (constructors)

CancellationException (constructors) occurences:
java.util.concurrent.CancellationException()
java.util.concurrent.CancellationException(java.lang.String)


Occurences of CANCEL_OPTION

CANCEL_OPTION occurences:
javax.swing.CANCEL_OPTION
javax.swing.CANCEL_OPTION


Occurences of canDisplay

canDisplay occurences:
java.awt.Font.canDisplay(char)
java.awt.Font.canDisplay(int)


Occurences of canDisplayUpTo

canDisplayUpTo occurences:
java.awt.Font.canDisplayUpTo(char[], int, int)
java.awt.Font.canDisplayUpTo(java.lang.String)
java.awt.Font.canDisplayUpTo(java.text.CharacterIterator, int, int)


Occurences of canEncode

canEncode occurences:
java.nio.charset.Charset.canEncode()
java.nio.charset.CharsetEncoder.canEncode(char)
java.nio.charset.CharsetEncoder.canEncode(java.lang.CharSequence)


Occurences of canEncodeImage

canEncodeImage occurences:
javax.imageio.spi.ImageWriterSpi.canEncodeImage(java.awt.image.RenderedImage)
javax.imageio.spi.ImageWriterSpi.canEncodeImage(javax.imageio.ImageTypeSpecifier)


Occurences of canImport

canImport occurences:
javax.swing.TransferHandler.canImport(javax.swing.JComponent, java.awt.datatransfer.DataFlavor[])
javax.swing.TransferHandler.canImport(javax.swing.TransferHandler.TransferSupport)


Occurences of canNodeAppear

canNodeAppear occurences:
javax.imageio.metadata.IIOMetadataFormat.canNodeAppear(java.lang.String, javax.imageio.ImageTypeSpecifier)
javax.imageio.metadata.IIOMetadataFormatImpl.canNodeAppear(java.lang.String, javax.imageio.ImageTypeSpecifier)


Occurences of CannotProceed (constructors)

CannotProceed (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.CannotProceed()
org.omg.CosNaming.NamingContextPackage.CannotProceed(java.lang.String, org.omg.CosNaming.NamingContext, org.omg.CosNaming.NameComponent[])
org.omg.CosNaming.NamingContextPackage.CannotProceed(org.omg.CosNaming.NamingContext, org.omg.CosNaming.NameComponent[])


Occurences of CannotProceedException (constructors)

CannotProceedException (constructors) occurences:
javax.naming.CannotProceedException()
javax.naming.CannotProceedException(java.lang.String)


Occurences of CannotProceedHolder (constructors)

CannotProceedHolder (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.CannotProceedHolder()
org.omg.CosNaming.NamingContextPackage.CannotProceedHolder(org.omg.CosNaming.NamingContextPackage.CannotProceed)


Occurences of canOffsetTiles

canOffsetTiles occurences:
javax.imageio.canOffsetTiles
javax.imageio.ImageWriteParam.canOffsetTiles()


Occurences of canRedo

canRedo occurences:
javax.swing.undo.AbstractUndoableEdit.canRedo()
javax.swing.undo.CompoundEdit.canRedo()
javax.swing.undo.UndoableEdit.canRedo()
javax.swing.undo.UndoManager.canRedo()


Occurences of canSetSourceRenderSize

canSetSourceRenderSize occurences:
javax.imageio.canSetSourceRenderSize
javax.imageio.ImageReadParam.canSetSourceRenderSize()


Occurences of canUndo

canUndo occurences:
javax.swing.undo.AbstractUndoableEdit.canUndo()
javax.swing.undo.CompoundEdit.canUndo()
javax.swing.undo.UndoableEdit.canUndo()
javax.swing.undo.UndoManager.canUndo()


Occurences of canUseCacheFile

canUseCacheFile occurences:
javax.imageio.spi.ImageInputStreamSpi.canUseCacheFile()
javax.imageio.spi.ImageOutputStreamSpi.canUseCacheFile()


Occurences of Canvas (constructors)

Canvas (constructors) occurences:
java.awt.Canvas()
java.awt.Canvas(java.awt.GraphicsConfiguration)


Occurences of canWriteCompressed

canWriteCompressed occurences:
javax.imageio.canWriteCompressed
javax.imageio.ImageWriteParam.canWriteCompressed()


Occurences of canWriteProgressive

canWriteProgressive occurences:
javax.imageio.canWriteProgressive
javax.imageio.ImageWriteParam.canWriteProgressive()


Occurences of canWriteTiles

canWriteTiles occurences:
javax.imageio.canWriteTiles
javax.imageio.ImageWriteParam.canWriteTiles()


Occurences of capacity

capacity occurences:
java.lang.StringBuffer.capacity()
java.lang.StringBuilder.capacity()
java.nio.Buffer.capacity()
java.util.Vector.capacity()
javax.swing.DefaultListModel.capacity()


Occurences of capacityIncrement

capacityIncrement occurences:
java.util.capacityIncrement
javax.management.monitor.capacityIncrement


Occurences of caps

caps occurences:
java.awt.caps
java.awt.caps


Occurences of CardLayout (constructors)

CardLayout (constructors) occurences:
java.awt.CardLayout()
java.awt.CardLayout(int, int)


Occurences of caretPositionChanged

caretPositionChanged occurences:
Class ActiveClient.ActiveClient.caretPositionChanged(java.awt.event.InputMethodEvent)
java.awt.AWTEventMulticaster.caretPositionChanged(java.awt.event.InputMethodEvent)
java.awt.event.InputMethodListener.caretPositionChanged(java.awt.event.InputMethodEvent)


Occurences of caretUpdate

caretUpdate occurences:
javax.swing.event.CaretListener.caretUpdate(javax.swing.event.CaretEvent)
javax.swing.text.JTextComponent.AccessibleJTextComponent.caretUpdate(javax.swing.event.CaretEvent)


Occurences of cbrt

cbrt occurences:
java.lang.Math.cbrt(double)
java.lang.StrictMath.cbrt(double)


Occurences of CDATA

CDATA occurences:
javax.swing.text.html.parser.CDATA
javax.xml.stream.CDATA


Occurences of ce

ce occurences:
java.nio.charset.ce
java.nio.charset.ce


Occurences of ceil

ceil occurences:
java.lang.Math.ceil(double)
java.lang.StrictMath.ceil(double)


Occurences of ceiling

ceiling occurences:
java.util.concurrent.ConcurrentSkipListSet.ceiling(E)
java.util.concurrent.ConcurrentSkipListSet.ceiling(java.lang.Object)
java.util.NavigableSet.ceiling(E)
java.util.NavigableSet.ceiling(java.lang.Object)
java.util.TreeSet.ceiling(E)
java.util.TreeSet.ceiling(java.lang.Object)


Occurences of ceilingEntry

ceilingEntry occurences:
java.util.concurrent.ConcurrentSkipListMap.ceilingEntry(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.ceilingEntry(K)
java.util.NavigableMap.ceilingEntry(java.lang.Object)
java.util.NavigableMap.ceilingEntry(K)
java.util.TreeMap.ceilingEntry(java.lang.Object)
java.util.TreeMap.ceilingEntry(K)


Occurences of ceilingKey

ceilingKey occurences:
java.util.concurrent.ConcurrentSkipListMap.ceilingKey(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.ceilingKey(K)
java.util.NavigableMap.ceilingKey(java.lang.Object)
java.util.NavigableMap.ceilingKey(K)
java.util.TreeMap.ceilingKey(java.lang.Object)
java.util.TreeMap.ceilingKey(K)


Occurences of cellEditor

cellEditor occurences:
javax.swing.cellEditor
javax.swing.cellEditor
javax.swing.plaf.basic.cellEditor
javax.swing.table.cellEditor


Occurences of cellRenderer

cellRenderer occurences:
javax.swing.cellRenderer
javax.swing.table.cellRenderer


Occurences of CELL_RENDERER_PROPERTY

CELL_RENDERER_PROPERTY occurences:
javax.swing.CELL_RENDERER_PROPERTY
javax.swing.table.CELL_RENDERER_PROPERTY


Occurences of CENATT

CENATT occurences:
java.util.jar.CENATT
java.util.jar.CENATT
java.util.jar.CENATT
java.util.jar.CENATT
java.util.zip.CENATT
java.util.zip.CENATT
java.util.zip.CENATT
java.util.zip.CENATT


Occurences of CENATX

CENATX occurences:
java.util.jar.CENATX
java.util.jar.CENATX
java.util.jar.CENATX
java.util.jar.CENATX
java.util.zip.CENATX
java.util.zip.CENATX
java.util.zip.CENATX
java.util.zip.CENATX


Occurences of CENCOM

CENCOM occurences:
java.util.jar.CENCOM
java.util.jar.CENCOM
java.util.jar.CENCOM
java.util.jar.CENCOM
java.util.zip.CENCOM
java.util.zip.CENCOM
java.util.zip.CENCOM
java.util.zip.CENCOM


Occurences of CENCRC

CENCRC occurences:
java.util.jar.CENCRC
java.util.jar.CENCRC
java.util.jar.CENCRC
java.util.jar.CENCRC
java.util.zip.CENCRC
java.util.zip.CENCRC
java.util.zip.CENCRC
java.util.zip.CENCRC


Occurences of CENDSK

CENDSK occurences:
java.util.jar.CENDSK
java.util.jar.CENDSK
java.util.jar.CENDSK
java.util.jar.CENDSK
java.util.zip.CENDSK
java.util.zip.CENDSK
java.util.zip.CENDSK
java.util.zip.CENDSK


Occurences of CENEXT

CENEXT occurences:
java.util.jar.CENEXT
java.util.jar.CENEXT
java.util.jar.CENEXT
java.util.jar.CENEXT
java.util.zip.CENEXT
java.util.zip.CENEXT
java.util.zip.CENEXT
java.util.zip.CENEXT


Occurences of CENFLG

CENFLG occurences:
java.util.jar.CENFLG
java.util.jar.CENFLG
java.util.jar.CENFLG
java.util.jar.CENFLG
java.util.zip.CENFLG
java.util.zip.CENFLG
java.util.zip.CENFLG
java.util.zip.CENFLG


Occurences of CENHDR

CENHDR occurences:
java.util.jar.CENHDR
java.util.jar.CENHDR
java.util.jar.CENHDR
java.util.jar.CENHDR
java.util.zip.CENHDR
java.util.zip.CENHDR
java.util.zip.CENHDR
java.util.zip.CENHDR


Occurences of CENHOW

CENHOW occurences:
java.util.jar.CENHOW
java.util.jar.CENHOW
java.util.jar.CENHOW
java.util.jar.CENHOW
java.util.zip.CENHOW
java.util.zip.CENHOW
java.util.zip.CENHOW
java.util.zip.CENHOW


Occurences of CENLEN

CENLEN occurences:
java.util.jar.CENLEN
java.util.jar.CENLEN
java.util.jar.CENLEN
java.util.jar.CENLEN
java.util.zip.CENLEN
java.util.zip.CENLEN
java.util.zip.CENLEN
java.util.zip.CENLEN


Occurences of CENNAM

CENNAM occurences:
java.util.jar.CENNAM
java.util.jar.CENNAM
java.util.jar.CENNAM
java.util.jar.CENNAM
java.util.zip.CENNAM
java.util.zip.CENNAM
java.util.zip.CENNAM
java.util.zip.CENNAM


Occurences of CENOFF

CENOFF occurences:
java.util.jar.CENOFF
java.util.jar.CENOFF
java.util.jar.CENOFF
java.util.jar.CENOFF
java.util.zip.CENOFF
java.util.zip.CENOFF
java.util.zip.CENOFF
java.util.zip.CENOFF


Occurences of CENSIG

CENSIG occurences:
java.util.jar.CENSIG
java.util.jar.CENSIG
java.util.jar.CENSIG
java.util.jar.CENSIG
java.util.zip.CENSIG
java.util.zip.CENSIG
java.util.zip.CENSIG
java.util.zip.CENSIG


Occurences of CENSIZ

CENSIZ occurences:
java.util.jar.CENSIZ
java.util.jar.CENSIZ
java.util.jar.CENSIZ
java.util.jar.CENSIZ
java.util.zip.CENSIZ
java.util.zip.CENSIZ
java.util.zip.CENSIZ
java.util.zip.CENSIZ


Occurences of CENTER

CENTER occurences:
java.awt.CENTER
java.awt.CENTER
java.awt.CENTER
java.awt.CENTER
javax.swing.border.CENTER
javax.swing.CENTER
javax.swing.CENTER
javax.swing.text.html.CENTER


Occurences of CENTER_BASELINE

CENTER_BASELINE occurences:
java.awt.CENTER_BASELINE
java.awt.font.CENTER_BASELINE


Occurences of CENTIM

CENTIM occurences:
java.util.jar.CENTIM
java.util.jar.CENTIM
java.util.jar.CENTIM
java.util.jar.CENTIM
java.util.zip.CENTIM
java.util.zip.CENTIM
java.util.zip.CENTIM
java.util.zip.CENTIM


Occurences of CENVEM

CENVEM occurences:
java.util.jar.CENVEM
java.util.jar.CENVEM
java.util.jar.CENVEM
java.util.jar.CENVEM
java.util.zip.CENVEM
java.util.zip.CENVEM
java.util.zip.CENVEM
java.util.zip.CENVEM


Occurences of CENVER

CENVER occurences:
java.util.jar.CENVER
java.util.jar.CENVER
java.util.jar.CENVER
java.util.jar.CENVER
java.util.zip.CENVER
java.util.zip.CENVER
java.util.zip.CENVER
java.util.zip.CENVER


Occurences of cert

cert occurences:
java.security.cert
javax.security.cert


Occurences of Certificate

Certificate occurences:
java.security.Certificate
java.security.cert.Certificate
javax.security.cert.Certificate


Occurences of Certificate (constructors)

Certificate (constructors) occurences:
java.security.cert.Certificate(java.lang.String)
javax.security.cert.Certificate()


Occurences of CertificateEncodingException

CertificateEncodingException occurences:
java.security.cert.CertificateEncodingException
javax.security.cert.CertificateEncodingException


Occurences of CertificateEncodingException (constructors)

CertificateEncodingException (constructors) occurences:
java.security.cert.CertificateEncodingException()
java.security.cert.CertificateEncodingException(java.lang.String)
java.security.cert.CertificateEncodingException(java.lang.String, java.lang.Throwable)
java.security.cert.CertificateEncodingException(java.lang.Throwable)
javax.security.cert.CertificateEncodingException()
javax.security.cert.CertificateEncodingException(java.lang.String)


Occurences of CertificateException

CertificateException occurences:
java.security.cert.CertificateException
javax.security.cert.CertificateException


Occurences of CertificateException (constructors)

CertificateException (constructors) occurences:
java.security.cert.CertificateException()
java.security.cert.CertificateException(java.lang.String)
java.security.cert.CertificateException(java.lang.String, java.lang.Throwable)
java.security.cert.CertificateException(java.lang.Throwable)
javax.security.cert.CertificateException()
javax.security.cert.CertificateException(java.lang.String)


Occurences of CertificateExpiredException

CertificateExpiredException occurences:
java.security.cert.CertificateExpiredException
javax.security.cert.CertificateExpiredException


Occurences of CertificateExpiredException (constructors)

CertificateExpiredException (constructors) occurences:
java.security.cert.CertificateExpiredException()
java.security.cert.CertificateExpiredException(java.lang.String)
javax.security.cert.CertificateExpiredException()
javax.security.cert.CertificateExpiredException(java.lang.String)


Occurences of CertificateNotYetValidException

CertificateNotYetValidException occurences:
java.security.cert.CertificateNotYetValidException
javax.security.cert.CertificateNotYetValidException


Occurences of CertificateNotYetValidException (constructors)

CertificateNotYetValidException (constructors) occurences:
java.security.cert.CertificateNotYetValidException()
java.security.cert.CertificateNotYetValidException(java.lang.String)
javax.security.cert.CertificateNotYetValidException()
javax.security.cert.CertificateNotYetValidException(java.lang.String)


Occurences of CertificateParsingException

CertificateParsingException occurences:
java.security.cert.CertificateParsingException
javax.security.cert.CertificateParsingException


Occurences of CertificateParsingException (constructors)

CertificateParsingException (constructors) occurences:
java.security.cert.CertificateParsingException()
java.security.cert.CertificateParsingException(java.lang.String)
java.security.cert.CertificateParsingException(java.lang.String, java.lang.Throwable)
java.security.cert.CertificateParsingException(java.lang.Throwable)
javax.security.cert.CertificateParsingException()
javax.security.cert.CertificateParsingException(java.lang.String)


Occurences of CertPathBuilderException (constructors)

CertPathBuilderException (constructors) occurences:
java.security.cert.CertPathBuilderException()
java.security.cert.CertPathBuilderException(java.lang.String)
java.security.cert.CertPathBuilderException(java.lang.String, java.lang.Throwable)
java.security.cert.CertPathBuilderException(java.lang.Throwable)


Occurences of CertPathValidatorException (constructors)

CertPathValidatorException (constructors) occurences:
java.security.cert.CertPathValidatorException()
java.security.cert.CertPathValidatorException(java.lang.String)
java.security.cert.CertPathValidatorException(java.lang.String, java.lang.Throwable)
java.security.cert.CertPathValidatorException(java.lang.String, java.lang.Throwable, java.security.cert.CertPath, int)
java.security.cert.CertPathValidatorException(java.lang.Throwable)


Occurences of CertStoreException (constructors)

CertStoreException (constructors) occurences:
java.security.cert.CertStoreException()
java.security.cert.CertStoreException(java.lang.String)
java.security.cert.CertStoreException(java.lang.String, java.lang.Throwable)
java.security.cert.CertStoreException(java.lang.Throwable)


Occurences of changedUpdate

changedUpdate occurences:
javax.swing.event.DocumentListener.changedUpdate(javax.swing.event.DocumentEvent)
javax.swing.text.FlowView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.FlowView.FlowStrategy.changedUpdate(javax.swing.text.FlowView, javax.swing.event.DocumentEvent, java.awt.Rectangle)
javax.swing.text.GlyphView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.html.BlockView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.html.ImageView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.html.InlineView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.JTextComponent.AccessibleJTextComponent.changedUpdate(javax.swing.event.DocumentEvent)
javax.swing.text.LabelView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.ParagraphView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.PlainView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.View.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.WrappedPlainView.changedUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)


Occurences of changeEvent

changeEvent occurences:
javax.swing.changeEvent
javax.swing.changeEvent
javax.swing.changeEvent
javax.swing.changeEvent
javax.swing.changeEvent
javax.swing.changeEvent
javax.swing.changeEvent
javax.swing.changeEvent
javax.swing.changeEvent
javax.swing.colorchooser.changeEvent
javax.swing.table.changeEvent
javax.swing.text.changeEvent
javax.swing.text.changeEvent


Occurences of changeHighlight

changeHighlight occurences:
javax.swing.text.DefaultHighlighter.changeHighlight(java.lang.Object, int, int)
javax.swing.text.Highlighter.changeHighlight(java.lang.Object, int, int)


Occurences of changeListener

changeListener occurences:
javax.swing.changeListener
javax.swing.changeListener
javax.swing.changeListener
javax.swing.changeListener
javax.swing.plaf.basic.changeListener
javax.swing.plaf.basic.changeListener
javax.swing.plaf.basic.changeListener
javax.swing.plaf.basic.changeListener


Occurences of changeSupport

changeSupport occurences:
javax.swing.changeSupport
javax.swing.tree.changeSupport


Occurences of channel

channel occurences:
java.nio.channels.FileLock.channel()
java.nio.channels.SelectionKey.channel()
javax.sound.midi.channel


Occurences of ChannelBinding (constructors)

ChannelBinding (constructors) occurences:
org.ietf.jgss.ChannelBinding(byte[])
org.ietf.jgss.ChannelBinding(java.net.InetAddress, java.net.InetAddress, byte[])


Occurences of channels

channels occurences:
java.nio.channels
javax.sound.sampled.channels


Occurences of CHAR

CHAR occurences:
com.sun.mirror.type.CHAR
java.sql.CHAR
javax.lang.model.type.CHAR


Occurences of CHARACTER

CHARACTER occurences:
javax.accessibility.CHARACTER
javax.management.openmbean.CHARACTER


Occurences of characters

characters occurences:
org.xml.sax.ContentHandler.characters(char[], int, int)
org.xml.sax.DocumentHandler.characters(char[], int, int)
org.xml.sax.HandlerBase.characters(char[], int, int)
org.xml.sax.helpers.DefaultHandler.characters(char[], int, int)
org.xml.sax.helpers.ParserAdapter.characters(char[], int, int)
org.xml.sax.helpers.XMLFilterImpl.characters(char[], int, int)
org.xml.sax.helpers.XMLReaderAdapter.characters(char[], int, int)


Occurences of CharArrayReader (constructors)

CharArrayReader (constructors) occurences:
java.io.CharArrayReader(char[])
java.io.CharArrayReader(char[], int, int)


Occurences of CharArrayWriter (constructors)

CharArrayWriter (constructors) occurences:
java.io.CharArrayWriter()
java.io.CharArrayWriter(int)


Occurences of charAt

charAt occurences:
java.lang.CharSequence.charAt(int)
java.lang.String.charAt(int)
java.lang.StringBuffer.charAt(int)
java.lang.StringBuilder.charAt(int)
java.nio.CharBuffer.charAt(int)
javax.swing.text.Segment.charAt(int)


Occurences of CharConversionException (constructors)

CharConversionException (constructors) occurences:
java.io.CharConversionException()
java.io.CharConversionException(java.lang.String)


Occurences of CharHolder (constructors)

CharHolder (constructors) occurences:
org.omg.CORBA.CharHolder()
org.omg.CORBA.CharHolder(char)


Occurences of CharSeqHolder (constructors)

CharSeqHolder (constructors) occurences:
org.omg.CORBA.CharSeqHolder()
org.omg.CORBA.CharSeqHolder(char[])


Occurences of charset

charset occurences:
java.nio.charset
java.nio.charset.CharsetDecoder.charset()
java.nio.charset.CharsetEncoder.charset()


Occurences of CharsetEncoder (constructors)

CharsetEncoder (constructors) occurences:
java.nio.charset.CharsetEncoder(java.nio.charset.Charset, float, float)
java.nio.charset.CharsetEncoder(java.nio.charset.Charset, float, float, byte[])


Occurences of charValue

charValue occurences:
com.sun.jdi.PrimitiveValue.charValue()
java.lang.Character.charValue()


Occurences of charWidth

charWidth occurences:
java.awt.FontMetrics.charWidth(char)
java.awt.FontMetrics.charWidth(int)


Occurences of check

check occurences:
java.security.cert.PKIXCertPathChecker.check(java.security.cert.Certificate, java.util.Collection)
javax.management.loading.MLet.check(java.lang.String, java.net.URL, java.lang.String, javax.management.loading.MLetContent)


Occurences of checkAccess

checkAccess occurences:
java.lang.SecurityManager.checkAccess(java.lang.Thread)
java.lang.SecurityManager.checkAccess(java.lang.ThreadGroup)
java.lang.Thread.checkAccess()
java.lang.ThreadGroup.checkAccess()
java.util.logging.LogManager.checkAccess()


Occurences of checkAll

checkAll occurences:
java.awt.MediaTracker.checkAll()
java.awt.MediaTracker.checkAll(boolean)


Occurences of Checkbox (constructors)

Checkbox (constructors) occurences:
java.awt.Checkbox()
java.awt.Checkbox(java.lang.String)
java.awt.Checkbox(java.lang.String, boolean)
java.awt.Checkbox(java.lang.String, boolean, java.awt.CheckboxGroup)
java.awt.Checkbox(java.lang.String, java.awt.CheckboxGroup, boolean)


Occurences of CheckboxMenuItem (constructors)

CheckboxMenuItem (constructors) occurences:
java.awt.CheckboxMenuItem()
java.awt.CheckboxMenuItem(java.lang.String)
java.awt.CheckboxMenuItem(java.lang.String, boolean)


Occurences of checkConnect

checkConnect occurences:
java.lang.SecurityManager.checkConnect(java.lang.String, int)
java.lang.SecurityManager.checkConnect(java.lang.String, int, java.lang.Object)


Occurences of CHECKED

CHECKED occurences:
javax.accessibility.CHECKED
javax.swing.text.html.CHECKED


Occurences of checkError

checkError occurences:
java.io.PrintStream.checkError()
java.io.PrintWriter.checkError()


Occurences of checkGuard

checkGuard occurences:
java.security.Guard.checkGuard(java.lang.Object)
java.security.Permission.checkGuard(java.lang.Object)


Occurences of checkHorizontalKey

checkHorizontalKey occurences:
javax.swing.AbstractButton.checkHorizontalKey(int, java.lang.String)
javax.swing.JLabel.checkHorizontalKey(int, java.lang.String)


Occurences of checkID

checkID occurences:
java.awt.MediaTracker.checkID(int)
java.awt.MediaTracker.checkID(int, boolean)


Occurences of checkImage

checkImage occurences:
java.awt.Component.checkImage(java.awt.Image, int, int, java.awt.image.ImageObserver)
java.awt.Component.checkImage(java.awt.Image, java.awt.image.ImageObserver)
java.awt.Toolkit.checkImage(java.awt.Image, int, int, java.awt.image.ImageObserver)


Occurences of checkMulticast

checkMulticast occurences:
java.lang.SecurityManager.checkMulticast(java.net.InetAddress)
java.lang.SecurityManager.checkMulticast(java.net.InetAddress, byte)


Occurences of checkPermission

checkPermission occurences:
java.lang.SecurityManager.checkPermission(java.security.Permission)
java.lang.SecurityManager.checkPermission(java.security.Permission, java.lang.Object)
java.security.AccessControlContext.checkPermission(java.security.Permission)
java.security.AccessController.checkPermission(java.security.Permission)
java.security.acl.Acl.checkPermission(java.security.Principal, java.security.acl.Permission)
java.security.acl.AclEntry.checkPermission(java.security.acl.Permission)


Occurences of checkRead

checkRead occurences:
java.lang.SecurityManager.checkRead(java.io.FileDescriptor)
java.lang.SecurityManager.checkRead(java.lang.String)
java.lang.SecurityManager.checkRead(java.lang.String, java.lang.Object)


Occurences of checkRoleReading

checkRoleReading occurences:
javax.management.relation.RelationService.checkRoleReading(java.lang.String, java.lang.String)
javax.management.relation.RelationServiceMBean.checkRoleReading(java.lang.String, java.lang.String)


Occurences of checkRoleWriting

checkRoleWriting occurences:
javax.management.relation.RelationService.checkRoleWriting(javax.management.relation.Role, java.lang.String, java.lang.Boolean)
javax.management.relation.RelationServiceMBean.checkRoleWriting(javax.management.relation.Role, java.lang.String, java.lang.Boolean)


Occurences of checkValidity

checkValidity occurences:
java.security.cert.X509Certificate.checkValidity()
java.security.cert.X509Certificate.checkValidity(java.util.Date)
javax.security.cert.X509Certificate.checkValidity()
javax.security.cert.X509Certificate.checkValidity(java.util.Date)


Occurences of checkVerticalKey

checkVerticalKey occurences:
javax.swing.AbstractButton.checkVerticalKey(int, java.lang.String)
javax.swing.JLabel.checkVerticalKey(int, java.lang.String)


Occurences of checkWrite

checkWrite occurences:
java.lang.SecurityManager.checkWrite(java.io.FileDescriptor)
java.lang.SecurityManager.checkWrite(java.lang.String)


Occurences of CHECK_BOX

CHECK_BOX occurences:
javax.accessibility.CHECK_BOX
javax.swing.plaf.synth.CHECK_BOX


Occurences of childAllocation

childAllocation occurences:
javax.swing.text.BoxView.childAllocation(int, java.awt.Rectangle)
javax.swing.text.CompositeView.childAllocation(int, java.awt.Rectangle)


Occurences of childJustRemovedHook

childJustRemovedHook occurences:
java.beans.beancontext.BeanContextServicesSupport.childJustRemovedHook(java.lang.Object, java.beans.beancontext.BeanContextSupport.BCSChild)
java.beans.beancontext.BeanContextSupport.childJustRemovedHook(java.lang.Object, java.beans.beancontext.BeanContextSupport.BCSChild)


Occurences of children

children occurences:
java.beans.beancontext.children
java.beans.beancontext.children
javax.swing.event.children
javax.swing.JTree.DynamicUtilTreeNode.children()
javax.swing.text.AbstractDocument.AbstractElement.children()
javax.swing.text.AbstractDocument.BranchElement.children()
javax.swing.text.AbstractDocument.LeafElement.children()
javax.swing.tree.children
javax.swing.tree.DefaultMutableTreeNode.children()
javax.swing.tree.TreeNode.children()


Occurences of childrenNames

childrenNames occurences:
java.util.prefs.AbstractPreferences.childrenNames()
java.util.prefs.Preferences.childrenNames()


Occurences of childValue

childValue occurences:
java.lang.InheritableThreadLocal.childValue(java.lang.Object)
java.lang.InheritableThreadLocal.childValue(T)
javax.swing.childValue


Occurences of ChoiceFormat (constructors)

ChoiceFormat (constructors) occurences:
java.text.ChoiceFormat(double[], java.lang.String[])
java.text.ChoiceFormat(java.lang.String)


Occurences of choices

choices occurences:
com.sun.jdi.connect.Connector.SelectedArgument.choices()
java.sql.choices


Occurences of CipherInputStream (constructors)

CipherInputStream (constructors) occurences:
javax.crypto.CipherInputStream(java.io.InputStream)
javax.crypto.CipherInputStream(java.io.InputStream, javax.crypto.Cipher)


Occurences of CipherOutputStream (constructors)

CipherOutputStream (constructors) occurences:
javax.crypto.CipherOutputStream(java.io.OutputStream)
javax.crypto.CipherOutputStream(java.io.OutputStream, javax.crypto.Cipher)


Occurences of CLASS

CLASS occurences:
com.sun.source.tree.CLASS
java.lang.annotation.CLASS
javax.lang.model.element.CLASS
javax.swing.text.html.CLASS
javax.tools.CLASS


Occurences of ClassCastException (constructors)

ClassCastException (constructors) occurences:
java.lang.ClassCastException()
java.lang.ClassCastException(java.lang.String)


Occurences of ClassCircularityError (constructors)

ClassCircularityError (constructors) occurences:
java.lang.ClassCircularityError()
java.lang.ClassCircularityError(java.lang.String)


Occurences of ClassFormatError (constructors)

ClassFormatError (constructors) occurences:
java.lang.ClassFormatError()
java.lang.ClassFormatError(java.lang.String)


Occurences of ClassLoader (constructors)

ClassLoader (constructors) occurences:
java.lang.ClassLoader()
java.lang.ClassLoader(java.lang.ClassLoader)


Occurences of className

className occurences:
com.sun.jdi.ClassNotLoadedException.className()
com.sun.jdi.event.ClassUnloadEvent.className()
javax.jws.soap.SOAPMessageHandler.className()
javax.naming.className
javax.xml.ws.RequestWrapper.className()
javax.xml.ws.ResponseWrapper.className()


Occurences of ClassNotFoundException (constructors)

ClassNotFoundException (constructors) occurences:
java.lang.ClassNotFoundException()
java.lang.ClassNotFoundException(java.lang.String)
java.lang.ClassNotFoundException(java.lang.String, java.lang.Throwable)


Occurences of ClassNotLoadedException (constructors)

ClassNotLoadedException (constructors) occurences:
com.sun.jdi.ClassNotLoadedException(java.lang.String)
com.sun.jdi.ClassNotLoadedException(java.lang.String, java.lang.String)


Occurences of ClassNotPreparedException (constructors)

ClassNotPreparedException (constructors) occurences:
com.sun.jdi.ClassNotPreparedException()
com.sun.jdi.ClassNotPreparedException(java.lang.String)


Occurences of ClassType

ClassType occurences:
com.sun.jdi.ClassType
com.sun.mirror.type.ClassType


Occurences of CLASS_OUTPUT

CLASS_OUTPUT occurences:
java.awt.color.CLASS_OUTPUT
javax.tools.CLASS_OUTPUT


Occurences of CLASS_PATH

CLASS_PATH occurences:
java.util.jar.CLASS_PATH
javax.tools.CLASS_PATH


Occurences of clear

clear occurences:
java.awt.List.clear()
java.awt.RenderingHints.clear()
java.beans.beancontext.BeanContextSupport.clear()
java.lang.ref.Reference.clear()
java.nio.Buffer.clear()
java.security.Provider.clear()
java.util.AbstractCollection.clear()
java.util.AbstractList.clear()
java.util.AbstractMap.clear()
java.util.AbstractQueue.clear()
java.util.ArrayDeque.clear()
java.util.ArrayList.clear()
java.util.BitSet.clear()
java.util.BitSet.clear(int)
java.util.BitSet.clear(int, int)
java.util.Calendar.clear()
java.util.Calendar.clear(int)
java.util.Collection.clear()
java.util.concurrent.ArrayBlockingQueue.clear()
java.util.concurrent.ConcurrentHashMap.clear()
java.util.concurrent.ConcurrentSkipListMap.clear()
java.util.concurrent.ConcurrentSkipListSet.clear()
java.util.concurrent.CopyOnWriteArrayList.clear()
java.util.concurrent.CopyOnWriteArraySet.clear()
java.util.concurrent.DelayQueue.clear()
java.util.concurrent.LinkedBlockingDeque.clear()
java.util.concurrent.LinkedBlockingQueue.clear()
java.util.concurrent.PriorityBlockingQueue.clear()
java.util.concurrent.SynchronousQueue.clear()
java.util.EnumMap.clear()
java.util.HashMap.clear()
java.util.HashSet.clear()
java.util.Hashtable.clear()
java.util.IdentityHashMap.clear()
java.util.jar.Attributes.clear()
java.util.jar.Manifest.clear()
java.util.LinkedHashMap.clear()
java.util.LinkedList.clear()
java.util.List.clear()
java.util.Map.clear()
java.util.prefs.AbstractPreferences.clear()
java.util.prefs.Preferences.clear()
java.util.PriorityQueue.clear()
java.util.Set.clear()
java.util.TreeMap.clear()
java.util.TreeSet.clear()
java.util.Vector.clear()
java.util.WeakHashMap.clear()
javax.accessibility.AccessibleRelationSet.clear()
javax.accessibility.AccessibleStateSet.clear()
javax.management.openmbean.TabularData.clear()
javax.management.openmbean.TabularDataSupport.clear()
javax.naming.directory.Attribute.clear()
javax.naming.directory.BasicAttribute.clear()
javax.naming.Reference.clear()
javax.print.attribute.AttributeSet.clear()
javax.print.attribute.HashAttributeSet.clear()
javax.script.SimpleBindings.clear()
javax.swing.ActionMap.clear()
javax.swing.ComponentInputMap.clear()
javax.swing.DefaultListModel.clear()
javax.swing.InputMap.clear()
javax.xml.datatype.XMLGregorianCalendar.clear()
org.omg.CORBA.Environment.clear()
org.xml.sax.helpers.AttributeListImpl.clear()
org.xml.sax.helpers.AttributesImpl.clear()


Occurences of CLEAR

CLEAR occurences:
java.awt.CLEAR
javax.swing.text.html.CLEAR
javax.swing.text.html.CLEAR


Occurences of clearAbortRequest

clearAbortRequest occurences:
javax.imageio.ImageReader.clearAbortRequest()
javax.imageio.ImageWriter.clearAbortRequest()


Occurences of clearAccessibleSelection

clearAccessibleSelection occurences:
java.awt.List.AccessibleAWTList.clearAccessibleSelection()
java.awt.MenuComponent.AccessibleAWTMenuComponent.clearAccessibleSelection()
javax.accessibility.AccessibleSelection.clearAccessibleSelection()
javax.swing.JComboBox.AccessibleJComboBox.clearAccessibleSelection()
javax.swing.JList.AccessibleJList.clearAccessibleSelection()
javax.swing.JMenu.AccessibleJMenu.clearAccessibleSelection()
javax.swing.JMenuBar.AccessibleJMenuBar.clearAccessibleSelection()
javax.swing.JTabbedPane.AccessibleJTabbedPane.clearAccessibleSelection()
javax.swing.JTable.AccessibleJTable.clearAccessibleSelection()
javax.swing.JTree.AccessibleJTree.clearAccessibleSelection()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.clearAccessibleSelection()


Occurences of clearCache

clearCache occurences:
java.util.ResourceBundle.clearCache()
java.util.ResourceBundle.clearCache(java.lang.ClassLoader)


Occurences of clearError

clearError occurences:
java.io.PrintStream.clearError()
java.io.PrintWriter.clearError()


Occurences of clearIconCache

clearIconCache occurences:
javax.swing.plaf.basic.BasicFileChooserUI.clearIconCache()
javax.swing.plaf.basic.BasicFileChooserUI.BasicFileView.clearIconCache()


Occurences of clearParameters

clearParameters occurences:
java.sql.PreparedStatement.clearParameters()
javax.sql.RowSet.clearParameters()
javax.sql.rowset.BaseRowSet.clearParameters()
javax.xml.transform.Transformer.clearParameters()


Occurences of clearPassword

clearPassword occurences:
javax.crypto.spec.PBEKeySpec.clearPassword()
javax.security.auth.callback.PasswordCallback.clearPassword()


Occurences of clearRect

clearRect occurences:
java.awt.Graphics.clearRect(int, int, int, int)
javax.swing.DebugGraphics.clearRect(int, int, int, int)


Occurences of clearSelection

clearSelection occurences:
javax.swing.ButtonGroup.clearSelection()
javax.swing.DefaultListSelectionModel.clearSelection()
javax.swing.DefaultSingleSelectionModel.clearSelection()
javax.swing.JList.clearSelection()
javax.swing.JTable.clearSelection()
javax.swing.JTree.clearSelection()
javax.swing.ListSelectionModel.clearSelection()
javax.swing.SingleSelectionModel.clearSelection()
javax.swing.tree.DefaultTreeSelectionModel.clearSelection()
javax.swing.tree.TreeSelectionModel.clearSelection()


Occurences of clearWarnings

clearWarnings occurences:
java.sql.Connection.clearWarnings()
java.sql.ResultSet.clearWarnings()
java.sql.Statement.clearWarnings()


Occurences of clipRect

clipRect occurences:
java.awt.Graphics.clipRect(int, int, int, int)
javax.swing.DebugGraphics.clipRect(int, int, int, int)


Occurences of Clob

Clob occurences:
Clob
java.sql.Clob


Occurences of clone

clone occurences:
java.awt.BufferCapabilities.clone()
java.awt.datatransfer.DataFlavor.clone()
java.awt.font.TextLayout.clone()
java.awt.font.TextMeasurer.clone()
java.awt.geom.AffineTransform.clone()
java.awt.geom.Area.clone()
java.awt.geom.CubicCurve2D.clone()
java.awt.geom.Dimension2D.clone()
java.awt.geom.Line2D.clone()
java.awt.geom.Path2D.clone()
java.awt.geom.Path2D.Double.clone()
java.awt.geom.Path2D.Float.clone()
java.awt.geom.Point2D.clone()
java.awt.geom.QuadCurve2D.clone()
java.awt.geom.RectangularShape.clone()
java.awt.GridBagConstraints.clone()
java.awt.image.ImageFilter.clone()
java.awt.image.Kernel.clone()
java.awt.image.renderable.ParameterBlock.clone()
java.awt.image.renderable.RenderContext.clone()
java.awt.ImageCapabilities.clone()
java.awt.Insets.clone()
java.awt.JobAttributes.clone()
java.awt.PageAttributes.clone()
java.awt.print.PageFormat.clone()
java.awt.print.Paper.clone()
java.awt.RenderingHints.clone()
java.lang.Enum.clone()
java.lang.Object.clone()
java.net.HttpCookie.clone()
java.rmi.server.UnicastRemoteObject.clone()
java.security.acl.AclEntry.clone()
java.security.cert.CertPathBuilderResult.clone()
java.security.cert.CertPathParameters.clone()
java.security.cert.CertPathValidatorResult.clone()
java.security.cert.CertSelector.clone()
java.security.cert.CertStoreParameters.clone()
java.security.cert.CollectionCertStoreParameters.clone()
java.security.cert.CRLSelector.clone()
java.security.cert.LDAPCertStoreParameters.clone()
java.security.cert.PKIXCertPathChecker.clone()
java.security.cert.PKIXCertPathValidatorResult.clone()
java.security.cert.PKIXParameters.clone()
java.security.cert.X509CertSelector.clone()
java.security.cert.X509CRLSelector.clone()
java.security.MessageDigest.clone()
java.security.MessageDigestSpi.clone()
java.security.Signature.clone()
java.security.SignatureSpi.clone()
java.text.BreakIterator.clone()
java.text.CharacterIterator.clone()
java.text.ChoiceFormat.clone()
java.text.Collator.clone()
java.text.DateFormat.clone()
java.text.DateFormatSymbols.clone()
java.text.DecimalFormat.clone()
java.text.DecimalFormatSymbols.clone()
java.text.Format.clone()
java.text.MessageFormat.clone()
java.text.NumberFormat.clone()
java.text.RuleBasedCollator.clone()
java.text.SimpleDateFormat.clone()
java.text.StringCharacterIterator.clone()
java.util.AbstractMap.clone()
java.util.ArrayDeque.clone()
java.util.ArrayList.clone()
java.util.BitSet.clone()
java.util.Calendar.clone()
java.util.concurrent.ConcurrentSkipListMap.clone()
java.util.concurrent.ConcurrentSkipListSet.clone()
java.util.concurrent.CopyOnWriteArrayList.clone()
java.util.Date.clone()
java.util.EnumMap.clone()
java.util.EnumSet.clone()
java.util.GregorianCalendar.clone()
java.util.HashMap.clone()
java.util.HashSet.clone()
java.util.Hashtable.clone()
java.util.IdentityHashMap.clone()
java.util.jar.Attributes.clone()
java.util.jar.Manifest.clone()
java.util.LinkedList.clone()
java.util.Locale.clone()
java.util.SimpleTimeZone.clone()
java.util.TimeZone.clone()
java.util.TreeMap.clone()
java.util.TreeSet.clone()
java.util.Vector.clone()
java.util.zip.ZipEntry.clone()
javax.crypto.Mac.clone()
javax.crypto.MacSpi.clone()
javax.management.Descriptor.clone()
javax.management.ImmutableDescriptor.clone()
javax.management.MBeanAttributeInfo.clone()
javax.management.MBeanConstructorInfo.clone()
javax.management.MBeanInfo.clone()
javax.management.MBeanNotificationInfo.clone()
javax.management.MBeanOperationInfo.clone()
javax.management.MBeanParameterInfo.clone()
javax.management.modelmbean.DescriptorSupport.clone()
javax.management.modelmbean.ModelMBeanAttributeInfo.clone()
javax.management.modelmbean.ModelMBeanConstructorInfo.clone()
javax.management.modelmbean.ModelMBeanInfo.clone()
javax.management.modelmbean.ModelMBeanInfoSupport.clone()
javax.management.modelmbean.ModelMBeanNotificationInfo.clone()
javax.management.modelmbean.ModelMBeanOperationInfo.clone()
javax.management.openmbean.TabularDataSupport.clone()
javax.management.relation.Role.clone()
javax.management.relation.RoleUnresolved.clone()
javax.naming.CompositeName.clone()
javax.naming.CompoundName.clone()
javax.naming.directory.Attribute.clone()
javax.naming.directory.Attributes.clone()
javax.naming.directory.BasicAttribute.clone()
javax.naming.directory.BasicAttributes.clone()
javax.naming.ldap.LdapName.clone()
javax.naming.Name.clone()
javax.naming.Reference.clone()
javax.print.attribute.EnumSyntax.clone()
javax.sound.midi.MetaMessage.clone()
javax.sound.midi.MidiMessage.clone()
javax.sound.midi.ShortMessage.clone()
javax.sound.midi.SysexMessage.clone()
javax.swing.AbstractAction.clone()
javax.swing.DefaultListSelectionModel.clone()
javax.swing.JFormattedTextField.AbstractFormatter.clone()
javax.swing.text.DefaultFormatter.clone()
javax.swing.text.DefaultStyledDocument.ElementBuffer.clone(javax.swing.text.Element, javax.swing.text.Element)
javax.swing.text.EditorKit.clone()
javax.swing.text.ElementIterator.clone()
javax.swing.text.GlyphView.clone()
javax.swing.text.html.HTMLEditorKit.clone()
javax.swing.text.InternationalFormatter.clone()
javax.swing.text.Segment.clone()
javax.swing.text.SimpleAttributeSet.clone()
javax.swing.text.StyleContext.SmallAttributeSet.clone()
javax.swing.text.StyledEditorKit.clone()
javax.swing.tree.DefaultMutableTreeNode.clone()
javax.swing.tree.DefaultTreeSelectionModel.clone()
javax.xml.datatype.XMLGregorianCalendar.clone()


Occurences of cloneNode

cloneNode occurences:
javax.imageio.metadata.IIOMetadataNode.cloneNode(boolean)
org.w3c.dom.Node.cloneNode(boolean)


Occurences of CloneNotSupportedException (constructors)

CloneNotSupportedException (constructors) occurences:
java.lang.CloneNotSupportedException()
java.lang.CloneNotSupportedException(java.lang.String)


Occurences of close

close occurences:
com.sun.jdi.connect.spi.Connection.close()
java.awt.SplashScreen.close()
java.beans.XMLDecoder.close()
java.beans.XMLEncoder.close()
java.io.BufferedInputStream.close()
java.io.BufferedReader.close()
java.io.BufferedWriter.close()
java.io.ByteArrayInputStream.close()
java.io.ByteArrayOutputStream.close()
java.io.CharArrayReader.close()
java.io.CharArrayWriter.close()
java.io.Closeable.close()
java.io.FileInputStream.close()
java.io.FileOutputStream.close()
java.io.FilterInputStream.close()
java.io.FilterOutputStream.close()
java.io.FilterReader.close()
java.io.FilterWriter.close()
java.io.InputStream.close()
java.io.InputStreamReader.close()
java.io.ObjectInput.close()
java.io.ObjectInputStream.close()
java.io.ObjectOutput.close()
java.io.ObjectOutputStream.close()
java.io.OutputStream.close()
java.io.OutputStreamWriter.close()
java.io.PipedInputStream.close()
java.io.PipedOutputStream.close()
java.io.PipedReader.close()
java.io.PipedWriter.close()
java.io.PrintStream.close()
java.io.PrintWriter.close()
java.io.PushbackInputStream.close()
java.io.PushbackReader.close()
java.io.RandomAccessFile.close()
java.io.Reader.close()
java.io.SequenceInputStream.close()
java.io.StringReader.close()
java.io.StringWriter.close()
java.io.Writer.close()
java.net.DatagramSocket.close()
java.net.DatagramSocketImpl.close()
java.net.ServerSocket.close()
java.net.Socket.close()
java.net.SocketImpl.close()
java.nio.channels.Channel.close()
java.nio.channels.InterruptibleChannel.close()
java.nio.channels.Selector.close()
java.nio.channels.spi.AbstractInterruptibleChannel.close()
java.nio.channels.spi.AbstractSelector.close()
java.sql.Connection.close()
java.sql.ResultSet.close()
java.sql.Statement.close()
java.util.Formatter.close()
java.util.logging.ConsoleHandler.close()
java.util.logging.FileHandler.close()
java.util.logging.Handler.close()
java.util.logging.MemoryHandler.close()
java.util.logging.SocketHandler.close()
java.util.logging.StreamHandler.close()
java.util.Scanner.close()
java.util.zip.DeflaterInputStream.close()
java.util.zip.DeflaterOutputStream.close()
java.util.zip.GZIPInputStream.close()
java.util.zip.InflaterInputStream.close()
java.util.zip.InflaterOutputStream.close()
java.util.zip.ZipFile.close()
java.util.zip.ZipInputStream.close()
java.util.zip.ZipOutputStream.close()
javax.crypto.CipherInputStream.close()
javax.crypto.CipherOutputStream.close()
javax.imageio.stream.FileCacheImageInputStream.close()
javax.imageio.stream.FileCacheImageOutputStream.close()
javax.imageio.stream.FileImageInputStream.close()
javax.imageio.stream.FileImageOutputStream.close()
javax.imageio.stream.ImageInputStream.close()
javax.imageio.stream.ImageInputStreamImpl.close()
javax.imageio.stream.MemoryCacheImageInputStream.close()
javax.imageio.stream.MemoryCacheImageOutputStream.close()
javax.management.remote.JMXConnector.close()
javax.management.remote.rmi.RMIConnection.close()
javax.management.remote.rmi.RMIConnectionImpl.close()
javax.management.remote.rmi.RMIConnectionImpl_Stub.close()
javax.management.remote.rmi.RMIConnector.close()
javax.management.remote.rmi.RMIServerImpl.close()
javax.naming.Context.close()
javax.naming.InitialContext.close()
javax.naming.ldap.StartTlsResponse.close()
javax.naming.NamingEnumeration.close()
javax.sound.midi.MidiDevice.close()
javax.sound.midi.Receiver.close()
javax.sound.midi.Transmitter.close()
javax.sound.sampled.AudioInputStream.close()
javax.sound.sampled.Line.close()
javax.sql.PooledConnection.close()
javax.swing.ProgressMonitor.close()
javax.swing.ProgressMonitorInputStream.close()
javax.tools.ForwardingJavaFileManager.close()
javax.tools.JavaFileManager.close()
javax.xml.soap.SOAPConnection.close()
javax.xml.stream.util.EventReaderDelegate.close()
javax.xml.stream.util.StreamReaderDelegate.close()
javax.xml.stream.XMLEventReader.close()
javax.xml.stream.XMLEventWriter.close()
javax.xml.stream.XMLStreamReader.close()
javax.xml.stream.XMLStreamWriter.close()
javax.xml.ws.handler.Handler.close(javax.xml.ws.handler.MessageContext)


Occurences of closeClient

closeClient occurences:
javax.management.remote.rmi.RMIIIOPServerImpl.closeClient(javax.management.remote.rmi.RMIConnection)
javax.management.remote.rmi.RMIJRMPServerImpl.closeClient(javax.management.remote.rmi.RMIConnection)
javax.management.remote.rmi.RMIServerImpl.closeClient(javax.management.remote.rmi.RMIConnection)


Occurences of CLOSED

CLOSED occurences:
javax.management.remote.CLOSED
javax.net.ssl.CLOSED


Occurences of ClosedConnectionException (constructors)

ClosedConnectionException (constructors) occurences:
com.sun.jdi.connect.spi.ClosedConnectionException()
com.sun.jdi.connect.spi.ClosedConnectionException(java.lang.String)


Occurences of closeEntry

closeEntry occurences:
java.util.zip.ZipInputStream.closeEntry()
java.util.zip.ZipOutputStream.closeEntry()


Occurences of closeFrame

closeFrame occurences:
javax.swing.DefaultDesktopManager.closeFrame(javax.swing.JInternalFrame)
javax.swing.DesktopManager.closeFrame(javax.swing.JInternalFrame)
javax.swing.plaf.basic.BasicInternalFrameUI.closeFrame(javax.swing.JInternalFrame)


Occurences of closeServer

closeServer occurences:
javax.management.remote.rmi.RMIIIOPServerImpl.closeServer()
javax.management.remote.rmi.RMIJRMPServerImpl.closeServer()
javax.management.remote.rmi.RMIServerImpl.closeServer()


Occurences of CODE

CODE occurences:
javax.swing.text.html.CODE
javax.swing.text.html.CODE


Occurences of code

code occurences:
org.w3c.dom.code
org.w3c.dom.events.code
org.w3c.dom.ls.code


Occurences of codePointAt

codePointAt occurences:
java.lang.Character.codePointAt(char[], int)
java.lang.Character.codePointAt(char[], int, int)
java.lang.Character.codePointAt(java.lang.CharSequence, int)
java.lang.String.codePointAt(int)
java.lang.StringBuffer.codePointAt(int)
java.lang.StringBuilder.codePointAt(int)


Occurences of codePointBefore

codePointBefore occurences:
java.lang.Character.codePointBefore(char[], int)
java.lang.Character.codePointBefore(char[], int, int)
java.lang.Character.codePointBefore(java.lang.CharSequence, int)
java.lang.String.codePointBefore(int)
java.lang.StringBuffer.codePointBefore(int)
java.lang.StringBuilder.codePointBefore(int)


Occurences of codePointCount

codePointCount occurences:
java.lang.Character.codePointCount(char[], int, int)
java.lang.Character.codePointCount(java.lang.CharSequence, int, int)
java.lang.String.codePointCount(int, int)
java.lang.StringBuffer.codePointCount(int, int)
java.lang.StringBuilder.codePointCount(int, int)


Occurences of CODESET_INCOMPATIBLE (constructors)

CODESET_INCOMPATIBLE (constructors) occurences:
org.omg.CORBA.CODESET_INCOMPATIBLE()
org.omg.CORBA.CODESET_INCOMPATIBLE(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.CODESET_INCOMPATIBLE(java.lang.String)
org.omg.CORBA.CODESET_INCOMPATIBLE(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of CodeSource (constructors)

CodeSource (constructors) occurences:
java.security.CodeSource(java.net.URL, java.security.cert.Certificate[])
java.security.CodeSource(java.net.URL, java.security.CodeSigner[])


Occurences of coerceData

coerceData occurences:
java.awt.image.BufferedImage.coerceData(boolean)
java.awt.image.ColorModel.coerceData(java.awt.image.WritableRaster, boolean)
java.awt.image.ComponentColorModel.coerceData(java.awt.image.WritableRaster, boolean)
java.awt.image.DirectColorModel.coerceData(java.awt.image.WritableRaster, boolean)


Occurences of CollectionCertStoreParameters (constructors)

CollectionCertStoreParameters (constructors) occurences:
java.security.cert.CollectionCertStoreParameters()
java.security.cert.CollectionCertStoreParameters(java.util.Collection)


Occurences of Color

Color occurences:
Color
java.awt.Color


Occurences of color

color occurences:
java.awt.color
javax.swing.border.color


Occurences of COLOR

COLOR occurences:
java.awt.COLOR
javax.print.attribute.standard.COLOR
javax.swing.text.html.COLOR
javax.swing.text.html.COLOR


Occurences of Color (constructors)

Color (constructors) occurences:
java.awt.Color(float, float, float)
java.awt.Color(float, float, float, float)
java.awt.Color(int)
java.awt.Color(int, boolean)
java.awt.Color(int, int, int)
java.awt.Color(int, int, int, int)
java.awt.Color(java.awt.color.ColorSpace, float[], float)


Occurences of ColorConvertOp (constructors)

ColorConvertOp (constructors) occurences:
java.awt.image.ColorConvertOp(java.awt.color.ColorSpace, java.awt.color.ColorSpace, java.awt.RenderingHints)
java.awt.image.ColorConvertOp(java.awt.color.ColorSpace, java.awt.RenderingHints)
java.awt.image.ColorConvertOp(java.awt.color.ICC_Profile[], java.awt.RenderingHints)
java.awt.image.ColorConvertOp(java.awt.RenderingHints)


Occurences of ColorModel (constructors)

ColorModel (constructors) occurences:
java.awt.image.ColorModel(int)
java.awt.image.ColorModel(int, int[], java.awt.color.ColorSpace, boolean, boolean, int, int)


Occurences of ColorUIResource (constructors)

ColorUIResource (constructors) occurences:
javax.swing.plaf.ColorUIResource(float, float, float)
javax.swing.plaf.ColorUIResource(int)
javax.swing.plaf.ColorUIResource(int, int, int)
javax.swing.plaf.ColorUIResource(java.awt.Color)


Occurences of COLOR_CHOOSER

COLOR_CHOOSER occurences:
javax.accessibility.COLOR_CHOOSER
javax.swing.plaf.synth.COLOR_CHOOSER


Occurences of column

column occurences:
com.sun.javadoc.SourcePosition.column()
com.sun.mirror.util.SourcePosition.column()
javax.swing.event.column


Occurences of columnAdded

columnAdded occurences:
javax.swing.event.TableColumnModelListener.columnAdded(javax.swing.event.TableColumnModelEvent)
javax.swing.JTable.columnAdded(javax.swing.event.TableColumnModelEvent)
javax.swing.JTable.AccessibleJTable.columnAdded(javax.swing.event.TableColumnModelEvent)
javax.swing.table.JTableHeader.columnAdded(javax.swing.event.TableColumnModelEvent)


Occurences of columnAtPoint

columnAtPoint occurences:
javax.swing.JTable.columnAtPoint(java.awt.Point)
javax.swing.table.JTableHeader.columnAtPoint(java.awt.Point)


Occurences of columnMarginChanged

columnMarginChanged occurences:
javax.swing.event.TableColumnModelListener.columnMarginChanged(javax.swing.event.ChangeEvent)
javax.swing.JTable.columnMarginChanged(javax.swing.event.ChangeEvent)
javax.swing.JTable.AccessibleJTable.columnMarginChanged(javax.swing.event.ChangeEvent)
javax.swing.table.JTableHeader.columnMarginChanged(javax.swing.event.ChangeEvent)


Occurences of columnModel

columnModel occurences:
javax.swing.columnModel
javax.swing.table.columnModel


Occurences of columnMoved

columnMoved occurences:
javax.swing.event.TableColumnModelListener.columnMoved(javax.swing.event.TableColumnModelEvent)
javax.swing.JTable.columnMoved(javax.swing.event.TableColumnModelEvent)
javax.swing.JTable.AccessibleJTable.columnMoved(javax.swing.event.TableColumnModelEvent)
javax.swing.table.JTableHeader.columnMoved(javax.swing.event.TableColumnModelEvent)


Occurences of columnNoNulls

columnNoNulls occurences:
java.sql.columnNoNulls
java.sql.columnNoNulls


Occurences of columnNullable

columnNullable occurences:
java.sql.columnNullable
java.sql.columnNullable


Occurences of columnNullableUnknown

columnNullableUnknown occurences:
java.sql.columnNullableUnknown
java.sql.columnNullableUnknown


Occurences of columnRemoved

columnRemoved occurences:
javax.swing.event.TableColumnModelListener.columnRemoved(javax.swing.event.TableColumnModelEvent)
javax.swing.JTable.columnRemoved(javax.swing.event.TableColumnModelEvent)
javax.swing.JTable.AccessibleJTable.columnRemoved(javax.swing.event.TableColumnModelEvent)
javax.swing.table.JTableHeader.columnRemoved(javax.swing.event.TableColumnModelEvent)


Occurences of columnSelectionChanged

columnSelectionChanged occurences:
javax.swing.event.TableColumnModelListener.columnSelectionChanged(javax.swing.event.ListSelectionEvent)
javax.swing.JTable.columnSelectionChanged(javax.swing.event.ListSelectionEvent)
javax.swing.JTable.AccessibleJTable.columnSelectionChanged(javax.swing.event.ListSelectionEvent)
javax.swing.table.JTableHeader.columnSelectionChanged(javax.swing.event.ListSelectionEvent)


Occurences of columnUpdated

columnUpdated occurences:
javax.sql.rowset.CachedRowSet.columnUpdated(int)
javax.sql.rowset.CachedRowSet.columnUpdated(java.lang.String)


Occurences of COLUMN_HEADER

COLUMN_HEADER occurences:
javax.accessibility.COLUMN_HEADER
javax.swing.COLUMN_HEADER


Occurences of combine

combine occurences:
java.security.DomainCombiner.combine(java.security.ProtectionDomain[], java.security.ProtectionDomain[])
javax.security.auth.SubjectDomainCombiner.combine(java.security.ProtectionDomain[], java.security.ProtectionDomain[])


Occurences of comboBox

comboBox occurences:
javax.swing.plaf.basic.comboBox
javax.swing.plaf.basic.comboBox
javax.swing.plaf.metal.comboBox


Occurences of COMBO_BOX

COMBO_BOX occurences:
javax.accessibility.COMBO_BOX
javax.swing.plaf.synth.COMBO_BOX


Occurences of command

command occurences:
java.lang.Compiler.command(java.lang.Object)
java.lang.ProcessBuilder.command()
java.lang.ProcessBuilder.command(java.lang.String...)
java.lang.ProcessBuilder.command(java.util.List)


Occurences of Comment

Comment occurences:
javax.xml.stream.events.Comment
org.w3c.dom.Comment


Occurences of comment

comment occurences:
javax.swing.text.html.HTMLWriter.comment(javax.swing.text.Element)
org.xml.sax.ext.DefaultHandler2.comment(char[], int, int)
org.xml.sax.ext.LexicalHandler.comment(char[], int, int)


Occurences of COMMENT

COMMENT occurences:
javax.swing.text.html.COMMENT
javax.swing.text.html.COMMENT
javax.xml.stream.COMMENT


Occurences of commit

commit occurences:
java.sql.Connection.commit()
javax.security.auth.spi.LoginModule.commit()
javax.sql.rowset.CachedRowSet.commit()
javax.sql.rowset.JdbcRowSet.commit()
javax.sql.rowset.spi.TransactionalWriter.commit()
javax.transaction.xa.XAResource.commit(javax.transaction.xa.Xid, boolean)


Occurences of commitEdit

commitEdit occurences:
javax.swing.JFormattedTextField.commitEdit()
javax.swing.JSpinner.commitEdit()
javax.swing.JSpinner.DefaultEditor.commitEdit()


Occurences of CommunicationException (constructors)

CommunicationException (constructors) occurences:
javax.naming.CommunicationException()
javax.naming.CommunicationException(java.lang.String)


Occurences of COMM_FAILURE (constructors)

COMM_FAILURE (constructors) occurences:
org.omg.CORBA.COMM_FAILURE()
org.omg.CORBA.COMM_FAILURE(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.COMM_FAILURE(java.lang.String)
org.omg.CORBA.COMM_FAILURE(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of compact

compact occurences:
java.nio.ByteBuffer.compact()
java.nio.CharBuffer.compact()
java.nio.DoubleBuffer.compact()
java.nio.FloatBuffer.compact()
java.nio.IntBuffer.compact()
java.nio.LongBuffer.compact()
java.nio.ShortBuffer.compact()


Occurences of comparator

comparator occurences:
java.util.concurrent.ConcurrentSkipListMap.comparator()
java.util.concurrent.ConcurrentSkipListSet.comparator()
java.util.concurrent.PriorityBlockingQueue.comparator()
java.util.PriorityQueue.comparator()
java.util.SortedMap.comparator()
java.util.SortedSet.comparator()
java.util.TreeMap.comparator()
java.util.TreeSet.comparator()


Occurences of compare

compare occurences:
java.lang.Double.compare(double, double)
java.lang.Float.compare(float, float)
java.text.Collator.compare(java.lang.Object, java.lang.Object)
java.text.Collator.compare(java.lang.String, java.lang.String)
java.text.RuleBasedCollator.compare(java.lang.String, java.lang.String)
java.util.Comparator.compare(java.lang.Object,java.lang.Object)
java.util.Comparator.compare(T, T)
javax.xml.datatype.Duration.compare(javax.xml.datatype.Duration)
javax.xml.datatype.XMLGregorianCalendar.compare(javax.xml.datatype.XMLGregorianCalendar)


Occurences of compareAndSet

compareAndSet occurences:
java.util.concurrent.atomic.AtomicBoolean.compareAndSet(boolean, boolean)
java.util.concurrent.atomic.AtomicInteger.compareAndSet(int, int)
java.util.concurrent.atomic.AtomicIntegerArray.compareAndSet(int, int, int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.compareAndSet(java.lang.Object,int,int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.compareAndSet(T, int, int)
java.util.concurrent.atomic.AtomicLong.compareAndSet(long, long)
java.util.concurrent.atomic.AtomicLongArray.compareAndSet(int, long, long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.compareAndSet(java.lang.Object,long,long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.compareAndSet(T, long, long)
java.util.concurrent.atomic.AtomicMarkableReference.compareAndSet(java.lang.Object,java.lang.Object,boolean,boolean)
java.util.concurrent.atomic.AtomicMarkableReference.compareAndSet(V, V, boolean, boolean)
java.util.concurrent.atomic.AtomicReference.compareAndSet(java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReference.compareAndSet(V, V)
java.util.concurrent.atomic.AtomicReferenceArray.compareAndSet(int, E, E)
java.util.concurrent.atomic.AtomicReferenceArray.compareAndSet(int,java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.compareAndSet(java.lang.Object,java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.compareAndSet(T, V, V)
java.util.concurrent.atomic.AtomicStampedReference.compareAndSet(java.lang.Object,java.lang.Object,int,int)
java.util.concurrent.atomic.AtomicStampedReference.compareAndSet(V, V, int, int)


Occurences of compareAndSetState

compareAndSetState occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.compareAndSetState(long, long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.compareAndSetState(int, int)


Occurences of compareDocumentPosition

compareDocumentPosition occurences:
javax.imageio.metadata.IIOMetadataNode.compareDocumentPosition(org.w3c.dom.Node)
org.w3c.dom.Node.compareDocumentPosition(org.w3c.dom.Node)


Occurences of compareTo

compareTo occurences:
com.sun.javadoc.Doc.compareTo(java.lang.Object)
com.sun.javadoc.SerialFieldTag.compareTo(java.lang.Object)
java.io.File.compareTo(java.io.File)
java.io.ObjectStreamField.compareTo(java.lang.Object)
java.lang.Boolean.compareTo(java.lang.Boolean)
java.lang.Byte.compareTo(java.lang.Byte)
java.lang.Character.compareTo(java.lang.Character)
java.lang.Comparable.compareTo(java.lang.Object)
java.lang.Comparable.compareTo(T)
java.lang.Double.compareTo(java.lang.Double)
java.lang.Enum.compareTo(E)
java.lang.Enum.compareTo(java.lang.Enum)
java.lang.Float.compareTo(java.lang.Float)
java.lang.Integer.compareTo(java.lang.Integer)
java.lang.Long.compareTo(java.lang.Long)
java.lang.Short.compareTo(java.lang.Short)
java.lang.String.compareTo(java.lang.String)
java.math.BigDecimal.compareTo(java.math.BigDecimal)
java.math.BigInteger.compareTo(java.math.BigInteger)
java.net.URI.compareTo(java.net.URI)
java.nio.ByteBuffer.compareTo(java.nio.ByteBuffer)
java.nio.CharBuffer.compareTo(java.nio.CharBuffer)
java.nio.charset.Charset.compareTo(java.nio.charset.Charset)
java.nio.DoubleBuffer.compareTo(java.nio.DoubleBuffer)
java.nio.FloatBuffer.compareTo(java.nio.FloatBuffer)
java.nio.IntBuffer.compareTo(java.nio.IntBuffer)
java.nio.LongBuffer.compareTo(java.nio.LongBuffer)
java.nio.ShortBuffer.compareTo(java.nio.ShortBuffer)
java.sql.Timestamp.compareTo(java.sql.Timestamp)
java.sql.Timestamp.compareTo(java.util.Date)
java.text.CollationKey.compareTo(java.text.CollationKey)
java.util.Calendar.compareTo(java.util.Calendar)
java.util.Date.compareTo(java.util.Date)
java.util.UUID.compareTo(java.util.UUID)
javax.management.ObjectName.compareTo(javax.management.ObjectName)
javax.naming.CompositeName.compareTo(java.lang.Object)
javax.naming.CompoundName.compareTo(java.lang.Object)
javax.naming.ldap.LdapName.compareTo(java.lang.Object)
javax.naming.ldap.Rdn.compareTo(java.lang.Object)
javax.naming.Name.compareTo(java.lang.Object)


Occurences of compile

compile occurences:
java.util.regex.Pattern.compile(java.lang.String)
java.util.regex.Pattern.compile(java.lang.String, int)
javax.script.Compilable.compile(java.io.Reader)
javax.script.Compilable.compile(java.lang.String)
javax.xml.xpath.XPath.compile(java.lang.String)


Occurences of completeDrag

completeDrag occurences:
javax.swing.plaf.basic.BasicSplitPaneDivider.DragController.completeDrag(int, int)
javax.swing.plaf.basic.BasicSplitPaneDivider.DragController.completeDrag(java.awt.event.MouseEvent)


Occurences of completeEditing

completeEditing occurences:
javax.swing.plaf.basic.BasicTreeUI.completeEditing()
javax.swing.plaf.basic.BasicTreeUI.completeEditing(boolean, boolean, boolean)


Occurences of component

component occurences:
java.awt.dnd.component
javax.swing.component


Occurences of componentAdded

componentAdded occurences:
java.awt.AWTEventMulticaster.componentAdded(java.awt.event.ContainerEvent)
java.awt.Container.AccessibleAWTContainer.AccessibleContainerHandler.componentAdded(java.awt.event.ContainerEvent)
java.awt.event.ContainerAdapter.componentAdded(java.awt.event.ContainerEvent)
java.awt.event.ContainerListener.componentAdded(java.awt.event.ContainerEvent)
javax.swing.JComponent.AccessibleJComponent.AccessibleContainerHandler.componentAdded(java.awt.event.ContainerEvent)
javax.swing.plaf.basic.BasicToolBarUI.ToolBarContListener.componentAdded(java.awt.event.ContainerEvent)


Occurences of ComponentColorModel (constructors)

ComponentColorModel (constructors) occurences:
java.awt.image.ComponentColorModel(java.awt.color.ColorSpace, boolean, boolean, int, int)
java.awt.image.ComponentColorModel(java.awt.color.ColorSpace, int[], boolean, boolean, int, int)


Occurences of componentHidden

componentHidden occurences:
java.awt.AWTEventMulticaster.componentHidden(java.awt.event.ComponentEvent)
java.awt.Component.AccessibleAWTComponent.AccessibleAWTComponentHandler.componentHidden(java.awt.event.ComponentEvent)
java.awt.event.ComponentAdapter.componentHidden(java.awt.event.ComponentEvent)
java.awt.event.ComponentListener.componentHidden(java.awt.event.ComponentEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.ComponentHandler.componentHidden(java.awt.event.ComponentEvent)


Occurences of componentListener

componentListener occurences:
javax.swing.plaf.basic.componentListener
javax.swing.plaf.basic.componentListener


Occurences of componentMoved

componentMoved occurences:
java.awt.AWTEventMulticaster.componentMoved(java.awt.event.ComponentEvent)
java.awt.Component.AccessibleAWTComponent.AccessibleAWTComponentHandler.componentMoved(java.awt.event.ComponentEvent)
java.awt.event.ComponentAdapter.componentMoved(java.awt.event.ComponentEvent)
java.awt.event.ComponentListener.componentMoved(java.awt.event.ComponentEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.ComponentHandler.componentMoved(java.awt.event.ComponentEvent)
javax.swing.plaf.basic.BasicTreeUI.ComponentHandler.componentMoved(java.awt.event.ComponentEvent)


Occurences of componentRemoved

componentRemoved occurences:
java.awt.AWTEventMulticaster.componentRemoved(java.awt.event.ContainerEvent)
java.awt.Container.AccessibleAWTContainer.AccessibleContainerHandler.componentRemoved(java.awt.event.ContainerEvent)
java.awt.event.ContainerAdapter.componentRemoved(java.awt.event.ContainerEvent)
java.awt.event.ContainerListener.componentRemoved(java.awt.event.ContainerEvent)
javax.swing.JComponent.AccessibleJComponent.AccessibleContainerHandler.componentRemoved(java.awt.event.ContainerEvent)
javax.swing.plaf.basic.BasicToolBarUI.ToolBarContListener.componentRemoved(java.awt.event.ContainerEvent)


Occurences of componentResized

componentResized occurences:
java.awt.AWTEventMulticaster.componentResized(java.awt.event.ComponentEvent)
java.awt.Component.AccessibleAWTComponent.AccessibleAWTComponentHandler.componentResized(java.awt.event.ComponentEvent)
java.awt.event.ComponentAdapter.componentResized(java.awt.event.ComponentEvent)
java.awt.event.ComponentListener.componentResized(java.awt.event.ComponentEvent)
javax.swing.JViewport.ViewListener.componentResized(java.awt.event.ComponentEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.ComponentHandler.componentResized(java.awt.event.ComponentEvent)
javax.swing.plaf.basic.BasicSliderUI.ComponentHandler.componentResized(java.awt.event.ComponentEvent)


Occurences of ComponentSampleModel (constructors)

ComponentSampleModel (constructors) occurences:
java.awt.image.ComponentSampleModel(int, int, int, int, int, int[])
java.awt.image.ComponentSampleModel(int, int, int, int, int, int[], int[])


Occurences of componentShown

componentShown occurences:
java.awt.AWTEventMulticaster.componentShown(java.awt.event.ComponentEvent)
java.awt.Component.AccessibleAWTComponent.AccessibleAWTComponentHandler.componentShown(java.awt.event.ComponentEvent)
java.awt.event.ComponentAdapter.componentShown(java.awt.event.ComponentEvent)
java.awt.event.ComponentListener.componentShown(java.awt.event.ComponentEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.ComponentHandler.componentShown(java.awt.event.ComponentEvent)


Occurences of component_count

component_count occurences:
org.omg.DynamicAny.DynAnyOperations.component_count()
org.omg.DynamicAny._DynAnyStub.component_count()
org.omg.DynamicAny._DynArrayStub.component_count()
org.omg.DynamicAny._DynEnumStub.component_count()
org.omg.DynamicAny._DynFixedStub.component_count()
org.omg.DynamicAny._DynSequenceStub.component_count()
org.omg.DynamicAny._DynStructStub.component_count()
org.omg.DynamicAny._DynUnionStub.component_count()
org.omg.DynamicAny._DynValueStub.component_count()


Occurences of composeName

composeName occurences:
javax.naming.Context.composeName(java.lang.String, java.lang.String)
javax.naming.Context.composeName(javax.naming.Name, javax.naming.Name)
javax.naming.InitialContext.composeName(java.lang.String, java.lang.String)
javax.naming.InitialContext.composeName(javax.naming.Name, javax.naming.Name)


Occurences of CompositeDataSupport (constructors)

CompositeDataSupport (constructors) occurences:
javax.management.openmbean.CompositeDataSupport(javax.management.openmbean.CompositeType, java.lang.String[], java.lang.Object[])
javax.management.openmbean.CompositeDataSupport(javax.management.openmbean.CompositeType, java.util.Map)


Occurences of CompositeName (constructors)

CompositeName (constructors) occurences:
javax.naming.CompositeName()
javax.naming.CompositeName(java.lang.String)
javax.naming.CompositeName(java.util.Enumeration)


Occurences of CompoundBorder (constructors)

CompoundBorder (constructors) occurences:
javax.swing.border.CompoundBorder()
javax.swing.border.CompoundBorder(javax.swing.border.Border, javax.swing.border.Border)


Occurences of CompoundName (constructors)

CompoundName (constructors) occurences:
javax.naming.CompoundName(java.lang.String, java.util.Properties)
javax.naming.CompoundName(java.util.Enumeration, java.util.Properties)


Occurences of computeFields

computeFields occurences:
java.util.Calendar.computeFields()
java.util.GregorianCalendar.computeFields()


Occurences of computeStringWidth

computeStringWidth occurences:
javax.swing.plaf.synth.SynthGraphicsUtils.computeStringWidth(javax.swing.plaf.synth.SynthContext, java.awt.Font, java.awt.FontMetrics, java.lang.String)
javax.swing.SwingUtilities.computeStringWidth(java.awt.FontMetrics, java.lang.String)


Occurences of computeTime

computeTime occurences:
java.util.Calendar.computeTime()
java.util.GregorianCalendar.computeTime()


Occurences of ConcurrentHashMap (constructors)

ConcurrentHashMap (constructors) occurences:
java.util.concurrent.ConcurrentHashMap()
java.util.concurrent.ConcurrentHashMap(int)
java.util.concurrent.ConcurrentHashMap(int, float)
java.util.concurrent.ConcurrentHashMap(int, float, int)
java.util.concurrent.ConcurrentHashMap(java.util.Map)


Occurences of ConcurrentLinkedQueue (constructors)

ConcurrentLinkedQueue (constructors) occurences:
java.util.concurrent.ConcurrentLinkedQueue()
java.util.concurrent.ConcurrentLinkedQueue(java.util.Collection)


Occurences of ConcurrentModificationException (constructors)

ConcurrentModificationException (constructors) occurences:
java.util.ConcurrentModificationException()
java.util.ConcurrentModificationException(java.lang.String)


Occurences of ConcurrentSkipListMap (constructors)

ConcurrentSkipListMap (constructors) occurences:
java.util.concurrent.ConcurrentSkipListMap()
java.util.concurrent.ConcurrentSkipListMap(java.util.Comparator)
java.util.concurrent.ConcurrentSkipListMap(java.util.Map)
java.util.concurrent.ConcurrentSkipListMap(java.util.SortedMap)


Occurences of ConcurrentSkipListSet (constructors)

ConcurrentSkipListSet (constructors) occurences:
java.util.concurrent.ConcurrentSkipListSet()
java.util.concurrent.ConcurrentSkipListSet(java.util.Collection)
java.util.concurrent.ConcurrentSkipListSet(java.util.Comparator)
java.util.concurrent.ConcurrentSkipListSet(java.util.SortedSet)


Occurences of ConfigurationException (constructors)

ConfigurationException (constructors) occurences:
javax.naming.ConfigurationException()
javax.naming.ConfigurationException(java.lang.String)


Occurences of configureBlocking

configureBlocking occurences:
java.nio.channels.SelectableChannel.configureBlocking(boolean)
java.nio.channels.spi.AbstractSelectableChannel.configureBlocking(boolean)


Occurences of configureEditor

configureEditor occurences:
javax.swing.JComboBox.configureEditor(javax.swing.ComboBoxEditor, java.lang.Object)
javax.swing.plaf.basic.BasicComboBoxUI.configureEditor()
javax.swing.plaf.metal.MetalComboBoxUI.configureEditor()


Occurences of configurePropertiesFromAction

configurePropertiesFromAction occurences:
javax.swing.AbstractButton.configurePropertiesFromAction(javax.swing.Action)
javax.swing.JComboBox.configurePropertiesFromAction(javax.swing.Action)
javax.swing.JMenuItem.configurePropertiesFromAction(javax.swing.Action)
javax.swing.JTextField.configurePropertiesFromAction(javax.swing.Action)


Occurences of configureScrollBarColors

configureScrollBarColors occurences:
javax.swing.plaf.basic.BasicScrollBarUI.configureScrollBarColors()
javax.swing.plaf.metal.MetalScrollBarUI.configureScrollBarColors()


Occurences of ConfirmationCallback (constructors)

ConfirmationCallback (constructors) occurences:
javax.security.auth.callback.ConfirmationCallback(int, int, int)
javax.security.auth.callback.ConfirmationCallback(int, java.lang.String[], int)
javax.security.auth.callback.ConfirmationCallback(java.lang.String, int, int, int)
javax.security.auth.callback.ConfirmationCallback(java.lang.String, int, java.lang.String[], int)


Occurences of connect

connect occurences:
com.sun.jdi.connect
java.io.PipedInputStream.connect(java.io.PipedOutputStream)
java.io.PipedOutputStream.connect(java.io.PipedInputStream)
java.io.PipedReader.connect(java.io.PipedWriter)
java.io.PipedWriter.connect(java.io.PipedReader)
java.net.DatagramSocket.connect(java.net.InetAddress, int)
java.net.DatagramSocket.connect(java.net.SocketAddress)
java.net.DatagramSocketImpl.connect(java.net.InetAddress, int)
java.net.Socket.connect(java.net.SocketAddress)
java.net.Socket.connect(java.net.SocketAddress, int)
java.net.SocketImpl.connect(java.lang.String, int)
java.net.SocketImpl.connect(java.net.InetAddress, int)
java.net.SocketImpl.connect(java.net.SocketAddress, int)
java.net.URLConnection.connect()
java.nio.channels.DatagramChannel.connect(java.net.SocketAddress)
java.nio.channels.SocketChannel.connect(java.net.SocketAddress)
java.sql.Driver.connect(java.lang.String, java.util.Properties)
javax.management.remote.JMXConnector.connect()
javax.management.remote.JMXConnector.connect(java.util.Map)
javax.management.remote.JMXConnectorFactory.connect(javax.management.remote.JMXServiceURL)
javax.management.remote.JMXConnectorFactory.connect(javax.management.remote.JMXServiceURL, java.util.Map)
javax.management.remote.rmi.RMIConnector.connect()
javax.management.remote.rmi.RMIConnector.connect(java.util.Map)
javax.rmi.CORBA.PortableRemoteObjectDelegate.connect(java.rmi.Remote, java.rmi.Remote)
javax.rmi.CORBA.Stub.connect(org.omg.CORBA.ORB)
javax.rmi.CORBA.StubDelegate.connect(javax.rmi.CORBA.Stub, org.omg.CORBA.ORB)
javax.rmi.PortableRemoteObject.connect(java.rmi.Remote, java.rmi.Remote)
org.omg.CORBA.ORB.connect(org.omg.CORBA.Object)


Occurences of ConnectException

ConnectException occurences:
java.net.ConnectException
java.rmi.ConnectException


Occurences of ConnectException (constructors)

ConnectException (constructors) occurences:
java.net.ConnectException()
java.net.ConnectException(java.lang.String)
java.rmi.ConnectException(java.lang.String)
java.rmi.ConnectException(java.lang.String, java.lang.Exception)


Occurences of ConnectIOException (constructors)

ConnectIOException (constructors) occurences:
java.rmi.ConnectIOException(java.lang.String)
java.rmi.ConnectIOException(java.lang.String, java.lang.Exception)


Occurences of Connection

Connection occurences:
com.sun.jdi.connect.spi.Connection
Connection
java.sql.Connection


Occurences of connectionClosed

connectionClosed occurences:
javax.management.remote.JMXConnectorServer.connectionClosed(java.lang.String, java.lang.String, java.lang.Object)
javax.management.remote.rmi.RMIConnectorServer.connectionClosed(java.lang.String, java.lang.String, java.lang.Object)
javax.sql.ConnectionEventListener.connectionClosed(javax.sql.ConnectionEvent)


Occurences of ConnectionEvent (constructors)

ConnectionEvent (constructors) occurences:
javax.sql.ConnectionEvent(javax.sql.PooledConnection)
javax.sql.ConnectionEvent(javax.sql.PooledConnection, java.sql.SQLException)


Occurences of connectionFailed

connectionFailed occurences:
javax.management.remote.JMXConnectorServer.connectionFailed(java.lang.String, java.lang.String, java.lang.Object)
javax.management.remote.rmi.RMIConnectorServer.connectionFailed(java.lang.String, java.lang.String, java.lang.Object)


Occurences of connectionOpened

connectionOpened occurences:
javax.management.remote.JMXConnectorServer.connectionOpened(java.lang.String, java.lang.String, java.lang.Object)
javax.management.remote.rmi.RMIConnectorServer.connectionOpened(java.lang.String, java.lang.String, java.lang.Object)


Occurences of constant

constant occurences:
javax.swing.Spring.constant(int)
javax.swing.Spring.constant(int, int, int)


Occurences of Constant Field Values

Constant Field Values occurences:
Constant Field Values
Constant Field Values
Constant Field Values
Constant Field Values
Constant Field Values
Constant Field Values
Constant Field Values


Occurences of CONSTRUCTOR

CONSTRUCTOR occurences:
java.lang.annotation.CONSTRUCTOR
javax.lang.model.element.CONSTRUCTOR


Occurences of consume

consume occurences:
java.awt.AWTEvent.consume()
java.awt.event.InputEvent.consume()
java.awt.event.InputMethodEvent.consume()


Occurences of contains

contains occurences:
java.awt.Component.contains(int, int)
java.awt.Component.contains(java.awt.Point)
java.awt.Component.AccessibleAWTComponent.contains(java.awt.Point)
java.awt.geom.Arc2D.contains(double, double)
java.awt.geom.Arc2D.contains(double, double, double, double)
java.awt.geom.Arc2D.contains(java.awt.geom.Rectangle2D)
java.awt.geom.Area.contains(double, double)
java.awt.geom.Area.contains(double, double, double, double)
java.awt.geom.Area.contains(java.awt.geom.Point2D)
java.awt.geom.Area.contains(java.awt.geom.Rectangle2D)
java.awt.geom.CubicCurve2D.contains(double, double)
java.awt.geom.CubicCurve2D.contains(double, double, double, double)
java.awt.geom.CubicCurve2D.contains(java.awt.geom.Point2D)
java.awt.geom.CubicCurve2D.contains(java.awt.geom.Rectangle2D)
java.awt.geom.Ellipse2D.contains(double, double)
java.awt.geom.Ellipse2D.contains(double, double, double, double)
java.awt.geom.Line2D.contains(double, double)
java.awt.geom.Line2D.contains(double, double, double, double)
java.awt.geom.Line2D.contains(java.awt.geom.Point2D)
java.awt.geom.Line2D.contains(java.awt.geom.Rectangle2D)
java.awt.geom.Path2D.contains(double, double)
java.awt.geom.Path2D.contains(double, double, double, double)
java.awt.geom.Path2D.contains(java.awt.geom.PathIterator, double, double)
java.awt.geom.Path2D.contains(java.awt.geom.PathIterator, double, double, double, double)
java.awt.geom.Path2D.contains(java.awt.geom.PathIterator, java.awt.geom.Point2D)
java.awt.geom.Path2D.contains(java.awt.geom.PathIterator, java.awt.geom.Rectangle2D)
java.awt.geom.Path2D.contains(java.awt.geom.Point2D)
java.awt.geom.Path2D.contains(java.awt.geom.Rectangle2D)
java.awt.geom.QuadCurve2D.contains(double, double)
java.awt.geom.QuadCurve2D.contains(double, double, double, double)
java.awt.geom.QuadCurve2D.contains(java.awt.geom.Point2D)
java.awt.geom.QuadCurve2D.contains(java.awt.geom.Rectangle2D)
java.awt.geom.Rectangle2D.contains(double, double)
java.awt.geom.Rectangle2D.contains(double, double, double, double)
java.awt.geom.RectangularShape.contains(java.awt.geom.Point2D)
java.awt.geom.RectangularShape.contains(java.awt.geom.Rectangle2D)
java.awt.geom.RoundRectangle2D.contains(double, double)
java.awt.geom.RoundRectangle2D.contains(double, double, double, double)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.contains(java.awt.Point)
java.awt.MenuComponent.AccessibleAWTMenuComponent.contains(java.awt.Point)
java.awt.Polygon.contains(double, double)
java.awt.Polygon.contains(double, double, double, double)
java.awt.Polygon.contains(int, int)
java.awt.Polygon.contains(java.awt.geom.Point2D)
java.awt.Polygon.contains(java.awt.geom.Rectangle2D)
java.awt.Polygon.contains(java.awt.Point)
java.awt.Rectangle.contains(int, int)
java.awt.Rectangle.contains(int, int, int, int)
java.awt.Rectangle.contains(java.awt.Point)
java.awt.Rectangle.contains(java.awt.Rectangle)
java.awt.Shape.contains(double, double)
java.awt.Shape.contains(double, double, double, double)
java.awt.Shape.contains(java.awt.geom.Point2D)
java.awt.Shape.contains(java.awt.geom.Rectangle2D)
java.beans.beancontext.BeanContextMembershipEvent.contains(java.lang.Object)
java.beans.beancontext.BeanContextSupport.contains(java.lang.Object)
java.lang.String.contains(java.lang.CharSequence)
java.nio.charset.Charset.contains(java.nio.charset.Charset)
java.util.AbstractCollection.contains(java.lang.Object)
java.util.ArrayDeque.contains(java.lang.Object)
java.util.ArrayList.contains(java.lang.Object)
java.util.Collection.contains(java.lang.Object)
java.util.concurrent.ArrayBlockingQueue.contains(java.lang.Object)
java.util.concurrent.BlockingDeque.contains(java.lang.Object)
java.util.concurrent.BlockingQueue.contains(java.lang.Object)
java.util.concurrent.ConcurrentHashMap.contains(java.lang.Object)
java.util.concurrent.ConcurrentLinkedQueue.contains(java.lang.Object)
java.util.concurrent.ConcurrentSkipListSet.contains(java.lang.Object)
java.util.concurrent.CopyOnWriteArrayList.contains(java.lang.Object)
java.util.concurrent.CopyOnWriteArraySet.contains(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.contains(java.lang.Object)
java.util.concurrent.PriorityBlockingQueue.contains(java.lang.Object)
java.util.concurrent.SynchronousQueue.contains(java.lang.Object)
java.util.Deque.contains(java.lang.Object)
java.util.HashSet.contains(java.lang.Object)
java.util.Hashtable.contains(java.lang.Object)
java.util.LinkedList.contains(java.lang.Object)
java.util.List.contains(java.lang.Object)
java.util.PriorityQueue.contains(java.lang.Object)
java.util.Set.contains(java.lang.Object)
java.util.TreeSet.contains(java.lang.Object)
java.util.Vector.contains(java.lang.Object)
javax.accessibility.AccessibleComponent.contains(java.awt.Point)
javax.accessibility.AccessibleRelationSet.contains(java.lang.String)
javax.accessibility.AccessibleStateSet.contains(javax.accessibility.AccessibleState)
javax.imageio.spi.ServiceRegistry.contains(java.lang.Object)
javax.lang.model.util.Types.contains(javax.lang.model.type.TypeMirror, javax.lang.model.type.TypeMirror)
javax.naming.directory.Attribute.contains(java.lang.Object)
javax.naming.directory.BasicAttribute.contains(java.lang.Object)
javax.print.attribute.SetOfIntegerSyntax.contains(int)
javax.print.attribute.SetOfIntegerSyntax.contains(javax.print.attribute.IntegerSyntax)
javax.swing.DefaultListModel.contains(java.lang.Object)
javax.swing.JComponent.contains(int, int)
javax.swing.JList.AccessibleJList.AccessibleJListChild.contains(java.awt.Point)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.contains(java.awt.Point)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.contains(java.awt.Point)
javax.swing.plaf.basic.BasicDirectoryModel.contains(java.lang.Object)
javax.swing.plaf.ComponentUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiButtonUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiColorChooserUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiComboBoxUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiDesktopIconUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiDesktopPaneUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiFileChooserUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiInternalFrameUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiLabelUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiListUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiMenuBarUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiMenuItemUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiOptionPaneUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiPanelUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiPopupMenuUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiProgressBarUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiRootPaneUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiScrollBarUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiScrollPaneUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiSeparatorUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiSliderUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiSpinnerUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiSplitPaneUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiTabbedPaneUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiTableHeaderUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiTableUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiTextUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiToolBarUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiToolTipUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiTreeUI.contains(javax.swing.JComponent, int, int)
javax.swing.plaf.multi.MultiViewportUI.contains(javax.swing.JComponent, int, int)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.contains(java.awt.Point)
org.w3c.dom.DOMStringList.contains(java.lang.String)
org.w3c.dom.NameList.contains(java.lang.String)


Occurences of containsAll

containsAll occurences:
java.beans.beancontext.BeanContextSupport.containsAll(java.util.Collection)
java.util.AbstractCollection.containsAll(java.util.Collection)
java.util.Collection.containsAll(java.util.Collection)
java.util.concurrent.CopyOnWriteArrayList.containsAll(java.util.Collection)
java.util.concurrent.CopyOnWriteArraySet.containsAll(java.util.Collection)
java.util.concurrent.SynchronousQueue.containsAll(java.util.Collection)
java.util.List.containsAll(java.util.Collection)
java.util.Set.containsAll(java.util.Collection)
java.util.Vector.containsAll(java.util.Collection)


Occurences of containsAttribute

containsAttribute occurences:
javax.swing.text.AbstractDocument.AbstractElement.containsAttribute(java.lang.Object, java.lang.Object)
javax.swing.text.AttributeSet.containsAttribute(java.lang.Object, java.lang.Object)
javax.swing.text.SimpleAttributeSet.containsAttribute(java.lang.Object, java.lang.Object)
javax.swing.text.StyleContext.NamedStyle.containsAttribute(java.lang.Object, java.lang.Object)
javax.swing.text.StyleContext.SmallAttributeSet.containsAttribute(java.lang.Object, java.lang.Object)


Occurences of containsAttributes

containsAttributes occurences:
javax.swing.text.AbstractDocument.AbstractElement.containsAttributes(javax.swing.text.AttributeSet)
javax.swing.text.AttributeSet.containsAttributes(javax.swing.text.AttributeSet)
javax.swing.text.SimpleAttributeSet.containsAttributes(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.NamedStyle.containsAttributes(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.SmallAttributeSet.containsAttributes(javax.swing.text.AttributeSet)


Occurences of containsCustomComponents

containsCustomComponents occurences:
javax.swing.plaf.basic.BasicOptionPaneUI.containsCustomComponents(javax.swing.JOptionPane)
javax.swing.plaf.multi.MultiOptionPaneUI.containsCustomComponents(javax.swing.JOptionPane)
javax.swing.plaf.OptionPaneUI.containsCustomComponents(javax.swing.JOptionPane)


Occurences of containsKey

containsKey occurences:
java.awt.RenderingHints.containsKey(java.lang.Object)
java.beans.beancontext.BeanContextSupport.containsKey(java.lang.Object)
java.util.AbstractMap.containsKey(java.lang.Object)
java.util.concurrent.ConcurrentHashMap.containsKey(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.containsKey(java.lang.Object)
java.util.EnumMap.containsKey(java.lang.Object)
java.util.HashMap.containsKey(java.lang.Object)
java.util.Hashtable.containsKey(java.lang.Object)
java.util.IdentityHashMap.containsKey(java.lang.Object)
java.util.jar.Attributes.containsKey(java.lang.Object)
java.util.Map.containsKey(java.lang.Object)
java.util.ResourceBundle.containsKey(java.lang.String)
java.util.TreeMap.containsKey(java.lang.Object)
java.util.WeakHashMap.containsKey(java.lang.Object)
javax.management.openmbean.CompositeData.containsKey(java.lang.String)
javax.management.openmbean.CompositeDataSupport.containsKey(java.lang.String)
javax.management.openmbean.CompositeType.containsKey(java.lang.String)
javax.management.openmbean.TabularData.containsKey(java.lang.Object[])
javax.management.openmbean.TabularDataSupport.containsKey(java.lang.Object)
javax.management.openmbean.TabularDataSupport.containsKey(java.lang.Object[])
javax.print.attribute.AttributeSet.containsKey(java.lang.Class)
javax.print.attribute.HashAttributeSet.containsKey(java.lang.Class)
javax.script.Bindings.containsKey(java.lang.Object)
javax.script.SimpleBindings.containsKey(java.lang.Object)


Occurences of containsObservedObject

containsObservedObject occurences:
javax.management.monitor.Monitor.containsObservedObject(javax.management.ObjectName)
javax.management.monitor.MonitorMBean.containsObservedObject(javax.management.ObjectName)


Occurences of containsValue

containsValue occurences:
java.awt.RenderingHints.containsValue(java.lang.Object)
java.util.AbstractMap.containsValue(java.lang.Object)
java.util.concurrent.ConcurrentHashMap.containsValue(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.containsValue(java.lang.Object)
java.util.EnumMap.containsValue(java.lang.Object)
java.util.HashMap.containsValue(java.lang.Object)
java.util.Hashtable.containsValue(java.lang.Object)
java.util.IdentityHashMap.containsValue(java.lang.Object)
java.util.jar.Attributes.containsValue(java.lang.Object)
java.util.LinkedHashMap.containsValue(java.lang.Object)
java.util.Map.containsValue(java.lang.Object)
java.util.TreeMap.containsValue(java.lang.Object)
java.util.WeakHashMap.containsValue(java.lang.Object)
javax.management.openmbean.CompositeData.containsValue(java.lang.Object)
javax.management.openmbean.CompositeDataSupport.containsValue(java.lang.Object)
javax.management.openmbean.TabularData.containsValue(javax.management.openmbean.CompositeData)
javax.management.openmbean.TabularDataSupport.containsValue(java.lang.Object)
javax.management.openmbean.TabularDataSupport.containsValue(javax.management.openmbean.CompositeData)
javax.print.attribute.AttributeSet.containsValue(javax.print.attribute.Attribute)
javax.print.attribute.HashAttributeSet.containsValue(javax.print.attribute.Attribute)
javax.script.SimpleBindings.containsValue(java.lang.Object)


Occurences of content

content occurences:
javax.swing.text.html.parser.content
javax.swing.text.html.parser.content


Occurences of CONTENT

CONTENT occurences:
javax.swing.text.html.CONTENT
javax.swing.text.html.CONTENT


Occurences of contentEquals

contentEquals occurences:
java.lang.String.contentEquals(java.lang.CharSequence)
java.lang.String.contentEquals(java.lang.StringBuffer)
javax.lang.model.element.Name.contentEquals(java.lang.CharSequence)


Occurences of ContentHandler

ContentHandler occurences:
java.net.ContentHandler
org.xml.sax.ContentHandler


Occurences of ContentModel (constructors)

ContentModel (constructors) occurences:
javax.swing.text.html.parser.ContentModel()
javax.swing.text.html.parser.ContentModel(int, java.lang.Object, javax.swing.text.html.parser.ContentModel)
javax.swing.text.html.parser.ContentModel(int, javax.swing.text.html.parser.ContentModel)
javax.swing.text.html.parser.ContentModel(javax.swing.text.html.parser.Element)


Occurences of Contents

Contents occurences:
Contents
Contents
Contents
Contents
Contents
Contents
Contents
Contents
Contents
Contents
Contents


Occurences of contentsChanged

contentsChanged occurences:
javax.swing.event.ListDataListener.contentsChanged(javax.swing.event.ListDataEvent)
javax.swing.JComboBox.contentsChanged(javax.swing.event.ListDataEvent)
javax.swing.JList.AccessibleJList.contentsChanged(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicComboBoxUI.ListDataHandler.contentsChanged(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicComboPopup.ListDataHandler.contentsChanged(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicListUI.ListDataHandler.contentsChanged(javax.swing.event.ListDataEvent)


Occurences of contentsLost

contentsLost occurences:
java.awt.Component.BltBufferStrategy.contentsLost()
java.awt.Component.FlipBufferStrategy.contentsLost()
java.awt.image.BufferStrategy.contentsLost()
java.awt.image.VolatileImage.contentsLost()


Occurences of contentsRestored

contentsRestored occurences:
java.awt.Component.BltBufferStrategy.contentsRestored()
java.awt.Component.FlipBufferStrategy.contentsRestored()
java.awt.image.BufferStrategy.contentsRestored()


Occurences of Context

Context occurences:
javax.naming.Context
org.omg.CORBA.Context


Occurences of context

context occurences:
java.awt.dnd.context
javax.script.context


Occurences of ContextNotEmptyException (constructors)

ContextNotEmptyException (constructors) occurences:
javax.naming.ContextNotEmptyException()
javax.naming.ContextNotEmptyException(java.lang.String)


Occurences of contexts

contexts occurences:
org.omg.CORBA.Request.contexts()
org.omg.PortableInterceptor.RequestInfoOperations.contexts()


Occurences of CONTINUE

CONTINUE occurences:
com.sun.source.tree.CONTINUE
javax.sound.midi.CONTINUE


Occurences of continueDrag

continueDrag occurences:
javax.swing.plaf.basic.BasicSplitPaneDivider.DragController.continueDrag(int, int)
javax.swing.plaf.basic.BasicSplitPaneDivider.DragController.continueDrag(java.awt.event.MouseEvent)


Occurences of CONTROL

CONTROL occurences:
java.awt.CONTROL
java.lang.CONTROL


Occurences of Control

Control occurences:
javax.naming.ldap.Control
javax.sound.sampled.Control


Occurences of controlChange

controlChange occurences:
javax.sound.midi.ControllerEventListener.controlChange(javax.sound.midi.ShortMessage)
javax.sound.midi.MidiChannel.controlChange(int, int)


Occurences of controller

controller occurences:
javax.imageio.controller
javax.imageio.metadata.controller


Occurences of convertImageMetadata

convertImageMetadata occurences:
javax.imageio.ImageTranscoder.convertImageMetadata(javax.imageio.metadata.IIOMetadata, javax.imageio.ImageTypeSpecifier, javax.imageio.ImageWriteParam)
javax.imageio.ImageWriter.convertImageMetadata(javax.imageio.metadata.IIOMetadata, javax.imageio.ImageTypeSpecifier, javax.imageio.ImageWriteParam)


Occurences of convertMouseEvent

convertMouseEvent occurences:
javax.swing.plaf.basic.BasicComboPopup.convertMouseEvent(java.awt.event.MouseEvent)
javax.swing.SwingUtilities.convertMouseEvent(java.awt.Component, java.awt.event.MouseEvent, java.awt.Component)


Occurences of convertPoint

convertPoint occurences:
javax.swing.SwingUtilities.convertPoint(java.awt.Component, int, int, java.awt.Component)
javax.swing.SwingUtilities.convertPoint(java.awt.Component, java.awt.Point, java.awt.Component)


Occurences of convertRowIndexToModel

convertRowIndexToModel occurences:
javax.swing.DefaultRowSorter.convertRowIndexToModel(int)
javax.swing.JTable.convertRowIndexToModel(int)
javax.swing.RowSorter.convertRowIndexToModel(int)


Occurences of convertRowIndexToView

convertRowIndexToView occurences:
javax.swing.DefaultRowSorter.convertRowIndexToView(int)
javax.swing.JTable.convertRowIndexToView(int)
javax.swing.RowSorter.convertRowIndexToView(int)


Occurences of convertStreamMetadata

convertStreamMetadata occurences:
javax.imageio.ImageTranscoder.convertStreamMetadata(javax.imageio.metadata.IIOMetadata, javax.imageio.ImageWriteParam)
javax.imageio.ImageWriter.convertStreamMetadata(javax.imageio.metadata.IIOMetadata, javax.imageio.ImageWriteParam)


Occurences of convertToVector

convertToVector occurences:
javax.swing.table.DefaultTableModel.convertToVector(java.lang.Object[])
javax.swing.table.DefaultTableModel.convertToVector(java.lang.Object[][])


Occurences of ConvolveOp (constructors)

ConvolveOp (constructors) occurences:
java.awt.image.ConvolveOp(java.awt.image.Kernel)
java.awt.image.ConvolveOp(java.awt.image.Kernel, int, java.awt.RenderingHints)


Occurences of Cookie Support

Cookie Support occurences:
Cookie Support
Cookie Support


Occurences of CookieHolder (constructors)

CookieHolder (constructors) occurences:
org.omg.PortableServer.ServantLocatorPackage.CookieHolder()
org.omg.PortableServer.ServantLocatorPackage.CookieHolder(java.lang.Object)


Occurences of CookieManager (constructors)

CookieManager (constructors) occurences:
java.net.CookieManager()
java.net.CookieManager(java.net.CookieStore, java.net.CookiePolicy)


Occurences of CopiesSupported (constructors)

CopiesSupported (constructors) occurences:
javax.print.attribute.standard.CopiesSupported(int)
javax.print.attribute.standard.CopiesSupported(int, int)


Occurences of copy

copy occurences:
java.util.Collections.copy(java.util.List, java.util.List)
javax.swing.JPasswordField.copy()
javax.swing.text.copy
javax.swing.text.JTextComponent.copy()
org.omg.CORBA.DynAny.copy()
org.omg.CORBA.PolicyOperations.copy()
org.omg.CORBA._PolicyStub.copy()
org.omg.DynamicAny.DynAnyOperations.copy()
org.omg.DynamicAny._DynAnyStub.copy()
org.omg.DynamicAny._DynArrayStub.copy()
org.omg.DynamicAny._DynEnumStub.copy()
org.omg.DynamicAny._DynFixedStub.copy()
org.omg.DynamicAny._DynSequenceStub.copy()
org.omg.DynamicAny._DynStructStub.copy()
org.omg.DynamicAny._DynUnionStub.copy()
org.omg.DynamicAny._DynValueStub.copy()


Occurences of copyArea

copyArea occurences:
java.awt.Graphics.copyArea(int, int, int, int, int, int)
javax.swing.DebugGraphics.copyArea(int, int, int, int, int, int)


Occurences of copyAttributes

copyAttributes occurences:
javax.swing.text.AbstractDocument.AbstractElement.copyAttributes()
javax.swing.text.AttributeSet.copyAttributes()
javax.swing.text.SimpleAttributeSet.copyAttributes()
javax.swing.text.StyleContext.NamedStyle.copyAttributes()
javax.swing.text.StyleContext.SmallAttributeSet.copyAttributes()


Occurences of copyData

copyData occurences:
java.awt.image.BufferedImage.copyData(java.awt.image.WritableRaster)
java.awt.image.RenderedImage.copyData(java.awt.image.WritableRaster)


Occurences of copyInto

copyInto occurences:
java.util.Vector.copyInto(java.lang.Object[])
javax.swing.DefaultListModel.copyInto(java.lang.Object[])


Occurences of copyObject

copyObject occurences:
javax.rmi.CORBA.Util.copyObject(java.lang.Object, org.omg.CORBA.ORB)
javax.rmi.CORBA.UtilDelegate.copyObject(java.lang.Object, org.omg.CORBA.ORB)


Occurences of copyObjects

copyObjects occurences:
javax.rmi.CORBA.Util.copyObjects(java.lang.Object[], org.omg.CORBA.ORB)
javax.rmi.CORBA.UtilDelegate.copyObjects(java.lang.Object[], org.omg.CORBA.ORB)


Occurences of copyOf

copyOf occurences:
java.util.Arrays.copyOf(boolean[], int)
java.util.Arrays.copyOf(byte[], int)
java.util.Arrays.copyOf(char[], int)
java.util.Arrays.copyOf(double[], int)
java.util.Arrays.copyOf(float[], int)
java.util.Arrays.copyOf(int[], int)
java.util.Arrays.copyOf(java.lang.Object[],int)
java.util.Arrays.copyOf(java.lang.Object[],int,java.lang.Class)
java.util.Arrays.copyOf(long[], int)
java.util.Arrays.copyOf(short[], int)
java.util.Arrays.copyOf(T[], int)
java.util.Arrays.copyOf(U[], int, java.lang.Class)
java.util.EnumSet.copyOf(java.util.Collection)
java.util.EnumSet.copyOf(java.util.EnumSet)


Occurences of copyOfRange

copyOfRange occurences:
java.util.Arrays.copyOfRange(boolean[], int, int)
java.util.Arrays.copyOfRange(byte[], int, int)
java.util.Arrays.copyOfRange(char[], int, int)
java.util.Arrays.copyOfRange(double[], int, int)
java.util.Arrays.copyOfRange(float[], int, int)
java.util.Arrays.copyOfRange(int[], int, int)
java.util.Arrays.copyOfRange(java.lang.Object[],int,int)
java.util.Arrays.copyOfRange(java.lang.Object[],int,int,java.lang.Class)
java.util.Arrays.copyOfRange(long[], int, int)
java.util.Arrays.copyOfRange(short[], int, int)
java.util.Arrays.copyOfRange(T[], int, int)
java.util.Arrays.copyOfRange(U[], int, int, java.lang.Class)


Occurences of CopyOnWriteArrayList (constructors)

CopyOnWriteArrayList (constructors) occurences:
java.util.concurrent.CopyOnWriteArrayList()
java.util.concurrent.CopyOnWriteArrayList(E[])
java.util.concurrent.CopyOnWriteArrayList(java.lang.Object[])
java.util.concurrent.CopyOnWriteArrayList(java.util.Collection)


Occurences of CopyOnWriteArraySet (constructors)

CopyOnWriteArraySet (constructors) occurences:
java.util.concurrent.CopyOnWriteArraySet()
java.util.concurrent.CopyOnWriteArraySet(java.util.Collection)


Occurences of Copyright Page for Sun Microsystems, Inc.

Copyright Page for Sun Microsystems, Inc. occurences:
Copyright Page for Sun Microsystems, Inc.
Copyright Page for Sun Microsystems, Inc.
Copyright Page for Sun Microsystems, Inc.
Copyright Page for Sun Microsystems, Inc.
Copyright Page for Sun Microsystems, Inc.


Occurences of copySign

copySign occurences:
java.lang.Math.copySign(double, double)
java.lang.Math.copySign(float, float)
java.lang.StrictMath.copySign(double, double)
java.lang.StrictMath.copySign(float, float)


Occurences of copyValueOf

copyValueOf occurences:
java.lang.String.copyValueOf(char[])
java.lang.String.copyValueOf(char[], int, int)


Occurences of CORBA

CORBA occurences:
javax.rmi.CORBA
org.omg.CORBA


Occurences of cos

cos occurences:
java.lang.Math.cos(double)
java.lang.StrictMath.cos(double)


Occurences of cosh

cosh occurences:
java.lang.Math.cosh(double)
java.lang.StrictMath.cosh(double)


Occurences of count

count occurences:
java.io.count
java.io.count
java.io.count
java.io.count
java.io.count
java.io.count
java.io.count
javax.swing.text.count
org.omg.CORBA.ContextList.count()
org.omg.CORBA.ExceptionList.count()
org.omg.CORBA.NVList.count()


Occurences of countItems

countItems occurences:
java.awt.Choice.countItems()
java.awt.List.countItems()
java.awt.Menu.countItems()


Occurences of crc

crc occurences:
java.util.zip.crc
java.util.zip.crc


Occurences of create

create occurences:
java.awt.Graphics.create()
java.awt.Graphics.create(int, int, int, int)
java.awt.image.renderable.ContextualRenderedImageFactory.create(java.awt.image.renderable.RenderContext, java.awt.image.renderable.ParameterBlock)
java.awt.image.renderable.RenderedImageFactory.create(java.awt.image.renderable.ParameterBlock, java.awt.RenderingHints)
java.beans.EventHandler.create(java.lang.Class, java.lang.Object, java.lang.String)
java.beans.EventHandler.create(java.lang.Class, java.lang.Object, java.lang.String, java.lang.String)
java.beans.EventHandler.create(java.lang.Class, java.lang.Object, java.lang.String, java.lang.String, java.lang.String)
java.net.DatagramSocketImpl.create()
java.net.SocketImpl.create(boolean)
java.net.URI.create(java.lang.String)
javax.swing.DebugGraphics.create()
javax.swing.DebugGraphics.create(int, int, int, int)
javax.swing.plaf.basic.BasicPasswordFieldUI.create(javax.swing.text.Element)
javax.swing.plaf.basic.BasicTextAreaUI.create(javax.swing.text.Element)
javax.swing.plaf.basic.BasicTextFieldUI.create(javax.swing.text.Element)
javax.swing.plaf.basic.BasicTextUI.create(javax.swing.text.Element)
javax.swing.plaf.basic.BasicTextUI.create(javax.swing.text.Element, int, int)
javax.swing.text.DefaultStyledDocument.create(javax.swing.text.DefaultStyledDocument.ElementSpec[])
javax.swing.text.html.HTMLDocument.create(javax.swing.text.DefaultStyledDocument.ElementSpec[])
javax.swing.text.html.HTMLEditorKit.HTMLFactory.create(javax.swing.text.Element)
javax.swing.text.ViewFactory.create(javax.swing.text.Element)
javax.xml.soap.SOAPElementFactory.create(java.lang.String)
javax.xml.soap.SOAPElementFactory.create(java.lang.String, java.lang.String, java.lang.String)
javax.xml.soap.SOAPElementFactory.create(javax.xml.soap.Name)
javax.xml.ws.Endpoint.create(java.lang.Object)
javax.xml.ws.Endpoint.create(java.lang.String, java.lang.Object)
javax.xml.ws.Service.create(java.net.URL, javax.xml.namespace.QName)
javax.xml.ws.Service.create(javax.xml.namespace.QName)


Occurences of createActionChangeListener

createActionChangeListener occurences:
javax.swing.JMenu.createActionChangeListener(javax.swing.JMenuItem)
javax.swing.JPopupMenu.createActionChangeListener(javax.swing.JMenuItem)
javax.swing.JToolBar.createActionChangeListener(javax.swing.JButton)


Occurences of createActionComponent

createActionComponent occurences:
javax.swing.JMenu.createActionComponent(javax.swing.Action)
javax.swing.JPopupMenu.createActionComponent(javax.swing.Action)
javax.swing.JToolBar.createActionComponent(javax.swing.Action)


Occurences of createActionPropertyChangeListener

createActionPropertyChangeListener occurences:
javax.swing.AbstractButton.createActionPropertyChangeListener(javax.swing.Action)
javax.swing.JComboBox.createActionPropertyChangeListener(javax.swing.Action)
javax.swing.JTextField.createActionPropertyChangeListener(javax.swing.Action)


Occurences of createArrowButton

createArrowButton occurences:
javax.swing.plaf.basic.BasicComboBoxUI.createArrowButton()
javax.swing.plaf.metal.MetalComboBoxUI.createArrowButton()


Occurences of createAttachmentPart

createAttachmentPart occurences:
javax.xml.soap.SOAPMessage.createAttachmentPart()
javax.xml.soap.SOAPMessage.createAttachmentPart(java.lang.Object, java.lang.String)
javax.xml.soap.SOAPMessage.createAttachmentPart(javax.activation.DataHandler)


Occurences of createAttribute

createAttribute occurences:
javax.xml.stream.XMLEventFactory.createAttribute(java.lang.String, java.lang.String)
javax.xml.stream.XMLEventFactory.createAttribute(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
javax.xml.stream.XMLEventFactory.createAttribute(javax.xml.namespace.QName, java.lang.String)
org.w3c.dom.Document.createAttribute(java.lang.String)


Occurences of createBandedRaster

createBandedRaster occurences:
java.awt.image.Raster.createBandedRaster(int, int, int, int, int[], int[], java.awt.Point)
java.awt.image.Raster.createBandedRaster(int, int, int, int, java.awt.Point)
java.awt.image.Raster.createBandedRaster(java.awt.image.DataBuffer, int, int, int, int[], int[], java.awt.Point)


Occurences of createBCSChild

createBCSChild occurences:
java.beans.beancontext.BeanContextServicesSupport.createBCSChild(java.lang.Object, java.lang.Object)
java.beans.beancontext.BeanContextSupport.createBCSChild(java.lang.Object, java.lang.Object)


Occurences of createBevelBorder

createBevelBorder occurences:
javax.swing.BorderFactory.createBevelBorder(int)
javax.swing.BorderFactory.createBevelBorder(int, java.awt.Color, java.awt.Color)
javax.swing.BorderFactory.createBevelBorder(int, java.awt.Color, java.awt.Color, java.awt.Color, java.awt.Color)


Occurences of createBinder

createBinder occurences:
javax.xml.bind.JAXBContext.createBinder()
javax.xml.bind.JAXBContext.createBinder(java.lang.Class)


Occurences of createBorderListener

createBorderListener occurences:
javax.swing.plaf.basic.BasicInternalFrameUI.createBorderListener(javax.swing.JInternalFrame)
javax.swing.plaf.metal.MetalInternalFrameUI.createBorderListener(javax.swing.JInternalFrame)


Occurences of createBranchElement

createBranchElement occurences:
javax.swing.text.AbstractDocument.createBranchElement(javax.swing.text.Element, javax.swing.text.AttributeSet)
javax.swing.text.html.HTMLDocument.createBranchElement(javax.swing.text.Element, javax.swing.text.AttributeSet)


Occurences of createBufferStrategy

createBufferStrategy occurences:
java.awt.Canvas.createBufferStrategy(int)
java.awt.Canvas.createBufferStrategy(int, java.awt.BufferCapabilities)
java.awt.Window.createBufferStrategy(int)
java.awt.Window.createBufferStrategy(int, java.awt.BufferCapabilities)


Occurences of createButtonListener

createButtonListener occurences:
javax.swing.plaf.basic.BasicButtonUI.createButtonListener(javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalButtonUI.createButtonListener(javax.swing.AbstractButton)


Occurences of createButtons

createButtons occurences:
javax.swing.plaf.basic.BasicInternalFrameTitlePane.createButtons()
javax.swing.plaf.metal.MetalInternalFrameTitlePane.createButtons()


Occurences of createCaret

createCaret occurences:
javax.swing.plaf.basic.BasicTextUI.createCaret()
javax.swing.text.DefaultEditorKit.createCaret()
javax.swing.text.EditorKit.createCaret()


Occurences of createChangeListener

createChangeListener occurences:
javax.swing.AbstractButton.createChangeListener()
javax.swing.JProgressBar.createChangeListener()
javax.swing.JSlider.createChangeListener()
javax.swing.JTabbedPane.createChangeListener()
javax.swing.plaf.basic.BasicMenuBarUI.createChangeListener()
javax.swing.plaf.basic.BasicMenuUI.createChangeListener(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.createChangeListener(javax.swing.JSlider)
javax.swing.plaf.basic.BasicTabbedPaneUI.createChangeListener()


Occurences of createClassFile

createClassFile occurences:
com.sun.mirror.apt.Filer.createClassFile(java.lang.String)
javax.annotation.processing.Filer.createClassFile(java.lang.CharSequence, javax.lang.model.element.Element...)


Occurences of createComment

createComment occurences:
javax.xml.stream.XMLEventFactory.createComment(java.lang.String)
org.w3c.dom.Document.createComment(java.lang.String)


Occurences of createCompatibleDestImage

createCompatibleDestImage occurences:
java.awt.image.AffineTransformOp.createCompatibleDestImage(java.awt.image.BufferedImage, java.awt.image.ColorModel)
java.awt.image.BufferedImageOp.createCompatibleDestImage(java.awt.image.BufferedImage, java.awt.image.ColorModel)
java.awt.image.ColorConvertOp.createCompatibleDestImage(java.awt.image.BufferedImage, java.awt.image.ColorModel)
java.awt.image.ConvolveOp.createCompatibleDestImage(java.awt.image.BufferedImage, java.awt.image.ColorModel)
java.awt.image.LookupOp.createCompatibleDestImage(java.awt.image.BufferedImage, java.awt.image.ColorModel)
java.awt.image.RescaleOp.createCompatibleDestImage(java.awt.image.BufferedImage, java.awt.image.ColorModel)


Occurences of createCompatibleDestRaster

createCompatibleDestRaster occurences:
java.awt.image.AffineTransformOp.createCompatibleDestRaster(java.awt.image.Raster)
java.awt.image.BandCombineOp.createCompatibleDestRaster(java.awt.image.Raster)
java.awt.image.ColorConvertOp.createCompatibleDestRaster(java.awt.image.Raster)
java.awt.image.ConvolveOp.createCompatibleDestRaster(java.awt.image.Raster)
java.awt.image.LookupOp.createCompatibleDestRaster(java.awt.image.Raster)
java.awt.image.RasterOp.createCompatibleDestRaster(java.awt.image.Raster)
java.awt.image.RescaleOp.createCompatibleDestRaster(java.awt.image.Raster)


Occurences of createCompatibleImage

createCompatibleImage occurences:
java.awt.GraphicsConfiguration.createCompatibleImage(int, int)
java.awt.GraphicsConfiguration.createCompatibleImage(int, int, int)


Occurences of createCompatibleSampleModel

createCompatibleSampleModel occurences:
java.awt.image.BandedSampleModel.createCompatibleSampleModel(int, int)
java.awt.image.ColorModel.createCompatibleSampleModel(int, int)
java.awt.image.ComponentColorModel.createCompatibleSampleModel(int, int)
java.awt.image.ComponentSampleModel.createCompatibleSampleModel(int, int)
java.awt.image.IndexColorModel.createCompatibleSampleModel(int, int)
java.awt.image.MultiPixelPackedSampleModel.createCompatibleSampleModel(int, int)
java.awt.image.PackedColorModel.createCompatibleSampleModel(int, int)
java.awt.image.PixelInterleavedSampleModel.createCompatibleSampleModel(int, int)
java.awt.image.SampleModel.createCompatibleSampleModel(int, int)
java.awt.image.SinglePixelPackedSampleModel.createCompatibleSampleModel(int, int)


Occurences of createCompatibleVolatileImage

createCompatibleVolatileImage occurences:
java.awt.GraphicsConfiguration.createCompatibleVolatileImage(int, int)
java.awt.GraphicsConfiguration.createCompatibleVolatileImage(int, int, int)
java.awt.GraphicsConfiguration.createCompatibleVolatileImage(int, int, java.awt.ImageCapabilities)
java.awt.GraphicsConfiguration.createCompatibleVolatileImage(int, int, java.awt.ImageCapabilities, int)


Occurences of createCompatibleWritableRaster

createCompatibleWritableRaster occurences:
java.awt.image.ColorModel.createCompatibleWritableRaster(int, int)
java.awt.image.ComponentColorModel.createCompatibleWritableRaster(int, int)
java.awt.image.DirectColorModel.createCompatibleWritableRaster(int, int)
java.awt.image.IndexColorModel.createCompatibleWritableRaster(int, int)
java.awt.image.Raster.createCompatibleWritableRaster()
java.awt.image.Raster.createCompatibleWritableRaster(int, int)
java.awt.image.Raster.createCompatibleWritableRaster(int, int, int, int)
java.awt.image.Raster.createCompatibleWritableRaster(java.awt.Rectangle)


Occurences of createComponent

createComponent occurences:
java.awt.Toolkit.createComponent(java.awt.Component)
javax.swing.text.ComponentView.createComponent()
javax.swing.text.html.FormView.createComponent()
javax.swing.text.html.ObjectView.createComponent()


Occurences of createComponentListener

createComponentListener occurences:
javax.swing.plaf.basic.BasicInternalFrameUI.createComponentListener()
javax.swing.plaf.basic.BasicSliderUI.createComponentListener(javax.swing.JSlider)
javax.swing.plaf.basic.BasicTreeUI.createComponentListener()


Occurences of createCompoundBorder

createCompoundBorder occurences:
javax.swing.BorderFactory.createCompoundBorder()
javax.swing.BorderFactory.createCompoundBorder(javax.swing.border.Border, javax.swing.border.Border)


Occurences of createContainerListener

createContainerListener occurences:
javax.swing.plaf.basic.BasicMenuBarUI.createContainerListener()
javax.swing.plaf.metal.MetalToolBarUI.createContainerListener()


Occurences of createContext

createContext occurences:
java.awt.AlphaComposite.createContext(java.awt.image.ColorModel, java.awt.image.ColorModel, java.awt.RenderingHints)
java.awt.Color.createContext(java.awt.image.ColorModel, java.awt.Rectangle, java.awt.geom.Rectangle2D, java.awt.geom.AffineTransform, java.awt.RenderingHints)
java.awt.Composite.createContext(java.awt.image.ColorModel, java.awt.image.ColorModel, java.awt.RenderingHints)
java.awt.GradientPaint.createContext(java.awt.image.ColorModel, java.awt.Rectangle, java.awt.geom.Rectangle2D, java.awt.geom.AffineTransform, java.awt.RenderingHints)
java.awt.LinearGradientPaint.createContext(java.awt.image.ColorModel, java.awt.Rectangle, java.awt.geom.Rectangle2D, java.awt.geom.AffineTransform, java.awt.RenderingHints)
java.awt.Paint.createContext(java.awt.image.ColorModel, java.awt.Rectangle, java.awt.geom.Rectangle2D, java.awt.geom.AffineTransform, java.awt.RenderingHints)
java.awt.RadialGradientPaint.createContext(java.awt.image.ColorModel, java.awt.Rectangle, java.awt.geom.Rectangle2D, java.awt.geom.AffineTransform, java.awt.RenderingHints)
java.awt.SystemColor.createContext(java.awt.image.ColorModel, java.awt.Rectangle, java.awt.geom.Rectangle2D, java.awt.geom.AffineTransform, java.awt.RenderingHints)
java.awt.TexturePaint.createContext(java.awt.image.ColorModel, java.awt.Rectangle, java.awt.geom.Rectangle2D, java.awt.geom.AffineTransform, java.awt.RenderingHints)
org.ietf.jgss.GSSManager.createContext(byte[])
org.ietf.jgss.GSSManager.createContext(org.ietf.jgss.GSSCredential)
org.ietf.jgss.GSSManager.createContext(org.ietf.jgss.GSSName, org.ietf.jgss.Oid, org.ietf.jgss.GSSCredential, int)


Occurences of createCredential

createCredential occurences:
org.ietf.jgss.GSSManager.createCredential(int)
org.ietf.jgss.GSSManager.createCredential(org.ietf.jgss.GSSName, int, org.ietf.jgss.Oid, int)
org.ietf.jgss.GSSManager.createCredential(org.ietf.jgss.GSSName, int, org.ietf.jgss.Oid[], int)


Occurences of createDataBuffer

createDataBuffer occurences:
java.awt.image.BandedSampleModel.createDataBuffer()
java.awt.image.ComponentSampleModel.createDataBuffer()
java.awt.image.MultiPixelPackedSampleModel.createDataBuffer()
java.awt.image.SampleModel.createDataBuffer()
java.awt.image.SinglePixelPackedSampleModel.createDataBuffer()


Occurences of createDataContentHandler

createDataContentHandler occurences:
javax.activation.CommandMap.createDataContentHandler(java.lang.String)
javax.activation.CommandMap.createDataContentHandler(java.lang.String, javax.activation.DataSource)
javax.activation.DataContentHandlerFactory.createDataContentHandler(java.lang.String)
javax.activation.MailcapCommandMap.createDataContentHandler(java.lang.String)


Occurences of createDecreaseButton

createDecreaseButton occurences:
javax.swing.plaf.basic.BasicScrollBarUI.createDecreaseButton(int)
javax.swing.plaf.metal.MetalScrollBarUI.createDecreaseButton(int)


Occurences of createDefaultColumnModel

createDefaultColumnModel occurences:
javax.swing.JTable.createDefaultColumnModel()
javax.swing.table.JTableHeader.createDefaultColumnModel()


Occurences of createDefaultDivider

createDefaultDivider occurences:
javax.swing.plaf.basic.BasicSplitPaneUI.createDefaultDivider()
javax.swing.plaf.metal.MetalSplitPaneUI.createDefaultDivider()


Occurences of createDefaultDocument

createDefaultDocument occurences:
javax.swing.text.DefaultEditorKit.createDefaultDocument()
javax.swing.text.EditorKit.createDefaultDocument()
javax.swing.text.html.HTMLEditorKit.createDefaultDocument()
javax.swing.text.StyledEditorKit.createDefaultDocument()


Occurences of createDefaultEditorKit

createDefaultEditorKit occurences:
javax.swing.JEditorPane.createDefaultEditorKit()
javax.swing.JTextPane.createDefaultEditorKit()


Occurences of createDefaultModel

createDefaultModel occurences:
javax.swing.JTextArea.createDefaultModel()
javax.swing.JTextField.createDefaultModel()


Occurences of createDefaultRendering

createDefaultRendering occurences:
java.awt.image.renderable.RenderableImage.createDefaultRendering()
java.awt.image.renderable.RenderableImageOp.createDefaultRendering()


Occurences of createDefaultRoot

createDefaultRoot occurences:
javax.swing.text.DefaultStyledDocument.createDefaultRoot()
javax.swing.text.html.HTMLDocument.createDefaultRoot()
javax.swing.text.PlainDocument.createDefaultRoot()


Occurences of createDialog

createDialog occurences:
java.awt.Toolkit.createDialog(java.awt.Dialog)
javax.swing.JColorChooser.createDialog(java.awt.Component, java.lang.String, boolean, javax.swing.JColorChooser, java.awt.event.ActionListener, java.awt.event.ActionListener)
javax.swing.JFileChooser.createDialog(java.awt.Component)
javax.swing.JOptionPane.createDialog(java.awt.Component, java.lang.String)
javax.swing.JOptionPane.createDialog(java.lang.String)


Occurences of createDispatch

createDispatch occurences:
javax.xml.ws.Service.createDispatch(javax.xml.namespace.QName, java.lang.Class, javax.xml.ws.Service.Mode)
javax.xml.ws.Service.createDispatch(javax.xml.namespace.QName, javax.xml.bind.JAXBContext, javax.xml.ws.Service.Mode)
javax.xml.ws.spi.ServiceDelegate.createDispatch(javax.xml.namespace.QName, java.lang.Class, javax.xml.ws.Service.Mode)
javax.xml.ws.spi.ServiceDelegate.createDispatch(javax.xml.namespace.QName, javax.xml.bind.JAXBContext, javax.xml.ws.Service.Mode)


Occurences of createDockingListener

createDockingListener occurences:
javax.swing.plaf.basic.BasicToolBarUI.createDockingListener()
javax.swing.plaf.metal.MetalToolBarUI.createDockingListener()


Occurences of createDragGestureRecognizer

createDragGestureRecognizer occurences:
java.awt.dnd.DragSource.createDragGestureRecognizer(java.lang.Class, java.awt.Component, int, java.awt.dnd.DragGestureListener)
java.awt.Toolkit.createDragGestureRecognizer(java.lang.Class, java.awt.dnd.DragSource, java.awt.Component, int, java.awt.dnd.DragGestureListener)


Occurences of createDTD

createDTD occurences:
javax.swing.text.html.parser.ParserDelegator.createDTD(javax.swing.text.html.parser.DTD, java.lang.String)
javax.xml.stream.XMLEventFactory.createDTD(java.lang.String)


Occurences of createEditor

createEditor occurences:
javax.swing.JSpinner.createEditor(javax.swing.SpinnerModel)
javax.swing.plaf.basic.BasicComboBoxUI.createEditor()
javax.swing.plaf.basic.BasicSpinnerUI.createEditor()
javax.swing.plaf.metal.MetalComboBoxUI.createEditor()


Occurences of createElement

createElement occurences:
javax.xml.soap.SOAPFactory.createElement(java.lang.String)
javax.xml.soap.SOAPFactory.createElement(java.lang.String, java.lang.String, java.lang.String)
javax.xml.soap.SOAPFactory.createElement(javax.xml.namespace.QName)
javax.xml.soap.SOAPFactory.createElement(javax.xml.soap.Name)
javax.xml.soap.SOAPFactory.createElement(org.w3c.dom.Element)
org.w3c.dom.Document.createElement(java.lang.String)


Occurences of createEmptyBorder

createEmptyBorder occurences:
javax.swing.BorderFactory.createEmptyBorder()
javax.swing.BorderFactory.createEmptyBorder(int, int, int, int)


Occurences of createEndElement

createEndElement occurences:
javax.xml.stream.XMLEventFactory.createEndElement(java.lang.String, java.lang.String, java.lang.String)
javax.xml.stream.XMLEventFactory.createEndElement(java.lang.String, java.lang.String, java.lang.String, java.util.Iterator)
javax.xml.stream.XMLEventFactory.createEndElement(javax.xml.namespace.QName, java.util.Iterator)


Occurences of createEntityReference

createEntityReference occurences:
javax.xml.stream.XMLEventFactory.createEntityReference(java.lang.String, javax.xml.stream.events.EntityDeclaration)
org.w3c.dom.Document.createEntityReference(java.lang.String)


Occurences of createEtchedBorder

createEtchedBorder occurences:
javax.swing.BorderFactory.createEtchedBorder()
javax.swing.BorderFactory.createEtchedBorder(int)
javax.swing.BorderFactory.createEtchedBorder(int, java.awt.Color, java.awt.Color)
javax.swing.BorderFactory.createEtchedBorder(java.awt.Color, java.awt.Color)


Occurences of createExtendedResponse

createExtendedResponse occurences:
javax.naming.ldap.ExtendedRequest.createExtendedResponse(java.lang.String, byte[], int, int)
javax.naming.ldap.StartTlsRequest.createExtendedResponse(java.lang.String, byte[], int, int)


Occurences of createFault

createFault occurences:
javax.xml.soap.SOAPFactory.createFault()
javax.xml.soap.SOAPFactory.createFault(java.lang.String, javax.xml.namespace.QName)


Occurences of createFileObject

createFileObject occurences:
javax.swing.filechooser.FileSystemView.createFileObject(java.io.File, java.lang.String)
javax.swing.filechooser.FileSystemView.createFileObject(java.lang.String)


Occurences of createFilteredReader

createFilteredReader occurences:
javax.xml.stream.XMLInputFactory.createFilteredReader(javax.xml.stream.XMLEventReader, javax.xml.stream.EventFilter)
javax.xml.stream.XMLInputFactory.createFilteredReader(javax.xml.stream.XMLStreamReader, javax.xml.stream.StreamFilter)


Occurences of createFocusListener

createFocusListener occurences:
javax.swing.plaf.basic.BasicComboBoxUI.createFocusListener()
javax.swing.plaf.basic.BasicListUI.createFocusListener()
javax.swing.plaf.basic.BasicSliderUI.createFocusListener(javax.swing.JSlider)
javax.swing.plaf.basic.BasicSplitPaneUI.createFocusListener()
javax.swing.plaf.basic.BasicTabbedPaneUI.createFocusListener()
javax.swing.plaf.basic.BasicTableUI.createFocusListener()
javax.swing.plaf.basic.BasicTreeUI.createFocusListener()


Occurences of createFont

createFont occurences:
java.awt.Font.createFont(int, java.io.File)
java.awt.Font.createFont(int, java.io.InputStream)


Occurences of createFragment

createFragment occurences:
javax.swing.text.GlyphView.createFragment(int, int)
javax.swing.text.View.createFragment(int, int)


Occurences of createGlyphVector

createGlyphVector occurences:
java.awt.Font.createGlyphVector(java.awt.font.FontRenderContext, char[])
java.awt.Font.createGlyphVector(java.awt.font.FontRenderContext, int[])
java.awt.Font.createGlyphVector(java.awt.font.FontRenderContext, java.lang.String)
java.awt.Font.createGlyphVector(java.awt.font.FontRenderContext, java.text.CharacterIterator)


Occurences of createGraphics

createGraphics occurences:
java.awt.GraphicsEnvironment.createGraphics(java.awt.image.BufferedImage)
java.awt.image.BufferedImage.createGraphics()
java.awt.image.VolatileImage.createGraphics()
java.awt.SplashScreen.createGraphics()


Occurences of createGrayscale

createGrayscale occurences:
javax.imageio.ImageTypeSpecifier.createGrayscale(int, int, boolean)
javax.imageio.ImageTypeSpecifier.createGrayscale(int, int, boolean, boolean)


Occurences of createImage

createImage occurences:
java.awt.Component.createImage(int, int)
java.awt.Component.createImage(java.awt.image.ImageProducer)
java.awt.Toolkit.createImage(byte[])
java.awt.Toolkit.createImage(byte[], int, int)
java.awt.Toolkit.createImage(java.awt.image.ImageProducer)
java.awt.Toolkit.createImage(java.lang.String)
java.awt.Toolkit.createImage(java.net.URL)


Occurences of createIncreaseButton

createIncreaseButton occurences:
javax.swing.plaf.basic.BasicScrollBarUI.createIncreaseButton(int)
javax.swing.plaf.metal.MetalScrollBarUI.createIncreaseButton(int)


Occurences of createInputAttributes

createInputAttributes occurences:
javax.swing.text.html.HTMLEditorKit.createInputAttributes(javax.swing.text.Element, javax.swing.text.MutableAttributeSet)
javax.swing.text.StyledEditorKit.createInputAttributes(javax.swing.text.Element, javax.swing.text.MutableAttributeSet)


Occurences of createInputStreamInstance

createInputStreamInstance occurences:
javax.imageio.spi.ImageInputStreamSpi.createInputStreamInstance(java.lang.Object)
javax.imageio.spi.ImageInputStreamSpi.createInputStreamInstance(java.lang.Object, boolean, java.io.File)


Occurences of createInterleavedRaster

createInterleavedRaster occurences:
java.awt.image.Raster.createInterleavedRaster(int, int, int, int, int, int[], java.awt.Point)
java.awt.image.Raster.createInterleavedRaster(int, int, int, int, java.awt.Point)
java.awt.image.Raster.createInterleavedRaster(java.awt.image.DataBuffer, int, int, int, int, int[], java.awt.Point)


Occurences of createIntersection

createIntersection occurences:
java.awt.geom.Rectangle2D.createIntersection(java.awt.geom.Rectangle2D)
java.awt.geom.Rectangle2D.Double.createIntersection(java.awt.geom.Rectangle2D)
java.awt.geom.Rectangle2D.Float.createIntersection(java.awt.geom.Rectangle2D)
java.awt.Rectangle.createIntersection(java.awt.geom.Rectangle2D)


Occurences of createItemListener

createItemListener occurences:
javax.swing.AbstractButton.createItemListener()
javax.swing.plaf.basic.BasicComboBoxUI.createItemListener()
javax.swing.plaf.basic.BasicComboPopup.createItemListener()


Occurences of createKeyListener

createKeyListener occurences:
javax.swing.plaf.basic.BasicComboBoxUI.createKeyListener()
javax.swing.plaf.basic.BasicComboPopup.createKeyListener()
javax.swing.plaf.basic.BasicTableUI.createKeyListener()
javax.swing.plaf.basic.BasicTreeUI.createKeyListener()


Occurences of createLargeAttributeSet

createLargeAttributeSet occurences:
javax.swing.text.html.StyleSheet.createLargeAttributeSet(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.createLargeAttributeSet(javax.swing.text.AttributeSet)


Occurences of createLayout

createLayout occurences:
javax.swing.plaf.basic.BasicInternalFrameTitlePane.createLayout()
javax.swing.plaf.basic.BasicSpinnerUI.createLayout()
javax.swing.plaf.metal.MetalInternalFrameTitlePane.createLayout()


Occurences of createLayoutManager

createLayoutManager occurences:
javax.swing.JViewport.createLayoutManager()
javax.swing.plaf.basic.BasicComboBoxUI.createLayoutManager()
javax.swing.plaf.basic.BasicInternalFrameUI.createLayoutManager()
javax.swing.plaf.basic.BasicOptionPaneUI.createLayoutManager()
javax.swing.plaf.basic.BasicTabbedPaneUI.createLayoutManager()
javax.swing.plaf.metal.MetalComboBoxUI.createLayoutManager()
javax.swing.plaf.metal.MetalTabbedPaneUI.createLayoutManager()


Occurences of createLeafElement

createLeafElement occurences:
javax.swing.text.AbstractDocument.createLeafElement(javax.swing.text.Element, javax.swing.text.AttributeSet, int, int)
javax.swing.text.html.HTMLDocument.createLeafElement(javax.swing.text.Element, javax.swing.text.AttributeSet, int, int)


Occurences of createLineBorder

createLineBorder occurences:
javax.swing.BorderFactory.createLineBorder(java.awt.Color)
javax.swing.BorderFactory.createLineBorder(java.awt.Color, int)


Occurences of createList

createList occurences:
java.awt.Toolkit.createList(java.awt.List)
javax.swing.plaf.basic.BasicComboPopup.createList()
javax.swing.plaf.metal.MetalFileChooserUI.createList(javax.swing.JFileChooser)


Occurences of createListDataListener

createListDataListener occurences:
javax.swing.plaf.basic.BasicComboBoxUI.createListDataListener()
javax.swing.plaf.basic.BasicComboPopup.createListDataListener()
javax.swing.plaf.basic.BasicListUI.createListDataListener()


Occurences of createListSelectionListener

createListSelectionListener occurences:
javax.swing.plaf.basic.BasicComboPopup.createListSelectionListener()
javax.swing.plaf.basic.BasicFileChooserUI.createListSelectionListener(javax.swing.JFileChooser)
javax.swing.plaf.basic.BasicListUI.createListSelectionListener()
javax.swing.plaf.metal.MetalFileChooserUI.createListSelectionListener(javax.swing.JFileChooser)


Occurences of createMatteBorder

createMatteBorder occurences:
javax.swing.BorderFactory.createMatteBorder(int, int, int, int, java.awt.Color)
javax.swing.BorderFactory.createMatteBorder(int, int, int, int, javax.swing.Icon)


Occurences of createMBean

createMBean occurences:
javax.management.MBeanServer.createMBean(java.lang.String, javax.management.ObjectName)
javax.management.MBeanServer.createMBean(java.lang.String, javax.management.ObjectName, java.lang.Object[], java.lang.String[])
javax.management.MBeanServer.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName)
javax.management.MBeanServer.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName, java.lang.Object[], java.lang.String[])
javax.management.MBeanServerConnection.createMBean(java.lang.String, javax.management.ObjectName)
javax.management.MBeanServerConnection.createMBean(java.lang.String, javax.management.ObjectName, java.lang.Object[], java.lang.String[])
javax.management.MBeanServerConnection.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName)
javax.management.MBeanServerConnection.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName, java.lang.Object[], java.lang.String[])
javax.management.remote.rmi.RMIConnection.createMBean(java.lang.String, javax.management.ObjectName, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnection.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnection.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnection.createMBean(java.lang.String, javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.createMBean(java.lang.String, javax.management.ObjectName, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.createMBean(java.lang.String, javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.createMBean(java.lang.String, javax.management.ObjectName, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.createMBean(java.lang.String, javax.management.ObjectName, javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.createMBean(java.lang.String, javax.management.ObjectName, javax.security.auth.Subject)


Occurences of createMBeanServer

createMBeanServer occurences:
javax.management.MBeanServerFactory.createMBeanServer()
javax.management.MBeanServerFactory.createMBeanServer(java.lang.String)


Occurences of createMenuDragMouseListener

createMenuDragMouseListener occurences:
javax.swing.plaf.basic.BasicMenuItemUI.createMenuDragMouseListener(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuUI.createMenuDragMouseListener(javax.swing.JComponent)


Occurences of createMenuKeyListener

createMenuKeyListener occurences:
javax.swing.plaf.basic.BasicMenuItemUI.createMenuKeyListener(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuUI.createMenuKeyListener(javax.swing.JComponent)


Occurences of createMessage

createMessage occurences:
javax.xml.soap.MessageFactory.createMessage()
javax.xml.soap.MessageFactory.createMessage(javax.xml.soap.MimeHeaders, java.io.InputStream)


Occurences of createMouseInputListener

createMouseInputListener occurences:
javax.swing.plaf.basic.BasicDesktopIconUI.createMouseInputListener()
javax.swing.plaf.basic.BasicListUI.createMouseInputListener()
javax.swing.plaf.basic.BasicMenuItemUI.createMouseInputListener(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuUI.createMouseInputListener(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableHeaderUI.createMouseInputListener()
javax.swing.plaf.basic.BasicTableUI.createMouseInputListener()


Occurences of createMouseListener

createMouseListener occurences:
javax.swing.plaf.basic.BasicComboPopup.createMouseListener()
javax.swing.plaf.basic.BasicTabbedPaneUI.createMouseListener()
javax.swing.plaf.basic.BasicTreeUI.createMouseListener()


Occurences of createName

createName occurences:
javax.xml.soap.SOAPEnvelope.createName(java.lang.String)
javax.xml.soap.SOAPEnvelope.createName(java.lang.String, java.lang.String, java.lang.String)
javax.xml.soap.SOAPFactory.createName(java.lang.String)
javax.xml.soap.SOAPFactory.createName(java.lang.String, java.lang.String, java.lang.String)
org.ietf.jgss.GSSManager.createName(byte[], org.ietf.jgss.Oid)
org.ietf.jgss.GSSManager.createName(byte[], org.ietf.jgss.Oid, org.ietf.jgss.Oid)
org.ietf.jgss.GSSManager.createName(java.lang.String, org.ietf.jgss.Oid)
org.ietf.jgss.GSSManager.createName(java.lang.String, org.ietf.jgss.Oid, org.ietf.jgss.Oid)


Occurences of createNamespace

createNamespace occurences:
javax.xml.stream.XMLEventFactory.createNamespace(java.lang.String)
javax.xml.stream.XMLEventFactory.createNamespace(java.lang.String, java.lang.String)


Occurences of createNonRolloverBorder

createNonRolloverBorder occurences:
javax.swing.plaf.basic.BasicToolBarUI.createNonRolloverBorder()
javax.swing.plaf.metal.MetalToolBarUI.createNonRolloverBorder()


Occurences of createNorthPane

createNorthPane occurences:
javax.swing.plaf.basic.BasicInternalFrameUI.createNorthPane(javax.swing.JInternalFrame)
javax.swing.plaf.metal.MetalInternalFrameUI.createNorthPane(javax.swing.JInternalFrame)


Occurences of createOutputStreamInstance

createOutputStreamInstance occurences:
javax.imageio.spi.ImageOutputStreamSpi.createOutputStreamInstance(java.lang.Object)
javax.imageio.spi.ImageOutputStreamSpi.createOutputStreamInstance(java.lang.Object, boolean, java.io.File)


Occurences of createPackedRaster

createPackedRaster occurences:
java.awt.image.Raster.createPackedRaster(int, int, int, int, int, java.awt.Point)
java.awt.image.Raster.createPackedRaster(int, int, int, int[], java.awt.Point)
java.awt.image.Raster.createPackedRaster(java.awt.image.DataBuffer, int, int, int, int[], java.awt.Point)
java.awt.image.Raster.createPackedRaster(java.awt.image.DataBuffer, int, int, int, java.awt.Point)


Occurences of createParallelGroup

createParallelGroup occurences:
javax.swing.GroupLayout.createParallelGroup()
javax.swing.GroupLayout.createParallelGroup(javax.swing.GroupLayout.Alignment)
javax.swing.GroupLayout.createParallelGroup(javax.swing.GroupLayout.Alignment, boolean)


Occurences of createPopup

createPopup occurences:
javax.swing.plaf.basic.BasicComboBoxUI.createPopup()
javax.swing.plaf.metal.MetalComboBoxUI.createPopup()


Occurences of createPosition

createPosition occurences:
javax.swing.text.AbstractDocument.createPosition(int)
javax.swing.text.AbstractDocument.Content.createPosition(int)
javax.swing.text.Document.createPosition(int)
javax.swing.text.GapContent.createPosition(int)
javax.swing.text.StringContent.createPosition(int)


Occurences of createProcessingInstruction

createProcessingInstruction occurences:
javax.xml.stream.XMLEventFactory.createProcessingInstruction(java.lang.String, java.lang.String)
org.w3c.dom.Document.createProcessingInstruction(java.lang.String, java.lang.String)


Occurences of createPropertyChangeListener

createPropertyChangeListener occurences:
javax.swing.plaf.basic.BasicColorChooserUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicComboBoxUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicComboPopup.createPropertyChangeListener()
javax.swing.plaf.basic.BasicDesktopPaneUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicFileChooserUI.createPropertyChangeListener(javax.swing.JFileChooser)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.createPropertyChangeListener()
javax.swing.plaf.basic.BasicInternalFrameUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicListUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicMenuItemUI.createPropertyChangeListener(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuUI.createPropertyChangeListener(javax.swing.JComponent)
javax.swing.plaf.basic.BasicOptionPaneUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicScrollBarUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicScrollPaneUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicSliderUI.createPropertyChangeListener(javax.swing.JSlider)
javax.swing.plaf.basic.BasicSpinnerUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicSplitPaneUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicTabbedPaneUI.createPropertyChangeListener()
javax.swing.plaf.basic.BasicTreeUI.createPropertyChangeListener()
javax.swing.plaf.metal.MetalComboBoxUI.createPropertyChangeListener()
javax.swing.plaf.metal.MetalFileChooserUI.createPropertyChangeListener(javax.swing.JFileChooser)
javax.swing.plaf.metal.MetalInternalFrameTitlePane.createPropertyChangeListener()
javax.swing.plaf.metal.MetalScrollBarUI.createPropertyChangeListener()
javax.swing.plaf.metal.MetalSliderUI.createPropertyChangeListener(javax.swing.JSlider)


Occurences of createReaderInstance

createReaderInstance occurences:
javax.imageio.spi.ImageReaderSpi.createReaderInstance()
javax.imageio.spi.ImageReaderSpi.createReaderInstance(java.lang.Object)


Occurences of createRegistry

createRegistry occurences:
java.rmi.registry.LocateRegistry.createRegistry(int)
java.rmi.registry.LocateRegistry.createRegistry(int, java.rmi.server.RMIClientSocketFactory, java.rmi.server.RMIServerSocketFactory)


Occurences of createRelation

createRelation occurences:
javax.management.relation.RelationService.createRelation(java.lang.String, java.lang.String, javax.management.relation.RoleList)
javax.management.relation.RelationServiceMBean.createRelation(java.lang.String, java.lang.String, javax.management.relation.RoleList)


Occurences of createRelationType

createRelationType occurences:
javax.management.relation.RelationService.createRelationType(java.lang.String, javax.management.relation.RoleInfo[])
javax.management.relation.RelationServiceMBean.createRelationType(java.lang.String, javax.management.relation.RoleInfo[])


Occurences of createRendering

createRendering occurences:
java.awt.image.renderable.RenderableImage.createRendering(java.awt.image.renderable.RenderContext)
java.awt.image.renderable.RenderableImageOp.createRendering(java.awt.image.renderable.RenderContext)


Occurences of createRolloverBorder

createRolloverBorder occurences:
javax.swing.plaf.basic.BasicToolBarUI.createRolloverBorder()
javax.swing.plaf.metal.MetalToolBarUI.createRolloverBorder()


Occurences of createRootPane

createRootPane occurences:
javax.swing.JApplet.createRootPane()
javax.swing.JDialog.createRootPane()
javax.swing.JFrame.createRootPane()
javax.swing.JInternalFrame.createRootPane()
javax.swing.JWindow.createRootPane()


Occurences of createRow

createRow occurences:
javax.swing.text.FlowView.createRow()
javax.swing.text.ParagraphView.createRow()


Occurences of createSaslClient

createSaslClient occurences:
javax.security.sasl.Sasl.createSaslClient(java.lang.String[], java.lang.String, java.lang.String, java.lang.String, java.util.Map, javax.security.auth.callback.CallbackHandler)
javax.security.sasl.SaslClientFactory.createSaslClient(java.lang.String[], java.lang.String, java.lang.String, java.lang.String, java.util.Map, javax.security.auth.callback.CallbackHandler)


Occurences of createSaslServer

createSaslServer occurences:
javax.security.sasl.Sasl.createSaslServer(java.lang.String, java.lang.String, java.lang.String, java.util.Map, javax.security.auth.callback.CallbackHandler)
javax.security.sasl.SaslServerFactory.createSaslServer(java.lang.String, java.lang.String, java.lang.String, java.util.Map, javax.security.auth.callback.CallbackHandler)


Occurences of createScaledRendering

createScaledRendering occurences:
java.awt.image.renderable.RenderableImage.createScaledRendering(int, int, java.awt.RenderingHints)
java.awt.image.renderable.RenderableImageOp.createScaledRendering(int, int, java.awt.RenderingHints)


Occurences of createScrollListener

createScrollListener occurences:
javax.swing.plaf.basic.BasicScrollBarUI.createScrollListener()
javax.swing.plaf.basic.BasicSliderUI.createScrollListener(javax.swing.JSlider)


Occurences of createSelectionModel

createSelectionModel occurences:
javax.swing.JList.createSelectionModel()
javax.swing.table.DefaultTableColumnModel.createSelectionModel()


Occurences of createServerSocket

createServerSocket occurences:
java.rmi.server.RMIServerSocketFactory.createServerSocket(int)
java.rmi.server.RMISocketFactory.createServerSocket(int)
javax.net.ServerSocketFactory.createServerSocket()
javax.net.ServerSocketFactory.createServerSocket(int)
javax.net.ServerSocketFactory.createServerSocket(int, int)
javax.net.ServerSocketFactory.createServerSocket(int, int, java.net.InetAddress)
javax.rmi.ssl.SslRMIServerSocketFactory.createServerSocket(int)


Occurences of createSmallAttributeSet

createSmallAttributeSet occurences:
javax.swing.text.html.StyleSheet.createSmallAttributeSet(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.createSmallAttributeSet(javax.swing.text.AttributeSet)


Occurences of createSocket

createSocket occurences:
java.rmi.server.RMIClientSocketFactory.createSocket(java.lang.String, int)
java.rmi.server.RMISocketFactory.createSocket(java.lang.String, int)
javax.net.SocketFactory.createSocket()
javax.net.SocketFactory.createSocket(java.lang.String, int)
javax.net.SocketFactory.createSocket(java.lang.String, int, java.net.InetAddress, int)
javax.net.SocketFactory.createSocket(java.net.InetAddress, int)
javax.net.SocketFactory.createSocket(java.net.InetAddress, int, java.net.InetAddress, int)
javax.net.ssl.SSLSocketFactory.createSocket(java.net.Socket, java.lang.String, int, boolean)
javax.rmi.ssl.SslRMIClientSocketFactory.createSocket(java.lang.String, int)


Occurences of createSourceFile

createSourceFile occurences:
com.sun.mirror.apt.Filer.createSourceFile(java.lang.String)
javax.annotation.processing.Filer.createSourceFile(java.lang.CharSequence, javax.lang.model.element.Element...)


Occurences of createSSLEngine

createSSLEngine occurences:
javax.net.ssl.SSLContext.createSSLEngine()
javax.net.ssl.SSLContext.createSSLEngine(java.lang.String, int)


Occurences of createStandardLabels

createStandardLabels occurences:
javax.swing.JSlider.createStandardLabels(int)
javax.swing.JSlider.createStandardLabels(int, int)


Occurences of createStartDocument

createStartDocument occurences:
javax.xml.stream.XMLEventFactory.createStartDocument()
javax.xml.stream.XMLEventFactory.createStartDocument(java.lang.String)
javax.xml.stream.XMLEventFactory.createStartDocument(java.lang.String, java.lang.String)
javax.xml.stream.XMLEventFactory.createStartDocument(java.lang.String, java.lang.String, boolean)


Occurences of createStartElement

createStartElement occurences:
javax.xml.stream.XMLEventFactory.createStartElement(java.lang.String, java.lang.String, java.lang.String)
javax.xml.stream.XMLEventFactory.createStartElement(java.lang.String, java.lang.String, java.lang.String, java.util.Iterator, java.util.Iterator)
javax.xml.stream.XMLEventFactory.createStartElement(java.lang.String, java.lang.String, java.lang.String, java.util.Iterator, java.util.Iterator, javax.xml.namespace.NamespaceContext)
javax.xml.stream.XMLEventFactory.createStartElement(javax.xml.namespace.QName, java.util.Iterator, java.util.Iterator)


Occurences of createStatement

createStatement occurences:
java.sql.Connection.createStatement()
java.sql.Connection.createStatement(int, int)
java.sql.Connection.createStatement(int, int, int)


Occurences of createStrokedShape

createStrokedShape occurences:
java.awt.BasicStroke.createStrokedShape(java.awt.Shape)
java.awt.Stroke.createStrokedShape(java.awt.Shape)


Occurences of createSubcontext

createSubcontext occurences:
javax.naming.Context.createSubcontext(java.lang.String)
javax.naming.Context.createSubcontext(javax.naming.Name)
javax.naming.directory.DirContext.createSubcontext(java.lang.String, javax.naming.directory.Attributes)
javax.naming.directory.DirContext.createSubcontext(javax.naming.Name, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.createSubcontext(java.lang.String, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.createSubcontext(javax.naming.Name, javax.naming.directory.Attributes)
javax.naming.InitialContext.createSubcontext(java.lang.String)
javax.naming.InitialContext.createSubcontext(javax.naming.Name)


Occurences of createSubsetSampleModel

createSubsetSampleModel occurences:
java.awt.image.BandedSampleModel.createSubsetSampleModel(int[])
java.awt.image.ComponentSampleModel.createSubsetSampleModel(int[])
java.awt.image.MultiPixelPackedSampleModel.createSubsetSampleModel(int[])
java.awt.image.PixelInterleavedSampleModel.createSubsetSampleModel(int[])
java.awt.image.SampleModel.createSubsetSampleModel(int[])
java.awt.image.SinglePixelPackedSampleModel.createSubsetSampleModel(int[])


Occurences of createTempFile

createTempFile occurences:
java.io.File.createTempFile(java.lang.String, java.lang.String)
java.io.File.createTempFile(java.lang.String, java.lang.String, java.io.File)


Occurences of createTitledBorder

createTitledBorder occurences:
javax.swing.BorderFactory.createTitledBorder(java.lang.String)
javax.swing.BorderFactory.createTitledBorder(javax.swing.border.Border)
javax.swing.BorderFactory.createTitledBorder(javax.swing.border.Border, java.lang.String)
javax.swing.BorderFactory.createTitledBorder(javax.swing.border.Border, java.lang.String, int, int)
javax.swing.BorderFactory.createTitledBorder(javax.swing.border.Border, java.lang.String, int, int, java.awt.Font)
javax.swing.BorderFactory.createTitledBorder(javax.swing.border.Border, java.lang.String, int, int, java.awt.Font, java.awt.Color)


Occurences of createTrackListener

createTrackListener occurences:
javax.swing.plaf.basic.BasicScrollBarUI.createTrackListener()
javax.swing.plaf.basic.BasicSliderUI.createTrackListener(javax.swing.JSlider)


Occurences of createTransformedShape

createTransformedShape occurences:
java.awt.geom.AffineTransform.createTransformedShape(java.awt.Shape)
java.awt.geom.Path2D.createTransformedShape(java.awt.geom.AffineTransform)


Occurences of createTreeModelListener

createTreeModelListener occurences:
javax.swing.JTree.createTreeModelListener()
javax.swing.plaf.basic.BasicTreeUI.createTreeModelListener()


Occurences of createUI

createUI occurences:
javax.swing.plaf.basic.BasicButtonUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicCheckBoxMenuItemUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicCheckBoxUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicColorChooserUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicComboBoxUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopIconUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicEditorPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicFormattedTextFieldUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicInternalFrameUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicLabelUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicListUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuItemUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicOptionPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPanelUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPasswordFieldUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPopupMenuSeparatorUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPopupMenuUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicProgressBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicRadioButtonMenuItemUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicRadioButtonUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicRootPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSeparatorUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSpinnerUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSplitPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTabbedPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableHeaderUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextAreaUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextFieldUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToggleButtonUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolBarSeparatorUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolTipUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.createUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicViewportUI.createUI(javax.swing.JComponent)
javax.swing.plaf.ComponentUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalButtonUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalCheckBoxUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalComboBoxUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalDesktopIconUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalFileChooserUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalInternalFrameUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalLabelUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalMenuBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalPopupMenuSeparatorUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalProgressBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalRadioButtonUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalRootPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalSeparatorUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalSliderUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalSplitPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalTabbedPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalTextFieldUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalToggleButtonUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolTipUI.createUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalTreeUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiButtonUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.createUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.createUI(javax.swing.JComponent)
javax.swing.plaf.synth.SynthLookAndFeel.createUI(javax.swing.JComponent)


Occurences of createUnion

createUnion occurences:
java.awt.geom.Rectangle2D.createUnion(java.awt.geom.Rectangle2D)
java.awt.geom.Rectangle2D.Double.createUnion(java.awt.geom.Rectangle2D)
java.awt.geom.Rectangle2D.Float.createUnion(java.awt.geom.Rectangle2D)
java.awt.Rectangle.createUnion(java.awt.geom.Rectangle2D)


Occurences of createUnmarshaller

createUnmarshaller occurences:
javax.xml.bind.annotation.DomHandler.createUnmarshaller(javax.xml.bind.ValidationEventHandler)
javax.xml.bind.annotation.W3CDomHandler.createUnmarshaller(javax.xml.bind.ValidationEventHandler)
javax.xml.bind.JAXBContext.createUnmarshaller()


Occurences of createValue

createValue occurences:
javax.swing.UIDefaults.ActiveValue.createValue(javax.swing.UIDefaults)
javax.swing.UIDefaults.LazyInputMap.createValue(javax.swing.UIDefaults)
javax.swing.UIDefaults.LazyValue.createValue(javax.swing.UIDefaults)
javax.swing.UIDefaults.ProxyLazyValue.createValue(javax.swing.UIDefaults)


Occurences of createValueHandler

createValueHandler occurences:
javax.rmi.CORBA.Util.createValueHandler()
javax.rmi.CORBA.UtilDelegate.createValueHandler()


Occurences of createVirtualMachine

createVirtualMachine occurences:
com.sun.jdi.VirtualMachineManager.createVirtualMachine(com.sun.jdi.connect.spi.Connection)
com.sun.jdi.VirtualMachineManager.createVirtualMachine(com.sun.jdi.connect.spi.Connection, java.lang.Process)


Occurences of createVolatileImage

createVolatileImage occurences:
java.awt.Component.createVolatileImage(int, int)
java.awt.Component.createVolatileImage(int, int, java.awt.ImageCapabilities)


Occurences of createWritableRaster

createWritableRaster occurences:
java.awt.image.Raster.createWritableRaster(java.awt.image.SampleModel, java.awt.image.DataBuffer, java.awt.Point)
java.awt.image.Raster.createWritableRaster(java.awt.image.SampleModel, java.awt.Point)


Occurences of createWriterInstance

createWriterInstance occurences:
javax.imageio.spi.ImageWriterSpi.createWriterInstance()
javax.imageio.spi.ImageWriterSpi.createWriterInstance(java.lang.Object)


Occurences of createXMLEventReader

createXMLEventReader occurences:
javax.xml.stream.XMLInputFactory.createXMLEventReader(java.io.InputStream)
javax.xml.stream.XMLInputFactory.createXMLEventReader(java.io.InputStream, java.lang.String)
javax.xml.stream.XMLInputFactory.createXMLEventReader(java.io.Reader)
javax.xml.stream.XMLInputFactory.createXMLEventReader(java.lang.String, java.io.InputStream)
javax.xml.stream.XMLInputFactory.createXMLEventReader(java.lang.String, java.io.Reader)
javax.xml.stream.XMLInputFactory.createXMLEventReader(javax.xml.stream.XMLStreamReader)
javax.xml.stream.XMLInputFactory.createXMLEventReader(javax.xml.transform.Source)


Occurences of createXMLEventWriter

createXMLEventWriter occurences:
javax.xml.stream.XMLOutputFactory.createXMLEventWriter(java.io.OutputStream)
javax.xml.stream.XMLOutputFactory.createXMLEventWriter(java.io.OutputStream, java.lang.String)
javax.xml.stream.XMLOutputFactory.createXMLEventWriter(java.io.Writer)
javax.xml.stream.XMLOutputFactory.createXMLEventWriter(javax.xml.transform.Result)


Occurences of createXMLReader

createXMLReader occurences:
org.xml.sax.helpers.XMLReaderFactory.createXMLReader()
org.xml.sax.helpers.XMLReaderFactory.createXMLReader(java.lang.String)


Occurences of createXMLStreamReader

createXMLStreamReader occurences:
javax.xml.stream.XMLInputFactory.createXMLStreamReader(java.io.InputStream)
javax.xml.stream.XMLInputFactory.createXMLStreamReader(java.io.InputStream, java.lang.String)
javax.xml.stream.XMLInputFactory.createXMLStreamReader(java.io.Reader)
javax.xml.stream.XMLInputFactory.createXMLStreamReader(java.lang.String, java.io.InputStream)
javax.xml.stream.XMLInputFactory.createXMLStreamReader(java.lang.String, java.io.Reader)
javax.xml.stream.XMLInputFactory.createXMLStreamReader(javax.xml.transform.Source)


Occurences of createXMLStreamWriter

createXMLStreamWriter occurences:
javax.xml.stream.XMLOutputFactory.createXMLStreamWriter(java.io.OutputStream)
javax.xml.stream.XMLOutputFactory.createXMLStreamWriter(java.io.OutputStream, java.lang.String)
javax.xml.stream.XMLOutputFactory.createXMLStreamWriter(java.io.Writer)
javax.xml.stream.XMLOutputFactory.createXMLStreamWriter(javax.xml.transform.Result)


Occurences of createZipEntry

createZipEntry occurences:
java.util.jar.JarInputStream.createZipEntry(java.lang.String)
java.util.zip.ZipInputStream.createZipEntry(java.lang.String)


Occurences of create_dyn_any

create_dyn_any occurences:
org.omg.CORBA.ORB.create_dyn_any(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnyFactoryOperations.create_dyn_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynAnyFactoryStub.create_dyn_any(org.omg.CORBA.Any)


Occurences of create_dyn_any_from_type_code

create_dyn_any_from_type_code occurences:
org.omg.DynamicAny.DynAnyFactoryOperations.create_dyn_any_from_type_code(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynAnyFactoryStub.create_dyn_any_from_type_code(org.omg.CORBA.TypeCode)


Occurences of create_input_stream

create_input_stream occurences:
org.omg.CORBA.Any.create_input_stream()
org.omg.CORBA.portable.OutputStream.create_input_stream()


Occurences of create_output_stream

create_output_stream occurences:
org.omg.CORBA.Any.create_output_stream()
org.omg.CORBA.ORB.create_output_stream()


Occurences of create_policy

create_policy occurences:
org.omg.CORBA.ORB.create_policy(int, org.omg.CORBA.Any)
org.omg.PortableInterceptor.PolicyFactoryOperations.create_policy(int, org.omg.CORBA.Any)


Occurences of create_request

create_request occurences:
org.omg.CORBA.portable.Delegate.create_request(org.omg.CORBA.Object, org.omg.CORBA.Context, java.lang.String, org.omg.CORBA.NVList, org.omg.CORBA.NamedValue)
org.omg.CORBA.portable.Delegate.create_request(org.omg.CORBA.Object, org.omg.CORBA.Context, java.lang.String, org.omg.CORBA.NVList, org.omg.CORBA.NamedValue, org.omg.CORBA.ExceptionList, org.omg.CORBA.ContextList)


Occurences of CredentialException (constructors)

CredentialException (constructors) occurences:
javax.security.auth.login.CredentialException()
javax.security.auth.login.CredentialException(java.lang.String)


Occurences of CredentialExpiredException (constructors)

CredentialExpiredException (constructors) occurences:
javax.security.auth.login.CredentialExpiredException()
javax.security.auth.login.CredentialExpiredException(java.lang.String)


Occurences of CredentialNotFoundException (constructors)

CredentialNotFoundException (constructors) occurences:
javax.security.auth.login.CredentialNotFoundException()
javax.security.auth.login.CredentialNotFoundException(java.lang.String)


Occurences of CREDENTIALS

CREDENTIALS occurences:
javax.management.remote.CREDENTIALS
javax.security.sasl.CREDENTIALS


Occurences of CRLException (constructors)

CRLException (constructors) occurences:
java.security.cert.CRLException()
java.security.cert.CRLException(java.lang.String)
java.security.cert.CRLException(java.lang.String, java.lang.Throwable)
java.security.cert.CRLException(java.lang.Throwable)


Occurences of CROSSHAIR_CURSOR

CROSSHAIR_CURSOR occurences:
java.awt.CROSSHAIR_CURSOR
java.awt.CROSSHAIR_CURSOR


Occurences of crypto

crypto occurences:
javax.crypto
javax.xml.crypto


Occurences of ctrlx

ctrlx occurences:
java.awt.geom.ctrlx
java.awt.geom.ctrlx


Occurences of ctrlx1

ctrlx1 occurences:
java.awt.geom.ctrlx1
java.awt.geom.ctrlx1


Occurences of ctrlx2

ctrlx2 occurences:
java.awt.geom.ctrlx2
java.awt.geom.ctrlx2


Occurences of ctrly

ctrly occurences:
java.awt.geom.ctrly
java.awt.geom.ctrly


Occurences of ctrly1

ctrly1 occurences:
java.awt.geom.ctrly1
java.awt.geom.ctrly1


Occurences of ctrly2

ctrly2 occurences:
java.awt.geom.ctrly2
java.awt.geom.ctrly2


Occurences of CTRL_MASK

CTRL_MASK occurences:
java.awt.CTRL_MASK
java.awt.event.CTRL_MASK
java.awt.event.CTRL_MASK


Occurences of ctx

ctx occurences:
org.omg.CORBA.Request.ctx()
org.omg.CORBA.Request.ctx(org.omg.CORBA.Context)
org.omg.CORBA.ServerRequest.ctx()


Occurences of CubicCurve2D.Double (constructors)

CubicCurve2D.Double (constructors) occurences:
java.awt.geom.CubicCurve2D.Double()
java.awt.geom.CubicCurve2D.Double(double, double, double, double, double, double, double, double)


Occurences of CubicCurve2D.Float (constructors)

CubicCurve2D.Float (constructors) occurences:
java.awt.geom.CubicCurve2D.Float()
java.awt.geom.CubicCurve2D.Float(float, float, float, float, float, float, float, float)


Occurences of Current

Current occurences:
org.omg.CORBA.Current
org.omg.PortableInterceptor.Current
org.omg.PortableServer.Current


Occurences of current

current occurences:
java.text.BreakIterator.current()
java.text.CharacterIterator.current()
java.text.StringCharacterIterator.current()
javax.swing.text.ElementIterator.current()
javax.swing.text.Segment.current()


Occurences of CurrentHelper

CurrentHelper occurences:
org.omg.CORBA.CurrentHelper
org.omg.PortableInterceptor.CurrentHelper
org.omg.PortableServer.CurrentHelper


Occurences of CurrentHelper (constructors)

CurrentHelper (constructors) occurences:
org.omg.CORBA.CurrentHelper()
org.omg.PortableInterceptor.CurrentHelper()
org.omg.PortableServer.CurrentHelper()


Occurences of CurrentHolder (constructors)

CurrentHolder (constructors) occurences:
org.omg.CORBA.CurrentHolder()
org.omg.CORBA.CurrentHolder(org.omg.CORBA.Current)


Occurences of currentManager

currentManager occurences:
javax.swing.RepaintManager.currentManager(java.awt.Component)
javax.swing.RepaintManager.currentManager(javax.swing.JComponent)


Occurences of currentMouseX

currentMouseX occurences:
javax.swing.plaf.basic.currentMouseX
javax.swing.plaf.basic.currentMouseX


Occurences of currentMouseY

currentMouseY occurences:
javax.swing.plaf.basic.currentMouseY
javax.swing.plaf.basic.currentMouseY


Occurences of CurrentOperations

CurrentOperations occurences:
org.omg.CORBA.CurrentOperations
org.omg.PortableInterceptor.CurrentOperations
org.omg.PortableServer.CurrentOperations


Occurences of currentSegment

currentSegment occurences:
java.awt.geom.FlatteningPathIterator.currentSegment(double[])
java.awt.geom.FlatteningPathIterator.currentSegment(float[])
java.awt.geom.PathIterator.currentSegment(double[])
java.awt.geom.PathIterator.currentSegment(float[])


Occurences of current_component

current_component occurences:
org.omg.CORBA.DynAny.current_component()
org.omg.DynamicAny.DynAnyOperations.current_component()
org.omg.DynamicAny._DynAnyStub.current_component()
org.omg.DynamicAny._DynArrayStub.current_component()
org.omg.DynamicAny._DynEnumStub.current_component()
org.omg.DynamicAny._DynFixedStub.current_component()
org.omg.DynamicAny._DynSequenceStub.current_component()
org.omg.DynamicAny._DynStructStub.current_component()
org.omg.DynamicAny._DynUnionStub.current_component()
org.omg.DynamicAny._DynValueStub.current_component()


Occurences of current_factory

current_factory occurences:
org.omg.PortableInterceptor.IORInfoOperations.current_factory()
org.omg.PortableInterceptor.IORInfoOperations.current_factory(org.omg.PortableInterceptor.ObjectReferenceFactory)


Occurences of current_member_kind

current_member_kind occurences:
org.omg.CORBA.DynStruct.current_member_kind()
org.omg.CORBA.DynValue.current_member_kind()
org.omg.DynamicAny.DynStructOperations.current_member_kind()
org.omg.DynamicAny.DynValueOperations.current_member_kind()
org.omg.DynamicAny._DynStructStub.current_member_kind()
org.omg.DynamicAny._DynValueStub.current_member_kind()


Occurences of current_member_name

current_member_name occurences:
org.omg.CORBA.DynStruct.current_member_name()
org.omg.CORBA.DynValue.current_member_name()
org.omg.DynamicAny.DynStructOperations.current_member_name()
org.omg.DynamicAny.DynValueOperations.current_member_name()
org.omg.DynamicAny._DynStructStub.current_member_name()
org.omg.DynamicAny._DynValueStub.current_member_name()


Occurences of Cursor (constructors)

Cursor (constructors) occurences:
java.awt.Cursor(int)
java.awt.Cursor(java.lang.String)


Occurences of curveTo

curveTo occurences:
java.awt.geom.Path2D.curveTo(double, double, double, double, double, double)
java.awt.geom.Path2D.Double.curveTo(double, double, double, double, double, double)
java.awt.geom.Path2D.Float.curveTo(double, double, double, double, double, double)
java.awt.geom.Path2D.Float.curveTo(float, float, float, float, float, float)


Occurences of cut

cut occurences:
javax.accessibility.AccessibleEditableText.cut(int, int)
javax.swing.JPasswordField.cut()
javax.swing.JSpinner.AccessibleJSpinner.cut(int, int)
javax.swing.text.JTextComponent.cut()
javax.swing.text.JTextComponent.AccessibleJTextComponent.cut(int, int)


Occurences of CyclicBarrier (constructors)

CyclicBarrier (constructors) occurences:
java.util.concurrent.CyclicBarrier(int)
java.util.concurrent.CyclicBarrier(int, java.lang.Runnable)


Occurences of D

D occurences:
java.awt.D
javax.print.attribute.standard.D
javax.print.attribute.standard.D


Occurences of damageRange

damageRange occurences:
javax.swing.plaf.basic.BasicTextUI.damageRange(javax.swing.text.JTextComponent, int, int)
javax.swing.plaf.basic.BasicTextUI.damageRange(javax.swing.text.JTextComponent, int, int, javax.swing.text.Position.Bias, javax.swing.text.Position.Bias)
javax.swing.plaf.multi.MultiTextUI.damageRange(javax.swing.text.JTextComponent, int, int)
javax.swing.plaf.multi.MultiTextUI.damageRange(javax.swing.text.JTextComponent, int, int, javax.swing.text.Position.Bias, javax.swing.text.Position.Bias)
javax.swing.plaf.TextUI.damageRange(javax.swing.text.JTextComponent, int, int)
javax.swing.plaf.TextUI.damageRange(javax.swing.text.JTextComponent, int, int, javax.swing.text.Position.Bias, javax.swing.text.Position.Bias)


Occurences of darkShadow

darkShadow occurences:
javax.swing.plaf.basic.darkShadow
javax.swing.plaf.basic.darkShadow
javax.swing.plaf.basic.darkShadow


Occurences of data

data occurences:
javax.sound.midi.data
javax.swing.text.html.parser.data
javax.swing.text.html.parser.data


Occurences of DataBuffer (constructors)

DataBuffer (constructors) occurences:
java.awt.image.DataBuffer(int, int)
java.awt.image.DataBuffer(int, int, int)
java.awt.image.DataBuffer(int, int, int, int)
java.awt.image.DataBuffer(int, int, int, int[])


Occurences of DataBufferByte (constructors)

DataBufferByte (constructors) occurences:
java.awt.image.DataBufferByte(byte[], int)
java.awt.image.DataBufferByte(byte[], int, int)
java.awt.image.DataBufferByte(byte[][], int)
java.awt.image.DataBufferByte(byte[][], int, int[])
java.awt.image.DataBufferByte(int)
java.awt.image.DataBufferByte(int, int)


Occurences of DataBufferDouble (constructors)

DataBufferDouble (constructors) occurences:
java.awt.image.DataBufferDouble(double[], int)
java.awt.image.DataBufferDouble(double[], int, int)
java.awt.image.DataBufferDouble(double[][], int)
java.awt.image.DataBufferDouble(double[][], int, int[])
java.awt.image.DataBufferDouble(int)
java.awt.image.DataBufferDouble(int, int)


Occurences of DataBufferFloat (constructors)

DataBufferFloat (constructors) occurences:
java.awt.image.DataBufferFloat(float[], int)
java.awt.image.DataBufferFloat(float[], int, int)
java.awt.image.DataBufferFloat(float[][], int)
java.awt.image.DataBufferFloat(float[][], int, int[])
java.awt.image.DataBufferFloat(int)
java.awt.image.DataBufferFloat(int, int)


Occurences of DataBufferInt (constructors)

DataBufferInt (constructors) occurences:
java.awt.image.DataBufferInt(int)
java.awt.image.DataBufferInt(int, int)
java.awt.image.DataBufferInt(int[], int)
java.awt.image.DataBufferInt(int[], int, int)
java.awt.image.DataBufferInt(int[][], int)
java.awt.image.DataBufferInt(int[][], int, int[])


Occurences of DataBufferShort (constructors)

DataBufferShort (constructors) occurences:
java.awt.image.DataBufferShort(int)
java.awt.image.DataBufferShort(int, int)
java.awt.image.DataBufferShort(short[], int)
java.awt.image.DataBufferShort(short[], int, int)
java.awt.image.DataBufferShort(short[][], int)
java.awt.image.DataBufferShort(short[][], int, int[])


Occurences of DataBufferUShort (constructors)

DataBufferUShort (constructors) occurences:
java.awt.image.DataBufferUShort(int)
java.awt.image.DataBufferUShort(int, int)
java.awt.image.DataBufferUShort(short[], int)
java.awt.image.DataBufferUShort(short[], int, int)
java.awt.image.DataBufferUShort(short[][], int)
java.awt.image.DataBufferUShort(short[][], int, int[])


Occurences of DataFlavor (constructors)

DataFlavor (constructors) occurences:
java.awt.datatransfer.DataFlavor()
java.awt.datatransfer.DataFlavor(java.lang.Class, java.lang.String)
java.awt.datatransfer.DataFlavor(java.lang.String)
java.awt.datatransfer.DataFlavor(java.lang.String, java.lang.String)
java.awt.datatransfer.DataFlavor(java.lang.String, java.lang.String, java.lang.ClassLoader)


Occurences of DataFormatException (constructors)

DataFormatException (constructors) occurences:
java.util.zip.DataFormatException()
java.util.zip.DataFormatException(java.lang.String)


Occurences of DatagramPacket (constructors)

DatagramPacket (constructors) occurences:
java.net.DatagramPacket(byte[], int)
java.net.DatagramPacket(byte[], int, int)
java.net.DatagramPacket(byte[], int, int, java.net.InetAddress, int)
java.net.DatagramPacket(byte[], int, int, java.net.SocketAddress)
java.net.DatagramPacket(byte[], int, java.net.InetAddress, int)
java.net.DatagramPacket(byte[], int, java.net.SocketAddress)


Occurences of DatagramSocket (constructors)

DatagramSocket (constructors) occurences:
java.net.DatagramSocket()
java.net.DatagramSocket(int)
java.net.DatagramSocket(int, java.net.InetAddress)
java.net.DatagramSocket(java.net.DatagramSocketImpl)
java.net.DatagramSocket(java.net.SocketAddress)


Occurences of DataHandler (constructors)

DataHandler (constructors) occurences:
javax.activation.DataHandler(java.lang.Object, java.lang.String)
javax.activation.DataHandler(java.net.URL)
javax.activation.DataHandler(javax.activation.DataSource)


Occurences of DataInputStream

DataInputStream occurences:
java.io.DataInputStream
org.omg.CORBA.DataInputStream


Occurences of DataLine.Info (constructors)

DataLine.Info (constructors) occurences:
javax.sound.sampled.DataLine.Info(java.lang.Class, javax.sound.sampled.AudioFormat)
javax.sound.sampled.DataLine.Info(java.lang.Class, javax.sound.sampled.AudioFormat, int)
javax.sound.sampled.DataLine.Info(java.lang.Class, javax.sound.sampled.AudioFormat[], int, int)


Occurences of dataModel

dataModel occurences:
javax.swing.dataModel
javax.swing.dataModel


Occurences of DataOutputStream

DataOutputStream occurences:
java.io.DataOutputStream
org.omg.CORBA.DataOutputStream


Occurences of DataSource

DataSource occurences:
DataSource
javax.activation.DataSource
javax.sql.DataSource


Occurences of DataTruncation (constructors)

DataTruncation (constructors) occurences:
java.sql.DataTruncation(int, boolean, boolean, int, int)
java.sql.DataTruncation(int, boolean, boolean, int, int, java.lang.Throwable)


Occurences of dataType

dataType occurences:
java.awt.image.dataType
java.awt.image.dataType


Occurences of DatatypeConfigurationException (constructors)

DatatypeConfigurationException (constructors) occurences:
javax.xml.datatype.DatatypeConfigurationException()
javax.xml.datatype.DatatypeConfigurationException(java.lang.String)
javax.xml.datatype.DatatypeConfigurationException(java.lang.String, java.lang.Throwable)
javax.xml.datatype.DatatypeConfigurationException(java.lang.Throwable)


Occurences of DATA_CONVERSION (constructors)

DATA_CONVERSION (constructors) occurences:
org.omg.CORBA.DATA_CONVERSION()
org.omg.CORBA.DATA_CONVERSION(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.DATA_CONVERSION(java.lang.String)
org.omg.CORBA.DATA_CONVERSION(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of DATE

DATE occurences:
java.sql.DATE
java.util.DATE
javax.management.openmbean.DATE
javax.xml.datatype.DATE


Occurences of date

date occurences:
Class GLOBALS.date
javax.annotation.Generated.date()


Occurences of Date

Date occurences:
java.sql.Date
java.util.Date


Occurences of Date (constructors)

Date (constructors) occurences:
java.sql.Date(int, int, int)
java.sql.Date(long)
java.util.Date()
java.util.Date(int, int, int)
java.util.Date(int, int, int, int, int)
java.util.Date(int, int, int, int, int, int)
java.util.Date(java.lang.String)
java.util.Date(long)


Occurences of DateFormatSymbols (constructors)

DateFormatSymbols (constructors) occurences:
java.text.DateFormatSymbols()
java.text.DateFormatSymbols(java.util.Locale)


Occurences of DateFormatter (constructors)

DateFormatter (constructors) occurences:
javax.swing.text.DateFormatter()
javax.swing.text.DateFormatter(java.text.DateFormat)


Occurences of DAYS

DAYS occurences:
java.util.concurrent.DAYS
javax.xml.datatype.DAYS


Occurences of DAY_OF_MONTH

DAY_OF_MONTH occurences:
java.text.DAY_OF_MONTH
java.util.DAY_OF_MONTH


Occurences of DAY_OF_WEEK

DAY_OF_WEEK occurences:
java.text.DAY_OF_WEEK
java.util.DAY_OF_WEEK


Occurences of DAY_OF_WEEK_IN_MONTH

DAY_OF_WEEK_IN_MONTH occurences:
java.text.DAY_OF_WEEK_IN_MONTH
java.util.DAY_OF_WEEK_IN_MONTH


Occurences of DAY_OF_YEAR

DAY_OF_YEAR occurences:
java.text.DAY_OF_YEAR
java.util.DAY_OF_YEAR


Occurences of deactivate

deactivate occurences:
java.awt.im.spi.InputMethod.deactivate(boolean)
javax.rmi.CORBA.Tie.deactivate()
org.omg.PortableServer.POAManagerOperations.deactivate(boolean, boolean)


Occurences of deactivateFrame

deactivateFrame occurences:
javax.swing.DefaultDesktopManager.deactivateFrame(javax.swing.JInternalFrame)
javax.swing.DesktopManager.deactivateFrame(javax.swing.JInternalFrame)
javax.swing.plaf.basic.BasicInternalFrameUI.deactivateFrame(javax.swing.JInternalFrame)


Occurences of DebugGraphics (constructors)

DebugGraphics (constructors) occurences:
javax.swing.DebugGraphics()
javax.swing.DebugGraphics(java.awt.Graphics)
javax.swing.DebugGraphics(java.awt.Graphics, javax.swing.JComponent)


Occurences of DECEMBER

DECEMBER occurences:
java.util.DECEMBER
javax.xml.datatype.DECEMBER


Occurences of decimal

decimal occurences:
java.util.decimal
java.util.decimal


Occurences of DecimalFormat (constructors)

DecimalFormat (constructors) occurences:
java.text.DecimalFormat()
java.text.DecimalFormat(java.lang.String)
java.text.DecimalFormat(java.lang.String, java.text.DecimalFormatSymbols)


Occurences of DecimalFormatSymbols (constructors)

DecimalFormatSymbols (constructors) occurences:
java.text.DecimalFormatSymbols()
java.text.DecimalFormatSymbols(java.util.Locale)


Occurences of DECLARED

DECLARED occurences:
java.lang.reflect.DECLARED
javax.lang.model.type.DECLARED


Occurences of DeclaredType

DeclaredType occurences:
com.sun.mirror.type.DeclaredType
javax.lang.model.type.DeclaredType


Occurences of declaringType

declaringType occurences:
com.sun.jdi.Location.declaringType()
com.sun.jdi.TypeComponent.declaringType()


Occurences of decode

decode occurences:
java.awt.Color.decode(java.lang.String)
java.awt.Font.decode(java.lang.String)
java.lang.Byte.decode(java.lang.String)
java.lang.Integer.decode(java.lang.String)
java.lang.Long.decode(java.lang.String)
java.lang.Short.decode(java.lang.String)
java.net.decode
java.net.URLDecoder.decode(java.lang.String)
java.net.URLDecoder.decode(java.lang.String, java.lang.String)
java.nio.charset.Charset.decode(java.nio.ByteBuffer)
java.nio.charset.CharsetDecoder.decode(java.nio.ByteBuffer)
java.nio.charset.CharsetDecoder.decode(java.nio.ByteBuffer, java.nio.CharBuffer, boolean)
java.security.Certificate.decode(java.io.InputStream)
org.omg.IOP.CodecOperations.decode(byte[])


Occurences of decorateTask

decorateTask occurences:
java.util.concurrent.ScheduledThreadPoolExecutor.decorateTask(java.lang.Runnable, java.util.concurrent.RunnableScheduledFuture)
java.util.concurrent.ScheduledThreadPoolExecutor.decorateTask(java.util.concurrent.Callable, java.util.concurrent.RunnableScheduledFuture)


Occurences of decrementAndGet

decrementAndGet occurences:
java.util.concurrent.atomic.AtomicInteger.decrementAndGet()
java.util.concurrent.atomic.AtomicIntegerArray.decrementAndGet(int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.decrementAndGet(java.lang.Object)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.decrementAndGet(T)
java.util.concurrent.atomic.AtomicLong.decrementAndGet()
java.util.concurrent.atomic.AtomicLongArray.decrementAndGet(int)
java.util.concurrent.atomic.AtomicLongFieldUpdater.decrementAndGet(java.lang.Object)
java.util.concurrent.atomic.AtomicLongFieldUpdater.decrementAndGet(T)


Occurences of def

def occurences:
java.util.zip.def
java.util.zip.def


Occurences of DEFAULT

DEFAULT occurences:
java.awt.dnd.DEFAULT
java.security.spec.DEFAULT
java.text.DEFAULT
javax.crypto.spec.DEFAULT
javax.crypto.spec.DEFAULT
javax.swing.DEFAULT
javax.swing.plaf.synth.DEFAULT
javax.swing.text.html.parser.DEFAULT
javax.xml.crypto.dsig.spec.DEFAULT


Occurences of defaultAction

defaultAction occurences:
com.sun.source.util.SimpleTreeVisitor.defaultAction(com.sun.source.tree.Tree, P)
com.sun.source.util.SimpleTreeVisitor.defaultAction(com.sun.source.tree.Tree,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.defaultAction(java.lang.Object, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.defaultAction(java.lang.Object,java.lang.Object)
javax.lang.model.util.SimpleElementVisitor6.defaultAction(javax.lang.model.element.Element, P)
javax.lang.model.util.SimpleElementVisitor6.defaultAction(javax.lang.model.element.Element,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.defaultAction(javax.lang.model.type.TypeMirror, P)
javax.lang.model.util.SimpleTypeVisitor6.defaultAction(javax.lang.model.type.TypeMirror,java.lang.Object)


Occurences of DefaultBoundedRangeModel (constructors)

DefaultBoundedRangeModel (constructors) occurences:
javax.swing.DefaultBoundedRangeModel()
javax.swing.DefaultBoundedRangeModel(int, int, int, int)


Occurences of DefaultCellEditor (constructors)

DefaultCellEditor (constructors) occurences:
javax.swing.DefaultCellEditor(javax.swing.JCheckBox)
javax.swing.DefaultCellEditor(javax.swing.JComboBox)
javax.swing.DefaultCellEditor(javax.swing.JTextField)


Occurences of DefaultColorSelectionModel (constructors)

DefaultColorSelectionModel (constructors) occurences:
javax.swing.colorchooser.DefaultColorSelectionModel()
javax.swing.colorchooser.DefaultColorSelectionModel(java.awt.Color)


Occurences of DefaultComboBoxModel (constructors)

DefaultComboBoxModel (constructors) occurences:
javax.swing.DefaultComboBoxModel()
javax.swing.DefaultComboBoxModel(java.lang.Object[])
javax.swing.DefaultComboBoxModel(java.util.Vector)


Occurences of defaultController

defaultController occurences:
javax.imageio.defaultController
javax.imageio.metadata.defaultController


Occurences of DefaultFormatterFactory (constructors)

DefaultFormatterFactory (constructors) occurences:
javax.swing.text.DefaultFormatterFactory()
javax.swing.text.DefaultFormatterFactory(javax.swing.JFormattedTextField.AbstractFormatter)
javax.swing.text.DefaultFormatterFactory(javax.swing.JFormattedTextField.AbstractFormatter, javax.swing.JFormattedTextField.AbstractFormatter)
javax.swing.text.DefaultFormatterFactory(javax.swing.JFormattedTextField.AbstractFormatter, javax.swing.JFormattedTextField.AbstractFormatter, javax.swing.JFormattedTextField.AbstractFormatter)
javax.swing.text.DefaultFormatterFactory(javax.swing.JFormattedTextField.AbstractFormatter, javax.swing.JFormattedTextField.AbstractFormatter, javax.swing.JFormattedTextField.AbstractFormatter, javax.swing.JFormattedTextField.AbstractFormatter)


Occurences of DefaultLoaderRepository

DefaultLoaderRepository occurences:
javax.management.DefaultLoaderRepository
javax.management.loading.DefaultLoaderRepository


Occurences of DefaultLoaderRepository (constructors)

DefaultLoaderRepository (constructors) occurences:
javax.management.DefaultLoaderRepository()
javax.management.loading.DefaultLoaderRepository()


Occurences of DefaultMutableTreeNode (constructors)

DefaultMutableTreeNode (constructors) occurences:
javax.swing.tree.DefaultMutableTreeNode()
javax.swing.tree.DefaultMutableTreeNode(java.lang.Object)
javax.swing.tree.DefaultMutableTreeNode(java.lang.Object, boolean)


Occurences of defaultPage

defaultPage occurences:
java.awt.print.PrinterJob.defaultPage()
java.awt.print.PrinterJob.defaultPage(java.awt.print.PageFormat)


Occurences of DefaultPersistenceDelegate (constructors)

DefaultPersistenceDelegate (constructors) occurences:
java.beans.DefaultPersistenceDelegate()
java.beans.DefaultPersistenceDelegate(java.lang.String[])


Occurences of DefaultStyledDocument (constructors)

DefaultStyledDocument (constructors) occurences:
javax.swing.text.DefaultStyledDocument()
javax.swing.text.DefaultStyledDocument(javax.swing.text.AbstractDocument.Content, javax.swing.text.StyleContext)
javax.swing.text.DefaultStyledDocument(javax.swing.text.StyleContext)


Occurences of DefaultStyledDocument.ElementSpec (constructors)

DefaultStyledDocument.ElementSpec (constructors) occurences:
javax.swing.text.DefaultStyledDocument.ElementSpec(javax.swing.text.AttributeSet, short)
javax.swing.text.DefaultStyledDocument.ElementSpec(javax.swing.text.AttributeSet, short, char[], int, int)
javax.swing.text.DefaultStyledDocument.ElementSpec(javax.swing.text.AttributeSet, short, int)


Occurences of DefaultTableModel (constructors)

DefaultTableModel (constructors) occurences:
javax.swing.table.DefaultTableModel()
javax.swing.table.DefaultTableModel(int, int)
javax.swing.table.DefaultTableModel(java.lang.Object[], int)
javax.swing.table.DefaultTableModel(java.lang.Object[][], java.lang.Object[])
javax.swing.table.DefaultTableModel(java.util.Vector, int)
javax.swing.table.DefaultTableModel(java.util.Vector, java.util.Vector)


Occurences of defaultTextIconGap

defaultTextIconGap occurences:
javax.swing.plaf.basic.defaultTextIconGap
javax.swing.plaf.basic.defaultTextIconGap


Occurences of DefaultTreeCellEditor (constructors)

DefaultTreeCellEditor (constructors) occurences:
javax.swing.tree.DefaultTreeCellEditor(javax.swing.JTree, javax.swing.tree.DefaultTreeCellRenderer)
javax.swing.tree.DefaultTreeCellEditor(javax.swing.JTree, javax.swing.tree.DefaultTreeCellRenderer, javax.swing.tree.TreeCellEditor)


Occurences of DefaultTreeModel (constructors)

DefaultTreeModel (constructors) occurences:
javax.swing.tree.DefaultTreeModel(javax.swing.tree.TreeNode)
javax.swing.tree.DefaultTreeModel(javax.swing.tree.TreeNode, boolean)


Occurences of defaultValue

defaultValue occurences:
com.sun.javadoc.AnnotationTypeElementDoc.defaultValue()
javax.management.defaultValue
javax.xml.bind.annotation.XmlElement.defaultValue()
javax.xml.bind.annotation.XmlElementDecl.defaultValue()


Occurences of DEFAULT_CLASS_LOADER

DEFAULT_CLASS_LOADER occurences:
javax.management.remote.DEFAULT_CLASS_LOADER
javax.management.remote.DEFAULT_CLASS_LOADER


Occurences of DEFAULT_CURSOR

DEFAULT_CURSOR occurences:
java.awt.DEFAULT_CURSOR
java.awt.DEFAULT_CURSOR


Occurences of DEFAULT_LIFETIME

DEFAULT_LIFETIME occurences:
org.ietf.jgss.DEFAULT_LIFETIME
org.ietf.jgss.DEFAULT_LIFETIME


Occurences of DEFAULT_VALUE

DEFAULT_VALUE occurences:
com.sun.source.util.DEFAULT_VALUE
javax.lang.model.util.DEFAULT_VALUE
javax.lang.model.util.DEFAULT_VALUE
javax.lang.model.util.DEFAULT_VALUE
javax.lang.model.util.DEFAULT_VALUE


Occurences of defEntity

defEntity occurences:
javax.swing.text.html.parser.DTD.defEntity(java.lang.String, int, int)
javax.swing.text.html.parser.DTD.defEntity(java.lang.String, int, java.lang.String)


Occurences of defineClass

defineClass occurences:
java.lang.ClassLoader.defineClass(byte[], int, int)
java.lang.ClassLoader.defineClass(java.lang.String, byte[], int, int)
java.lang.ClassLoader.defineClass(java.lang.String, byte[], int, int, java.security.ProtectionDomain)
java.lang.ClassLoader.defineClass(java.lang.String, java.nio.ByteBuffer, java.security.ProtectionDomain)
java.security.SecureClassLoader.defineClass(java.lang.String, byte[], int, int, java.security.CodeSource)
java.security.SecureClassLoader.defineClass(java.lang.String, java.nio.ByteBuffer, java.security.CodeSource)


Occurences of definePackage

definePackage occurences:
java.lang.ClassLoader.definePackage(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.net.URL)
java.net.URLClassLoader.definePackage(java.lang.String, java.util.jar.Manifest, java.net.URL)


Occurences of deflate

deflate occurences:
java.util.zip.Deflater.deflate(byte[])
java.util.zip.Deflater.deflate(byte[], int, int)
java.util.zip.DeflaterOutputStream.deflate()


Occurences of DEFLATED

DEFLATED occurences:
java.util.zip.DEFLATED
java.util.zip.DEFLATED
java.util.zip.DEFLATED


Occurences of Deflater (constructors)

Deflater (constructors) occurences:
java.util.zip.Deflater()
java.util.zip.Deflater(int)
java.util.zip.Deflater(int, boolean)


Occurences of DeflaterInputStream (constructors)

DeflaterInputStream (constructors) occurences:
java.util.zip.DeflaterInputStream(java.io.InputStream)
java.util.zip.DeflaterInputStream(java.io.InputStream, java.util.zip.Deflater)
java.util.zip.DeflaterInputStream(java.io.InputStream, java.util.zip.Deflater, int)


Occurences of DeflaterOutputStream (constructors)

DeflaterOutputStream (constructors) occurences:
java.util.zip.DeflaterOutputStream(java.io.OutputStream)
java.util.zip.DeflaterOutputStream(java.io.OutputStream, java.util.zip.Deflater)
java.util.zip.DeflaterOutputStream(java.io.OutputStream, java.util.zip.Deflater, int)


Occurences of DEFLATE_HINT

DEFLATE_HINT occurences:
java.util.jar.DEFLATE_HINT
java.util.jar.DEFLATE_HINT


Occurences of def_kind

def_kind occurences:
org.omg.CORBA.IRObjectOperations.def_kind()
org.omg.CORBA._IDLTypeStub.def_kind()


Occurences of deiconifyFrame

deiconifyFrame occurences:
javax.swing.DefaultDesktopManager.deiconifyFrame(javax.swing.JInternalFrame)
javax.swing.DesktopManager.deiconifyFrame(javax.swing.JInternalFrame)
javax.swing.plaf.basic.BasicInternalFrameUI.deiconifyFrame(javax.swing.JInternalFrame)


Occurences of deinstall

deinstall occurences:
javax.swing.text.Caret.deinstall(javax.swing.text.JTextComponent)
javax.swing.text.DefaultCaret.deinstall(javax.swing.text.JTextComponent)
javax.swing.text.DefaultHighlighter.deinstall(javax.swing.text.JTextComponent)
javax.swing.text.EditorKit.deinstall(javax.swing.JEditorPane)
javax.swing.text.Highlighter.deinstall(javax.swing.text.JTextComponent)
javax.swing.text.html.HTMLEditorKit.deinstall(javax.swing.JEditorPane)
javax.swing.text.StyledEditorKit.deinstall(javax.swing.JEditorPane)


Occurences of DelayQueue (constructors)

DelayQueue (constructors) occurences:
java.util.concurrent.DelayQueue()
java.util.concurrent.DelayQueue(java.util.Collection)


Occurences of Delegate

Delegate occurences:
org.omg.CORBA.portable.Delegate
org.omg.CORBA_2_3.portable.Delegate
org.omg.PortableServer.portable.Delegate


Occurences of Delegate (constructors)

Delegate (constructors) occurences:
org.omg.CORBA.portable.Delegate()
org.omg.CORBA_2_3.portable.Delegate()


Occurences of delegateFocus

delegateFocus occurences:
javax.swing.plaf.basic.BasicComboPopup.delegateFocus(java.awt.event.MouseEvent)
javax.swing.plaf.metal.MetalComboBoxUI.MetalComboPopup.delegateFocus(java.awt.event.MouseEvent)


Occurences of DelegationPermission (constructors)

DelegationPermission (constructors) occurences:
javax.security.auth.kerberos.DelegationPermission(java.lang.String)
javax.security.auth.kerberos.DelegationPermission(java.lang.String, java.lang.String)


Occurences of DELETE

DELETE occurences:
java.awt.DELETE
javax.accessibility.DELETE
javax.swing.event.DELETE


Occurences of delete

delete occurences:
java.io.File.delete()
java.lang.StringBuffer.delete(int, int)
java.lang.StringBuilder.delete(int, int)
javax.accessibility.AccessibleEditableText.delete(int, int)
javax.swing.JSpinner.AccessibleJSpinner.delete(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.delete(int, int)
javax.tools.FileObject.delete()
javax.tools.ForwardingFileObject.delete()
javax.tools.SimpleJavaFileObject.delete()


Occurences of deleteChar

deleteChar occurences:
java.awt.font.LineBreakMeasurer.deleteChar(java.text.AttributedCharacterIterator, int)
java.awt.font.TextMeasurer.deleteChar(java.text.AttributedCharacterIterator, int)


Occurences of deleteCharAt

deleteCharAt occurences:
java.lang.StringBuffer.deleteCharAt(int)
java.lang.StringBuilder.deleteCharAt(int)


Occurences of deleteShortcut

deleteShortcut occurences:
java.awt.MenuBar.deleteShortcut(java.awt.MenuShortcut)
java.awt.MenuItem.deleteShortcut()


Occurences of deliverEvent

deliverEvent occurences:
java.awt.Component.deliverEvent(java.awt.Event)
java.awt.Container.deliverEvent(java.awt.Event)


Occurences of deltaTransform

deltaTransform occurences:
java.awt.geom.AffineTransform.deltaTransform(double[], int, double[], int, int)
java.awt.geom.AffineTransform.deltaTransform(java.awt.geom.Point2D, java.awt.geom.Point2D)


Occurences of Deprecated List

Deprecated List occurences:
Deprecated List
Deprecated List
Deprecated List
Deprecated List


Occurences of depth

depth occurences:
com.sun.jdi.request.StepRequest.depth()
javax.swing.text.ElementIterator.depth()


Occurences of dequeueKeyEvents

dequeueKeyEvents occurences:
java.awt.DefaultKeyboardFocusManager.dequeueKeyEvents(long, java.awt.Component)
java.awt.KeyboardFocusManager.dequeueKeyEvents(long, java.awt.Component)


Occurences of dereference

dereference occurences:
javax.xml.crypto.dsig.keyinfo.RetrievalMethod.dereference(javax.xml.crypto.XMLCryptoContext)
javax.xml.crypto.URIDereferencer.dereference(javax.xml.crypto.URIReference, javax.xml.crypto.XMLCryptoContext)


Occurences of deregisterAll

deregisterAll occurences:
javax.imageio.spi.ServiceRegistry.deregisterAll()
javax.imageio.spi.ServiceRegistry.deregisterAll(java.lang.Class)


Occurences of deregisterServiceProvider

deregisterServiceProvider occurences:
javax.imageio.spi.ServiceRegistry.deregisterServiceProvider(java.lang.Object)
javax.imageio.spi.ServiceRegistry.deregisterServiceProvider(java.lang.Object,java.lang.Class)
javax.imageio.spi.ServiceRegistry.deregisterServiceProvider(T, java.lang.Class)


Occurences of derive

derive occurences:
java.awt.AlphaComposite.derive(float)
java.awt.AlphaComposite.derive(int)


Occurences of deriveFont

deriveFont occurences:
java.awt.Font.deriveFont(float)
java.awt.Font.deriveFont(int)
java.awt.Font.deriveFont(int, float)
java.awt.Font.deriveFont(int, java.awt.geom.AffineTransform)
java.awt.Font.deriveFont(java.awt.geom.AffineTransform)
java.awt.Font.deriveFont(java.util.Map)


Occurences of deriveMMFont

deriveMMFont occurences:
java.awt.font.MultipleMaster.deriveMMFont(float[])
java.awt.font.MultipleMaster.deriveMMFont(float[], float, float, float, float)


Occurences of descendingIterator

descendingIterator occurences:
java.util.ArrayDeque.descendingIterator()
java.util.concurrent.ConcurrentSkipListSet.descendingIterator()
java.util.concurrent.LinkedBlockingDeque.descendingIterator()
java.util.Deque.descendingIterator()
java.util.LinkedList.descendingIterator()
java.util.NavigableSet.descendingIterator()
java.util.TreeSet.descendingIterator()


Occurences of descendingKeySet

descendingKeySet occurences:
java.util.concurrent.ConcurrentNavigableMap.descendingKeySet()
java.util.concurrent.ConcurrentSkipListMap.descendingKeySet()
java.util.NavigableMap.descendingKeySet()
java.util.TreeMap.descendingKeySet()


Occurences of descendingMap

descendingMap occurences:
java.util.concurrent.ConcurrentNavigableMap.descendingMap()
java.util.concurrent.ConcurrentSkipListMap.descendingMap()
java.util.NavigableMap.descendingMap()
java.util.TreeMap.descendingMap()


Occurences of descendingSet

descendingSet occurences:
java.util.concurrent.ConcurrentSkipListSet.descendingSet()
java.util.NavigableSet.descendingSet()
java.util.TreeSet.descendingSet()


Occurences of description

description occurences:
com.sun.javadoc.SerialFieldTag.description()
com.sun.jdi.connect.Connector.description()
com.sun.jdi.connect.Connector.Argument.description()
com.sun.jdi.connect.spi.TransportService.description()
com.sun.jdi.VirtualMachine.description()
java.sql.description
javax.annotation.Resource.description()
javax.management.description


Occurences of DescriptorSupport (constructors)

DescriptorSupport (constructors) occurences:
javax.management.modelmbean.DescriptorSupport()
javax.management.modelmbean.DescriptorSupport(int)
javax.management.modelmbean.DescriptorSupport(java.lang.String)
javax.management.modelmbean.DescriptorSupport(java.lang.String...)
javax.management.modelmbean.DescriptorSupport(java.lang.String[], java.lang.Object[])
javax.management.modelmbean.DescriptorSupport(javax.management.modelmbean.DescriptorSupport)


Occurences of DESedeKeySpec (constructors)

DESedeKeySpec (constructors) occurences:
javax.crypto.spec.DESedeKeySpec(byte[])
javax.crypto.spec.DESedeKeySpec(byte[], int)


Occurences of deserialize

deserialize occurences:
java.beans.beancontext.BeanContextSupport.deserialize(java.io.ObjectInputStream, java.util.Collection)
javax.management.MBeanServer.deserialize(java.lang.String, byte[])
javax.management.MBeanServer.deserialize(java.lang.String, javax.management.ObjectName, byte[])
javax.management.MBeanServer.deserialize(javax.management.ObjectName, byte[])


Occurences of Design Overview

Design Overview occurences:
Design Overview
Design Overview


Occurences of DESKeySpec (constructors)

DESKeySpec (constructors) occurences:
javax.crypto.spec.DESKeySpec(byte[])
javax.crypto.spec.DESKeySpec(byte[], int)


Occurences of desktop

desktop occurences:
java.awt.desktop
javax.swing.plaf.basic.desktop


Occurences of desktopIcon

desktopIcon occurences:
javax.swing.desktopIcon
javax.swing.plaf.basic.desktopIcon


Occurences of DESKTOP_ICON

DESKTOP_ICON occurences:
javax.accessibility.DESKTOP_ICON
javax.swing.plaf.synth.DESKTOP_ICON


Occurences of DESKTOP_PANE

DESKTOP_PANE occurences:
javax.accessibility.DESKTOP_PANE
javax.swing.plaf.synth.DESKTOP_PANE


Occurences of destination

destination occurences:
javax.imageio.destination
javax.swing.plaf.basic.destination


Occurences of destroy

destroy occurences:
java.applet.Applet.destroy()
java.lang.Process.destroy()
java.lang.Thread.destroy()
java.lang.ThreadGroup.destroy()
java.security.KeyStore.PasswordProtection.destroy()
javax.security.auth.Destroyable.destroy()
javax.security.auth.kerberos.KerberosKey.destroy()
javax.security.auth.kerberos.KerberosTicket.destroy()
javax.security.auth.x500.X500PrivateCredential.destroy()
org.omg.CORBA.DynAny.destroy()
org.omg.CORBA.IRObjectOperations.destroy()
org.omg.CORBA.ORB.destroy()
org.omg.CORBA.PolicyOperations.destroy()
org.omg.CORBA._IDLTypeStub.destroy()
org.omg.CORBA._PolicyStub.destroy()
org.omg.CosNaming.BindingIteratorOperations.destroy()
org.omg.CosNaming.NamingContextOperations.destroy()
org.omg.CosNaming._BindingIteratorStub.destroy()
org.omg.CosNaming._NamingContextExtStub.destroy()
org.omg.CosNaming._NamingContextStub.destroy()
org.omg.DynamicAny.DynAnyOperations.destroy()
org.omg.DynamicAny._DynAnyStub.destroy()
org.omg.DynamicAny._DynArrayStub.destroy()
org.omg.DynamicAny._DynEnumStub.destroy()
org.omg.DynamicAny._DynFixedStub.destroy()
org.omg.DynamicAny._DynSequenceStub.destroy()
org.omg.DynamicAny._DynStructStub.destroy()
org.omg.DynamicAny._DynUnionStub.destroy()
org.omg.DynamicAny._DynValueStub.destroy()
org.omg.PortableInterceptor.InterceptorOperations.destroy()
org.omg.PortableServer.POAOperations.destroy(boolean, boolean)


Occurences of DestroyFailedException (constructors)

DestroyFailedException (constructors) occurences:
javax.security.auth.DestroyFailedException()
javax.security.auth.DestroyFailedException(java.lang.String)


Occurences of destroySubcontext

destroySubcontext occurences:
javax.naming.Context.destroySubcontext(java.lang.String)
javax.naming.Context.destroySubcontext(javax.naming.Name)
javax.naming.InitialContext.destroySubcontext(java.lang.String)
javax.naming.InitialContext.destroySubcontext(javax.naming.Name)


Occurences of detail

detail occurences:
java.io.detail
java.rmi.activation.detail
java.rmi.detail
java.rmi.server.detail
java.util.detail


Occurences of Deva Search

Deva Search occurences:
Deva Search
Deva Search
Deva Search
Deva Search
Deva Search
Deva Search
Deva Search
Deva Search
Deva Search
Deva Search
Deva Search
Deva Search


Occurences of Deva Search - Help Page

Deva Search - Help Page occurences:
Deva Search - Help Page
Deva Search - Help Page
Deva Search - Help Page
Deva Search - Help Page


Occurences of Deva Search - Refresh previous page or no Javascript

Deva Search - Refresh previous page or no Javascript occurences:
Deva Search - Refresh previous page or no Javascript
Deva Search - Refresh previous page or no Javascript
Deva Search - Refresh previous page or no Javascript
Deva Search - Refresh previous page or no Javascript
Deva Search - Refresh previous page or no Javascript


Occurences of DEVANAGARI

DEVANAGARI occurences:
java.awt.font.DEVANAGARI
java.lang.DEVANAGARI


Occurences of DHParameterSpec (constructors)

DHParameterSpec (constructors) occurences:
javax.crypto.spec.DHParameterSpec(java.math.BigInteger, java.math.BigInteger)
javax.crypto.spec.DHParameterSpec(java.math.BigInteger, java.math.BigInteger, int)


Occurences of DIALOG

DIALOG occurences:
java.awt.DIALOG
javax.accessibility.DIALOG


Occurences of Dialog (constructors)

Dialog (constructors) occurences:
java.awt.Dialog(java.awt.Dialog)
java.awt.Dialog(java.awt.Dialog, java.lang.String)
java.awt.Dialog(java.awt.Dialog, java.lang.String, boolean)
java.awt.Dialog(java.awt.Dialog, java.lang.String, boolean, java.awt.GraphicsConfiguration)
java.awt.Dialog(java.awt.Frame)
java.awt.Dialog(java.awt.Frame, boolean)
java.awt.Dialog(java.awt.Frame, java.lang.String)
java.awt.Dialog(java.awt.Frame, java.lang.String, boolean)
java.awt.Dialog(java.awt.Frame, java.lang.String, boolean, java.awt.GraphicsConfiguration)
java.awt.Dialog(java.awt.Window)
java.awt.Dialog(java.awt.Window, java.awt.Dialog.ModalityType)
java.awt.Dialog(java.awt.Window, java.lang.String)
java.awt.Dialog(java.awt.Window, java.lang.String, java.awt.Dialog.ModalityType)
java.awt.Dialog(java.awt.Window, java.lang.String, java.awt.Dialog.ModalityType, java.awt.GraphicsConfiguration)


Occurences of die

die occurences:
javax.swing.undo.AbstractUndoableEdit.die()
javax.swing.undo.CompoundEdit.die()
javax.swing.undo.UndoableEdit.die()


Occurences of digest

digest occurences:
java.security.digest
java.security.digest
java.security.MessageDigest.digest()
java.security.MessageDigest.digest(byte[])
java.security.MessageDigest.digest(byte[], int, int)


Occurences of DigestException (constructors)

DigestException (constructors) occurences:
java.security.DigestException()
java.security.DigestException(java.lang.String)
java.security.DigestException(java.lang.String, java.lang.Throwable)
java.security.DigestException(java.lang.Throwable)


Occurences of digit

digit occurences:
java.lang.Character.digit(char, int)
java.lang.Character.digit(int, int)


Occurences of Dimension (constructors)

Dimension (constructors) occurences:
java.awt.Dimension()
java.awt.Dimension(int, int)
java.awt.Dimension(java.awt.Dimension)


Occurences of DIR

DIR occurences:
javax.swing.text.html.DIR
javax.swing.text.html.DIR


Occurences of DirectColorModel (constructors)

DirectColorModel (constructors) occurences:
java.awt.image.DirectColorModel(int, int, int, int)
java.awt.image.DirectColorModel(int, int, int, int, int)
java.awt.image.DirectColorModel(java.awt.color.ColorSpace, int, int, int, int, int, boolean, int)


Occurences of direction

direction occurences:
javax.swing.plaf.basic.direction
javax.swing.plaf.basic.direction
javax.swing.plaf.basic.direction
javax.swing.plaf.basic.direction
javax.swing.plaf.basic.direction


Occurences of directory

directory occurences:
java.lang.ProcessBuilder.directory()
java.lang.ProcessBuilder.directory(java.io.File)
javax.naming.directory


Occurences of disable

disable occurences:
com.sun.jdi.request.EventRequest.disable()
java.awt.Component.disable()
java.awt.MenuItem.disable()
java.lang.Compiler.disable()
javax.swing.JComponent.disable()


Occurences of disabledTextColor

disabledTextColor occurences:
javax.swing.plaf.metal.disabledTextColor
javax.swing.plaf.metal.disabledTextColor
javax.swing.plaf.metal.disabledTextColor


Occurences of disableEvents

disableEvents occurences:
java.awt.Component.disableEvents(long)
java.awt.MenuItem.disableEvents(long)


Occurences of DISCARDING

DISCARDING occurences:
org.omg.PortableInterceptor.DISCARDING
org.omg.PortableServer.POAManagerPackage.DISCARDING


Occurences of discardKeyEvents

discardKeyEvents occurences:
java.awt.DefaultKeyboardFocusManager.discardKeyEvents(java.awt.Component)
java.awt.KeyboardFocusManager.discardKeyEvents(java.awt.Component)


Occurences of disconnect

disconnect occurences:
java.net.DatagramSocket.disconnect()
java.net.DatagramSocketImpl.disconnect()
java.net.HttpURLConnection.disconnect()
java.nio.channels.DatagramChannel.disconnect()
org.omg.CORBA.ORB.disconnect(org.omg.CORBA.Object)


Occurences of discriminator_kind

discriminator_kind occurences:
org.omg.CORBA.DynUnion.discriminator_kind()
org.omg.DynamicAny.DynUnionOperations.discriminator_kind()
org.omg.DynamicAny._DynUnionStub.discriminator_kind()


Occurences of dispatch

dispatch occurences:
java.awt.ActiveEvent.dispatch()
java.awt.event.InvocationEvent.dispatch()
java.rmi.server.Skeleton.dispatch(java.rmi.Remote, java.rmi.server.RemoteCall, int, long)
javax.naming.event.NamingEvent.dispatch(javax.naming.event.NamingListener)
javax.naming.event.NamingExceptionEvent.dispatch(javax.naming.event.NamingListener)
javax.naming.ldap.UnsolicitedNotificationEvent.dispatch(javax.naming.ldap.UnsolicitedNotificationListener)


Occurences of dispatchEvent

dispatchEvent occurences:
java.awt.Component.dispatchEvent(java.awt.AWTEvent)
java.awt.DefaultKeyboardFocusManager.dispatchEvent(java.awt.AWTEvent)
java.awt.EventQueue.dispatchEvent(java.awt.AWTEvent)
java.awt.im.InputContext.dispatchEvent(java.awt.AWTEvent)
java.awt.im.spi.InputMethod.dispatchEvent(java.awt.AWTEvent)
java.awt.KeyboardFocusManager.dispatchEvent(java.awt.AWTEvent)
java.awt.MenuComponent.dispatchEvent(java.awt.AWTEvent)
org.w3c.dom.events.EventTarget.dispatchEvent(org.w3c.dom.events.Event)


Occurences of dispatchKeyEvent

dispatchKeyEvent occurences:
java.awt.DefaultKeyboardFocusManager.dispatchKeyEvent(java.awt.event.KeyEvent)
java.awt.KeyboardFocusManager.dispatchKeyEvent(java.awt.event.KeyEvent)
java.awt.KeyEventDispatcher.dispatchKeyEvent(java.awt.event.KeyEvent)


Occurences of displayName

displayName occurences:
com.sun.tools.attach.VirtualMachineDescriptor.displayName()
java.nio.charset.Charset.displayName()
java.nio.charset.Charset.displayName(java.util.Locale)


Occurences of dispose

dispose occurences:
com.sun.jdi.VirtualMachine.dispose()
com.sun.tools.jconsole.JConsolePlugin.dispose()
java.awt.Component.BltBufferStrategy.dispose()
java.awt.Component.FlipBufferStrategy.dispose()
java.awt.CompositeContext.dispose()
java.awt.Graphics.dispose()
java.awt.im.InputContext.dispose()
java.awt.im.spi.InputMethod.dispose()
java.awt.image.BufferStrategy.dispose()
java.awt.PaintContext.dispose()
java.awt.Window.dispose()
javax.imageio.ImageReader.dispose()
javax.imageio.ImageWriter.dispose()
javax.print.StreamPrintService.dispose()
javax.security.sasl.SaslClient.dispose()
javax.security.sasl.SaslServer.dispose()
javax.swing.DebugGraphics.dispose()
javax.swing.JInternalFrame.dispose()
org.ietf.jgss.GSSContext.dispose()
org.ietf.jgss.GSSCredential.dispose()


Occurences of distance

distance occurences:
java.awt.geom.Point2D.distance(double, double)
java.awt.geom.Point2D.distance(double, double, double, double)
java.awt.geom.Point2D.distance(java.awt.geom.Point2D)


Occurences of distanceSq

distanceSq occurences:
java.awt.geom.Point2D.distanceSq(double, double)
java.awt.geom.Point2D.distanceSq(double, double, double, double)
java.awt.geom.Point2D.distanceSq(java.awt.geom.Point2D)


Occurences of DIV

DIV occurences:
javax.management.DIV
javax.swing.text.html.DIV


Occurences of divide

divide occurences:
java.math.BigDecimal.divide(java.math.BigDecimal)
java.math.BigDecimal.divide(java.math.BigDecimal, int)
java.math.BigDecimal.divide(java.math.BigDecimal, int, int)
java.math.BigDecimal.divide(java.math.BigDecimal, int, java.math.RoundingMode)
java.math.BigDecimal.divide(java.math.BigDecimal, java.math.MathContext)
java.math.BigDecimal.divide(java.math.BigDecimal, java.math.RoundingMode)
java.math.BigInteger.divide(java.math.BigInteger)


Occurences of divideAndRemainder

divideAndRemainder occurences:
java.math.BigDecimal.divideAndRemainder(java.math.BigDecimal)
java.math.BigDecimal.divideAndRemainder(java.math.BigDecimal, java.math.MathContext)
java.math.BigInteger.divideAndRemainder(java.math.BigInteger)


Occurences of dividerSize

dividerSize occurences:
javax.swing.dividerSize
javax.swing.plaf.basic.dividerSize
javax.swing.plaf.basic.dividerSize


Occurences of divideToIntegralValue

divideToIntegralValue occurences:
java.math.BigDecimal.divideToIntegralValue(java.math.BigDecimal)
java.math.BigDecimal.divideToIntegralValue(java.math.BigDecimal, java.math.MathContext)


Occurences of divisionType

divisionType occurences:
javax.sound.midi.divisionType
javax.sound.midi.divisionType


Occurences of dndec

dndec occurences:
java.util.dndec
java.util.dndec


Occurences of doAccessibleAction

doAccessibleAction occurences:
java.awt.Button.AccessibleAWTButton.doAccessibleAction(int)
java.awt.Checkbox.AccessibleAWTCheckbox.doAccessibleAction(int)
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.doAccessibleAction(int)
java.awt.Choice.AccessibleAWTChoice.doAccessibleAction(int)
java.awt.MenuItem.AccessibleAWTMenuItem.doAccessibleAction(int)
javax.accessibility.AccessibleAction.doAccessibleAction(int)
javax.accessibility.AccessibleHyperlink.doAccessibleAction(int)
javax.swing.AbstractButton.AccessibleAbstractButton.doAccessibleAction(int)
javax.swing.JComboBox.AccessibleJComboBox.doAccessibleAction(int)
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.HTMLLink.doAccessibleAction(int)
javax.swing.JSpinner.AccessibleJSpinner.doAccessibleAction(int)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.doAccessibleAction(int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.doAccessibleAction(int)


Occurences of doAs

doAs occurences:
javax.security.auth.Subject.doAs(javax.security.auth.Subject, java.security.PrivilegedAction)
javax.security.auth.Subject.doAs(javax.security.auth.Subject, java.security.PrivilegedExceptionAction)


Occurences of doAsPrivileged

doAsPrivileged occurences:
javax.security.auth.Subject.doAsPrivileged(javax.security.auth.Subject, java.security.PrivilegedAction, java.security.AccessControlContext)
javax.security.auth.Subject.doAsPrivileged(javax.security.auth.Subject, java.security.PrivilegedExceptionAction, java.security.AccessControlContext)


Occurences of Doc

Doc occurences:
com.sun.javadoc.Doc
javax.print.Doc


Occurences of Doclet Overview

Doclet Overview occurences:
Doclet Overview
Doclet Overview


Occurences of doClick

doClick occurences:
javax.swing.AbstractButton.doClick()
javax.swing.AbstractButton.doClick(int)
javax.swing.JMenu.doClick(int)
javax.swing.plaf.basic.BasicMenuItemUI.doClick(javax.swing.MenuSelectionManager)


Occurences of Document

Document occurences:
javax.swing.text.Document
org.w3c.dom.Document


Occurences of DocumentEvent

DocumentEvent occurences:
javax.swing.event.DocumentEvent
org.w3c.dom.events.DocumentEvent


Occurences of doFinal

doFinal occurences:
javax.crypto.Cipher.doFinal()
javax.crypto.Cipher.doFinal(byte[])
javax.crypto.Cipher.doFinal(byte[], int)
javax.crypto.Cipher.doFinal(byte[], int, int)
javax.crypto.Cipher.doFinal(byte[], int, int, byte[])
javax.crypto.Cipher.doFinal(byte[], int, int, byte[], int)
javax.crypto.Cipher.doFinal(java.nio.ByteBuffer, java.nio.ByteBuffer)
javax.crypto.Mac.doFinal()
javax.crypto.Mac.doFinal(byte[])
javax.crypto.Mac.doFinal(byte[], int)


Occurences of doLayout

doLayout occurences:
java.awt.Component.doLayout()
java.awt.Container.doLayout()
java.awt.ScrollPane.doLayout()
javax.swing.JTable.doLayout()
javax.swing.tree.DefaultTreeCellEditor.EditorContainer.doLayout()


Occurences of doLookup

doLookup occurences:
javax.naming.InitialContext.doLookup(java.lang.String)
javax.naming.InitialContext.doLookup(javax.naming.Name)


Occurences of dom

dom occurences:
javax.xml.crypto.dom
javax.xml.crypto.dsig.dom
javax.xml.transform.dom
org.w3c.dom


Occurences of DOMLocator

DOMLocator occurences:
javax.xml.transform.dom.DOMLocator
org.w3c.dom.DOMLocator


Occurences of DOMResult (constructors)

DOMResult (constructors) occurences:
javax.xml.transform.dom.DOMResult()
javax.xml.transform.dom.DOMResult(org.w3c.dom.Node)
javax.xml.transform.dom.DOMResult(org.w3c.dom.Node, java.lang.String)
javax.xml.transform.dom.DOMResult(org.w3c.dom.Node, org.w3c.dom.Node)
javax.xml.transform.dom.DOMResult(org.w3c.dom.Node, org.w3c.dom.Node, java.lang.String)


Occurences of DOMSignContext (constructors)

DOMSignContext (constructors) occurences:
javax.xml.crypto.dsig.dom.DOMSignContext(java.security.Key, org.w3c.dom.Node)
javax.xml.crypto.dsig.dom.DOMSignContext(java.security.Key, org.w3c.dom.Node, org.w3c.dom.Node)
javax.xml.crypto.dsig.dom.DOMSignContext(javax.xml.crypto.KeySelector, org.w3c.dom.Node)
javax.xml.crypto.dsig.dom.DOMSignContext(javax.xml.crypto.KeySelector, org.w3c.dom.Node, org.w3c.dom.Node)


Occurences of DOMSource (constructors)

DOMSource (constructors) occurences:
javax.xml.transform.dom.DOMSource()
javax.xml.transform.dom.DOMSource(org.w3c.dom.Node)
javax.xml.transform.dom.DOMSource(org.w3c.dom.Node, java.lang.String)


Occurences of DOMValidateContext (constructors)

DOMValidateContext (constructors) occurences:
javax.xml.crypto.dsig.dom.DOMValidateContext(java.security.Key, org.w3c.dom.Node)
javax.xml.crypto.dsig.dom.DOMValidateContext(javax.xml.crypto.KeySelector, org.w3c.dom.Node)


Occurences of DONE

DONE occurences:
java.text.DONE
java.text.DONE
javax.swing.DONE


Occurences of done

done occurences:
java.rmi.server.RemoteCall.done()
java.rmi.server.RemoteRef.done(java.rmi.server.RemoteCall)
java.util.concurrent.FutureTask.done()
javax.swing.SwingWorker.done()


Occurences of dontUseGui

dontUseGui occurences:
java.beans.beancontext.BeanContextSupport.dontUseGui()
java.beans.Visibility.dontUseGui()


Occurences of doPrivileged

doPrivileged occurences:
java.security.AccessController.doPrivileged(java.security.PrivilegedAction)
java.security.AccessController.doPrivileged(java.security.PrivilegedAction, java.security.AccessControlContext)
java.security.AccessController.doPrivileged(java.security.PrivilegedExceptionAction)
java.security.AccessController.doPrivileged(java.security.PrivilegedExceptionAction, java.security.AccessControlContext)


Occurences of doPrivilegedWithCombiner

doPrivilegedWithCombiner occurences:
java.security.AccessController.doPrivilegedWithCombiner(java.security.PrivilegedAction)
java.security.AccessController.doPrivilegedWithCombiner(java.security.PrivilegedExceptionAction)


Occurences of DOUBLE

DOUBLE occurences:
com.sun.mirror.type.DOUBLE
java.sql.DOUBLE
javax.lang.model.type.DOUBLE
javax.management.openmbean.DOUBLE


Occurences of Double (constructors)

Double (constructors) occurences:
java.lang.Double(double)
java.lang.Double(java.lang.String)


Occurences of DoubleHolder (constructors)

DoubleHolder (constructors) occurences:
org.omg.CORBA.DoubleHolder()
org.omg.CORBA.DoubleHolder(double)


Occurences of DoubleSeqHolder (constructors)

DoubleSeqHolder (constructors) occurences:
org.omg.CORBA.DoubleSeqHolder()
org.omg.CORBA.DoubleSeqHolder(double[])


Occurences of doubleValue

doubleValue occurences:
com.sun.jdi.PrimitiveValue.doubleValue()
java.lang.Byte.doubleValue()
java.lang.Double.doubleValue()
java.lang.Float.doubleValue()
java.lang.Integer.doubleValue()
java.lang.Long.doubleValue()
java.lang.Number.doubleValue()
java.lang.Short.doubleValue()
java.math.BigDecimal.doubleValue()
java.math.BigInteger.doubleValue()
java.util.concurrent.atomic.AtomicInteger.doubleValue()
java.util.concurrent.atomic.AtomicLong.doubleValue()


Occurences of DOWN

DOWN occurences:
java.awt.DOWN
java.math.DOWN


Occurences of downFocusCycle

downFocusCycle occurences:
java.awt.DefaultKeyboardFocusManager.downFocusCycle(java.awt.Container)
java.awt.KeyboardFocusManager.downFocusCycle()
java.awt.KeyboardFocusManager.downFocusCycle(java.awt.Container)


Occurences of downKey

downKey occurences:
javax.swing.plaf.basic.downKey
javax.swing.plaf.basic.downKey
javax.swing.plaf.basic.downKey


Occurences of DRAFT

DRAFT occurences:
java.awt.DRAFT
javax.print.attribute.standard.DRAFT


Occurences of dragDividerTo

dragDividerTo occurences:
javax.swing.plaf.basic.BasicSplitPaneDivider.dragDividerTo(int)
javax.swing.plaf.basic.BasicSplitPaneUI.dragDividerTo(int)


Occurences of dragDropEnd

dragDropEnd occurences:
java.awt.dnd.DragSourceAdapter.dragDropEnd(java.awt.dnd.DragSourceDropEvent)
java.awt.dnd.DragSourceContext.dragDropEnd(java.awt.dnd.DragSourceDropEvent)
java.awt.dnd.DragSourceListener.dragDropEnd(java.awt.dnd.DragSourceDropEvent)


Occurences of dragEnter

dragEnter occurences:
java.awt.dnd.DragSourceAdapter.dragEnter(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DragSourceContext.dragEnter(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DragSourceListener.dragEnter(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DropTarget.dragEnter(java.awt.dnd.DropTargetDragEvent)
java.awt.dnd.DropTargetAdapter.dragEnter(java.awt.dnd.DropTargetDragEvent)
java.awt.dnd.DropTargetListener.dragEnter(java.awt.dnd.DropTargetDragEvent)


Occurences of dragExit

dragExit occurences:
java.awt.dnd.DragSourceAdapter.dragExit(java.awt.dnd.DragSourceEvent)
java.awt.dnd.DragSourceContext.dragExit(java.awt.dnd.DragSourceEvent)
java.awt.dnd.DragSourceListener.dragExit(java.awt.dnd.DragSourceEvent)
java.awt.dnd.DropTarget.dragExit(java.awt.dnd.DropTargetEvent)
java.awt.dnd.DropTargetAdapter.dragExit(java.awt.dnd.DropTargetEvent)
java.awt.dnd.DropTargetListener.dragExit(java.awt.dnd.DropTargetEvent)


Occurences of dragFrame

dragFrame occurences:
javax.swing.DefaultDesktopManager.dragFrame(javax.swing.JComponent, int, int)
javax.swing.DesktopManager.dragFrame(javax.swing.JComponent, int, int)


Occurences of DragGestureRecognizer (constructors)

DragGestureRecognizer (constructors) occurences:
java.awt.dnd.DragGestureRecognizer(java.awt.dnd.DragSource)
java.awt.dnd.DragGestureRecognizer(java.awt.dnd.DragSource, java.awt.Component)
java.awt.dnd.DragGestureRecognizer(java.awt.dnd.DragSource, java.awt.Component, int)
java.awt.dnd.DragGestureRecognizer(java.awt.dnd.DragSource, java.awt.Component, int, java.awt.dnd.DragGestureListener)


Occurences of dragMouseMoved

dragMouseMoved occurences:
java.awt.dnd.DragSourceAdapter.dragMouseMoved(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DragSourceContext.dragMouseMoved(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DragSourceMotionListener.dragMouseMoved(java.awt.dnd.DragSourceDragEvent)


Occurences of dragOver

dragOver occurences:
java.awt.dnd.DragSourceAdapter.dragOver(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DragSourceContext.dragOver(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DragSourceListener.dragOver(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DropTarget.dragOver(java.awt.dnd.DropTargetDragEvent)
java.awt.dnd.DropTargetAdapter.dragOver(java.awt.dnd.DropTargetDragEvent)
java.awt.dnd.DropTargetListener.dragOver(java.awt.dnd.DropTargetDragEvent)


Occurences of DragSourceDragEvent (constructors)

DragSourceDragEvent (constructors) occurences:
java.awt.dnd.DragSourceDragEvent(java.awt.dnd.DragSourceContext, int, int, int)
java.awt.dnd.DragSourceDragEvent(java.awt.dnd.DragSourceContext, int, int, int, int, int)


Occurences of DragSourceDropEvent (constructors)

DragSourceDropEvent (constructors) occurences:
java.awt.dnd.DragSourceDropEvent(java.awt.dnd.DragSourceContext)
java.awt.dnd.DragSourceDropEvent(java.awt.dnd.DragSourceContext, int, boolean)
java.awt.dnd.DragSourceDropEvent(java.awt.dnd.DragSourceContext, int, boolean, int, int)


Occurences of DragSourceEvent (constructors)

DragSourceEvent (constructors) occurences:
java.awt.dnd.DragSourceEvent(java.awt.dnd.DragSourceContext)
java.awt.dnd.DragSourceEvent(java.awt.dnd.DragSourceContext, int, int)


Occurences of drain

drain occurences:
java.io.ObjectOutputStream.drain()
javax.sound.sampled.DataLine.drain()


Occurences of drainTo

drainTo occurences:
java.util.concurrent.ArrayBlockingQueue.drainTo(java.util.Collection)
java.util.concurrent.ArrayBlockingQueue.drainTo(java.util.Collection, int)
java.util.concurrent.BlockingQueue.drainTo(java.util.Collection)
java.util.concurrent.BlockingQueue.drainTo(java.util.Collection, int)
java.util.concurrent.DelayQueue.drainTo(java.util.Collection)
java.util.concurrent.DelayQueue.drainTo(java.util.Collection, int)
java.util.concurrent.LinkedBlockingDeque.drainTo(java.util.Collection)
java.util.concurrent.LinkedBlockingDeque.drainTo(java.util.Collection, int)
java.util.concurrent.LinkedBlockingQueue.drainTo(java.util.Collection)
java.util.concurrent.LinkedBlockingQueue.drainTo(java.util.Collection, int)
java.util.concurrent.PriorityBlockingQueue.drainTo(java.util.Collection)
java.util.concurrent.PriorityBlockingQueue.drainTo(java.util.Collection, int)
java.util.concurrent.SynchronousQueue.drainTo(java.util.Collection)
java.util.concurrent.SynchronousQueue.drainTo(java.util.Collection, int)


Occurences of draw

draw occurences:
java.awt.font.GraphicAttribute.draw(java.awt.Graphics2D, float, float)
java.awt.font.ImageGraphicAttribute.draw(java.awt.Graphics2D, float, float)
java.awt.font.ShapeGraphicAttribute.draw(java.awt.Graphics2D, float, float)
java.awt.font.TextLayout.draw(java.awt.Graphics2D, float, float)
java.awt.Graphics2D.draw(java.awt.Shape)


Occurences of draw3DRect

draw3DRect occurences:
java.awt.Graphics.draw3DRect(int, int, int, int, boolean)
java.awt.Graphics2D.draw3DRect(int, int, int, int, boolean)
javax.swing.DebugGraphics.draw3DRect(int, int, int, int, boolean)


Occurences of drawArc

drawArc occurences:
java.awt.Graphics.drawArc(int, int, int, int, int, int)
javax.swing.DebugGraphics.drawArc(int, int, int, int, int, int)


Occurences of drawBytes

drawBytes occurences:
java.awt.Graphics.drawBytes(byte[], int, int, int, int)
javax.swing.DebugGraphics.drawBytes(byte[], int, int, int, int)


Occurences of drawChars

drawChars occurences:
java.awt.Graphics.drawChars(char[], int, int, int, int)
javax.swing.DebugGraphics.drawChars(char[], int, int, int, int)


Occurences of drawImage

drawImage occurences:
java.awt.Graphics.drawImage(java.awt.Image, int, int, int, int, int, int, int, int, java.awt.Color, java.awt.image.ImageObserver)
java.awt.Graphics.drawImage(java.awt.Image, int, int, int, int, int, int, int, int, java.awt.image.ImageObserver)
java.awt.Graphics.drawImage(java.awt.Image, int, int, int, int, java.awt.Color, java.awt.image.ImageObserver)
java.awt.Graphics.drawImage(java.awt.Image, int, int, int, int, java.awt.image.ImageObserver)
java.awt.Graphics.drawImage(java.awt.Image, int, int, java.awt.Color, java.awt.image.ImageObserver)
java.awt.Graphics.drawImage(java.awt.Image, int, int, java.awt.image.ImageObserver)
java.awt.Graphics2D.drawImage(java.awt.Image, java.awt.geom.AffineTransform, java.awt.image.ImageObserver)
java.awt.Graphics2D.drawImage(java.awt.image.BufferedImage, java.awt.image.BufferedImageOp, int, int)
javax.swing.DebugGraphics.drawImage(java.awt.Image, int, int, int, int, int, int, int, int, java.awt.Color, java.awt.image.ImageObserver)
javax.swing.DebugGraphics.drawImage(java.awt.Image, int, int, int, int, int, int, int, int, java.awt.image.ImageObserver)
javax.swing.DebugGraphics.drawImage(java.awt.Image, int, int, int, int, java.awt.Color, java.awt.image.ImageObserver)
javax.swing.DebugGraphics.drawImage(java.awt.Image, int, int, int, int, java.awt.image.ImageObserver)
javax.swing.DebugGraphics.drawImage(java.awt.Image, int, int, java.awt.Color, java.awt.image.ImageObserver)
javax.swing.DebugGraphics.drawImage(java.awt.Image, int, int, java.awt.image.ImageObserver)


Occurences of drawLine

drawLine occurences:
java.awt.Graphics.drawLine(int, int, int, int)
javax.swing.DebugGraphics.drawLine(int, int, int, int)
javax.swing.plaf.synth.SynthGraphicsUtils.drawLine(javax.swing.plaf.synth.SynthContext, java.lang.Object, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthGraphicsUtils.drawLine(javax.swing.plaf.synth.SynthContext, java.lang.Object, java.awt.Graphics, int, int, int, int, java.lang.Object)
javax.swing.text.PlainView.drawLine(int, java.awt.Graphics, int, int)
javax.swing.text.WrappedPlainView.drawLine(int, int, java.awt.Graphics, int, int)


Occurences of drawOval

drawOval occurences:
java.awt.Graphics.drawOval(int, int, int, int)
javax.swing.DebugGraphics.drawOval(int, int, int, int)


Occurences of drawPolygon

drawPolygon occurences:
java.awt.Graphics.drawPolygon(int[], int[], int)
java.awt.Graphics.drawPolygon(java.awt.Polygon)
javax.swing.DebugGraphics.drawPolygon(int[], int[], int)


Occurences of drawPolyline

drawPolyline occurences:
java.awt.Graphics.drawPolyline(int[], int[], int)
javax.swing.DebugGraphics.drawPolyline(int[], int[], int)


Occurences of drawRect

drawRect occurences:
java.awt.Graphics.drawRect(int, int, int, int)
javax.swing.DebugGraphics.drawRect(int, int, int, int)


Occurences of drawRoundRect

drawRoundRect occurences:
java.awt.Graphics.drawRoundRect(int, int, int, int, int, int)
javax.swing.DebugGraphics.drawRoundRect(int, int, int, int, int, int)


Occurences of drawSelectedText

drawSelectedText occurences:
javax.swing.text.PasswordView.drawSelectedText(java.awt.Graphics, int, int, int, int)
javax.swing.text.PlainView.drawSelectedText(java.awt.Graphics, int, int, int, int)
javax.swing.text.WrappedPlainView.drawSelectedText(java.awt.Graphics, int, int, int, int)


Occurences of drawString

drawString occurences:
java.awt.Graphics.drawString(java.lang.String, int, int)
java.awt.Graphics.drawString(java.text.AttributedCharacterIterator, int, int)
java.awt.Graphics2D.drawString(java.lang.String, float, float)
java.awt.Graphics2D.drawString(java.lang.String, int, int)
java.awt.Graphics2D.drawString(java.text.AttributedCharacterIterator, float, float)
java.awt.Graphics2D.drawString(java.text.AttributedCharacterIterator, int, int)
javax.swing.DebugGraphics.drawString(java.lang.String, int, int)
javax.swing.DebugGraphics.drawString(java.text.AttributedCharacterIterator, int, int)
javax.swing.plaf.basic.BasicGraphicsUtils.drawString(java.awt.Graphics, java.lang.String, int, int, int)


Occurences of drawUnselectedText

drawUnselectedText occurences:
javax.swing.text.PasswordView.drawUnselectedText(java.awt.Graphics, int, int, int, int)
javax.swing.text.PlainView.drawUnselectedText(java.awt.Graphics, int, int, int, int)
javax.swing.text.WrappedPlainView.drawUnselectedText(java.awt.Graphics, int, int, int, int)


Occurences of DriverManager

DriverManager occurences:
DriverManager
java.sql.DriverManager


Occurences of drop

drop occurences:
java.awt.dnd.DropTarget.drop(java.awt.dnd.DropTargetDropEvent)
java.awt.dnd.DropTargetListener.drop(java.awt.dnd.DropTargetDropEvent)


Occurences of dropActionChanged

dropActionChanged occurences:
java.awt.dnd.DragSourceAdapter.dropActionChanged(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DragSourceContext.dropActionChanged(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DragSourceListener.dropActionChanged(java.awt.dnd.DragSourceDragEvent)
java.awt.dnd.DropTarget.dropActionChanged(java.awt.dnd.DropTargetDragEvent)
java.awt.dnd.DropTargetAdapter.dropActionChanged(java.awt.dnd.DropTargetDragEvent)
java.awt.dnd.DropTargetListener.dropActionChanged(java.awt.dnd.DropTargetDragEvent)


Occurences of dropComplete

dropComplete occurences:
java.awt.dnd.DropTargetContext.dropComplete(boolean)
java.awt.dnd.DropTargetDropEvent.dropComplete(boolean)


Occurences of DropTarget (constructors)

DropTarget (constructors) occurences:
java.awt.dnd.DropTarget()
java.awt.dnd.DropTarget(java.awt.Component, int, java.awt.dnd.DropTargetListener)
java.awt.dnd.DropTarget(java.awt.Component, int, java.awt.dnd.DropTargetListener, boolean)
java.awt.dnd.DropTarget(java.awt.Component, int, java.awt.dnd.DropTargetListener, boolean, java.awt.datatransfer.FlavorMap)
java.awt.dnd.DropTarget(java.awt.Component, java.awt.dnd.DropTargetListener)


Occurences of DropTargetDropEvent (constructors)

DropTargetDropEvent (constructors) occurences:
java.awt.dnd.DropTargetDropEvent(java.awt.dnd.DropTargetContext, java.awt.Point, int, int)
java.awt.dnd.DropTargetDropEvent(java.awt.dnd.DropTargetContext, java.awt.Point, int, int, boolean)


Occurences of DTD

DTD occurences:
javax.swing.text.html.parser.DTD
javax.xml.stream.DTD
javax.xml.stream.events.DTD


Occurences of dtWidth

dtWidth occurences:
java.util.dtWidth
java.util.dtWidth


Occurences of dump

dump occurences:
javax.swing.text.AbstractDocument.dump(java.io.PrintStream)
javax.swing.text.AbstractDocument.AbstractElement.dump(java.io.PrintStream, int)


Occurences of duplicate

duplicate occurences:
java.nio.ByteBuffer.duplicate()
java.nio.CharBuffer.duplicate()
java.nio.DoubleBuffer.duplicate()
java.nio.FloatBuffer.duplicate()
java.nio.IntBuffer.duplicate()
java.nio.LongBuffer.duplicate()
java.nio.ShortBuffer.duplicate()
org.omg.CORBA.portable.Delegate.duplicate(org.omg.CORBA.Object)


Occurences of DuplicateName (constructors)

DuplicateName (constructors) occurences:
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName()
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName(java.lang.String)
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName(java.lang.String, java.lang.String)


Occurences of DuplicateRequestException (constructors)

DuplicateRequestException (constructors) occurences:
com.sun.jdi.request.DuplicateRequestException()
com.sun.jdi.request.DuplicateRequestException(java.lang.String)


Occurences of DynamicImplementation

DynamicImplementation occurences:
org.omg.CORBA.DynamicImplementation
org.omg.PortableServer.DynamicImplementation


Occurences of DynamicImplementation (constructors)

DynamicImplementation (constructors) occurences:
org.omg.CORBA.DynamicImplementation()
org.omg.PortableServer.DynamicImplementation()


Occurences of DynAny

DynAny occurences:
org.omg.CORBA.DynAny
org.omg.DynamicAny.DynAny


Occurences of DynAnyPackage

DynAnyPackage occurences:
org.omg.CORBA.DynAnyPackage
org.omg.DynamicAny.DynAnyPackage


Occurences of DynArray

DynArray occurences:
org.omg.CORBA.DynArray
org.omg.DynamicAny.DynArray


Occurences of DynEnum

DynEnum occurences:
org.omg.CORBA.DynEnum
org.omg.DynamicAny.DynEnum


Occurences of DynFixed

DynFixed occurences:
org.omg.CORBA.DynFixed
org.omg.DynamicAny.DynFixed


Occurences of DynSequence

DynSequence occurences:
org.omg.CORBA.DynSequence
org.omg.DynamicAny.DynSequence


Occurences of DynStruct

DynStruct occurences:
org.omg.CORBA.DynStruct
org.omg.DynamicAny.DynStruct


Occurences of DynUnion

DynUnion occurences:
org.omg.CORBA.DynUnion
org.omg.DynamicAny.DynUnion


Occurences of DynValue

DynValue occurences:
org.omg.CORBA.DynValue
org.omg.DynamicAny.DynValue


Occurences of E

E occurences:
java.awt.E
java.lang.E
java.lang.E
javax.print.attribute.standard.E
javax.print.attribute.standard.E


Occurences of EAST

EAST occurences:
java.awt.EAST
java.awt.EAST
javax.swing.EAST
javax.swing.EAST


Occurences of ECFieldF2m (constructors)

ECFieldF2m (constructors) occurences:
java.security.spec.ECFieldF2m(int)
java.security.spec.ECFieldF2m(int, int[])
java.security.spec.ECFieldF2m(int, java.math.BigInteger)


Occurences of echoCharIsSet

echoCharIsSet occurences:
java.awt.TextField.echoCharIsSet()
javax.swing.JPasswordField.echoCharIsSet()


Occurences of editCellAt

editCellAt occurences:
javax.swing.JTable.editCellAt(int, int)
javax.swing.JTable.editCellAt(int, int, java.util.EventObject)


Occurences of editingCanceled

editingCanceled occurences:
javax.swing.event.CellEditorListener.editingCanceled(javax.swing.event.ChangeEvent)
javax.swing.JTable.editingCanceled(javax.swing.event.ChangeEvent)
javax.swing.JTable.AccessibleJTable.editingCanceled(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicTreeUI.CellEditorHandler.editingCanceled(javax.swing.event.ChangeEvent)


Occurences of editingComponent

editingComponent occurences:
javax.swing.plaf.basic.editingComponent
javax.swing.tree.editingComponent


Occurences of editingRow

editingRow occurences:
javax.swing.editingRow
javax.swing.plaf.basic.editingRow


Occurences of editingStopped

editingStopped occurences:
javax.swing.event.CellEditorListener.editingStopped(javax.swing.event.ChangeEvent)
javax.swing.JTable.editingStopped(javax.swing.event.ChangeEvent)
javax.swing.JTable.AccessibleJTable.editingStopped(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicTreeUI.CellEditorHandler.editingStopped(javax.swing.event.ChangeEvent)


Occurences of editor

editor occurences:
javax.swing.editor
javax.swing.plaf.basic.editor
javax.swing.plaf.basic.editor


Occurences of editorBorderInsets

editorBorderInsets occurences:
javax.swing.plaf.metal.editorBorderInsets
javax.swing.plaf.metal.editorBorderInsets


Occurences of Element

Element occurences:
javax.lang.model.element.Element
javax.swing.text.Element
javax.swing.text.html.parser.Element
javax.xml.bind.Element
org.w3c.dom.Element


Occurences of element

element occurences:
com.sun.javadoc.AnnotationDesc.ElementValuePair.element()
java.lang.annotation.AnnotationTypeMismatchException.element()
java.util.AbstractQueue.element()
java.util.ArrayDeque.element()
java.util.concurrent.BlockingDeque.element()
java.util.concurrent.LinkedBlockingDeque.element()
java.util.Deque.element()
java.util.LinkedList.element()
java.util.Queue.element()
javax.lang.model.element
javax.swing.text.element


Occurences of elementAt

elementAt occurences:
java.util.Vector.elementAt(int)
javax.swing.DefaultListModel.elementAt(int)


Occurences of elementCount

elementCount occurences:
java.util.elementCount
javax.management.monitor.elementCount


Occurences of elementDecl

elementDecl occurences:
org.xml.sax.ext.DeclHandler.elementDecl(java.lang.String, java.lang.String)
org.xml.sax.ext.DefaultHandler2.elementDecl(java.lang.String, java.lang.String)


Occurences of ElementIterator (constructors)

ElementIterator (constructors) occurences:
javax.swing.text.ElementIterator(javax.swing.text.Document)
javax.swing.text.ElementIterator(javax.swing.text.Element)


Occurences of ElementKindVisitor6 (constructors)

ElementKindVisitor6 (constructors) occurences:
javax.lang.model.util.ElementKindVisitor6()
javax.lang.model.util.ElementKindVisitor6(java.lang.Object)
javax.lang.model.util.ElementKindVisitor6(R)


Occurences of elements

elements occurences:
com.sun.javadoc.AnnotationTypeDoc.elements()
java.security.PermissionCollection.elements()
java.security.Permissions.elements()
java.security.Provider.elements()
java.util.concurrent.ConcurrentHashMap.elements()
java.util.Dictionary.elements()
java.util.Hashtable.elements()
java.util.Vector.elements()
javax.swing.DefaultListModel.elements()
javax.swing.text.html.parser.elements


Occurences of ElementScanner6 (constructors)

ElementScanner6 (constructors) occurences:
javax.lang.model.util.ElementScanner6()
javax.lang.model.util.ElementScanner6(java.lang.Object)
javax.lang.model.util.ElementScanner6(R)


Occurences of Ellipse2D.Double (constructors)

Ellipse2D.Double (constructors) occurences:
java.awt.geom.Ellipse2D.Double()
java.awt.geom.Ellipse2D.Double(double, double, double, double)


Occurences of Ellipse2D.Float (constructors)

Ellipse2D.Float (constructors) occurences:
java.awt.geom.Ellipse2D.Float()
java.awt.geom.Ellipse2D.Float(float, float, float, float)


Occurences of EllipticCurve (constructors)

EllipticCurve (constructors) occurences:
java.security.spec.EllipticCurve(java.security.spec.ECField, java.math.BigInteger, java.math.BigInteger)
java.security.spec.EllipticCurve(java.security.spec.ECField, java.math.BigInteger, java.math.BigInteger, byte[])


Occurences of EMPTY

EMPTY occurences:
javax.swing.text.EMPTY
javax.swing.text.html.parser.EMPTY


Occurences of empty

empty occurences:
java.util.Stack.empty()
javax.swing.text.html.parser.ContentModel.empty()


Occurences of EmptyBorder (constructors)

EmptyBorder (constructors) occurences:
javax.swing.border.EmptyBorder(int, int, int, int)
javax.swing.border.EmptyBorder(java.awt.Insets)


Occurences of enable

enable occurences:
com.sun.jdi.request.EventRequest.enable()
java.awt.Component.enable()
java.awt.Component.enable(boolean)
java.awt.MenuItem.enable()
java.awt.MenuItem.enable(boolean)
java.lang.Compiler.enable()
javax.swing.JComponent.enable()


Occurences of ENABLED

ENABLED occurences:
javax.accessibility.ENABLED
javax.swing.ENABLED
javax.swing.plaf.synth.ENABLED


Occurences of enableEvents

enableEvents occurences:
java.awt.Component.enableEvents(long)
java.awt.MenuItem.enableEvents(long)


Occurences of enableInputMethods

enableInputMethods occurences:
java.awt.Component.enableInputMethods(boolean)
java.awt.TextComponent.enableInputMethods(boolean)


Occurences of encode

encode occurences:
java.net.encode
java.net.URLEncoder.encode(java.lang.String)
java.net.URLEncoder.encode(java.lang.String, java.lang.String)
java.nio.charset.Charset.encode(java.lang.String)
java.nio.charset.Charset.encode(java.nio.CharBuffer)
java.nio.charset.CharsetEncoder.encode(java.nio.CharBuffer)
java.nio.charset.CharsetEncoder.encode(java.nio.CharBuffer, java.nio.ByteBuffer, boolean)
java.security.Certificate.encode(java.io.OutputStream)
org.omg.IOP.CodecOperations.encode(org.omg.CORBA.Any)


Occurences of Encoding (constructors)

Encoding (constructors) occurences:
org.omg.IOP.Encoding()
org.omg.IOP.Encoding(short, byte, byte)


Occurences of EncryptedPrivateKeyInfo (constructors)

EncryptedPrivateKeyInfo (constructors) occurences:
javax.crypto.EncryptedPrivateKeyInfo(byte[])
javax.crypto.EncryptedPrivateKeyInfo(java.lang.String, byte[])
javax.crypto.EncryptedPrivateKeyInfo(java.security.AlgorithmParameters, byte[])


Occurences of end

end occurences:
java.awt.PrintJob.end()
java.nio.channels.spi.AbstractInterruptibleChannel.end(boolean)
java.nio.channels.spi.AbstractSelector.end()
java.util.regex.Matcher.end()
java.util.regex.Matcher.end(int)
java.util.regex.MatchResult.end()
java.util.regex.MatchResult.end(int)
java.util.zip.Deflater.end()
java.util.zip.Inflater.end()
javax.swing.text.html.HTMLDocument.HTMLReader.BlockAction.end(javax.swing.text.html.HTML.Tag)
javax.swing.text.html.HTMLDocument.HTMLReader.CharacterAction.end(javax.swing.text.html.HTML.Tag)
javax.swing.text.html.HTMLDocument.HTMLReader.FormAction.end(javax.swing.text.html.HTML.Tag)
javax.swing.text.html.HTMLDocument.HTMLReader.HiddenAction.end(javax.swing.text.html.HTML.Tag)
javax.swing.text.html.HTMLDocument.HTMLReader.ParagraphAction.end(javax.swing.text.html.HTML.Tag)
javax.swing.text.html.HTMLDocument.HTMLReader.PreAction.end(javax.swing.text.html.HTML.Tag)
javax.swing.text.html.HTMLDocument.HTMLReader.TagAction.end(javax.swing.text.html.HTML.Tag)
javax.swing.undo.CompoundEdit.end()
javax.swing.undo.StateEdit.end()
javax.swing.undo.UndoManager.end()
javax.transaction.xa.XAResource.end(javax.transaction.xa.Xid, int)


Occurences of endCDATA

endCDATA occurences:
org.xml.sax.ext.DefaultHandler2.endCDATA()
org.xml.sax.ext.LexicalHandler.endCDATA()


Occurences of ENDCOM

ENDCOM occurences:
java.util.jar.ENDCOM
java.util.jar.ENDCOM
java.util.jar.ENDCOM
java.util.jar.ENDCOM
java.util.zip.ENDCOM
java.util.zip.ENDCOM
java.util.zip.ENDCOM
java.util.zip.ENDCOM


Occurences of endComposition

endComposition occurences:
java.awt.im.InputContext.endComposition()
java.awt.im.spi.InputMethod.endComposition()


Occurences of endDocument

endDocument occurences:
org.xml.sax.ContentHandler.endDocument()
org.xml.sax.DocumentHandler.endDocument()
org.xml.sax.HandlerBase.endDocument()
org.xml.sax.helpers.DefaultHandler.endDocument()
org.xml.sax.helpers.ParserAdapter.endDocument()
org.xml.sax.helpers.XMLFilterImpl.endDocument()
org.xml.sax.helpers.XMLReaderAdapter.endDocument()


Occurences of endDraggingFrame

endDraggingFrame occurences:
javax.swing.DefaultDesktopManager.endDraggingFrame(javax.swing.JComponent)
javax.swing.DesktopManager.endDraggingFrame(javax.swing.JComponent)


Occurences of endDTD

endDTD occurences:
org.xml.sax.ext.DefaultHandler2.endDTD()
org.xml.sax.ext.LexicalHandler.endDTD()


Occurences of endElement

endElement occurences:
org.xml.sax.ContentHandler.endElement(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.DocumentHandler.endElement(java.lang.String)
org.xml.sax.HandlerBase.endElement(java.lang.String)
org.xml.sax.helpers.DefaultHandler.endElement(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.helpers.ParserAdapter.endElement(java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.endElement(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.helpers.XMLReaderAdapter.endElement(java.lang.String, java.lang.String, java.lang.String)


Occurences of endEntity

endEntity occurences:
org.xml.sax.ext.DefaultHandler2.endEntity(java.lang.String)
org.xml.sax.ext.LexicalHandler.endEntity(java.lang.String)


Occurences of ENDHDR

ENDHDR occurences:
java.util.jar.ENDHDR
java.util.jar.ENDHDR
java.util.jar.ENDHDR
java.util.jar.ENDHDR
java.util.zip.ENDHDR
java.util.zip.ENDHDR
java.util.zip.ENDHDR
java.util.zip.ENDHDR


Occurences of endIndex

endIndex occurences:
javax.accessibility.endIndex
javax.accessibility.endIndex


Occurences of ENDOFF

ENDOFF occurences:
java.util.jar.ENDOFF
java.util.jar.ENDOFF
java.util.jar.ENDOFF
java.util.jar.ENDOFF
java.util.zip.ENDOFF
java.util.zip.ENDOFF
java.util.zip.ENDOFF
java.util.zip.ENDOFF


Occurences of endPrefixMapping

endPrefixMapping occurences:
org.xml.sax.ContentHandler.endPrefixMapping(java.lang.String)
org.xml.sax.helpers.DefaultHandler.endPrefixMapping(java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.endPrefixMapping(java.lang.String)
org.xml.sax.helpers.XMLReaderAdapter.endPrefixMapping(java.lang.String)


Occurences of endResizingFrame

endResizingFrame occurences:
javax.swing.DefaultDesktopManager.endResizingFrame(javax.swing.JComponent)
javax.swing.DesktopManager.endResizingFrame(javax.swing.JComponent)


Occurences of ENDSIG

ENDSIG occurences:
java.util.jar.ENDSIG
java.util.jar.ENDSIG
java.util.jar.ENDSIG
java.util.jar.ENDSIG
java.util.zip.ENDSIG
java.util.zip.ENDSIG
java.util.zip.ENDSIG
java.util.zip.ENDSIG


Occurences of ENDSIZ

ENDSIZ occurences:
java.util.jar.ENDSIZ
java.util.jar.ENDSIZ
java.util.jar.ENDSIZ
java.util.jar.ENDSIZ
java.util.zip.ENDSIZ
java.util.zip.ENDSIZ
java.util.zip.ENDSIZ
java.util.zip.ENDSIZ


Occurences of ENDSUB

ENDSUB occurences:
java.util.jar.ENDSUB
java.util.jar.ENDSUB
java.util.jar.ENDSUB
java.util.jar.ENDSUB
java.util.zip.ENDSUB
java.util.zip.ENDSUB
java.util.zip.ENDSUB
java.util.zip.ENDSUB


Occurences of endsWith

endsWith occurences:
java.lang.String.endsWith(java.lang.String)
javax.naming.CompositeName.endsWith(javax.naming.Name)
javax.naming.CompoundName.endsWith(javax.naming.Name)
javax.naming.ldap.LdapName.endsWith(java.util.List)
javax.naming.ldap.LdapName.endsWith(javax.naming.Name)
javax.naming.Name.endsWith(javax.naming.Name)


Occurences of endTag

endTag occurences:
javax.swing.text.html.HTMLWriter.endTag(javax.swing.text.Element)
javax.swing.text.html.parser.Parser.endTag(boolean)


Occurences of ENDTAG

ENDTAG occurences:
javax.swing.text.html.ENDTAG
javax.swing.text.html.parser.ENDTAG


Occurences of ENDTOT

ENDTOT occurences:
java.util.jar.ENDTOT
java.util.jar.ENDTOT
java.util.jar.ENDTOT
java.util.jar.ENDTOT
java.util.zip.ENDTOT
java.util.zip.ENDTOT
java.util.zip.ENDTOT
java.util.zip.ENDTOT


Occurences of end_value

end_value occurences:
org.omg.CORBA.portable.ValueInputStream.end_value()
org.omg.CORBA.portable.ValueOutputStream.end_value()


Occurences of engineCreateSSLEngine

engineCreateSSLEngine occurences:
javax.net.ssl.SSLContextSpi.engineCreateSSLEngine()
javax.net.ssl.SSLContextSpi.engineCreateSSLEngine(java.lang.String, int)


Occurences of engineDigest

engineDigest occurences:
java.security.MessageDigestSpi.engineDigest()
java.security.MessageDigestSpi.engineDigest(byte[], int, int)


Occurences of engineDoFinal

engineDoFinal occurences:
javax.crypto.CipherSpi.engineDoFinal(byte[], int, int)
javax.crypto.CipherSpi.engineDoFinal(byte[], int, int, byte[], int)
javax.crypto.CipherSpi.engineDoFinal(java.nio.ByteBuffer, java.nio.ByteBuffer)
javax.crypto.MacSpi.engineDoFinal()


Occurences of engineGenerateCertPath

engineGenerateCertPath occurences:
java.security.cert.CertificateFactorySpi.engineGenerateCertPath(java.io.InputStream)
java.security.cert.CertificateFactorySpi.engineGenerateCertPath(java.io.InputStream, java.lang.String)
java.security.cert.CertificateFactorySpi.engineGenerateCertPath(java.util.List)


Occurences of engineGenerateSecret

engineGenerateSecret occurences:
javax.crypto.KeyAgreementSpi.engineGenerateSecret()
javax.crypto.KeyAgreementSpi.engineGenerateSecret(byte[], int)
javax.crypto.KeyAgreementSpi.engineGenerateSecret(java.lang.String)
javax.crypto.SecretKeyFactorySpi.engineGenerateSecret(java.security.spec.KeySpec)


Occurences of engineGenExemptionBlob

engineGenExemptionBlob occurences:
javax.crypto.ExemptionMechanismSpi.engineGenExemptionBlob()
javax.crypto.ExemptionMechanismSpi.engineGenExemptionBlob(byte[], int)


Occurences of engineGetEncoded

engineGetEncoded occurences:
java.security.AlgorithmParametersSpi.engineGetEncoded()
java.security.AlgorithmParametersSpi.engineGetEncoded(java.lang.String)


Occurences of engineGetKeySpec

engineGetKeySpec occurences:
java.security.KeyFactorySpi.engineGetKeySpec(java.security.Key, java.lang.Class)
javax.crypto.SecretKeyFactorySpi.engineGetKeySpec(javax.crypto.SecretKey, java.lang.Class)


Occurences of engineGetOutputSize

engineGetOutputSize occurences:
javax.crypto.CipherSpi.engineGetOutputSize(int)
javax.crypto.ExemptionMechanismSpi.engineGetOutputSize(int)


Occurences of engineGetParameters

engineGetParameters occurences:
java.security.SignatureSpi.engineGetParameters()
javax.crypto.CipherSpi.engineGetParameters()


Occurences of engineGetPermissions

engineGetPermissions occurences:
java.security.PolicySpi.engineGetPermissions(java.security.CodeSource)
java.security.PolicySpi.engineGetPermissions(java.security.ProtectionDomain)


Occurences of engineInit

engineInit occurences:
java.security.AlgorithmParameterGeneratorSpi.engineInit(int, java.security.SecureRandom)
java.security.AlgorithmParameterGeneratorSpi.engineInit(java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
java.security.AlgorithmParametersSpi.engineInit(byte[])
java.security.AlgorithmParametersSpi.engineInit(byte[], java.lang.String)
java.security.AlgorithmParametersSpi.engineInit(java.security.spec.AlgorithmParameterSpec)
javax.crypto.CipherSpi.engineInit(int, java.security.Key, java.security.AlgorithmParameters, java.security.SecureRandom)
javax.crypto.CipherSpi.engineInit(int, java.security.Key, java.security.SecureRandom)
javax.crypto.CipherSpi.engineInit(int, java.security.Key, java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
javax.crypto.ExemptionMechanismSpi.engineInit(java.security.Key)
javax.crypto.ExemptionMechanismSpi.engineInit(java.security.Key, java.security.AlgorithmParameters)
javax.crypto.ExemptionMechanismSpi.engineInit(java.security.Key, java.security.spec.AlgorithmParameterSpec)
javax.crypto.KeyAgreementSpi.engineInit(java.security.Key, java.security.SecureRandom)
javax.crypto.KeyAgreementSpi.engineInit(java.security.Key, java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
javax.crypto.KeyGeneratorSpi.engineInit(int, java.security.SecureRandom)
javax.crypto.KeyGeneratorSpi.engineInit(java.security.SecureRandom)
javax.crypto.KeyGeneratorSpi.engineInit(java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
javax.crypto.MacSpi.engineInit(java.security.Key, java.security.spec.AlgorithmParameterSpec)
javax.net.ssl.KeyManagerFactorySpi.engineInit(java.security.KeyStore, char[])
javax.net.ssl.KeyManagerFactorySpi.engineInit(javax.net.ssl.ManagerFactoryParameters)
javax.net.ssl.SSLContextSpi.engineInit(javax.net.ssl.KeyManager[], javax.net.ssl.TrustManager[], java.security.SecureRandom)
javax.net.ssl.TrustManagerFactorySpi.engineInit(java.security.KeyStore)
javax.net.ssl.TrustManagerFactorySpi.engineInit(javax.net.ssl.ManagerFactoryParameters)


Occurences of engineInitSign

engineInitSign occurences:
java.security.SignatureSpi.engineInitSign(java.security.PrivateKey)
java.security.SignatureSpi.engineInitSign(java.security.PrivateKey, java.security.SecureRandom)


Occurences of engineLoad

engineLoad occurences:
java.security.KeyStoreSpi.engineLoad(java.io.InputStream, char[])
java.security.KeyStoreSpi.engineLoad(java.security.KeyStore.LoadStoreParameter)


Occurences of engineRefresh

engineRefresh occurences:
java.security.PolicySpi.engineRefresh()
javax.security.auth.login.ConfigurationSpi.engineRefresh()


Occurences of engineReset

engineReset occurences:
java.security.MessageDigestSpi.engineReset()
javax.crypto.MacSpi.engineReset()


Occurences of engineSetKeyEntry

engineSetKeyEntry occurences:
java.security.KeyStoreSpi.engineSetKeyEntry(java.lang.String, byte[], java.security.cert.Certificate[])
java.security.KeyStoreSpi.engineSetKeyEntry(java.lang.String, java.security.Key, char[], java.security.cert.Certificate[])


Occurences of engineSetParameter

engineSetParameter occurences:
java.security.SignatureSpi.engineSetParameter(java.lang.String, java.lang.Object)
java.security.SignatureSpi.engineSetParameter(java.security.spec.AlgorithmParameterSpec)


Occurences of engineSign

engineSign occurences:
java.security.SignatureSpi.engineSign()
java.security.SignatureSpi.engineSign(byte[], int, int)


Occurences of engineStore

engineStore occurences:
java.security.KeyStoreSpi.engineStore(java.io.OutputStream, char[])
java.security.KeyStoreSpi.engineStore(java.security.KeyStore.LoadStoreParameter)


Occurences of engineTranslateKey

engineTranslateKey occurences:
java.security.KeyFactorySpi.engineTranslateKey(java.security.Key)
javax.crypto.SecretKeyFactorySpi.engineTranslateKey(javax.crypto.SecretKey)


Occurences of engineUpdate

engineUpdate occurences:
java.security.MessageDigestSpi.engineUpdate(byte)
java.security.MessageDigestSpi.engineUpdate(byte[], int, int)
java.security.MessageDigestSpi.engineUpdate(java.nio.ByteBuffer)
java.security.SignatureSpi.engineUpdate(byte)
java.security.SignatureSpi.engineUpdate(byte[], int, int)
java.security.SignatureSpi.engineUpdate(java.nio.ByteBuffer)
javax.crypto.CipherSpi.engineUpdate(byte[], int, int)
javax.crypto.CipherSpi.engineUpdate(byte[], int, int, byte[], int)
javax.crypto.CipherSpi.engineUpdate(java.nio.ByteBuffer, java.nio.ByteBuffer)
javax.crypto.MacSpi.engineUpdate(byte)
javax.crypto.MacSpi.engineUpdate(byte[], int, int)
javax.crypto.MacSpi.engineUpdate(java.nio.ByteBuffer)


Occurences of engineVerify

engineVerify occurences:
java.security.SignatureSpi.engineVerify(byte[])
java.security.SignatureSpi.engineVerify(byte[], int, int)


Occurences of enhancements

enhancements occurences:
enhancements
enhancements


Occurences of enqueueKeyEvents

enqueueKeyEvents occurences:
java.awt.DefaultKeyboardFocusManager.enqueueKeyEvents(long, java.awt.Component)
java.awt.KeyboardFocusManager.enqueueKeyEvents(long, java.awt.Component)


Occurences of ensureCapacity

ensureCapacity occurences:
java.lang.StringBuffer.ensureCapacity(int)
java.lang.StringBuilder.ensureCapacity(int)
java.util.ArrayList.ensureCapacity(int)
java.util.Vector.ensureCapacity(int)
javax.swing.DefaultListModel.ensureCapacity(int)


Occurences of ensureFileIsVisible

ensureFileIsVisible occurences:
javax.swing.JFileChooser.ensureFileIsVisible(java.io.File)
javax.swing.plaf.basic.BasicFileChooserUI.ensureFileIsVisible(javax.swing.JFileChooser, java.io.File)
javax.swing.plaf.FileChooserUI.ensureFileIsVisible(javax.swing.JFileChooser, java.io.File)
javax.swing.plaf.metal.MetalFileChooserUI.ensureFileIsVisible(javax.swing.JFileChooser, java.io.File)
javax.swing.plaf.multi.MultiFileChooserUI.ensureFileIsVisible(javax.swing.JFileChooser, java.io.File)


Occurences of ENTER

ENTER occurences:
com.sun.source.util.ENTER
java.awt.dnd.ENTER
java.awt.ENTER


Occurences of entering

entering occurences:
java.util.logging.Logger.entering(java.lang.String, java.lang.String)
java.util.logging.Logger.entering(java.lang.String, java.lang.String, java.lang.Object)
java.util.logging.Logger.entering(java.lang.String, java.lang.String, java.lang.Object[])


Occurences of Entity

Entity occurences:
javax.swing.text.html.parser.Entity
org.w3c.dom.Entity


Occurences of EntityReference

EntityReference occurences:
javax.xml.stream.events.EntityReference
org.w3c.dom.EntityReference


Occurences of entries

entries occurences:
java.security.acl.Acl.entries()
java.util.jar.JarFile.entries()
java.util.zip.ZipFile.entries()


Occurences of entrySet

entrySet occurences:
java.awt.RenderingHints.entrySet()
java.security.Provider.entrySet()
java.util.AbstractMap.entrySet()
java.util.concurrent.ConcurrentHashMap.entrySet()
java.util.concurrent.ConcurrentSkipListMap.entrySet()
java.util.EnumMap.entrySet()
java.util.HashMap.entrySet()
java.util.Hashtable.entrySet()
java.util.IdentityHashMap.entrySet()
java.util.jar.Attributes.entrySet()
java.util.Map.entrySet()
java.util.SortedMap.entrySet()
java.util.TreeMap.entrySet()
java.util.WeakHashMap.entrySet()
javax.management.openmbean.TabularDataSupport.entrySet()
javax.script.SimpleBindings.entrySet()


Occurences of enumerate

enumerate occurences:
java.lang.Thread.enumerate(java.lang.Thread[])
java.lang.ThreadGroup.enumerate(java.lang.ThreadGroup[])
java.lang.ThreadGroup.enumerate(java.lang.ThreadGroup[], boolean)
java.lang.ThreadGroup.enumerate(java.lang.Thread[])
java.lang.ThreadGroup.enumerate(java.lang.Thread[], boolean)


Occurences of EnumMap (constructors)

EnumMap (constructors) occurences:
java.util.EnumMap(java.lang.Class)
java.util.EnumMap(java.util.EnumMap)
java.util.EnumMap(java.util.Map)


Occurences of enum_constant_detail

enum_constant_detail occurences:
com.sun.javadoc.enum_constant_detail
com.sun.mirror.apt.enum_constant_detail
com.sun.mirror.declaration.enum_constant_detail
com.sun.mirror.type.enum_constant_detail
com.sun.source.tree.enum_constant_detail
com.sun.source.util.enum_constant_detail
com.sun.tools.jconsole.enum_constant_detail
java.awt.enum_constant_detail
java.awt.enum_constant_detail
java.awt.enum_constant_detail
java.awt.enum_constant_detail
java.awt.enum_constant_detail
java.awt.enum_constant_detail
java.awt.enum_constant_detail
java.lang.annotation.enum_constant_detail
java.lang.annotation.enum_constant_detail
java.lang.enum_constant_detail
java.lang.management.enum_constant_detail
java.math.enum_constant_detail
java.net.enum_constant_detail
java.net.enum_constant_detail
java.security.enum_constant_detail
java.sql.enum_constant_detail
java.sql.enum_constant_detail
java.text.enum_constant_detail
java.util.concurrent.enum_constant_detail
java.util.enum_constant_detail
javax.annotation.enum_constant_detail
javax.jws.enum_constant_detail
javax.jws.soap.enum_constant_detail
javax.jws.soap.enum_constant_detail
javax.jws.soap.enum_constant_detail
javax.lang.model.element.enum_constant_detail
javax.lang.model.element.enum_constant_detail
javax.lang.model.element.enum_constant_detail
javax.lang.model.enum_constant_detail
javax.lang.model.type.enum_constant_detail
javax.net.ssl.enum_constant_detail
javax.net.ssl.enum_constant_detail
javax.swing.enum_constant_detail
javax.swing.enum_constant_detail
javax.swing.enum_constant_detail
javax.swing.enum_constant_detail
javax.swing.enum_constant_detail
javax.swing.enum_constant_detail
javax.swing.enum_constant_detail
javax.swing.event.enum_constant_detail
javax.swing.text.html.enum_constant_detail
javax.tools.enum_constant_detail
javax.tools.enum_constant_detail
javax.tools.enum_constant_detail
javax.xml.bind.annotation.enum_constant_detail
javax.xml.bind.annotation.enum_constant_detail
javax.xml.bind.annotation.enum_constant_detail
javax.xml.ws.enum_constant_detail
javax.xml.ws.handler.enum_constant_detail


Occurences of enum_constant_summary

enum_constant_summary occurences:
com.sun.javadoc.enum_constant_summary
com.sun.mirror.apt.enum_constant_summary
com.sun.mirror.declaration.enum_constant_summary
com.sun.mirror.type.enum_constant_summary
com.sun.source.tree.enum_constant_summary
com.sun.source.util.enum_constant_summary
com.sun.tools.jconsole.enum_constant_summary
java.awt.enum_constant_summary
java.awt.enum_constant_summary
java.awt.enum_constant_summary
java.awt.enum_constant_summary
java.awt.enum_constant_summary
java.awt.enum_constant_summary
java.awt.enum_constant_summary
java.lang.annotation.enum_constant_summary
java.lang.annotation.enum_constant_summary
java.lang.enum_constant_summary
java.lang.management.enum_constant_summary
java.math.enum_constant_summary
java.net.enum_constant_summary
java.net.enum_constant_summary
java.security.enum_constant_summary
java.sql.enum_constant_summary
java.sql.enum_constant_summary
java.text.enum_constant_summary
java.util.concurrent.enum_constant_summary
java.util.enum_constant_summary
javax.annotation.enum_constant_summary
javax.jws.enum_constant_summary
javax.jws.soap.enum_constant_summary
javax.jws.soap.enum_constant_summary
javax.jws.soap.enum_constant_summary
javax.lang.model.element.enum_constant_summary
javax.lang.model.element.enum_constant_summary
javax.lang.model.element.enum_constant_summary
javax.lang.model.enum_constant_summary
javax.lang.model.type.enum_constant_summary
javax.net.ssl.enum_constant_summary
javax.net.ssl.enum_constant_summary
javax.swing.enum_constant_summary
javax.swing.enum_constant_summary
javax.swing.enum_constant_summary
javax.swing.enum_constant_summary
javax.swing.enum_constant_summary
javax.swing.enum_constant_summary
javax.swing.enum_constant_summary
javax.swing.event.enum_constant_summary
javax.swing.text.html.enum_constant_summary
javax.tools.enum_constant_summary
javax.tools.enum_constant_summary
javax.tools.enum_constant_summary
javax.xml.bind.annotation.enum_constant_summary
javax.xml.bind.annotation.enum_constant_summary
javax.xml.bind.annotation.enum_constant_summary
javax.xml.ws.enum_constant_summary
javax.xml.ws.handler.enum_constant_summary


Occurences of environment

environment occurences:
java.lang.ProcessBuilder.environment()
javax.naming.environment


Occurences of EOFException (constructors)

EOFException (constructors) occurences:
java.io.EOFException()
java.io.EOFException(java.lang.String)


Occurences of equal

equal occurences:
org.omg.CORBA.Any.equal(org.omg.CORBA.Any)
org.omg.CORBA.TypeCode.equal(org.omg.CORBA.TypeCode)
org.omg.DynamicAny.DynAnyOperations.equal(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynAnyStub.equal(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynArrayStub.equal(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynEnumStub.equal(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynFixedStub.equal(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynSequenceStub.equal(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynStructStub.equal(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynUnionStub.equal(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynValueStub.equal(org.omg.DynamicAny.DynAny)


Occurences of EQUAL

EQUAL occurences:
javax.swing.EQUAL
javax.xml.datatype.EQUAL


Occurences of equals

equals occurences:
com.sun.jdi.BooleanValue.equals(java.lang.Object)
com.sun.jdi.ByteValue.equals(java.lang.Object)
com.sun.jdi.CharValue.equals(java.lang.Object)
com.sun.jdi.DoubleValue.equals(java.lang.Object)
com.sun.jdi.Field.equals(java.lang.Object)
com.sun.jdi.FloatValue.equals(java.lang.Object)
com.sun.jdi.IntegerValue.equals(java.lang.Object)
com.sun.jdi.LocalVariable.equals(java.lang.Object)
com.sun.jdi.Location.equals(java.lang.Object)
com.sun.jdi.LongValue.equals(java.lang.Object)
com.sun.jdi.Method.equals(java.lang.Object)
com.sun.jdi.ObjectReference.equals(java.lang.Object)
com.sun.jdi.ReferenceType.equals(java.lang.Object)
com.sun.jdi.ShortValue.equals(java.lang.Object)
com.sun.jdi.VoidValue.equals(java.lang.Object)
com.sun.mirror.declaration.Declaration.equals(java.lang.Object)
com.sun.mirror.type.TypeMirror.equals(java.lang.Object)
com.sun.tools.attach.VirtualMachine.equals(java.lang.Object)
com.sun.tools.attach.VirtualMachineDescriptor.equals(java.lang.Object)
java.awt.AlphaComposite.equals(java.lang.Object)
java.awt.AWTKeyStroke.equals(java.lang.Object)
java.awt.BasicStroke.equals(java.lang.Object)
java.awt.Color.equals(java.lang.Object)
java.awt.datatransfer.DataFlavor.equals(java.awt.datatransfer.DataFlavor)
java.awt.datatransfer.DataFlavor.equals(java.lang.Object)
java.awt.datatransfer.DataFlavor.equals(java.lang.String)
java.awt.Dimension.equals(java.lang.Object)
java.awt.DisplayMode.equals(java.awt.DisplayMode)
java.awt.DisplayMode.equals(java.lang.Object)
java.awt.Font.equals(java.lang.Object)
java.awt.font.FontRenderContext.equals(java.awt.font.FontRenderContext)
java.awt.font.FontRenderContext.equals(java.lang.Object)
java.awt.font.GlyphVector.equals(java.awt.font.GlyphVector)
java.awt.font.ImageGraphicAttribute.equals(java.awt.font.ImageGraphicAttribute)
java.awt.font.ImageGraphicAttribute.equals(java.lang.Object)
java.awt.font.NumericShaper.equals(java.lang.Object)
java.awt.font.ShapeGraphicAttribute.equals(java.awt.font.ShapeGraphicAttribute)
java.awt.font.ShapeGraphicAttribute.equals(java.lang.Object)
java.awt.font.TextHitInfo.equals(java.awt.font.TextHitInfo)
java.awt.font.TextHitInfo.equals(java.lang.Object)
java.awt.font.TextLayout.equals(java.awt.font.TextLayout)
java.awt.font.TextLayout.equals(java.lang.Object)
java.awt.font.TransformAttribute.equals(java.lang.Object)
java.awt.geom.AffineTransform.equals(java.lang.Object)
java.awt.geom.Arc2D.equals(java.lang.Object)
java.awt.geom.Area.equals(java.awt.geom.Area)
java.awt.geom.Ellipse2D.equals(java.lang.Object)
java.awt.geom.Point2D.equals(java.lang.Object)
java.awt.geom.Rectangle2D.equals(java.lang.Object)
java.awt.geom.RoundRectangle2D.equals(java.lang.Object)
java.awt.image.ColorModel.equals(java.lang.Object)
java.awt.image.ComponentColorModel.equals(java.lang.Object)
java.awt.image.ComponentSampleModel.equals(java.lang.Object)
java.awt.image.MultiPixelPackedSampleModel.equals(java.lang.Object)
java.awt.image.PackedColorModel.equals(java.lang.Object)
java.awt.image.SinglePixelPackedSampleModel.equals(java.lang.Object)
java.awt.Insets.equals(java.lang.Object)
java.awt.JobAttributes.equals(java.lang.Object)
java.awt.MenuShortcut.equals(java.awt.MenuShortcut)
java.awt.MenuShortcut.equals(java.lang.Object)
java.awt.PageAttributes.equals(java.lang.Object)
java.awt.Point.equals(java.lang.Object)
java.awt.Rectangle.equals(java.lang.Object)
java.awt.RenderingHints.equals(java.lang.Object)
java.awt.RenderingHints.Key.equals(java.lang.Object)
java.beans.IndexedPropertyDescriptor.equals(java.lang.Object)
java.beans.PropertyDescriptor.equals(java.lang.Object)
java.io.File.equals(java.lang.Object)
java.io.FilePermission.equals(java.lang.Object)
java.lang.annotation.Annotation.equals(java.lang.Object)
java.lang.Boolean.equals(java.lang.Object)
java.lang.Byte.equals(java.lang.Object)
java.lang.Character.equals(java.lang.Object)
java.lang.Character.Subset.equals(java.lang.Object)
java.lang.Double.equals(java.lang.Object)
java.lang.Enum.equals(java.lang.Object)
java.lang.Float.equals(java.lang.Object)
java.lang.Integer.equals(java.lang.Object)
java.lang.Long.equals(java.lang.Object)
java.lang.Object.equals(java.lang.Object)
java.lang.reflect.Constructor.equals(java.lang.Object)
java.lang.reflect.Field.equals(java.lang.Object)
java.lang.reflect.Method.equals(java.lang.Object)
java.lang.Short.equals(java.lang.Object)
java.lang.StackTraceElement.equals(java.lang.Object)
java.lang.String.equals(java.lang.Object)
java.math.BigDecimal.equals(java.lang.Object)
java.math.BigInteger.equals(java.lang.Object)
java.math.MathContext.equals(java.lang.Object)
java.net.HttpCookie.equals(java.lang.Object)
java.net.Inet4Address.equals(java.lang.Object)
java.net.Inet6Address.equals(java.lang.Object)
java.net.InetAddress.equals(java.lang.Object)
java.net.InetSocketAddress.equals(java.lang.Object)
java.net.InterfaceAddress.equals(java.lang.Object)
java.net.NetworkInterface.equals(java.lang.Object)
java.net.Proxy.equals(java.lang.Object)
java.net.SocketPermission.equals(java.lang.Object)
java.net.URI.equals(java.lang.Object)
java.net.URL.equals(java.lang.Object)
java.net.URLStreamHandler.equals(java.net.URL, java.net.URL)
java.nio.ByteBuffer.equals(java.lang.Object)
java.nio.CharBuffer.equals(java.lang.Object)
java.nio.charset.Charset.equals(java.lang.Object)
java.nio.DoubleBuffer.equals(java.lang.Object)
java.nio.FloatBuffer.equals(java.lang.Object)
java.nio.IntBuffer.equals(java.lang.Object)
java.nio.LongBuffer.equals(java.lang.Object)
java.nio.ShortBuffer.equals(java.lang.Object)
java.rmi.activation.ActivationDesc.equals(java.lang.Object)
java.rmi.activation.ActivationGroupDesc.equals(java.lang.Object)
java.rmi.activation.ActivationGroupDesc.CommandEnvironment.equals(java.lang.Object)
java.rmi.activation.ActivationGroupID.equals(java.lang.Object)
java.rmi.activation.ActivationID.equals(java.lang.Object)
java.rmi.dgc.VMID.equals(java.lang.Object)
java.rmi.MarshalledObject.equals(java.lang.Object)
java.rmi.server.ObjID.equals(java.lang.Object)
java.rmi.server.RemoteObject.equals(java.lang.Object)
java.rmi.server.UID.equals(java.lang.Object)
java.security.AccessControlContext.equals(java.lang.Object)
java.security.acl.Permission.equals(java.lang.Object)
java.security.AllPermission.equals(java.lang.Object)
java.security.BasicPermission.equals(java.lang.Object)
java.security.cert.Certificate.equals(java.lang.Object)
java.security.cert.CertPath.equals(java.lang.Object)
java.security.cert.X509CRL.equals(java.lang.Object)
java.security.cert.X509CRLEntry.equals(java.lang.Object)
java.security.CodeSigner.equals(java.lang.Object)
java.security.CodeSource.equals(java.lang.Object)
java.security.Identity.equals(java.lang.Object)
java.security.Permission.equals(java.lang.Object)
java.security.Principal.equals(java.lang.Object)
java.security.spec.ECFieldF2m.equals(java.lang.Object)
java.security.spec.ECFieldFp.equals(java.lang.Object)
java.security.spec.ECPoint.equals(java.lang.Object)
java.security.spec.EllipticCurve.equals(java.lang.Object)
java.security.Timestamp.equals(java.lang.Object)
java.security.UnresolvedPermission.equals(java.lang.Object)
java.sql.RowId.equals(java.lang.Object)
java.sql.Timestamp.equals(java.lang.Object)
java.sql.Timestamp.equals(java.sql.Timestamp)
java.text.AttributedCharacterIterator.Attribute.equals(java.lang.Object)
java.text.ChoiceFormat.equals(java.lang.Object)
java.text.Collator.equals(java.lang.Object)
java.text.Collator.equals(java.lang.String, java.lang.String)
java.text.DateFormat.equals(java.lang.Object)
java.text.DateFormatSymbols.equals(java.lang.Object)
java.text.DecimalFormat.equals(java.lang.Object)
java.text.DecimalFormatSymbols.equals(java.lang.Object)
java.text.FieldPosition.equals(java.lang.Object)
java.text.MessageFormat.equals(java.lang.Object)
java.text.NumberFormat.equals(java.lang.Object)
java.text.ParsePosition.equals(java.lang.Object)
java.text.RuleBasedCollator.equals(java.lang.Object)
java.text.SimpleDateFormat.equals(java.lang.Object)
java.text.StringCharacterIterator.equals(java.lang.Object)
java.util.AbstractList.equals(java.lang.Object)
java.util.AbstractMap.equals(java.lang.Object)
java.util.AbstractMap.SimpleEntry.equals(java.lang.Object)
java.util.AbstractMap.SimpleImmutableEntry.equals(java.lang.Object)
java.util.AbstractSet.equals(java.lang.Object)
java.util.Arrays.equals(boolean[], boolean[])
java.util.Arrays.equals(byte[], byte[])
java.util.Arrays.equals(char[], char[])
java.util.Arrays.equals(double[], double[])
java.util.Arrays.equals(float[], float[])
java.util.Arrays.equals(int[], int[])
java.util.Arrays.equals(java.lang.Object[], java.lang.Object[])
java.util.Arrays.equals(long[], long[])
java.util.Arrays.equals(short[], short[])
java.util.BitSet.equals(java.lang.Object)
java.util.Calendar.equals(java.lang.Object)
java.util.Collection.equals(java.lang.Object)
java.util.Comparator.equals(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.equals(java.lang.Object)
java.util.concurrent.ConcurrentSkipListSet.equals(java.lang.Object)
java.util.concurrent.CopyOnWriteArrayList.equals(java.lang.Object)
java.util.concurrent.CopyOnWriteArraySet.equals(java.lang.Object)
java.util.Date.equals(java.lang.Object)
java.util.EnumMap.equals(java.lang.Object)
java.util.GregorianCalendar.equals(java.lang.Object)
java.util.Hashtable.equals(java.lang.Object)
java.util.IdentityHashMap.equals(java.lang.Object)
java.util.jar.Attributes.equals(java.lang.Object)
java.util.jar.Attributes.Name.equals(java.lang.Object)
java.util.jar.Manifest.equals(java.lang.Object)
java.util.List.equals(java.lang.Object)
java.util.Locale.equals(java.lang.Object)
java.util.logging.Level.equals(java.lang.Object)
java.util.Map.equals(java.lang.Object)
java.util.Map.Entry.equals(java.lang.Object)
java.util.PropertyPermission.equals(java.lang.Object)
java.util.Set.equals(java.lang.Object)
java.util.SimpleTimeZone.equals(java.lang.Object)
java.util.UUID.equals(java.lang.Object)
java.util.Vector.equals(java.lang.Object)
javax.activation.ActivationDataFlavor.equals(java.awt.datatransfer.DataFlavor)
javax.crypto.spec.RC2ParameterSpec.equals(java.lang.Object)
javax.crypto.spec.RC5ParameterSpec.equals(java.lang.Object)
javax.crypto.spec.SecretKeySpec.equals(java.lang.Object)
javax.imageio.ImageTypeSpecifier.equals(java.lang.Object)
javax.lang.model.element.Element.equals(java.lang.Object)
javax.lang.model.element.Name.equals(java.lang.Object)
javax.lang.model.type.TypeMirror.equals(java.lang.Object)
javax.management.Attribute.equals(java.lang.Object)
javax.management.Descriptor.equals(java.lang.Object)
javax.management.ImmutableDescriptor.equals(java.lang.Object)
javax.management.MBeanAttributeInfo.equals(java.lang.Object)
javax.management.MBeanConstructorInfo.equals(java.lang.Object)
javax.management.MBeanFeatureInfo.equals(java.lang.Object)
javax.management.MBeanInfo.equals(java.lang.Object)
javax.management.MBeanNotificationInfo.equals(java.lang.Object)
javax.management.MBeanOperationInfo.equals(java.lang.Object)
javax.management.MBeanParameterInfo.equals(java.lang.Object)
javax.management.MBeanPermission.equals(java.lang.Object)
javax.management.MBeanServerPermission.equals(java.lang.Object)
javax.management.modelmbean.DescriptorSupport.equals(java.lang.Object)
javax.management.ObjectInstance.equals(java.lang.Object)
javax.management.ObjectName.equals(java.lang.Object)
javax.management.openmbean.ArrayType.equals(java.lang.Object)
javax.management.openmbean.CompositeData.equals(java.lang.Object)
javax.management.openmbean.CompositeDataSupport.equals(java.lang.Object)
javax.management.openmbean.CompositeType.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanAttributeInfo.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanAttributeInfoSupport.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanConstructorInfo.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanConstructorInfoSupport.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanInfo.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanInfoSupport.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanOperationInfo.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanOperationInfoSupport.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanParameterInfo.equals(java.lang.Object)
javax.management.openmbean.OpenMBeanParameterInfoSupport.equals(java.lang.Object)
javax.management.openmbean.OpenType.equals(java.lang.Object)
javax.management.openmbean.SimpleType.equals(java.lang.Object)
javax.management.openmbean.TabularData.equals(java.lang.Object)
javax.management.openmbean.TabularDataSupport.equals(java.lang.Object)
javax.management.openmbean.TabularType.equals(java.lang.Object)
javax.management.remote.JMXPrincipal.equals(java.lang.Object)
javax.management.remote.JMXServiceURL.equals(java.lang.Object)
javax.naming.BinaryRefAddr.equals(java.lang.Object)
javax.naming.CompositeName.equals(java.lang.Object)
javax.naming.CompoundName.equals(java.lang.Object)
javax.naming.directory.BasicAttribute.equals(java.lang.Object)
javax.naming.directory.BasicAttributes.equals(java.lang.Object)
javax.naming.ldap.LdapName.equals(java.lang.Object)
javax.naming.ldap.Rdn.equals(java.lang.Object)
javax.naming.RefAddr.equals(java.lang.Object)
javax.naming.Reference.equals(java.lang.Object)
javax.print.attribute.AttributeSet.equals(java.lang.Object)
javax.print.attribute.DateTimeSyntax.equals(java.lang.Object)
javax.print.attribute.HashAttributeSet.equals(java.lang.Object)
javax.print.attribute.IntegerSyntax.equals(java.lang.Object)
javax.print.attribute.ResolutionSyntax.equals(java.lang.Object)
javax.print.attribute.SetOfIntegerSyntax.equals(java.lang.Object)
javax.print.attribute.Size2DSyntax.equals(java.lang.Object)
javax.print.attribute.standard.Copies.equals(java.lang.Object)
javax.print.attribute.standard.CopiesSupported.equals(java.lang.Object)
javax.print.attribute.standard.DateTimeAtCompleted.equals(java.lang.Object)
javax.print.attribute.standard.DateTimeAtCreation.equals(java.lang.Object)
javax.print.attribute.standard.DateTimeAtProcessing.equals(java.lang.Object)
javax.print.attribute.standard.Destination.equals(java.lang.Object)
javax.print.attribute.standard.DocumentName.equals(java.lang.Object)
javax.print.attribute.standard.JobHoldUntil.equals(java.lang.Object)
javax.print.attribute.standard.JobImpressions.equals(java.lang.Object)
javax.print.attribute.standard.JobImpressionsCompleted.equals(java.lang.Object)
javax.print.attribute.standard.JobImpressionsSupported.equals(java.lang.Object)
javax.print.attribute.standard.JobKOctets.equals(java.lang.Object)
javax.print.attribute.standard.JobKOctetsProcessed.equals(java.lang.Object)
javax.print.attribute.standard.JobKOctetsSupported.equals(java.lang.Object)
javax.print.attribute.standard.JobMediaSheets.equals(java.lang.Object)
javax.print.attribute.standard.JobMediaSheetsCompleted.equals(java.lang.Object)
javax.print.attribute.standard.JobMediaSheetsSupported.equals(java.lang.Object)
javax.print.attribute.standard.JobMessageFromOperator.equals(java.lang.Object)
javax.print.attribute.standard.JobName.equals(java.lang.Object)
javax.print.attribute.standard.JobOriginatingUserName.equals(java.lang.Object)
javax.print.attribute.standard.JobPriority.equals(java.lang.Object)
javax.print.attribute.standard.JobPrioritySupported.equals(java.lang.Object)
javax.print.attribute.standard.Media.equals(java.lang.Object)
javax.print.attribute.standard.MediaPrintableArea.equals(java.lang.Object)
javax.print.attribute.standard.MediaSize.equals(java.lang.Object)
javax.print.attribute.standard.NumberOfDocuments.equals(java.lang.Object)
javax.print.attribute.standard.NumberOfInterveningJobs.equals(java.lang.Object)
javax.print.attribute.standard.NumberUp.equals(java.lang.Object)
javax.print.attribute.standard.NumberUpSupported.equals(java.lang.Object)
javax.print.attribute.standard.OutputDeviceAssigned.equals(java.lang.Object)
javax.print.attribute.standard.PageRanges.equals(java.lang.Object)
javax.print.attribute.standard.PagesPerMinute.equals(java.lang.Object)
javax.print.attribute.standard.PagesPerMinuteColor.equals(java.lang.Object)
javax.print.attribute.standard.PrinterInfo.equals(java.lang.Object)
javax.print.attribute.standard.PrinterLocation.equals(java.lang.Object)
javax.print.attribute.standard.PrinterMakeAndModel.equals(java.lang.Object)
javax.print.attribute.standard.PrinterMessageFromOperator.equals(java.lang.Object)
javax.print.attribute.standard.PrinterMoreInfo.equals(java.lang.Object)
javax.print.attribute.standard.PrinterMoreInfoManufacturer.equals(java.lang.Object)
javax.print.attribute.standard.PrinterName.equals(java.lang.Object)
javax.print.attribute.standard.PrinterResolution.equals(java.lang.Object)
javax.print.attribute.standard.PrinterURI.equals(java.lang.Object)
javax.print.attribute.standard.QueuedJobCount.equals(java.lang.Object)
javax.print.attribute.standard.RequestingUserName.equals(java.lang.Object)
javax.print.attribute.TextSyntax.equals(java.lang.Object)
javax.print.attribute.URISyntax.equals(java.lang.Object)
javax.print.DocFlavor.equals(java.lang.Object)
javax.print.PrintService.equals(java.lang.Object)
javax.rmi.CORBA.Stub.equals(java.lang.Object)
javax.rmi.CORBA.StubDelegate.equals(javax.rmi.CORBA.Stub, java.lang.Object)
javax.rmi.ssl.SslRMIClientSocketFactory.equals(java.lang.Object)
javax.rmi.ssl.SslRMIServerSocketFactory.equals(java.lang.Object)
javax.security.auth.kerberos.DelegationPermission.equals(java.lang.Object)
javax.security.auth.kerberos.KerberosKey.equals(java.lang.Object)
javax.security.auth.kerberos.KerberosPrincipal.equals(java.lang.Object)
javax.security.auth.kerberos.KerberosTicket.equals(java.lang.Object)
javax.security.auth.kerberos.ServicePermission.equals(java.lang.Object)
javax.security.auth.PrivateCredentialPermission.equals(java.lang.Object)
javax.security.auth.Subject.equals(java.lang.Object)
javax.security.auth.x500.X500Principal.equals(java.lang.Object)
javax.security.cert.Certificate.equals(java.lang.Object)
javax.sound.midi.MidiDevice.Info.equals(java.lang.Object)
javax.sound.midi.Sequencer.SyncMode.equals(java.lang.Object)
javax.sound.sampled.AudioFileFormat.Type.equals(java.lang.Object)
javax.sound.sampled.AudioFormat.Encoding.equals(java.lang.Object)
javax.sound.sampled.Control.Type.equals(java.lang.Object)
javax.sound.sampled.LineEvent.Type.equals(java.lang.Object)
javax.sound.sampled.Mixer.Info.equals(java.lang.Object)
javax.sound.sampled.Port.Info.equals(java.lang.Object)
javax.sound.sampled.ReverbType.equals(java.lang.Object)
javax.swing.RowSorter.SortKey.equals(java.lang.Object)
javax.swing.text.DefaultCaret.equals(java.lang.Object)
javax.swing.text.html.HTML.UnknownTag.equals(java.lang.Object)
javax.swing.text.SimpleAttributeSet.equals(java.lang.Object)
javax.swing.text.StyleContext.SmallAttributeSet.equals(java.lang.Object)
javax.swing.text.TabSet.equals(java.lang.Object)
javax.swing.text.TabStop.equals(java.lang.Object)
javax.swing.tree.TreePath.equals(java.lang.Object)
javax.xml.datatype.Duration.equals(java.lang.Object)
javax.xml.datatype.XMLGregorianCalendar.equals(java.lang.Object)
javax.xml.namespace.QName.equals(java.lang.Object)
org.ietf.jgss.ChannelBinding.equals(java.lang.Object)
org.ietf.jgss.GSSCredential.equals(java.lang.Object)
org.ietf.jgss.GSSName.equals(java.lang.Object)
org.ietf.jgss.GSSName.equals(org.ietf.jgss.GSSName)
org.ietf.jgss.Oid.equals(java.lang.Object)
org.omg.CORBA.portable.Delegate.equals(org.omg.CORBA.Object, java.lang.Object)
org.omg.CORBA.portable.ObjectImpl.equals(java.lang.Object)


Occurences of ERA

ERA occurences:
java.text.ERA
java.util.ERA


Occurences of err

err occurences:
java.io.err
java.lang.err


Occurences of error

error occurences:
java.util.logging.ErrorManager.error(java.lang.String, java.lang.Exception, int)
javax.swing.text.html.parser.Parser.error(java.lang.String)
javax.swing.text.html.parser.Parser.error(java.lang.String, java.lang.String)
javax.swing.text.html.parser.Parser.error(java.lang.String, java.lang.String, java.lang.String)
javax.swing.text.html.parser.Parser.error(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
javax.xml.transform.ErrorListener.error(javax.xml.transform.TransformerException)
org.xml.sax.ErrorHandler.error(org.xml.sax.SAXParseException)
org.xml.sax.HandlerBase.error(org.xml.sax.SAXParseException)
org.xml.sax.helpers.DefaultHandler.error(org.xml.sax.SAXParseException)
org.xml.sax.helpers.XMLFilterImpl.error(org.xml.sax.SAXParseException)


Occurences of ERROR

ERROR occurences:
java.awt.ERROR
java.awt.image.ERROR
java.util.jar.ERROR
javax.lang.model.type.ERROR
javax.print.attribute.standard.ERROR
javax.security.auth.callback.ERROR
javax.security.auth.callback.ERROR
javax.tools.ERROR
javax.xml.bind.ERROR


Occurences of Error (constructors)

Error (constructors) occurences:
java.lang.Error()
java.lang.Error(java.lang.String)
java.lang.Error(java.lang.String, java.lang.Throwable)
java.lang.Error(java.lang.Throwable)


Occurences of errorCode

errorCode occurences:
com.sun.jdi.InternalException.errorCode()
javax.transaction.xa.errorCode


Occurences of errorRaised

errorRaised occurences:
com.sun.mirror.apt.RoundState.errorRaised()
javax.annotation.processing.RoundEnvironment.errorRaised()


Occurences of EtchedBorder (constructors)

EtchedBorder (constructors) occurences:
javax.swing.border.EtchedBorder()
javax.swing.border.EtchedBorder(int)
javax.swing.border.EtchedBorder(int, java.awt.Color, java.awt.Color)
javax.swing.border.EtchedBorder(java.awt.Color, java.awt.Color)


Occurences of etherealize

etherealize occurences:
org.omg.PortableServer.ServantActivatorOperations.etherealize(byte[], org.omg.PortableServer.POA, org.omg.PortableServer.Servant, boolean, boolean)
org.omg.PortableServer._ServantActivatorStub.etherealize(byte[], org.omg.PortableServer.POA, org.omg.PortableServer.Servant, boolean, boolean)


Occurences of ETHIOPIC

ETHIOPIC occurences:
java.awt.font.ETHIOPIC
java.lang.ETHIOPIC


Occurences of eval

eval occurences:
javax.script.AbstractScriptEngine.eval(java.io.Reader)
javax.script.AbstractScriptEngine.eval(java.io.Reader, javax.script.Bindings)
javax.script.AbstractScriptEngine.eval(java.lang.String)
javax.script.AbstractScriptEngine.eval(java.lang.String, javax.script.Bindings)
javax.script.CompiledScript.eval()
javax.script.CompiledScript.eval(javax.script.Bindings)
javax.script.CompiledScript.eval(javax.script.ScriptContext)
javax.script.ScriptEngine.eval(java.io.Reader)
javax.script.ScriptEngine.eval(java.io.Reader, javax.script.Bindings)
javax.script.ScriptEngine.eval(java.io.Reader, javax.script.ScriptContext)
javax.script.ScriptEngine.eval(java.lang.String)
javax.script.ScriptEngine.eval(java.lang.String, javax.script.Bindings)
javax.script.ScriptEngine.eval(java.lang.String, javax.script.ScriptContext)


Occurences of evaluate

evaluate occurences:
javax.sql.rowset.Predicate.evaluate(java.lang.Object, int)
javax.sql.rowset.Predicate.evaluate(java.lang.Object, java.lang.String)
javax.sql.rowset.Predicate.evaluate(javax.sql.RowSet)
javax.xml.xpath.XPath.evaluate(java.lang.String, java.lang.Object)
javax.xml.xpath.XPath.evaluate(java.lang.String, java.lang.Object, javax.xml.namespace.QName)
javax.xml.xpath.XPath.evaluate(java.lang.String, org.xml.sax.InputSource)
javax.xml.xpath.XPath.evaluate(java.lang.String, org.xml.sax.InputSource, javax.xml.namespace.QName)
javax.xml.xpath.XPathExpression.evaluate(java.lang.Object)
javax.xml.xpath.XPathExpression.evaluate(java.lang.Object, javax.xml.namespace.QName)
javax.xml.xpath.XPathExpression.evaluate(org.xml.sax.InputSource)
javax.xml.xpath.XPathExpression.evaluate(org.xml.sax.InputSource, javax.xml.namespace.QName)
javax.xml.xpath.XPathFunction.evaluate(java.util.List)


Occurences of event

event occurences:
com.sun.jdi.event
java.awt.event
javax.imageio.event
javax.naming.event
javax.print.event
javax.swing.event
javax.swing.tree.event


Occurences of Event

Event occurences:
com.sun.jdi.event.Event
java.awt.Event
org.w3c.dom.events.Event


Occurences of Event (constructors)

Event (constructors) occurences:
java.awt.Event(java.lang.Object, int, java.lang.Object)
java.awt.Event(java.lang.Object, long, int, int, int, int, int)
java.awt.Event(java.lang.Object, long, int, int, int, int, int, java.lang.Object)


Occurences of eventDispatched

eventDispatched occurences:
java.awt.event.AWTEventListener.eventDispatched(java.awt.AWTEvent)
java.awt.event.AWTEventListenerProxy.eventDispatched(java.awt.AWTEvent)


Occurences of EventListener

EventListener occurences:
java.util.EventListener
org.w3c.dom.events.EventListener


Occurences of EventQueue

EventQueue occurences:
com.sun.jdi.event.EventQueue
java.awt.EventQueue


Occurences of EventReaderDelegate (constructors)

EventReaderDelegate (constructors) occurences:
javax.xml.stream.util.EventReaderDelegate()
javax.xml.stream.util.EventReaderDelegate(javax.xml.stream.XMLEventReader)


Occurences of events

events occurences:
java.awt.dnd.events
javax.xml.stream.events
org.w3c.dom.events


Occurences of EventSetDescriptor (constructors)

EventSetDescriptor (constructors) occurences:
java.beans.EventSetDescriptor(java.lang.Class, java.lang.String, java.lang.Class, java.lang.String)
java.beans.EventSetDescriptor(java.lang.Class, java.lang.String, java.lang.Class, java.lang.String[], java.lang.String, java.lang.String)
java.beans.EventSetDescriptor(java.lang.Class, java.lang.String, java.lang.Class, java.lang.String[], java.lang.String, java.lang.String, java.lang.String)
java.beans.EventSetDescriptor(java.lang.String, java.lang.Class, java.beans.MethodDescriptor[], java.lang.reflect.Method, java.lang.reflect.Method)
java.beans.EventSetDescriptor(java.lang.String, java.lang.Class, java.lang.reflect.Method[], java.lang.reflect.Method, java.lang.reflect.Method)
java.beans.EventSetDescriptor(java.lang.String, java.lang.Class, java.lang.reflect.Method[], java.lang.reflect.Method, java.lang.reflect.Method, java.lang.reflect.Method)


Occurences of ExcC14NParameterSpec (constructors)

ExcC14NParameterSpec (constructors) occurences:
javax.xml.crypto.dsig.spec.ExcC14NParameterSpec()
javax.xml.crypto.dsig.spec.ExcC14NParameterSpec(java.util.List)


Occurences of except

except occurences:
org.omg.CORBA.except
org.omg.CORBA.ServerRequest.except(org.omg.CORBA.Any)


Occurences of exception

exception occurences:
com.sun.javadoc.ThrowsTag.exception()
com.sun.jdi.event.ExceptionEvent.exception()
com.sun.jdi.InvocationException.exception()
com.sun.jdi.request.ExceptionRequest.exception()
org.omg.CORBA.Environment.exception()
org.omg.CORBA.Environment.exception(java.lang.Exception)


Occurences of Exception (constructors)

Exception (constructors) occurences:
java.lang.Exception()
java.lang.Exception(java.lang.String)
java.lang.Exception(java.lang.String, java.lang.Throwable)
java.lang.Exception(java.lang.Throwable)


Occurences of ExceptionInInitializerError (constructors)

ExceptionInInitializerError (constructors) occurences:
java.lang.ExceptionInInitializerError()
java.lang.ExceptionInInitializerError(java.lang.String)
java.lang.ExceptionInInitializerError(java.lang.Throwable)


Occurences of exceptions

exceptions occurences:
com.sun.javadoc.PackageDoc.exceptions()
javax.swing.exceptions
org.omg.CORBA.Request.exceptions()
org.omg.PortableInterceptor.RequestInfoOperations.exceptions()


Occurences of exchange

exchange occurences:
java.util.concurrent.Exchanger.exchange(java.lang.Object)
java.util.concurrent.Exchanger.exchange(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.Exchanger.exchange(V)
java.util.concurrent.Exchanger.exchange(V, long, java.util.concurrent.TimeUnit)


Occurences of exec

exec occurences:
Class GLOBALS.exec
java.lang.Runtime.exec(java.lang.String)
java.lang.Runtime.exec(java.lang.String, java.lang.String[])
java.lang.Runtime.exec(java.lang.String, java.lang.String[], java.io.File)
java.lang.Runtime.exec(java.lang.String[])
java.lang.Runtime.exec(java.lang.String[], java.lang.String[])
java.lang.Runtime.exec(java.lang.String[], java.lang.String[], java.io.File)


Occurences of execute

execute occurences:
java.beans.Statement.execute()
java.sql.PreparedStatement.execute()
java.sql.Statement.execute(java.lang.String)
java.sql.Statement.execute(java.lang.String, int)
java.sql.Statement.execute(java.lang.String, int[])
java.sql.Statement.execute(java.lang.String, java.lang.String[])
java.util.concurrent.Executor.execute(java.lang.Runnable)
java.util.concurrent.ScheduledThreadPoolExecutor.execute(java.lang.Runnable)
java.util.concurrent.ThreadPoolExecutor.execute(java.lang.Runnable)
javax.sql.RowSet.execute()
javax.sql.rowset.CachedRowSet.execute(java.sql.Connection)
javax.swing.SwingWorker.execute()


Occurences of executeQuery

executeQuery occurences:
java.sql.PreparedStatement.executeQuery()
java.sql.Statement.executeQuery(java.lang.String)


Occurences of executeUpdate

executeUpdate occurences:
java.sql.PreparedStatement.executeUpdate()
java.sql.Statement.executeUpdate(java.lang.String)
java.sql.Statement.executeUpdate(java.lang.String, int)
java.sql.Statement.executeUpdate(java.lang.String, int[])
java.sql.Statement.executeUpdate(java.lang.String, java.lang.String[])


Occurences of ExecutionException (constructors)

ExecutionException (constructors) occurences:
java.util.concurrent.ExecutionException()
java.util.concurrent.ExecutionException(java.lang.String)
java.util.concurrent.ExecutionException(java.lang.String, java.lang.Throwable)
java.util.concurrent.ExecutionException(java.lang.Throwable)


Occurences of EXECUTIVE

EXECUTIVE occurences:
java.awt.EXECUTIVE
javax.print.attribute.standard.EXECUTIVE
javax.print.attribute.standard.EXECUTIVE


Occurences of ExecutorCompletionService (constructors)

ExecutorCompletionService (constructors) occurences:
java.util.concurrent.ExecutorCompletionService(java.util.concurrent.Executor)
java.util.concurrent.ExecutorCompletionService(java.util.concurrent.Executor, java.util.concurrent.BlockingQueue)


Occurences of ExemptionMechanismException (constructors)

ExemptionMechanismException (constructors) occurences:
javax.crypto.ExemptionMechanismException()
javax.crypto.ExemptionMechanismException(java.lang.String)


Occurences of exit

exit occurences:
Class GLOBALS.exit
com.sun.jdi.VirtualMachine.exit(int)
java.lang.Runtime.exit(int)
java.lang.System.exit(int)


Occurences of exiting

exiting occurences:
java.util.logging.Logger.exiting(java.lang.String, java.lang.String)
java.util.logging.Logger.exiting(java.lang.String, java.lang.String, java.lang.Object)


Occurences of EXIT_ON_CLOSE

EXIT_ON_CLOSE occurences:
javax.swing.EXIT_ON_CLOSE
javax.swing.EXIT_ON_CLOSE


Occurences of exp

exp occurences:
java.lang.Math.exp(double)
java.lang.StrictMath.exp(double)


Occurences of ExpandVetoException (constructors)

ExpandVetoException (constructors) occurences:
javax.swing.tree.ExpandVetoException(javax.swing.event.TreeExpansionEvent)
javax.swing.tree.ExpandVetoException(javax.swing.event.TreeExpansionEvent, java.lang.String)


Occurences of expm1

expm1 occurences:
java.lang.Math.expm1(double)
java.lang.StrictMath.expm1(double)


Occurences of export

export occurences:
javax.management.remote.rmi.RMIIIOPServerImpl.export()
javax.management.remote.rmi.RMIJRMPServerImpl.export()
javax.management.remote.rmi.RMIServerImpl.export()
org.ietf.jgss.GSSContext.export()
org.ietf.jgss.GSSName.export()


Occurences of ExportException (constructors)

ExportException (constructors) occurences:
java.rmi.server.ExportException(java.lang.String)
java.rmi.server.ExportException(java.lang.String, java.lang.Exception)


Occurences of exportNode

exportNode occurences:
java.util.prefs.AbstractPreferences.exportNode(java.io.OutputStream)
java.util.prefs.Preferences.exportNode(java.io.OutputStream)


Occurences of exportObject

exportObject occurences:
java.rmi.activation.Activatable.exportObject(java.rmi.Remote, java.lang.String, java.rmi.MarshalledObject, boolean, int)
java.rmi.activation.Activatable.exportObject(java.rmi.Remote, java.lang.String, java.rmi.MarshalledObject, boolean, int, java.rmi.server.RMIClientSocketFactory, java.rmi.server.RMIServerSocketFactory)
java.rmi.activation.Activatable.exportObject(java.rmi.Remote, java.rmi.activation.ActivationID, int)
java.rmi.activation.Activatable.exportObject(java.rmi.Remote, java.rmi.activation.ActivationID, int, java.rmi.server.RMIClientSocketFactory, java.rmi.server.RMIServerSocketFactory)
java.rmi.server.ServerRef.exportObject(java.rmi.Remote, java.lang.Object)
java.rmi.server.UnicastRemoteObject.exportObject(java.rmi.Remote)
java.rmi.server.UnicastRemoteObject.exportObject(java.rmi.Remote, int)
java.rmi.server.UnicastRemoteObject.exportObject(java.rmi.Remote, int, java.rmi.server.RMIClientSocketFactory, java.rmi.server.RMIServerSocketFactory)
javax.rmi.CORBA.PortableRemoteObjectDelegate.exportObject(java.rmi.Remote)
javax.rmi.PortableRemoteObject.exportObject(java.rmi.Remote)


Occurences of exportSubtree

exportSubtree occurences:
java.util.prefs.AbstractPreferences.exportSubtree(java.io.OutputStream)
java.util.prefs.Preferences.exportSubtree(java.io.OutputStream)


Occurences of Expression (constructors)

Expression (constructors) occurences:
java.beans.Expression(java.lang.Object, java.lang.Object, java.lang.String, java.lang.Object[])
java.beans.Expression(java.lang.Object, java.lang.String, java.lang.Object[])


Occurences of extcheck - Jar conflict detection utility

extcheck - Jar conflict detection utility occurences:
extcheck - Jar conflict detection utility
extcheck - Jar conflict detection utility


Occurences of EXTCRC

EXTCRC occurences:
java.util.jar.EXTCRC
java.util.jar.EXTCRC
java.util.jar.EXTCRC
java.util.jar.EXTCRC
java.util.zip.EXTCRC
java.util.zip.EXTCRC
java.util.zip.EXTCRC
java.util.zip.EXTCRC


Occurences of extendedOperation

extendedOperation occurences:
javax.naming.ldap.InitialLdapContext.extendedOperation(javax.naming.ldap.ExtendedRequest)
javax.naming.ldap.LdapContext.extendedOperation(javax.naming.ldap.ExtendedRequest)


Occurences of extent

extent occurences:
java.awt.geom.extent
java.awt.geom.extent


Occurences of externalEntityDecl

externalEntityDecl occurences:
org.xml.sax.ext.DeclHandler.externalEntityDecl(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.ext.DefaultHandler2.externalEntityDecl(java.lang.String, java.lang.String, java.lang.String)


Occurences of Externalization with an Externalizable SuperClass

Externalization with an Externalizable SuperClass occurences:
Externalization with an Externalizable SuperClass
Externalization with an Externalizable SuperClass
Externalization with an Externalizable SuperClass


Occurences of Externalization with an NonExternalizable SuperClass

Externalization with an NonExternalizable SuperClass occurences:
Externalization with an NonExternalizable SuperClass
Externalization with an NonExternalizable SuperClass
Externalization with an NonExternalizable SuperClass


Occurences of EXTHDR

EXTHDR occurences:
java.util.jar.EXTHDR
java.util.jar.EXTHDR
java.util.jar.EXTHDR
java.util.jar.EXTHDR
java.util.zip.EXTHDR
java.util.zip.EXTHDR
java.util.zip.EXTHDR
java.util.zip.EXTHDR


Occurences of EXTLEN

EXTLEN occurences:
java.util.jar.EXTLEN
java.util.jar.EXTLEN
java.util.jar.EXTLEN
java.util.jar.EXTLEN
java.util.zip.EXTLEN
java.util.zip.EXTLEN
java.util.zip.EXTLEN
java.util.zip.EXTLEN


Occurences of extract

extract occurences:
org.omg.CORBA.AnySeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.BooleanSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.CharSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.CompletionStatusHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.CurrentHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.DefinitionKindHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.DoubleSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.FieldNameHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.FloatSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.IdentifierHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.IDLTypeHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.LongLongSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.LongSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.NameValuePairHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ObjectHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.OctetSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ParameterModeHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.PolicyErrorCodeHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.PolicyErrorHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.PolicyHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.PolicyListHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.PolicyTypeHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.RepositoryIdHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ServiceDetailHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ServiceInformationHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.SetOverrideTypeHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ShortSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.StringSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.StringValueHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.StructMemberHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ULongLongSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ULongSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.UnionMemberHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.UnknownUserExceptionHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.UShortSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ValueBaseHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.ValueMemberHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.VersionSpecHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.VisibilityHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.WCharSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.WrongTransactionHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.WStringSeqHelper.extract(org.omg.CORBA.Any)
org.omg.CORBA.WStringValueHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.BindingHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.BindingIteratorHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.BindingListHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.BindingTypeHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.IstringHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NameComponentHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NameHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextExtHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextExtPackage.AddressHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextExtPackage.StringNameHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextExtPackage.URLStringHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextPackage.NotEmptyHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextPackage.NotFoundHelper.extract(org.omg.CORBA.Any)
org.omg.CosNaming.NamingContextPackage.NotFoundReasonHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.AnySeqHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnyFactoryHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCodeHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnyHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnyPackage.InvalidValueHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnyPackage.TypeMismatchHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnySeqHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynArrayHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynEnumHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynFixedHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynSequenceHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynStructHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynUnionHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.DynValueHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.FieldNameHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.NameDynAnyPairHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.NameDynAnyPairSeqHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.NameValuePairHelper.extract(org.omg.CORBA.Any)
org.omg.DynamicAny.NameValuePairSeqHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.CodecFactoryHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.CodecFactoryPackage.UnknownEncodingHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.CodecPackage.FormatMismatchHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.CodecPackage.InvalidTypeForEncodingHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.CodecPackage.TypeMismatchHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.ComponentIdHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.IORHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.MultipleComponentProfileHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.ProfileIdHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.ServiceContextHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.ServiceContextListHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.ServiceIdHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.TaggedComponentHelper.extract(org.omg.CORBA.Any)
org.omg.IOP.TaggedProfileHelper.extract(org.omg.CORBA.Any)
org.omg.Messaging.SyncScopeHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.AdapterManagerIdHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.AdapterNameHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.AdapterStateHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.CurrentHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ForwardRequestHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.InvalidSlotHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.IORInterceptor_3_0Helper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ObjectIdHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ObjectReferenceFactoryHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ObjectReferenceTemplateHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ORBIdHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateNameHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidNameHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ORBInitInfoPackage.ObjectIdHelper.extract(org.omg.CORBA.Any)
org.omg.PortableInterceptor.ServerIdHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.CurrentHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.CurrentPackage.NoContextHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.ForwardRequestHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAManagerPackage.AdapterInactiveHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.AdapterAlreadyExistsHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.AdapterNonExistentHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.InvalidPolicyHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.NoServantHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.ObjectAlreadyActiveHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.ObjectNotActiveHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.ServantAlreadyActiveHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.ServantNotActiveHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.WrongAdapterHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.POAPackage.WrongPolicyHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.ServantActivatorHelper.extract(org.omg.CORBA.Any)
org.omg.PortableServer.ServantLocatorHelper.extract(org.omg.CORBA.Any)


Occurences of EXTSIG

EXTSIG occurences:
java.util.jar.EXTSIG
java.util.jar.EXTSIG
java.util.jar.EXTSIG
java.util.jar.EXTSIG
java.util.zip.EXTSIG
java.util.zip.EXTSIG
java.util.zip.EXTSIG
java.util.zip.EXTSIG


Occurences of EXTSIZ

EXTSIZ occurences:
java.util.jar.EXTSIZ
java.util.jar.EXTSIZ
java.util.jar.EXTSIZ
java.util.jar.EXTSIZ
java.util.zip.EXTSIZ
java.util.zip.EXTSIZ
java.util.zip.EXTSIZ
java.util.zip.EXTSIZ


Occurences of E_RESIZE_CURSOR

E_RESIZE_CURSOR occurences:
java.awt.E_RESIZE_CURSOR
java.awt.E_RESIZE_CURSOR


Occurences of F4

F4 occurences:
java.awt.F4
java.security.spec.F4


Occurences of FactoryConfigurationError

FactoryConfigurationError occurences:
javax.xml.parsers.FactoryConfigurationError
javax.xml.stream.FactoryConfigurationError


Occurences of FactoryConfigurationError (constructors)

FactoryConfigurationError (constructors) occurences:
javax.xml.parsers.FactoryConfigurationError()
javax.xml.parsers.FactoryConfigurationError(java.lang.Exception)
javax.xml.parsers.FactoryConfigurationError(java.lang.Exception, java.lang.String)
javax.xml.parsers.FactoryConfigurationError(java.lang.String)
javax.xml.stream.FactoryConfigurationError()
javax.xml.stream.FactoryConfigurationError(java.lang.Exception)
javax.xml.stream.FactoryConfigurationError(java.lang.Exception, java.lang.String)
javax.xml.stream.FactoryConfigurationError(java.lang.String)
javax.xml.stream.FactoryConfigurationError(java.lang.String, java.lang.Exception)


Occurences of FailedLoginException (constructors)

FailedLoginException (constructors) occurences:
javax.security.auth.login.FailedLoginException()
javax.security.auth.login.FailedLoginException(java.lang.String)


Occurences of FALSE

FALSE occurences:
java.lang.FALSE
java.util.jar.FALSE
java.util.jar.FALSE


Occurences of fatalError

fatalError occurences:
javax.xml.transform.ErrorListener.fatalError(javax.xml.transform.TransformerException)
org.xml.sax.ErrorHandler.fatalError(org.xml.sax.SAXParseException)
org.xml.sax.HandlerBase.fatalError(org.xml.sax.SAXParseException)
org.xml.sax.helpers.DefaultHandler.fatalError(org.xml.sax.SAXParseException)
org.xml.sax.helpers.XMLFilterImpl.fatalError(org.xml.sax.SAXParseException)


Occurences of fd

fd occurences:
java.net.fd
java.net.fd


Occurences of FEATURE

FEATURE occurences:
javax.xml.transform.dom.FEATURE
javax.xml.transform.dom.FEATURE
javax.xml.transform.sax.FEATURE
javax.xml.transform.sax.FEATURE
javax.xml.transform.sax.FEATURE
javax.xml.transform.stax.FEATURE
javax.xml.transform.stax.FEATURE
javax.xml.transform.stream.FEATURE
javax.xml.transform.stream.FEATURE


Occurences of FEBRUARY

FEBRUARY occurences:
java.util.FEBRUARY
javax.xml.datatype.FEBRUARY


Occurences of fetchNotifications

fetchNotifications occurences:
javax.management.remote.rmi.RMIConnection.fetchNotifications(long, int, long)
javax.management.remote.rmi.RMIConnectionImpl.fetchNotifications(long, int, long)
javax.management.remote.rmi.RMIConnectionImpl_Stub.fetchNotifications(long, int, long)


Occurences of Field

Field occurences:
com.sun.jdi.Field
java.lang.reflect.Field


Occurences of FIELD

FIELD occurences:
java.lang.annotation.FIELD
javax.lang.model.element.FIELD
javax.xml.bind.annotation.FIELD


Occurences of field

field occurences:
com.sun.jdi.event.WatchpointEvent.field()
com.sun.jdi.request.WatchpointRequest.field()


Occurences of FieldNameHelper

FieldNameHelper occurences:
org.omg.CORBA.FieldNameHelper
org.omg.DynamicAny.FieldNameHelper


Occurences of FieldNameHelper (constructors)

FieldNameHelper (constructors) occurences:
org.omg.CORBA.FieldNameHelper()
org.omg.DynamicAny.FieldNameHelper()


Occurences of FieldPosition (constructors)

FieldPosition (constructors) occurences:
java.text.FieldPosition(int)
java.text.FieldPosition(java.text.Format.Field)
java.text.FieldPosition(java.text.Format.Field, int)


Occurences of fields

fields occurences:
com.sun.javadoc.ClassDoc.fields()
com.sun.javadoc.ClassDoc.fields(boolean)
com.sun.jdi.ReferenceType.fields()
java.util.fields


Occurences of fieldsIn

fieldsIn occurences:
javax.lang.model.util.ElementFilter.fieldsIn(java.lang.Iterable)
javax.lang.model.util.ElementFilter.fieldsIn(java.util.Set)


Occurences of file

file occurences:
com.sun.javadoc.SourcePosition.file()
com.sun.mirror.util.SourcePosition.file()
javax.jws.HandlerChain.file()


Occurences of FILE

FILE occurences:
java.awt.FILE
javax.print.attribute.standard.FILE


Occurences of File (constructors)

File (constructors) occurences:
java.io.File(java.io.File, java.lang.String)
java.io.File(java.lang.String)
java.io.File(java.lang.String, java.lang.String)
java.io.File(java.net.URI)


Occurences of FileDataSource (constructors)

FileDataSource (constructors) occurences:
javax.activation.FileDataSource(java.io.File)
javax.activation.FileDataSource(java.lang.String)


Occurences of FileDialog (constructors)

FileDialog (constructors) occurences:
java.awt.FileDialog(java.awt.Dialog)
java.awt.FileDialog(java.awt.Dialog, java.lang.String)
java.awt.FileDialog(java.awt.Dialog, java.lang.String, int)
java.awt.FileDialog(java.awt.Frame)
java.awt.FileDialog(java.awt.Frame, java.lang.String)
java.awt.FileDialog(java.awt.Frame, java.lang.String, int)


Occurences of FileFilter

FileFilter occurences:
java.io.FileFilter
javax.swing.filechooser.FileFilter


Occurences of FileHandler (constructors)

FileHandler (constructors) occurences:
java.util.logging.FileHandler()
java.util.logging.FileHandler(java.lang.String)
java.util.logging.FileHandler(java.lang.String, boolean)
java.util.logging.FileHandler(java.lang.String, int, int)
java.util.logging.FileHandler(java.lang.String, int, int, boolean)


Occurences of FileImageInputStream (constructors)

FileImageInputStream (constructors) occurences:
javax.imageio.stream.FileImageInputStream(java.io.File)
javax.imageio.stream.FileImageInputStream(java.io.RandomAccessFile)


Occurences of FileImageOutputStream (constructors)

FileImageOutputStream (constructors) occurences:
javax.imageio.stream.FileImageOutputStream(java.io.File)
javax.imageio.stream.FileImageOutputStream(java.io.RandomAccessFile)


Occurences of FileInputStream (constructors)

FileInputStream (constructors) occurences:
java.io.FileInputStream(java.io.File)
java.io.FileInputStream(java.io.FileDescriptor)
java.io.FileInputStream(java.lang.String)


Occurences of FileNotFoundException (constructors)

FileNotFoundException (constructors) occurences:
java.io.FileNotFoundException()
java.io.FileNotFoundException(java.lang.String)


Occurences of FileOutputStream (constructors)

FileOutputStream (constructors) occurences:
java.io.FileOutputStream(java.io.File)
java.io.FileOutputStream(java.io.File, boolean)
java.io.FileOutputStream(java.io.FileDescriptor)
java.io.FileOutputStream(java.lang.String)
java.io.FileOutputStream(java.lang.String, boolean)


Occurences of Filer

Filer occurences:
com.sun.mirror.apt.Filer
javax.annotation.processing.Filer


Occurences of FileReader (constructors)

FileReader (constructors) occurences:
java.io.FileReader(java.io.File)
java.io.FileReader(java.io.FileDescriptor)
java.io.FileReader(java.lang.String)


Occurences of FileWriter (constructors)

FileWriter (constructors) occurences:
java.io.FileWriter(java.io.File)
java.io.FileWriter(java.io.File, boolean)
java.io.FileWriter(java.io.FileDescriptor)
java.io.FileWriter(java.lang.String)
java.io.FileWriter(java.lang.String, boolean)


Occurences of FILE_CHOOSER

FILE_CHOOSER occurences:
javax.accessibility.FILE_CHOOSER
javax.swing.plaf.synth.FILE_CHOOSER


Occurences of fill

fill occurences:
java.awt.fill
java.awt.Graphics2D.fill(java.awt.Shape)
java.util.Arrays.fill(boolean[], boolean)
java.util.Arrays.fill(boolean[], int, int, boolean)
java.util.Arrays.fill(byte[], byte)
java.util.Arrays.fill(byte[], int, int, byte)
java.util.Arrays.fill(char[], char)
java.util.Arrays.fill(char[], int, int, char)
java.util.Arrays.fill(double[], double)
java.util.Arrays.fill(double[], int, int, double)
java.util.Arrays.fill(float[], float)
java.util.Arrays.fill(float[], int, int, float)
java.util.Arrays.fill(int[], int)
java.util.Arrays.fill(int[], int, int, int)
java.util.Arrays.fill(java.lang.Object[], int, int, java.lang.Object)
java.util.Arrays.fill(java.lang.Object[], java.lang.Object)
java.util.Arrays.fill(long[], int, int, long)
java.util.Arrays.fill(long[], long)
java.util.Arrays.fill(short[], int, int, short)
java.util.Arrays.fill(short[], short)
java.util.Collections.fill(java.util.List, T)
java.util.Collections.fill(java.util.List,java.lang.Object)
java.util.zip.InflaterInputStream.fill()


Occurences of fill3DRect

fill3DRect occurences:
java.awt.Graphics.fill3DRect(int, int, int, int, boolean)
java.awt.Graphics2D.fill3DRect(int, int, int, int, boolean)
javax.swing.DebugGraphics.fill3DRect(int, int, int, int, boolean)


Occurences of fillArc

fillArc occurences:
java.awt.Graphics.fillArc(int, int, int, int, int, int)
javax.swing.DebugGraphics.fillArc(int, int, int, int, int, int)


Occurences of fillOval

fillOval occurences:
java.awt.Graphics.fillOval(int, int, int, int)
javax.swing.DebugGraphics.fillOval(int, int, int, int)


Occurences of fillPolygon

fillPolygon occurences:
java.awt.Graphics.fillPolygon(int[], int[], int)
java.awt.Graphics.fillPolygon(java.awt.Polygon)
javax.swing.DebugGraphics.fillPolygon(int[], int[], int)


Occurences of fillRect

fillRect occurences:
java.awt.Graphics.fillRect(int, int, int, int)
javax.swing.DebugGraphics.fillRect(int, int, int, int)


Occurences of fillRoundRect

fillRoundRect occurences:
java.awt.Graphics.fillRoundRect(int, int, int, int, int, int)
javax.swing.DebugGraphics.fillRoundRect(int, int, int, int, int, int)


Occurences of filter

filter occurences:
com.sun.mirror.util.DeclarationFilter.filter(java.util.Collection)
com.sun.mirror.util.DeclarationFilter.filter(java.util.Collection, java.lang.Class)
java.awt.image.AffineTransformOp.filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
java.awt.image.AffineTransformOp.filter(java.awt.image.Raster, java.awt.image.WritableRaster)
java.awt.image.BandCombineOp.filter(java.awt.image.Raster, java.awt.image.WritableRaster)
java.awt.image.BufferedImageOp.filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
java.awt.image.ColorConvertOp.filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
java.awt.image.ColorConvertOp.filter(java.awt.image.Raster, java.awt.image.WritableRaster)
java.awt.image.ConvolveOp.filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
java.awt.image.ConvolveOp.filter(java.awt.image.Raster, java.awt.image.WritableRaster)
java.awt.image.LookupOp.filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
java.awt.image.LookupOp.filter(java.awt.image.Raster, java.awt.image.WritableRaster)
java.awt.image.RasterOp.filter(java.awt.image.Raster, java.awt.image.WritableRaster)
java.awt.image.RescaleOp.filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
java.awt.image.RescaleOp.filter(java.awt.image.Raster, java.awt.image.WritableRaster)
javax.imageio.spi.ServiceRegistry.Filter.filter(java.lang.Object)


Occurences of filterRGB

filterRGB occurences:
java.awt.image.RGBImageFilter.filterRGB(int, int, int)
javax.swing.GrayFilter.filterRGB(int, int, int)


Occurences of FINAL

FINAL occurences:
com.sun.mirror.declaration.FINAL
java.lang.reflect.FINAL
javax.lang.model.element.FINAL


Occurences of finalize

finalize occurences:
java.awt.color.ICC_Profile.finalize()
java.awt.Font.finalize()
java.awt.Graphics.finalize()
java.awt.image.ColorModel.finalize()
java.awt.image.IndexColorModel.finalize()
java.awt.PrintJob.finalize()
java.io.FileInputStream.finalize()
java.io.FileOutputStream.finalize()
java.lang.Enum.finalize()
java.lang.Object.finalize()
java.util.concurrent.ThreadPoolExecutor.finalize()
java.util.zip.Deflater.finalize()
java.util.zip.Inflater.finalize()
java.util.zip.ZipFile.finalize()
javax.crypto.ExemptionMechanism.finalize()
javax.imageio.spi.ServiceRegistry.finalize()
javax.imageio.stream.FileCacheImageInputStream.finalize()
javax.imageio.stream.FileImageInputStream.finalize()
javax.imageio.stream.FileImageOutputStream.finalize()
javax.imageio.stream.ImageInputStreamImpl.finalize()
javax.imageio.stream.MemoryCacheImageInputStream.finalize()


Occurences of find

find occurences:
Class GLOBALS.find
java.util.regex.Matcher.find()
java.util.regex.Matcher.find(int)


Occurences of findAssociatedMBeans

findAssociatedMBeans occurences:
javax.management.relation.RelationService.findAssociatedMBeans(javax.management.ObjectName, java.lang.String, java.lang.String)
javax.management.relation.RelationServiceMBean.findAssociatedMBeans(javax.management.ObjectName, java.lang.String, java.lang.String)


Occurences of findClass

findClass occurences:
com.sun.javadoc.ClassDoc.findClass(java.lang.String)
com.sun.javadoc.PackageDoc.findClass(java.lang.String)
java.lang.ClassLoader.findClass(java.lang.String)
java.net.URLClassLoader.findClass(java.lang.String)
javax.management.loading.MLet.findClass(java.lang.String)


Occurences of findColumn

findColumn occurences:
java.sql.ResultSet.findColumn(java.lang.String)
javax.swing.table.AbstractTableModel.findColumn(java.lang.String)


Occurences of findComponentAt

findComponentAt occurences:
java.awt.Container.findComponentAt(int, int)
java.awt.Container.findComponentAt(java.awt.Point)


Occurences of findInLine

findInLine occurences:
java.util.Scanner.findInLine(java.lang.String)
java.util.Scanner.findInLine(java.util.regex.Pattern)


Occurences of findLibrary

findLibrary occurences:
java.lang.ClassLoader.findLibrary(java.lang.String)
javax.management.loading.MLet.findLibrary(java.lang.String)


Occurences of findReferencingRelations

findReferencingRelations occurences:
javax.management.relation.RelationService.findReferencingRelations(javax.management.ObjectName, java.lang.String, java.lang.String)
javax.management.relation.RelationServiceMBean.findReferencingRelations(javax.management.ObjectName, java.lang.String, java.lang.String)


Occurences of findRelationsOfType

findRelationsOfType occurences:
javax.management.relation.RelationService.findRelationsOfType(java.lang.String)
javax.management.relation.RelationServiceMBean.findRelationsOfType(java.lang.String)


Occurences of findResource

findResource occurences:
java.lang.ClassLoader.findResource(java.lang.String)
java.net.URLClassLoader.findResource(java.lang.String)


Occurences of findResources

findResources occurences:
java.lang.ClassLoader.findResources(java.lang.String)
java.net.URLClassLoader.findResources(java.lang.String)


Occurences of findWithinHorizon

findWithinHorizon occurences:
java.util.Scanner.findWithinHorizon(java.lang.String, int)
java.util.Scanner.findWithinHorizon(java.util.regex.Pattern, int)


Occurences of finish

finish occurences:
java.util.zip.Deflater.finish()
java.util.zip.DeflaterOutputStream.finish()
java.util.zip.GZIPOutputStream.finish()
java.util.zip.InflaterOutputStream.finish()
java.util.zip.ZipOutputStream.finish()


Occurences of finishDraggingTo

finishDraggingTo occurences:
javax.swing.plaf.basic.BasicSplitPaneDivider.finishDraggingTo(int)
javax.swing.plaf.basic.BasicSplitPaneUI.finishDraggingTo(int)


Occurences of finished

finished occurences:
com.sun.source.util.TaskListener.finished(com.sun.source.util.TaskEvent)
java.util.zip.Deflater.finished()
java.util.zip.Inflater.finished()


Occurences of finishedPaintingChildren

finishedPaintingChildren occurences:
javax.swing.plaf.basic.BasicSplitPaneUI.finishedPaintingChildren(javax.swing.JSplitPane, java.awt.Graphics)
javax.swing.plaf.multi.MultiSplitPaneUI.finishedPaintingChildren(javax.swing.JSplitPane, java.awt.Graphics)
javax.swing.plaf.SplitPaneUI.finishedPaintingChildren(javax.swing.JSplitPane, java.awt.Graphics)


Occurences of fireActionPerformed

fireActionPerformed occurences:
javax.swing.AbstractButton.fireActionPerformed(java.awt.event.ActionEvent)
javax.swing.DefaultButtonModel.fireActionPerformed(java.awt.event.ActionEvent)
javax.swing.JFileChooser.fireActionPerformed(java.lang.String)
javax.swing.JTextField.fireActionPerformed()
javax.swing.Timer.fireActionPerformed(java.awt.event.ActionEvent)


Occurences of fireChangedUpdate

fireChangedUpdate occurences:
javax.swing.text.AbstractDocument.fireChangedUpdate(javax.swing.event.DocumentEvent)
javax.swing.text.html.HTMLDocument.fireChangedUpdate(javax.swing.event.DocumentEvent)


Occurences of fireContentsChanged

fireContentsChanged occurences:
javax.swing.AbstractListModel.fireContentsChanged(java.lang.Object, int, int)
javax.swing.plaf.basic.BasicDirectoryModel.fireContentsChanged()


Occurences of fireIndexedPropertyChange

fireIndexedPropertyChange occurences:
java.beans.PropertyChangeSupport.fireIndexedPropertyChange(java.lang.String, int, boolean, boolean)
java.beans.PropertyChangeSupport.fireIndexedPropertyChange(java.lang.String, int, int, int)
java.beans.PropertyChangeSupport.fireIndexedPropertyChange(java.lang.String, int, java.lang.Object, java.lang.Object)


Occurences of fireItemStateChanged

fireItemStateChanged occurences:
javax.swing.AbstractButton.fireItemStateChanged(java.awt.event.ItemEvent)
javax.swing.DefaultButtonModel.fireItemStateChanged(java.awt.event.ItemEvent)
javax.swing.JComboBox.fireItemStateChanged(java.awt.event.ItemEvent)


Occurences of firePopupMenuCanceled

firePopupMenuCanceled occurences:
javax.swing.JComboBox.firePopupMenuCanceled()
javax.swing.JPopupMenu.firePopupMenuCanceled()
javax.swing.plaf.basic.BasicComboPopup.firePopupMenuCanceled()


Occurences of firePopupMenuWillBecomeInvisible

firePopupMenuWillBecomeInvisible occurences:
javax.swing.JComboBox.firePopupMenuWillBecomeInvisible()
javax.swing.JPopupMenu.firePopupMenuWillBecomeInvisible()
javax.swing.plaf.basic.BasicComboPopup.firePopupMenuWillBecomeInvisible()


Occurences of firePopupMenuWillBecomeVisible

firePopupMenuWillBecomeVisible occurences:
javax.swing.JComboBox.firePopupMenuWillBecomeVisible()
javax.swing.JPopupMenu.firePopupMenuWillBecomeVisible()
javax.swing.plaf.basic.BasicComboPopup.firePopupMenuWillBecomeVisible()


Occurences of firePropertyChange

firePropertyChange occurences:
java.awt.Component.firePropertyChange(java.lang.String, boolean, boolean)
java.awt.Component.firePropertyChange(java.lang.String, byte, byte)
java.awt.Component.firePropertyChange(java.lang.String, char, char)
java.awt.Component.firePropertyChange(java.lang.String, double, double)
java.awt.Component.firePropertyChange(java.lang.String, float, float)
java.awt.Component.firePropertyChange(java.lang.String, int, int)
java.awt.Component.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
java.awt.Component.firePropertyChange(java.lang.String, long, long)
java.awt.Component.firePropertyChange(java.lang.String, short, short)
java.awt.KeyboardFocusManager.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
java.beans.beancontext.BeanContextChildSupport.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
java.beans.PropertyChangeSupport.firePropertyChange(java.beans.PropertyChangeEvent)
java.beans.PropertyChangeSupport.firePropertyChange(java.lang.String, boolean, boolean)
java.beans.PropertyChangeSupport.firePropertyChange(java.lang.String, int, int)
java.beans.PropertyChangeSupport.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
java.beans.PropertyEditorSupport.firePropertyChange()
javax.accessibility.AccessibleContext.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.AbstractAction.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, boolean, boolean)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, byte, byte)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, char, char)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, double, double)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, float, float)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, int, int)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, long, long)
javax.swing.DefaultListCellRenderer.firePropertyChange(java.lang.String, short, short)
javax.swing.event.SwingPropertyChangeSupport.firePropertyChange(java.beans.PropertyChangeEvent)
javax.swing.JComponent.firePropertyChange(java.lang.String, boolean, boolean)
javax.swing.JComponent.firePropertyChange(java.lang.String, char, char)
javax.swing.JComponent.firePropertyChange(java.lang.String, int, int)
javax.swing.JViewport.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.plaf.basic.BasicDirectoryModel.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.SwingWorker.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.table.DefaultTableCellRenderer.firePropertyChange(java.lang.String, boolean, boolean)
javax.swing.table.DefaultTableCellRenderer.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, boolean, boolean)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, byte, byte)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, char, char)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, double, double)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, float, float)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, int, int)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, long, long)
javax.swing.tree.DefaultTreeCellRenderer.firePropertyChange(java.lang.String, short, short)
javax.swing.UIDefaults.firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)


Occurences of fireServiceAdded

fireServiceAdded occurences:
java.beans.beancontext.BeanContextServicesSupport.fireServiceAdded(java.beans.beancontext.BeanContextServiceAvailableEvent)
java.beans.beancontext.BeanContextServicesSupport.fireServiceAdded(java.lang.Class)


Occurences of fireServiceRevoked

fireServiceRevoked occurences:
java.beans.beancontext.BeanContextServicesSupport.fireServiceRevoked(java.beans.beancontext.BeanContextServiceRevokedEvent)
java.beans.beancontext.BeanContextServicesSupport.fireServiceRevoked(java.lang.Class, boolean)


Occurences of fireStateChanged

fireStateChanged occurences:
javax.swing.AbstractButton.fireStateChanged()
javax.swing.AbstractSpinnerModel.fireStateChanged()
javax.swing.colorchooser.DefaultColorSelectionModel.fireStateChanged()
javax.swing.DefaultBoundedRangeModel.fireStateChanged()
javax.swing.DefaultButtonModel.fireStateChanged()
javax.swing.DefaultSingleSelectionModel.fireStateChanged()
javax.swing.JProgressBar.fireStateChanged()
javax.swing.JSlider.fireStateChanged()
javax.swing.JSpinner.fireStateChanged()
javax.swing.JTabbedPane.fireStateChanged()
javax.swing.JViewport.fireStateChanged()
javax.swing.MenuSelectionManager.fireStateChanged()
javax.swing.text.DefaultCaret.fireStateChanged()
javax.swing.text.StyleContext.NamedStyle.fireStateChanged()


Occurences of fireUndoableEditUpdate

fireUndoableEditUpdate occurences:
javax.swing.text.AbstractDocument.fireUndoableEditUpdate(javax.swing.event.UndoableEditEvent)
javax.swing.text.html.HTMLDocument.fireUndoableEditUpdate(javax.swing.event.UndoableEditEvent)


Occurences of fireValueChanged

fireValueChanged occurences:
javax.swing.DefaultListSelectionModel.fireValueChanged(boolean)
javax.swing.DefaultListSelectionModel.fireValueChanged(int, int)
javax.swing.DefaultListSelectionModel.fireValueChanged(int, int, boolean)
javax.swing.JTree.fireValueChanged(javax.swing.event.TreeSelectionEvent)
javax.swing.tree.DefaultTreeSelectionModel.fireValueChanged(javax.swing.event.TreeSelectionEvent)


Occurences of fireVetoableChange

fireVetoableChange occurences:
java.awt.KeyboardFocusManager.fireVetoableChange(java.lang.String, java.lang.Object, java.lang.Object)
java.beans.beancontext.BeanContextChildSupport.fireVetoableChange(java.lang.String, java.lang.Object, java.lang.Object)
java.beans.VetoableChangeSupport.fireVetoableChange(java.beans.PropertyChangeEvent)
java.beans.VetoableChangeSupport.fireVetoableChange(java.lang.String, boolean, boolean)
java.beans.VetoableChangeSupport.fireVetoableChange(java.lang.String, int, int)
java.beans.VetoableChangeSupport.fireVetoableChange(java.lang.String, java.lang.Object, java.lang.Object)
javax.swing.JComponent.fireVetoableChange(java.lang.String, java.lang.Object, java.lang.Object)


Occurences of first

first occurences:
java.awt.CardLayout.first(java.awt.Container)
java.sql.ResultSet.first()
java.text.BreakIterator.first()
java.text.CharacterIterator.first()
java.text.StringCharacterIterator.first()
java.util.concurrent.ConcurrentSkipListSet.first()
java.util.SortedSet.first()
java.util.TreeSet.first()
javax.swing.text.ElementIterator.first()
javax.swing.text.html.parser.ContentModel.first()
javax.swing.text.html.parser.ContentModel.first(java.lang.Object)
javax.swing.text.Segment.first()


Occurences of firstElement

firstElement occurences:
java.util.Vector.firstElement()
javax.swing.DefaultListModel.firstElement()


Occurences of firstEntry

firstEntry occurences:
java.util.concurrent.ConcurrentSkipListMap.firstEntry()
java.util.NavigableMap.firstEntry()
java.util.TreeMap.firstEntry()


Occurences of firstKey

firstKey occurences:
java.util.concurrent.ConcurrentSkipListMap.firstKey()
java.util.SortedMap.firstKey()
java.util.TreeMap.firstKey()


Occurences of firstRow

firstRow occurences:
javax.swing.event.firstRow
javax.swing.firstRow


Occurences of firstSentenceTags

firstSentenceTags occurences:
com.sun.javadoc.Doc.firstSentenceTags()
com.sun.javadoc.Tag.firstSentenceTags()


Occurences of FixedHolder (constructors)

FixedHolder (constructors) occurences:
org.omg.CORBA.FixedHolder()
org.omg.CORBA.FixedHolder(java.math.BigDecimal)


Occurences of flags

flags occurences:
java.util.regex.Pattern.flags()
org.omg.CORBA.NamedValue.flags()


Occurences of FlatteningPathIterator (constructors)

FlatteningPathIterator (constructors) occurences:
java.awt.geom.FlatteningPathIterator(java.awt.geom.PathIterator, double)
java.awt.geom.FlatteningPathIterator(java.awt.geom.PathIterator, double, int)


Occurences of flip

flip occurences:
java.awt.Component.FlipBufferStrategy.flip(java.awt.BufferCapabilities.FlipContents)
java.nio.Buffer.flip()
java.util.BitSet.flip(int)
java.util.BitSet.flip(int, int)


Occurences of flipEastAndWestAtEnds

flipEastAndWestAtEnds occurences:
javax.swing.text.BoxView.flipEastAndWestAtEnds(int, javax.swing.text.Position.Bias)
javax.swing.text.CompositeView.flipEastAndWestAtEnds(int, javax.swing.text.Position.Bias)
javax.swing.text.ParagraphView.flipEastAndWestAtEnds(int, javax.swing.text.Position.Bias)


Occurences of FLOAT

FLOAT occurences:
com.sun.mirror.type.FLOAT
java.sql.FLOAT
javax.lang.model.type.FLOAT
javax.management.openmbean.FLOAT
javax.swing.text.html.FLOAT


Occurences of Float (constructors)

Float (constructors) occurences:
java.lang.Float(double)
java.lang.Float(float)
java.lang.Float(java.lang.String)


Occurences of FloatControl (constructors)

FloatControl (constructors) occurences:
javax.sound.sampled.FloatControl(javax.sound.sampled.FloatControl.Type, float, float, float, int, float, java.lang.String)
javax.sound.sampled.FloatControl(javax.sound.sampled.FloatControl.Type, float, float, float, int, float, java.lang.String, java.lang.String, java.lang.String, java.lang.String)


Occurences of FloatHolder (constructors)

FloatHolder (constructors) occurences:
org.omg.CORBA.FloatHolder()
org.omg.CORBA.FloatHolder(float)


Occurences of FloatSeqHolder (constructors)

FloatSeqHolder (constructors) occurences:
org.omg.CORBA.FloatSeqHolder()
org.omg.CORBA.FloatSeqHolder(float[])


Occurences of floatValue

floatValue occurences:
com.sun.jdi.PrimitiveValue.floatValue()
java.lang.Byte.floatValue()
java.lang.Double.floatValue()
java.lang.Float.floatValue()
java.lang.Integer.floatValue()
java.lang.Long.floatValue()
java.lang.Number.floatValue()
java.lang.Short.floatValue()
java.math.BigDecimal.floatValue()
java.math.BigInteger.floatValue()
java.util.concurrent.atomic.AtomicInteger.floatValue()
java.util.concurrent.atomic.AtomicLong.floatValue()


Occurences of floor

floor occurences:
java.lang.Math.floor(double)
java.lang.StrictMath.floor(double)
java.util.concurrent.ConcurrentSkipListSet.floor(E)
java.util.concurrent.ConcurrentSkipListSet.floor(java.lang.Object)
java.util.NavigableSet.floor(E)
java.util.NavigableSet.floor(java.lang.Object)
java.util.TreeSet.floor(E)
java.util.TreeSet.floor(java.lang.Object)


Occurences of floorEntry

floorEntry occurences:
java.util.concurrent.ConcurrentSkipListMap.floorEntry(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.floorEntry(K)
java.util.NavigableMap.floorEntry(java.lang.Object)
java.util.NavigableMap.floorEntry(K)
java.util.TreeMap.floorEntry(java.lang.Object)
java.util.TreeMap.floorEntry(K)


Occurences of floorKey

floorKey occurences:
java.util.concurrent.ConcurrentSkipListMap.floorKey(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.floorKey(K)
java.util.NavigableMap.floorKey(java.lang.Object)
java.util.NavigableMap.floorKey(K)
java.util.TreeMap.floorKey(java.lang.Object)
java.util.TreeMap.floorKey(K)


Occurences of FlowLayout (constructors)

FlowLayout (constructors) occurences:
java.awt.FlowLayout()
java.awt.FlowLayout(int)
java.awt.FlowLayout(int, int, int)


Occurences of flush

flush occurences:
java.awt.Image.flush()
java.beans.XMLEncoder.flush()
java.io.BufferedOutputStream.flush()
java.io.BufferedWriter.flush()
java.io.CharArrayWriter.flush()
java.io.Console.flush()
java.io.DataOutputStream.flush()
java.io.FilterOutputStream.flush()
java.io.FilterWriter.flush()
java.io.Flushable.flush()
java.io.ObjectOutput.flush()
java.io.ObjectOutputStream.flush()
java.io.OutputStream.flush()
java.io.OutputStreamWriter.flush()
java.io.PipedOutputStream.flush()
java.io.PipedWriter.flush()
java.io.PrintStream.flush()
java.io.PrintWriter.flush()
java.io.StringWriter.flush()
java.io.Writer.flush()
java.nio.charset.CharsetDecoder.flush(java.nio.CharBuffer)
java.nio.charset.CharsetEncoder.flush(java.nio.ByteBuffer)
java.util.Formatter.flush()
java.util.logging.Handler.flush()
java.util.logging.MemoryHandler.flush()
java.util.logging.StreamHandler.flush()
java.util.prefs.AbstractPreferences.flush()
java.util.prefs.Preferences.flush()
java.util.zip.InflaterOutputStream.flush()
javax.crypto.CipherOutputStream.flush()
javax.imageio.stream.ImageInputStream.flush()
javax.imageio.stream.ImageInputStreamImpl.flush()
javax.sound.sampled.DataLine.flush()
javax.swing.text.html.HTMLDocument.HTMLReader.flush()
javax.swing.text.html.HTMLEditorKit.ParserCallback.flush()
javax.tools.ForwardingJavaFileManager.flush()
javax.tools.JavaFileManager.flush()
javax.xml.stream.XMLEventWriter.flush()
javax.xml.stream.XMLStreamWriter.flush()


Occurences of flushBefore

flushBefore occurences:
javax.imageio.stream.FileCacheImageOutputStream.flushBefore(long)
javax.imageio.stream.ImageInputStream.flushBefore(long)
javax.imageio.stream.ImageInputStreamImpl.flushBefore(long)
javax.imageio.stream.ImageOutputStream.flushBefore(long)
javax.imageio.stream.MemoryCacheImageInputStream.flushBefore(long)
javax.imageio.stream.MemoryCacheImageOutputStream.flushBefore(long)


Occurences of focusColor

focusColor occurences:
javax.swing.plaf.metal.focusColor
javax.swing.plaf.metal.focusColor
javax.swing.plaf.metal.focusColor


Occurences of FOCUSED

FOCUSED occurences:
javax.accessibility.FOCUSED
javax.swing.plaf.synth.FOCUSED


Occurences of FocusEvent (constructors)

FocusEvent (constructors) occurences:
java.awt.event.FocusEvent(java.awt.Component, int)
java.awt.event.FocusEvent(java.awt.Component, int, boolean)
java.awt.event.FocusEvent(java.awt.Component, int, boolean, java.awt.Component)


Occurences of focusGained

focusGained occurences:
Class LWTextComponent.LWTextComponent.focusGained(java.awt.event.FocusEvent)
java.awt.AWTEventMulticaster.focusGained(java.awt.event.FocusEvent)
java.awt.Component.AccessibleAWTComponent.AccessibleAWTFocusHandler.focusGained(java.awt.event.FocusEvent)
java.awt.event.FocusAdapter.focusGained(java.awt.event.FocusEvent)
java.awt.event.FocusListener.focusGained(java.awt.event.FocusEvent)
javax.swing.JComponent.AccessibleJComponent.AccessibleFocusHandler.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicButtonListener.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicComboBoxEditor.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicComboBoxUI.FocusHandler.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicListUI.FocusHandler.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicSliderUI.FocusHandler.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicSplitPaneUI.FocusHandler.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicTabbedPaneUI.FocusHandler.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicTableUI.FocusHandler.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicToolBarUI.ToolBarFocusListener.focusGained(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicTreeUI.FocusHandler.focusGained(java.awt.event.FocusEvent)
javax.swing.text.DefaultCaret.focusGained(java.awt.event.FocusEvent)


Occurences of focusListener

focusListener occurences:
javax.swing.plaf.basic.focusListener
javax.swing.plaf.basic.focusListener
javax.swing.plaf.basic.focusListener
javax.swing.plaf.basic.focusListener
javax.swing.plaf.basic.focusListener
javax.swing.plaf.basic.focusListener


Occurences of focusLost

focusLost occurences:
Class LWTextComponent.LWTextComponent.focusLost(java.awt.event.FocusEvent)
java.awt.AWTEventMulticaster.focusLost(java.awt.event.FocusEvent)
java.awt.Component.AccessibleAWTComponent.AccessibleAWTFocusHandler.focusLost(java.awt.event.FocusEvent)
java.awt.event.FocusAdapter.focusLost(java.awt.event.FocusEvent)
java.awt.event.FocusListener.focusLost(java.awt.event.FocusEvent)
javax.swing.JComponent.AccessibleJComponent.AccessibleFocusHandler.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicButtonListener.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicComboBoxEditor.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicComboBoxUI.FocusHandler.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicListUI.FocusHandler.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicSliderUI.FocusHandler.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicSplitPaneUI.FocusHandler.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicTabbedPaneUI.FocusHandler.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicTableUI.FocusHandler.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicToolBarUI.ToolBarFocusListener.focusLost(java.awt.event.FocusEvent)
javax.swing.plaf.basic.BasicTreeUI.FocusHandler.focusLost(java.awt.event.FocusEvent)
javax.swing.text.DefaultCaret.focusLost(java.awt.event.FocusEvent)


Occurences of focusNextComponent

focusNextComponent occurences:
java.awt.DefaultKeyboardFocusManager.focusNextComponent(java.awt.Component)
java.awt.KeyboardFocusManager.focusNextComponent()
java.awt.KeyboardFocusManager.focusNextComponent(java.awt.Component)


Occurences of focusPreviousComponent

focusPreviousComponent occurences:
java.awt.DefaultKeyboardFocusManager.focusPreviousComponent(java.awt.Component)
java.awt.KeyboardFocusManager.focusPreviousComponent()
java.awt.KeyboardFocusManager.focusPreviousComponent(java.awt.Component)


Occurences of FOLIO

FOLIO occurences:
java.awt.FOLIO
javax.print.attribute.standard.FOLIO
javax.print.attribute.standard.FOLIO


Occurences of FONT

FONT occurences:
java.awt.font.FONT
javax.swing.text.html.FONT
javax.swing.text.html.FONT


Occurences of font

font occurences:
java.awt.font
java.awt.font
javax.swing.tree.font


Occurences of Font (constructors)

Font (constructors) occurences:
java.awt.Font(java.awt.Font)
java.awt.Font(java.lang.String, int, int)
java.awt.Font(java.util.Map)


Occurences of FontRenderContext (constructors)

FontRenderContext (constructors) occurences:
java.awt.font.FontRenderContext()
java.awt.font.FontRenderContext(java.awt.geom.AffineTransform, boolean, boolean)
java.awt.font.FontRenderContext(java.awt.geom.AffineTransform, java.lang.Object, java.lang.Object)


Occurences of FontUIResource (constructors)

FontUIResource (constructors) occurences:
javax.swing.plaf.FontUIResource(java.awt.Font)
javax.swing.plaf.FontUIResource(java.lang.String, int, int)


Occurences of force

force occurences:
java.nio.channels.FileChannel.force(boolean)
java.nio.MappedByteBuffer.force()


Occurences of FOREGROUND

FOREGROUND occurences:
java.awt.font.FOREGROUND
javax.swing.plaf.synth.FOREGROUND


Occurences of format

format occurences:
java.io.Console.format(java.lang.String, java.lang.Object...)
java.io.PrintStream.format(java.lang.String, java.lang.Object...)
java.io.PrintStream.format(java.util.Locale, java.lang.String, java.lang.Object...)
java.io.PrintWriter.format(java.lang.String, java.lang.Object...)
java.io.PrintWriter.format(java.util.Locale, java.lang.String, java.lang.Object...)
java.lang.String.format(java.lang.String, java.lang.Object...)
java.lang.String.format(java.util.Locale, java.lang.String, java.lang.Object...)
java.net.format
java.net.format
java.text.ChoiceFormat.format(double, java.lang.StringBuffer, java.text.FieldPosition)
java.text.ChoiceFormat.format(long, java.lang.StringBuffer, java.text.FieldPosition)
java.text.DateFormat.format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
java.text.DateFormat.format(java.util.Date)
java.text.DateFormat.format(java.util.Date, java.lang.StringBuffer, java.text.FieldPosition)
java.text.DecimalFormat.format(double, java.lang.StringBuffer, java.text.FieldPosition)
java.text.DecimalFormat.format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
java.text.DecimalFormat.format(long, java.lang.StringBuffer, java.text.FieldPosition)
java.text.Format.format(java.lang.Object)
java.text.Format.format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
java.text.MessageFormat.format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
java.text.MessageFormat.format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition)
java.text.MessageFormat.format(java.lang.String, java.lang.Object...)
java.text.NumberFormat.format(double)
java.text.NumberFormat.format(double, java.lang.StringBuffer, java.text.FieldPosition)
java.text.NumberFormat.format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
java.text.NumberFormat.format(long)
java.text.NumberFormat.format(long, java.lang.StringBuffer, java.text.FieldPosition)
java.text.SimpleDateFormat.format(java.util.Date, java.lang.StringBuffer, java.text.FieldPosition)
java.util.format
java.util.Formatter.format(java.lang.String, java.lang.Object...)
java.util.Formatter.format(java.util.Locale, java.lang.String, java.lang.Object...)
java.util.logging.Formatter.format(java.util.logging.LogRecord)
java.util.logging.SimpleFormatter.format(java.util.logging.LogRecord)
java.util.logging.XMLFormatter.format(java.util.logging.LogRecord)
javax.sound.sampled.format
org.omg.IOP.format


Occurences of FormatMismatch (constructors)

FormatMismatch (constructors) occurences:
org.omg.IOP.CodecPackage.FormatMismatch()
org.omg.IOP.CodecPackage.FormatMismatch(java.lang.String)


Occurences of Formatter

Formatter occurences:
java.util.Formatter
java.util.logging.Formatter


Occurences of Formatter (constructors)

Formatter (constructors) occurences:
java.util.Formatter()
java.util.Formatter(java.io.File)
java.util.Formatter(java.io.File, java.lang.String)
java.util.Formatter(java.io.File, java.lang.String, java.util.Locale)
java.util.Formatter(java.io.OutputStream)
java.util.Formatter(java.io.OutputStream, java.lang.String)
java.util.Formatter(java.io.OutputStream, java.lang.String, java.util.Locale)
java.util.Formatter(java.io.PrintStream)
java.util.Formatter(java.lang.Appendable)
java.util.Formatter(java.lang.Appendable, java.util.Locale)
java.util.Formatter(java.lang.String)
java.util.Formatter(java.lang.String, java.lang.String)
java.util.Formatter(java.lang.String, java.lang.String, java.util.Locale)
java.util.Formatter(java.util.Locale)
java.util.logging.Formatter()


Occurences of formatToCharacterIterator

formatToCharacterIterator occurences:
java.text.DecimalFormat.formatToCharacterIterator(java.lang.Object)
java.text.Format.formatToCharacterIterator(java.lang.Object)
java.text.MessageFormat.formatToCharacterIterator(java.lang.Object)
java.text.SimpleDateFormat.formatToCharacterIterator(java.lang.Object)


Occurences of forName

forName occurences:
java.lang.Character.UnicodeBlock.forName(java.lang.String)
java.lang.Class.forName(java.lang.String)
java.lang.Class.forName(java.lang.String, boolean, java.lang.ClassLoader)
java.nio.charset.Charset.forName(java.lang.String)


Occurences of ForwardingFileObject (constructors)

ForwardingFileObject (constructors) occurences:
javax.tools.ForwardingFileObject(F)
javax.tools.ForwardingFileObject(javax.tools.FileObject)


Occurences of ForwardingJavaFileManager (constructors)

ForwardingJavaFileManager (constructors) occurences:
javax.tools.ForwardingJavaFileManager(javax.tools.JavaFileManager)
javax.tools.ForwardingJavaFileManager(M)


Occurences of ForwardingJavaFileObject (constructors)

ForwardingJavaFileObject (constructors) occurences:
javax.tools.ForwardingJavaFileObject(F)
javax.tools.ForwardingJavaFileObject(javax.tools.JavaFileObject)


Occurences of ForwardRequest

ForwardRequest occurences:
org.omg.PortableInterceptor.ForwardRequest
org.omg.PortableServer.ForwardRequest


Occurences of ForwardRequest (constructors)

ForwardRequest (constructors) occurences:
org.omg.PortableInterceptor.ForwardRequest()
org.omg.PortableInterceptor.ForwardRequest(java.lang.String, org.omg.CORBA.Object)
org.omg.PortableInterceptor.ForwardRequest(org.omg.CORBA.Object)
org.omg.PortableServer.ForwardRequest()
org.omg.PortableServer.ForwardRequest(java.lang.String, org.omg.CORBA.Object)
org.omg.PortableServer.ForwardRequest(org.omg.CORBA.Object)


Occurences of ForwardRequestHelper

ForwardRequestHelper occurences:
org.omg.PortableInterceptor.ForwardRequestHelper
org.omg.PortableServer.ForwardRequestHelper


Occurences of ForwardRequestHelper (constructors)

ForwardRequestHelper (constructors) occurences:
org.omg.PortableInterceptor.ForwardRequestHelper()
org.omg.PortableServer.ForwardRequestHelper()


Occurences of forwardUpdate

forwardUpdate occurences:
javax.swing.text.BoxView.forwardUpdate(javax.swing.event.DocumentEvent.ElementChange, javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.TableView.forwardUpdate(javax.swing.event.DocumentEvent.ElementChange, javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.View.forwardUpdate(javax.swing.event.DocumentEvent.ElementChange, javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)


Occurences of forward_reference

forward_reference occurences:
org.omg.PortableInterceptor.RequestInfoOperations.forward_reference()
org.omg.PortableServer.forward_reference


Occurences of frame

frame occurences:
com.sun.jdi.ThreadReference.frame(int)
javax.swing.plaf.basic.frame
javax.swing.plaf.basic.frame
javax.swing.plaf.basic.frame


Occurences of FRAME

FRAME occurences:
javax.accessibility.FRAME
javax.swing.FRAME
javax.swing.text.html.FRAME


Occurences of Frame (constructors)

Frame (constructors) occurences:
java.awt.Frame()
java.awt.Frame(java.awt.GraphicsConfiguration)
java.awt.Frame(java.lang.String)
java.awt.Frame(java.lang.String, java.awt.GraphicsConfiguration)


Occurences of frames

frames occurences:
com.sun.jdi.ThreadReference.frames()
com.sun.jdi.ThreadReference.frames(int, int)


Occurences of frameSize

frameSize occurences:
javax.sound.sampled.frameSize
javax.sound.sampled.frameSize


Occurences of free

free occurences:
java.sql.Array.free()
java.sql.Blob.free()
java.sql.Clob.free()
java.sql.SQLXML.free()
javax.sql.rowset.serial.SerialArray.free()
javax.sql.rowset.serial.SerialBlob.free()
javax.sql.rowset.serial.SerialClob.free()


Occurences of FREE_MEM (constructors)

FREE_MEM (constructors) occurences:
org.omg.CORBA.FREE_MEM()
org.omg.CORBA.FREE_MEM(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.FREE_MEM(java.lang.String)
org.omg.CORBA.FREE_MEM(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of Frequently Asked Questions

Frequently Asked Questions occurences:
Frequently Asked Questions
Frequently Asked Questions


Occurences of from

from occurences:
java.lang.management.MemoryNotificationInfo.from(javax.management.openmbean.CompositeData)
java.lang.management.MemoryUsage.from(javax.management.openmbean.CompositeData)
java.lang.management.MonitorInfo.from(javax.management.openmbean.CompositeData)
java.lang.management.ThreadInfo.from(javax.management.openmbean.CompositeData)


Occurences of fromCIEXYZ

fromCIEXYZ occurences:
java.awt.color.ColorSpace.fromCIEXYZ(float[])
java.awt.color.ICC_ColorSpace.fromCIEXYZ(float[])


Occurences of fromRGB

fromRGB occurences:
java.awt.color.ColorSpace.fromRGB(float[])
java.awt.color.ICC_ColorSpace.fromRGB(float[])


Occurences of from_any

from_any occurences:
org.omg.CORBA.DynAny.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnyOperations.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynAnyStub.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynArrayStub.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynEnumStub.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynFixedStub.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynSequenceStub.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynStructStub.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynUnionStub.from_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynValueStub.from_any(org.omg.CORBA.Any)


Occurences of from_int

from_int occurences:
org.omg.CORBA.CompletionStatus.from_int(int)
org.omg.CORBA.DefinitionKind.from_int(int)
org.omg.CORBA.ParameterMode.from_int(int)
org.omg.CORBA.SetOverrideType.from_int(int)
org.omg.CORBA.TCKind.from_int(int)
org.omg.CosNaming.BindingType.from_int(int)
org.omg.CosNaming.NamingContextPackage.NotFoundReason.from_int(int)
org.omg.PortableServer.IdAssignmentPolicyValue.from_int(int)
org.omg.PortableServer.IdUniquenessPolicyValue.from_int(int)
org.omg.PortableServer.ImplicitActivationPolicyValue.from_int(int)
org.omg.PortableServer.LifespanPolicyValue.from_int(int)
org.omg.PortableServer.POAManagerPackage.State.from_int(int)
org.omg.PortableServer.RequestProcessingPolicyValue.from_int(int)
org.omg.PortableServer.ServantRetentionPolicyValue.from_int(int)
org.omg.PortableServer.ThreadPolicyValue.from_int(int)


Occurences of FutureTask (constructors)

FutureTask (constructors) occurences:
java.util.concurrent.FutureTask(java.lang.Runnable, V)
java.util.concurrent.FutureTask(java.lang.Runnable,java.lang.Object)
java.util.concurrent.FutureTask(java.util.concurrent.Callable)


Occurences of GapContent (constructors)

GapContent (constructors) occurences:
javax.swing.text.GapContent()
javax.swing.text.GapContent(int)


Occurences of gc

gc occurences:
java.lang.management.MemoryMXBean.gc()
java.lang.Runtime.gc()
java.lang.System.gc()


Occurences of GeneralPath (constructors)

GeneralPath (constructors) occurences:
java.awt.geom.GeneralPath()
java.awt.geom.GeneralPath(int)
java.awt.geom.GeneralPath(int, int)
java.awt.geom.GeneralPath(java.awt.Shape)


Occurences of GeneralSecurityException (constructors)

GeneralSecurityException (constructors) occurences:
java.security.GeneralSecurityException()
java.security.GeneralSecurityException(java.lang.String)
java.security.GeneralSecurityException(java.lang.String, java.lang.Throwable)
java.security.GeneralSecurityException(java.lang.Throwable)


Occurences of generateCertPath

generateCertPath occurences:
java.security.cert.CertificateFactory.generateCertPath(java.io.InputStream)
java.security.cert.CertificateFactory.generateCertPath(java.io.InputStream, java.lang.String)
java.security.cert.CertificateFactory.generateCertPath(java.util.List)


Occurences of generateKeyPair

generateKeyPair occurences:
java.security.KeyPairGenerator.generateKeyPair()
java.security.KeyPairGeneratorSpi.generateKeyPair()


Occurences of generateSecret

generateSecret occurences:
javax.crypto.KeyAgreement.generateSecret()
javax.crypto.KeyAgreement.generateSecret(byte[], int)
javax.crypto.KeyAgreement.generateSecret(java.lang.String)
javax.crypto.SecretKeyFactory.generateSecret(java.security.spec.KeySpec)


Occurences of genericSignature

genericSignature occurences:
com.sun.jdi.LocalVariable.genericSignature()
com.sun.jdi.ReferenceType.genericSignature()
com.sun.jdi.TypeComponent.genericSignature()


Occurences of genExemptionBlob

genExemptionBlob occurences:
javax.crypto.ExemptionMechanism.genExemptionBlob()
javax.crypto.ExemptionMechanism.genExemptionBlob(byte[])
javax.crypto.ExemptionMechanism.genExemptionBlob(byte[], int)


Occurences of get

get occurences:
java.awt.RenderingHints.get(java.lang.Object)
java.beans.Encoder.get(java.lang.Object)
java.io.ObjectInputStream.GetField.get(java.lang.String, boolean)
java.io.ObjectInputStream.GetField.get(java.lang.String, byte)
java.io.ObjectInputStream.GetField.get(java.lang.String, char)
java.io.ObjectInputStream.GetField.get(java.lang.String, double)
java.io.ObjectInputStream.GetField.get(java.lang.String, float)
java.io.ObjectInputStream.GetField.get(java.lang.String, int)
java.io.ObjectInputStream.GetField.get(java.lang.String, java.lang.Object)
java.io.ObjectInputStream.GetField.get(java.lang.String, long)
java.io.ObjectInputStream.GetField.get(java.lang.String, short)
java.lang.ref.PhantomReference.get()
java.lang.ref.Reference.get()
java.lang.ref.SoftReference.get()
java.lang.reflect.Array.get(java.lang.Object, int)
java.lang.reflect.Field.get(java.lang.Object)
java.lang.ThreadLocal.get()
java.net.CookieHandler.get(java.net.URI, java.util.Map)
java.net.CookieManager.get(java.net.URI, java.util.Map)
java.net.CookieStore.get(java.net.URI)
java.net.ResponseCache.get(java.net.URI, java.lang.String, java.util.Map)
java.nio.ByteBuffer.get()
java.nio.ByteBuffer.get(byte[])
java.nio.ByteBuffer.get(byte[], int, int)
java.nio.ByteBuffer.get(int)
java.nio.CharBuffer.get()
java.nio.CharBuffer.get(char[])
java.nio.CharBuffer.get(char[], int, int)
java.nio.CharBuffer.get(int)
java.nio.DoubleBuffer.get()
java.nio.DoubleBuffer.get(double[])
java.nio.DoubleBuffer.get(double[], int, int)
java.nio.DoubleBuffer.get(int)
java.nio.FloatBuffer.get()
java.nio.FloatBuffer.get(float[])
java.nio.FloatBuffer.get(float[], int, int)
java.nio.FloatBuffer.get(int)
java.nio.IntBuffer.get()
java.nio.IntBuffer.get(int)
java.nio.IntBuffer.get(int[])
java.nio.IntBuffer.get(int[], int, int)
java.nio.LongBuffer.get()
java.nio.LongBuffer.get(int)
java.nio.LongBuffer.get(long[])
java.nio.LongBuffer.get(long[], int, int)
java.nio.ShortBuffer.get()
java.nio.ShortBuffer.get(int)
java.nio.ShortBuffer.get(short[])
java.nio.ShortBuffer.get(short[], int, int)
java.rmi.MarshalledObject.get()
java.security.Provider.get(java.lang.Object)
java.util.AbstractList.get(int)
java.util.AbstractMap.get(java.lang.Object)
java.util.AbstractSequentialList.get(int)
java.util.ArrayList.get(int)
java.util.BitSet.get(int)
java.util.BitSet.get(int, int)
java.util.Calendar.get(int)
java.util.concurrent.atomic.AtomicBoolean.get()
java.util.concurrent.atomic.AtomicInteger.get()
java.util.concurrent.atomic.AtomicIntegerArray.get(int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.get(java.lang.Object)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.get(T)
java.util.concurrent.atomic.AtomicLong.get()
java.util.concurrent.atomic.AtomicLongArray.get(int)
java.util.concurrent.atomic.AtomicLongFieldUpdater.get(java.lang.Object)
java.util.concurrent.atomic.AtomicLongFieldUpdater.get(T)
java.util.concurrent.atomic.AtomicMarkableReference.get(boolean[])
java.util.concurrent.atomic.AtomicReference.get()
java.util.concurrent.atomic.AtomicReferenceArray.get(int)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.get(java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.get(T)
java.util.concurrent.atomic.AtomicStampedReference.get(int[])
java.util.concurrent.ConcurrentHashMap.get(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.get(java.lang.Object)
java.util.concurrent.CopyOnWriteArrayList.get(int)
java.util.concurrent.Future.get()
java.util.concurrent.Future.get(long, java.util.concurrent.TimeUnit)
java.util.concurrent.FutureTask.get()
java.util.concurrent.FutureTask.get(long, java.util.concurrent.TimeUnit)
java.util.Dictionary.get(java.lang.Object)
java.util.EnumMap.get(java.lang.Object)
java.util.HashMap.get(java.lang.Object)
java.util.Hashtable.get(java.lang.Object)
java.util.IdentityHashMap.get(java.lang.Object)
java.util.jar.Attributes.get(java.lang.Object)
java.util.LinkedHashMap.get(java.lang.Object)
java.util.LinkedList.get(int)
java.util.List.get(int)
java.util.Map.get(java.lang.Object)
java.util.prefs.AbstractPreferences.get(java.lang.String, java.lang.String)
java.util.prefs.Preferences.get(java.lang.String, java.lang.String)
java.util.TreeMap.get(java.lang.Object)
java.util.Vector.get(int)
java.util.WeakHashMap.get(java.lang.Object)
javax.accessibility.AccessibleRelationSet.get(java.lang.String)
javax.activation.MimeTypeParameterList.get(java.lang.String)
javax.management.openmbean.CompositeData.get(java.lang.String)
javax.management.openmbean.CompositeDataSupport.get(java.lang.String)
javax.management.openmbean.TabularData.get(java.lang.Object[])
javax.management.openmbean.TabularDataSupport.get(java.lang.Object)
javax.management.openmbean.TabularDataSupport.get(java.lang.Object[])
javax.naming.CompositeName.get(int)
javax.naming.CompoundName.get(int)
javax.naming.directory.Attribute.get()
javax.naming.directory.Attribute.get(int)
javax.naming.directory.Attributes.get(java.lang.String)
javax.naming.directory.BasicAttribute.get()
javax.naming.directory.BasicAttribute.get(int)
javax.naming.directory.BasicAttributes.get(java.lang.String)
javax.naming.ldap.LdapName.get(int)
javax.naming.Name.get(int)
javax.naming.Reference.get(int)
javax.naming.Reference.get(java.lang.String)
javax.print.attribute.AttributeSet.get(java.lang.Class)
javax.print.attribute.HashAttributeSet.get(java.lang.Class)
javax.script.AbstractScriptEngine.get(java.lang.String)
javax.script.Bindings.get(java.lang.Object)
javax.script.ScriptEngine.get(java.lang.String)
javax.script.ScriptEngineManager.get(java.lang.String)
javax.script.SimpleBindings.get(java.lang.Object)
javax.sound.midi.Track.get(int)
javax.swing.ActionMap.get(java.lang.Object)
javax.swing.DefaultListModel.get(int)
javax.swing.InputMap.get(javax.swing.KeyStroke)
javax.swing.plaf.synth.SynthStyle.get(javax.swing.plaf.synth.SynthContext, java.lang.Object)
javax.swing.SwingWorker.get()
javax.swing.SwingWorker.get(long, java.util.concurrent.TimeUnit)
javax.swing.UIDefaults.get(java.lang.Object)
javax.swing.UIDefaults.get(java.lang.Object, java.util.Locale)
javax.swing.UIManager.get(java.lang.Object)
javax.swing.UIManager.get(java.lang.Object, java.util.Locale)
javax.xml.crypto.dom.DOMCryptoContext.get(java.lang.Object)
javax.xml.crypto.XMLCryptoContext.get(java.lang.Object)
javax.xml.soap.SOAPConnection.get(java.lang.Object)


Occurences of getAcceleratorForeground

getAcceleratorForeground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getAcceleratorForeground()
javax.swing.plaf.metal.MetalTheme.getAcceleratorForeground()


Occurences of getAcceleratorSelectedForeground

getAcceleratorSelectedForeground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getAcceleratorSelectedForeground()
javax.swing.plaf.metal.MetalTheme.getAcceleratorSelectedForeground()


Occurences of getAcceptAllFileFilter

getAcceptAllFileFilter occurences:
javax.swing.JFileChooser.getAcceptAllFileFilter()
javax.swing.plaf.basic.BasicFileChooserUI.getAcceptAllFileFilter(javax.swing.JFileChooser)
javax.swing.plaf.FileChooserUI.getAcceptAllFileFilter(javax.swing.JFileChooser)
javax.swing.plaf.multi.MultiFileChooserUI.getAcceptAllFileFilter(javax.swing.JFileChooser)


Occurences of getAccessibleAction

getAccessibleAction occurences:
java.awt.Button.AccessibleAWTButton.getAccessibleAction()
java.awt.Checkbox.AccessibleAWTCheckbox.getAccessibleAction()
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.getAccessibleAction()
java.awt.Choice.AccessibleAWTChoice.getAccessibleAction()
java.awt.MenuItem.AccessibleAWTMenuItem.getAccessibleAction()
javax.accessibility.AccessibleContext.getAccessibleAction()
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleAction()
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleAction()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleAction()
javax.swing.JSpinner.AccessibleJSpinner.getAccessibleAction()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleAction()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleAction()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleAction()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAccessibleAction()


Occurences of getAccessibleActionAnchor

getAccessibleActionAnchor occurences:
javax.accessibility.AccessibleHyperlink.getAccessibleActionAnchor(int)
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.HTMLLink.getAccessibleActionAnchor(int)


Occurences of getAccessibleActionCount

getAccessibleActionCount occurences:
java.awt.Button.AccessibleAWTButton.getAccessibleActionCount()
java.awt.Checkbox.AccessibleAWTCheckbox.getAccessibleActionCount()
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.getAccessibleActionCount()
java.awt.Choice.AccessibleAWTChoice.getAccessibleActionCount()
java.awt.MenuItem.AccessibleAWTMenuItem.getAccessibleActionCount()
javax.accessibility.AccessibleAction.getAccessibleActionCount()
javax.accessibility.AccessibleHyperlink.getAccessibleActionCount()
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleActionCount()
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleActionCount()
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.HTMLLink.getAccessibleActionCount()
javax.swing.JSpinner.AccessibleJSpinner.getAccessibleActionCount()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleActionCount()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAccessibleActionCount()


Occurences of getAccessibleActionDescription

getAccessibleActionDescription occurences:
java.awt.Button.AccessibleAWTButton.getAccessibleActionDescription(int)
java.awt.Checkbox.AccessibleAWTCheckbox.getAccessibleActionDescription(int)
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.getAccessibleActionDescription(int)
java.awt.Choice.AccessibleAWTChoice.getAccessibleActionDescription(int)
java.awt.MenuItem.AccessibleAWTMenuItem.getAccessibleActionDescription(int)
javax.accessibility.AccessibleAction.getAccessibleActionDescription(int)
javax.accessibility.AccessibleHyperlink.getAccessibleActionDescription(int)
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleActionDescription(int)
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleActionDescription(int)
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.HTMLLink.getAccessibleActionDescription(int)
javax.swing.JSpinner.AccessibleJSpinner.getAccessibleActionDescription(int)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleActionDescription(int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAccessibleActionDescription(int)


Occurences of getAccessibleActionObject

getAccessibleActionObject occurences:
javax.accessibility.AccessibleHyperlink.getAccessibleActionObject(int)
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.HTMLLink.getAccessibleActionObject(int)


Occurences of getAccessibleAt

getAccessibleAt occurences:
java.awt.Component.AccessibleAWTComponent.getAccessibleAt(java.awt.Point)
java.awt.Container.AccessibleAWTContainer.getAccessibleAt(java.awt.Point)
java.awt.List.AccessibleAWTList.getAccessibleAt(java.awt.Point)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getAccessibleAt(java.awt.Point)
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleAt(java.awt.Point)
javax.accessibility.AccessibleComponent.getAccessibleAt(java.awt.Point)
javax.accessibility.AccessibleTable.getAccessibleAt(int, int)
javax.swing.JEditorPane.AccessibleJEditorPaneHTML.getAccessibleAt(java.awt.Point)
javax.swing.JList.AccessibleJList.getAccessibleAt(java.awt.Point)
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleAt(java.awt.Point)
javax.swing.JTabbedPane.AccessibleJTabbedPane.getAccessibleAt(java.awt.Point)
javax.swing.JTable.AccessibleJTable.getAccessibleAt(int, int)
javax.swing.JTable.AccessibleJTable.getAccessibleAt(java.awt.Point)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleAt(java.awt.Point)
javax.swing.JTree.AccessibleJTree.getAccessibleAt(java.awt.Point)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleAt(java.awt.Point)
javax.swing.SwingUtilities.getAccessibleAt(java.awt.Component, java.awt.Point)
javax.swing.table.JTableHeader.AccessibleJTableHeader.getAccessibleAt(java.awt.Point)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleAt(java.awt.Point)


Occurences of getAccessibleCaption

getAccessibleCaption occurences:
javax.accessibility.AccessibleTable.getAccessibleCaption()
javax.swing.JTable.AccessibleJTable.getAccessibleCaption()


Occurences of getAccessibleChild

getAccessibleChild occurences:
java.awt.Component.AccessibleAWTComponent.getAccessibleChild(int)
java.awt.Container.AccessibleAWTContainer.getAccessibleChild(int)
java.awt.List.AccessibleAWTList.getAccessibleChild(int)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getAccessibleChild(int)
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleChild(int)
javax.accessibility.AccessibleContext.getAccessibleChild(int)
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleChild(int)
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleChild(int)
javax.swing.JComponent.AccessibleJComponent.getAccessibleChild(int)
javax.swing.JEditorPane.AccessibleJEditorPaneHTML.getAccessibleChild(int)
javax.swing.JList.AccessibleJList.getAccessibleChild(int)
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleChild(int)
javax.swing.JMenu.AccessibleJMenu.getAccessibleChild(int)
javax.swing.JRootPane.AccessibleJRootPane.getAccessibleChild(int)
javax.swing.JSpinner.AccessibleJSpinner.getAccessibleChild(int)
javax.swing.JTabbedPane.AccessibleJTabbedPane.getAccessibleChild(int)
javax.swing.JTable.AccessibleJTable.getAccessibleChild(int)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleChild(int)
javax.swing.JTree.AccessibleJTree.getAccessibleChild(int)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleChild(int)
javax.swing.plaf.basic.BasicComboBoxUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.ComponentUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiButtonUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiColorChooserUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiComboBoxUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiDesktopIconUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiDesktopPaneUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiFileChooserUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiInternalFrameUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiLabelUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiListUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiMenuBarUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiMenuItemUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiOptionPaneUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiPanelUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiPopupMenuUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiProgressBarUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiRootPaneUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiScrollBarUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiScrollPaneUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiSeparatorUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiSliderUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiSpinnerUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiSplitPaneUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiTabbedPaneUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiTableHeaderUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiTableUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiTextUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiToolBarUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiToolTipUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiTreeUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.plaf.multi.MultiViewportUI.getAccessibleChild(javax.swing.JComponent, int)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleChild(int)
javax.swing.SwingUtilities.getAccessibleChild(java.awt.Component, int)
javax.swing.table.JTableHeader.AccessibleJTableHeader.getAccessibleChild(int)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleChild(int)


Occurences of getAccessibleChildrenCount

getAccessibleChildrenCount occurences:
java.awt.Component.AccessibleAWTComponent.getAccessibleChildrenCount()
java.awt.Container.AccessibleAWTContainer.getAccessibleChildrenCount()
java.awt.List.AccessibleAWTList.getAccessibleChildrenCount()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getAccessibleChildrenCount()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleChildrenCount()
javax.accessibility.AccessibleContext.getAccessibleChildrenCount()
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleChildrenCount()
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleChildrenCount()
javax.swing.JComponent.AccessibleJComponent.getAccessibleChildrenCount()
javax.swing.JEditorPane.AccessibleJEditorPaneHTML.getAccessibleChildrenCount()
javax.swing.JList.AccessibleJList.getAccessibleChildrenCount()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleChildrenCount()
javax.swing.JMenu.AccessibleJMenu.getAccessibleChildrenCount()
javax.swing.JRootPane.AccessibleJRootPane.getAccessibleChildrenCount()
javax.swing.JSpinner.AccessibleJSpinner.getAccessibleChildrenCount()
javax.swing.JTabbedPane.AccessibleJTabbedPane.getAccessibleChildrenCount()
javax.swing.JTable.AccessibleJTable.getAccessibleChildrenCount()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleChildrenCount()
javax.swing.JTree.AccessibleJTree.getAccessibleChildrenCount()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleChildrenCount()
javax.swing.plaf.basic.BasicComboBoxUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.ComponentUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiButtonUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.getAccessibleChildrenCount(javax.swing.JComponent)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleChildrenCount()
javax.swing.SwingUtilities.getAccessibleChildrenCount(java.awt.Component)
javax.swing.table.JTableHeader.AccessibleJTableHeader.getAccessibleChildrenCount()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleChildrenCount()


Occurences of getAccessibleColumn

getAccessibleColumn occurences:
javax.accessibility.AccessibleExtendedTable.getAccessibleColumn(int)
javax.swing.JTable.AccessibleJTable.getAccessibleColumn(int)


Occurences of getAccessibleColumnCount

getAccessibleColumnCount occurences:
javax.accessibility.AccessibleTable.getAccessibleColumnCount()
javax.swing.JTable.AccessibleJTable.getAccessibleColumnCount()


Occurences of getAccessibleColumnDescription

getAccessibleColumnDescription occurences:
javax.accessibility.AccessibleTable.getAccessibleColumnDescription(int)
javax.swing.JTable.AccessibleJTable.getAccessibleColumnDescription(int)


Occurences of getAccessibleColumnExtentAt

getAccessibleColumnExtentAt occurences:
javax.accessibility.AccessibleTable.getAccessibleColumnExtentAt(int, int)
javax.swing.JTable.AccessibleJTable.getAccessibleColumnExtentAt(int, int)


Occurences of getAccessibleColumnHeader

getAccessibleColumnHeader occurences:
javax.accessibility.AccessibleTable.getAccessibleColumnHeader()
javax.swing.JTable.AccessibleJTable.getAccessibleColumnHeader()


Occurences of getAccessibleComponent

getAccessibleComponent occurences:
java.awt.Component.AccessibleAWTComponent.getAccessibleComponent()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleComponent()
javax.accessibility.AccessibleContext.getAccessibleComponent()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleComponent()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleComponent()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleComponent()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleComponent()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleComponent()


Occurences of getAccessibleContext

getAccessibleContext occurences:
java.applet.Applet.getAccessibleContext()
java.awt.Button.getAccessibleContext()
java.awt.Canvas.getAccessibleContext()
java.awt.Checkbox.getAccessibleContext()
java.awt.CheckboxMenuItem.getAccessibleContext()
java.awt.Choice.getAccessibleContext()
java.awt.Component.getAccessibleContext()
java.awt.Dialog.getAccessibleContext()
java.awt.Frame.getAccessibleContext()
java.awt.Label.getAccessibleContext()
java.awt.List.getAccessibleContext()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getAccessibleContext()
java.awt.Menu.getAccessibleContext()
java.awt.MenuBar.getAccessibleContext()
java.awt.MenuComponent.getAccessibleContext()
java.awt.MenuItem.getAccessibleContext()
java.awt.Panel.getAccessibleContext()
java.awt.PopupMenu.getAccessibleContext()
java.awt.Scrollbar.getAccessibleContext()
java.awt.ScrollPane.getAccessibleContext()
java.awt.TextArea.getAccessibleContext()
java.awt.TextComponent.getAccessibleContext()
java.awt.TextField.getAccessibleContext()
java.awt.Window.getAccessibleContext()
javax.accessibility.Accessible.getAccessibleContext()
javax.swing.Box.getAccessibleContext()
javax.swing.Box.Filler.getAccessibleContext()
javax.swing.CellRendererPane.getAccessibleContext()
javax.swing.ImageIcon.getAccessibleContext()
javax.swing.JApplet.getAccessibleContext()
javax.swing.JButton.getAccessibleContext()
javax.swing.JCheckBox.getAccessibleContext()
javax.swing.JCheckBoxMenuItem.getAccessibleContext()
javax.swing.JColorChooser.getAccessibleContext()
javax.swing.JComboBox.getAccessibleContext()
javax.swing.JComponent.getAccessibleContext()
javax.swing.JDesktopPane.getAccessibleContext()
javax.swing.JDialog.getAccessibleContext()
javax.swing.JEditorPane.getAccessibleContext()
javax.swing.JFileChooser.getAccessibleContext()
javax.swing.JFrame.getAccessibleContext()
javax.swing.JInternalFrame.getAccessibleContext()
javax.swing.JInternalFrame.JDesktopIcon.getAccessibleContext()
javax.swing.JLabel.getAccessibleContext()
javax.swing.JLayeredPane.getAccessibleContext()
javax.swing.JList.getAccessibleContext()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleContext()
javax.swing.JMenu.getAccessibleContext()
javax.swing.JMenuBar.getAccessibleContext()
javax.swing.JMenuItem.getAccessibleContext()
javax.swing.JOptionPane.getAccessibleContext()
javax.swing.JPanel.getAccessibleContext()
javax.swing.JPasswordField.getAccessibleContext()
javax.swing.JPopupMenu.getAccessibleContext()
javax.swing.JProgressBar.getAccessibleContext()
javax.swing.JRadioButton.getAccessibleContext()
javax.swing.JRadioButtonMenuItem.getAccessibleContext()
javax.swing.JRootPane.getAccessibleContext()
javax.swing.JScrollBar.getAccessibleContext()
javax.swing.JScrollPane.getAccessibleContext()
javax.swing.JSeparator.getAccessibleContext()
javax.swing.JSlider.getAccessibleContext()
javax.swing.JSpinner.getAccessibleContext()
javax.swing.JSplitPane.getAccessibleContext()
javax.swing.JTabbedPane.getAccessibleContext()
javax.swing.JTable.getAccessibleContext()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleContext()
javax.swing.JTextArea.getAccessibleContext()
javax.swing.JTextField.getAccessibleContext()
javax.swing.JToggleButton.getAccessibleContext()
javax.swing.JToolBar.getAccessibleContext()
javax.swing.JToolTip.getAccessibleContext()
javax.swing.JTree.getAccessibleContext()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleContext()
javax.swing.JViewport.getAccessibleContext()
javax.swing.JWindow.getAccessibleContext()
javax.swing.plaf.basic.BasicComboPopup.getAccessibleContext()
javax.swing.ProgressMonitor.getAccessibleContext()
javax.swing.table.JTableHeader.getAccessibleContext()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleContext()
javax.swing.text.html.HTMLEditorKit.getAccessibleContext()
javax.swing.text.JTextComponent.getAccessibleContext()


Occurences of getAccessibleDescription

getAccessibleDescription occurences:
java.awt.Component.AccessibleAWTComponent.getAccessibleDescription()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleDescription()
javax.accessibility.AccessibleContext.getAccessibleDescription()
javax.swing.JComponent.AccessibleJComponent.getAccessibleDescription()
javax.swing.JEditorPane.AccessibleJEditorPane.getAccessibleDescription()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleDescription()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleDescription()
javax.swing.JToolTip.AccessibleJToolTip.getAccessibleDescription()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleDescription()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleDescription()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleDescription()


Occurences of getAccessibleEditableText

getAccessibleEditableText occurences:
javax.accessibility.AccessibleContext.getAccessibleEditableText()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAccessibleEditableText()


Occurences of getAccessibleIcon

getAccessibleIcon occurences:
javax.accessibility.AccessibleContext.getAccessibleIcon()
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleIcon()
javax.swing.JLabel.AccessibleJLabel.getAccessibleIcon()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleIcon()


Occurences of getAccessibleIconDescription

getAccessibleIconDescription occurences:
javax.accessibility.AccessibleIcon.getAccessibleIconDescription()
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleIconDescription()


Occurences of getAccessibleIconHeight

getAccessibleIconHeight occurences:
javax.accessibility.AccessibleIcon.getAccessibleIconHeight()
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleIconHeight()


Occurences of getAccessibleIconWidth

getAccessibleIconWidth occurences:
javax.accessibility.AccessibleIcon.getAccessibleIconWidth()
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleIconWidth()


Occurences of getAccessibleIndex

getAccessibleIndex occurences:
javax.accessibility.AccessibleExtendedTable.getAccessibleIndex(int, int)
javax.swing.JTable.AccessibleJTable.getAccessibleIndex(int, int)


Occurences of getAccessibleIndexInParent

getAccessibleIndexInParent occurences:
java.awt.Component.AccessibleAWTComponent.getAccessibleIndexInParent()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getAccessibleIndexInParent()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleIndexInParent()
javax.accessibility.AccessibleContext.getAccessibleIndexInParent()
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleIndexInParent()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleIndexInParent()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleIndexInParent()
javax.swing.JTree.AccessibleJTree.getAccessibleIndexInParent()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleIndexInParent()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleIndexInParent()
javax.swing.SwingUtilities.getAccessibleIndexInParent(java.awt.Component)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleIndexInParent()


Occurences of getAccessibleKeyBinding

getAccessibleKeyBinding occurences:
javax.accessibility.AccessibleExtendedComponent.getAccessibleKeyBinding()
javax.accessibility.AccessibleKeyBinding.getAccessibleKeyBinding(int)
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleKeyBinding()
javax.swing.JComponent.AccessibleJComponent.getAccessibleKeyBinding()
javax.swing.JLabel.AccessibleJLabel.getAccessibleKeyBinding()


Occurences of getAccessibleName

getAccessibleName occurences:
java.awt.Button.AccessibleAWTButton.getAccessibleName()
java.awt.Component.AccessibleAWTComponent.getAccessibleName()
java.awt.Label.AccessibleAWTLabel.getAccessibleName()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleName()
java.awt.MenuItem.AccessibleAWTMenuItem.getAccessibleName()
javax.accessibility.AccessibleContext.getAccessibleName()
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleName()
javax.swing.JComponent.AccessibleJComponent.getAccessibleName()
javax.swing.JDialog.AccessibleJDialog.getAccessibleName()
javax.swing.JFrame.AccessibleJFrame.getAccessibleName()
javax.swing.JInternalFrame.AccessibleJInternalFrame.getAccessibleName()
javax.swing.JLabel.AccessibleJLabel.getAccessibleName()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleName()
javax.swing.JTabbedPane.AccessibleJTabbedPane.getAccessibleName()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleName()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleName()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleName()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleName()


Occurences of getAccessibleParent

getAccessibleParent occurences:
java.awt.Component.AccessibleAWTComponent.getAccessibleParent()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleParent()
javax.accessibility.AccessibleContext.getAccessibleParent()
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleParent()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleParent()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleParent()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleParent()


Occurences of getAccessibleRelationSet

getAccessibleRelationSet occurences:
javax.accessibility.AccessibleContext.getAccessibleRelationSet()
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleRelationSet()
javax.swing.JLabel.AccessibleJLabel.getAccessibleRelationSet()


Occurences of getAccessibleRole

getAccessibleRole occurences:
java.applet.Applet.AccessibleApplet.getAccessibleRole()
java.awt.Button.AccessibleAWTButton.getAccessibleRole()
java.awt.Canvas.AccessibleAWTCanvas.getAccessibleRole()
java.awt.Checkbox.AccessibleAWTCheckbox.getAccessibleRole()
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.getAccessibleRole()
java.awt.Choice.AccessibleAWTChoice.getAccessibleRole()
java.awt.Component.AccessibleAWTComponent.getAccessibleRole()
java.awt.Dialog.AccessibleAWTDialog.getAccessibleRole()
java.awt.Frame.AccessibleAWTFrame.getAccessibleRole()
java.awt.Label.AccessibleAWTLabel.getAccessibleRole()
java.awt.List.AccessibleAWTList.getAccessibleRole()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getAccessibleRole()
java.awt.Menu.AccessibleAWTMenu.getAccessibleRole()
java.awt.MenuBar.AccessibleAWTMenuBar.getAccessibleRole()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleRole()
java.awt.MenuItem.AccessibleAWTMenuItem.getAccessibleRole()
java.awt.Panel.AccessibleAWTPanel.getAccessibleRole()
java.awt.PopupMenu.AccessibleAWTPopupMenu.getAccessibleRole()
java.awt.Scrollbar.AccessibleAWTScrollBar.getAccessibleRole()
java.awt.ScrollPane.AccessibleAWTScrollPane.getAccessibleRole()
java.awt.TextComponent.AccessibleAWTTextComponent.getAccessibleRole()
java.awt.Window.AccessibleAWTWindow.getAccessibleRole()
javax.accessibility.AccessibleContext.getAccessibleRole()
javax.swing.Box.AccessibleBox.getAccessibleRole()
javax.swing.Box.Filler.AccessibleBoxFiller.getAccessibleRole()
javax.swing.CellRendererPane.AccessibleCellRendererPane.getAccessibleRole()
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleRole()
javax.swing.JButton.AccessibleJButton.getAccessibleRole()
javax.swing.JCheckBox.AccessibleJCheckBox.getAccessibleRole()
javax.swing.JCheckBoxMenuItem.AccessibleJCheckBoxMenuItem.getAccessibleRole()
javax.swing.JColorChooser.AccessibleJColorChooser.getAccessibleRole()
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleRole()
javax.swing.JComponent.AccessibleJComponent.getAccessibleRole()
javax.swing.JDesktopPane.AccessibleJDesktopPane.getAccessibleRole()
javax.swing.JFileChooser.AccessibleJFileChooser.getAccessibleRole()
javax.swing.JInternalFrame.AccessibleJInternalFrame.getAccessibleRole()
javax.swing.JInternalFrame.JDesktopIcon.AccessibleJDesktopIcon.getAccessibleRole()
javax.swing.JLabel.AccessibleJLabel.getAccessibleRole()
javax.swing.JLayeredPane.AccessibleJLayeredPane.getAccessibleRole()
javax.swing.JList.AccessibleJList.getAccessibleRole()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleRole()
javax.swing.JMenu.AccessibleJMenu.getAccessibleRole()
javax.swing.JMenuBar.AccessibleJMenuBar.getAccessibleRole()
javax.swing.JMenuItem.AccessibleJMenuItem.getAccessibleRole()
javax.swing.JOptionPane.AccessibleJOptionPane.getAccessibleRole()
javax.swing.JPanel.AccessibleJPanel.getAccessibleRole()
javax.swing.JPasswordField.AccessibleJPasswordField.getAccessibleRole()
javax.swing.JPopupMenu.AccessibleJPopupMenu.getAccessibleRole()
javax.swing.JProgressBar.AccessibleJProgressBar.getAccessibleRole()
javax.swing.JRadioButton.AccessibleJRadioButton.getAccessibleRole()
javax.swing.JRadioButtonMenuItem.AccessibleJRadioButtonMenuItem.getAccessibleRole()
javax.swing.JRootPane.AccessibleJRootPane.getAccessibleRole()
javax.swing.JScrollBar.AccessibleJScrollBar.getAccessibleRole()
javax.swing.JScrollPane.AccessibleJScrollPane.getAccessibleRole()
javax.swing.JSeparator.AccessibleJSeparator.getAccessibleRole()
javax.swing.JSlider.AccessibleJSlider.getAccessibleRole()
javax.swing.JSpinner.AccessibleJSpinner.getAccessibleRole()
javax.swing.JSplitPane.AccessibleJSplitPane.getAccessibleRole()
javax.swing.JTabbedPane.AccessibleJTabbedPane.getAccessibleRole()
javax.swing.JTable.AccessibleJTable.getAccessibleRole()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleRole()
javax.swing.JToggleButton.AccessibleJToggleButton.getAccessibleRole()
javax.swing.JToolBar.AccessibleJToolBar.getAccessibleRole()
javax.swing.JToolTip.AccessibleJToolTip.getAccessibleRole()
javax.swing.JTree.AccessibleJTree.getAccessibleRole()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleRole()
javax.swing.JViewport.AccessibleJViewport.getAccessibleRole()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleRole()
javax.swing.table.JTableHeader.AccessibleJTableHeader.getAccessibleRole()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleRole()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAccessibleRole()


Occurences of getAccessibleRow

getAccessibleRow occurences:
javax.accessibility.AccessibleExtendedTable.getAccessibleRow(int)
javax.swing.JTable.AccessibleJTable.getAccessibleRow(int)


Occurences of getAccessibleRowCount

getAccessibleRowCount occurences:
javax.accessibility.AccessibleTable.getAccessibleRowCount()
javax.swing.JTable.AccessibleJTable.getAccessibleRowCount()


Occurences of getAccessibleRowDescription

getAccessibleRowDescription occurences:
javax.accessibility.AccessibleTable.getAccessibleRowDescription(int)
javax.swing.JTable.AccessibleJTable.getAccessibleRowDescription(int)


Occurences of getAccessibleRowExtentAt

getAccessibleRowExtentAt occurences:
javax.accessibility.AccessibleTable.getAccessibleRowExtentAt(int, int)
javax.swing.JTable.AccessibleJTable.getAccessibleRowExtentAt(int, int)


Occurences of getAccessibleRowHeader

getAccessibleRowHeader occurences:
javax.accessibility.AccessibleTable.getAccessibleRowHeader()
javax.swing.JTable.AccessibleJTable.getAccessibleRowHeader()


Occurences of getAccessibleSelection

getAccessibleSelection occurences:
java.awt.List.AccessibleAWTList.getAccessibleSelection()
java.awt.List.AccessibleAWTList.getAccessibleSelection(int)
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleSelection()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleSelection(int)
javax.accessibility.AccessibleContext.getAccessibleSelection()
javax.accessibility.AccessibleSelection.getAccessibleSelection(int)
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleSelection()
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleSelection(int)
javax.swing.JList.AccessibleJList.getAccessibleSelection()
javax.swing.JList.AccessibleJList.getAccessibleSelection(int)
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleSelection()
javax.swing.JMenu.AccessibleJMenu.getAccessibleSelection()
javax.swing.JMenu.AccessibleJMenu.getAccessibleSelection(int)
javax.swing.JMenuBar.AccessibleJMenuBar.getAccessibleSelection()
javax.swing.JMenuBar.AccessibleJMenuBar.getAccessibleSelection(int)
javax.swing.JTabbedPane.AccessibleJTabbedPane.getAccessibleSelection()
javax.swing.JTabbedPane.AccessibleJTabbedPane.getAccessibleSelection(int)
javax.swing.JTable.AccessibleJTable.getAccessibleSelection()
javax.swing.JTable.AccessibleJTable.getAccessibleSelection(int)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleSelection()
javax.swing.JTree.AccessibleJTree.getAccessibleSelection()
javax.swing.JTree.AccessibleJTree.getAccessibleSelection(int)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleSelection()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleSelection(int)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleSelection()


Occurences of getAccessibleSelectionCount

getAccessibleSelectionCount occurences:
java.awt.List.AccessibleAWTList.getAccessibleSelectionCount()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleSelectionCount()
javax.accessibility.AccessibleSelection.getAccessibleSelectionCount()
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleSelectionCount()
javax.swing.JList.AccessibleJList.getAccessibleSelectionCount()
javax.swing.JMenu.AccessibleJMenu.getAccessibleSelectionCount()
javax.swing.JMenuBar.AccessibleJMenuBar.getAccessibleSelectionCount()
javax.swing.JTabbedPane.AccessibleJTabbedPane.getAccessibleSelectionCount()
javax.swing.JTable.AccessibleJTable.getAccessibleSelectionCount()
javax.swing.JTree.AccessibleJTree.getAccessibleSelectionCount()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleSelectionCount()


Occurences of getAccessibleStateSet

getAccessibleStateSet occurences:
java.applet.Applet.AccessibleApplet.getAccessibleStateSet()
java.awt.Checkbox.AccessibleAWTCheckbox.getAccessibleStateSet()
java.awt.Component.AccessibleAWTComponent.getAccessibleStateSet()
java.awt.Dialog.AccessibleAWTDialog.getAccessibleStateSet()
java.awt.Frame.AccessibleAWTFrame.getAccessibleStateSet()
java.awt.List.AccessibleAWTList.getAccessibleStateSet()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getAccessibleStateSet()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getAccessibleStateSet()
java.awt.Scrollbar.AccessibleAWTScrollBar.getAccessibleStateSet()
java.awt.TextArea.AccessibleAWTTextArea.getAccessibleStateSet()
java.awt.TextComponent.AccessibleAWTTextComponent.getAccessibleStateSet()
java.awt.TextField.AccessibleAWTTextField.getAccessibleStateSet()
java.awt.Window.AccessibleAWTWindow.getAccessibleStateSet()
javax.accessibility.AccessibleContext.getAccessibleStateSet()
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleStateSet()
javax.swing.ImageIcon.AccessibleImageIcon.getAccessibleStateSet()
javax.swing.JComboBox.AccessibleJComboBox.getAccessibleStateSet()
javax.swing.JComponent.AccessibleJComponent.getAccessibleStateSet()
javax.swing.JDialog.AccessibleJDialog.getAccessibleStateSet()
javax.swing.JEditorPane.AccessibleJEditorPane.getAccessibleStateSet()
javax.swing.JFrame.AccessibleJFrame.getAccessibleStateSet()
javax.swing.JList.AccessibleJList.getAccessibleStateSet()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleStateSet()
javax.swing.JMenuBar.AccessibleJMenuBar.getAccessibleStateSet()
javax.swing.JProgressBar.AccessibleJProgressBar.getAccessibleStateSet()
javax.swing.JScrollBar.AccessibleJScrollBar.getAccessibleStateSet()
javax.swing.JSlider.AccessibleJSlider.getAccessibleStateSet()
javax.swing.JSplitPane.AccessibleJSplitPane.getAccessibleStateSet()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleStateSet()
javax.swing.JTextArea.AccessibleJTextArea.getAccessibleStateSet()
javax.swing.JTextField.AccessibleJTextField.getAccessibleStateSet()
javax.swing.JToolBar.AccessibleJToolBar.getAccessibleStateSet()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleStateSet()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleStateSet()
javax.swing.SwingUtilities.getAccessibleStateSet(java.awt.Component)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleStateSet()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAccessibleStateSet()


Occurences of getAccessibleSummary

getAccessibleSummary occurences:
javax.accessibility.AccessibleTable.getAccessibleSummary()
javax.swing.JTable.AccessibleJTable.getAccessibleSummary()


Occurences of getAccessibleTable

getAccessibleTable occurences:
javax.accessibility.AccessibleContext.getAccessibleTable()
javax.swing.JTable.AccessibleJTable.getAccessibleTable()


Occurences of getAccessibleText

getAccessibleText occurences:
java.awt.TextComponent.AccessibleAWTTextComponent.getAccessibleText()
javax.accessibility.AccessibleContext.getAccessibleText()
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleText()
javax.swing.JEditorPane.AccessibleJEditorPaneHTML.getAccessibleText()
javax.swing.JLabel.AccessibleJLabel.getAccessibleText()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleText()
javax.swing.JPasswordField.AccessibleJPasswordField.getAccessibleText()
javax.swing.JSpinner.AccessibleJSpinner.getAccessibleText()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleText()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleText()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleText()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleText()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAccessibleText()


Occurences of getAccessibleValue

getAccessibleValue occurences:
java.awt.Button.AccessibleAWTButton.getAccessibleValue()
java.awt.Checkbox.AccessibleAWTCheckbox.getAccessibleValue()
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.getAccessibleValue()
java.awt.MenuItem.AccessibleAWTMenuItem.getAccessibleValue()
java.awt.Scrollbar.AccessibleAWTScrollBar.getAccessibleValue()
javax.accessibility.AccessibleContext.getAccessibleValue()
javax.swing.AbstractButton.AccessibleAbstractButton.getAccessibleValue()
javax.swing.JInternalFrame.AccessibleJInternalFrame.getAccessibleValue()
javax.swing.JInternalFrame.JDesktopIcon.AccessibleJDesktopIcon.getAccessibleValue()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getAccessibleValue()
javax.swing.JProgressBar.AccessibleJProgressBar.getAccessibleValue()
javax.swing.JScrollBar.AccessibleJScrollBar.getAccessibleValue()
javax.swing.JSlider.AccessibleJSlider.getAccessibleValue()
javax.swing.JSpinner.AccessibleJSpinner.getAccessibleValue()
javax.swing.JSplitPane.AccessibleJSplitPane.getAccessibleValue()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getAccessibleValue()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getAccessibleValue()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAccessibleValue()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getAccessibleValue()


Occurences of getAccessLevel

getAccessLevel occurences:
javax.tools.ForwardingJavaFileObject.getAccessLevel()
javax.tools.JavaFileObject.getAccessLevel()
javax.tools.SimpleJavaFileObject.getAccessLevel()


Occurences of getACHuffmanTables

getACHuffmanTables occurences:
javax.imageio.plugins.jpeg.JPEGImageReadParam.getACHuffmanTables()
javax.imageio.plugins.jpeg.JPEGImageWriteParam.getACHuffmanTables()


Occurences of getAction

getAction occurences:
java.beans.EventHandler.getAction()
javax.swing.AbstractButton.getAction()
javax.swing.JComboBox.getAction()
javax.swing.JTextField.getAction()
javax.swing.text.Keymap.getAction(javax.swing.KeyStroke)


Occurences of getActionCommand

getActionCommand occurences:
java.awt.Button.getActionCommand()
java.awt.event.ActionEvent.getActionCommand()
java.awt.MenuItem.getActionCommand()
java.awt.TrayIcon.getActionCommand()
javax.swing.AbstractButton.getActionCommand()
javax.swing.ButtonModel.getActionCommand()
javax.swing.DefaultButtonModel.getActionCommand()
javax.swing.JComboBox.getActionCommand()
javax.swing.Timer.getActionCommand()


Occurences of getActionListeners

getActionListeners occurences:
java.awt.Button.getActionListeners()
java.awt.List.getActionListeners()
java.awt.MenuItem.getActionListeners()
java.awt.TextField.getActionListeners()
java.awt.TrayIcon.getActionListeners()
javax.swing.AbstractButton.getActionListeners()
javax.swing.DefaultButtonModel.getActionListeners()
javax.swing.JComboBox.getActionListeners()
javax.swing.JFileChooser.getActionListeners()
javax.swing.JTextField.getActionListeners()
javax.swing.Timer.getActionListeners()


Occurences of getActionMap

getActionMap occurences:
javax.swing.JComponent.getActionMap()
javax.swing.plaf.metal.MetalFileChooserUI.getActionMap()


Occurences of getActions

getActions occurences:
java.io.FilePermission.getActions()
java.net.SocketPermission.getActions()
java.security.AllPermission.getActions()
java.security.BasicPermission.getActions()
java.security.Permission.getActions()
java.security.UnresolvedPermission.getActions()
java.util.PropertyPermission.getActions()
javax.management.MBeanPermission.getActions()
javax.security.auth.kerberos.ServicePermission.getActions()
javax.security.auth.PrivateCredentialPermission.getActions()
javax.swing.JFormattedTextField.getActions()
javax.swing.JFormattedTextField.AbstractFormatter.getActions()
javax.swing.JTextField.getActions()
javax.swing.text.DefaultEditorKit.getActions()
javax.swing.text.EditorKit.getActions()
javax.swing.text.html.HTMLEditorKit.getActions()
javax.swing.text.InternationalFormatter.getActions()
javax.swing.text.JTextComponent.getActions()
javax.swing.text.StyledEditorKit.getActions()


Occurences of getActualMaximum

getActualMaximum occurences:
java.util.Calendar.getActualMaximum(int)
java.util.GregorianCalendar.getActualMaximum(int)


Occurences of getActualMinimum

getActualMinimum occurences:
java.util.Calendar.getActualMinimum(int)
java.util.GregorianCalendar.getActualMinimum(int)


Occurences of getActualTypeArguments

getActualTypeArguments occurences:
com.sun.mirror.type.DeclaredType.getActualTypeArguments()
java.lang.reflect.ParameterizedType.getActualTypeArguments()


Occurences of getAdapter

getAdapter occurences:
javax.xml.bind.helpers.AbstractMarshallerImpl.getAdapter(java.lang.Class)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.getAdapter(java.lang.Class)
javax.xml.bind.Marshaller.getAdapter(java.lang.Class)
javax.xml.bind.Unmarshaller.getAdapter(java.lang.Class)


Occurences of getAdditionalBeanInfo

getAdditionalBeanInfo occurences:
java.beans.BeanInfo.getAdditionalBeanInfo()
java.beans.SimpleBeanInfo.getAdditionalBeanInfo()


Occurences of getAdditionalHeight

getAdditionalHeight occurences:
javax.swing.plaf.metal.MetalIconFactory.FileIcon16.getAdditionalHeight()
javax.swing.plaf.metal.MetalIconFactory.FolderIcon16.getAdditionalHeight()
javax.swing.plaf.metal.MetalIconFactory.TreeFolderIcon.getAdditionalHeight()
javax.swing.plaf.metal.MetalIconFactory.TreeLeafIcon.getAdditionalHeight()


Occurences of getAddress

getAddress occurences:
java.net.DatagramPacket.getAddress()
java.net.Inet4Address.getAddress()
java.net.Inet6Address.getAddress()
java.net.InetAddress.getAddress()
java.net.InetSocketAddress.getAddress()
java.net.InterfaceAddress.getAddress()
javax.management.remote.JMXAddressable.getAddress()
javax.management.remote.JMXConnectorServerMBean.getAddress()
javax.management.remote.rmi.RMIConnector.getAddress()
javax.management.remote.rmi.RMIConnectorServer.getAddress()


Occurences of getAdjustmentListeners

getAdjustmentListeners occurences:
java.awt.Scrollbar.getAdjustmentListeners()
java.awt.ScrollPaneAdjustable.getAdjustmentListeners()
javax.swing.JScrollBar.getAdjustmentListeners()


Occurences of getAdler

getAdler occurences:
java.util.zip.Deflater.getAdler()
java.util.zip.Inflater.getAdler()


Occurences of getAdvance

getAdvance occurences:
java.awt.font.GlyphMetrics.getAdvance()
java.awt.font.GraphicAttribute.getAdvance()
java.awt.font.ImageGraphicAttribute.getAdvance()
java.awt.font.ShapeGraphicAttribute.getAdvance()
java.awt.font.TextLayout.getAdvance()


Occurences of getAfterIndex

getAfterIndex occurences:
java.awt.TextComponent.AccessibleAWTTextComponent.getAfterIndex(int, int)
javax.accessibility.AccessibleText.getAfterIndex(int, int)
javax.swing.AbstractButton.AccessibleAbstractButton.getAfterIndex(int, int)
javax.swing.JLabel.AccessibleJLabel.getAfterIndex(int, int)
javax.swing.JPasswordField.AccessibleJPasswordField.getAfterIndex(int, int)
javax.swing.JSpinner.AccessibleJSpinner.getAfterIndex(int, int)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAfterIndex(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAfterIndex(int, int)


Occurences of getAlgorithm

getAlgorithm occurences:
java.security.AlgorithmParameterGenerator.getAlgorithm()
java.security.AlgorithmParameters.getAlgorithm()
java.security.cert.CertPathBuilder.getAlgorithm()
java.security.cert.CertPathValidator.getAlgorithm()
java.security.Key.getAlgorithm()
java.security.KeyFactory.getAlgorithm()
java.security.KeyPairGenerator.getAlgorithm()
java.security.MessageDigest.getAlgorithm()
java.security.Provider.Service.getAlgorithm()
java.security.SecureRandom.getAlgorithm()
java.security.Signature.getAlgorithm()
java.security.SignedObject.getAlgorithm()
javax.crypto.Cipher.getAlgorithm()
javax.crypto.KeyAgreement.getAlgorithm()
javax.crypto.KeyGenerator.getAlgorithm()
javax.crypto.Mac.getAlgorithm()
javax.crypto.SealedObject.getAlgorithm()
javax.crypto.SecretKeyFactory.getAlgorithm()
javax.crypto.spec.PSource.getAlgorithm()
javax.crypto.spec.SecretKeySpec.getAlgorithm()
javax.net.ssl.KeyManagerFactory.getAlgorithm()
javax.net.ssl.TrustManagerFactory.getAlgorithm()
javax.security.auth.kerberos.KerberosKey.getAlgorithm()
javax.xml.crypto.AlgorithmMethod.getAlgorithm()
javax.xml.crypto.dsig.TransformService.getAlgorithm()


Occurences of getAlignment

getAlignment occurences:
java.awt.FlowLayout.getAlignment()
java.awt.font.GraphicAttribute.getAlignment()
java.awt.Label.getAlignment()
javax.swing.text.BoxView.getAlignment(int)
javax.swing.text.ComponentView.getAlignment(int)
javax.swing.text.GlyphView.getAlignment(int)
javax.swing.text.html.BlockView.getAlignment(int)
javax.swing.text.html.ImageView.getAlignment(int)
javax.swing.text.html.ListView.getAlignment(int)
javax.swing.text.IconView.getAlignment(int)
javax.swing.text.ParagraphView.getAlignment(int)
javax.swing.text.StyleConstants.getAlignment(javax.swing.text.AttributeSet)
javax.swing.text.TabStop.getAlignment()
javax.swing.text.View.getAlignment(int)


Occurences of getAlignmentX

getAlignmentX occurences:
java.awt.Component.getAlignmentX()
java.awt.Container.getAlignmentX()
javax.swing.JComponent.getAlignmentX()


Occurences of getAlignmentY

getAlignmentY occurences:
java.awt.Component.getAlignmentY()
java.awt.Container.getAlignmentY()
javax.swing.JComponent.getAlignmentY()


Occurences of getAll

getAll occurences:
javax.management.openmbean.CompositeData.getAll(java.lang.String[])
javax.management.openmbean.CompositeDataSupport.getAll(java.lang.String[])
javax.naming.CompositeName.getAll()
javax.naming.CompoundName.getAll()
javax.naming.directory.Attribute.getAll()
javax.naming.directory.Attributes.getAll()
javax.naming.directory.BasicAttribute.getAll()
javax.naming.directory.BasicAttributes.getAll()
javax.naming.ldap.LdapName.getAll()
javax.naming.Name.getAll()
javax.naming.Reference.getAll()


Occurences of getAllAttributeKeys

getAllAttributeKeys occurences:
java.text.AttributedCharacterIterator.getAllAttributeKeys()
javax.swing.text.html.CSS.getAllAttributeKeys()
javax.swing.text.html.HTML.getAllAttributeKeys()


Occurences of getAllCommands

getAllCommands occurences:
javax.activation.CommandMap.getAllCommands(java.lang.String)
javax.activation.CommandMap.getAllCommands(java.lang.String, javax.activation.DataSource)
javax.activation.DataHandler.getAllCommands()
javax.activation.MailcapCommandMap.getAllCommands(java.lang.String)


Occurences of getAllMimeHeaders

getAllMimeHeaders occurences:
javax.xml.soap.AttachmentPart.getAllMimeHeaders()
javax.xml.soap.SOAPPart.getAllMimeHeaders()


Occurences of getAllNotificationIDs

getAllNotificationIDs occurences:
javax.management.timer.Timer.getAllNotificationIDs()
javax.management.timer.TimerMBean.getAllNotificationIDs()


Occurences of getAllowsChildren

getAllowsChildren occurences:
javax.swing.text.AbstractDocument.AbstractElement.getAllowsChildren()
javax.swing.text.AbstractDocument.BranchElement.getAllowsChildren()
javax.swing.text.AbstractDocument.LeafElement.getAllowsChildren()
javax.swing.tree.DefaultMutableTreeNode.getAllowsChildren()
javax.swing.tree.TreeNode.getAllowsChildren()


Occurences of getAllRelationIds

getAllRelationIds occurences:
javax.management.relation.RelationService.getAllRelationIds()
javax.management.relation.RelationServiceMBean.getAllRelationIds()


Occurences of getAllRelationTypeNames

getAllRelationTypeNames occurences:
javax.management.relation.RelationService.getAllRelationTypeNames()
javax.management.relation.RelationServiceMBean.getAllRelationTypeNames()


Occurences of getAllRoles

getAllRoles occurences:
javax.management.relation.Relation.getAllRoles()
javax.management.relation.RelationService.getAllRoles(java.lang.String)
javax.management.relation.RelationServiceMBean.getAllRoles(java.lang.String)
javax.management.relation.RelationSupport.getAllRoles()


Occurences of getAlpha

getAlpha occurences:
java.awt.AlphaComposite.getAlpha()
java.awt.Color.getAlpha()
java.awt.image.ColorModel.getAlpha(int)
java.awt.image.ColorModel.getAlpha(java.lang.Object)
java.awt.image.ComponentColorModel.getAlpha(int)
java.awt.image.ComponentColorModel.getAlpha(java.lang.Object)
java.awt.image.DirectColorModel.getAlpha(int)
java.awt.image.DirectColorModel.getAlpha(java.lang.Object)
java.awt.image.IndexColorModel.getAlpha(int)


Occurences of getAlphaRaster

getAlphaRaster occurences:
java.awt.image.BufferedImage.getAlphaRaster()
java.awt.image.ColorModel.getAlphaRaster(java.awt.image.WritableRaster)
java.awt.image.ComponentColorModel.getAlphaRaster(java.awt.image.WritableRaster)
java.awt.image.PackedColorModel.getAlphaRaster(java.awt.image.WritableRaster)


Occurences of getAnchorSelectionIndex

getAnchorSelectionIndex occurences:
javax.swing.DefaultListSelectionModel.getAnchorSelectionIndex()
javax.swing.JList.getAnchorSelectionIndex()
javax.swing.ListSelectionModel.getAnchorSelectionIndex()


Occurences of getAndAdd

getAndAdd occurences:
java.util.concurrent.atomic.AtomicInteger.getAndAdd(int)
java.util.concurrent.atomic.AtomicIntegerArray.getAndAdd(int, int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.getAndAdd(java.lang.Object,int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.getAndAdd(T, int)
java.util.concurrent.atomic.AtomicLong.getAndAdd(long)
java.util.concurrent.atomic.AtomicLongArray.getAndAdd(int, long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.getAndAdd(java.lang.Object,long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.getAndAdd(T, long)


Occurences of getAndDecrement

getAndDecrement occurences:
java.util.concurrent.atomic.AtomicInteger.getAndDecrement()
java.util.concurrent.atomic.AtomicIntegerArray.getAndDecrement(int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.getAndDecrement(java.lang.Object)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.getAndDecrement(T)
java.util.concurrent.atomic.AtomicLong.getAndDecrement()
java.util.concurrent.atomic.AtomicLongArray.getAndDecrement(int)
java.util.concurrent.atomic.AtomicLongFieldUpdater.getAndDecrement(java.lang.Object)
java.util.concurrent.atomic.AtomicLongFieldUpdater.getAndDecrement(T)


Occurences of getAndIncrement

getAndIncrement occurences:
java.util.concurrent.atomic.AtomicInteger.getAndIncrement()
java.util.concurrent.atomic.AtomicIntegerArray.getAndIncrement(int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.getAndIncrement(java.lang.Object)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.getAndIncrement(T)
java.util.concurrent.atomic.AtomicLong.getAndIncrement()
java.util.concurrent.atomic.AtomicLongArray.getAndIncrement(int)
java.util.concurrent.atomic.AtomicLongFieldUpdater.getAndIncrement(java.lang.Object)
java.util.concurrent.atomic.AtomicLongFieldUpdater.getAndIncrement(T)


Occurences of getAndSet

getAndSet occurences:
java.util.concurrent.atomic.AtomicBoolean.getAndSet(boolean)
java.util.concurrent.atomic.AtomicInteger.getAndSet(int)
java.util.concurrent.atomic.AtomicIntegerArray.getAndSet(int, int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.getAndSet(java.lang.Object,int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.getAndSet(T, int)
java.util.concurrent.atomic.AtomicLong.getAndSet(long)
java.util.concurrent.atomic.AtomicLongArray.getAndSet(int, long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.getAndSet(java.lang.Object,long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.getAndSet(T, long)
java.util.concurrent.atomic.AtomicReference.getAndSet(java.lang.Object)
java.util.concurrent.atomic.AtomicReference.getAndSet(V)
java.util.concurrent.atomic.AtomicReferenceArray.getAndSet(int, E)
java.util.concurrent.atomic.AtomicReferenceArray.getAndSet(int,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.getAndSet(java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.getAndSet(T, V)


Occurences of getAngleExtent

getAngleExtent occurences:
java.awt.geom.Arc2D.getAngleExtent()
java.awt.geom.Arc2D.Double.getAngleExtent()
java.awt.geom.Arc2D.Float.getAngleExtent()


Occurences of getAngleStart

getAngleStart occurences:
java.awt.geom.Arc2D.getAngleStart()
java.awt.geom.Arc2D.Double.getAngleStart()
java.awt.geom.Arc2D.Float.getAngleStart()


Occurences of getAnnotation

getAnnotation occurences:
com.sun.mirror.declaration.Declaration.getAnnotation(java.lang.Class)
java.lang.Class.getAnnotation(java.lang.Class)
java.lang.Package.getAnnotation(java.lang.Class)
java.lang.reflect.AccessibleObject.getAnnotation(java.lang.Class)
java.lang.reflect.AnnotatedElement.getAnnotation(java.lang.Class)
java.lang.reflect.Constructor.getAnnotation(java.lang.Class)
java.lang.reflect.Field.getAnnotation(java.lang.Class)
java.lang.reflect.Method.getAnnotation(java.lang.Class)
javax.lang.model.element.Element.getAnnotation(java.lang.Class)


Occurences of getAnnotationMirrors

getAnnotationMirrors occurences:
com.sun.mirror.declaration.Declaration.getAnnotationMirrors()
javax.lang.model.element.Element.getAnnotationMirrors()


Occurences of getAnnotations

getAnnotations occurences:
com.sun.source.tree.ModifiersTree.getAnnotations()
java.lang.Class.getAnnotations()
java.lang.Package.getAnnotations()
java.lang.reflect.AccessibleObject.getAnnotations()
java.lang.reflect.AnnotatedElement.getAnnotations()


Occurences of getAnnotationType

getAnnotationType occurences:
com.sun.mirror.declaration.AnnotationMirror.getAnnotationType()
com.sun.source.tree.AnnotationTree.getAnnotationType()
javax.lang.model.element.AnnotationMirror.getAnnotationType()


Occurences of getAnonymousLogger

getAnonymousLogger occurences:
java.util.logging.Logger.getAnonymousLogger()
java.util.logging.Logger.getAnonymousLogger(java.lang.String)


Occurences of getAppletContext

getAppletContext occurences:
java.applet.Applet.getAppletContext()
java.applet.AppletStub.getAppletContext()


Occurences of getApproveButton

getApproveButton occurences:
javax.swing.plaf.basic.BasicFileChooserUI.getApproveButton(javax.swing.JFileChooser)
javax.swing.plaf.metal.MetalFileChooserUI.getApproveButton(javax.swing.JFileChooser)


Occurences of getApproveButtonMnemonic

getApproveButtonMnemonic occurences:
javax.swing.JFileChooser.getApproveButtonMnemonic()
javax.swing.plaf.basic.BasicFileChooserUI.getApproveButtonMnemonic(javax.swing.JFileChooser)


Occurences of getApproveButtonText

getApproveButtonText occurences:
javax.swing.JFileChooser.getApproveButtonText()
javax.swing.plaf.basic.BasicFileChooserUI.getApproveButtonText(javax.swing.JFileChooser)
javax.swing.plaf.FileChooserUI.getApproveButtonText(javax.swing.JFileChooser)
javax.swing.plaf.multi.MultiFileChooserUI.getApproveButtonText(javax.swing.JFileChooser)


Occurences of getApproveButtonToolTipText

getApproveButtonToolTipText occurences:
javax.swing.JFileChooser.getApproveButtonToolTipText()
javax.swing.plaf.basic.BasicFileChooserUI.getApproveButtonToolTipText(javax.swing.JFileChooser)


Occurences of getArcHeight

getArcHeight occurences:
java.awt.geom.RoundRectangle2D.getArcHeight()
java.awt.geom.RoundRectangle2D.Double.getArcHeight()
java.awt.geom.RoundRectangle2D.Float.getArcHeight()


Occurences of getArcWidth

getArcWidth occurences:
java.awt.geom.RoundRectangle2D.getArcWidth()
java.awt.geom.RoundRectangle2D.Double.getArcWidth()
java.awt.geom.RoundRectangle2D.Float.getArcWidth()


Occurences of getArgument

getArgument occurences:
javax.lang.model.element.UnknownAnnotationValueException.getArgument()
javax.lang.model.element.UnknownElementException.getArgument()
javax.lang.model.type.UnknownTypeException.getArgument()


Occurences of getArguments

getArguments occurences:
com.sun.source.tree.AnnotationTree.getArguments()
com.sun.source.tree.MethodInvocationTree.getArguments()
com.sun.source.tree.NewClassTree.getArguments()
java.beans.Statement.getArguments()


Occurences of getArray

getArray occurences:
java.sql.Array.getArray()
java.sql.Array.getArray(java.util.Map)
java.sql.Array.getArray(long, int)
java.sql.Array.getArray(long, int, java.util.Map)
java.sql.CallableStatement.getArray(int)
java.sql.CallableStatement.getArray(java.lang.String)
java.sql.ResultSet.getArray(int)
java.sql.ResultSet.getArray(java.lang.String)
javax.sql.rowset.serial.SerialArray.getArray()
javax.sql.rowset.serial.SerialArray.getArray(java.util.Map)
javax.sql.rowset.serial.SerialArray.getArray(long, int)
javax.sql.rowset.serial.SerialArray.getArray(long, int, java.util.Map)
javax.swing.text.DefaultStyledDocument.ElementSpec.getArray()
javax.swing.text.GapContent.getArray()


Occurences of getArrayType

getArrayType occurences:
com.sun.mirror.util.Types.getArrayType(com.sun.mirror.type.TypeMirror)
javax.lang.model.util.Types.getArrayType(javax.lang.model.type.TypeMirror)
javax.management.openmbean.ArrayType.getArrayType(javax.management.openmbean.OpenType)


Occurences of getAscent

getAscent occurences:
java.awt.font.GraphicAttribute.getAscent()
java.awt.font.ImageGraphicAttribute.getAscent()
java.awt.font.LineMetrics.getAscent()
java.awt.font.ShapeGraphicAttribute.getAscent()
java.awt.font.TextLayout.getAscent()
java.awt.FontMetrics.getAscent()
javax.swing.text.GlyphView.GlyphPainter.getAscent(javax.swing.text.GlyphView)


Occurences of getAsciiStream

getAsciiStream occurences:
java.sql.Clob.getAsciiStream()
java.sql.ResultSet.getAsciiStream(int)
java.sql.ResultSet.getAsciiStream(java.lang.String)
javax.sql.rowset.serial.SerialClob.getAsciiStream()


Occurences of getAsText

getAsText occurences:
java.beans.PropertyEditor.getAsText()
java.beans.PropertyEditorSupport.getAsText()


Occurences of getAtIndex

getAtIndex occurences:
java.awt.TextComponent.AccessibleAWTTextComponent.getAtIndex(int, int)
javax.accessibility.AccessibleText.getAtIndex(int, int)
javax.swing.AbstractButton.AccessibleAbstractButton.getAtIndex(int, int)
javax.swing.JLabel.AccessibleJLabel.getAtIndex(int, int)
javax.swing.JPasswordField.AccessibleJPasswordField.getAtIndex(int, int)
javax.swing.JSpinner.AccessibleJSpinner.getAtIndex(int, int)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getAtIndex(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getAtIndex(int, int)


Occurences of getAttachmentMarshaller

getAttachmentMarshaller occurences:
javax.xml.bind.helpers.AbstractMarshallerImpl.getAttachmentMarshaller()
javax.xml.bind.Marshaller.getAttachmentMarshaller()


Occurences of getAttachments

getAttachments occurences:
javax.xml.soap.SOAPMessage.getAttachments()
javax.xml.soap.SOAPMessage.getAttachments(javax.xml.soap.MimeHeaders)


Occurences of getAttachmentUnmarshaller

getAttachmentUnmarshaller occurences:
javax.xml.bind.helpers.AbstractUnmarshallerImpl.getAttachmentUnmarshaller()
javax.xml.bind.Unmarshaller.getAttachmentUnmarshaller()


Occurences of getAttribute

getAttribute occurences:
java.security.Provider.Service.getAttribute(java.lang.String)
java.text.AttributedCharacterIterator.getAttribute(java.text.AttributedCharacterIterator.Attribute)
javax.imageio.metadata.IIOMetadataNode.getAttribute(java.lang.String)
javax.management.AttributeValueExp.getAttribute(javax.management.ObjectName)
javax.management.DynamicMBean.getAttribute(java.lang.String)
javax.management.MBeanServer.getAttribute(javax.management.ObjectName, java.lang.String)
javax.management.MBeanServerConnection.getAttribute(javax.management.ObjectName, java.lang.String)
javax.management.modelmbean.ModelMBeanInfo.getAttribute(java.lang.String)
javax.management.modelmbean.ModelMBeanInfoSupport.getAttribute(java.lang.String)
javax.management.modelmbean.RequiredModelMBean.getAttribute(java.lang.String)
javax.management.remote.rmi.RMIConnection.getAttribute(javax.management.ObjectName, java.lang.String, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.getAttribute(javax.management.ObjectName, java.lang.String, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.getAttribute(javax.management.ObjectName, java.lang.String, javax.security.auth.Subject)
javax.management.StandardMBean.getAttribute(java.lang.String)
javax.naming.directory.ModificationItem.getAttribute()
javax.print.PrintService.getAttribute(java.lang.Class)
javax.script.ScriptContext.getAttribute(java.lang.String)
javax.script.ScriptContext.getAttribute(java.lang.String, int)
javax.script.SimpleScriptContext.getAttribute(java.lang.String)
javax.script.SimpleScriptContext.getAttribute(java.lang.String, int)
javax.swing.text.AbstractDocument.AbstractElement.getAttribute(java.lang.Object)
javax.swing.text.AttributeSet.getAttribute(java.lang.Object)
javax.swing.text.html.CSS.getAttribute(java.lang.String)
javax.swing.text.html.parser.Element.getAttribute(java.lang.String)
javax.swing.text.SimpleAttributeSet.getAttribute(java.lang.Object)
javax.swing.text.StyleContext.NamedStyle.getAttribute(java.lang.Object)
javax.swing.text.StyleContext.SmallAttributeSet.getAttribute(java.lang.Object)
javax.xml.parsers.DocumentBuilderFactory.getAttribute(java.lang.String)
javax.xml.transform.TransformerFactory.getAttribute(java.lang.String)
org.w3c.dom.Element.getAttribute(java.lang.String)


Occurences of getAttributeCount

getAttributeCount occurences:
javax.swing.text.AbstractDocument.AbstractElement.getAttributeCount()
javax.swing.text.AttributeSet.getAttributeCount()
javax.swing.text.SimpleAttributeSet.getAttributeCount()
javax.swing.text.StyleContext.NamedStyle.getAttributeCount()
javax.swing.text.StyleContext.SmallAttributeSet.getAttributeCount()
javax.xml.stream.util.StreamReaderDelegate.getAttributeCount()
javax.xml.stream.XMLStreamReader.getAttributeCount()


Occurences of getAttributeDataType

getAttributeDataType occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeDataType(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeDataType(java.lang.String, java.lang.String)


Occurences of getAttributeDefaultValue

getAttributeDefaultValue occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeDefaultValue(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeDefaultValue(java.lang.String, java.lang.String)


Occurences of getAttributeDefinition

getAttributeDefinition occurences:
javax.naming.directory.Attribute.getAttributeDefinition()
javax.naming.directory.BasicAttribute.getAttributeDefinition()


Occurences of getAttributeDescription

getAttributeDescription occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeDescription(java.lang.String, java.lang.String, java.util.Locale)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeDescription(java.lang.String, java.lang.String, java.util.Locale)


Occurences of getAttributeEnumerations

getAttributeEnumerations occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeEnumerations(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeEnumerations(java.lang.String, java.lang.String)


Occurences of getAttributeID

getAttributeID occurences:
javax.naming.ldap.SortKey.getAttributeID()
javax.naming.ldap.SortResponseControl.getAttributeID()


Occurences of getAttributeListMaxLength

getAttributeListMaxLength occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeListMaxLength(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeListMaxLength(java.lang.String, java.lang.String)


Occurences of getAttributeListMinLength

getAttributeListMinLength occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeListMinLength(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeListMinLength(java.lang.String, java.lang.String)


Occurences of getAttributeLocalName

getAttributeLocalName occurences:
javax.xml.stream.util.StreamReaderDelegate.getAttributeLocalName(int)
javax.xml.stream.XMLStreamReader.getAttributeLocalName(int)


Occurences of getAttributeMaxValue

getAttributeMaxValue occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeMaxValue(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeMaxValue(java.lang.String, java.lang.String)


Occurences of getAttributeMinValue

getAttributeMinValue occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeMinValue(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeMinValue(java.lang.String, java.lang.String)


Occurences of getAttributeName

getAttributeName occurences:
javax.management.AttributeChangeNotification.getAttributeName()
javax.management.AttributeValueExp.getAttributeName()
javax.xml.stream.util.StreamReaderDelegate.getAttributeName(int)
javax.xml.stream.XMLStreamReader.getAttributeName(int)


Occurences of getAttributeNames

getAttributeNames occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeNames(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeNames(java.lang.String)
javax.swing.text.AbstractDocument.AbstractElement.getAttributeNames()
javax.swing.text.AttributeSet.getAttributeNames()
javax.swing.text.SimpleAttributeSet.getAttributeNames()
javax.swing.text.StyleContext.NamedStyle.getAttributeNames()
javax.swing.text.StyleContext.SmallAttributeSet.getAttributeNames()


Occurences of getAttributeNamespace

getAttributeNamespace occurences:
javax.xml.stream.util.StreamReaderDelegate.getAttributeNamespace(int)
javax.xml.stream.XMLStreamReader.getAttributeNamespace(int)


Occurences of getAttributeNode

getAttributeNode occurences:
javax.imageio.metadata.IIOMetadataNode.getAttributeNode(java.lang.String)
org.w3c.dom.Element.getAttributeNode(java.lang.String)


Occurences of getAttributeNodeNS

getAttributeNodeNS occurences:
javax.imageio.metadata.IIOMetadataNode.getAttributeNodeNS(java.lang.String, java.lang.String)
org.w3c.dom.Element.getAttributeNodeNS(java.lang.String, java.lang.String)


Occurences of getAttributeNS

getAttributeNS occurences:
javax.imageio.metadata.IIOMetadataNode.getAttributeNS(java.lang.String, java.lang.String)
org.w3c.dom.Element.getAttributeNS(java.lang.String, java.lang.String)


Occurences of getAttributePrefix

getAttributePrefix occurences:
javax.xml.stream.util.StreamReaderDelegate.getAttributePrefix(int)
javax.xml.stream.XMLStreamReader.getAttributePrefix(int)


Occurences of getAttributes

getAttributes occurences:
java.awt.Font.getAttributes()
java.net.JarURLConnection.getAttributes()
java.sql.DatabaseMetaData.getAttributes(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
java.sql.Struct.getAttributes()
java.sql.Struct.getAttributes(java.util.Map)
java.text.AttributedCharacterIterator.getAttributes()
java.util.jar.JarEntry.getAttributes()
java.util.jar.Manifest.getAttributes(java.lang.String)
javax.imageio.metadata.IIOMetadataNode.getAttributes()
javax.management.DynamicMBean.getAttributes(java.lang.String[])
javax.management.loading.MLetContent.getAttributes()
javax.management.MBeanInfo.getAttributes()
javax.management.MBeanServer.getAttributes(javax.management.ObjectName, java.lang.String[])
javax.management.MBeanServerConnection.getAttributes(javax.management.ObjectName, java.lang.String[])
javax.management.modelmbean.ModelMBeanInfo.getAttributes()
javax.management.modelmbean.RequiredModelMBean.getAttributes(java.lang.String[])
javax.management.openmbean.OpenMBeanInfo.getAttributes()
javax.management.remote.JMXConnectorServerMBean.getAttributes()
javax.management.remote.rmi.RMIConnection.getAttributes(javax.management.ObjectName, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.getAttributes(javax.management.ObjectName, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.getAttributes(javax.management.ObjectName, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectorServer.getAttributes()
javax.management.StandardMBean.getAttributes(java.lang.String[])
javax.naming.directory.DirContext.getAttributes(java.lang.String)
javax.naming.directory.DirContext.getAttributes(java.lang.String, java.lang.String[])
javax.naming.directory.DirContext.getAttributes(javax.naming.Name)
javax.naming.directory.DirContext.getAttributes(javax.naming.Name, java.lang.String[])
javax.naming.directory.InitialDirContext.getAttributes(java.lang.String)
javax.naming.directory.InitialDirContext.getAttributes(java.lang.String, java.lang.String[])
javax.naming.directory.InitialDirContext.getAttributes(javax.naming.Name)
javax.naming.directory.InitialDirContext.getAttributes(javax.naming.Name, java.lang.String[])
javax.naming.directory.SearchResult.getAttributes()
javax.naming.spi.DirStateFactory.Result.getAttributes()
javax.print.Doc.getAttributes()
javax.print.DocPrintJob.getAttributes()
javax.print.event.PrintJobAttributeEvent.getAttributes()
javax.print.event.PrintServiceAttributeEvent.getAttributes()
javax.print.PrintService.getAttributes()
javax.print.SimpleDoc.getAttributes()
javax.sql.rowset.serial.SerialStruct.getAttributes()
javax.sql.rowset.serial.SerialStruct.getAttributes(java.util.Map)
javax.swing.text.AbstractDocument.AbstractElement.getAttributes()
javax.swing.text.DefaultStyledDocument.ElementSpec.getAttributes()
javax.swing.text.Element.getAttributes()
javax.swing.text.html.BlockView.getAttributes()
javax.swing.text.html.HTMLDocument.Iterator.getAttributes()
javax.swing.text.html.ImageView.getAttributes()
javax.swing.text.html.InlineView.getAttributes()
javax.swing.text.html.Option.getAttributes()
javax.swing.text.html.ParagraphView.getAttributes()
javax.swing.text.html.parser.Element.getAttributes()
javax.swing.text.html.parser.Parser.getAttributes()
javax.swing.text.View.getAttributes()
javax.xml.stream.events.StartElement.getAttributes()
org.w3c.dom.Node.getAttributes()


Occurences of getAttributesScope

getAttributesScope occurences:
javax.script.ScriptContext.getAttributesScope(java.lang.String)
javax.script.SimpleScriptContext.getAttributesScope(java.lang.String)


Occurences of getAttributeSyntaxDefinition

getAttributeSyntaxDefinition occurences:
javax.naming.directory.Attribute.getAttributeSyntaxDefinition()
javax.naming.directory.BasicAttribute.getAttributeSyntaxDefinition()


Occurences of getAttributeType

getAttributeType occurences:
javax.management.AttributeChangeNotification.getAttributeType()
javax.xml.stream.util.StreamReaderDelegate.getAttributeType(int)
javax.xml.stream.XMLStreamReader.getAttributeType(int)


Occurences of getAttributeValue

getAttributeValue occurences:
javax.xml.soap.SOAPElement.getAttributeValue(javax.xml.namespace.QName)
javax.xml.soap.SOAPElement.getAttributeValue(javax.xml.soap.Name)
javax.xml.stream.util.StreamReaderDelegate.getAttributeValue(int)
javax.xml.stream.util.StreamReaderDelegate.getAttributeValue(java.lang.String, java.lang.String)
javax.xml.stream.XMLStreamReader.getAttributeValue(int)
javax.xml.stream.XMLStreamReader.getAttributeValue(java.lang.String, java.lang.String)


Occurences of getAttributeValueType

getAttributeValueType occurences:
javax.imageio.metadata.IIOMetadataFormat.getAttributeValueType(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getAttributeValueType(java.lang.String, java.lang.String)


Occurences of getAudioClip

getAudioClip occurences:
java.applet.Applet.getAudioClip(java.net.URL)
java.applet.Applet.getAudioClip(java.net.URL, java.lang.String)
java.applet.AppletContext.getAudioClip(java.net.URL)


Occurences of getAudioFileFormat

getAudioFileFormat occurences:
javax.sound.sampled.AudioSystem.getAudioFileFormat(java.io.File)
javax.sound.sampled.AudioSystem.getAudioFileFormat(java.io.InputStream)
javax.sound.sampled.AudioSystem.getAudioFileFormat(java.net.URL)
javax.sound.sampled.spi.AudioFileReader.getAudioFileFormat(java.io.File)
javax.sound.sampled.spi.AudioFileReader.getAudioFileFormat(java.io.InputStream)
javax.sound.sampled.spi.AudioFileReader.getAudioFileFormat(java.net.URL)


Occurences of getAudioFileTypes

getAudioFileTypes occurences:
javax.sound.sampled.AudioSystem.getAudioFileTypes()
javax.sound.sampled.AudioSystem.getAudioFileTypes(javax.sound.sampled.AudioInputStream)
javax.sound.sampled.spi.AudioFileWriter.getAudioFileTypes()
javax.sound.sampled.spi.AudioFileWriter.getAudioFileTypes(javax.sound.sampled.AudioInputStream)


Occurences of getAudioInputStream

getAudioInputStream occurences:
javax.sound.sampled.AudioSystem.getAudioInputStream(java.io.File)
javax.sound.sampled.AudioSystem.getAudioInputStream(java.io.InputStream)
javax.sound.sampled.AudioSystem.getAudioInputStream(java.net.URL)
javax.sound.sampled.AudioSystem.getAudioInputStream(javax.sound.sampled.AudioFormat, javax.sound.sampled.AudioInputStream)
javax.sound.sampled.AudioSystem.getAudioInputStream(javax.sound.sampled.AudioFormat.Encoding, javax.sound.sampled.AudioInputStream)
javax.sound.sampled.spi.AudioFileReader.getAudioInputStream(java.io.File)
javax.sound.sampled.spi.AudioFileReader.getAudioInputStream(java.io.InputStream)
javax.sound.sampled.spi.AudioFileReader.getAudioInputStream(java.net.URL)
javax.sound.sampled.spi.FormatConversionProvider.getAudioInputStream(javax.sound.sampled.AudioFormat, javax.sound.sampled.AudioInputStream)
javax.sound.sampled.spi.FormatConversionProvider.getAudioInputStream(javax.sound.sampled.AudioFormat.Encoding, javax.sound.sampled.AudioInputStream)


Occurences of getAuthority

getAuthority occurences:
java.net.URI.getAuthority()
java.net.URL.getAuthority()


Occurences of getAuthorizationID

getAuthorizationID occurences:
javax.security.sasl.AuthorizeCallback.getAuthorizationID()
javax.security.sasl.SaslServer.getAuthorizationID()


Occurences of getAutoCommit

getAutoCommit occurences:
java.sql.Connection.getAutoCommit()
javax.sql.rowset.JdbcRowSet.getAutoCommit()


Occurences of getAvailableFontFamilyNames

getAvailableFontFamilyNames occurences:
java.awt.GraphicsEnvironment.getAvailableFontFamilyNames()
java.awt.GraphicsEnvironment.getAvailableFontFamilyNames(java.util.Locale)


Occurences of getAvailableIDs

getAvailableIDs occurences:
java.util.TimeZone.getAvailableIDs()
java.util.TimeZone.getAvailableIDs(int)


Occurences of getAvailableLocales

getAvailableLocales occurences:
java.awt.im.spi.InputMethodDescriptor.getAvailableLocales()
java.text.BreakIterator.getAvailableLocales()
java.text.Collator.getAvailableLocales()
java.text.DateFormat.getAvailableLocales()
java.text.DateFormatSymbols.getAvailableLocales()
java.text.DecimalFormatSymbols.getAvailableLocales()
java.text.NumberFormat.getAvailableLocales()
java.util.Calendar.getAvailableLocales()
java.util.Locale.getAvailableLocales()
java.util.spi.LocaleServiceProvider.getAvailableLocales()
javax.imageio.ImageReader.getAvailableLocales()
javax.imageio.ImageWriter.getAvailableLocales()


Occurences of getAWTEventListeners

getAWTEventListeners occurences:
java.awt.Toolkit.getAWTEventListeners()
java.awt.Toolkit.getAWTEventListeners(long)


Occurences of getAWTKeyStroke

getAWTKeyStroke occurences:
java.awt.AWTKeyStroke.getAWTKeyStroke(char)
java.awt.AWTKeyStroke.getAWTKeyStroke(int, int)
java.awt.AWTKeyStroke.getAWTKeyStroke(int, int, boolean)
java.awt.AWTKeyStroke.getAWTKeyStroke(java.lang.Character, int)
java.awt.AWTKeyStroke.getAWTKeyStroke(java.lang.String)


Occurences of getAxis

getAxis occurences:
javax.swing.BoxLayout.getAxis()
javax.swing.text.BoxView.getAxis()


Occurences of getBackground

getBackground occurences:
java.awt.Component.getBackground()
java.awt.Component.AccessibleAWTComponent.getBackground()
java.awt.Graphics2D.getBackground()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getBackground()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getBackground()
java.awt.TextComponent.getBackground()
javax.accessibility.AccessibleComponent.getBackground()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getBackground()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getBackground()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getBackground()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getBackground()
javax.swing.text.DefaultStyledDocument.getBackground(javax.swing.text.AttributeSet)
javax.swing.text.GlyphView.getBackground()
javax.swing.text.html.StyleSheet.getBackground(javax.swing.text.AttributeSet)
javax.swing.text.LabelView.getBackground()
javax.swing.text.StyleConstants.getBackground(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.getBackground(javax.swing.text.AttributeSet)
javax.swing.text.StyledDocument.getBackground(javax.swing.text.AttributeSet)


Occurences of getBankData

getBankData occurences:
java.awt.image.DataBufferByte.getBankData()
java.awt.image.DataBufferDouble.getBankData()
java.awt.image.DataBufferFloat.getBankData()
java.awt.image.DataBufferInt.getBankData()
java.awt.image.DataBufferShort.getBankData()
java.awt.image.DataBufferUShort.getBankData()


Occurences of getBase

getBase occurences:
javax.swing.text.html.HTMLDocument.getBase()
javax.swing.text.html.StyleSheet.getBase()


Occurences of getBaseline

getBaseline occurences:
java.awt.Component.getBaseline(int, int)
java.awt.font.TextLayout.getBaseline()
javax.swing.border.AbstractBorder.getBaseline(java.awt.Component, int, int)
javax.swing.border.TitledBorder.getBaseline(java.awt.Component, int, int)
javax.swing.JComponent.getBaseline(int, int)
javax.swing.JSpinner.DefaultEditor.getBaseline(int, int)
javax.swing.plaf.basic.BasicButtonUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicComboBoxUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicLabelUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicListUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicPanelUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicProgressBarUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicScrollPaneUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicSliderUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicSpinnerUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicTabbedPaneUI.getBaseline(int)
javax.swing.plaf.basic.BasicTabbedPaneUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicTableHeaderUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicTableUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicTextAreaUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicTextFieldUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.basic.BasicTreeUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.ComponentUI.getBaseline(javax.swing.JComponent, int, int)
javax.swing.plaf.metal.MetalComboBoxUI.getBaseline(javax.swing.JComponent, int, int)


Occurences of getBaselineOffset

getBaselineOffset occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.getBaselineOffset()
javax.swing.plaf.metal.MetalTabbedPaneUI.getBaselineOffset()


Occurences of getBaselineOffsets

getBaselineOffsets occurences:
java.awt.font.LineMetrics.getBaselineOffsets()
java.awt.font.TextLayout.getBaselineOffsets()


Occurences of getBaselineResizeBehavior

getBaselineResizeBehavior occurences:
java.awt.Component.getBaselineResizeBehavior()
javax.swing.border.AbstractBorder.getBaselineResizeBehavior(java.awt.Component)
javax.swing.border.TitledBorder.getBaselineResizeBehavior(java.awt.Component)
javax.swing.JComponent.getBaselineResizeBehavior()
javax.swing.JSpinner.DefaultEditor.getBaselineResizeBehavior()
javax.swing.plaf.basic.BasicButtonUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicComboBoxUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicLabelUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicListUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPanelUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicProgressBarUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollPaneUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSpinnerUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTabbedPaneUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextAreaUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextFieldUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.getBaselineResizeBehavior(javax.swing.JComponent)
javax.swing.plaf.ComponentUI.getBaselineResizeBehavior(javax.swing.JComponent)


Occurences of getBaseType

getBaseType occurences:
java.sql.Array.getBaseType()
javax.activation.MimeType.getBaseType()
javax.sql.rowset.serial.SerialArray.getBaseType()


Occurences of getBaseTypeName

getBaseTypeName occurences:
java.sql.Array.getBaseTypeName()
java.sql.Ref.getBaseTypeName()
javax.sql.rowset.serial.SerialArray.getBaseTypeName()
javax.sql.rowset.serial.SerialRef.getBaseTypeName()


Occurences of getBaseURI

getBaseURI occurences:
javax.imageio.metadata.IIOMetadataNode.getBaseURI()
javax.xml.crypto.dom.DOMCryptoContext.getBaseURI()
javax.xml.crypto.XMLCryptoContext.getBaseURI()
javax.xml.stream.events.EntityDeclaration.getBaseURI()
org.w3c.dom.ls.LSInput.getBaseURI()
org.w3c.dom.Node.getBaseURI()


Occurences of getBasicConstraints

getBasicConstraints occurences:
java.security.cert.X509Certificate.getBasicConstraints()
java.security.cert.X509CertSelector.getBasicConstraints()


Occurences of getBeanContext

getBeanContext occurences:
java.beans.beancontext.BeanContextChild.getBeanContext()
java.beans.beancontext.BeanContextChildSupport.getBeanContext()
java.beans.beancontext.BeanContextEvent.getBeanContext()


Occurences of getBeanDescriptor

getBeanDescriptor occurences:
java.beans.BeanInfo.getBeanDescriptor()
java.beans.SimpleBeanInfo.getBeanDescriptor()


Occurences of getBeanInfo

getBeanInfo occurences:
java.beans.Introspector.getBeanInfo(java.lang.Class)
java.beans.Introspector.getBeanInfo(java.lang.Class, int)
java.beans.Introspector.getBeanInfo(java.lang.Class, java.lang.Class)


Occurences of getBeforeIndex

getBeforeIndex occurences:
java.awt.TextComponent.AccessibleAWTTextComponent.getBeforeIndex(int, int)
javax.accessibility.AccessibleText.getBeforeIndex(int, int)
javax.swing.AbstractButton.AccessibleAbstractButton.getBeforeIndex(int, int)
javax.swing.JLabel.AccessibleJLabel.getBeforeIndex(int, int)
javax.swing.JPasswordField.AccessibleJPasswordField.getBeforeIndex(int, int)
javax.swing.JSpinner.AccessibleJSpinner.getBeforeIndex(int, int)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getBeforeIndex(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getBeforeIndex(int, int)


Occurences of getBeginIndex

getBeginIndex occurences:
java.text.CharacterIterator.getBeginIndex()
java.text.FieldPosition.getBeginIndex()
java.text.StringCharacterIterator.getBeginIndex()
javax.swing.text.Segment.getBeginIndex()


Occurences of getBestConfiguration

getBestConfiguration occurences:
java.awt.GraphicsConfigTemplate.getBestConfiguration(java.awt.GraphicsConfiguration[])
java.awt.GraphicsDevice.getBestConfiguration(java.awt.GraphicsConfigTemplate)


Occurences of getBigDecimal

getBigDecimal occurences:
java.sql.CallableStatement.getBigDecimal(int)
java.sql.CallableStatement.getBigDecimal(int, int)
java.sql.CallableStatement.getBigDecimal(java.lang.String)
java.sql.ResultSet.getBigDecimal(int)
java.sql.ResultSet.getBigDecimal(int, int)
java.sql.ResultSet.getBigDecimal(java.lang.String)
java.sql.ResultSet.getBigDecimal(java.lang.String, int)


Occurences of getBinaryStream

getBinaryStream occurences:
java.sql.Blob.getBinaryStream()
java.sql.Blob.getBinaryStream(long, long)
java.sql.ResultSet.getBinaryStream(int)
java.sql.ResultSet.getBinaryStream(java.lang.String)
java.sql.SQLXML.getBinaryStream()
javax.sql.rowset.serial.SerialBlob.getBinaryStream()
javax.sql.rowset.serial.SerialBlob.getBinaryStream(long, long)


Occurences of getBinding

getBinding occurences:
javax.xml.ws.BindingProvider.getBinding()
javax.xml.ws.Endpoint.getBinding()


Occurences of getBindings

getBindings occurences:
javax.script.AbstractScriptEngine.getBindings(int)
javax.script.ScriptContext.getBindings(int)
javax.script.ScriptEngine.getBindings(int)
javax.script.ScriptEngineManager.getBindings()
javax.script.SimpleScriptContext.getBindings(int)


Occurences of getBitOffset

getBitOffset occurences:
java.awt.image.MultiPixelPackedSampleModel.getBitOffset(int)
javax.imageio.stream.ImageInputStream.getBitOffset()
javax.imageio.stream.ImageInputStreamImpl.getBitOffset()


Occurences of getBlack

getBlack occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getBlack()
javax.swing.plaf.metal.MetalTheme.getBlack()
javax.swing.plaf.metal.OceanTheme.getBlack()


Occurences of getBlinkRate

getBlinkRate occurences:
javax.swing.text.Caret.getBlinkRate()
javax.swing.text.DefaultCaret.getBlinkRate()


Occurences of getBlob

getBlob occurences:
java.sql.CallableStatement.getBlob(int)
java.sql.CallableStatement.getBlob(java.lang.String)
java.sql.ResultSet.getBlob(int)
java.sql.ResultSet.getBlob(java.lang.String)


Occurences of getBlock

getBlock occurences:
com.sun.source.tree.CatchTree.getBlock()
com.sun.source.tree.SynchronizedTree.getBlock()
com.sun.source.tree.TryTree.getBlock()


Occurences of getBlockIncrement

getBlockIncrement occurences:
java.awt.Adjustable.getBlockIncrement()
java.awt.Scrollbar.getBlockIncrement()
java.awt.ScrollPaneAdjustable.getBlockIncrement()
javax.swing.JScrollBar.getBlockIncrement()
javax.swing.JScrollBar.getBlockIncrement(int)
javax.swing.JScrollPane.ScrollBar.getBlockIncrement(int)


Occurences of getBlue

getBlue occurences:
java.awt.Color.getBlue()
java.awt.image.ColorModel.getBlue(int)
java.awt.image.ColorModel.getBlue(java.lang.Object)
java.awt.image.ComponentColorModel.getBlue(int)
java.awt.image.ComponentColorModel.getBlue(java.lang.Object)
java.awt.image.DirectColorModel.getBlue(int)
java.awt.image.DirectColorModel.getBlue(java.lang.Object)
java.awt.image.IndexColorModel.getBlue(int)


Occurences of getBody

getBody occurences:
com.sun.source.tree.MethodTree.getBody()
java.net.CacheRequest.getBody()
java.net.CacheResponse.getBody()
javax.xml.soap.SOAPEnvelope.getBody()


Occurences of getBoolean

getBoolean occurences:
java.lang.Boolean.getBoolean(java.lang.String)
java.lang.reflect.Array.getBoolean(java.lang.Object, int)
java.lang.reflect.Field.getBoolean(java.lang.Object)
java.sql.CallableStatement.getBoolean(int)
java.sql.CallableStatement.getBoolean(java.lang.String)
java.sql.ResultSet.getBoolean(int)
java.sql.ResultSet.getBoolean(java.lang.String)
java.util.prefs.AbstractPreferences.getBoolean(java.lang.String, boolean)
java.util.prefs.Preferences.getBoolean(java.lang.String, boolean)
javax.swing.plaf.synth.SynthStyle.getBoolean(javax.swing.plaf.synth.SynthContext, java.lang.Object, boolean)
javax.swing.UIDefaults.getBoolean(java.lang.Object)
javax.swing.UIDefaults.getBoolean(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getBoolean(java.lang.Object)
javax.swing.UIManager.getBoolean(java.lang.Object, java.util.Locale)


Occurences of getBorder

getBorder occurences:
javax.swing.border.TitledBorder.getBorder()
javax.swing.JComponent.getBorder()
javax.swing.plaf.basic.BasicSplitPaneDivider.getBorder()
javax.swing.tree.DefaultTreeCellEditor.DefaultTextField.getBorder()
javax.swing.UIDefaults.getBorder(java.lang.Object)
javax.swing.UIDefaults.getBorder(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getBorder(java.lang.Object)
javax.swing.UIManager.getBorder(java.lang.Object, java.util.Locale)


Occurences of getBorderInsets

getBorderInsets occurences:
javax.swing.border.AbstractBorder.getBorderInsets(java.awt.Component)
javax.swing.border.AbstractBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.border.BevelBorder.getBorderInsets(java.awt.Component)
javax.swing.border.BevelBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.border.Border.getBorderInsets(java.awt.Component)
javax.swing.border.CompoundBorder.getBorderInsets(java.awt.Component)
javax.swing.border.CompoundBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.border.EmptyBorder.getBorderInsets()
javax.swing.border.EmptyBorder.getBorderInsets(java.awt.Component)
javax.swing.border.EmptyBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.border.EtchedBorder.getBorderInsets(java.awt.Component)
javax.swing.border.EtchedBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.border.LineBorder.getBorderInsets(java.awt.Component)
javax.swing.border.LineBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.border.MatteBorder.getBorderInsets()
javax.swing.border.MatteBorder.getBorderInsets(java.awt.Component)
javax.swing.border.MatteBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.border.SoftBevelBorder.getBorderInsets(java.awt.Component)
javax.swing.border.SoftBevelBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.border.TitledBorder.getBorderInsets(java.awt.Component)
javax.swing.border.TitledBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.basic.BasicBorders.ButtonBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.basic.BasicBorders.ButtonBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.basic.BasicBorders.FieldBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.basic.BasicBorders.FieldBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.basic.BasicBorders.MarginBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.basic.BasicBorders.MarginBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.basic.BasicBorders.MenuBarBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.basic.BasicBorders.MenuBarBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.basic.BasicBorders.RadioButtonBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.basic.BasicBorders.RadioButtonBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.basic.BasicBorders.SplitPaneBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.basic.BasicBorders.ToggleButtonBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.basic.BasicBorders.ToggleButtonBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.BorderUIResource.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.ButtonBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.ButtonBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.metal.MetalBorders.Flush3DBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.Flush3DBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.metal.MetalBorders.InternalFrameBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.InternalFrameBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.metal.MetalBorders.MenuBarBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.MenuBarBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.metal.MetalBorders.MenuItemBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.MenuItemBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.metal.MetalBorders.OptionDialogBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.OptionDialogBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.metal.MetalBorders.PaletteBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.PaletteBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.metal.MetalBorders.PopupMenuBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.PopupMenuBorder.getBorderInsets(java.awt.Component, java.awt.Insets)
javax.swing.plaf.metal.MetalBorders.ScrollPaneBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.TableHeaderBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.ToolBarBorder.getBorderInsets(java.awt.Component)
javax.swing.plaf.metal.MetalBorders.ToolBarBorder.getBorderInsets(java.awt.Component, java.awt.Insets)


Occurences of getBorderSelectionColor

getBorderSelectionColor occurences:
javax.swing.tree.DefaultTreeCellEditor.getBorderSelectionColor()
javax.swing.tree.DefaultTreeCellRenderer.getBorderSelectionColor()


Occurences of getBottomInset

getBottomInset occurences:
javax.swing.text.AsyncBoxView.getBottomInset()
javax.swing.text.CompositeView.getBottomInset()


Occurences of getBounds

getBounds occurences:
com.sun.mirror.declaration.TypeParameterDeclaration.getBounds()
com.sun.source.tree.TypeParameterTree.getBounds()
java.awt.Component.getBounds()
java.awt.Component.getBounds(java.awt.Rectangle)
java.awt.Component.AccessibleAWTComponent.getBounds()
java.awt.font.GraphicAttribute.getBounds()
java.awt.font.ImageGraphicAttribute.getBounds()
java.awt.font.ShapeGraphicAttribute.getBounds()
java.awt.font.TextLayout.getBounds()
java.awt.geom.Area.getBounds()
java.awt.geom.CubicCurve2D.getBounds()
java.awt.geom.Line2D.getBounds()
java.awt.geom.Path2D.getBounds()
java.awt.geom.QuadCurve2D.getBounds()
java.awt.geom.RectangularShape.getBounds()
java.awt.GraphicsConfiguration.getBounds()
java.awt.image.Raster.getBounds()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getBounds()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getBounds()
java.awt.Polygon.getBounds()
java.awt.Rectangle.getBounds()
java.awt.Shape.getBounds()
java.awt.SplashScreen.getBounds()
java.lang.reflect.TypeVariable.getBounds()
javax.accessibility.AccessibleComponent.getBounds()
javax.lang.model.element.TypeParameterElement.getBounds()
javax.swing.JComponent.getBounds(java.awt.Rectangle)
javax.swing.JList.AccessibleJList.AccessibleJListChild.getBounds()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getBounds()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getBounds()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getBounds()
javax.swing.tree.AbstractLayoutCache.getBounds(javax.swing.tree.TreePath, java.awt.Rectangle)
javax.swing.tree.FixedHeightLayoutCache.getBounds(javax.swing.tree.TreePath, java.awt.Rectangle)
javax.swing.tree.VariableHeightLayoutCache.getBounds(javax.swing.tree.TreePath, java.awt.Rectangle)


Occurences of getBounds2D

getBounds2D occurences:
java.awt.font.GlyphMetrics.getBounds2D()
java.awt.geom.Arc2D.getBounds2D()
java.awt.geom.Area.getBounds2D()
java.awt.geom.CubicCurve2D.Double.getBounds2D()
java.awt.geom.CubicCurve2D.Float.getBounds2D()
java.awt.geom.Ellipse2D.Double.getBounds2D()
java.awt.geom.Ellipse2D.Float.getBounds2D()
java.awt.geom.Line2D.Double.getBounds2D()
java.awt.geom.Line2D.Float.getBounds2D()
java.awt.geom.Path2D.Double.getBounds2D()
java.awt.geom.Path2D.Float.getBounds2D()
java.awt.geom.QuadCurve2D.Double.getBounds2D()
java.awt.geom.QuadCurve2D.Float.getBounds2D()
java.awt.geom.Rectangle2D.getBounds2D()
java.awt.geom.Rectangle2D.Double.getBounds2D()
java.awt.geom.Rectangle2D.Float.getBounds2D()
java.awt.geom.RoundRectangle2D.Double.getBounds2D()
java.awt.geom.RoundRectangle2D.Float.getBounds2D()
java.awt.image.AffineTransformOp.getBounds2D(java.awt.image.BufferedImage)
java.awt.image.AffineTransformOp.getBounds2D(java.awt.image.Raster)
java.awt.image.BandCombineOp.getBounds2D(java.awt.image.Raster)
java.awt.image.BufferedImageOp.getBounds2D(java.awt.image.BufferedImage)
java.awt.image.ColorConvertOp.getBounds2D(java.awt.image.BufferedImage)
java.awt.image.ColorConvertOp.getBounds2D(java.awt.image.Raster)
java.awt.image.ConvolveOp.getBounds2D(java.awt.image.BufferedImage)
java.awt.image.ConvolveOp.getBounds2D(java.awt.image.Raster)
java.awt.image.LookupOp.getBounds2D(java.awt.image.BufferedImage)
java.awt.image.LookupOp.getBounds2D(java.awt.image.Raster)
java.awt.image.RasterOp.getBounds2D(java.awt.image.Raster)
java.awt.image.renderable.ContextualRenderedImageFactory.getBounds2D(java.awt.image.renderable.ParameterBlock)
java.awt.image.RescaleOp.getBounds2D(java.awt.image.BufferedImage)
java.awt.image.RescaleOp.getBounds2D(java.awt.image.Raster)
java.awt.Polygon.getBounds2D()
java.awt.Rectangle.getBounds2D()
java.awt.Shape.getBounds2D()


Occurences of getBreakWeight

getBreakWeight occurences:
javax.swing.text.GlyphView.getBreakWeight(int, float, float)
javax.swing.text.html.InlineView.getBreakWeight(int, float, float)
javax.swing.text.ParagraphView.getBreakWeight(int, float)
javax.swing.text.View.getBreakWeight(int, float, float)


Occurences of getBroadcast

getBroadcast occurences:
java.net.DatagramSocket.getBroadcast()
java.net.InterfaceAddress.getBroadcast()


Occurences of getBufferStrategy

getBufferStrategy occurences:
java.awt.Canvas.getBufferStrategy()
java.awt.Window.getBufferStrategy()


Occurences of getBundle

getBundle occurences:
java.util.ResourceBundle.getBundle(java.lang.String)
java.util.ResourceBundle.getBundle(java.lang.String, java.util.Locale)
java.util.ResourceBundle.getBundle(java.lang.String, java.util.Locale, java.lang.ClassLoader)
java.util.ResourceBundle.getBundle(java.lang.String, java.util.Locale, java.lang.ClassLoader, java.util.ResourceBundle.Control)
java.util.ResourceBundle.getBundle(java.lang.String, java.util.Locale, java.util.ResourceBundle.Control)
java.util.ResourceBundle.getBundle(java.lang.String, java.util.ResourceBundle.Control)


Occurences of getButton

getButton occurences:
java.awt.event.MouseEvent.getButton()
org.w3c.dom.events.MouseEvent.getButton()


Occurences of getButtonBorder

getButtonBorder occurences:
javax.swing.plaf.basic.BasicBorders.getButtonBorder()
javax.swing.plaf.metal.MetalBorders.getButtonBorder()


Occurences of getByAddress

getByAddress occurences:
java.net.Inet6Address.getByAddress(java.lang.String, byte[], int)
java.net.Inet6Address.getByAddress(java.lang.String, byte[], java.net.NetworkInterface)
java.net.InetAddress.getByAddress(byte[])
java.net.InetAddress.getByAddress(java.lang.String, byte[])


Occurences of getByName

getByName occurences:
java.net.InetAddress.getByName(java.lang.String)
java.net.NetworkInterface.getByName(java.lang.String)


Occurences of getByte

getByte occurences:
java.lang.reflect.Array.getByte(java.lang.Object, int)
java.lang.reflect.Field.getByte(java.lang.Object)
java.sql.CallableStatement.getByte(int)
java.sql.CallableStatement.getByte(java.lang.String)
java.sql.ResultSet.getByte(int)
java.sql.ResultSet.getByte(java.lang.String)


Occurences of getByteArray

getByteArray occurences:
java.util.prefs.AbstractPreferences.getByteArray(java.lang.String, byte[])
java.util.prefs.Preferences.getByteArray(java.lang.String, byte[])


Occurences of getByteLength

getByteLength occurences:
javax.sound.midi.MidiFileFormat.getByteLength()
javax.sound.sampled.AudioFileFormat.getByteLength()


Occurences of getByteOrder

getByteOrder occurences:
javax.imageio.stream.ImageInputStream.getByteOrder()
javax.imageio.stream.ImageInputStreamImpl.getByteOrder()


Occurences of getBytes

getBytes occurences:
java.lang.String.getBytes()
java.lang.String.getBytes(int, int, byte[], int)
java.lang.String.getBytes(java.lang.String)
java.lang.String.getBytes(java.nio.charset.Charset)
java.sql.Blob.getBytes(long, int)
java.sql.CallableStatement.getBytes(int)
java.sql.CallableStatement.getBytes(java.lang.String)
java.sql.ResultSet.getBytes(int)
java.sql.ResultSet.getBytes(java.lang.String)
java.sql.RowId.getBytes()
javax.sql.rowset.serial.SerialBlob.getBytes(long, int)


Occurences of getBytesRead

getBytesRead occurences:
java.util.zip.Deflater.getBytesRead()
java.util.zip.Inflater.getBytesRead()


Occurences of getByteStream

getByteStream occurences:
org.w3c.dom.ls.LSInput.getByteStream()
org.w3c.dom.ls.LSOutput.getByteStream()
org.xml.sax.InputSource.getByteStream()


Occurences of getBytesWritten

getBytesWritten occurences:
java.util.zip.Deflater.getBytesWritten()
java.util.zip.Inflater.getBytesWritten()


Occurences of getCalendarField

getCalendarField occurences:
java.text.DateFormat.Field.getCalendarField()
javax.swing.SpinnerDateModel.getCalendarField()


Occurences of getCanonicalName

getCanonicalName occurences:
java.lang.Class.getCanonicalName()
javax.management.ObjectName.getCanonicalName()


Occurences of getCapabilities

getCapabilities occurences:
java.awt.Component.BltBufferStrategy.getCapabilities()
java.awt.Component.FlipBufferStrategy.getCapabilities()
java.awt.Image.getCapabilities(java.awt.GraphicsConfiguration)
java.awt.image.BufferStrategy.getCapabilities()
java.awt.image.VolatileImage.getCapabilities()


Occurences of getCaret

getCaret occurences:
Class ActiveClient.ActiveClient.getCaret()
Class LWTextComponent.LWTextComponent.getCaret()
java.awt.event.InputMethodEvent.getCaret()
javax.swing.text.JTextComponent.getCaret()
javax.swing.text.NavigationFilter.FilterBypass.getCaret()


Occurences of getCaretInfo

getCaretInfo occurences:
java.awt.font.TextLayout.getCaretInfo(java.awt.font.TextHitInfo)
java.awt.font.TextLayout.getCaretInfo(java.awt.font.TextHitInfo, java.awt.geom.Rectangle2D)


Occurences of getCaretPosition

getCaretPosition occurences:
java.awt.TextComponent.getCaretPosition()
java.awt.TextComponent.AccessibleAWTTextComponent.getCaretPosition()
javax.accessibility.AccessibleText.getCaretPosition()
javax.swing.AbstractButton.AccessibleAbstractButton.getCaretPosition()
javax.swing.JLabel.AccessibleJLabel.getCaretPosition()
javax.swing.JSpinner.AccessibleJSpinner.getCaretPosition()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getCaretPosition()
javax.swing.text.JTextComponent.getCaretPosition()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getCaretPosition()


Occurences of getCaretRectangle

getCaretRectangle occurences:
Class LWTextComponent.LWTextComponent.getCaretRectangle()
Class LWTextComponent.LWTextComponent.getCaretRectangle(java.awt.font.TextHitInfo)


Occurences of getCaretShape

getCaretShape occurences:
java.awt.font.TextLayout.getCaretShape(java.awt.font.TextHitInfo)
java.awt.font.TextLayout.getCaretShape(java.awt.font.TextHitInfo, java.awt.geom.Rectangle2D)


Occurences of getCaretShapes

getCaretShapes occurences:
java.awt.font.TextLayout.getCaretShapes(int)
java.awt.font.TextLayout.getCaretShapes(int, java.awt.geom.Rectangle2D)
java.awt.font.TextLayout.getCaretShapes(int, java.awt.geom.Rectangle2D, java.awt.font.TextLayout.CaretPolicy)


Occurences of getCatalogName

getCatalogName occurences:
java.sql.ResultSetMetaData.getCatalogName(int)
javax.sql.rowset.RowSetMetaDataImpl.getCatalogName(int)


Occurences of getCategory

getCategory occurences:
javax.print.attribute.Attribute.getCategory()
javax.print.attribute.standard.Chromaticity.getCategory()
javax.print.attribute.standard.ColorSupported.getCategory()
javax.print.attribute.standard.Compression.getCategory()
javax.print.attribute.standard.Copies.getCategory()
javax.print.attribute.standard.CopiesSupported.getCategory()
javax.print.attribute.standard.DateTimeAtCompleted.getCategory()
javax.print.attribute.standard.DateTimeAtCreation.getCategory()
javax.print.attribute.standard.DateTimeAtProcessing.getCategory()
javax.print.attribute.standard.Destination.getCategory()
javax.print.attribute.standard.DocumentName.getCategory()
javax.print.attribute.standard.Fidelity.getCategory()
javax.print.attribute.standard.Finishings.getCategory()
javax.print.attribute.standard.JobHoldUntil.getCategory()
javax.print.attribute.standard.JobImpressions.getCategory()
javax.print.attribute.standard.JobImpressionsCompleted.getCategory()
javax.print.attribute.standard.JobImpressionsSupported.getCategory()
javax.print.attribute.standard.JobKOctets.getCategory()
javax.print.attribute.standard.JobKOctetsProcessed.getCategory()
javax.print.attribute.standard.JobKOctetsSupported.getCategory()
javax.print.attribute.standard.JobMediaSheets.getCategory()
javax.print.attribute.standard.JobMediaSheetsCompleted.getCategory()
javax.print.attribute.standard.JobMediaSheetsSupported.getCategory()
javax.print.attribute.standard.JobMessageFromOperator.getCategory()
javax.print.attribute.standard.JobName.getCategory()
javax.print.attribute.standard.JobOriginatingUserName.getCategory()
javax.print.attribute.standard.JobPriority.getCategory()
javax.print.attribute.standard.JobPrioritySupported.getCategory()
javax.print.attribute.standard.JobSheets.getCategory()
javax.print.attribute.standard.JobState.getCategory()
javax.print.attribute.standard.JobStateReason.getCategory()
javax.print.attribute.standard.JobStateReasons.getCategory()
javax.print.attribute.standard.Media.getCategory()
javax.print.attribute.standard.MediaPrintableArea.getCategory()
javax.print.attribute.standard.MediaSize.getCategory()
javax.print.attribute.standard.MultipleDocumentHandling.getCategory()
javax.print.attribute.standard.NumberOfDocuments.getCategory()
javax.print.attribute.standard.NumberOfInterveningJobs.getCategory()
javax.print.attribute.standard.NumberUp.getCategory()
javax.print.attribute.standard.NumberUpSupported.getCategory()
javax.print.attribute.standard.OrientationRequested.getCategory()
javax.print.attribute.standard.OutputDeviceAssigned.getCategory()
javax.print.attribute.standard.PageRanges.getCategory()
javax.print.attribute.standard.PagesPerMinute.getCategory()
javax.print.attribute.standard.PagesPerMinuteColor.getCategory()
javax.print.attribute.standard.PDLOverrideSupported.getCategory()
javax.print.attribute.standard.PresentationDirection.getCategory()
javax.print.attribute.standard.PrinterInfo.getCategory()
javax.print.attribute.standard.PrinterIsAcceptingJobs.getCategory()
javax.print.attribute.standard.PrinterLocation.getCategory()
javax.print.attribute.standard.PrinterMakeAndModel.getCategory()
javax.print.attribute.standard.PrinterMessageFromOperator.getCategory()
javax.print.attribute.standard.PrinterMoreInfo.getCategory()
javax.print.attribute.standard.PrinterMoreInfoManufacturer.getCategory()
javax.print.attribute.standard.PrinterName.getCategory()
javax.print.attribute.standard.PrinterResolution.getCategory()
javax.print.attribute.standard.PrinterState.getCategory()
javax.print.attribute.standard.PrinterStateReason.getCategory()
javax.print.attribute.standard.PrinterStateReasons.getCategory()
javax.print.attribute.standard.PrinterURI.getCategory()
javax.print.attribute.standard.PrintQuality.getCategory()
javax.print.attribute.standard.QueuedJobCount.getCategory()
javax.print.attribute.standard.ReferenceUriSchemesSupported.getCategory()
javax.print.attribute.standard.RequestingUserName.getCategory()
javax.print.attribute.standard.Severity.getCategory()
javax.print.attribute.standard.SheetCollate.getCategory()
javax.print.attribute.standard.Sides.getCategory()


Occurences of getCause

getCause occurences:
java.awt.print.PrinterIOException.getCause()
java.io.WriteAbortedException.getCause()
java.lang.ClassNotFoundException.getCause()
java.lang.ExceptionInInitializerError.getCause()
java.lang.reflect.InvocationTargetException.getCause()
java.lang.reflect.UndeclaredThrowableException.getCause()
java.lang.Throwable.getCause()
java.rmi.activation.ActivationException.getCause()
java.rmi.RemoteException.getCause()
java.rmi.server.ServerCloneException.getCause()
java.security.PrivilegedActionException.getCause()
javax.management.MBeanException.getCause()
javax.management.ReflectionException.getCause()
javax.management.remote.JMXProviderException.getCause()
javax.management.remote.JMXServerErrorException.getCause()
javax.management.RuntimeErrorException.getCause()
javax.management.RuntimeMBeanException.getCause()
javax.management.RuntimeOperationsException.getCause()
javax.naming.NamingException.getCause()
javax.security.sasl.SaslException.getCause()
javax.xml.bind.JAXBException.getCause()
javax.xml.crypto.dsig.TransformException.getCause()
javax.xml.crypto.dsig.XMLSignatureException.getCause()
javax.xml.crypto.KeySelectorException.getCause()
javax.xml.crypto.MarshalException.getCause()
javax.xml.crypto.NoSuchMechanismException.getCause()
javax.xml.crypto.URIReferenceException.getCause()
javax.xml.soap.SOAPException.getCause()
javax.xml.transform.TransformerException.getCause()
javax.xml.xpath.XPathException.getCause()


Occurences of getCellBounds

getCellBounds occurences:
javax.swing.JList.getCellBounds(int, int)
javax.swing.plaf.basic.BasicListUI.getCellBounds(javax.swing.JList, int, int)
javax.swing.plaf.ListUI.getCellBounds(javax.swing.JList, int, int)
javax.swing.plaf.multi.MultiListUI.getCellBounds(javax.swing.JList, int, int)


Occurences of getCellEditor

getCellEditor occurences:
javax.swing.JTable.getCellEditor()
javax.swing.JTable.getCellEditor(int, int)
javax.swing.JTree.getCellEditor()
javax.swing.plaf.basic.BasicTreeUI.getCellEditor()
javax.swing.table.TableColumn.getCellEditor()


Occurences of getCellEditorListeners

getCellEditorListeners occurences:
javax.swing.AbstractCellEditor.getCellEditorListeners()
javax.swing.tree.DefaultTreeCellEditor.getCellEditorListeners()


Occurences of getCellEditorValue

getCellEditorValue occurences:
javax.swing.CellEditor.getCellEditorValue()
javax.swing.DefaultCellEditor.getCellEditorValue()
javax.swing.DefaultCellEditor.EditorDelegate.getCellEditorValue()
javax.swing.tree.DefaultTreeCellEditor.getCellEditorValue()


Occurences of getCellRenderer

getCellRenderer occurences:
javax.swing.JList.getCellRenderer()
javax.swing.JTable.getCellRenderer(int, int)
javax.swing.JTree.getCellRenderer()
javax.swing.plaf.basic.BasicTreeUI.getCellRenderer()
javax.swing.table.TableColumn.getCellRenderer()


Occurences of getCenterPoint

getCenterPoint occurences:
java.awt.GraphicsEnvironment.getCenterPoint()
java.awt.RadialGradientPaint.getCenterPoint()


Occurences of getCertificate

getCertificate occurences:
java.security.cert.X509CertSelector.getCertificate()
java.security.KeyStore.getCertificate(java.lang.String)
java.security.KeyStore.PrivateKeyEntry.getCertificate()
javax.security.auth.x500.X500PrivateCredential.getCertificate()


Occurences of getCertificateChain

getCertificateChain occurences:
java.security.KeyStore.getCertificateChain(java.lang.String)
java.security.KeyStore.PrivateKeyEntry.getCertificateChain()
javax.net.ssl.X509KeyManager.getCertificateChain(java.lang.String)


Occurences of getCertificates

getCertificates occurences:
java.net.JarURLConnection.getCertificates()
java.security.cert.CertPath.getCertificates()
java.security.cert.CertStore.getCertificates(java.security.cert.CertSelector)
java.security.CodeSource.getCertificates()
java.util.jar.JarEntry.getCertificates()


Occurences of getCertPath

getCertPath occurences:
java.security.cert.CertPathBuilderResult.getCertPath()
java.security.cert.CertPathValidatorException.getCertPath()
java.security.cert.PKIXCertPathBuilderResult.getCertPath()


Occurences of getChange

getChange occurences:
javax.swing.event.DocumentEvent.getChange(javax.swing.text.Element)
javax.swing.text.AbstractDocument.DefaultDocumentEvent.getChange(javax.swing.text.Element)


Occurences of getChangeListeners

getChangeListeners occurences:
javax.swing.AbstractButton.getChangeListeners()
javax.swing.AbstractSpinnerModel.getChangeListeners()
javax.swing.colorchooser.DefaultColorSelectionModel.getChangeListeners()
javax.swing.DefaultBoundedRangeModel.getChangeListeners()
javax.swing.DefaultButtonModel.getChangeListeners()
javax.swing.DefaultSingleSelectionModel.getChangeListeners()
javax.swing.JProgressBar.getChangeListeners()
javax.swing.JSlider.getChangeListeners()
javax.swing.JSpinner.getChangeListeners()
javax.swing.JTabbedPane.getChangeListeners()
javax.swing.JViewport.getChangeListeners()
javax.swing.MenuSelectionManager.getChangeListeners()
javax.swing.text.DefaultCaret.getChangeListeners()
javax.swing.text.StyleContext.getChangeListeners()
javax.swing.text.StyleContext.NamedStyle.getChangeListeners()


Occurences of getChannel

getChannel occurences:
java.io.FileInputStream.getChannel()
java.io.FileOutputStream.getChannel()
java.io.RandomAccessFile.getChannel()
java.net.DatagramSocket.getChannel()
java.net.ServerSocket.getChannel()
java.net.Socket.getChannel()
javax.sound.midi.ShortMessage.getChannel()


Occurences of getChannels

getChannels occurences:
javax.sound.midi.Synthesizer.getChannels()
javax.sound.sampled.AudioFormat.getChannels()


Occurences of getChar

getChar occurences:
java.lang.reflect.Array.getChar(java.lang.Object, int)
java.lang.reflect.Field.getChar(java.lang.Object)
java.nio.ByteBuffer.getChar()
java.nio.ByteBuffer.getChar(int)


Occurences of getCharacterAttribute

getCharacterAttribute occurences:
java.awt.TextComponent.AccessibleAWTTextComponent.getCharacterAttribute(int)
javax.accessibility.AccessibleText.getCharacterAttribute(int)
javax.swing.AbstractButton.AccessibleAbstractButton.getCharacterAttribute(int)
javax.swing.JLabel.AccessibleJLabel.getCharacterAttribute(int)
javax.swing.JSpinner.AccessibleJSpinner.getCharacterAttribute(int)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getCharacterAttribute(int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getCharacterAttribute(int)


Occurences of getCharacterBounds

getCharacterBounds occurences:
java.awt.TextComponent.AccessibleAWTTextComponent.getCharacterBounds(int)
javax.accessibility.AccessibleText.getCharacterBounds(int)
javax.swing.AbstractButton.AccessibleAbstractButton.getCharacterBounds(int)
javax.swing.JLabel.AccessibleJLabel.getCharacterBounds(int)
javax.swing.JSpinner.AccessibleJSpinner.getCharacterBounds(int)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getCharacterBounds(int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getCharacterBounds(int)


Occurences of getCharacterElement

getCharacterElement occurences:
javax.swing.text.DefaultStyledDocument.getCharacterElement(int)
javax.swing.text.StyledDocument.getCharacterElement(int)


Occurences of getCharacterEncodingScheme

getCharacterEncodingScheme occurences:
javax.xml.stream.events.StartDocument.getCharacterEncodingScheme()
javax.xml.stream.util.StreamReaderDelegate.getCharacterEncodingScheme()
javax.xml.stream.XMLStreamReader.getCharacterEncodingScheme()


Occurences of getCharacterInstance

getCharacterInstance occurences:
java.text.BreakIterator.getCharacterInstance()
java.text.BreakIterator.getCharacterInstance(java.util.Locale)
java.text.spi.BreakIteratorProvider.getCharacterInstance(java.util.Locale)


Occurences of getCharacterStream

getCharacterStream occurences:
java.sql.CallableStatement.getCharacterStream(int)
java.sql.CallableStatement.getCharacterStream(java.lang.String)
java.sql.Clob.getCharacterStream()
java.sql.Clob.getCharacterStream(long, long)
java.sql.ResultSet.getCharacterStream(int)
java.sql.ResultSet.getCharacterStream(java.lang.String)
java.sql.SQLXML.getCharacterStream()
javax.sql.rowset.serial.SerialClob.getCharacterStream()
javax.sql.rowset.serial.SerialClob.getCharacterStream(long, long)
org.w3c.dom.ls.LSInput.getCharacterStream()
org.w3c.dom.ls.LSOutput.getCharacterStream()
org.xml.sax.InputSource.getCharacterStream()


Occurences of getCharContent

getCharContent occurences:
javax.tools.FileObject.getCharContent(boolean)
javax.tools.ForwardingFileObject.getCharContent(boolean)
javax.tools.SimpleJavaFileObject.getCharContent(boolean)


Occurences of getCharCount

getCharCount occurences:
java.awt.TextComponent.AccessibleAWTTextComponent.getCharCount()
javax.accessibility.AccessibleText.getCharCount()
javax.swing.AbstractButton.AccessibleAbstractButton.getCharCount()
javax.swing.JLabel.AccessibleJLabel.getCharCount()
javax.swing.JSpinner.AccessibleJSpinner.getCharCount()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getCharCount()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getCharCount()


Occurences of getChars

getChars occurences:
java.lang.String.getChars(int, int, char[], int)
java.lang.StringBuffer.getChars(int, int, char[], int)
java.lang.StringBuilder.getChars(int, int, char[], int)
javax.swing.text.AbstractDocument.Content.getChars(int, int, javax.swing.text.Segment)
javax.swing.text.GapContent.getChars(int, int, javax.swing.text.Segment)
javax.swing.text.StringContent.getChars(int, int, javax.swing.text.Segment)


Occurences of getCharsetName

getCharsetName occurences:
java.nio.charset.IllegalCharsetNameException.getCharsetName()
java.nio.charset.UnsupportedCharsetException.getCharsetName()


Occurences of getCheckBoxIcon

getCheckBoxIcon occurences:
javax.swing.plaf.basic.BasicIconFactory.getCheckBoxIcon()
javax.swing.plaf.metal.MetalIconFactory.getCheckBoxIcon()


Occurences of getCheckBoxMenuItemIcon

getCheckBoxMenuItemIcon occurences:
javax.swing.plaf.basic.BasicIconFactory.getCheckBoxMenuItemIcon()
javax.swing.plaf.metal.MetalIconFactory.getCheckBoxMenuItemIcon()


Occurences of getChecksum

getChecksum occurences:
java.util.zip.CheckedInputStream.getChecksum()
java.util.zip.CheckedOutputStream.getChecksum()


Occurences of getChild

getChild occurences:
java.awt.event.ContainerEvent.getChild()
java.util.prefs.AbstractPreferences.getChild(java.lang.String)
java.util.prefs.NodeChangeEvent.getChild()
javax.swing.filechooser.FileSystemView.getChild(java.io.File, java.lang.String)
javax.swing.tree.DefaultTreeModel.getChild(java.lang.Object, int)
javax.swing.tree.TreeModel.getChild(java.lang.Object, int)


Occurences of getChildAllocation

getChildAllocation occurences:
javax.swing.text.AsyncBoxView.getChildAllocation(int, java.awt.Shape)
javax.swing.text.AsyncBoxView.ChildLocator.getChildAllocation(int)
javax.swing.text.AsyncBoxView.ChildLocator.getChildAllocation(int, java.awt.Shape)
javax.swing.text.BoxView.getChildAllocation(int, java.awt.Shape)
javax.swing.text.CompositeView.getChildAllocation(int, java.awt.Shape)
javax.swing.text.View.getChildAllocation(int, java.awt.Shape)


Occurences of getChildAt

getChildAt occurences:
javax.swing.JTree.DynamicUtilTreeNode.getChildAt(int)
javax.swing.text.AbstractDocument.AbstractElement.getChildAt(int)
javax.swing.tree.DefaultMutableTreeNode.getChildAt(int)
javax.swing.tree.TreeNode.getChildAt(int)


Occurences of getChildCount

getChildCount occurences:
javax.swing.JTree.DynamicUtilTreeNode.getChildCount()
javax.swing.text.AbstractDocument.AbstractElement.getChildCount()
javax.swing.tree.DefaultMutableTreeNode.getChildCount()
javax.swing.tree.DefaultTreeModel.getChildCount(java.lang.Object)
javax.swing.tree.TreeModel.getChildCount(java.lang.Object)
javax.swing.tree.TreeNode.getChildCount()


Occurences of getChildElements

getChildElements occurences:
javax.xml.soap.SOAPElement.getChildElements()
javax.xml.soap.SOAPElement.getChildElements(javax.xml.namespace.QName)
javax.xml.soap.SOAPElement.getChildElements(javax.xml.soap.Name)


Occurences of getChildNames

getChildNames occurences:
javax.imageio.metadata.IIOMetadataFormat.getChildNames(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getChildNames(java.lang.String)


Occurences of getChildNodes

getChildNodes occurences:
javax.imageio.metadata.IIOMetadataNode.getChildNodes()
org.w3c.dom.Node.getChildNodes()


Occurences of getChildPolicy

getChildPolicy occurences:
javax.imageio.metadata.IIOMetadataFormat.getChildPolicy(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getChildPolicy(java.lang.String)


Occurences of getChildren

getChildren occurences:
java.security.cert.PolicyNode.getChildren()
javax.swing.event.TreeModelEvent.getChildren()


Occurences of getChildrenAdded

getChildrenAdded occurences:
javax.swing.event.DocumentEvent.ElementChange.getChildrenAdded()
javax.swing.text.AbstractDocument.ElementEdit.getChildrenAdded()


Occurences of getChildrenRemoved

getChildrenRemoved occurences:
javax.swing.event.DocumentEvent.ElementChange.getChildrenRemoved()
javax.swing.text.AbstractDocument.ElementEdit.getChildrenRemoved()


Occurences of getCipherSuite

getCipherSuite occurences:
java.net.SecureCacheResponse.getCipherSuite()
javax.net.ssl.HandshakeCompletedEvent.getCipherSuite()
javax.net.ssl.HttpsURLConnection.getCipherSuite()
javax.net.ssl.SSLSession.getCipherSuite()


Occurences of getClassAnnotation

getClassAnnotation occurences:
java.rmi.server.RMIClassLoader.getClassAnnotation(java.lang.Class)
java.rmi.server.RMIClassLoaderSpi.getClassAnnotation(java.lang.Class)


Occurences of getClasses

getClasses occurences:
com.sun.mirror.declaration.PackageDeclaration.getClasses()
java.lang.Class.getClasses()


Occurences of getClassLoader

getClassLoader occurences:
java.lang.Class.getClassLoader()
java.rmi.server.RMIClassLoader.getClassLoader(java.lang.String)
java.rmi.server.RMIClassLoaderSpi.getClassLoader(java.lang.String)
java.security.ProtectionDomain.getClassLoader()
javax.management.MBeanServer.getClassLoader(javax.management.ObjectName)
javax.tools.ForwardingJavaFileManager.getClassLoader(javax.tools.JavaFileManager.Location)
javax.tools.JavaFileManager.getClassLoader(javax.tools.JavaFileManager.Location)


Occurences of getClassLoaderRepository

getClassLoaderRepository occurences:
javax.management.MBeanServer.getClassLoaderRepository()
javax.management.MBeanServerFactory.getClassLoaderRepository(javax.management.MBeanServer)
javax.management.modelmbean.RequiredModelMBean.getClassLoaderRepository()


Occurences of getClassName

getClassName occurences:
java.lang.management.LockInfo.getClassName()
java.lang.StackTraceElement.getClassName()
java.rmi.activation.ActivationDesc.getClassName()
java.rmi.activation.ActivationGroupDesc.getClassName()
java.security.Provider.Service.getClassName()
java.util.MissingResourceException.getClassName()
javax.management.MBeanInfo.getClassName()
javax.management.modelmbean.ModelMBeanInfo.getClassName()
javax.management.ObjectInstance.getClassName()
javax.management.openmbean.OpenMBeanInfo.getClassName()
javax.management.openmbean.OpenType.getClassName()
javax.management.StandardMBean.getClassName(javax.management.MBeanInfo)
javax.naming.Binding.getClassName()
javax.naming.NameClassPair.getClassName()
javax.naming.Reference.getClassName()
javax.swing.UIManager.LookAndFeelInfo.getClassName()


Occurences of getClientHost

getClientHost occurences:
java.rmi.server.RemoteServer.getClientHost()
java.rmi.server.ServerRef.getClientHost()


Occurences of getClientInfo

getClientInfo occurences:
java.sql.Connection.getClientInfo()
java.sql.Connection.getClientInfo(java.lang.String)


Occurences of getClip

getClip occurences:
java.awt.Graphics.getClip()
javax.sound.sampled.AudioSystem.getClip()
javax.sound.sampled.AudioSystem.getClip(javax.sound.sampled.Mixer.Info)
javax.swing.DebugGraphics.getClip()


Occurences of getClipBounds

getClipBounds occurences:
java.awt.Graphics.getClipBounds()
java.awt.Graphics.getClipBounds(java.awt.Rectangle)
javax.swing.DebugGraphics.getClipBounds()


Occurences of getClob

getClob occurences:
java.sql.CallableStatement.getClob(int)
java.sql.CallableStatement.getClob(java.lang.String)
java.sql.ResultSet.getClob(int)
java.sql.ResultSet.getClob(java.lang.String)


Occurences of getClosestPathForLocation

getClosestPathForLocation occurences:
javax.swing.JTree.getClosestPathForLocation(int, int)
javax.swing.plaf.basic.BasicTreeUI.getClosestPathForLocation(javax.swing.JTree, int, int)
javax.swing.plaf.multi.MultiTreeUI.getClosestPathForLocation(javax.swing.JTree, int, int)
javax.swing.plaf.TreeUI.getClosestPathForLocation(javax.swing.JTree, int, int)


Occurences of getCode

getCode occurences:
javax.management.loading.MLetContent.getCode()
javax.tools.Diagnostic.getCode()


Occurences of getCodeBase

getCodeBase occurences:
java.applet.Applet.getCodeBase()
java.applet.AppletStub.getCodeBase()
javax.management.loading.MLetContent.getCodeBase()


Occurences of getCodebase

getCodebase occurences:
javax.rmi.CORBA.Util.getCodebase(java.lang.Class)
javax.rmi.CORBA.UtilDelegate.getCodebase(java.lang.Class)


Occurences of getCodeSigners

getCodeSigners occurences:
java.security.CodeSource.getCodeSigners()
java.util.jar.JarEntry.getCodeSigners()


Occurences of getCollationElementIterator

getCollationElementIterator occurences:
java.text.RuleBasedCollator.getCollationElementIterator(java.lang.String)
java.text.RuleBasedCollator.getCollationElementIterator(java.text.CharacterIterator)


Occurences of getCollationKey

getCollationKey occurences:
java.text.Collator.getCollationKey(java.lang.String)
java.text.RuleBasedCollator.getCollationKey(java.lang.String)


Occurences of getColor

getColor occurences:
java.awt.Color.getColor(java.lang.String)
java.awt.Color.getColor(java.lang.String, int)
java.awt.Color.getColor(java.lang.String, java.awt.Color)
java.awt.Graphics.getColor()
java.awt.PageAttributes.getColor()
javax.swing.DebugGraphics.getColor()
javax.swing.JColorChooser.getColor()
javax.swing.plaf.synth.SynthStyle.getColor(javax.swing.plaf.synth.SynthContext, javax.swing.plaf.synth.ColorType)
javax.swing.text.DefaultHighlighter.DefaultHighlightPainter.getColor()
javax.swing.UIDefaults.getColor(java.lang.Object)
javax.swing.UIDefaults.getColor(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getColor(java.lang.Object)
javax.swing.UIManager.getColor(java.lang.Object, java.util.Locale)


Occurences of getColorComponents

getColorComponents occurences:
java.awt.Color.getColorComponents(float[])
java.awt.Color.getColorComponents(java.awt.color.ColorSpace, float[])


Occurences of getColorModel

getColorModel occurences:
java.awt.Component.getColorModel()
java.awt.GraphicsConfiguration.getColorModel()
java.awt.GraphicsConfiguration.getColorModel(int)
java.awt.image.BufferedImage.getColorModel()
java.awt.image.PixelGrabber.getColorModel()
java.awt.image.RenderedImage.getColorModel()
java.awt.PaintContext.getColorModel()
java.awt.Toolkit.getColorModel()
javax.imageio.ImageTypeSpecifier.getColorModel()


Occurences of getColorSpace

getColorSpace occurences:
java.awt.Color.getColorSpace()
java.awt.image.ColorModel.getColorSpace()
java.awt.MultipleGradientPaint.getColorSpace()


Occurences of getColumn

getColumn occurences:
javax.swing.event.TableModelEvent.getColumn()
javax.swing.JTable.getColumn(java.lang.Object)
javax.swing.JTable.DropLocation.getColumn()
javax.swing.RowSorter.SortKey.getColumn()
javax.swing.table.DefaultTableColumnModel.getColumn(int)
javax.swing.table.TableColumnModel.getColumn(int)


Occurences of getColumnClass

getColumnClass occurences:
javax.swing.JTable.getColumnClass(int)
javax.swing.table.AbstractTableModel.getColumnClass(int)
javax.swing.table.TableModel.getColumnClass(int)


Occurences of getColumnClassName

getColumnClassName occurences:
java.sql.ResultSetMetaData.getColumnClassName(int)
javax.sql.rowset.RowSetMetaDataImpl.getColumnClassName(int)


Occurences of getColumnCount

getColumnCount occurences:
java.sql.ResultSetMetaData.getColumnCount()
javax.sql.rowset.RowSetMetaDataImpl.getColumnCount()
javax.swing.DefaultRowSorter.ModelWrapper.getColumnCount()
javax.swing.JTable.getColumnCount()
javax.swing.table.DefaultTableColumnModel.getColumnCount()
javax.swing.table.DefaultTableModel.getColumnCount()
javax.swing.table.TableColumnModel.getColumnCount()
javax.swing.table.TableModel.getColumnCount()
javax.swing.text.TableView.TableCell.getColumnCount()


Occurences of getColumnDisplaySize

getColumnDisplaySize occurences:
java.sql.ResultSetMetaData.getColumnDisplaySize(int)
javax.sql.rowset.RowSetMetaDataImpl.getColumnDisplaySize(int)


Occurences of getColumnHeader

getColumnHeader occurences:
javax.swing.JScrollPane.getColumnHeader()
javax.swing.ScrollPaneLayout.getColumnHeader()


Occurences of getColumnIndex

getColumnIndex occurences:
javax.swing.table.DefaultTableColumnModel.getColumnIndex(java.lang.Object)
javax.swing.table.TableColumnModel.getColumnIndex(java.lang.Object)


Occurences of getColumnIndexAtX

getColumnIndexAtX occurences:
javax.swing.table.DefaultTableColumnModel.getColumnIndexAtX(int)
javax.swing.table.TableColumnModel.getColumnIndexAtX(int)


Occurences of getColumnLabel

getColumnLabel occurences:
java.sql.ResultSetMetaData.getColumnLabel(int)
javax.sql.rowset.RowSetMetaDataImpl.getColumnLabel(int)


Occurences of getColumnMargin

getColumnMargin occurences:
javax.swing.table.DefaultTableColumnModel.getColumnMargin()
javax.swing.table.TableColumnModel.getColumnMargin()


Occurences of getColumnModel

getColumnModel occurences:
javax.swing.JTable.getColumnModel()
javax.swing.table.JTableHeader.getColumnModel()


Occurences of getColumnName

getColumnName occurences:
java.sql.ResultSetMetaData.getColumnName(int)
javax.sql.rowset.RowSetMetaDataImpl.getColumnName(int)
javax.swing.JTable.getColumnName(int)
javax.swing.table.AbstractTableModel.getColumnName(int)
javax.swing.table.DefaultTableModel.getColumnName(int)
javax.swing.table.TableModel.getColumnName(int)


Occurences of getColumnNumber

getColumnNumber occurences:
com.sun.source.tree.LineMap.getColumnNumber(long)
javax.script.ScriptException.getColumnNumber()
javax.tools.Diagnostic.getColumnNumber()
javax.xml.bind.helpers.ValidationEventLocatorImpl.getColumnNumber()
javax.xml.bind.ValidationEventLocator.getColumnNumber()
javax.xml.stream.Location.getColumnNumber()
javax.xml.transform.SourceLocator.getColumnNumber()
org.w3c.dom.DOMLocator.getColumnNumber()
org.xml.sax.helpers.LocatorImpl.getColumnNumber()
org.xml.sax.Locator.getColumnNumber()
org.xml.sax.SAXParseException.getColumnNumber()


Occurences of getColumns

getColumns occurences:
java.awt.GridLayout.getColumns()
java.awt.TextArea.getColumns()
java.awt.TextField.getColumns()
java.sql.DatabaseMetaData.getColumns(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
javax.swing.JTextArea.getColumns()
javax.swing.JTextField.getColumns()
javax.swing.table.DefaultTableColumnModel.getColumns()
javax.swing.table.TableColumnModel.getColumns()


Occurences of getColumnSelectionAllowed

getColumnSelectionAllowed occurences:
javax.swing.JTable.getColumnSelectionAllowed()
javax.swing.table.DefaultTableColumnModel.getColumnSelectionAllowed()
javax.swing.table.TableColumnModel.getColumnSelectionAllowed()


Occurences of getColumnType

getColumnType occurences:
java.sql.ResultSetMetaData.getColumnType(int)
javax.sql.rowset.RowSetMetaDataImpl.getColumnType(int)


Occurences of getColumnTypeName

getColumnTypeName occurences:
java.sql.ResultSetMetaData.getColumnTypeName(int)
javax.sql.rowset.RowSetMetaDataImpl.getColumnTypeName(int)


Occurences of getColumnWidth

getColumnWidth occurences:
javax.swing.JTextArea.getColumnWidth()
javax.swing.JTextField.getColumnWidth()


Occurences of getCommand

getCommand occurences:
javax.activation.CommandMap.getCommand(java.lang.String, java.lang.String)
javax.activation.CommandMap.getCommand(java.lang.String, java.lang.String, javax.activation.DataSource)
javax.activation.DataHandler.getCommand(java.lang.String)
javax.activation.MailcapCommandMap.getCommand(java.lang.String, java.lang.String)
javax.sound.midi.ShortMessage.getCommand()
javax.sql.RowSet.getCommand()
javax.sql.rowset.BaseRowSet.getCommand()


Occurences of getComment

getComment occurences:
java.net.HttpCookie.getComment()
java.util.zip.ZipEntry.getComment()


Occurences of getCommittedText

getCommittedText occurences:
Class ActiveClient.ActiveClient.getCommittedText(int, int, java.text.AttributedCharacterIterator.Attribute[])
Class LWTextComponent.LWTextComponent.getCommittedText()
Class LWTextComponent.LWTextComponent.getCommittedText(int, int)
java.awt.im.InputMethodRequests.getCommittedText(int, int, java.text.AttributedCharacterIterator.Attribute[])


Occurences of getCommittedTextLength

getCommittedTextLength occurences:
Class LWTextComponent.LWTextComponent.getCommittedTextLength()
java.awt.im.InputMethodRequests.getCommittedTextLength()


Occurences of getComparator

getComparator occurences:
javax.swing.DefaultRowSorter.getComparator(int)
javax.swing.SortingFocusTraversalPolicy.getComparator()
javax.swing.table.TableRowSorter.getComparator(int)


Occurences of getCompilationUnit

getCompilationUnit occurences:
com.sun.source.util.TaskEvent.getCompilationUnit()
com.sun.source.util.TreePath.getCompilationUnit()


Occurences of getCompletions

getCompletions occurences:
javax.annotation.processing.AbstractProcessor.getCompletions(javax.lang.model.element.Element, javax.lang.model.element.AnnotationMirror, javax.lang.model.element.ExecutableElement, java.lang.String)
javax.annotation.processing.Processor.getCompletions(javax.lang.model.element.Element, javax.lang.model.element.AnnotationMirror, javax.lang.model.element.ExecutableElement, java.lang.String)


Occurences of getComponent

getComponent occurences:
java.awt.Container.getComponent(int)
java.awt.dnd.DragGestureEvent.getComponent()
java.awt.dnd.DragGestureRecognizer.getComponent()
java.awt.dnd.DragSourceContext.getComponent()
java.awt.dnd.DropTarget.getComponent()
java.awt.dnd.DropTargetContext.getComponent()
java.awt.event.ComponentEvent.getComponent()
java.awt.event.HierarchyEvent.getComponent()
java.beans.beancontext.BeanContextChildComponentProxy.getComponent()
javax.swing.ComponentInputMap.getComponent()
javax.swing.DefaultCellEditor.getComponent()
javax.swing.event.AncestorEvent.getComponent()
javax.swing.JMenu.getComponent()
javax.swing.JMenuBar.getComponent()
javax.swing.JMenuItem.getComponent()
javax.swing.JPopupMenu.getComponent()
javax.swing.JToolTip.getComponent()
javax.swing.MenuElement.getComponent()
javax.swing.plaf.basic.BasicTextUI.getComponent()
javax.swing.plaf.synth.SynthContext.getComponent()
javax.swing.Renderer.getComponent()
javax.swing.text.ComponentView.getComponent()
javax.swing.text.DefaultCaret.getComponent()
javax.swing.text.StyleConstants.getComponent(javax.swing.text.AttributeSet)
javax.swing.TransferHandler.TransferSupport.getComponent()


Occurences of getComponentAfter

getComponentAfter occurences:
java.awt.ContainerOrderFocusTraversalPolicy.getComponentAfter(java.awt.Container, java.awt.Component)
java.awt.FocusTraversalPolicy.getComponentAfter(java.awt.Container, java.awt.Component)
javax.swing.DefaultFocusManager.getComponentAfter(java.awt.Container, java.awt.Component)
javax.swing.LayoutFocusTraversalPolicy.getComponentAfter(java.awt.Container, java.awt.Component)
javax.swing.SortingFocusTraversalPolicy.getComponentAfter(java.awt.Container, java.awt.Component)


Occurences of getComponentAt

getComponentAt occurences:
java.awt.Component.getComponentAt(int, int)
java.awt.Component.getComponentAt(java.awt.Point)
java.awt.Container.getComponentAt(int, int)
java.awt.Container.getComponentAt(java.awt.Point)
javax.swing.JTabbedPane.getComponentAt(int)


Occurences of getComponentAtIndex

getComponentAtIndex occurences:
javax.swing.JMenuBar.getComponentAtIndex(int)
javax.swing.JPopupMenu.getComponentAtIndex(int)
javax.swing.JToolBar.getComponentAtIndex(int)


Occurences of getComponentBefore

getComponentBefore occurences:
java.awt.ContainerOrderFocusTraversalPolicy.getComponentBefore(java.awt.Container, java.awt.Component)
java.awt.FocusTraversalPolicy.getComponentBefore(java.awt.Container, java.awt.Component)
javax.swing.DefaultFocusManager.getComponentBefore(java.awt.Container, java.awt.Component)
javax.swing.LayoutFocusTraversalPolicy.getComponentBefore(java.awt.Container, java.awt.Component)
javax.swing.SortingFocusTraversalPolicy.getComponentBefore(java.awt.Container, java.awt.Component)


Occurences of getComponentIndex

getComponentIndex occurences:
javax.swing.JMenuBar.getComponentIndex(java.awt.Component)
javax.swing.JPopupMenu.getComponentIndex(java.awt.Component)
javax.swing.JToolBar.getComponentIndex(java.awt.Component)


Occurences of getComponents

getComponents occurences:
java.awt.Color.getComponents(float[])
java.awt.Color.getComponents(java.awt.color.ColorSpace, float[])
java.awt.Container.getComponents()
java.awt.image.ColorModel.getComponents(int, int[], int)
java.awt.image.ColorModel.getComponents(java.lang.Object, int[], int)
java.awt.image.ComponentColorModel.getComponents(int, int[], int)
java.awt.image.ComponentColorModel.getComponents(java.lang.Object, int[], int)
java.awt.image.DirectColorModel.getComponents(int, int[], int)
java.awt.image.DirectColorModel.getComponents(java.lang.Object, int[], int)
java.awt.image.IndexColorModel.getComponents(int, int[], int)
java.awt.image.IndexColorModel.getComponents(java.lang.Object, int[], int)


Occurences of getComponentSize

getComponentSize occurences:
java.awt.image.ColorModel.getComponentSize()
java.awt.image.ColorModel.getComponentSize(int)
java.awt.image.IndexColorModel.getComponentSize()


Occurences of getComponentType

getComponentType occurences:
com.sun.mirror.type.ArrayType.getComponentType()
java.lang.Class.getComponentType()
javax.lang.model.type.ArrayType.getComponentType()


Occurences of getCompositeAnnotationProcessor

getCompositeAnnotationProcessor occurences:
com.sun.mirror.apt.AnnotationProcessors.getCompositeAnnotationProcessor(com.sun.mirror.apt.AnnotationProcessor...)
com.sun.mirror.apt.AnnotationProcessors.getCompositeAnnotationProcessor(java.util.Collection)


Occurences of getCompositeType

getCompositeType occurences:
javax.management.openmbean.CompositeData.getCompositeType()
javax.management.openmbean.CompositeDataSupport.getCompositeType()


Occurences of getCompressionQualityDescriptions

getCompressionQualityDescriptions occurences:
javax.imageio.ImageWriteParam.getCompressionQualityDescriptions()
javax.imageio.plugins.jpeg.JPEGImageWriteParam.getCompressionQualityDescriptions()


Occurences of getCompressionQualityValues

getCompressionQualityValues occurences:
javax.imageio.ImageWriteParam.getCompressionQualityValues()
javax.imageio.plugins.jpeg.JPEGImageWriteParam.getCompressionQualityValues()


Occurences of getConcurrency

getConcurrency occurences:
java.sql.ResultSet.getConcurrency()
javax.sql.rowset.BaseRowSet.getConcurrency()


Occurences of getCondition

getCondition occurences:
com.sun.source.tree.AssertTree.getCondition()
com.sun.source.tree.ConditionalExpressionTree.getCondition()
com.sun.source.tree.DoWhileLoopTree.getCondition()
com.sun.source.tree.ForLoopTree.getCondition()
com.sun.source.tree.IfTree.getCondition()
com.sun.source.tree.WhileLoopTree.getCondition()


Occurences of getConflictValue

getConflictValue occurences:
javax.sql.rowset.spi.SyncResolver.getConflictValue(int)
javax.sql.rowset.spi.SyncResolver.getConflictValue(java.lang.String)


Occurences of getConnectControls

getConnectControls occurences:
javax.naming.ldap.InitialLdapContext.getConnectControls()
javax.naming.ldap.LdapContext.getConnectControls()


Occurences of getConnection

getConnection occurences:
java.sql.DatabaseMetaData.getConnection()
java.sql.DriverManager.getConnection(java.lang.String)
java.sql.DriverManager.getConnection(java.lang.String, java.lang.String, java.lang.String)
java.sql.DriverManager.getConnection(java.lang.String, java.util.Properties)
java.sql.Statement.getConnection()
javax.sql.DataSource.getConnection()
javax.sql.DataSource.getConnection(java.lang.String, java.lang.String)
javax.sql.PooledConnection.getConnection()
javax.sql.RowSetInternal.getConnection()


Occurences of getConnectionId

getConnectionId occurences:
javax.management.remote.JMXConnectionNotification.getConnectionId()
javax.management.remote.JMXConnector.getConnectionId()
javax.management.remote.rmi.RMIConnection.getConnectionId()
javax.management.remote.rmi.RMIConnectionImpl.getConnectionId()
javax.management.remote.rmi.RMIConnectionImpl_Stub.getConnectionId()
javax.management.remote.rmi.RMIConnector.getConnectionId()


Occurences of getConnectionIds

getConnectionIds occurences:
javax.management.remote.JMXConnectorServer.getConnectionIds()
javax.management.remote.JMXConnectorServerMBean.getConnectionIds()


Occurences of getConstantExpression

getConstantExpression occurences:
com.sun.mirror.declaration.FieldDeclaration.getConstantExpression()
javax.lang.model.util.Elements.getConstantExpression(java.lang.Object)


Occurences of getConstantValue

getConstantValue occurences:
com.sun.mirror.declaration.FieldDeclaration.getConstantValue()
javax.lang.model.element.VariableElement.getConstantValue()


Occurences of getConstraint

getConstraint occurences:
javax.swing.SpringLayout.getConstraint(java.lang.String, java.awt.Component)
javax.swing.SpringLayout.Constraints.getConstraint(java.lang.String)


Occurences of getConstraints

getConstraints occurences:
java.awt.BorderLayout.getConstraints(java.awt.Component)
java.awt.GridBagLayout.getConstraints(java.awt.Component)
javax.swing.SpringLayout.getConstraints(java.awt.Component)


Occurences of getConstructor

getConstructor occurences:
java.lang.Class.getConstructor(java.lang.Class...)
javax.management.modelmbean.ModelMBeanInfoSupport.getConstructor(java.lang.String)


Occurences of getConstructors

getConstructors occurences:
com.sun.mirror.declaration.ClassDeclaration.getConstructors()
java.lang.Class.getConstructors()
javax.management.MBeanInfo.getConstructors()
javax.management.modelmbean.ModelMBeanInfo.getConstructors()
javax.management.openmbean.OpenMBeanInfo.getConstructors()
javax.management.StandardMBean.getConstructors(javax.management.MBeanConstructorInfo[], java.lang.Object)


Occurences of getContainer

getContainer occurences:
java.awt.event.ContainerEvent.getContainer()
java.beans.beancontext.BeanContextContainerProxy.getContainer()
javax.swing.text.View.getContainer()


Occurences of getContent

getContent occurences:
java.net.ContentHandler.getContent(java.net.URLConnection)
java.net.ContentHandler.getContent(java.net.URLConnection, java.lang.Class[])
java.net.URL.getContent()
java.net.URL.getContent(java.lang.Class[])
java.net.URLConnection.getContent()
java.net.URLConnection.getContent(java.lang.Class[])
javax.activation.DataContentHandler.getContent(javax.activation.DataSource)
javax.activation.DataHandler.getContent()
javax.naming.BinaryRefAddr.getContent()
javax.naming.RefAddr.getContent()
javax.naming.StringRefAddr.getContent()
javax.swing.text.AbstractDocument.getContent()
javax.swing.text.html.parser.Element.getContent()
javax.xml.crypto.dsig.keyinfo.KeyInfo.getContent()
javax.xml.crypto.dsig.keyinfo.X509Data.getContent()
javax.xml.crypto.dsig.SignatureProperty.getContent()
javax.xml.crypto.dsig.XMLObject.getContent()
javax.xml.soap.AttachmentPart.getContent()
javax.xml.soap.SOAPPart.getContent()


Occurences of getContentHandler

getContentHandler occurences:
javax.xml.validation.ValidatorHandler.getContentHandler()
org.xml.sax.helpers.ParserAdapter.getContentHandler()
org.xml.sax.helpers.XMLFilterImpl.getContentHandler()
org.xml.sax.XMLReader.getContentHandler()


Occurences of getContentId

getContentId occurences:
javax.xml.soap.AttachmentPart.getContentId()
javax.xml.soap.SOAPPart.getContentId()


Occurences of getContentLocation

getContentLocation occurences:
javax.xml.soap.AttachmentPart.getContentLocation()
javax.xml.soap.SOAPPart.getContentLocation()


Occurences of getContentPane

getContentPane occurences:
javax.swing.JApplet.getContentPane()
javax.swing.JDialog.getContentPane()
javax.swing.JFrame.getContentPane()
javax.swing.JInternalFrame.getContentPane()
javax.swing.JRootPane.getContentPane()
javax.swing.JWindow.getContentPane()
javax.swing.RootPaneContainer.getContentPane()


Occurences of getContents

getContents occurences:
java.awt.datatransfer.Clipboard.getContents(java.lang.Object)
java.util.ListResourceBundle.getContents()
javax.accessibility.AccessibleResourceBundle.getContents()


Occurences of getContentType

getContentType occurences:
java.net.URLConnection.getContentType()
javax.activation.DataHandler.getContentType()
javax.activation.DataSource.getContentType()
javax.activation.FileDataSource.getContentType()
javax.activation.FileTypeMap.getContentType(java.io.File)
javax.activation.FileTypeMap.getContentType(java.lang.String)
javax.activation.MimetypesFileTypeMap.getContentType(java.io.File)
javax.activation.MimetypesFileTypeMap.getContentType(java.lang.String)
javax.activation.URLDataSource.getContentType()
javax.swing.JEditorPane.getContentType()
javax.swing.text.DefaultEditorKit.getContentType()
javax.swing.text.EditorKit.getContentType()
javax.swing.text.html.HTMLEditorKit.getContentType()
javax.swing.text.rtf.RTFEditorKit.getContentType()
javax.xml.soap.AttachmentPart.getContentType()


Occurences of getContext

getContext occurences:
com.sun.tools.jconsole.JConsolePlugin.getContext()
java.security.AccessController.getContext()
javax.script.AbstractScriptEngine.getContext()
javax.script.ScriptEngine.getContext()
javax.xml.ws.Response.getContext()


Occurences of getContextualShaper

getContextualShaper occurences:
java.awt.font.NumericShaper.getContextualShaper(int)
java.awt.font.NumericShaper.getContextualShaper(int, int)


Occurences of getControl

getControl occurences:
java.util.ResourceBundle.Control.getControl(java.util.List)
javax.sound.sampled.Line.getControl(javax.sound.sampled.Control.Type)
javax.swing.plaf.metal.MetalLookAndFeel.getControl()
javax.swing.plaf.metal.MetalTheme.getControl()


Occurences of getControlDarkShadow

getControlDarkShadow occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getControlDarkShadow()
javax.swing.plaf.metal.MetalTheme.getControlDarkShadow()


Occurences of getControlDisabled

getControlDisabled occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getControlDisabled()
javax.swing.plaf.metal.MetalTheme.getControlDisabled()


Occurences of getControlHighlight

getControlHighlight occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getControlHighlight()
javax.swing.plaf.metal.MetalTheme.getControlHighlight()


Occurences of getControlInfo

getControlInfo occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getControlInfo()
javax.swing.plaf.metal.MetalTheme.getControlInfo()


Occurences of getControlInstance

getControlInstance occurences:
javax.naming.ldap.ControlFactory.getControlInstance(javax.naming.ldap.Control)
javax.naming.ldap.ControlFactory.getControlInstance(javax.naming.ldap.Control, javax.naming.Context, java.util.Hashtable)


Occurences of getController

getController occurences:
javax.imageio.IIOParam.getController()
javax.imageio.metadata.IIOMetadata.getController()
javax.sound.midi.MidiChannel.getController(int)


Occurences of getControls

getControls occurences:
javax.naming.ldap.HasControls.getControls()
javax.sound.sampled.Line.getControls()


Occurences of getControlShadow

getControlShadow occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getControlShadow()
javax.swing.plaf.metal.MetalTheme.getControlShadow()


Occurences of getControlTextColor

getControlTextColor occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getControlTextColor()
javax.swing.plaf.metal.MetalTheme.getControlTextColor()
javax.swing.plaf.metal.OceanTheme.getControlTextColor()


Occurences of getControlTextFont

getControlTextFont occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getControlTextFont()
javax.swing.plaf.metal.MetalLookAndFeel.getControlTextFont()
javax.swing.plaf.metal.MetalTheme.getControlTextFont()


Occurences of getConversion

getConversion occurences:
java.util.FormatFlagsConversionMismatchException.getConversion()
java.util.IllegalFormatConversionException.getConversion()
java.util.UnknownFormatConversionException.getConversion()


Occurences of getCopies

getCopies occurences:
java.awt.JobAttributes.getCopies()
java.awt.print.PrinterJob.getCopies()


Occurences of getCorner

getCorner occurences:
javax.swing.JScrollPane.getCorner(java.lang.String)
javax.swing.ScrollPaneLayout.getCorner(java.lang.String)


Occurences of getCount

getCount occurences:
java.lang.management.MemoryNotificationInfo.getCount()
java.util.concurrent.CountDownLatch.getCount()


Occurences of getCrtCoefficient

getCrtCoefficient occurences:
java.security.interfaces.RSAMultiPrimePrivateCrtKey.getCrtCoefficient()
java.security.interfaces.RSAPrivateCrtKey.getCrtCoefficient()
java.security.spec.RSAMultiPrimePrivateCrtKeySpec.getCrtCoefficient()
java.security.spec.RSAOtherPrimeInfo.getCrtCoefficient()
java.security.spec.RSAPrivateCrtKeySpec.getCrtCoefficient()


Occurences of getCtrlP1

getCtrlP1 occurences:
java.awt.geom.CubicCurve2D.getCtrlP1()
java.awt.geom.CubicCurve2D.Double.getCtrlP1()
java.awt.geom.CubicCurve2D.Float.getCtrlP1()


Occurences of getCtrlP2

getCtrlP2 occurences:
java.awt.geom.CubicCurve2D.getCtrlP2()
java.awt.geom.CubicCurve2D.Double.getCtrlP2()
java.awt.geom.CubicCurve2D.Float.getCtrlP2()


Occurences of getCtrlPt

getCtrlPt occurences:
java.awt.geom.QuadCurve2D.getCtrlPt()
java.awt.geom.QuadCurve2D.Double.getCtrlPt()
java.awt.geom.QuadCurve2D.Float.getCtrlPt()


Occurences of getCtrlX

getCtrlX occurences:
java.awt.geom.QuadCurve2D.getCtrlX()
java.awt.geom.QuadCurve2D.Double.getCtrlX()
java.awt.geom.QuadCurve2D.Float.getCtrlX()


Occurences of getCtrlX1

getCtrlX1 occurences:
java.awt.geom.CubicCurve2D.getCtrlX1()
java.awt.geom.CubicCurve2D.Double.getCtrlX1()
java.awt.geom.CubicCurve2D.Float.getCtrlX1()


Occurences of getCtrlX2

getCtrlX2 occurences:
java.awt.geom.CubicCurve2D.getCtrlX2()
java.awt.geom.CubicCurve2D.Double.getCtrlX2()
java.awt.geom.CubicCurve2D.Float.getCtrlX2()


Occurences of getCtrlY

getCtrlY occurences:
java.awt.geom.QuadCurve2D.getCtrlY()
java.awt.geom.QuadCurve2D.Double.getCtrlY()
java.awt.geom.QuadCurve2D.Float.getCtrlY()


Occurences of getCtrlY1

getCtrlY1 occurences:
java.awt.geom.CubicCurve2D.getCtrlY1()
java.awt.geom.CubicCurve2D.Double.getCtrlY1()
java.awt.geom.CubicCurve2D.Float.getCtrlY1()


Occurences of getCtrlY2

getCtrlY2 occurences:
java.awt.geom.CubicCurve2D.getCtrlY2()
java.awt.geom.CubicCurve2D.Double.getCtrlY2()
java.awt.geom.CubicCurve2D.Float.getCtrlY2()


Occurences of getCurrency

getCurrency occurences:
java.text.DecimalFormat.getCurrency()
java.text.DecimalFormatSymbols.getCurrency()
java.text.NumberFormat.getCurrency()


Occurences of getCurrencyInstance

getCurrencyInstance occurences:
java.text.NumberFormat.getCurrencyInstance()
java.text.NumberFormat.getCurrencyInstance(java.util.Locale)
java.text.spi.NumberFormatProvider.getCurrencyInstance(java.util.Locale)


Occurences of getCurrentAccessibleValue

getCurrentAccessibleValue occurences:
java.awt.Button.AccessibleAWTButton.getCurrentAccessibleValue()
java.awt.Checkbox.AccessibleAWTCheckbox.getCurrentAccessibleValue()
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.getCurrentAccessibleValue()
java.awt.MenuItem.AccessibleAWTMenuItem.getCurrentAccessibleValue()
java.awt.Scrollbar.AccessibleAWTScrollBar.getCurrentAccessibleValue()
javax.accessibility.AccessibleValue.getCurrentAccessibleValue()
javax.swing.AbstractButton.AccessibleAbstractButton.getCurrentAccessibleValue()
javax.swing.JInternalFrame.AccessibleJInternalFrame.getCurrentAccessibleValue()
javax.swing.JInternalFrame.JDesktopIcon.AccessibleJDesktopIcon.getCurrentAccessibleValue()
javax.swing.JProgressBar.AccessibleJProgressBar.getCurrentAccessibleValue()
javax.swing.JScrollBar.AccessibleJScrollBar.getCurrentAccessibleValue()
javax.swing.JSlider.AccessibleJSlider.getCurrentAccessibleValue()
javax.swing.JSpinner.AccessibleJSpinner.getCurrentAccessibleValue()
javax.swing.JSplitPane.AccessibleJSplitPane.getCurrentAccessibleValue()


Occurences of getCurrentDataFlavors

getCurrentDataFlavors occurences:
java.awt.dnd.DropTargetContext.getCurrentDataFlavors()
java.awt.dnd.DropTargetDragEvent.getCurrentDataFlavors()
java.awt.dnd.DropTargetDropEvent.getCurrentDataFlavors()


Occurences of getCurrentDataFlavorsAsList

getCurrentDataFlavorsAsList occurences:
java.awt.dnd.DropTargetContext.getCurrentDataFlavorsAsList()
java.awt.dnd.DropTargetDragEvent.getCurrentDataFlavorsAsList()
java.awt.dnd.DropTargetDropEvent.getCurrentDataFlavorsAsList()


Occurences of getCurrentServiceClasses

getCurrentServiceClasses occurences:
java.beans.beancontext.BeanContextServices.getCurrentServiceClasses()
java.beans.beancontext.BeanContextServicesSupport.getCurrentServiceClasses()


Occurences of getCurrentServiceSelectors

getCurrentServiceSelectors occurences:
java.beans.beancontext.BeanContextServiceAvailableEvent.getCurrentServiceSelectors()
java.beans.beancontext.BeanContextServiceProvider.getCurrentServiceSelectors(java.beans.beancontext.BeanContextServices, java.lang.Class)
java.beans.beancontext.BeanContextServices.getCurrentServiceSelectors(java.lang.Class)
java.beans.beancontext.BeanContextServicesSupport.getCurrentServiceSelectors(java.lang.Class)
java.beans.beancontext.BeanContextServicesSupport.BCSSProxyServiceProvider.getCurrentServiceSelectors(java.beans.beancontext.BeanContextServices, java.lang.Class)


Occurences of getCursor

getCursor occurences:
java.awt.Component.getCursor()
java.awt.Component.AccessibleAWTComponent.getCursor()
java.awt.dnd.DragSourceContext.getCursor()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getCursor()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getCursor()
javax.accessibility.AccessibleComponent.getCursor()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getCursor()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getCursor()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getCursor()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getCursor()


Occurences of getCustomEditor

getCustomEditor occurences:
java.beans.PropertyEditor.getCustomEditor()
java.beans.PropertyEditorSupport.getCustomEditor()


Occurences of getData

getData occurences:
java.awt.color.ICC_Profile.getData()
java.awt.color.ICC_Profile.getData(int)
java.awt.datatransfer.Clipboard.getData(java.awt.datatransfer.DataFlavor)
java.awt.image.BufferedImage.getData()
java.awt.image.BufferedImage.getData(java.awt.Rectangle)
java.awt.image.DataBufferByte.getData()
java.awt.image.DataBufferByte.getData(int)
java.awt.image.DataBufferDouble.getData()
java.awt.image.DataBufferDouble.getData(int)
java.awt.image.DataBufferFloat.getData()
java.awt.image.DataBufferFloat.getData(int)
java.awt.image.DataBufferInt.getData()
java.awt.image.DataBufferInt.getData(int)
java.awt.image.DataBufferShort.getData()
java.awt.image.DataBufferShort.getData(int)
java.awt.image.DataBufferUShort.getData()
java.awt.image.DataBufferUShort.getData(int)
java.awt.image.RenderedImage.getData()
java.awt.image.RenderedImage.getData(java.awt.Rectangle)
java.net.DatagramPacket.getData()
java.rmi.activation.ActivationDesc.getData()
java.rmi.activation.ActivationGroupDesc.getData()
javax.imageio.stream.IIOByteBuffer.getData()
javax.sound.midi.MetaMessage.getData()
javax.sound.midi.SoundbankResource.getData()
javax.sound.midi.SysexMessage.getData()
javax.swing.text.html.FormSubmitEvent.getData()
javax.swing.text.html.parser.Entity.getData()
javax.xml.stream.events.Characters.getData()
javax.xml.stream.events.ProcessingInstruction.getData()
org.w3c.dom.CharacterData.getData()
org.w3c.dom.ProcessingInstruction.getData()


Occurences of getDataElement

getDataElement occurences:
java.awt.image.ColorModel.getDataElement(float[], int)
java.awt.image.ColorModel.getDataElement(int[], int)
java.awt.image.ComponentColorModel.getDataElement(float[], int)
java.awt.image.ComponentColorModel.getDataElement(int[], int)
java.awt.image.DirectColorModel.getDataElement(int[], int)
java.awt.image.IndexColorModel.getDataElement(int[], int)


Occurences of getDataElements

getDataElements occurences:
java.awt.image.BandedSampleModel.getDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.ColorModel.getDataElements(float[], int, java.lang.Object)
java.awt.image.ColorModel.getDataElements(int, java.lang.Object)
java.awt.image.ColorModel.getDataElements(int[], int, java.lang.Object)
java.awt.image.ComponentColorModel.getDataElements(float[], int, java.lang.Object)
java.awt.image.ComponentColorModel.getDataElements(int, java.lang.Object)
java.awt.image.ComponentColorModel.getDataElements(int[], int, java.lang.Object)
java.awt.image.ComponentSampleModel.getDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.DirectColorModel.getDataElements(int, java.lang.Object)
java.awt.image.DirectColorModel.getDataElements(int[], int, java.lang.Object)
java.awt.image.IndexColorModel.getDataElements(int, java.lang.Object)
java.awt.image.IndexColorModel.getDataElements(int[], int, java.lang.Object)
java.awt.image.MultiPixelPackedSampleModel.getDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.Raster.getDataElements(int, int, int, int, java.lang.Object)
java.awt.image.Raster.getDataElements(int, int, java.lang.Object)
java.awt.image.SampleModel.getDataElements(int, int, int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.SampleModel.getDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.getDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)


Occurences of getDataSourceName

getDataSourceName occurences:
javax.sql.RowSet.getDataSourceName()
javax.sql.rowset.BaseRowSet.getDataSourceName()


Occurences of getDataType

getDataType occurences:
java.awt.image.DataBuffer.getDataType()
java.awt.image.SampleModel.getDataType()


Occurences of getDate

getDate occurences:
java.net.URLConnection.getDate()
java.security.cert.PKIXParameters.getDate()
java.sql.CallableStatement.getDate(int)
java.sql.CallableStatement.getDate(int, java.util.Calendar)
java.sql.CallableStatement.getDate(java.lang.String)
java.sql.CallableStatement.getDate(java.lang.String, java.util.Calendar)
java.sql.ResultSet.getDate(int)
java.sql.ResultSet.getDate(int, java.util.Calendar)
java.sql.ResultSet.getDate(java.lang.String)
java.sql.ResultSet.getDate(java.lang.String, java.util.Calendar)
java.sql.Time.getDate()
java.util.Date.getDate()
javax.management.timer.Timer.getDate(java.lang.Integer)
javax.management.timer.TimerMBean.getDate(java.lang.Integer)
javax.swing.SpinnerDateModel.getDate()


Occurences of getDateInstance

getDateInstance occurences:
java.text.DateFormat.getDateInstance()
java.text.DateFormat.getDateInstance(int)
java.text.DateFormat.getDateInstance(int, java.util.Locale)
java.text.spi.DateFormatProvider.getDateInstance(int, java.util.Locale)


Occurences of getDateTimeInstance

getDateTimeInstance occurences:
java.text.DateFormat.getDateTimeInstance()
java.text.DateFormat.getDateTimeInstance(int, int)
java.text.DateFormat.getDateTimeInstance(int, int, java.util.Locale)
java.text.spi.DateFormatProvider.getDateTimeInstance(int, int, java.util.Locale)


Occurences of getDay

getDay occurences:
java.sql.Time.getDay()
java.util.Date.getDay()
javax.xml.datatype.XMLGregorianCalendar.getDay()


Occurences of getDCHuffmanTables

getDCHuffmanTables occurences:
javax.imageio.plugins.jpeg.JPEGImageReadParam.getDCHuffmanTables()
javax.imageio.plugins.jpeg.JPEGImageWriteParam.getDCHuffmanTables()


Occurences of getDeclaration

getDeclaration occurences:
com.sun.mirror.type.AnnotationType.getDeclaration()
com.sun.mirror.type.ClassType.getDeclaration()
com.sun.mirror.type.DeclaredType.getDeclaration()
com.sun.mirror.type.EnumType.getDeclaration()
com.sun.mirror.type.InterfaceType.getDeclaration()
com.sun.mirror.type.TypeVariable.getDeclaration()
javax.swing.text.html.StyleSheet.getDeclaration(java.lang.String)
javax.xml.stream.events.EntityReference.getDeclaration()


Occurences of getDeclaredAnnotations

getDeclaredAnnotations occurences:
java.lang.Class.getDeclaredAnnotations()
java.lang.Package.getDeclaredAnnotations()
java.lang.reflect.AccessibleObject.getDeclaredAnnotations()
java.lang.reflect.AnnotatedElement.getDeclaredAnnotations()
java.lang.reflect.Constructor.getDeclaredAnnotations()
java.lang.reflect.Field.getDeclaredAnnotations()
java.lang.reflect.Method.getDeclaredAnnotations()


Occurences of getDeclaredType

getDeclaredType occurences:
com.sun.mirror.util.Types.getDeclaredType(com.sun.mirror.declaration.TypeDeclaration, com.sun.mirror.type.TypeMirror...)
com.sun.mirror.util.Types.getDeclaredType(com.sun.mirror.type.DeclaredType, com.sun.mirror.declaration.TypeDeclaration, com.sun.mirror.type.TypeMirror...)
javax.lang.model.util.Types.getDeclaredType(javax.lang.model.element.TypeElement, javax.lang.model.type.TypeMirror...)
javax.lang.model.util.Types.getDeclaredType(javax.lang.model.type.DeclaredType, javax.lang.model.element.TypeElement, javax.lang.model.type.TypeMirror...)
javax.xml.bind.JAXBElement.getDeclaredType()


Occurences of getDeclaringClass

getDeclaringClass occurences:
java.lang.Class.getDeclaringClass()
java.lang.Enum.getDeclaringClass()
java.lang.reflect.Constructor.getDeclaringClass()
java.lang.reflect.Field.getDeclaringClass()
java.lang.reflect.Member.getDeclaringClass()
java.lang.reflect.Method.getDeclaringClass()


Occurences of getDeclaringType

getDeclaringType occurences:
com.sun.mirror.declaration.AnnotationTypeElementDeclaration.getDeclaringType()
com.sun.mirror.declaration.EnumConstantDeclaration.getDeclaringType()
com.sun.mirror.declaration.MemberDeclaration.getDeclaringType()


Occurences of getDefault

getDefault occurences:
java.net.CookieHandler.getDefault()
java.net.ProxySelector.getDefault()
java.net.ResponseCache.getDefault()
java.util.Locale.getDefault()
java.util.TimeZone.getDefault()
javax.net.ServerSocketFactory.getDefault()
javax.net.SocketFactory.getDefault()
javax.net.ssl.SSLContext.getDefault()
javax.net.ssl.SSLServerSocketFactory.getDefault()
javax.net.ssl.SSLSocketFactory.getDefault()


Occurences of getDefaultAlgorithm

getDefaultAlgorithm occurences:
javax.net.ssl.KeyManagerFactory.getDefaultAlgorithm()
javax.net.ssl.TrustManagerFactory.getDefaultAlgorithm()


Occurences of getDefaultCipherSuites

getDefaultCipherSuites occurences:
javax.net.ssl.SSLServerSocketFactory.getDefaultCipherSuites()
javax.net.ssl.SSLSocketFactory.getDefaultCipherSuites()


Occurences of getDefaultCloseOperation

getDefaultCloseOperation occurences:
javax.swing.JDialog.getDefaultCloseOperation()
javax.swing.JFrame.getDefaultCloseOperation()
javax.swing.JInternalFrame.getDefaultCloseOperation()


Occurences of getDefaultComponent

getDefaultComponent occurences:
java.awt.ContainerOrderFocusTraversalPolicy.getDefaultComponent(java.awt.Container)
java.awt.FocusTraversalPolicy.getDefaultComponent(java.awt.Container)
javax.swing.SortingFocusTraversalPolicy.getDefaultComponent(java.awt.Container)


Occurences of getDefaultController

getDefaultController occurences:
javax.imageio.IIOParam.getDefaultController()
javax.imageio.metadata.IIOMetadata.getDefaultController()


Occurences of getDefaultCursor

getDefaultCursor occurences:
java.awt.Cursor.getDefaultCursor()
javax.swing.text.html.HTMLEditorKit.getDefaultCursor()


Occurences of getDefaultDomain

getDefaultDomain occurences:
javax.management.MBeanServer.getDefaultDomain()
javax.management.MBeanServerConnection.getDefaultDomain()
javax.management.remote.rmi.RMIConnection.getDefaultDomain(javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.getDefaultDomain(javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.getDefaultDomain(javax.security.auth.Subject)


Occurences of getDefaultEventIndex

getDefaultEventIndex occurences:
java.beans.BeanInfo.getDefaultEventIndex()
java.beans.SimpleBeanInfo.getDefaultEventIndex()


Occurences of getDefaultLocale

getDefaultLocale occurences:
javax.swing.JComponent.getDefaultLocale()
javax.swing.UIDefaults.getDefaultLocale()


Occurences of getDefaultNamespacePrefix

getDefaultNamespacePrefix occurences:
javax.xml.crypto.dom.DOMCryptoContext.getDefaultNamespacePrefix()
javax.xml.crypto.XMLCryptoContext.getDefaultNamespacePrefix()


Occurences of getDefaultPort

getDefaultPort occurences:
java.net.URL.getDefaultPort()
java.net.URLStreamHandler.getDefaultPort()


Occurences of getDefaultPropertyIndex

getDefaultPropertyIndex occurences:
java.beans.BeanInfo.getDefaultPropertyIndex()
java.beans.SimpleBeanInfo.getDefaultPropertyIndex()


Occurences of getDefaultRenderer

getDefaultRenderer occurences:
javax.swing.JTable.getDefaultRenderer(java.lang.Class)
javax.swing.table.JTableHeader.getDefaultRenderer()


Occurences of getDefaultRootElement

getDefaultRootElement occurences:
javax.swing.text.AbstractDocument.getDefaultRootElement()
javax.swing.text.DefaultStyledDocument.getDefaultRootElement()
javax.swing.text.Document.getDefaultRootElement()
javax.swing.text.PlainDocument.getDefaultRootElement()


Occurences of getDefaults

getDefaults occurences:
javax.swing.LookAndFeel.getDefaults()
javax.swing.plaf.basic.BasicLookAndFeel.getDefaults()
javax.swing.plaf.metal.MetalLookAndFeel.getDefaults()
javax.swing.plaf.multi.MultiLookAndFeel.getDefaults()
javax.swing.plaf.synth.SynthLookAndFeel.getDefaults()
javax.swing.UIManager.getDefaults()


Occurences of getDefaultType

getDefaultType occurences:
java.security.cert.CertPathBuilder.getDefaultType()
java.security.cert.CertPathValidator.getDefaultType()
java.security.cert.CertStore.getDefaultType()
java.security.KeyStore.getDefaultType()


Occurences of getDefaultValue

getDefaultValue occurences:
com.sun.mirror.declaration.AnnotationTypeElementDeclaration.getDefaultValue()
com.sun.source.tree.MethodTree.getDefaultValue()
java.lang.reflect.Method.getDefaultValue()
javax.lang.model.element.ExecutableElement.getDefaultValue()
javax.management.openmbean.OpenMBeanAttributeInfoSupport.getDefaultValue()
javax.management.openmbean.OpenMBeanParameterInfo.getDefaultValue()
javax.management.openmbean.OpenMBeanParameterInfoSupport.getDefaultValue()
javax.swing.text.html.CSS.Attribute.getDefaultValue()


Occurences of getDelay

getDelay occurences:
java.util.concurrent.Delayed.getDelay(java.util.concurrent.TimeUnit)
javax.swing.JMenu.getDelay()
javax.swing.Timer.getDelay()


Occurences of getDepth

getDepth occurences:
java.security.cert.PolicyNode.getDepth()
javax.swing.plaf.metal.MetalFileChooserUI.DirectoryComboBoxModel.getDepth(int)
javax.swing.tree.DefaultMutableTreeNode.getDepth()


Occurences of getDerivedGauge

getDerivedGauge occurences:
javax.management.monitor.CounterMonitor.getDerivedGauge()
javax.management.monitor.CounterMonitor.getDerivedGauge(javax.management.ObjectName)
javax.management.monitor.CounterMonitorMBean.getDerivedGauge()
javax.management.monitor.CounterMonitorMBean.getDerivedGauge(javax.management.ObjectName)
javax.management.monitor.GaugeMonitor.getDerivedGauge()
javax.management.monitor.GaugeMonitor.getDerivedGauge(javax.management.ObjectName)
javax.management.monitor.GaugeMonitorMBean.getDerivedGauge()
javax.management.monitor.GaugeMonitorMBean.getDerivedGauge(javax.management.ObjectName)
javax.management.monitor.MonitorNotification.getDerivedGauge()
javax.management.monitor.StringMonitor.getDerivedGauge()
javax.management.monitor.StringMonitor.getDerivedGauge(javax.management.ObjectName)
javax.management.monitor.StringMonitorMBean.getDerivedGauge()
javax.management.monitor.StringMonitorMBean.getDerivedGauge(javax.management.ObjectName)


Occurences of getDerivedGaugeTimeStamp

getDerivedGaugeTimeStamp occurences:
javax.management.monitor.CounterMonitor.getDerivedGaugeTimeStamp()
javax.management.monitor.CounterMonitor.getDerivedGaugeTimeStamp(javax.management.ObjectName)
javax.management.monitor.CounterMonitorMBean.getDerivedGaugeTimeStamp()
javax.management.monitor.CounterMonitorMBean.getDerivedGaugeTimeStamp(javax.management.ObjectName)
javax.management.monitor.GaugeMonitor.getDerivedGaugeTimeStamp()
javax.management.monitor.GaugeMonitor.getDerivedGaugeTimeStamp(javax.management.ObjectName)
javax.management.monitor.GaugeMonitorMBean.getDerivedGaugeTimeStamp()
javax.management.monitor.GaugeMonitorMBean.getDerivedGaugeTimeStamp(javax.management.ObjectName)
javax.management.monitor.StringMonitor.getDerivedGaugeTimeStamp()
javax.management.monitor.StringMonitor.getDerivedGaugeTimeStamp(javax.management.ObjectName)
javax.management.monitor.StringMonitorMBean.getDerivedGaugeTimeStamp()
javax.management.monitor.StringMonitorMBean.getDerivedGaugeTimeStamp(javax.management.ObjectName)


Occurences of getDescent

getDescent occurences:
java.awt.font.GraphicAttribute.getDescent()
java.awt.font.ImageGraphicAttribute.getDescent()
java.awt.font.LineMetrics.getDescent()
java.awt.font.ShapeGraphicAttribute.getDescent()
java.awt.font.TextLayout.getDescent()
java.awt.FontMetrics.getDescent()
javax.swing.text.GlyphView.GlyphPainter.getDescent(javax.swing.text.GlyphView)


Occurences of getDescription

getDescription occurences:
java.util.regex.PatternSyntaxException.getDescription()
javax.imageio.spi.IIOServiceProvider.getDescription(java.util.Locale)
javax.management.MBeanFeatureInfo.getDescription()
javax.management.MBeanInfo.getDescription()
javax.management.modelmbean.ModelMBeanInfo.getDescription()
javax.management.openmbean.CompositeType.getDescription(java.lang.String)
javax.management.openmbean.OpenMBeanConstructorInfo.getDescription()
javax.management.openmbean.OpenMBeanInfo.getDescription()
javax.management.openmbean.OpenMBeanOperationInfo.getDescription()
javax.management.openmbean.OpenMBeanParameterInfo.getDescription()
javax.management.openmbean.OpenType.getDescription()
javax.management.relation.RoleInfo.getDescription()
javax.management.StandardMBean.getDescription(javax.management.MBeanAttributeInfo)
javax.management.StandardMBean.getDescription(javax.management.MBeanConstructorInfo)
javax.management.StandardMBean.getDescription(javax.management.MBeanConstructorInfo, javax.management.MBeanParameterInfo, int)
javax.management.StandardMBean.getDescription(javax.management.MBeanFeatureInfo)
javax.management.StandardMBean.getDescription(javax.management.MBeanInfo)
javax.management.StandardMBean.getDescription(javax.management.MBeanOperationInfo)
javax.management.StandardMBean.getDescription(javax.management.MBeanOperationInfo, javax.management.MBeanParameterInfo, int)
javax.sound.midi.MidiDevice.Info.getDescription()
javax.sound.midi.Soundbank.getDescription()
javax.sound.sampled.Mixer.Info.getDescription()
javax.swing.event.HyperlinkEvent.getDescription()
javax.swing.filechooser.FileFilter.getDescription()
javax.swing.filechooser.FileNameExtensionFilter.getDescription()
javax.swing.filechooser.FileView.getDescription(java.io.File)
javax.swing.ImageIcon.getDescription()
javax.swing.JFileChooser.getDescription(java.io.File)
javax.swing.LookAndFeel.getDescription()
javax.swing.plaf.basic.BasicFileChooserUI.AcceptAllFileFilter.getDescription()
javax.swing.plaf.basic.BasicFileChooserUI.BasicFileView.getDescription(java.io.File)
javax.swing.plaf.metal.MetalLookAndFeel.getDescription()
javax.swing.plaf.multi.MultiLookAndFeel.getDescription()
javax.swing.plaf.synth.SynthLookAndFeel.getDescription()


Occurences of getDescriptor

getDescriptor occurences:
javax.management.DescriptorRead.getDescriptor()
javax.management.MBeanFeatureInfo.getDescriptor()
javax.management.MBeanInfo.getDescriptor()
javax.management.modelmbean.ModelMBeanAttributeInfo.getDescriptor()
javax.management.modelmbean.ModelMBeanConstructorInfo.getDescriptor()
javax.management.modelmbean.ModelMBeanInfo.getDescriptor(java.lang.String, java.lang.String)
javax.management.modelmbean.ModelMBeanInfoSupport.getDescriptor()
javax.management.modelmbean.ModelMBeanInfoSupport.getDescriptor(java.lang.String)
javax.management.modelmbean.ModelMBeanInfoSupport.getDescriptor(java.lang.String, java.lang.String)
javax.management.modelmbean.ModelMBeanNotificationInfo.getDescriptor()
javax.management.modelmbean.ModelMBeanOperationInfo.getDescriptor()


Occurences of getDescriptors

getDescriptors occurences:
javax.management.modelmbean.ModelMBeanInfo.getDescriptors(java.lang.String)
javax.management.modelmbean.ModelMBeanInfoSupport.getDescriptors(java.lang.String)


Occurences of getDesktopColor

getDesktopColor occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getDesktopColor()
javax.swing.plaf.metal.MetalTheme.getDesktopColor()
javax.swing.plaf.metal.OceanTheme.getDesktopColor()


Occurences of getDesktopManager

getDesktopManager occurences:
javax.swing.JDesktopPane.getDesktopManager()
javax.swing.plaf.basic.BasicInternalFrameUI.getDesktopManager()


Occurences of getDesktopPane

getDesktopPane occurences:
javax.swing.JInternalFrame.getDesktopPane()
javax.swing.JInternalFrame.JDesktopIcon.getDesktopPane()


Occurences of getDestination

getDestination occurences:
java.awt.JobAttributes.getDestination()
javax.imageio.ImageReader.getDestination(javax.imageio.ImageReadParam, java.util.Iterator, int, int)
javax.imageio.ImageReadParam.getDestination()


Occurences of getDetail

getDetail occurences:
com.sun.source.tree.AssertTree.getDetail()
javax.xml.soap.SOAPFault.getDetail()
org.w3c.dom.events.UIEvent.getDetail()


Occurences of getDevice

getDevice occurences:
java.awt.GraphicsConfiguration.getDevice()
java.awt.PointerInfo.getDevice()
javax.sound.midi.spi.MidiDeviceProvider.getDevice(javax.sound.midi.MidiDevice.Info)


Occurences of getDeviceInfo

getDeviceInfo occurences:
javax.sound.midi.MidiDevice.getDeviceInfo()
javax.sound.midi.spi.MidiDeviceProvider.getDeviceInfo()


Occurences of getDialogTitle

getDialogTitle occurences:
javax.swing.JFileChooser.getDialogTitle()
javax.swing.plaf.basic.BasicFileChooserUI.getDialogTitle(javax.swing.JFileChooser)
javax.swing.plaf.FileChooserUI.getDialogTitle(javax.swing.JFileChooser)
javax.swing.plaf.multi.MultiFileChooserUI.getDialogTitle(javax.swing.JFileChooser)


Occurences of getDifferenceMode

getDifferenceMode occurences:
javax.management.monitor.CounterMonitor.getDifferenceMode()
javax.management.monitor.CounterMonitorMBean.getDifferenceMode()
javax.management.monitor.GaugeMonitor.getDifferenceMode()
javax.management.monitor.GaugeMonitorMBean.getDifferenceMode()


Occurences of getDigestAlgorithm

getDigestAlgorithm occurences:
java.security.spec.MGF1ParameterSpec.getDigestAlgorithm()
java.security.spec.PSSParameterSpec.getDigestAlgorithm()
javax.crypto.spec.OAEPParameterSpec.getDigestAlgorithm()


Occurences of getDimension

getDimension occurences:
javax.management.openmbean.ArrayType.getDimension()
javax.swing.UIDefaults.getDimension(java.lang.Object)
javax.swing.UIDefaults.getDimension(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getDimension(java.lang.Object)
javax.swing.UIManager.getDimension(java.lang.Object, java.util.Locale)


Occurences of getDirection

getDirection occurences:
javax.swing.plaf.basic.BasicArrowButton.getDirection()
javax.swing.text.DefaultStyledDocument.ElementSpec.getDirection()


Occurences of getDirectionality

getDirectionality occurences:
java.lang.Character.getDirectionality(char)
java.lang.Character.getDirectionality(int)


Occurences of getDirectory

getDirectory occurences:
java.awt.FileDialog.getDirectory()
javax.swing.plaf.basic.BasicFileChooserUI.getDirectory()


Occurences of getDirectoryName

getDirectoryName occurences:
javax.swing.plaf.basic.BasicFileChooserUI.getDirectoryName()
javax.swing.plaf.metal.MetalFileChooserUI.getDirectoryName()


Occurences of getDisabledIcon

getDisabledIcon occurences:
javax.swing.AbstractButton.getDisabledIcon()
javax.swing.JLabel.getDisabledIcon()
javax.swing.LookAndFeel.getDisabledIcon(javax.swing.JComponent, javax.swing.Icon)
javax.swing.plaf.metal.MetalLookAndFeel.getDisabledIcon(javax.swing.JComponent, javax.swing.Icon)


Occurences of getDisabledSelectedIcon

getDisabledSelectedIcon occurences:
javax.swing.AbstractButton.getDisabledSelectedIcon()
javax.swing.LookAndFeel.getDisabledSelectedIcon(javax.swing.JComponent, javax.swing.Icon)
javax.swing.plaf.metal.MetalLookAndFeel.getDisabledSelectedIcon(javax.swing.JComponent, javax.swing.Icon)


Occurences of getDisabledTextColor

getDisabledTextColor occurences:
javax.swing.plaf.metal.MetalButtonUI.getDisabledTextColor()
javax.swing.plaf.metal.MetalRadioButtonUI.getDisabledTextColor()
javax.swing.plaf.metal.MetalToggleButtonUI.getDisabledTextColor()
javax.swing.text.JTextComponent.getDisabledTextColor()


Occurences of getDisplayCountry

getDisplayCountry occurences:
java.util.Locale.getDisplayCountry()
java.util.Locale.getDisplayCountry(java.util.Locale)
java.util.spi.LocaleNameProvider.getDisplayCountry(java.lang.String, java.util.Locale)


Occurences of getDisplayedMnemonicIndex

getDisplayedMnemonicIndex occurences:
javax.swing.AbstractButton.getDisplayedMnemonicIndex()
javax.swing.colorchooser.AbstractColorChooserPanel.getDisplayedMnemonicIndex()
javax.swing.JLabel.getDisplayedMnemonicIndex()


Occurences of getDisplayLanguage

getDisplayLanguage occurences:
java.util.Locale.getDisplayLanguage()
java.util.Locale.getDisplayLanguage(java.util.Locale)
java.util.spi.LocaleNameProvider.getDisplayLanguage(java.lang.String, java.util.Locale)


Occurences of getDisplayName

getDisplayName occurences:
java.beans.FeatureDescriptor.getDisplayName()
java.net.NetworkInterface.getDisplayName()
java.util.Calendar.getDisplayName(int, int, java.util.Locale)
java.util.Locale.getDisplayName()
java.util.Locale.getDisplayName(java.util.Locale)
java.util.spi.TimeZoneNameProvider.getDisplayName(java.lang.String, boolean, int, java.util.Locale)
java.util.TimeZone.getDisplayName()
java.util.TimeZone.getDisplayName(boolean, int)
java.util.TimeZone.getDisplayName(boolean, int, java.util.Locale)
java.util.TimeZone.getDisplayName(java.util.Locale)
javax.swing.colorchooser.AbstractColorChooserPanel.getDisplayName()


Occurences of getDisplayText

getDisplayText occurences:
Class ActiveClient.ActiveClient.getDisplayText()
Class LWTextComponent.LWTextComponent.getDisplayText()


Occurences of getDisplayVariant

getDisplayVariant occurences:
java.util.Locale.getDisplayVariant()
java.util.Locale.getDisplayVariant(java.util.Locale)
java.util.spi.LocaleNameProvider.getDisplayVariant(java.lang.String, java.util.Locale)


Occurences of getDividerLocation

getDividerLocation occurences:
javax.swing.JSplitPane.getDividerLocation()
javax.swing.plaf.basic.BasicSplitPaneUI.getDividerLocation(javax.swing.JSplitPane)
javax.swing.plaf.multi.MultiSplitPaneUI.getDividerLocation(javax.swing.JSplitPane)
javax.swing.plaf.SplitPaneUI.getDividerLocation(javax.swing.JSplitPane)


Occurences of getDividerSize

getDividerSize occurences:
javax.swing.JSplitPane.getDividerSize()
javax.swing.plaf.basic.BasicSplitPaneDivider.getDividerSize()


Occurences of getDivisionType

getDivisionType occurences:
javax.sound.midi.MidiFileFormat.getDivisionType()
javax.sound.midi.Sequence.getDivisionType()


Occurences of getDocComment

getDocComment occurences:
com.sun.mirror.declaration.Declaration.getDocComment()
javax.lang.model.util.Elements.getDocComment(javax.lang.model.element.Element)


Occurences of getDocFlavor

getDocFlavor occurences:
javax.print.Doc.getDocFlavor()
javax.print.SimpleDoc.getDocFlavor()


Occurences of getDocument

getDocument occurences:
javax.swing.event.DocumentEvent.getDocument()
javax.swing.text.AbstractDocument.AbstractElement.getDocument()
javax.swing.text.AbstractDocument.DefaultDocumentEvent.getDocument()
javax.swing.text.AbstractWriter.getDocument()
javax.swing.text.DocumentFilter.FilterBypass.getDocument()
javax.swing.text.Element.getDocument()
javax.swing.text.JTextComponent.getDocument()
javax.swing.text.View.getDocument()


Occurences of getDocumentBase

getDocumentBase occurences:
java.applet.Applet.getDocumentBase()
java.applet.AppletStub.getDocumentBase()
javax.management.loading.MLetContent.getDocumentBase()


Occurences of getDocumentFilter

getDocumentFilter occurences:
javax.swing.JFormattedTextField.AbstractFormatter.getDocumentFilter()
javax.swing.text.AbstractDocument.getDocumentFilter()
javax.swing.text.DefaultFormatter.getDocumentFilter()


Occurences of getDomain

getDomain occurences:
java.net.HttpCookie.getDomain()
javax.management.ObjectName.getDomain()


Occurences of getDomains

getDomains occurences:
javax.management.MBeanServer.getDomains()
javax.management.MBeanServerConnection.getDomains()
javax.management.remote.rmi.RMIConnection.getDomains(javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.getDomains(javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.getDomains(javax.security.auth.Subject)


Occurences of getDomConfig

getDomConfig occurences:
org.w3c.dom.Document.getDomConfig()
org.w3c.dom.ls.LSParser.getDomConfig()
org.w3c.dom.ls.LSSerializer.getDomConfig()


Occurences of getDOMImplementation

getDOMImplementation occurences:
javax.xml.parsers.DocumentBuilder.getDOMImplementation()
org.w3c.dom.bootstrap.DOMImplementationRegistry.getDOMImplementation(java.lang.String)
org.w3c.dom.DOMImplementationSource.getDOMImplementation(java.lang.String)


Occurences of getDOMImplementationList

getDOMImplementationList occurences:
org.w3c.dom.bootstrap.DOMImplementationRegistry.getDOMImplementationList(java.lang.String)
org.w3c.dom.DOMImplementationSource.getDOMImplementationList(java.lang.String)


Occurences of getDot

getDot occurences:
javax.swing.event.CaretEvent.getDot()
javax.swing.text.Caret.getDot()
javax.swing.text.DefaultCaret.getDot()


Occurences of getDouble

getDouble occurences:
java.lang.reflect.Array.getDouble(java.lang.Object, int)
java.lang.reflect.Field.getDouble(java.lang.Object)
java.nio.ByteBuffer.getDouble()
java.nio.ByteBuffer.getDouble(int)
java.sql.CallableStatement.getDouble(int)
java.sql.CallableStatement.getDouble(java.lang.String)
java.sql.ResultSet.getDouble(int)
java.sql.ResultSet.getDouble(java.lang.String)
java.util.prefs.AbstractPreferences.getDouble(java.lang.String, double)
java.util.prefs.Preferences.getDouble(java.lang.String, double)


Occurences of getDragEnabled

getDragEnabled occurences:
javax.swing.JColorChooser.getDragEnabled()
javax.swing.JFileChooser.getDragEnabled()
javax.swing.JList.getDragEnabled()
javax.swing.JTable.getDragEnabled()
javax.swing.JTree.getDragEnabled()
javax.swing.text.JTextComponent.getDragEnabled()


Occurences of getDragSource

getDragSource occurences:
java.awt.dnd.DragGestureEvent.getDragSource()
java.awt.dnd.DragGestureRecognizer.getDragSource()
java.awt.dnd.DragSourceContext.getDragSource()


Occurences of getDrawGraphics

getDrawGraphics occurences:
java.awt.Component.BltBufferStrategy.getDrawGraphics()
java.awt.Component.FlipBufferStrategy.getDrawGraphics()
java.awt.image.BufferStrategy.getDrawGraphics()


Occurences of getDropAction

getDropAction occurences:
java.awt.dnd.DragSourceDragEvent.getDropAction()
java.awt.dnd.DragSourceDropEvent.getDropAction()
java.awt.dnd.DropTargetDragEvent.getDropAction()
java.awt.dnd.DropTargetDropEvent.getDropAction()
javax.swing.TransferHandler.TransferSupport.getDropAction()


Occurences of getDropLocation

getDropLocation occurences:
javax.swing.JList.getDropLocation()
javax.swing.JTable.getDropLocation()
javax.swing.JTree.getDropLocation()
javax.swing.text.JTextComponent.getDropLocation()
javax.swing.TransferHandler.TransferSupport.getDropLocation()


Occurences of getDropMode

getDropMode occurences:
javax.swing.JList.getDropMode()
javax.swing.JTable.getDropMode()
javax.swing.JTree.getDropMode()
javax.swing.text.JTextComponent.getDropMode()


Occurences of getDropTarget

getDropTarget occurences:
java.awt.Component.getDropTarget()
java.awt.dnd.DropTargetContext.getDropTarget()


Occurences of getDropTargetContext

getDropTargetContext occurences:
java.awt.dnd.DropTarget.getDropTargetContext()
java.awt.dnd.DropTargetEvent.getDropTargetContext()


Occurences of getDSTSavings

getDSTSavings occurences:
java.util.SimpleTimeZone.getDSTSavings()
java.util.TimeZone.getDSTSavings()


Occurences of getDTDHandler

getDTDHandler occurences:
org.xml.sax.helpers.ParserAdapter.getDTDHandler()
org.xml.sax.helpers.XMLFilterImpl.getDTDHandler()
org.xml.sax.XMLReader.getDTDHandler()


Occurences of getEchoChar

getEchoChar occurences:
java.awt.TextField.getEchoChar()
javax.swing.JPasswordField.getEchoChar()


Occurences of getEditingPath

getEditingPath occurences:
javax.swing.JTree.getEditingPath()
javax.swing.plaf.basic.BasicTreeUI.getEditingPath(javax.swing.JTree)
javax.swing.plaf.multi.MultiTreeUI.getEditingPath(javax.swing.JTree)
javax.swing.plaf.TreeUI.getEditingPath(javax.swing.JTree)


Occurences of getEditor

getEditor occurences:
javax.swing.JComboBox.getEditor()
javax.swing.JSpinner.getEditor()
javax.swing.text.StyledEditorKit.StyledTextAction.getEditor(java.awt.event.ActionEvent)


Occurences of getEditorComponent

getEditorComponent occurences:
javax.swing.ComboBoxEditor.getEditorComponent()
javax.swing.JTable.getEditorComponent()
javax.swing.plaf.basic.BasicComboBoxEditor.getEditorComponent()


Occurences of getEditorKit

getEditorKit occurences:
javax.swing.JEditorPane.getEditorKit()
javax.swing.plaf.basic.BasicEditorPaneUI.getEditorKit(javax.swing.text.JTextComponent)
javax.swing.plaf.basic.BasicTextUI.getEditorKit(javax.swing.text.JTextComponent)
javax.swing.plaf.multi.MultiTextUI.getEditorKit(javax.swing.text.JTextComponent)
javax.swing.plaf.TextUI.getEditorKit(javax.swing.text.JTextComponent)


Occurences of getElem

getElem occurences:
java.awt.image.DataBuffer.getElem(int)
java.awt.image.DataBuffer.getElem(int, int)
java.awt.image.DataBufferByte.getElem(int)
java.awt.image.DataBufferByte.getElem(int, int)
java.awt.image.DataBufferDouble.getElem(int)
java.awt.image.DataBufferDouble.getElem(int, int)
java.awt.image.DataBufferFloat.getElem(int)
java.awt.image.DataBufferFloat.getElem(int, int)
java.awt.image.DataBufferInt.getElem(int)
java.awt.image.DataBufferInt.getElem(int, int)
java.awt.image.DataBufferShort.getElem(int)
java.awt.image.DataBufferShort.getElem(int, int)
java.awt.image.DataBufferUShort.getElem(int)
java.awt.image.DataBufferUShort.getElem(int, int)


Occurences of getElemDouble

getElemDouble occurences:
java.awt.image.DataBuffer.getElemDouble(int)
java.awt.image.DataBuffer.getElemDouble(int, int)
java.awt.image.DataBufferDouble.getElemDouble(int)
java.awt.image.DataBufferDouble.getElemDouble(int, int)
java.awt.image.DataBufferFloat.getElemDouble(int)
java.awt.image.DataBufferFloat.getElemDouble(int, int)


Occurences of getElement

getElement occurences:
com.sun.source.util.Trees.getElement(com.sun.source.util.TreePath)
javax.swing.event.DocumentEvent.ElementChange.getElement()
javax.swing.text.AbstractDocument.AbstractElement.getElement(int)
javax.swing.text.AbstractDocument.BranchElement.getElement(int)
javax.swing.text.AbstractDocument.ElementEdit.getElement()
javax.swing.text.AbstractDocument.LeafElement.getElement(int)
javax.swing.text.Element.getElement(int)
javax.swing.text.html.HTMLDocument.getElement(java.lang.String)
javax.swing.text.html.HTMLDocument.getElement(javax.swing.text.Element, java.lang.Object, java.lang.Object)
javax.swing.text.html.parser.DTD.getElement(int)
javax.swing.text.html.parser.DTD.getElement(java.lang.String)
javax.swing.text.html.parser.TagElement.getElement()
javax.swing.text.View.getElement()
javax.xml.bind.annotation.DomHandler.getElement(javax.xml.transform.Result)
javax.xml.bind.annotation.DomHandler.getElement(ResultT)
javax.xml.bind.annotation.W3CDomHandler.getElement(javax.xml.transform.dom.DOMResult)


Occurences of getElementAt

getElementAt occurences:
javax.swing.DefaultComboBoxModel.getElementAt(int)
javax.swing.DefaultListModel.getElementAt(int)
javax.swing.ListModel.getElementAt(int)
javax.swing.plaf.basic.BasicDirectoryModel.getElementAt(int)
javax.swing.plaf.metal.MetalFileChooserUI.DirectoryComboBoxModel.getElementAt(int)
javax.swing.plaf.metal.MetalFileChooserUI.FilterComboBoxModel.getElementAt(int)


Occurences of getElementById

getElementById occurences:
javax.xml.crypto.dom.DOMCryptoContext.getElementById(java.lang.String)
org.w3c.dom.Document.getElementById(java.lang.String)


Occurences of getElementCount

getElementCount occurences:
javax.swing.text.AbstractDocument.AbstractElement.getElementCount()
javax.swing.text.AbstractDocument.BranchElement.getElementCount()
javax.swing.text.AbstractDocument.LeafElement.getElementCount()
javax.swing.text.Element.getElementCount()


Occurences of getElementDescription

getElementDescription occurences:
javax.imageio.metadata.IIOMetadataFormat.getElementDescription(java.lang.String, java.util.Locale)
javax.imageio.metadata.IIOMetadataFormatImpl.getElementDescription(java.lang.String, java.util.Locale)


Occurences of getElementIndex

getElementIndex occurences:
javax.swing.text.AbstractDocument.AbstractElement.getElementIndex(int)
javax.swing.text.AbstractDocument.BranchElement.getElementIndex(int)
javax.swing.text.AbstractDocument.LeafElement.getElementIndex(int)
javax.swing.text.Element.getElementIndex(int)


Occurences of getElementMaxChildren

getElementMaxChildren occurences:
javax.imageio.metadata.IIOMetadataFormat.getElementMaxChildren(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getElementMaxChildren(java.lang.String)


Occurences of getElementMinChildren

getElementMinChildren occurences:
javax.imageio.metadata.IIOMetadataFormat.getElementMinChildren(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getElementMinChildren(java.lang.String)


Occurences of getElementName

getElementName occurences:
javax.xml.bind.JAXBIntrospector.getElementName(java.lang.Object)
javax.xml.soap.SOAPElement.getElementName()


Occurences of getElements

getElements occurences:
com.sun.source.util.JavacTask.getElements()
javax.swing.ButtonGroup.getElements()
javax.swing.text.html.parser.ContentModel.getElements(java.util.Vector)


Occurences of getElementsAnnotatedWith

getElementsAnnotatedWith occurences:
javax.annotation.processing.RoundEnvironment.getElementsAnnotatedWith(java.lang.Class)
javax.annotation.processing.RoundEnvironment.getElementsAnnotatedWith(javax.lang.model.element.TypeElement)


Occurences of getElementsByTagName

getElementsByTagName occurences:
javax.imageio.metadata.IIOMetadataNode.getElementsByTagName(java.lang.String)
org.w3c.dom.Document.getElementsByTagName(java.lang.String)
org.w3c.dom.Element.getElementsByTagName(java.lang.String)


Occurences of getElementsByTagNameNS

getElementsByTagNameNS occurences:
javax.imageio.metadata.IIOMetadataNode.getElementsByTagNameNS(java.lang.String, java.lang.String)
org.w3c.dom.Document.getElementsByTagNameNS(java.lang.String, java.lang.String)
org.w3c.dom.Element.getElementsByTagNameNS(java.lang.String, java.lang.String)


Occurences of getElementText

getElementText occurences:
javax.xml.stream.util.EventReaderDelegate.getElementText()
javax.xml.stream.util.StreamReaderDelegate.getElementText()
javax.xml.stream.XMLEventReader.getElementText()
javax.xml.stream.XMLStreamReader.getElementText()


Occurences of getElementValues

getElementValues occurences:
com.sun.mirror.declaration.AnnotationMirror.getElementValues()
javax.lang.model.element.AnnotationMirror.getElementValues()


Occurences of getElemFloat

getElemFloat occurences:
java.awt.image.DataBuffer.getElemFloat(int)
java.awt.image.DataBuffer.getElemFloat(int, int)
java.awt.image.DataBufferDouble.getElemFloat(int)
java.awt.image.DataBufferDouble.getElemFloat(int, int)
java.awt.image.DataBufferFloat.getElemFloat(int)
java.awt.image.DataBufferFloat.getElemFloat(int, int)


Occurences of getEmptySet

getEmptySet occurences:
javax.swing.text.AbstractDocument.AttributeContext.getEmptySet()
javax.swing.text.StyleContext.getEmptySet()


Occurences of getEnabledCipherSuites

getEnabledCipherSuites occurences:
javax.net.ssl.SSLEngine.getEnabledCipherSuites()
javax.net.ssl.SSLServerSocket.getEnabledCipherSuites()
javax.net.ssl.SSLSocket.getEnabledCipherSuites()
javax.rmi.ssl.SslRMIServerSocketFactory.getEnabledCipherSuites()


Occurences of getEnabledProtocols

getEnabledProtocols occurences:
javax.net.ssl.SSLEngine.getEnabledProtocols()
javax.net.ssl.SSLServerSocket.getEnabledProtocols()
javax.net.ssl.SSLSocket.getEnabledProtocols()
javax.rmi.ssl.SslRMIServerSocketFactory.getEnabledProtocols()


Occurences of getEnableSessionCreation

getEnableSessionCreation occurences:
javax.net.ssl.SSLEngine.getEnableSessionCreation()
javax.net.ssl.SSLServerSocket.getEnableSessionCreation()
javax.net.ssl.SSLSocket.getEnableSessionCreation()


Occurences of getEnclosingClass

getEnclosingClass occurences:
com.sun.source.tree.Scope.getEnclosingClass()
java.lang.Class.getEnclosingClass()


Occurences of getEnclosingMethod

getEnclosingMethod occurences:
com.sun.source.tree.Scope.getEnclosingMethod()
java.lang.Class.getEnclosingMethod()


Occurences of getEncoded

getEncoded occurences:
java.security.AlgorithmParameters.getEncoded()
java.security.AlgorithmParameters.getEncoded(java.lang.String)
java.security.cert.Certificate.getEncoded()
java.security.cert.CertPath.getEncoded()
java.security.cert.CertPath.getEncoded(java.lang.String)
java.security.cert.PolicyQualifierInfo.getEncoded()
java.security.cert.X509CRL.getEncoded()
java.security.cert.X509CRLEntry.getEncoded()
java.security.Key.getEncoded()
java.security.spec.EncodedKeySpec.getEncoded()
java.security.spec.PKCS8EncodedKeySpec.getEncoded()
java.security.spec.X509EncodedKeySpec.getEncoded()
javax.crypto.EncryptedPrivateKeyInfo.getEncoded()
javax.crypto.spec.SecretKeySpec.getEncoded()
javax.security.auth.kerberos.KerberosKey.getEncoded()
javax.security.auth.kerberos.KerberosTicket.getEncoded()
javax.security.auth.x500.X500Principal.getEncoded()
javax.security.cert.Certificate.getEncoded()


Occurences of getEncodedValue

getEncodedValue occurences:
javax.naming.ldap.BasicControl.getEncodedValue()
javax.naming.ldap.Control.getEncodedValue()
javax.naming.ldap.ExtendedRequest.getEncodedValue()
javax.naming.ldap.ExtendedResponse.getEncodedValue()
javax.naming.ldap.StartTlsRequest.getEncodedValue()
javax.naming.ldap.StartTlsResponse.getEncodedValue()


Occurences of getEncoding

getEncoding occurences:
java.io.InputStreamReader.getEncoding()
java.io.OutputStreamWriter.getEncoding()
java.util.logging.Handler.getEncoding()
javax.sound.sampled.AudioFormat.getEncoding()
javax.xml.bind.helpers.AbstractMarshallerImpl.getEncoding()
javax.xml.crypto.dsig.XMLObject.getEncoding()
javax.xml.stream.util.StreamReaderDelegate.getEncoding()
javax.xml.stream.XMLStreamReader.getEncoding()
org.w3c.dom.ls.LSInput.getEncoding()
org.w3c.dom.ls.LSOutput.getEncoding()
org.xml.sax.ext.Locator2.getEncoding()
org.xml.sax.ext.Locator2Impl.getEncoding()
org.xml.sax.InputSource.getEncoding()


Occurences of getEndIndex

getEndIndex occurences:
java.text.CharacterIterator.getEndIndex()
java.text.FieldPosition.getEndIndex()
java.text.StringCharacterIterator.getEndIndex()
javax.accessibility.AccessibleHyperlink.getEndIndex()
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.HTMLLink.getEndIndex()
javax.swing.text.Segment.getEndIndex()


Occurences of getEndOffset

getEndOffset occurences:
javax.swing.text.AbstractDocument.AbstractElement.getEndOffset()
javax.swing.text.AbstractDocument.BranchElement.getEndOffset()
javax.swing.text.AbstractDocument.LeafElement.getEndOffset()
javax.swing.text.AbstractWriter.getEndOffset()
javax.swing.text.Element.getEndOffset()
javax.swing.text.GlyphView.getEndOffset()
javax.swing.text.Highlighter.Highlight.getEndOffset()
javax.swing.text.html.HTMLDocument.Iterator.getEndOffset()
javax.swing.text.View.getEndOffset()


Occurences of getEndPoint

getEndPoint occurences:
java.awt.geom.Arc2D.getEndPoint()
java.awt.LinearGradientPaint.getEndPoint()


Occurences of getEndPosition

getEndPosition occurences:
com.sun.source.util.SourcePositions.getEndPosition(com.sun.source.tree.CompilationUnitTree, com.sun.source.tree.Tree)
javax.swing.text.AbstractDocument.getEndPosition()
javax.swing.text.Document.getEndPosition()
javax.tools.Diagnostic.getEndPosition()


Occurences of getEntities

getEntities occurences:
javax.xml.stream.events.DTD.getEntities()
org.w3c.dom.DocumentType.getEntities()


Occurences of getEntity

getEntity occurences:
javax.swing.text.html.parser.DTD.getEntity(int)
javax.swing.text.html.parser.DTD.getEntity(java.lang.String)


Occurences of getEntityResolver

getEntityResolver occurences:
org.xml.sax.helpers.ParserAdapter.getEntityResolver()
org.xml.sax.helpers.XMLFilterImpl.getEntityResolver()
org.xml.sax.XMLReader.getEntityResolver()


Occurences of getEntry

getEntry occurences:
java.security.KeyStore.getEntry(java.lang.String, java.security.KeyStore.ProtectionParameter)
java.util.jar.JarFile.getEntry(java.lang.String)
java.util.zip.ZipFile.getEntry(java.lang.String)


Occurences of getEnumConstants

getEnumConstants occurences:
com.sun.mirror.declaration.EnumDeclaration.getEnumConstants()
java.lang.Class.getEnumConstants()


Occurences of getEnumValueTable

getEnumValueTable occurences:
javax.print.attribute.EnumSyntax.getEnumValueTable()
javax.print.attribute.standard.Chromaticity.getEnumValueTable()
javax.print.attribute.standard.ColorSupported.getEnumValueTable()
javax.print.attribute.standard.Compression.getEnumValueTable()
javax.print.attribute.standard.Fidelity.getEnumValueTable()
javax.print.attribute.standard.Finishings.getEnumValueTable()
javax.print.attribute.standard.JobSheets.getEnumValueTable()
javax.print.attribute.standard.JobState.getEnumValueTable()
javax.print.attribute.standard.JobStateReason.getEnumValueTable()
javax.print.attribute.standard.MediaName.getEnumValueTable()
javax.print.attribute.standard.MediaSizeName.getEnumValueTable()
javax.print.attribute.standard.MediaTray.getEnumValueTable()
javax.print.attribute.standard.MultipleDocumentHandling.getEnumValueTable()
javax.print.attribute.standard.OrientationRequested.getEnumValueTable()
javax.print.attribute.standard.PDLOverrideSupported.getEnumValueTable()
javax.print.attribute.standard.PresentationDirection.getEnumValueTable()
javax.print.attribute.standard.PrinterIsAcceptingJobs.getEnumValueTable()
javax.print.attribute.standard.PrinterState.getEnumValueTable()
javax.print.attribute.standard.PrinterStateReason.getEnumValueTable()
javax.print.attribute.standard.PrintQuality.getEnumValueTable()
javax.print.attribute.standard.ReferenceUriSchemesSupported.getEnumValueTable()
javax.print.attribute.standard.Severity.getEnumValueTable()
javax.print.attribute.standard.SheetCollate.getEnumValueTable()
javax.print.attribute.standard.Sides.getEnumValueTable()


Occurences of getenv

getenv occurences:
java.lang.System.getenv()
java.lang.System.getenv(java.lang.String)


Occurences of getEnvironment

getEnvironment occurences:
javax.naming.CannotProceedException.getEnvironment()
javax.naming.Context.getEnvironment()
javax.naming.InitialContext.getEnvironment()


Occurences of getErrorCode

getErrorCode occurences:
java.sql.SQLException.getErrorCode()
javax.xml.bind.JAXBException.getErrorCode()
javax.xml.bind.TypeConstraintException.getErrorCode()


Occurences of getErrorHandler

getErrorHandler occurences:
javax.xml.validation.SchemaFactory.getErrorHandler()
javax.xml.validation.Validator.getErrorHandler()
javax.xml.validation.ValidatorHandler.getErrorHandler()
org.xml.sax.helpers.ParserAdapter.getErrorHandler()
org.xml.sax.helpers.XMLFilterImpl.getErrorHandler()
org.xml.sax.XMLReader.getErrorHandler()


Occurences of getErrorListener

getErrorListener occurences:
javax.xml.transform.Transformer.getErrorListener()
javax.xml.transform.TransformerFactory.getErrorListener()


Occurences of getErrorStream

getErrorStream occurences:
java.lang.Process.getErrorStream()
java.net.HttpURLConnection.getErrorStream()


Occurences of getErrorWriter

getErrorWriter occurences:
javax.script.ScriptContext.getErrorWriter()
javax.script.SimpleScriptContext.getErrorWriter()


Occurences of getEscapeProcessing

getEscapeProcessing occurences:
javax.sql.RowSet.getEscapeProcessing()
javax.sql.rowset.BaseRowSet.getEscapeProcessing()


Occurences of getEventContext

getEventContext occurences:
javax.naming.event.NamingEvent.getEventContext()
javax.naming.event.NamingExceptionEvent.getEventContext()


Occurences of getEventHandler

getEventHandler occurences:
javax.xml.bind.Binder.getEventHandler()
javax.xml.bind.helpers.AbstractMarshallerImpl.getEventHandler()
javax.xml.bind.helpers.AbstractUnmarshallerImpl.getEventHandler()
javax.xml.bind.Marshaller.getEventHandler()
javax.xml.bind.Unmarshaller.getEventHandler()
javax.xml.bind.Validator.getEventHandler()


Occurences of getEventSetDescriptors

getEventSetDescriptors occurences:
java.beans.BeanInfo.getEventSetDescriptors()
java.beans.SimpleBeanInfo.getEventSetDescriptors()


Occurences of getEventType

getEventType occurences:
javax.swing.event.HyperlinkEvent.getEventType()
javax.xml.stream.events.XMLEvent.getEventType()
javax.xml.stream.util.StreamReaderDelegate.getEventType()
javax.xml.stream.XMLStreamReader.getEventType()


Occurences of getException

getException occurences:
java.awt.event.InvocationEvent.getException()
java.lang.ClassNotFoundException.getException()
java.lang.ExceptionInInitializerError.getException()
java.security.PrivilegedActionException.getException()
javax.naming.event.NamingExceptionEvent.getException()
javax.naming.ldap.SortResponseControl.getException()
javax.naming.ldap.UnsolicitedNotification.getException()
javax.xml.parsers.FactoryConfigurationError.getException()
javax.xml.stream.FactoryConfigurationError.getException()
javax.xml.transform.TransformerException.getException()
javax.xml.transform.TransformerFactoryConfigurationError.getException()
org.xml.sax.SAXException.getException()


Occurences of getExceptionListener

getExceptionListener occurences:
java.beans.Encoder.getExceptionListener()
java.beans.XMLDecoder.getExceptionListener()


Occurences of getExceptionTypes

getExceptionTypes occurences:
java.lang.reflect.Constructor.getExceptionTypes()
java.lang.reflect.Method.getExceptionTypes()


Occurences of getExclusiveQueuedThreads

getExclusiveQueuedThreads occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.getExclusiveQueuedThreads()
java.util.concurrent.locks.AbstractQueuedSynchronizer.getExclusiveQueuedThreads()


Occurences of getExecutor

getExecutor occurences:
javax.xml.ws.Endpoint.getExecutor()
javax.xml.ws.Service.getExecutor()
javax.xml.ws.spi.ServiceDelegate.getExecutor()


Occurences of getExpandedState

getExpandedState occurences:
javax.swing.tree.AbstractLayoutCache.getExpandedState(javax.swing.tree.TreePath)
javax.swing.tree.FixedHeightLayoutCache.getExpandedState(javax.swing.tree.TreePath)
javax.swing.tree.VariableHeightLayoutCache.getExpandedState(javax.swing.tree.TreePath)


Occurences of getExponent

getExponent occurences:
java.lang.Math.getExponent(double)
java.lang.Math.getExponent(float)
java.lang.StrictMath.getExponent(double)
java.lang.StrictMath.getExponent(float)
java.security.spec.RSAOtherPrimeInfo.getExponent()


Occurences of getExpression

getExpression occurences:
com.sun.source.tree.ArrayAccessTree.getExpression()
com.sun.source.tree.AssignmentTree.getExpression()
com.sun.source.tree.CaseTree.getExpression()
com.sun.source.tree.CompoundAssignmentTree.getExpression()
com.sun.source.tree.EnhancedForLoopTree.getExpression()
com.sun.source.tree.ExpressionStatementTree.getExpression()
com.sun.source.tree.InstanceOfTree.getExpression()
com.sun.source.tree.MemberSelectTree.getExpression()
com.sun.source.tree.ParenthesizedTree.getExpression()
com.sun.source.tree.ReturnTree.getExpression()
com.sun.source.tree.SwitchTree.getExpression()
com.sun.source.tree.SynchronizedTree.getExpression()
com.sun.source.tree.ThrowTree.getExpression()
com.sun.source.tree.TypeCastTree.getExpression()
com.sun.source.tree.UnaryTree.getExpression()
javax.xml.crypto.dsig.spec.XPathType.getExpression()


Occurences of getExtendedKeyUsage

getExtendedKeyUsage occurences:
java.security.cert.X509Certificate.getExtendedKeyUsage()
java.security.cert.X509CertSelector.getExtendedKeyUsage()


Occurences of getExtensions

getExtensions occurences:
javax.script.ScriptEngineFactory.getExtensions()
javax.swing.filechooser.FileNameExtensionFilter.getExtensions()


Occurences of getExtent

getExtent occurences:
javax.swing.BoundedRangeModel.getExtent()
javax.swing.DefaultBoundedRangeModel.getExtent()
javax.swing.JSlider.getExtent()


Occurences of getExternalSubset

getExternalSubset occurences:
org.xml.sax.ext.DefaultHandler2.getExternalSubset(java.lang.String, java.lang.String)
org.xml.sax.ext.EntityResolver2.getExternalSubset(java.lang.String, java.lang.String)


Occurences of getFamily

getFamily occurences:
java.awt.Font.getFamily()
java.awt.Font.getFamily(java.util.Locale)


Occurences of getFault

getFault occurences:
javax.xml.soap.SOAPBody.getFault()
javax.xml.ws.soap.SOAPFaultException.getFault()


Occurences of getFD

getFD occurences:
java.io.FileInputStream.getFD()
java.io.FileOutputStream.getFD()
java.io.RandomAccessFile.getFD()


Occurences of getFeature

getFeature occurences:
javax.imageio.metadata.IIOMetadataNode.getFeature(java.lang.String, java.lang.String)
javax.xml.parsers.DocumentBuilderFactory.getFeature(java.lang.String)
javax.xml.parsers.SAXParserFactory.getFeature(java.lang.String)
javax.xml.transform.TransformerFactory.getFeature(java.lang.String)
javax.xml.validation.SchemaFactory.getFeature(java.lang.String)
javax.xml.validation.Validator.getFeature(java.lang.String)
javax.xml.validation.ValidatorHandler.getFeature(java.lang.String)
javax.xml.xpath.XPathFactory.getFeature(java.lang.String)
org.w3c.dom.DOMImplementation.getFeature(java.lang.String, java.lang.String)
org.w3c.dom.Node.getFeature(java.lang.String, java.lang.String)
org.xml.sax.helpers.ParserAdapter.getFeature(java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.getFeature(java.lang.String)
org.xml.sax.XMLReader.getFeature(java.lang.String)


Occurences of getFetchDirection

getFetchDirection occurences:
java.sql.ResultSet.getFetchDirection()
java.sql.Statement.getFetchDirection()
javax.sql.rowset.BaseRowSet.getFetchDirection()


Occurences of getFetchSize

getFetchSize occurences:
java.sql.ResultSet.getFetchSize()
java.sql.Statement.getFetchSize()
javax.sql.rowset.BaseRowSet.getFetchSize()


Occurences of getField

getField occurences:
java.io.ObjectStreamClass.getField(java.lang.String)
java.lang.Class.getField(java.lang.String)
java.security.spec.EllipticCurve.getField()
java.text.FieldPosition.getField()
javax.xml.datatype.Duration.getField(javax.xml.datatype.DatatypeConstants.Field)


Occurences of getFieldNames

getFieldNames occurences:
javax.management.Descriptor.getFieldNames()
javax.management.ImmutableDescriptor.getFieldNames()
javax.management.modelmbean.DescriptorSupport.getFieldNames()


Occurences of getFields

getFields occurences:
com.sun.mirror.declaration.TypeDeclaration.getFields()
java.io.ObjectStreamClass.getFields()
java.lang.Class.getFields()
javax.management.Descriptor.getFields()
javax.management.ImmutableDescriptor.getFields()
javax.management.modelmbean.DescriptorSupport.getFields()
javax.sql.rowset.serial.SerialJavaObject.getFields()
javax.swing.text.InternationalFormatter.getFields(int)


Occurences of getFieldSize

getFieldSize occurences:
java.security.spec.ECField.getFieldSize()
java.security.spec.ECFieldF2m.getFieldSize()
java.security.spec.ECFieldFp.getFieldSize()


Occurences of getFieldValue

getFieldValue occurences:
javax.management.Descriptor.getFieldValue(java.lang.String)
javax.management.ImmutableDescriptor.getFieldValue(java.lang.String)
javax.management.modelmbean.DescriptorSupport.getFieldValue(java.lang.String)


Occurences of getFieldValues

getFieldValues occurences:
javax.management.Descriptor.getFieldValues(java.lang.String...)
javax.management.ImmutableDescriptor.getFieldValues(java.lang.String...)
javax.management.modelmbean.DescriptorSupport.getFieldValues(java.lang.String...)


Occurences of getFile

getFile occurences:
java.awt.FileDialog.getFile()
java.net.URL.getFile()
javax.activation.FileDataSource.getFile()


Occurences of getFileDescriptor

getFileDescriptor occurences:
java.net.DatagramSocketImpl.getFileDescriptor()
java.net.SocketImpl.getFileDescriptor()


Occurences of getFileForInput

getFileForInput occurences:
javax.tools.ForwardingJavaFileManager.getFileForInput(javax.tools.JavaFileManager.Location, java.lang.String, java.lang.String)
javax.tools.JavaFileManager.getFileForInput(javax.tools.JavaFileManager.Location, java.lang.String, java.lang.String)


Occurences of getFileForOutput

getFileForOutput occurences:
javax.tools.ForwardingJavaFileManager.getFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, java.lang.String, javax.tools.FileObject)
javax.tools.JavaFileManager.getFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, java.lang.String, javax.tools.FileObject)


Occurences of getFileName

getFileName occurences:
java.awt.JobAttributes.getFileName()
java.lang.StackTraceElement.getFileName()
javax.script.ScriptException.getFileName()
javax.swing.plaf.basic.BasicFileChooserUI.getFileName()
javax.swing.plaf.metal.MetalFileChooserUI.getFileName()


Occurences of getFiler

getFiler occurences:
com.sun.mirror.apt.AnnotationProcessorEnvironment.getFiler()
javax.annotation.processing.ProcessingEnvironment.getFiler()


Occurences of getFiles

getFiles occurences:
javax.swing.filechooser.FileSystemView.getFiles(java.io.File, boolean)
javax.swing.plaf.basic.BasicDirectoryModel.getFiles()


Occurences of getFileSystemView

getFileSystemView occurences:
javax.swing.filechooser.FileSystemView.getFileSystemView()
javax.swing.JFileChooser.getFileSystemView()


Occurences of getFileView

getFileView occurences:
javax.swing.JFileChooser.getFileView()
javax.swing.plaf.basic.BasicFileChooserUI.getFileView(javax.swing.JFileChooser)
javax.swing.plaf.FileChooserUI.getFileView(javax.swing.JFileChooser)
javax.swing.plaf.multi.MultiFileChooserUI.getFileView(javax.swing.JFileChooser)


Occurences of getFilter

getFilter occurences:
com.sun.mirror.util.DeclarationFilter.getFilter(java.lang.Class)
com.sun.mirror.util.DeclarationFilter.getFilter(java.util.Collection)
java.util.logging.Handler.getFilter()
java.util.logging.Logger.getFilter()
javax.sql.rowset.FilteredRowSet.getFilter()
javax.xml.crypto.dsig.spec.XPathType.getFilter()
org.w3c.dom.ls.LSParser.getFilter()
org.w3c.dom.ls.LSSerializer.getFilter()


Occurences of getFirst

getFirst occurences:
java.util.ArrayDeque.getFirst()
java.util.concurrent.LinkedBlockingDeque.getFirst()
java.util.Deque.getFirst()
java.util.LinkedList.getFirst()


Occurences of getFirstChild

getFirstChild occurences:
javax.imageio.metadata.IIOMetadataNode.getFirstChild()
javax.swing.tree.DefaultMutableTreeNode.getFirstChild()
org.w3c.dom.Node.getFirstChild()


Occurences of getFirstColumn

getFirstColumn occurences:
javax.accessibility.AccessibleTableModelChange.getFirstColumn()
javax.swing.JTable.AccessibleJTable.AccessibleJTableModelChange.getFirstColumn()


Occurences of getFirstComponent

getFirstComponent occurences:
java.awt.ContainerOrderFocusTraversalPolicy.getFirstComponent(java.awt.Container)
java.awt.FocusTraversalPolicy.getFirstComponent(java.awt.Container)
javax.swing.DefaultFocusManager.getFirstComponent(java.awt.Container)
javax.swing.LayoutFocusTraversalPolicy.getFirstComponent(java.awt.Container)
javax.swing.SortingFocusTraversalPolicy.getFirstComponent(java.awt.Container)


Occurences of getFirstQueuedThread

getFirstQueuedThread occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.getFirstQueuedThread()
java.util.concurrent.locks.AbstractQueuedSynchronizer.getFirstQueuedThread()


Occurences of getFirstRow

getFirstRow occurences:
javax.accessibility.AccessibleTableModelChange.getFirstRow()
javax.swing.event.TableModelEvent.getFirstRow()
javax.swing.JTable.AccessibleJTable.AccessibleJTableModelChange.getFirstRow()


Occurences of getFixedRate

getFixedRate occurences:
javax.management.timer.Timer.getFixedRate(java.lang.Integer)
javax.management.timer.TimerMBean.getFixedRate(java.lang.Integer)


Occurences of getFlags

getFlags occurences:
com.sun.source.tree.ModifiersTree.getFlags()
java.util.DuplicateFormatFlagsException.getFlags()
java.util.FormatFlagsConversionMismatchException.getFlags()
java.util.IllegalFormatFlagsException.getFlags()
java.util.UnknownFormatFlagsException.getFlags()
javax.security.auth.kerberos.KerberosTicket.getFlags()


Occurences of getFlatness

getFlatness occurences:
java.awt.geom.CubicCurve2D.getFlatness()
java.awt.geom.CubicCurve2D.getFlatness(double, double, double, double, double, double, double, double)
java.awt.geom.CubicCurve2D.getFlatness(double[], int)
java.awt.geom.FlatteningPathIterator.getFlatness()
java.awt.geom.QuadCurve2D.getFlatness()
java.awt.geom.QuadCurve2D.getFlatness(double, double, double, double, double, double)
java.awt.geom.QuadCurve2D.getFlatness(double[], int)


Occurences of getFlatnessSq

getFlatnessSq occurences:
java.awt.geom.CubicCurve2D.getFlatnessSq()
java.awt.geom.CubicCurve2D.getFlatnessSq(double, double, double, double, double, double, double, double)
java.awt.geom.CubicCurve2D.getFlatnessSq(double[], int)
java.awt.geom.QuadCurve2D.getFlatnessSq()
java.awt.geom.QuadCurve2D.getFlatnessSq(double, double, double, double, double, double)
java.awt.geom.QuadCurve2D.getFlatnessSq(double[], int)


Occurences of getFlavorMap

getFlavorMap occurences:
java.awt.dnd.DragSource.getFlavorMap()
java.awt.dnd.DropTarget.getFlavorMap()


Occurences of getFlavorsForNative

getFlavorsForNative occurences:
java.awt.datatransfer.FlavorTable.getFlavorsForNative(java.lang.String)
java.awt.datatransfer.SystemFlavorMap.getFlavorsForNative(java.lang.String)


Occurences of getFlavorsForNatives

getFlavorsForNatives occurences:
java.awt.datatransfer.FlavorMap.getFlavorsForNatives(java.lang.String[])
java.awt.datatransfer.SystemFlavorMap.getFlavorsForNatives(java.lang.String[])


Occurences of getFloat

getFloat occurences:
java.lang.reflect.Array.getFloat(java.lang.Object, int)
java.lang.reflect.Field.getFloat(java.lang.Object)
java.nio.ByteBuffer.getFloat()
java.nio.ByteBuffer.getFloat(int)
java.sql.CallableStatement.getFloat(int)
java.sql.CallableStatement.getFloat(java.lang.String)
java.sql.ResultSet.getFloat(int)
java.sql.ResultSet.getFloat(java.lang.String)
java.util.prefs.AbstractPreferences.getFloat(java.lang.String, float)
java.util.prefs.Preferences.getFloat(java.lang.String, float)


Occurences of getFlowSpan

getFlowSpan occurences:
javax.swing.text.FlowView.getFlowSpan(int)
javax.swing.text.ParagraphView.getFlowSpan(int)


Occurences of getFlowStart

getFlowStart occurences:
javax.swing.text.FlowView.getFlowStart(int)
javax.swing.text.ParagraphView.getFlowStart(int)


Occurences of getFlushedPosition

getFlushedPosition occurences:
javax.imageio.stream.ImageInputStream.getFlushedPosition()
javax.imageio.stream.ImageInputStreamImpl.getFlushedPosition()


Occurences of getFocusColor

getFocusColor occurences:
javax.swing.plaf.basic.BasicSliderUI.getFocusColor()
javax.swing.plaf.metal.MetalButtonUI.getFocusColor()
javax.swing.plaf.metal.MetalLookAndFeel.getFocusColor()
javax.swing.plaf.metal.MetalRadioButtonUI.getFocusColor()
javax.swing.plaf.metal.MetalTheme.getFocusColor()
javax.swing.plaf.metal.MetalToggleButtonUI.getFocusColor()


Occurences of getFocusCycleRootAncestor

getFocusCycleRootAncestor occurences:
java.awt.Component.getFocusCycleRootAncestor()
java.awt.Window.getFocusCycleRootAncestor()
javax.swing.JInternalFrame.getFocusCycleRootAncestor()


Occurences of getFocusOwner

getFocusOwner occurences:
java.awt.KeyboardFocusManager.getFocusOwner()
java.awt.Window.getFocusOwner()
javax.swing.JInternalFrame.getFocusOwner()


Occurences of getFocusTraversalKeys

getFocusTraversalKeys occurences:
java.awt.Component.getFocusTraversalKeys(int)
java.awt.Container.getFocusTraversalKeys(int)
java.awt.Window.getFocusTraversalKeys(int)


Occurences of getFont

getFont occurences:
java.awt.Component.getFont()
java.awt.Component.AccessibleAWTComponent.getFont()
java.awt.Font.getFont(java.lang.String)
java.awt.Font.getFont(java.lang.String, java.awt.Font)
java.awt.Font.getFont(java.util.Map)
java.awt.font.GlyphVector.getFont()
java.awt.FontMetrics.getFont()
java.awt.Graphics.getFont()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getFont()
java.awt.MenuComponent.getFont()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getFont()
java.awt.MenuContainer.getFont()
javax.accessibility.AccessibleComponent.getFont()
javax.swing.border.TitledBorder.getFont(java.awt.Component)
javax.swing.DebugGraphics.getFont()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getFont()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getFont()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getFont()
javax.swing.plaf.synth.SynthStyle.getFont(javax.swing.plaf.synth.SynthContext)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getFont()
javax.swing.text.DefaultStyledDocument.getFont(javax.swing.text.AttributeSet)
javax.swing.text.GlyphView.getFont()
javax.swing.text.html.StyleSheet.getFont(javax.swing.text.AttributeSet)
javax.swing.text.LabelView.getFont()
javax.swing.text.StyleContext.getFont(java.lang.String, int, int)
javax.swing.text.StyleContext.getFont(javax.swing.text.AttributeSet)
javax.swing.text.StyledDocument.getFont(javax.swing.text.AttributeSet)
javax.swing.tree.DefaultTreeCellEditor.getFont()
javax.swing.tree.DefaultTreeCellEditor.DefaultTextField.getFont()
javax.swing.tree.DefaultTreeCellRenderer.getFont()
javax.swing.UIDefaults.getFont(java.lang.Object)
javax.swing.UIDefaults.getFont(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getFont(java.lang.Object)
javax.swing.UIManager.getFont(java.lang.Object, java.util.Locale)


Occurences of getFontMetrics

getFontMetrics occurences:
java.awt.Component.getFontMetrics(java.awt.Font)
java.awt.Component.AccessibleAWTComponent.getFontMetrics(java.awt.Font)
java.awt.Graphics.getFontMetrics()
java.awt.Graphics.getFontMetrics(java.awt.Font)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getFontMetrics(java.awt.Font)
java.awt.MenuComponent.AccessibleAWTMenuComponent.getFontMetrics(java.awt.Font)
java.awt.Toolkit.getFontMetrics(java.awt.Font)
javax.accessibility.AccessibleComponent.getFontMetrics(java.awt.Font)
javax.swing.DebugGraphics.getFontMetrics()
javax.swing.DebugGraphics.getFontMetrics(java.awt.Font)
javax.swing.JComponent.getFontMetrics(java.awt.Font)
javax.swing.JList.AccessibleJList.AccessibleJListChild.getFontMetrics(java.awt.Font)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getFontMetrics(java.awt.Font)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getFontMetrics(java.awt.Font)
javax.swing.plaf.basic.BasicTabbedPaneUI.getFontMetrics()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getFontMetrics(java.awt.Font)
javax.swing.text.FieldView.getFontMetrics()
javax.swing.text.LabelView.getFontMetrics()
javax.swing.text.StyleContext.getFontMetrics(java.awt.Font)


Occurences of getFontName

getFontName occurences:
java.awt.Font.getFontName()
java.awt.Font.getFontName(java.util.Locale)


Occurences of getFontRenderContext

getFontRenderContext occurences:
java.awt.font.GlyphVector.getFontRenderContext()
java.awt.FontMetrics.getFontRenderContext()
java.awt.Graphics2D.getFontRenderContext()


Occurences of getFontTable

getFontTable occurences:
java.awt.font.OpenType.getFontTable(int)
java.awt.font.OpenType.getFontTable(int, int, int)
java.awt.font.OpenType.getFontTable(java.lang.String)
java.awt.font.OpenType.getFontTable(java.lang.String, int, int)


Occurences of getFontTableSize

getFontTableSize occurences:
java.awt.font.OpenType.getFontTableSize(int)
java.awt.font.OpenType.getFontTableSize(java.lang.String)


Occurences of getForeground

getForeground occurences:
java.awt.Component.getForeground()
java.awt.Component.AccessibleAWTComponent.getForeground()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getForeground()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getForeground()
javax.accessibility.AccessibleComponent.getForeground()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getForeground()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getForeground()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getForeground()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getForeground()
javax.swing.text.DefaultStyledDocument.getForeground(javax.swing.text.AttributeSet)
javax.swing.text.GlyphView.getForeground()
javax.swing.text.html.StyleSheet.getForeground(javax.swing.text.AttributeSet)
javax.swing.text.LabelView.getForeground()
javax.swing.text.StyleConstants.getForeground(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.getForeground(javax.swing.text.AttributeSet)
javax.swing.text.StyledDocument.getForeground(javax.swing.text.AttributeSet)


Occurences of getFormalTypeParameters

getFormalTypeParameters occurences:
com.sun.mirror.declaration.ExecutableDeclaration.getFormalTypeParameters()
com.sun.mirror.declaration.TypeDeclaration.getFormalTypeParameters()


Occurences of getFormat

getFormat occurences:
java.security.Certificate.getFormat()
java.security.Key.getFormat()
java.security.spec.EncodedKeySpec.getFormat()
java.security.spec.PKCS8EncodedKeySpec.getFormat()
java.security.spec.X509EncodedKeySpec.getFormat()
javax.crypto.spec.SecretKeySpec.getFormat()
javax.security.auth.kerberos.KerberosKey.getFormat()
javax.sound.sampled.AudioFileFormat.getFormat()
javax.sound.sampled.AudioInputStream.getFormat()
javax.sound.sampled.DataLine.getFormat()
javax.swing.JSpinner.DateEditor.getFormat()
javax.swing.JSpinner.NumberEditor.getFormat()
javax.swing.text.InternationalFormatter.getFormat()


Occurences of getFormats

getFormats occurences:
java.text.ChoiceFormat.getFormats()
java.text.MessageFormat.getFormats()
java.util.ResourceBundle.Control.getFormats(java.lang.String)
javax.sound.sampled.DataLine.Info.getFormats()


Occurences of getFormatSpecifier

getFormatSpecifier occurences:
java.util.MissingFormatArgumentException.getFormatSpecifier()
java.util.MissingFormatWidthException.getFormatSpecifier()


Occurences of getFormatter

getFormatter occurences:
java.util.logging.Handler.getFormatter()
javax.swing.JFormattedTextField.getFormatter()
javax.swing.JFormattedTextField.AbstractFormatterFactory.getFormatter(javax.swing.JFormattedTextField)
javax.swing.text.DefaultFormatterFactory.getFormatter(javax.swing.JFormattedTextField)


Occurences of getFrameLength

getFrameLength occurences:
javax.sound.sampled.AudioFileFormat.getFrameLength()
javax.sound.sampled.AudioInputStream.getFrameLength()
javax.sound.sampled.Clip.getFrameLength()


Occurences of getFramePosition

getFramePosition occurences:
javax.sound.sampled.DataLine.getFramePosition()
javax.sound.sampled.LineEvent.getFramePosition()


Occurences of getG

getG occurences:
java.security.interfaces.DSAParams.getG()
java.security.spec.DSAParameterSpec.getG()
java.security.spec.DSAPrivateKeySpec.getG()
java.security.spec.DSAPublicKeySpec.getG()
javax.crypto.spec.DHParameterSpec.getG()
javax.crypto.spec.DHPrivateKeySpec.getG()
javax.crypto.spec.DHPublicKeySpec.getG()


Occurences of getGamma

getGamma occurences:
java.awt.color.ICC_ProfileGray.getGamma()
java.awt.color.ICC_ProfileRGB.getGamma(int)


Occurences of getGenericExceptionTypes

getGenericExceptionTypes occurences:
java.lang.reflect.Constructor.getGenericExceptionTypes()
java.lang.reflect.Method.getGenericExceptionTypes()


Occurences of getGenericParameterTypes

getGenericParameterTypes occurences:
java.lang.reflect.Constructor.getGenericParameterTypes()
java.lang.reflect.Method.getGenericParameterTypes()


Occurences of getGlassPane

getGlassPane occurences:
javax.swing.JApplet.getGlassPane()
javax.swing.JDialog.getGlassPane()
javax.swing.JFrame.getGlassPane()
javax.swing.JInternalFrame.getGlassPane()
javax.swing.JRootPane.getGlassPane()
javax.swing.JWindow.getGlassPane()
javax.swing.RootPaneContainer.getGlassPane()


Occurences of getGlyphOutline

getGlyphOutline occurences:
java.awt.font.GlyphVector.getGlyphOutline(int)
java.awt.font.GlyphVector.getGlyphOutline(int, float, float)


Occurences of getGranularityPeriod

getGranularityPeriod occurences:
javax.management.monitor.Monitor.getGranularityPeriod()
javax.management.monitor.MonitorMBean.getGranularityPeriod()


Occurences of getGraphics

getGraphics occurences:
java.awt.Component.getGraphics()
java.awt.Image.getGraphics()
java.awt.image.BufferedImage.getGraphics()
java.awt.image.VolatileImage.getGraphics()
java.awt.PrintJob.getGraphics()
javax.swing.JApplet.getGraphics()
javax.swing.JComponent.getGraphics()
javax.swing.JDialog.getGraphics()
javax.swing.JFrame.getGraphics()
javax.swing.JWindow.getGraphics()
javax.swing.text.View.getGraphics()


Occurences of getGraphicsConfiguration

getGraphicsConfiguration occurences:
java.awt.Component.getGraphicsConfiguration()
java.awt.Window.getGraphicsConfiguration()


Occurences of getGreatestMinimum

getGreatestMinimum occurences:
java.util.Calendar.getGreatestMinimum(int)
java.util.GregorianCalendar.getGreatestMinimum(int)


Occurences of getGreen

getGreen occurences:
java.awt.Color.getGreen()
java.awt.image.ColorModel.getGreen(int)
java.awt.image.ColorModel.getGreen(java.lang.Object)
java.awt.image.ComponentColorModel.getGreen(int)
java.awt.image.ComponentColorModel.getGreen(java.lang.Object)
java.awt.image.DirectColorModel.getGreen(int)
java.awt.image.DirectColorModel.getGreen(java.lang.Object)
java.awt.image.IndexColorModel.getGreen(int)


Occurences of getHandlerChain

getHandlerChain occurences:
javax.xml.ws.Binding.getHandlerChain()
javax.xml.ws.handler.HandlerResolver.getHandlerChain(javax.xml.ws.handler.PortInfo)


Occurences of getHandlerResolver

getHandlerResolver occurences:
javax.xml.ws.Service.getHandlerResolver()
javax.xml.ws.spi.ServiceDelegate.getHandlerResolver()


Occurences of getHandshakeStatus

getHandshakeStatus occurences:
javax.net.ssl.SSLEngine.getHandshakeStatus()
javax.net.ssl.SSLEngineResult.getHandshakeStatus()


Occurences of getHead

getHead occurences:
java.util.logging.Formatter.getHead(java.util.logging.Handler)
java.util.logging.XMLFormatter.getHead(java.util.logging.Handler)


Occurences of getHeader

getHeader occurences:
javax.xml.soap.MimeHeaders.getHeader(java.lang.String)
javax.xml.soap.SOAPEnvelope.getHeader()


Occurences of getHeaderField

getHeaderField occurences:
java.net.HttpURLConnection.getHeaderField(int)
java.net.URLConnection.getHeaderField(int)
java.net.URLConnection.getHeaderField(java.lang.String)


Occurences of getHeaderFieldDate

getHeaderFieldDate occurences:
java.net.HttpURLConnection.getHeaderFieldDate(java.lang.String, long)
java.net.URLConnection.getHeaderFieldDate(java.lang.String, long)


Occurences of getHeaderFieldKey

getHeaderFieldKey occurences:
java.net.HttpURLConnection.getHeaderFieldKey(int)
java.net.URLConnection.getHeaderFieldKey(int)


Occurences of getHeaders

getHeaders occurences:
java.net.CacheResponse.getHeaders()
javax.xml.ws.handler.soap.SOAPHandler.getHeaders()
javax.xml.ws.handler.soap.SOAPMessageContext.getHeaders(javax.xml.namespace.QName, javax.xml.bind.JAXBContext, boolean)


Occurences of getHeight

getHeight occurences:
java.awt.Component.getHeight()
java.awt.Dimension.getHeight()
java.awt.DisplayMode.getHeight()
java.awt.font.LineMetrics.getHeight()
java.awt.FontMetrics.getHeight()
java.awt.geom.Arc2D.Double.getHeight()
java.awt.geom.Arc2D.Float.getHeight()
java.awt.geom.Dimension2D.getHeight()
java.awt.geom.Ellipse2D.Double.getHeight()
java.awt.geom.Ellipse2D.Float.getHeight()
java.awt.geom.Rectangle2D.Double.getHeight()
java.awt.geom.Rectangle2D.Float.getHeight()
java.awt.geom.RectangularShape.getHeight()
java.awt.geom.RoundRectangle2D.Double.getHeight()
java.awt.geom.RoundRectangle2D.Float.getHeight()
java.awt.Image.getHeight(java.awt.image.ImageObserver)
java.awt.image.BufferedImage.getHeight()
java.awt.image.BufferedImage.getHeight(java.awt.image.ImageObserver)
java.awt.image.Kernel.getHeight()
java.awt.image.PixelGrabber.getHeight()
java.awt.image.Raster.getHeight()
java.awt.image.renderable.RenderableImage.getHeight()
java.awt.image.renderable.RenderableImageOp.getHeight()
java.awt.image.RenderedImage.getHeight()
java.awt.image.SampleModel.getHeight()
java.awt.image.VolatileImage.getHeight()
java.awt.print.PageFormat.getHeight()
java.awt.print.Paper.getHeight()
java.awt.Rectangle.getHeight()
javax.imageio.ImageReader.getHeight(int)
javax.print.attribute.standard.MediaPrintableArea.getHeight(int)
javax.swing.JComponent.getHeight()
javax.swing.SpringLayout.Constraints.getHeight()
javax.swing.text.BoxView.getHeight()
javax.swing.text.GlyphView.GlyphPainter.getHeight(javax.swing.text.GlyphView)


Occurences of getHelpMenu

getHelpMenu occurences:
java.awt.MenuBar.getHelpMenu()
javax.swing.JMenuBar.getHelpMenu()


Occurences of getHgap

getHgap occurences:
java.awt.BorderLayout.getHgap()
java.awt.CardLayout.getHgap()
java.awt.FlowLayout.getHgap()
java.awt.GridLayout.getHgap()


Occurences of getHighlightColor

getHighlightColor occurences:
javax.swing.border.EtchedBorder.getHighlightColor()
javax.swing.border.EtchedBorder.getHighlightColor(java.awt.Component)
javax.swing.plaf.basic.BasicSliderUI.getHighlightColor()


Occurences of getHighlightedTextColor

getHighlightedTextColor occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getHighlightedTextColor()
javax.swing.plaf.metal.MetalTheme.getHighlightedTextColor()


Occurences of getHighlightInnerColor

getHighlightInnerColor occurences:
javax.swing.border.BevelBorder.getHighlightInnerColor()
javax.swing.border.BevelBorder.getHighlightInnerColor(java.awt.Component)


Occurences of getHighlightOuterColor

getHighlightOuterColor occurences:
javax.swing.border.BevelBorder.getHighlightOuterColor()
javax.swing.border.BevelBorder.getHighlightOuterColor(java.awt.Component)


Occurences of getHighlights

getHighlights occurences:
javax.swing.text.DefaultHighlighter.getHighlights()
javax.swing.text.Highlighter.getHighlights()


Occurences of getHighThreshold

getHighThreshold occurences:
javax.management.monitor.GaugeMonitor.getHighThreshold()
javax.management.monitor.GaugeMonitorMBean.getHighThreshold()


Occurences of getHoldability

getHoldability occurences:
java.sql.Connection.getHoldability()
java.sql.ResultSet.getHoldability()


Occurences of getHoldCount

getHoldCount occurences:
java.util.concurrent.locks.ReentrantLock.getHoldCount()
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.getHoldCount()


Occurences of getHorizontalAlignment

getHorizontalAlignment occurences:
javax.swing.AbstractButton.getHorizontalAlignment()
javax.swing.JLabel.getHorizontalAlignment()
javax.swing.JTextField.getHorizontalAlignment()


Occurences of getHorizontalLegBuffer

getHorizontalLegBuffer occurences:
javax.swing.plaf.basic.BasicTreeUI.getHorizontalLegBuffer()
javax.swing.plaf.metal.MetalTreeUI.getHorizontalLegBuffer()


Occurences of getHorizontalScrollBar

getHorizontalScrollBar occurences:
javax.swing.JScrollPane.getHorizontalScrollBar()
javax.swing.ScrollPaneLayout.getHorizontalScrollBar()


Occurences of getHorizontalScrollBarPolicy

getHorizontalScrollBarPolicy occurences:
javax.swing.JScrollPane.getHorizontalScrollBarPolicy()
javax.swing.ScrollPaneLayout.getHorizontalScrollBarPolicy()


Occurences of getHorizontalTextPosition

getHorizontalTextPosition occurences:
javax.swing.AbstractButton.getHorizontalTextPosition()
javax.swing.JLabel.getHorizontalTextPosition()


Occurences of getHost

getHost occurences:
java.net.URI.getHost()
java.net.URL.getHost()
javax.management.remote.JMXServiceURL.getHost()


Occurences of getHostAddress

getHostAddress occurences:
java.net.Inet4Address.getHostAddress()
java.net.Inet6Address.getHostAddress()
java.net.InetAddress.getHostAddress()
java.net.URLStreamHandler.getHostAddress(java.net.URL)


Occurences of getHostName

getHostName occurences:
java.net.InetAddress.getHostName()
java.net.InetSocketAddress.getHostName()


Occurences of getHours

getHours occurences:
java.sql.Date.getHours()
java.util.Date.getHours()
javax.xml.datatype.Duration.getHours()


Occurences of getHumanPresentableName

getHumanPresentableName occurences:
java.awt.datatransfer.DataFlavor.getHumanPresentableName()
javax.activation.ActivationDataFlavor.getHumanPresentableName()


Occurences of getIcon

getIcon occurences:
java.beans.BeanInfo.getIcon(int)
java.beans.SimpleBeanInfo.getIcon(int)
javax.swing.AbstractButton.getIcon()
javax.swing.filechooser.FileView.getIcon(java.io.File)
javax.swing.JFileChooser.getIcon(java.io.File)
javax.swing.JLabel.getIcon()
javax.swing.JOptionPane.getIcon()
javax.swing.plaf.basic.BasicFileChooserUI.BasicFileView.getIcon(java.io.File)
javax.swing.plaf.basic.BasicOptionPaneUI.getIcon()
javax.swing.plaf.synth.SynthStyle.getIcon(javax.swing.plaf.synth.SynthContext, java.lang.Object)
javax.swing.text.StyleConstants.getIcon(javax.swing.text.AttributeSet)
javax.swing.UIDefaults.getIcon(java.lang.Object)
javax.swing.UIDefaults.getIcon(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getIcon(java.lang.Object)
javax.swing.UIManager.getIcon(java.lang.Object, java.util.Locale)


Occurences of getIconHeight

getIconHeight occurences:
javax.swing.Icon.getIconHeight()
javax.swing.ImageIcon.getIconHeight()
javax.swing.plaf.IconUIResource.getIconHeight()
javax.swing.plaf.metal.MetalCheckBoxIcon.getIconHeight()
javax.swing.plaf.metal.MetalComboBoxIcon.getIconHeight()
javax.swing.plaf.metal.MetalIconFactory.FileIcon16.getIconHeight()
javax.swing.plaf.metal.MetalIconFactory.FolderIcon16.getIconHeight()
javax.swing.plaf.metal.MetalIconFactory.PaletteCloseIcon.getIconHeight()
javax.swing.plaf.metal.MetalIconFactory.TreeControlIcon.getIconHeight()


Occurences of getIconTextGap

getIconTextGap occurences:
javax.swing.AbstractButton.getIconTextGap()
javax.swing.JLabel.getIconTextGap()


Occurences of getIconWidth

getIconWidth occurences:
javax.swing.Icon.getIconWidth()
javax.swing.ImageIcon.getIconWidth()
javax.swing.plaf.IconUIResource.getIconWidth()
javax.swing.plaf.metal.MetalCheckBoxIcon.getIconWidth()
javax.swing.plaf.metal.MetalComboBoxIcon.getIconWidth()
javax.swing.plaf.metal.MetalIconFactory.FileIcon16.getIconWidth()
javax.swing.plaf.metal.MetalIconFactory.FolderIcon16.getIconWidth()
javax.swing.plaf.metal.MetalIconFactory.PaletteCloseIcon.getIconWidth()
javax.swing.plaf.metal.MetalIconFactory.TreeControlIcon.getIconWidth()


Occurences of getID

getID occurences:
java.awt.AWTEvent.getID()
java.rmi.activation.Activatable.getID()
java.util.TimeZone.getID()
javax.naming.directory.Attribute.getID()
javax.naming.directory.BasicAttribute.getID()
javax.naming.ldap.BasicControl.getID()
javax.naming.ldap.Control.getID()
javax.naming.ldap.ExtendedRequest.getID()
javax.naming.ldap.ExtendedResponse.getID()
javax.naming.ldap.StartTlsRequest.getID()
javax.naming.ldap.StartTlsResponse.getID()
javax.swing.LookAndFeel.getID()
javax.swing.plaf.metal.MetalLookAndFeel.getID()
javax.swing.plaf.multi.MultiLookAndFeel.getID()
javax.swing.plaf.synth.ColorType.getID()
javax.swing.plaf.synth.SynthLookAndFeel.getID()


Occurences of getId

getId occurences:
java.lang.Thread.getId()
javax.net.ssl.SSLSession.getId()
javax.xml.crypto.dsig.keyinfo.KeyInfo.getId()
javax.xml.crypto.dsig.Manifest.getId()
javax.xml.crypto.dsig.Reference.getId()
javax.xml.crypto.dsig.SignatureProperties.getId()
javax.xml.crypto.dsig.SignatureProperty.getId()
javax.xml.crypto.dsig.SignedInfo.getId()
javax.xml.crypto.dsig.XMLObject.getId()
javax.xml.crypto.dsig.XMLSignature.getId()
javax.xml.crypto.dsig.XMLSignature.SignatureValue.getId()
javax.xml.datatype.DatatypeConstants.Field.getId()
org.omg.CORBA.portable.ApplicationException.getId()


Occurences of getIdentifier

getIdentifier occurences:
com.sun.source.tree.MemberSelectTree.getIdentifier()
com.sun.source.tree.NewClassTree.getIdentifier()
javax.swing.DefaultRowSorter.ModelWrapper.getIdentifier(int)
javax.swing.RowFilter.Entry.getIdentifier()
javax.swing.table.TableColumn.getIdentifier()


Occurences of getIdentity

getIdentity occurences:
java.security.IdentityScope.getIdentity(java.lang.String)
java.security.IdentityScope.getIdentity(java.security.Principal)
java.security.IdentityScope.getIdentity(java.security.PublicKey)


Occurences of getIDs

getIDs occurences:
javax.naming.directory.Attributes.getIDs()
javax.naming.directory.BasicAttributes.getIDs()


Occurences of getImage

getImage occurences:
java.applet.Applet.getImage(java.net.URL)
java.applet.Applet.getImage(java.net.URL, java.lang.String)
java.applet.AppletContext.getImage(java.net.URL)
java.awt.TexturePaint.getImage()
java.awt.Toolkit.getImage(java.lang.String)
java.awt.Toolkit.getImage(java.net.URL)
java.awt.TrayIcon.getImage()
javax.swing.ImageIcon.getImage()
javax.swing.text.html.ImageView.getImage()


Occurences of getImageableHeight

getImageableHeight occurences:
java.awt.print.PageFormat.getImageableHeight()
java.awt.print.Paper.getImageableHeight()


Occurences of getImageableWidth

getImageableWidth occurences:
java.awt.print.PageFormat.getImageableWidth()
java.awt.print.Paper.getImageableWidth()


Occurences of getImageableX

getImageableX occurences:
java.awt.print.PageFormat.getImageableX()
java.awt.print.Paper.getImageableX()


Occurences of getImageableY

getImageableY occurences:
java.awt.print.PageFormat.getImageableY()
java.awt.print.Paper.getImageableY()


Occurences of getImageMetadata

getImageMetadata occurences:
javax.imageio.ImageReader.getImageMetadata(int)
javax.imageio.ImageReader.getImageMetadata(int, java.lang.String, java.util.Set)


Occurences of getImageURL

getImageURL occurences:
java.awt.SplashScreen.getImageURL()
javax.swing.text.html.ImageView.getImageURL()


Occurences of getImpact

getImpact occurences:
javax.management.MBeanOperationInfo.getImpact()
javax.management.openmbean.OpenMBeanOperationInfo.getImpact()
javax.management.StandardMBean.getImpact(javax.management.MBeanOperationInfo)


Occurences of getImplementation

getImplementation occurences:
javax.management.StandardMBean.getImplementation()
org.w3c.dom.Document.getImplementation()


Occurences of getImplementationName

getImplementationName occurences:
javax.management.MBeanServerDelegate.getImplementationName()
javax.management.MBeanServerDelegateMBean.getImplementationName()


Occurences of getImplementationVendor

getImplementationVendor occurences:
java.lang.Package.getImplementationVendor()
javax.management.MBeanServerDelegate.getImplementationVendor()
javax.management.MBeanServerDelegateMBean.getImplementationVendor()


Occurences of getImplementationVersion

getImplementationVersion occurences:
java.lang.Package.getImplementationVersion()
javax.management.MBeanServerDelegate.getImplementationVersion()
javax.management.MBeanServerDelegateMBean.getImplementationVersion()


Occurences of getImplicitDownCycleTraversal

getImplicitDownCycleTraversal occurences:
java.awt.ContainerOrderFocusTraversalPolicy.getImplicitDownCycleTraversal()
javax.swing.SortingFocusTraversalPolicy.getImplicitDownCycleTraversal()


Occurences of getInactiveControlTextColor

getInactiveControlTextColor occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getInactiveControlTextColor()
javax.swing.plaf.metal.MetalTheme.getInactiveControlTextColor()
javax.swing.plaf.metal.OceanTheme.getInactiveControlTextColor()


Occurences of getInactiveSystemTextColor

getInactiveSystemTextColor occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getInactiveSystemTextColor()
javax.swing.plaf.metal.MetalTheme.getInactiveSystemTextColor()


Occurences of getIndex

getIndex occurences:
com.sun.source.tree.ArrayAccessTree.getIndex()
java.beans.IndexedPropertyChangeEvent.getIndex()
java.net.URISyntaxException.getIndex()
java.security.cert.CertPathValidatorException.getIndex()
java.sql.DataTruncation.getIndex()
java.text.CharacterIterator.getIndex()
java.text.ParsePosition.getIndex()
java.text.StringCharacterIterator.getIndex()
java.util.regex.PatternSyntaxException.getIndex()
javax.swing.event.DocumentEvent.ElementChange.getIndex()
javax.swing.JList.DropLocation.getIndex()
javax.swing.SizeSequence.getIndex(int)
javax.swing.text.AbstractDocument.AbstractElement.getIndex(javax.swing.tree.TreeNode)
javax.swing.text.AbstractDocument.ElementEdit.getIndex()
javax.swing.text.html.parser.Element.getIndex()
javax.swing.text.JTextComponent.DropLocation.getIndex()
javax.swing.text.Segment.getIndex()
javax.swing.tree.DefaultMutableTreeNode.getIndex(javax.swing.tree.TreeNode)
javax.swing.tree.TreeNode.getIndex(javax.swing.tree.TreeNode)
org.xml.sax.Attributes.getIndex(java.lang.String)
org.xml.sax.Attributes.getIndex(java.lang.String, java.lang.String)
org.xml.sax.helpers.AttributesImpl.getIndex(java.lang.String)
org.xml.sax.helpers.AttributesImpl.getIndex(java.lang.String, java.lang.String)


Occurences of getIndexAtPoint

getIndexAtPoint occurences:
java.awt.TextComponent.AccessibleAWTTextComponent.getIndexAtPoint(java.awt.Point)
javax.accessibility.AccessibleText.getIndexAtPoint(java.awt.Point)
javax.swing.AbstractButton.AccessibleAbstractButton.getIndexAtPoint(java.awt.Point)
javax.swing.JLabel.AccessibleJLabel.getIndexAtPoint(java.awt.Point)
javax.swing.JSpinner.AccessibleJSpinner.getIndexAtPoint(java.awt.Point)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getIndexAtPoint(java.awt.Point)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getIndexAtPoint(java.awt.Point)


Occurences of getIndexOf

getIndexOf occurences:
javax.swing.DefaultComboBoxModel.getIndexOf(java.lang.Object)
javax.swing.JLayeredPane.getIndexOf(java.awt.Component)


Occurences of getIndexOfChild

getIndexOfChild occurences:
javax.swing.tree.DefaultTreeModel.getIndexOfChild(java.lang.Object, java.lang.Object)
javax.swing.tree.TreeModel.getIndexOfChild(java.lang.Object, java.lang.Object)


Occurences of getInetAddress

getInetAddress occurences:
java.net.DatagramSocket.getInetAddress()
java.net.ServerSocket.getInetAddress()
java.net.Socket.getInetAddress()
java.net.SocketImpl.getInetAddress()


Occurences of getInfo

getInfo occurences:
java.security.Identity.getInfo()
java.security.Provider.getInfo()


Occurences of getInitialComponent

getInitialComponent occurences:
java.awt.FocusTraversalPolicy.getInitialComponent(java.awt.Window)
javax.swing.InternalFrameFocusTraversalPolicy.getInitialComponent(javax.swing.JInternalFrame)


Occurences of getInitialContext

getInitialContext occurences:
javax.naming.spi.InitialContextFactory.getInitialContext(java.util.Hashtable)
javax.naming.spi.NamingManager.getInitialContext(java.util.Hashtable)


Occurences of getInitialDelay

getInitialDelay occurences:
javax.swing.Timer.getInitialDelay()
javax.swing.ToolTipManager.getInitialDelay()


Occurences of getInitializer

getInitializer occurences:
com.sun.source.tree.ForLoopTree.getInitializer()
com.sun.source.tree.VariableTree.getInitializer()


Occurences of getInitThreshold

getInitThreshold occurences:
javax.management.monitor.CounterMonitor.getInitThreshold()
javax.management.monitor.CounterMonitorMBean.getInitThreshold()


Occurences of getInput

getInput occurences:
java.net.URISyntaxException.getInput()
javax.imageio.ImageReader.getInput()
org.w3c.dom.ls.LSLoadEvent.getInput()
org.w3c.dom.ls.LSProgressEvent.getInput()


Occurences of getInputAttributes

getInputAttributes occurences:
javax.swing.JTextPane.getInputAttributes()
javax.swing.text.html.HTMLEditorKit.getInputAttributes()
javax.swing.text.StyledEditorKit.getInputAttributes()


Occurences of getInputContext

getInputContext occurences:
java.awt.Component.getInputContext()
java.awt.Window.getInputContext()


Occurences of getInputEncoding

getInputEncoding occurences:
org.w3c.dom.Document.getInputEncoding()
org.w3c.dom.Entity.getInputEncoding()


Occurences of getInputLength

getInputLength occurences:
java.nio.charset.MalformedInputException.getInputLength()
java.nio.charset.UnmappableCharacterException.getInputLength()


Occurences of getInputMap

getInputMap occurences:
javax.swing.JComponent.getInputMap()
javax.swing.JComponent.getInputMap(int)


Occurences of getInputMethodRequests

getInputMethodRequests occurences:
Class ActiveClient.ActiveClient.getInputMethodRequests()
java.awt.Component.getInputMethodRequests()
java.awt.TextComponent.getInputMethodRequests()
javax.swing.text.JTextComponent.getInputMethodRequests()


Occurences of getInputStream

getInputStream occurences:
java.lang.Process.getInputStream()
java.net.Socket.getInputStream()
java.net.SocketImpl.getInputStream()
java.net.URLConnection.getInputStream()
java.rmi.server.RemoteCall.getInputStream()
java.util.jar.JarFile.getInputStream(java.util.zip.ZipEntry)
java.util.zip.ZipFile.getInputStream(java.util.zip.ZipEntry)
javax.activation.DataHandler.getInputStream()
javax.activation.DataSource.getInputStream()
javax.activation.FileDataSource.getInputStream()
javax.activation.URLDataSource.getInputStream()
javax.xml.transform.stream.StreamSource.getInputStream()
org.omg.CORBA.portable.ApplicationException.getInputStream()


Occurences of getInsertPositionOffset

getInsertPositionOffset occurences:
Class ActiveClient.ActiveClient.getInsertPositionOffset()
java.awt.im.InputMethodRequests.getInsertPositionOffset()


Occurences of getInsets

getInsets occurences:
java.awt.Container.getInsets()
javax.swing.JComponent.getInsets()
javax.swing.JComponent.getInsets(java.awt.Insets)
javax.swing.JViewport.getInsets()
javax.swing.JViewport.getInsets(java.awt.Insets)
javax.swing.plaf.basic.BasicComboBoxUI.getInsets()
javax.swing.plaf.basic.BasicDesktopIconUI.getInsets(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSplitPaneDivider.getInsets()
javax.swing.plaf.basic.BasicSplitPaneUI.getInsets(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolBarUI.DragWindow.getInsets()
javax.swing.plaf.synth.SynthStyle.getInsets(javax.swing.plaf.synth.SynthContext, java.awt.Insets)
javax.swing.UIDefaults.getInsets(java.lang.Object)
javax.swing.UIDefaults.getInsets(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getInsets(java.lang.Object)
javax.swing.UIManager.getInsets(java.lang.Object, java.util.Locale)


Occurences of getInstance

getInstance occurences:
java.awt.AlphaComposite.getInstance(int)
java.awt.AlphaComposite.getInstance(int, float)
java.awt.color.ColorSpace.getInstance(int)
java.awt.color.ICC_Profile.getInstance(byte[])
java.awt.color.ICC_Profile.getInstance(int)
java.awt.color.ICC_Profile.getInstance(java.io.InputStream)
java.awt.color.ICC_Profile.getInstance(java.lang.String)
java.awt.im.InputContext.getInstance()
java.security.AlgorithmParameterGenerator.getInstance(java.lang.String)
java.security.AlgorithmParameterGenerator.getInstance(java.lang.String, java.lang.String)
java.security.AlgorithmParameterGenerator.getInstance(java.lang.String, java.security.Provider)
java.security.AlgorithmParameters.getInstance(java.lang.String)
java.security.AlgorithmParameters.getInstance(java.lang.String, java.lang.String)
java.security.AlgorithmParameters.getInstance(java.lang.String, java.security.Provider)
java.security.cert.CertificateFactory.getInstance(java.lang.String)
java.security.cert.CertificateFactory.getInstance(java.lang.String, java.lang.String)
java.security.cert.CertificateFactory.getInstance(java.lang.String, java.security.Provider)
java.security.cert.CertPathBuilder.getInstance(java.lang.String)
java.security.cert.CertPathBuilder.getInstance(java.lang.String, java.lang.String)
java.security.cert.CertPathBuilder.getInstance(java.lang.String, java.security.Provider)
java.security.cert.CertPathValidator.getInstance(java.lang.String)
java.security.cert.CertPathValidator.getInstance(java.lang.String, java.lang.String)
java.security.cert.CertPathValidator.getInstance(java.lang.String, java.security.Provider)
java.security.cert.CertStore.getInstance(java.lang.String, java.security.cert.CertStoreParameters)
java.security.cert.CertStore.getInstance(java.lang.String, java.security.cert.CertStoreParameters, java.lang.String)
java.security.cert.CertStore.getInstance(java.lang.String, java.security.cert.CertStoreParameters, java.security.Provider)
java.security.KeyFactory.getInstance(java.lang.String)
java.security.KeyFactory.getInstance(java.lang.String, java.lang.String)
java.security.KeyFactory.getInstance(java.lang.String, java.security.Provider)
java.security.KeyPairGenerator.getInstance(java.lang.String)
java.security.KeyPairGenerator.getInstance(java.lang.String, java.lang.String)
java.security.KeyPairGenerator.getInstance(java.lang.String, java.security.Provider)
java.security.KeyStore.getInstance(java.lang.String)
java.security.KeyStore.getInstance(java.lang.String, java.lang.String)
java.security.KeyStore.getInstance(java.lang.String, java.security.Provider)
java.security.MessageDigest.getInstance(java.lang.String)
java.security.MessageDigest.getInstance(java.lang.String, java.lang.String)
java.security.MessageDigest.getInstance(java.lang.String, java.security.Provider)
java.security.Policy.getInstance(java.lang.String, java.security.Policy.Parameters)
java.security.Policy.getInstance(java.lang.String, java.security.Policy.Parameters, java.lang.String)
java.security.Policy.getInstance(java.lang.String, java.security.Policy.Parameters, java.security.Provider)
java.security.SecureRandom.getInstance(java.lang.String)
java.security.SecureRandom.getInstance(java.lang.String, java.lang.String)
java.security.SecureRandom.getInstance(java.lang.String, java.security.Provider)
java.security.Signature.getInstance(java.lang.String)
java.security.Signature.getInstance(java.lang.String, java.lang.String)
java.security.Signature.getInstance(java.lang.String, java.security.Provider)
java.text.Collator.getInstance()
java.text.Collator.getInstance(java.util.Locale)
java.text.DateFormat.getInstance()
java.text.DateFormatSymbols.getInstance()
java.text.DateFormatSymbols.getInstance(java.util.Locale)
java.text.DecimalFormatSymbols.getInstance()
java.text.DecimalFormatSymbols.getInstance(java.util.Locale)
java.text.NumberFormat.getInstance()
java.text.NumberFormat.getInstance(java.util.Locale)
java.text.spi.CollatorProvider.getInstance(java.util.Locale)
java.text.spi.DateFormatSymbolsProvider.getInstance(java.util.Locale)
java.text.spi.DecimalFormatSymbolsProvider.getInstance(java.util.Locale)
java.util.Calendar.getInstance()
java.util.Calendar.getInstance(java.util.Locale)
java.util.Calendar.getInstance(java.util.TimeZone)
java.util.Calendar.getInstance(java.util.TimeZone, java.util.Locale)
java.util.Currency.getInstance(java.lang.String)
java.util.Currency.getInstance(java.util.Locale)
javax.crypto.Cipher.getInstance(java.lang.String)
javax.crypto.Cipher.getInstance(java.lang.String, java.lang.String)
javax.crypto.Cipher.getInstance(java.lang.String, java.security.Provider)
javax.crypto.ExemptionMechanism.getInstance(java.lang.String)
javax.crypto.ExemptionMechanism.getInstance(java.lang.String, java.lang.String)
javax.crypto.ExemptionMechanism.getInstance(java.lang.String, java.security.Provider)
javax.crypto.KeyAgreement.getInstance(java.lang.String)
javax.crypto.KeyAgreement.getInstance(java.lang.String, java.lang.String)
javax.crypto.KeyAgreement.getInstance(java.lang.String, java.security.Provider)
javax.crypto.KeyGenerator.getInstance(java.lang.String)
javax.crypto.KeyGenerator.getInstance(java.lang.String, java.lang.String)
javax.crypto.KeyGenerator.getInstance(java.lang.String, java.security.Provider)
javax.crypto.Mac.getInstance(java.lang.String)
javax.crypto.Mac.getInstance(java.lang.String, java.lang.String)
javax.crypto.Mac.getInstance(java.lang.String, java.security.Provider)
javax.crypto.SecretKeyFactory.getInstance(java.lang.String)
javax.crypto.SecretKeyFactory.getInstance(java.lang.String, java.lang.String)
javax.crypto.SecretKeyFactory.getInstance(java.lang.String, java.security.Provider)
javax.management.ObjectName.getInstance(java.lang.String)
javax.management.ObjectName.getInstance(java.lang.String, java.lang.String, java.lang.String)
javax.management.ObjectName.getInstance(java.lang.String, java.util.Hashtable)
javax.management.ObjectName.getInstance(javax.management.ObjectName)
javax.net.ssl.KeyManagerFactory.getInstance(java.lang.String)
javax.net.ssl.KeyManagerFactory.getInstance(java.lang.String, java.lang.String)
javax.net.ssl.KeyManagerFactory.getInstance(java.lang.String, java.security.Provider)
javax.net.ssl.SSLContext.getInstance(java.lang.String)
javax.net.ssl.SSLContext.getInstance(java.lang.String, java.lang.String)
javax.net.ssl.SSLContext.getInstance(java.lang.String, java.security.Provider)
javax.net.ssl.TrustManagerFactory.getInstance(java.lang.String)
javax.net.ssl.TrustManagerFactory.getInstance(java.lang.String, java.lang.String)
javax.net.ssl.TrustManagerFactory.getInstance(java.lang.String, java.security.Provider)
javax.security.auth.login.Configuration.getInstance(java.lang.String, javax.security.auth.login.Configuration.Parameters)
javax.security.auth.login.Configuration.getInstance(java.lang.String, javax.security.auth.login.Configuration.Parameters, java.lang.String)
javax.security.auth.login.Configuration.getInstance(java.lang.String, javax.security.auth.login.Configuration.Parameters, java.security.Provider)
javax.security.cert.X509Certificate.getInstance(byte[])
javax.security.cert.X509Certificate.getInstance(java.io.InputStream)
javax.sql.rowset.spi.SyncFactory.getInstance(java.lang.String)
javax.swing.LayoutStyle.getInstance()
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.getInstance()
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.getInstance(java.lang.String)
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.getInstance(java.lang.String, java.lang.String)
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.getInstance(java.lang.String, java.security.Provider)
javax.xml.crypto.dsig.TransformService.getInstance(java.lang.String, java.lang.String)
javax.xml.crypto.dsig.TransformService.getInstance(java.lang.String, java.lang.String, java.lang.String)
javax.xml.crypto.dsig.TransformService.getInstance(java.lang.String, java.lang.String, java.security.Provider)
javax.xml.crypto.dsig.XMLSignatureFactory.getInstance()
javax.xml.crypto.dsig.XMLSignatureFactory.getInstance(java.lang.String)
javax.xml.crypto.dsig.XMLSignatureFactory.getInstance(java.lang.String, java.lang.String)
javax.xml.crypto.dsig.XMLSignatureFactory.getInstance(java.lang.String, java.security.Provider)
org.ietf.jgss.GSSManager.getInstance()


Occurences of getInt

getInt occurences:
java.lang.reflect.Array.getInt(java.lang.Object, int)
java.lang.reflect.Field.getInt(java.lang.Object)
java.nio.ByteBuffer.getInt()
java.nio.ByteBuffer.getInt(int)
java.sql.CallableStatement.getInt(int)
java.sql.CallableStatement.getInt(java.lang.String)
java.sql.ResultSet.getInt(int)
java.sql.ResultSet.getInt(java.lang.String)
java.util.prefs.AbstractPreferences.getInt(java.lang.String, int)
java.util.prefs.Preferences.getInt(java.lang.String, int)
javax.swing.plaf.synth.SynthStyle.getInt(javax.swing.plaf.synth.SynthContext, java.lang.Object, int)
javax.swing.UIDefaults.getInt(java.lang.Object)
javax.swing.UIDefaults.getInt(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getInt(java.lang.Object)
javax.swing.UIManager.getInt(java.lang.Object, java.util.Locale)


Occurences of getInteger

getInteger occurences:
java.lang.Integer.getInteger(java.lang.String)
java.lang.Integer.getInteger(java.lang.String, int)
java.lang.Integer.getInteger(java.lang.String, java.lang.Integer)


Occurences of getIntegerInstance

getIntegerInstance occurences:
java.text.NumberFormat.getIntegerInstance()
java.text.NumberFormat.getIntegerInstance(java.util.Locale)
java.text.spi.NumberFormatProvider.getIntegerInstance(java.util.Locale)


Occurences of getInterface

getInterface occurences:
java.net.MulticastSocket.getInterface()
javax.script.Invocable.getInterface(java.lang.Class)
javax.script.Invocable.getInterface(java.lang.Object, java.lang.Class)


Occurences of getInterfaces

getInterfaces occurences:
com.sun.mirror.declaration.PackageDeclaration.getInterfaces()
java.lang.Class.getInterfaces()
javax.lang.model.element.TypeElement.getInterfaces()


Occurences of getInteriorRectangle

getInteriorRectangle occurences:
javax.swing.border.AbstractBorder.getInteriorRectangle(java.awt.Component, int, int, int, int)
javax.swing.border.AbstractBorder.getInteriorRectangle(java.awt.Component, javax.swing.border.Border, int, int, int, int)


Occurences of getInternalFrame

getInternalFrame occurences:
javax.swing.event.InternalFrameEvent.getInternalFrame()
javax.swing.JInternalFrame.JDesktopIcon.getInternalFrame()


Occurences of getIssuerDN

getIssuerDN occurences:
java.security.cert.X509Certificate.getIssuerDN()
java.security.cert.X509CRL.getIssuerDN()
javax.security.cert.X509Certificate.getIssuerDN()


Occurences of getIssuerX500Principal

getIssuerX500Principal occurences:
java.security.cert.X509Certificate.getIssuerX500Principal()
java.security.cert.X509CRL.getIssuerX500Principal()


Occurences of getItem

getItem occurences:
java.awt.Choice.getItem(int)
java.awt.event.ItemEvent.getItem()
java.awt.List.getItem(int)
java.awt.Menu.getItem(int)
javax.swing.ComboBoxEditor.getItem()
javax.swing.JMenu.getItem(int)
javax.swing.plaf.basic.BasicComboBoxEditor.getItem()


Occurences of getItemCount

getItemCount occurences:
java.awt.Choice.getItemCount()
java.awt.List.getItemCount()
java.awt.Menu.getItemCount()
javax.swing.JComboBox.getItemCount()
javax.swing.JMenu.getItemCount()


Occurences of getItemListeners

getItemListeners occurences:
java.awt.Checkbox.getItemListeners()
java.awt.CheckboxMenuItem.getItemListeners()
java.awt.Choice.getItemListeners()
java.awt.List.getItemListeners()
javax.swing.AbstractButton.getItemListeners()
javax.swing.DefaultButtonModel.getItemListeners()
javax.swing.JComboBox.getItemListeners()


Occurences of getIterationCount

getIterationCount occurences:
javax.crypto.interfaces.PBEKey.getIterationCount()
javax.crypto.spec.PBEKeySpec.getIterationCount()
javax.crypto.spec.PBEParameterSpec.getIterationCount()


Occurences of getIterator

getIterator occurences:
java.text.AttributedString.getIterator()
java.text.AttributedString.getIterator(java.text.AttributedCharacterIterator.Attribute[])
java.text.AttributedString.getIterator(java.text.AttributedCharacterIterator.Attribute[], int, int)
javax.swing.text.html.HTMLDocument.getIterator(javax.swing.text.html.HTML.Tag)


Occurences of getIV

getIV occurences:
javax.crypto.Cipher.getIV()
javax.crypto.spec.IvParameterSpec.getIV()
javax.crypto.spec.RC2ParameterSpec.getIV()
javax.crypto.spec.RC5ParameterSpec.getIV()


Occurences of getJarEntry

getJarEntry occurences:
java.net.JarURLConnection.getJarEntry()
java.util.jar.JarFile.getJarEntry(java.lang.String)


Occurences of getJavaFileForInput

getJavaFileForInput occurences:
javax.tools.ForwardingJavaFileManager.getJavaFileForInput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind)
javax.tools.JavaFileManager.getJavaFileForInput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind)


Occurences of getJavaFileForOutput

getJavaFileForOutput occurences:
javax.tools.ForwardingJavaFileManager.getJavaFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind, javax.tools.FileObject)
javax.tools.JavaFileManager.getJavaFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind, javax.tools.FileObject)


Occurences of getJavaFileObjects

getJavaFileObjects occurences:
javax.tools.StandardJavaFileManager.getJavaFileObjects(java.io.File...)
javax.tools.StandardJavaFileManager.getJavaFileObjects(java.lang.String...)


Occurences of getJavaInitializationString

getJavaInitializationString occurences:
java.beans.PropertyEditor.getJavaInitializationString()
java.beans.PropertyEditorSupport.getJavaInitializationString()


Occurences of getJAXBNode

getJAXBNode occurences:
javax.xml.bind.Binder.getJAXBNode(java.lang.Object)
javax.xml.bind.Binder.getJAXBNode(XmlNode)


Occurences of getJMenuBar

getJMenuBar occurences:
javax.swing.JApplet.getJMenuBar()
javax.swing.JDialog.getJMenuBar()
javax.swing.JFrame.getJMenuBar()
javax.swing.JInternalFrame.getJMenuBar()
javax.swing.JRootPane.getJMenuBar()


Occurences of getKey

getKey occurences:
java.awt.MenuShortcut.getKey()
java.security.KeyStore.getKey(java.lang.String, char[])
java.util.AbstractMap.SimpleEntry.getKey()
java.util.AbstractMap.SimpleImmutableEntry.getKey()
java.util.Map.Entry.getKey()
java.util.MissingResourceException.getKey()
java.util.prefs.PreferenceChangeEvent.getKey()
javax.accessibility.AccessibleRelation.getKey()
javax.crypto.spec.DESedeKeySpec.getKey()
javax.crypto.spec.DESKeySpec.getKey()
javax.xml.crypto.KeySelectorResult.getKey()


Occurences of getKeyChar

getKeyChar occurences:
java.awt.AWTKeyStroke.getKeyChar()
java.awt.event.KeyEvent.getKeyChar()


Occurences of getKeyCode

getKeyCode occurences:
java.awt.AWTKeyStroke.getKeyCode()
java.awt.event.KeyEvent.getKeyCode()


Occurences of getKeyListener

getKeyListener occurences:
javax.swing.plaf.basic.BasicComboPopup.getKeyListener()
javax.swing.plaf.basic.ComboPopup.getKeyListener()


Occurences of getKeymap

getKeymap occurences:
javax.swing.text.JTextComponent.getKeymap()
javax.swing.text.JTextComponent.getKeymap(java.lang.String)


Occurences of getKeys

getKeys occurences:
java.util.ListResourceBundle.getKeys()
java.util.PropertyResourceBundle.getKeys()
java.util.ResourceBundle.getKeys()
javax.swing.AbstractAction.getKeys()


Occurences of getKeySelector

getKeySelector occurences:
javax.xml.crypto.dom.DOMCryptoContext.getKeySelector()
javax.xml.crypto.XMLCryptoContext.getKeySelector()


Occurences of getKeySpec

getKeySpec occurences:
java.security.KeyFactory.getKeySpec(java.security.Key, java.lang.Class)
javax.crypto.EncryptedPrivateKeyInfo.getKeySpec(java.security.Key)
javax.crypto.EncryptedPrivateKeyInfo.getKeySpec(java.security.Key, java.lang.String)
javax.crypto.EncryptedPrivateKeyInfo.getKeySpec(java.security.Key, java.security.Provider)
javax.crypto.EncryptedPrivateKeyInfo.getKeySpec(javax.crypto.Cipher)
javax.crypto.SecretKeyFactory.getKeySpec(javax.crypto.SecretKey, java.lang.Class)


Occurences of getKeyStroke

getKeyStroke occurences:
javax.swing.KeyStroke.getKeyStroke(char)
javax.swing.KeyStroke.getKeyStroke(char, boolean)
javax.swing.KeyStroke.getKeyStroke(int, int)
javax.swing.KeyStroke.getKeyStroke(int, int, boolean)
javax.swing.KeyStroke.getKeyStroke(java.lang.Character, int)
javax.swing.KeyStroke.getKeyStroke(java.lang.String)


Occurences of getKeyUsage

getKeyUsage occurences:
java.security.cert.X509Certificate.getKeyUsage()
java.security.cert.X509CertSelector.getKeyUsage()


Occurences of getKind

getKind occurences:
com.sun.mirror.type.PrimitiveType.getKind()
com.sun.source.tree.Tree.getKind()
com.sun.source.util.TaskEvent.getKind()
javax.lang.model.element.Element.getKind()
javax.lang.model.type.TypeMirror.getKind()
javax.tools.Diagnostic.getKind()
javax.tools.ForwardingJavaFileObject.getKind()
javax.tools.JavaFileObject.getKind()
javax.tools.SimpleJavaFileObject.getKind()


Occurences of getLabel

getLabel occurences:
com.sun.source.tree.BreakTree.getLabel()
com.sun.source.tree.ContinueTree.getLabel()
com.sun.source.tree.LabeledStatementTree.getLabel()
java.awt.Button.getLabel()
java.awt.Checkbox.getLabel()
java.awt.MenuItem.getLabel()
javax.swing.AbstractButton.getLabel()
javax.swing.JPopupMenu.getLabel()
javax.swing.text.html.Option.getLabel()


Occurences of getLast

getLast occurences:
java.util.ArrayDeque.getLast()
java.util.concurrent.LinkedBlockingDeque.getLast()
java.util.Deque.getLast()
java.util.LinkedList.getLast()


Occurences of getLastChild

getLastChild occurences:
javax.imageio.metadata.IIOMetadataNode.getLastChild()
javax.swing.tree.DefaultMutableTreeNode.getLastChild()
org.w3c.dom.Node.getLastChild()


Occurences of getLastColumn

getLastColumn occurences:
javax.accessibility.AccessibleTableModelChange.getLastColumn()
javax.swing.JTable.AccessibleJTable.AccessibleJTableModelChange.getLastColumn()


Occurences of getLastComponent

getLastComponent occurences:
java.awt.ContainerOrderFocusTraversalPolicy.getLastComponent(java.awt.Container)
java.awt.FocusTraversalPolicy.getLastComponent(java.awt.Container)
javax.swing.DefaultFocusManager.getLastComponent(java.awt.Container)
javax.swing.LayoutFocusTraversalPolicy.getLastComponent(java.awt.Container)
javax.swing.SortingFocusTraversalPolicy.getLastComponent(java.awt.Container)


Occurences of getLastModified

getLastModified occurences:
java.net.URLConnection.getLastModified()
javax.tools.FileObject.getLastModified()
javax.tools.ForwardingFileObject.getLastModified()
javax.tools.SimpleJavaFileObject.getLastModified()


Occurences of getLastRow

getLastRow occurences:
javax.accessibility.AccessibleTableModelChange.getLastRow()
javax.swing.event.TableModelEvent.getLastRow()
javax.swing.JTable.AccessibleJTable.AccessibleJTableModelChange.getLastRow()


Occurences of getLayer

getLayer occurences:
javax.swing.JInternalFrame.getLayer()
javax.swing.JLayeredPane.getLayer(java.awt.Component)
javax.swing.JLayeredPane.getLayer(javax.swing.JComponent)


Occurences of getLayeredPane

getLayeredPane occurences:
javax.swing.JApplet.getLayeredPane()
javax.swing.JDialog.getLayeredPane()
javax.swing.JFrame.getLayeredPane()
javax.swing.JInternalFrame.getLayeredPane()
javax.swing.JRootPane.getLayeredPane()
javax.swing.JWindow.getLayeredPane()
javax.swing.RootPaneContainer.getLayeredPane()


Occurences of getLayout

getLayout occurences:
java.awt.Container.getLayout()
java.awt.font.TextMeasurer.getLayout(int, int)


Occurences of getLayoutAlignmentX

getLayoutAlignmentX occurences:
java.awt.BorderLayout.getLayoutAlignmentX(java.awt.Container)
java.awt.CardLayout.getLayoutAlignmentX(java.awt.Container)
java.awt.GridBagLayout.getLayoutAlignmentX(java.awt.Container)
java.awt.LayoutManager2.getLayoutAlignmentX(java.awt.Container)
javax.swing.BoxLayout.getLayoutAlignmentX(java.awt.Container)
javax.swing.GroupLayout.getLayoutAlignmentX(java.awt.Container)
javax.swing.JRootPane.RootLayout.getLayoutAlignmentX(java.awt.Container)
javax.swing.OverlayLayout.getLayoutAlignmentX(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.getLayoutAlignmentX(java.awt.Container)
javax.swing.SpringLayout.getLayoutAlignmentX(java.awt.Container)


Occurences of getLayoutAlignmentY

getLayoutAlignmentY occurences:
java.awt.BorderLayout.getLayoutAlignmentY(java.awt.Container)
java.awt.CardLayout.getLayoutAlignmentY(java.awt.Container)
java.awt.GridBagLayout.getLayoutAlignmentY(java.awt.Container)
java.awt.LayoutManager2.getLayoutAlignmentY(java.awt.Container)
javax.swing.BoxLayout.getLayoutAlignmentY(java.awt.Container)
javax.swing.GroupLayout.getLayoutAlignmentY(java.awt.Container)
javax.swing.JRootPane.RootLayout.getLayoutAlignmentY(java.awt.Container)
javax.swing.OverlayLayout.getLayoutAlignmentY(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.getLayoutAlignmentY(java.awt.Container)
javax.swing.SpringLayout.getLayoutAlignmentY(java.awt.Container)


Occurences of getLayoutComponent

getLayoutComponent occurences:
java.awt.BorderLayout.getLayoutComponent(java.awt.Container, java.lang.Object)
java.awt.BorderLayout.getLayoutComponent(java.lang.Object)


Occurences of getLayoutStyle

getLayoutStyle occurences:
javax.swing.GroupLayout.getLayoutStyle()
javax.swing.LookAndFeel.getLayoutStyle()
javax.swing.plaf.metal.MetalLookAndFeel.getLayoutStyle()


Occurences of getLeading

getLeading occurences:
java.awt.font.LineMetrics.getLeading()
java.awt.font.TextLayout.getLeading()
java.awt.FontMetrics.getLeading()


Occurences of getLeadSelectionIndex

getLeadSelectionIndex occurences:
javax.swing.DefaultListSelectionModel.getLeadSelectionIndex()
javax.swing.JList.getLeadSelectionIndex()
javax.swing.ListSelectionModel.getLeadSelectionIndex()


Occurences of getLeadSelectionPath

getLeadSelectionPath occurences:
javax.swing.JTree.getLeadSelectionPath()
javax.swing.tree.DefaultTreeSelectionModel.getLeadSelectionPath()
javax.swing.tree.TreeSelectionModel.getLeadSelectionPath()


Occurences of getLeadSelectionRow

getLeadSelectionRow occurences:
javax.swing.JTree.getLeadSelectionRow()
javax.swing.tree.DefaultTreeSelectionModel.getLeadSelectionRow()
javax.swing.tree.TreeSelectionModel.getLeadSelectionRow()


Occurences of getLeastMaximum

getLeastMaximum occurences:
java.util.Calendar.getLeastMaximum(int)
java.util.GregorianCalendar.getLeastMaximum(int)


Occurences of getLeftInset

getLeftInset occurences:
javax.swing.text.AsyncBoxView.getLeftInset()
javax.swing.text.CompositeView.getLeftInset()


Occurences of getLegalValues

getLegalValues occurences:
javax.management.openmbean.OpenMBeanAttributeInfoSupport.getLegalValues()
javax.management.openmbean.OpenMBeanParameterInfo.getLegalValues()
javax.management.openmbean.OpenMBeanParameterInfoSupport.getLegalValues()


Occurences of getLength

getLength occurences:
java.lang.reflect.Array.getLength(java.lang.Object)
java.net.DatagramPacket.getLength()
java.text.Bidi.getLength()
javax.imageio.metadata.IIOMetadataNode.getLength()
javax.imageio.stream.IIOByteBuffer.getLength()
javax.sound.midi.MidiMessage.getLength()
javax.swing.event.DocumentEvent.getLength()
javax.swing.text.AbstractDocument.getLength()
javax.swing.text.AbstractDocument.DefaultDocumentEvent.getLength()
javax.swing.text.DefaultStyledDocument.ElementSpec.getLength()
javax.swing.text.Document.getLength()
org.w3c.dom.CharacterData.getLength()
org.w3c.dom.DOMImplementationList.getLength()
org.w3c.dom.DOMStringList.getLength()
org.w3c.dom.NamedNodeMap.getLength()
org.w3c.dom.NameList.getLength()
org.w3c.dom.NodeList.getLength()
org.xml.sax.AttributeList.getLength()
org.xml.sax.Attributes.getLength()
org.xml.sax.helpers.AttributeListImpl.getLength()
org.xml.sax.helpers.AttributesImpl.getLength()


Occurences of getLevel

getLevel occurences:
java.util.logging.Handler.getLevel()
java.util.logging.Logger.getLevel()
java.util.logging.LogRecord.getLevel()
javax.sound.sampled.DataLine.getLevel()
javax.swing.tree.DefaultMutableTreeNode.getLevel()


Occurences of getLibraryDirectory

getLibraryDirectory occurences:
javax.management.loading.MLet.getLibraryDirectory()
javax.management.loading.MLetMBean.getLibraryDirectory()


Occurences of getLine

getLine occurences:
javax.sound.sampled.AudioSystem.getLine(javax.sound.sampled.Line.Info)
javax.sound.sampled.LineEvent.getLine()
javax.sound.sampled.Mixer.getLine(javax.sound.sampled.Line.Info)


Occurences of getLineBuffer

getLineBuffer occurences:
javax.swing.text.PlainView.getLineBuffer()
javax.swing.text.WrappedPlainView.getLineBuffer()


Occurences of getLineInstance

getLineInstance occurences:
java.text.BreakIterator.getLineInstance()
java.text.BreakIterator.getLineInstance(java.util.Locale)
java.text.spi.BreakIteratorProvider.getLineInstance(java.util.Locale)


Occurences of getLineMetrics

getLineMetrics occurences:
java.awt.Font.getLineMetrics(char[], int, int, java.awt.font.FontRenderContext)
java.awt.Font.getLineMetrics(java.lang.String, int, int, java.awt.font.FontRenderContext)
java.awt.Font.getLineMetrics(java.lang.String, java.awt.font.FontRenderContext)
java.awt.Font.getLineMetrics(java.text.CharacterIterator, int, int, java.awt.font.FontRenderContext)
java.awt.FontMetrics.getLineMetrics(char[], int, int, java.awt.Graphics)
java.awt.FontMetrics.getLineMetrics(java.lang.String, int, int, java.awt.Graphics)
java.awt.FontMetrics.getLineMetrics(java.lang.String, java.awt.Graphics)
java.awt.FontMetrics.getLineMetrics(java.text.CharacterIterator, int, int, java.awt.Graphics)


Occurences of getLineNumber

getLineNumber occurences:
com.sun.source.tree.LineMap.getLineNumber(long)
java.io.LineNumberInputStream.getLineNumber()
java.io.LineNumberReader.getLineNumber()
java.lang.StackTraceElement.getLineNumber()
javax.script.ScriptException.getLineNumber()
javax.tools.Diagnostic.getLineNumber()
javax.xml.bind.helpers.ValidationEventLocatorImpl.getLineNumber()
javax.xml.bind.ValidationEventLocator.getLineNumber()
javax.xml.stream.Location.getLineNumber()
javax.xml.transform.SourceLocator.getLineNumber()
org.w3c.dom.DOMLocator.getLineNumber()
org.xml.sax.helpers.LocatorImpl.getLineNumber()
org.xml.sax.Locator.getLineNumber()
org.xml.sax.SAXParseException.getLineNumber()


Occurences of getLink

getLink occurences:
javax.accessibility.AccessibleHypertext.getLink(int)
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.getLink(int)


Occurences of getLinkCount

getLinkCount occurences:
javax.accessibility.AccessibleHypertext.getLinkCount()
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.getLinkCount()


Occurences of getLinkedException

getLinkedException occurences:
javax.xml.bind.helpers.ValidationEventImpl.getLinkedException()
javax.xml.bind.JAXBException.getLinkedException()
javax.xml.bind.TypeConstraintException.getLinkedException()
javax.xml.bind.ValidationEvent.getLinkedException()


Occurences of getLinkIndex

getLinkIndex occurences:
javax.accessibility.AccessibleHypertext.getLinkIndex(int)
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.getLinkIndex(int)


Occurences of getList

getList occurences:
javax.swing.plaf.basic.BasicComboPopup.getList()
javax.swing.plaf.basic.ComboPopup.getList()
javax.swing.SpinnerListModel.getList()


Occurences of getListCellRendererComponent

getListCellRendererComponent occurences:
javax.swing.DefaultListCellRenderer.getListCellRendererComponent(javax.swing.JList, java.lang.Object, int, boolean, boolean)
javax.swing.ListCellRenderer.getListCellRendererComponent(javax.swing.JList, java.lang.Object, int, boolean, boolean)
javax.swing.plaf.basic.BasicComboBoxRenderer.getListCellRendererComponent(javax.swing.JList, java.lang.Object, int, boolean, boolean)
javax.swing.plaf.metal.MetalFileChooserUI.FilterComboBoxRenderer.getListCellRendererComponent(javax.swing.JList, java.lang.Object, int, boolean, boolean)


Occurences of getListener

getListener occurences:
java.util.EventListenerProxy.getListener()
javax.xml.bind.helpers.AbstractMarshallerImpl.getListener()
javax.xml.bind.helpers.AbstractUnmarshallerImpl.getListener()
javax.xml.bind.Marshaller.getListener()
javax.xml.bind.Unmarshaller.getListener()


Occurences of getListenerCount

getListenerCount occurences:
javax.swing.event.EventListenerList.getListenerCount()
javax.swing.event.EventListenerList.getListenerCount(java.lang.Class)


Occurences of getListeners

getListeners occurences:
java.awt.AWTEventMulticaster.getListeners(java.util.EventListener, java.lang.Class)
java.awt.Button.getListeners(java.lang.Class)
java.awt.Checkbox.getListeners(java.lang.Class)
java.awt.CheckboxMenuItem.getListeners(java.lang.Class)
java.awt.Choice.getListeners(java.lang.Class)
java.awt.Component.getListeners(java.lang.Class)
java.awt.Container.getListeners(java.lang.Class)
java.awt.dnd.DragSource.getListeners(java.lang.Class)
java.awt.List.getListeners(java.lang.Class)
java.awt.MenuItem.getListeners(java.lang.Class)
java.awt.Scrollbar.getListeners(java.lang.Class)
java.awt.TextComponent.getListeners(java.lang.Class)
java.awt.TextField.getListeners(java.lang.Class)
java.awt.Window.getListeners(java.lang.Class)
javax.swing.AbstractListModel.getListeners(java.lang.Class)
javax.swing.AbstractSpinnerModel.getListeners(java.lang.Class)
javax.swing.DefaultBoundedRangeModel.getListeners(java.lang.Class)
javax.swing.DefaultButtonModel.getListeners(java.lang.Class)
javax.swing.DefaultListSelectionModel.getListeners(java.lang.Class)
javax.swing.DefaultSingleSelectionModel.getListeners(java.lang.Class)
javax.swing.event.EventListenerList.getListeners(java.lang.Class)
javax.swing.JComponent.getListeners(java.lang.Class)
javax.swing.table.AbstractTableModel.getListeners(java.lang.Class)
javax.swing.table.DefaultTableColumnModel.getListeners(java.lang.Class)
javax.swing.text.AbstractDocument.getListeners(java.lang.Class)
javax.swing.text.DefaultCaret.getListeners(java.lang.Class)
javax.swing.text.StyleContext.NamedStyle.getListeners(java.lang.Class)
javax.swing.Timer.getListeners(java.lang.Class)
javax.swing.tree.DefaultTreeModel.getListeners(java.lang.Class)
javax.swing.tree.DefaultTreeSelectionModel.getListeners(java.lang.Class)


Occurences of getListSelectionListeners

getListSelectionListeners occurences:
javax.swing.DefaultListSelectionModel.getListSelectionListeners()
javax.swing.JList.getListSelectionListeners()


Occurences of getLocalAddress

getLocalAddress occurences:
java.net.DatagramSocket.getLocalAddress()
java.net.Socket.getLocalAddress()


Occurences of getLocalCertificates

getLocalCertificates occurences:
javax.net.ssl.HandshakeCompletedEvent.getLocalCertificates()
javax.net.ssl.HttpsURLConnection.getLocalCertificates()
javax.net.ssl.SSLSession.getLocalCertificates()


Occurences of getLocale

getLocale occurences:
java.applet.Applet.getLocale()
java.awt.Component.getLocale()
java.awt.Component.AccessibleAWTComponent.getLocale()
java.awt.im.InputContext.getLocale()
java.awt.im.spi.InputMethod.getLocale()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getLocale()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getLocale()
java.awt.Window.getLocale()
java.beans.beancontext.BeanContextSupport.getLocale()
java.text.MessageFormat.getLocale()
java.util.ResourceBundle.getLocale()
javax.accessibility.AccessibleContext.getLocale()
javax.annotation.processing.ProcessingEnvironment.getLocale()
javax.imageio.ImageReader.getLocale()
javax.imageio.ImageWriteParam.getLocale()
javax.imageio.ImageWriter.getLocale()
javax.print.attribute.TextSyntax.getLocale()
javax.security.auth.callback.LanguageCallback.getLocale()
javax.swing.ImageIcon.AccessibleImageIcon.getLocale()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getLocale()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getLocale()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getLocale()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getLocale()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getLocale()


Occurences of getLocalName

getLocalName occurences:
javax.imageio.metadata.IIOMetadataNode.getLocalName()
javax.xml.soap.Name.getLocalName()
javax.xml.stream.util.StreamReaderDelegate.getLocalName()
javax.xml.stream.XMLStreamReader.getLocalName()
org.w3c.dom.Node.getLocalName()
org.xml.sax.Attributes.getLocalName(int)
org.xml.sax.helpers.AttributesImpl.getLocalName(int)


Occurences of getLocalPort

getLocalPort occurences:
java.net.DatagramSocket.getLocalPort()
java.net.DatagramSocketImpl.getLocalPort()
java.net.ServerSocket.getLocalPort()
java.net.Socket.getLocalPort()
java.net.SocketImpl.getLocalPort()


Occurences of getLocalPrincipal

getLocalPrincipal occurences:
java.net.SecureCacheResponse.getLocalPrincipal()
javax.net.ssl.HandshakeCompletedEvent.getLocalPrincipal()
javax.net.ssl.HttpsURLConnection.getLocalPrincipal()
javax.net.ssl.SSLSession.getLocalPrincipal()


Occurences of getLocalSocketAddress

getLocalSocketAddress occurences:
java.net.DatagramSocket.getLocalSocketAddress()
java.net.ServerSocket.getLocalSocketAddress()
java.net.Socket.getLocalSocketAddress()


Occurences of getLocation

getLocation occurences:
java.awt.Component.getLocation()
java.awt.Component.getLocation(java.awt.Point)
java.awt.Component.AccessibleAWTComponent.getLocation()
java.awt.dnd.DragSourceEvent.getLocation()
java.awt.dnd.DropTargetDragEvent.getLocation()
java.awt.dnd.DropTargetDropEvent.getLocation()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getLocation()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getLocation()
java.awt.Point.getLocation()
java.awt.PointerInfo.getLocation()
java.awt.Rectangle.getLocation()
java.net.HttpRetryException.getLocation()
java.rmi.activation.ActivationDesc.getLocation()
java.rmi.activation.ActivationGroupDesc.getLocation()
java.security.CodeSource.getLocation()
javax.accessibility.AccessibleComponent.getLocation()
javax.swing.JComponent.getLocation(java.awt.Point)
javax.swing.JList.AccessibleJList.AccessibleJListChild.getLocation()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getLocation()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getLocation()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getLocation()
javax.tools.StandardJavaFileManager.getLocation(javax.tools.JavaFileManager.Location)
javax.xml.stream.events.XMLEvent.getLocation()
javax.xml.stream.util.StreamReaderDelegate.getLocation()
javax.xml.stream.XMLStreamException.getLocation()
javax.xml.stream.XMLStreamReader.getLocation()
org.w3c.dom.DOMError.getLocation()


Occurences of getLocationOffset

getLocationOffset occurences:
Class ActiveClient.ActiveClient.getLocationOffset(int, int)
java.awt.im.InputMethodRequests.getLocationOffset(int, int)


Occurences of getLocationOnScreen

getLocationOnScreen occurences:
java.awt.Component.getLocationOnScreen()
java.awt.Component.AccessibleAWTComponent.getLocationOnScreen()
java.awt.event.MouseEvent.getLocationOnScreen()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getLocationOnScreen()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getLocationOnScreen()
javax.accessibility.AccessibleComponent.getLocationOnScreen()
javax.swing.JList.AccessibleJList.AccessibleJListChild.getLocationOnScreen()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getLocationOnScreen()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getLocationOnScreen()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getLocationOnScreen()


Occurences of getLocator

getLocator occurences:
javax.xml.bind.helpers.ValidationEventImpl.getLocator()
javax.xml.bind.ValidationEvent.getLocator()
javax.xml.transform.TransformerException.getLocator()


Occurences of getLogger

getLogger occurences:
java.util.logging.Logger.getLogger(java.lang.String)
java.util.logging.Logger.getLogger(java.lang.String, java.lang.String)
java.util.logging.LogManager.getLogger(java.lang.String)
javax.sql.rowset.spi.SyncFactory.getLogger()


Occurences of getLoggerNames

getLoggerNames occurences:
java.util.logging.LoggingMXBean.getLoggerNames()
java.util.logging.LogManager.getLoggerNames()


Occurences of getLogicalHighlightShape

getLogicalHighlightShape occurences:
java.awt.font.TextLayout.getLogicalHighlightShape(int, int)
java.awt.font.TextLayout.getLogicalHighlightShape(int, int, java.awt.geom.Rectangle2D)


Occurences of getLogicalStyle

getLogicalStyle occurences:
javax.swing.JTextPane.getLogicalStyle()
javax.swing.text.DefaultStyledDocument.getLogicalStyle(int)
javax.swing.text.StyledDocument.getLogicalStyle(int)


Occurences of getLoginTimeout

getLoginTimeout occurences:
java.sql.DriverManager.getLoginTimeout()
javax.sql.CommonDataSource.getLoginTimeout()


Occurences of getLogWriter

getLogWriter occurences:
java.sql.DriverManager.getLogWriter()
javax.sql.CommonDataSource.getLogWriter()


Occurences of getLong

getLong occurences:
java.lang.Long.getLong(java.lang.String)
java.lang.Long.getLong(java.lang.String, java.lang.Long)
java.lang.Long.getLong(java.lang.String, long)
java.lang.reflect.Array.getLong(java.lang.Object, int)
java.lang.reflect.Field.getLong(java.lang.Object)
java.nio.ByteBuffer.getLong()
java.nio.ByteBuffer.getLong(int)
java.sql.CallableStatement.getLong(int)
java.sql.CallableStatement.getLong(java.lang.String)
java.sql.ResultSet.getLong(int)
java.sql.ResultSet.getLong(java.lang.String)
java.util.prefs.AbstractPreferences.getLong(java.lang.String, long)
java.util.prefs.Preferences.getLong(java.lang.String, long)


Occurences of getLowerBounds

getLowerBounds occurences:
com.sun.mirror.type.WildcardType.getLowerBounds()
java.lang.reflect.WildcardType.getLowerBounds()


Occurences of getLowThreshold

getLowThreshold occurences:
javax.management.monitor.GaugeMonitor.getLowThreshold()
javax.management.monitor.GaugeMonitorMBean.getLowThreshold()


Occurences of getMagicCaretPosition

getMagicCaretPosition occurences:
javax.swing.text.Caret.getMagicCaretPosition()
javax.swing.text.DefaultCaret.getMagicCaretPosition()


Occurences of getMainAttributes

getMainAttributes occurences:
java.net.JarURLConnection.getMainAttributes()
java.util.jar.Manifest.getMainAttributes()


Occurences of getMajorVersion

getMajorVersion occurences:
java.awt.color.ICC_Profile.getMajorVersion()
java.sql.Driver.getMajorVersion()


Occurences of getManifest

getManifest occurences:
java.net.JarURLConnection.getManifest()
java.util.jar.JarFile.getManifest()
java.util.jar.JarInputStream.getManifest()


Occurences of getMargin

getMargin occurences:
javax.swing.AbstractButton.getMargin()
javax.swing.JMenuBar.getMargin()
javax.swing.JPopupMenu.getMargin()
javax.swing.JToolBar.getMargin()
javax.swing.text.JTextComponent.getMargin()


Occurences of getMark

getMark occurences:
javax.swing.event.CaretEvent.getMark()
javax.swing.text.Caret.getMark()
javax.swing.text.DefaultCaret.getMark()


Occurences of getMask

getMask occurences:
java.awt.image.PackedColorModel.getMask(int)
javax.swing.text.MaskFormatter.getMask()


Occurences of getMatchingMimeHeaders

getMatchingMimeHeaders occurences:
javax.xml.soap.AttachmentPart.getMatchingMimeHeaders(java.lang.String[])
javax.xml.soap.SOAPPart.getMatchingMimeHeaders(java.lang.String[])


Occurences of getMatrix

getMatrix occurences:
java.awt.color.ICC_ProfileRGB.getMatrix()
java.awt.geom.AffineTransform.getMatrix(double[])
java.awt.image.BandCombineOp.getMatrix()
java.awt.print.PageFormat.getMatrix()


Occurences of getMaxCharactersPerLineCount

getMaxCharactersPerLineCount occurences:
javax.swing.JOptionPane.getMaxCharactersPerLineCount()
javax.swing.plaf.basic.BasicOptionPaneUI.getMaxCharactersPerLineCount()


Occurences of getMaxCharBounds

getMaxCharBounds occurences:
java.awt.Font.getMaxCharBounds(java.awt.font.FontRenderContext)
java.awt.FontMetrics.getMaxCharBounds(java.awt.Graphics)


Occurences of getMaxFieldSize

getMaxFieldSize occurences:
java.sql.Statement.getMaxFieldSize()
javax.sql.RowSet.getMaxFieldSize()
javax.sql.rowset.BaseRowSet.getMaxFieldSize()


Occurences of getMaximum

getMaximum occurences:
java.awt.Adjustable.getMaximum()
java.awt.Scrollbar.getMaximum()
java.awt.ScrollPaneAdjustable.getMaximum()
java.util.Calendar.getMaximum(int)
java.util.GregorianCalendar.getMaximum(int)
javax.sound.sampled.FloatControl.getMaximum()
javax.swing.BoundedRangeModel.getMaximum()
javax.swing.DefaultBoundedRangeModel.getMaximum()
javax.swing.JProgressBar.getMaximum()
javax.swing.JScrollBar.getMaximum()
javax.swing.JSlider.getMaximum()
javax.swing.ProgressMonitor.getMaximum()
javax.swing.SpinnerNumberModel.getMaximum()
javax.swing.text.InternationalFormatter.getMaximum()


Occurences of getMaximumAccessibleValue

getMaximumAccessibleValue occurences:
java.awt.Button.AccessibleAWTButton.getMaximumAccessibleValue()
java.awt.Checkbox.AccessibleAWTCheckbox.getMaximumAccessibleValue()
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.getMaximumAccessibleValue()
java.awt.MenuItem.AccessibleAWTMenuItem.getMaximumAccessibleValue()
java.awt.Scrollbar.AccessibleAWTScrollBar.getMaximumAccessibleValue()
javax.accessibility.AccessibleValue.getMaximumAccessibleValue()
javax.swing.AbstractButton.AccessibleAbstractButton.getMaximumAccessibleValue()
javax.swing.JInternalFrame.AccessibleJInternalFrame.getMaximumAccessibleValue()
javax.swing.JInternalFrame.JDesktopIcon.AccessibleJDesktopIcon.getMaximumAccessibleValue()
javax.swing.JProgressBar.AccessibleJProgressBar.getMaximumAccessibleValue()
javax.swing.JScrollBar.AccessibleJScrollBar.getMaximumAccessibleValue()
javax.swing.JSlider.AccessibleJSlider.getMaximumAccessibleValue()
javax.swing.JSpinner.AccessibleJSpinner.getMaximumAccessibleValue()
javax.swing.JSplitPane.AccessibleJSplitPane.getMaximumAccessibleValue()


Occurences of getMaximumDividerLocation

getMaximumDividerLocation occurences:
javax.swing.JSplitPane.getMaximumDividerLocation()
javax.swing.plaf.basic.BasicSplitPaneUI.getMaximumDividerLocation(javax.swing.JSplitPane)
javax.swing.plaf.multi.MultiSplitPaneUI.getMaximumDividerLocation(javax.swing.JSplitPane)
javax.swing.plaf.SplitPaneUI.getMaximumDividerLocation(javax.swing.JSplitPane)


Occurences of getMaximumFractionDigits

getMaximumFractionDigits occurences:
java.text.DecimalFormat.getMaximumFractionDigits()
java.text.NumberFormat.getMaximumFractionDigits()


Occurences of getMaximumIntegerDigits

getMaximumIntegerDigits occurences:
java.text.DecimalFormat.getMaximumIntegerDigits()
java.text.NumberFormat.getMaximumIntegerDigits()


Occurences of getMaximumSize

getMaximumSize occurences:
java.awt.Component.getMaximumSize()
java.awt.Container.getMaximumSize()
javax.swing.JComponent.getMaximumSize()
javax.swing.JScrollBar.getMaximumSize()
javax.swing.JToolBar.Separator.getMaximumSize()
javax.swing.plaf.basic.BasicArrowButton.getMaximumSize()
javax.swing.plaf.basic.BasicButtonUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicComboBoxUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopIconUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicInternalFrameUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicLabelUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuBarUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuItemUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicProgressBarUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollBarUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSeparatorUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSplitPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTabbedPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableHeaderUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolTipUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.ComponentUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalDesktopIconUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalFileChooserUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollButton.getMaximumSize()
javax.swing.plaf.multi.MultiButtonUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.getMaximumSize(javax.swing.JComponent)
javax.swing.plaf.synth.SynthGraphicsUtils.getMaximumSize(javax.swing.plaf.synth.SynthContext, java.awt.Font, java.lang.String, javax.swing.Icon, int, int, int, int, int, int)


Occurences of getMaximumSpan

getMaximumSpan occurences:
javax.swing.text.AsyncBoxView.getMaximumSpan(int)
javax.swing.text.BoxView.getMaximumSpan(int)
javax.swing.text.ComponentView.getMaximumSpan(int)
javax.swing.text.html.BlockView.getMaximumSpan(int)
javax.swing.text.html.FormView.getMaximumSpan(int)
javax.swing.text.html.ParagraphView.getMaximumSpan(int)
javax.swing.text.View.getMaximumSpan(int)
javax.swing.text.WrappedPlainView.getMaximumSpan(int)


Occurences of getMaxRows

getMaxRows occurences:
java.sql.Statement.getMaxRows()
javax.sql.RowSet.getMaxRows()
javax.sql.rowset.BaseRowSet.getMaxRows()


Occurences of getMaxSelectionIndex

getMaxSelectionIndex occurences:
javax.swing.DefaultListSelectionModel.getMaxSelectionIndex()
javax.swing.JList.getMaxSelectionIndex()
javax.swing.ListSelectionModel.getMaxSelectionIndex()


Occurences of getMaxSelectionRow

getMaxSelectionRow occurences:
javax.swing.JTree.getMaxSelectionRow()
javax.swing.tree.DefaultTreeSelectionModel.getMaxSelectionRow()
javax.swing.tree.TreeSelectionModel.getMaxSelectionRow()


Occurences of getMaxValue

getMaxValue occurences:
java.awt.color.ColorSpace.getMaxValue(int)
java.awt.color.ICC_ColorSpace.getMaxValue(int)
javax.management.openmbean.OpenMBeanAttributeInfoSupport.getMaxValue()
javax.management.openmbean.OpenMBeanParameterInfo.getMaxValue()
javax.management.openmbean.OpenMBeanParameterInfoSupport.getMaxValue()


Occurences of getMBeanCount

getMBeanCount occurences:
javax.management.MBeanServer.getMBeanCount()
javax.management.MBeanServerConnection.getMBeanCount()
javax.management.remote.rmi.RMIConnection.getMBeanCount(javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.getMBeanCount(javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.getMBeanCount(javax.security.auth.Subject)


Occurences of getMBeanDescriptor

getMBeanDescriptor occurences:
javax.management.modelmbean.ModelMBeanInfo.getMBeanDescriptor()
javax.management.modelmbean.ModelMBeanInfoSupport.getMBeanDescriptor()


Occurences of getMBeanInfo

getMBeanInfo occurences:
javax.management.DynamicMBean.getMBeanInfo()
javax.management.MBeanServer.getMBeanInfo(javax.management.ObjectName)
javax.management.MBeanServerConnection.getMBeanInfo(javax.management.ObjectName)
javax.management.modelmbean.RequiredModelMBean.getMBeanInfo()
javax.management.remote.rmi.RMIConnection.getMBeanInfo(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.getMBeanInfo(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.getMBeanInfo(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.StandardMBean.getMBeanInfo()


Occurences of getMBeanServer

getMBeanServer occurences:
javax.management.QueryEval.getMBeanServer()
javax.management.remote.JMXConnectorServer.getMBeanServer()
javax.management.remote.MBeanServerForwarder.getMBeanServer()
javax.management.remote.rmi.RMIServerImpl.getMBeanServer()


Occurences of getMBeanServerConnection

getMBeanServerConnection occurences:
com.sun.tools.jconsole.JConsoleContext.getMBeanServerConnection()
javax.management.MBeanServerInvocationHandler.getMBeanServerConnection()
javax.management.remote.JMXConnector.getMBeanServerConnection()
javax.management.remote.JMXConnector.getMBeanServerConnection(javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnector.getMBeanServerConnection()
javax.management.remote.rmi.RMIConnector.getMBeanServerConnection(javax.security.auth.Subject)


Occurences of getMBeanServerId

getMBeanServerId occurences:
javax.management.MBeanServerDelegate.getMBeanServerId()
javax.management.MBeanServerDelegateMBean.getMBeanServerId()


Occurences of getMBeansFromURL

getMBeansFromURL occurences:
javax.management.loading.MLet.getMBeansFromURL(java.lang.String)
javax.management.loading.MLet.getMBeansFromURL(java.net.URL)
javax.management.loading.MLetMBean.getMBeansFromURL(java.lang.String)
javax.management.loading.MLetMBean.getMBeansFromURL(java.net.URL)


Occurences of getMechanismName

getMechanismName occurences:
javax.security.sasl.SaslClient.getMechanismName()
javax.security.sasl.SaslServer.getMechanismName()


Occurences of getMechanismNames

getMechanismNames occurences:
javax.security.sasl.SaslClientFactory.getMechanismNames(java.util.Map)
javax.security.sasl.SaslServerFactory.getMechanismNames(java.util.Map)


Occurences of getMechanismType

getMechanismType occurences:
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.getMechanismType()
javax.xml.crypto.dsig.TransformService.getMechanismType()
javax.xml.crypto.dsig.XMLSignatureFactory.getMechanismType()


Occurences of getMechs

getMechs occurences:
org.ietf.jgss.GSSCredential.getMechs()
org.ietf.jgss.GSSManager.getMechs()


Occurences of getMediaWhitePoint

getMediaWhitePoint occurences:
java.awt.color.ICC_ProfileGray.getMediaWhitePoint()
java.awt.color.ICC_ProfileRGB.getMediaWhitePoint()


Occurences of getMembers

getMembers occurences:
com.sun.source.tree.ClassTree.getMembers()
javax.print.attribute.SetOfIntegerSyntax.getMembers()


Occurences of getMenu

getMenu occurences:
java.awt.MenuBar.getMenu(int)
javax.swing.JMenuBar.getMenu(int)


Occurences of getMenuArrowIcon

getMenuArrowIcon occurences:
javax.swing.plaf.basic.BasicIconFactory.getMenuArrowIcon()
javax.swing.plaf.metal.MetalIconFactory.getMenuArrowIcon()


Occurences of getMenuBackground

getMenuBackground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getMenuBackground()
javax.swing.plaf.metal.MetalTheme.getMenuBackground()


Occurences of getMenuBar

getMenuBar occurences:
java.awt.Frame.getMenuBar()
javax.swing.JInternalFrame.getMenuBar()
javax.swing.JRootPane.getMenuBar()


Occurences of getMenuCount

getMenuCount occurences:
java.awt.MenuBar.getMenuCount()
javax.swing.JMenuBar.getMenuCount()


Occurences of getMenuDisabledForeground

getMenuDisabledForeground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getMenuDisabledForeground()
javax.swing.plaf.metal.MetalTheme.getMenuDisabledForeground()
javax.swing.plaf.metal.OceanTheme.getMenuDisabledForeground()


Occurences of getMenuForeground

getMenuForeground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getMenuForeground()
javax.swing.plaf.metal.MetalTheme.getMenuForeground()


Occurences of getMenuItemArrowIcon

getMenuItemArrowIcon occurences:
javax.swing.plaf.basic.BasicIconFactory.getMenuItemArrowIcon()
javax.swing.plaf.metal.MetalIconFactory.getMenuItemArrowIcon()


Occurences of getMenuItemCheckIcon

getMenuItemCheckIcon occurences:
javax.swing.plaf.basic.BasicIconFactory.getMenuItemCheckIcon()
javax.swing.plaf.metal.MetalIconFactory.getMenuItemCheckIcon()


Occurences of getMenuKeyListeners

getMenuKeyListeners occurences:
javax.swing.JMenuItem.getMenuKeyListeners()
javax.swing.JPopupMenu.getMenuKeyListeners()


Occurences of getMenuSelectedBackground

getMenuSelectedBackground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getMenuSelectedBackground()
javax.swing.plaf.metal.MetalTheme.getMenuSelectedBackground()


Occurences of getMenuSelectedForeground

getMenuSelectedForeground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getMenuSelectedForeground()
javax.swing.plaf.metal.MetalTheme.getMenuSelectedForeground()


Occurences of getMenuSelectionManager

getMenuSelectionManager occurences:
javax.swing.event.MenuDragMouseEvent.getMenuSelectionManager()
javax.swing.event.MenuKeyEvent.getMenuSelectionManager()


Occurences of getMenuTextFont

getMenuTextFont occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getMenuTextFont()
javax.swing.plaf.metal.MetalLookAndFeel.getMenuTextFont()
javax.swing.plaf.metal.MetalTheme.getMenuTextFont()


Occurences of getMessage

getMessage occurences:
java.awt.HeadlessException.getMessage()
java.io.InvalidClassException.getMessage()
java.io.WriteAbortedException.getMessage()
java.lang.Throwable.getMessage()
java.net.URISyntaxException.getMessage()
java.nio.charset.MalformedInputException.getMessage()
java.nio.charset.UnmappableCharacterException.getMessage()
java.rmi.activation.ActivationException.getMessage()
java.rmi.RemoteException.getMessage()
java.rmi.server.ServerCloneException.getMessage()
java.util.DuplicateFormatFlagsException.getMessage()
java.util.FormatFlagsConversionMismatchException.getMessage()
java.util.IllegalFormatCodePointException.getMessage()
java.util.IllegalFormatConversionException.getMessage()
java.util.IllegalFormatFlagsException.getMessage()
java.util.IllegalFormatPrecisionException.getMessage()
java.util.IllegalFormatWidthException.getMessage()
java.util.logging.LogRecord.getMessage()
java.util.MissingFormatArgumentException.getMessage()
java.util.MissingFormatWidthException.getMessage()
java.util.regex.PatternSyntaxException.getMessage()
java.util.UnknownFormatConversionException.getMessage()
java.util.UnknownFormatFlagsException.getMessage()
javax.annotation.processing.Completion.getMessage()
javax.management.Notification.getMessage()
javax.script.ScriptException.getMessage()
javax.security.auth.callback.TextOutputCallback.getMessage()
javax.sound.midi.MidiEvent.getMessage()
javax.sound.midi.MidiMessage.getMessage()
javax.swing.JOptionPane.getMessage()
javax.swing.plaf.basic.BasicOptionPaneUI.getMessage()
javax.tools.Diagnostic.getMessage(java.util.Locale)
javax.xml.bind.helpers.ValidationEventImpl.getMessage()
javax.xml.bind.ValidationEvent.getMessage()
javax.xml.parsers.FactoryConfigurationError.getMessage()
javax.xml.soap.SOAPException.getMessage()
javax.xml.stream.FactoryConfigurationError.getMessage()
javax.xml.transform.TransformerFactoryConfigurationError.getMessage()
javax.xml.ws.handler.LogicalMessageContext.getMessage()
javax.xml.ws.handler.soap.SOAPMessageContext.getMessage()
org.ietf.jgss.GSSException.getMessage()
org.w3c.dom.DOMError.getMessage()
org.xml.sax.SAXException.getMessage()


Occurences of getMessageDigest

getMessageDigest occurences:
java.security.DigestInputStream.getMessageDigest()
java.security.DigestOutputStream.getMessageDigest()


Occurences of getMessager

getMessager occurences:
com.sun.mirror.apt.AnnotationProcessorEnvironment.getMessager()
javax.annotation.processing.ProcessingEnvironment.getMessager()


Occurences of getMessageType

getMessageType occurences:
javax.security.auth.callback.ConfirmationCallback.getMessageType()
javax.security.auth.callback.TextOutputCallback.getMessageType()
javax.swing.JOptionPane.getMessageType()


Occurences of getMetaData

getMetaData occurences:
java.sql.Connection.getMetaData()
java.sql.PreparedStatement.getMetaData()
java.sql.ResultSet.getMetaData()


Occurences of getMetadata

getMetadata occurences:
javax.imageio.IIOImage.getMetadata()
javax.xml.ws.Endpoint.getMetadata()


Occurences of getMethod

getMethod occurences:
java.beans.MethodDescriptor.getMethod()
java.lang.Class.getMethod(java.lang.String, java.lang.Class...)
java.util.zip.ZipEntry.getMethod()
javax.swing.text.html.FormSubmitEvent.getMethod()


Occurences of getMethodDescriptors

getMethodDescriptors occurences:
java.beans.BeanInfo.getMethodDescriptors()
java.beans.SimpleBeanInfo.getMethodDescriptors()


Occurences of getMethodName

getMethodName occurences:
java.beans.Statement.getMethodName()
java.lang.StackTraceElement.getMethodName()


Occurences of getMethods

getMethods occurences:
com.sun.mirror.declaration.AnnotationTypeDeclaration.getMethods()
com.sun.mirror.declaration.ClassDeclaration.getMethods()
com.sun.mirror.declaration.TypeDeclaration.getMethods()
java.lang.Class.getMethods()


Occurences of getMGFAlgorithm

getMGFAlgorithm occurences:
java.security.spec.PSSParameterSpec.getMGFAlgorithm()
javax.crypto.spec.OAEPParameterSpec.getMGFAlgorithm()


Occurences of getMGFParameters

getMGFParameters occurences:
java.security.spec.PSSParameterSpec.getMGFParameters()
javax.crypto.spec.OAEPParameterSpec.getMGFParameters()


Occurences of getMIC

getMIC occurences:
org.ietf.jgss.GSSContext.getMIC(byte[], int, int, org.ietf.jgss.MessageProp)
org.ietf.jgss.GSSContext.getMIC(java.io.InputStream, java.io.OutputStream, org.ietf.jgss.MessageProp)


Occurences of getMicrosecondLength

getMicrosecondLength occurences:
javax.sound.midi.MidiFileFormat.getMicrosecondLength()
javax.sound.midi.Sequence.getMicrosecondLength()
javax.sound.midi.Sequencer.getMicrosecondLength()
javax.sound.sampled.Clip.getMicrosecondLength()


Occurences of getMicrosecondPosition

getMicrosecondPosition occurences:
javax.sound.midi.MidiDevice.getMicrosecondPosition()
javax.sound.midi.Sequencer.getMicrosecondPosition()
javax.sound.sampled.DataLine.getMicrosecondPosition()


Occurences of getMidiFileFormat

getMidiFileFormat occurences:
javax.sound.midi.MidiSystem.getMidiFileFormat(java.io.File)
javax.sound.midi.MidiSystem.getMidiFileFormat(java.io.InputStream)
javax.sound.midi.MidiSystem.getMidiFileFormat(java.net.URL)
javax.sound.midi.spi.MidiFileReader.getMidiFileFormat(java.io.File)
javax.sound.midi.spi.MidiFileReader.getMidiFileFormat(java.io.InputStream)
javax.sound.midi.spi.MidiFileReader.getMidiFileFormat(java.net.URL)


Occurences of getMidiFileTypes

getMidiFileTypes occurences:
javax.sound.midi.MidiSystem.getMidiFileTypes()
javax.sound.midi.MidiSystem.getMidiFileTypes(javax.sound.midi.Sequence)
javax.sound.midi.spi.MidiFileWriter.getMidiFileTypes()
javax.sound.midi.spi.MidiFileWriter.getMidiFileTypes(javax.sound.midi.Sequence)


Occurences of getMimeHeader

getMimeHeader occurences:
javax.xml.soap.AttachmentPart.getMimeHeader(java.lang.String)
javax.xml.soap.SOAPPart.getMimeHeader(java.lang.String)


Occurences of getMimeType

getMimeType occurences:
java.awt.datatransfer.DataFlavor.getMimeType()
javax.activation.ActivationDataFlavor.getMimeType()
javax.print.DocFlavor.getMimeType()
javax.xml.crypto.dsig.XMLObject.getMimeType()
javax.xml.crypto.OctetStreamData.getMimeType()


Occurences of getMimeTypes

getMimeTypes occurences:
javax.accessibility.AccessibleStreamable.getMimeTypes()
javax.activation.CommandMap.getMimeTypes()
javax.activation.MailcapCommandMap.getMimeTypes()
javax.script.ScriptEngineFactory.getMimeTypes()


Occurences of getMinimum

getMinimum occurences:
java.awt.Adjustable.getMinimum()
java.awt.Scrollbar.getMinimum()
java.awt.ScrollPaneAdjustable.getMinimum()
java.util.Calendar.getMinimum(int)
java.util.GregorianCalendar.getMinimum(int)
javax.sound.sampled.FloatControl.getMinimum()
javax.swing.BoundedRangeModel.getMinimum()
javax.swing.DefaultBoundedRangeModel.getMinimum()
javax.swing.JProgressBar.getMinimum()
javax.swing.JScrollBar.getMinimum()
javax.swing.JSlider.getMinimum()
javax.swing.ProgressMonitor.getMinimum()
javax.swing.SpinnerNumberModel.getMinimum()
javax.swing.text.InternationalFormatter.getMinimum()


Occurences of getMinimumAccessibleValue

getMinimumAccessibleValue occurences:
java.awt.Button.AccessibleAWTButton.getMinimumAccessibleValue()
java.awt.Checkbox.AccessibleAWTCheckbox.getMinimumAccessibleValue()
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.getMinimumAccessibleValue()
java.awt.MenuItem.AccessibleAWTMenuItem.getMinimumAccessibleValue()
java.awt.Scrollbar.AccessibleAWTScrollBar.getMinimumAccessibleValue()
javax.accessibility.AccessibleValue.getMinimumAccessibleValue()
javax.swing.AbstractButton.AccessibleAbstractButton.getMinimumAccessibleValue()
javax.swing.JInternalFrame.AccessibleJInternalFrame.getMinimumAccessibleValue()
javax.swing.JInternalFrame.JDesktopIcon.AccessibleJDesktopIcon.getMinimumAccessibleValue()
javax.swing.JProgressBar.AccessibleJProgressBar.getMinimumAccessibleValue()
javax.swing.JScrollBar.AccessibleJScrollBar.getMinimumAccessibleValue()
javax.swing.JSlider.AccessibleJSlider.getMinimumAccessibleValue()
javax.swing.JSpinner.AccessibleJSpinner.getMinimumAccessibleValue()
javax.swing.JSplitPane.AccessibleJSplitPane.getMinimumAccessibleValue()


Occurences of getMinimumDividerLocation

getMinimumDividerLocation occurences:
javax.swing.JSplitPane.getMinimumDividerLocation()
javax.swing.plaf.basic.BasicSplitPaneUI.getMinimumDividerLocation(javax.swing.JSplitPane)
javax.swing.plaf.multi.MultiSplitPaneUI.getMinimumDividerLocation(javax.swing.JSplitPane)
javax.swing.plaf.SplitPaneUI.getMinimumDividerLocation(javax.swing.JSplitPane)


Occurences of getMinimumFractionDigits

getMinimumFractionDigits occurences:
java.text.DecimalFormat.getMinimumFractionDigits()
java.text.NumberFormat.getMinimumFractionDigits()


Occurences of getMinimumIntegerDigits

getMinimumIntegerDigits occurences:
java.text.DecimalFormat.getMinimumIntegerDigits()
java.text.NumberFormat.getMinimumIntegerDigits()


Occurences of getMinimumSize

getMinimumSize occurences:
java.awt.Component.getMinimumSize()
java.awt.Container.getMinimumSize()
java.awt.List.getMinimumSize()
java.awt.List.getMinimumSize(int)
java.awt.TextArea.getMinimumSize()
java.awt.TextArea.getMinimumSize(int, int)
java.awt.TextField.getMinimumSize()
java.awt.TextField.getMinimumSize(int)
javax.swing.border.TitledBorder.getMinimumSize(java.awt.Component)
javax.swing.JComponent.getMinimumSize()
javax.swing.JScrollBar.getMinimumSize()
javax.swing.JToolBar.Separator.getMinimumSize()
javax.swing.plaf.basic.BasicArrowButton.getMinimumSize()
javax.swing.plaf.basic.BasicButtonUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicComboBoxUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopIconUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicInternalFrameUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicLabelUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuBarUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuItemUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicProgressBarUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSeparatorUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSplitPaneDivider.getMinimumSize()
javax.swing.plaf.basic.BasicSplitPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTabbedPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableHeaderUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextAreaUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolTipUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.ComponentUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalComboBoxButton.getMinimumSize()
javax.swing.plaf.metal.MetalComboBoxUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalDesktopIconUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalFileChooserUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollButton.getMinimumSize()
javax.swing.plaf.multi.MultiButtonUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.getMinimumSize(javax.swing.JComponent)
javax.swing.plaf.synth.SynthGraphicsUtils.getMinimumSize(javax.swing.plaf.synth.SynthContext, java.awt.Font, java.lang.String, javax.swing.Icon, int, int, int, int, int, int)


Occurences of getMinimumSpan

getMinimumSpan occurences:
javax.swing.text.AsyncBoxView.getMinimumSpan(int)
javax.swing.text.BoxView.getMinimumSpan(int)
javax.swing.text.ComponentView.getMinimumSpan(int)
javax.swing.text.html.BlockView.getMinimumSpan(int)
javax.swing.text.html.ParagraphView.getMinimumSpan(int)
javax.swing.text.View.getMinimumSpan(int)
javax.swing.text.WrappedPlainView.getMinimumSpan(int)


Occurences of getMinimumThumbSize

getMinimumThumbSize occurences:
javax.swing.plaf.basic.BasicScrollBarUI.getMinimumThumbSize()
javax.swing.plaf.metal.MetalScrollBarUI.getMinimumThumbSize()


Occurences of getMinorString

getMinorString occurences:
org.ietf.jgss.GSSException.getMinorString()
org.ietf.jgss.MessageProp.getMinorString()


Occurences of getMinorVersion

getMinorVersion occurences:
java.awt.color.ICC_Profile.getMinorVersion()
java.sql.Driver.getMinorVersion()


Occurences of getMinSelectionIndex

getMinSelectionIndex occurences:
javax.swing.DefaultListSelectionModel.getMinSelectionIndex()
javax.swing.JList.getMinSelectionIndex()
javax.swing.ListSelectionModel.getMinSelectionIndex()


Occurences of getMinSelectionRow

getMinSelectionRow occurences:
javax.swing.JTree.getMinSelectionRow()
javax.swing.tree.DefaultTreeSelectionModel.getMinSelectionRow()
javax.swing.tree.TreeSelectionModel.getMinSelectionRow()


Occurences of getMinTileX

getMinTileX occurences:
java.awt.image.BufferedImage.getMinTileX()
java.awt.image.RenderedImage.getMinTileX()


Occurences of getMinTileY

getMinTileY occurences:
java.awt.image.BufferedImage.getMinTileY()
java.awt.image.RenderedImage.getMinTileY()


Occurences of getMinutes

getMinutes occurences:
java.sql.Date.getMinutes()
java.util.Date.getMinutes()
javax.xml.datatype.Duration.getMinutes()


Occurences of getMinValue

getMinValue occurences:
java.awt.color.ColorSpace.getMinValue(int)
java.awt.color.ICC_ColorSpace.getMinValue(int)
javax.management.openmbean.OpenMBeanAttributeInfoSupport.getMinValue()
javax.management.openmbean.OpenMBeanParameterInfo.getMinValue()
javax.management.openmbean.OpenMBeanParameterInfoSupport.getMinValue()


Occurences of getMinX

getMinX occurences:
java.awt.geom.RectangularShape.getMinX()
java.awt.image.BufferedImage.getMinX()
java.awt.image.Raster.getMinX()
java.awt.image.renderable.RenderableImage.getMinX()
java.awt.image.renderable.RenderableImageOp.getMinX()
java.awt.image.RenderedImage.getMinX()


Occurences of getMinY

getMinY occurences:
java.awt.geom.RectangularShape.getMinY()
java.awt.image.BufferedImage.getMinY()
java.awt.image.Raster.getMinY()
java.awt.image.renderable.RenderableImage.getMinY()
java.awt.image.renderable.RenderableImageOp.getMinY()
java.awt.image.RenderedImage.getMinY()


Occurences of getMixer

getMixer occurences:
javax.sound.sampled.AudioSystem.getMixer(javax.sound.sampled.Mixer.Info)
javax.sound.sampled.spi.MixerProvider.getMixer(javax.sound.sampled.Mixer.Info)


Occurences of getMixerInfo

getMixerInfo occurences:
javax.sound.sampled.AudioSystem.getMixerInfo()
javax.sound.sampled.Mixer.getMixerInfo()
javax.sound.sampled.spi.MixerProvider.getMixerInfo()


Occurences of getMnemonic

getMnemonic occurences:
javax.swing.AbstractButton.getMnemonic()
javax.swing.ButtonModel.getMnemonic()
javax.swing.colorchooser.AbstractColorChooserPanel.getMnemonic()
javax.swing.DefaultButtonModel.getMnemonic()


Occurences of getModel

getModel occurences:
javax.swing.AbstractButton.getModel()
javax.swing.DefaultRowSorter.getModel()
javax.swing.DefaultRowSorter.ModelWrapper.getModel()
javax.swing.JComboBox.getModel()
javax.swing.JList.getModel()
javax.swing.JProgressBar.getModel()
javax.swing.JScrollBar.getModel()
javax.swing.JSlider.getModel()
javax.swing.JSpinner.getModel()
javax.swing.JSpinner.DateEditor.getModel()
javax.swing.JSpinner.ListEditor.getModel()
javax.swing.JSpinner.NumberEditor.getModel()
javax.swing.JTabbedPane.getModel()
javax.swing.JTable.getModel()
javax.swing.JTree.getModel()
javax.swing.plaf.basic.BasicFileChooserUI.getModel()
javax.swing.plaf.basic.BasicTreeUI.getModel()
javax.swing.RowFilter.Entry.getModel()
javax.swing.RowSorter.getModel()
javax.swing.tree.AbstractLayoutCache.getModel()


Occurences of getModelRowCount

getModelRowCount occurences:
javax.swing.DefaultRowSorter.getModelRowCount()
javax.swing.RowSorter.getModelRowCount()


Occurences of getModifiers

getModifiers occurences:
com.sun.mirror.declaration.Declaration.getModifiers()
com.sun.source.tree.ClassTree.getModifiers()
com.sun.source.tree.MethodTree.getModifiers()
com.sun.source.tree.VariableTree.getModifiers()
java.awt.AWTKeyStroke.getModifiers()
java.awt.event.ActionEvent.getModifiers()
java.awt.event.InputEvent.getModifiers()
java.lang.Class.getModifiers()
java.lang.reflect.Constructor.getModifiers()
java.lang.reflect.Field.getModifiers()
java.lang.reflect.Member.getModifiers()
java.lang.reflect.Method.getModifiers()
javax.lang.model.element.Element.getModifiers()


Occurences of getModulus

getModulus occurences:
java.security.interfaces.RSAKey.getModulus()
java.security.spec.RSAPrivateKeySpec.getModulus()
java.security.spec.RSAPublicKeySpec.getModulus()
javax.management.monitor.CounterMonitor.getModulus()
javax.management.monitor.CounterMonitorMBean.getModulus()


Occurences of getMonth

getMonth occurences:
java.sql.Time.getMonth()
java.util.Date.getMonth()
javax.xml.datatype.XMLGregorianCalendar.getMonth()


Occurences of getMonths

getMonths occurences:
java.text.DateFormatSymbols.getMonths()
javax.xml.datatype.Duration.getMonths()


Occurences of getMoreResults

getMoreResults occurences:
java.sql.Statement.getMoreResults()
java.sql.Statement.getMoreResults(int)


Occurences of getMostRecentFocusOwner

getMostRecentFocusOwner occurences:
java.awt.Window.getMostRecentFocusOwner()
javax.swing.JInternalFrame.getMostRecentFocusOwner()


Occurences of getMouseListener

getMouseListener occurences:
javax.swing.plaf.basic.BasicComboPopup.getMouseListener()
javax.swing.plaf.basic.ComboPopup.getMouseListener()


Occurences of getMouseListeners

getMouseListeners occurences:
java.awt.Component.getMouseListeners()
java.awt.TrayIcon.getMouseListeners()


Occurences of getMouseMotionListener

getMouseMotionListener occurences:
javax.swing.plaf.basic.BasicComboPopup.getMouseMotionListener()
javax.swing.plaf.basic.ComboPopup.getMouseMotionListener()


Occurences of getMouseMotionListeners

getMouseMotionListeners occurences:
java.awt.Component.getMouseMotionListeners()
java.awt.TrayIcon.getMouseMotionListeners()


Occurences of getMousePosition

getMousePosition occurences:
java.awt.Component.getMousePosition()
java.awt.Container.getMousePosition(boolean)


Occurences of getName

getName occurences:
com.sun.source.tree.IdentifierTree.getName()
com.sun.source.tree.MethodTree.getName()
com.sun.source.tree.TypeParameterTree.getName()
com.sun.source.tree.VariableTree.getName()
com.sun.tools.doclets.Taglet.getName()
java.awt.color.ColorSpace.getName(int)
java.awt.Component.getName()
java.awt.Cursor.getName()
java.awt.datatransfer.Clipboard.getName()
java.awt.Font.getName()
java.awt.MenuComponent.getName()
java.beans.FeatureDescriptor.getName()
java.io.File.getName()
java.io.ObjectStreamClass.getName()
java.io.ObjectStreamField.getName()
java.lang.Class.getName()
java.lang.management.CompilationMXBean.getName()
java.lang.management.MemoryManagerMXBean.getName()
java.lang.management.MemoryPoolMXBean.getName()
java.lang.management.OperatingSystemMXBean.getName()
java.lang.management.RuntimeMXBean.getName()
java.lang.Package.getName()
java.lang.reflect.Constructor.getName()
java.lang.reflect.Field.getName()
java.lang.reflect.Member.getName()
java.lang.reflect.Method.getName()
java.lang.reflect.TypeVariable.getName()
java.lang.Thread.getName()
java.lang.ThreadGroup.getName()
java.net.HttpCookie.getName()
java.net.NetworkInterface.getName()
java.security.acl.Acl.getName()
java.security.Identity.getName()
java.security.Permission.getName()
java.security.Principal.getName()
java.security.Provider.getName()
java.security.spec.ECGenParameterSpec.getName()
java.text.AttributedCharacterIterator.Attribute.getName()
java.util.logging.Level.getName()
java.util.logging.Logger.getName()
java.util.zip.ZipEntry.getName()
java.util.zip.ZipFile.getName()
javax.activation.DataHandler.getName()
javax.activation.DataSource.getName()
javax.activation.FileDataSource.getName()
javax.activation.URLDataSource.getName()
javax.crypto.ExemptionMechanism.getName()
javax.lang.model.util.Elements.getName(java.lang.CharSequence)
javax.management.Attribute.getName()
javax.management.loading.MLetContent.getName()
javax.management.MBeanFeatureInfo.getName()
javax.management.openmbean.OpenMBeanConstructorInfo.getName()
javax.management.openmbean.OpenMBeanOperationInfo.getName()
javax.management.openmbean.OpenMBeanParameterInfo.getName()
javax.management.relation.RoleInfo.getName()
javax.management.remote.JMXPrincipal.getName()
javax.naming.NameClassPair.getName()
javax.net.ssl.SSLSessionBindingEvent.getName()
javax.print.attribute.Attribute.getName()
javax.print.attribute.standard.Chromaticity.getName()
javax.print.attribute.standard.ColorSupported.getName()
javax.print.attribute.standard.Compression.getName()
javax.print.attribute.standard.Copies.getName()
javax.print.attribute.standard.CopiesSupported.getName()
javax.print.attribute.standard.DateTimeAtCompleted.getName()
javax.print.attribute.standard.DateTimeAtCreation.getName()
javax.print.attribute.standard.DateTimeAtProcessing.getName()
javax.print.attribute.standard.Destination.getName()
javax.print.attribute.standard.DocumentName.getName()
javax.print.attribute.standard.Fidelity.getName()
javax.print.attribute.standard.Finishings.getName()
javax.print.attribute.standard.JobHoldUntil.getName()
javax.print.attribute.standard.JobImpressions.getName()
javax.print.attribute.standard.JobImpressionsCompleted.getName()
javax.print.attribute.standard.JobImpressionsSupported.getName()
javax.print.attribute.standard.JobKOctets.getName()
javax.print.attribute.standard.JobKOctetsProcessed.getName()
javax.print.attribute.standard.JobKOctetsSupported.getName()
javax.print.attribute.standard.JobMediaSheets.getName()
javax.print.attribute.standard.JobMediaSheetsCompleted.getName()
javax.print.attribute.standard.JobMediaSheetsSupported.getName()
javax.print.attribute.standard.JobMessageFromOperator.getName()
javax.print.attribute.standard.JobName.getName()
javax.print.attribute.standard.JobOriginatingUserName.getName()
javax.print.attribute.standard.JobPriority.getName()
javax.print.attribute.standard.JobPrioritySupported.getName()
javax.print.attribute.standard.JobSheets.getName()
javax.print.attribute.standard.JobState.getName()
javax.print.attribute.standard.JobStateReason.getName()
javax.print.attribute.standard.JobStateReasons.getName()
javax.print.attribute.standard.Media.getName()
javax.print.attribute.standard.MediaPrintableArea.getName()
javax.print.attribute.standard.MediaSize.getName()
javax.print.attribute.standard.MultipleDocumentHandling.getName()
javax.print.attribute.standard.NumberOfDocuments.getName()
javax.print.attribute.standard.NumberOfInterveningJobs.getName()
javax.print.attribute.standard.NumberUp.getName()
javax.print.attribute.standard.NumberUpSupported.getName()
javax.print.attribute.standard.OrientationRequested.getName()
javax.print.attribute.standard.OutputDeviceAssigned.getName()
javax.print.attribute.standard.PageRanges.getName()
javax.print.attribute.standard.PagesPerMinute.getName()
javax.print.attribute.standard.PagesPerMinuteColor.getName()
javax.print.attribute.standard.PDLOverrideSupported.getName()
javax.print.attribute.standard.PresentationDirection.getName()
javax.print.attribute.standard.PrinterInfo.getName()
javax.print.attribute.standard.PrinterIsAcceptingJobs.getName()
javax.print.attribute.standard.PrinterLocation.getName()
javax.print.attribute.standard.PrinterMakeAndModel.getName()
javax.print.attribute.standard.PrinterMessageFromOperator.getName()
javax.print.attribute.standard.PrinterMoreInfo.getName()
javax.print.attribute.standard.PrinterMoreInfoManufacturer.getName()
javax.print.attribute.standard.PrinterName.getName()
javax.print.attribute.standard.PrinterResolution.getName()
javax.print.attribute.standard.PrinterState.getName()
javax.print.attribute.standard.PrinterStateReason.getName()
javax.print.attribute.standard.PrinterStateReasons.getName()
javax.print.attribute.standard.PrinterURI.getName()
javax.print.attribute.standard.PrintQuality.getName()
javax.print.attribute.standard.QueuedJobCount.getName()
javax.print.attribute.standard.ReferenceUriSchemesSupported.getName()
javax.print.attribute.standard.RequestingUserName.getName()
javax.print.attribute.standard.Severity.getName()
javax.print.attribute.standard.SheetCollate.getName()
javax.print.attribute.standard.Sides.getName()
javax.print.PrintService.getName()
javax.security.auth.callback.NameCallback.getName()
javax.security.auth.kerberos.KerberosPrincipal.getName()
javax.security.auth.x500.X500Principal.getName()
javax.security.auth.x500.X500Principal.getName(java.lang.String)
javax.security.auth.x500.X500Principal.getName(java.lang.String, java.util.Map)
javax.sound.midi.MidiDevice.Info.getName()
javax.sound.midi.Soundbank.getName()
javax.sound.midi.SoundbankResource.getName()
javax.sound.sampled.Mixer.Info.getName()
javax.sound.sampled.Port.Info.getName()
javax.sound.sampled.ReverbType.getName()
javax.swing.filechooser.FileView.getName(java.io.File)
javax.swing.JFileChooser.getName(java.io.File)
javax.swing.LookAndFeel.getName()
javax.swing.plaf.basic.BasicFileChooserUI.BasicFileView.getName(java.io.File)
javax.swing.plaf.metal.DefaultMetalTheme.getName()
javax.swing.plaf.metal.MetalLookAndFeel.getName()
javax.swing.plaf.metal.MetalTheme.getName()
javax.swing.plaf.metal.OceanTheme.getName()
javax.swing.plaf.multi.MultiLookAndFeel.getName()
javax.swing.plaf.synth.Region.getName()
javax.swing.plaf.synth.SynthLookAndFeel.getName()
javax.swing.text.AbstractDocument.AbstractElement.getName()
javax.swing.text.AbstractDocument.BranchElement.getName()
javax.swing.text.AbstractDocument.LeafElement.getName()
javax.swing.text.DefaultStyledDocument.SectionElement.getName()
javax.swing.text.Element.getName()
javax.swing.text.html.HTMLDocument.BlockElement.getName()
javax.swing.text.html.HTMLDocument.RunElement.getName()
javax.swing.text.html.parser.AttributeList.getName()
javax.swing.text.html.parser.DTD.getName()
javax.swing.text.html.parser.Element.getName()
javax.swing.text.html.parser.Entity.getName()
javax.swing.text.Keymap.getName()
javax.swing.text.Style.getName()
javax.swing.text.StyleContext.NamedStyle.getName()
javax.swing.UIManager.LookAndFeelInfo.getName()
javax.tools.FileObject.getName()
javax.tools.ForwardingFileObject.getName()
javax.tools.JavaFileManager.Location.getName()
javax.tools.SimpleJavaFileObject.getName()
javax.tools.StandardLocation.getName()
javax.xml.bind.JAXBElement.getName()
javax.xml.crypto.dsig.keyinfo.KeyName.getName()
javax.xml.soap.MimeHeader.getName()
javax.xml.stream.events.Attribute.getName()
javax.xml.stream.events.EndElement.getName()
javax.xml.stream.events.EntityDeclaration.getName()
javax.xml.stream.events.EntityReference.getName()
javax.xml.stream.events.NotationDeclaration.getName()
javax.xml.stream.events.StartElement.getName()
javax.xml.stream.util.StreamReaderDelegate.getName()
javax.xml.stream.XMLStreamReader.getName()
org.ietf.jgss.GSSCredential.getName()
org.ietf.jgss.GSSCredential.getName(org.ietf.jgss.Oid)
org.w3c.dom.Attr.getName()
org.w3c.dom.DocumentType.getName()
org.w3c.dom.NameList.getName(int)
org.xml.sax.AttributeList.getName(int)
org.xml.sax.helpers.AttributeListImpl.getName(int)


Occurences of getNameConstraints

getNameConstraints occurences:
java.security.cert.TrustAnchor.getNameConstraints()
java.security.cert.X509CertSelector.getNameConstraints()


Occurences of getNameInNamespace

getNameInNamespace occurences:
javax.naming.Context.getNameInNamespace()
javax.naming.InitialContext.getNameInNamespace()
javax.naming.NameClassPair.getNameInNamespace()


Occurences of getNameParser

getNameParser occurences:
javax.naming.Context.getNameParser(java.lang.String)
javax.naming.Context.getNameParser(javax.naming.Name)
javax.naming.InitialContext.getNameParser(java.lang.String)
javax.naming.InitialContext.getNameParser(javax.naming.Name)


Occurences of getNames

getNames occurences:
javax.activation.MimeTypeParameterList.getNames()
javax.script.ScriptEngineFactory.getNames()


Occurences of getNamespaceContext

getNamespaceContext occurences:
javax.xml.stream.events.StartElement.getNamespaceContext()
javax.xml.stream.util.StreamReaderDelegate.getNamespaceContext()
javax.xml.stream.XMLEventWriter.getNamespaceContext()
javax.xml.stream.XMLStreamReader.getNamespaceContext()
javax.xml.stream.XMLStreamWriter.getNamespaceContext()
javax.xml.xpath.XPath.getNamespaceContext()


Occurences of getNamespaceCount

getNamespaceCount occurences:
javax.xml.stream.util.StreamReaderDelegate.getNamespaceCount()
javax.xml.stream.XMLStreamReader.getNamespaceCount()


Occurences of getNamespaceMap

getNamespaceMap occurences:
javax.xml.crypto.dsig.spec.XPathFilterParameterSpec.getNamespaceMap()
javax.xml.crypto.dsig.spec.XPathType.getNamespaceMap()


Occurences of getNamespacePrefix

getNamespacePrefix occurences:
javax.xml.crypto.dom.DOMCryptoContext.getNamespacePrefix(java.lang.String, java.lang.String)
javax.xml.crypto.XMLCryptoContext.getNamespacePrefix(java.lang.String, java.lang.String)
javax.xml.stream.util.StreamReaderDelegate.getNamespacePrefix(int)
javax.xml.stream.XMLStreamReader.getNamespacePrefix(int)


Occurences of getNamespaces

getNamespaces occurences:
javax.xml.stream.events.EndElement.getNamespaces()
javax.xml.stream.events.StartElement.getNamespaces()


Occurences of getNamespaceURI

getNamespaceURI occurences:
javax.imageio.metadata.IIOMetadataNode.getNamespaceURI()
javax.xml.namespace.NamespaceContext.getNamespaceURI(java.lang.String)
javax.xml.namespace.QName.getNamespaceURI()
javax.xml.soap.SOAPElement.getNamespaceURI(java.lang.String)
javax.xml.stream.events.Namespace.getNamespaceURI()
javax.xml.stream.events.StartElement.getNamespaceURI(java.lang.String)
javax.xml.stream.util.StreamReaderDelegate.getNamespaceURI()
javax.xml.stream.util.StreamReaderDelegate.getNamespaceURI(int)
javax.xml.stream.util.StreamReaderDelegate.getNamespaceURI(java.lang.String)
javax.xml.stream.XMLStreamReader.getNamespaceURI()
javax.xml.stream.XMLStreamReader.getNamespaceURI(int)
javax.xml.stream.XMLStreamReader.getNamespaceURI(java.lang.String)
org.w3c.dom.NameList.getNamespaceURI(int)
org.w3c.dom.Node.getNamespaceURI()


Occurences of getNativesForFlavor

getNativesForFlavor occurences:
java.awt.datatransfer.FlavorTable.getNativesForFlavor(java.awt.datatransfer.DataFlavor)
java.awt.datatransfer.SystemFlavorMap.getNativesForFlavor(java.awt.datatransfer.DataFlavor)


Occurences of getNativesForFlavors

getNativesForFlavors occurences:
java.awt.datatransfer.FlavorMap.getNativesForFlavors(java.awt.datatransfer.DataFlavor[])
java.awt.datatransfer.SystemFlavorMap.getNativesForFlavors(java.awt.datatransfer.DataFlavor[])


Occurences of getNavigationFilter

getNavigationFilter occurences:
javax.swing.JFormattedTextField.AbstractFormatter.getNavigationFilter()
javax.swing.text.DefaultFormatter.getNavigationFilter()
javax.swing.text.JTextComponent.getNavigationFilter()


Occurences of getNbNotifications

getNbNotifications occurences:
javax.management.timer.Timer.getNbNotifications()
javax.management.timer.TimerMBean.getNbNotifications()


Occurences of getNbOccurences

getNbOccurences occurences:
javax.management.timer.Timer.getNbOccurences(java.lang.Integer)
javax.management.timer.TimerMBean.getNbOccurences(java.lang.Integer)


Occurences of getNCharacterStream

getNCharacterStream occurences:
java.sql.CallableStatement.getNCharacterStream(int)
java.sql.CallableStatement.getNCharacterStream(java.lang.String)
java.sql.ResultSet.getNCharacterStream(int)
java.sql.ResultSet.getNCharacterStream(java.lang.String)


Occurences of getNClob

getNClob occurences:
java.sql.CallableStatement.getNClob(int)
java.sql.CallableStatement.getNClob(java.lang.String)
java.sql.ResultSet.getNClob(int)
java.sql.ResultSet.getNClob(java.lang.String)


Occurences of getNeedClientAuth

getNeedClientAuth occurences:
javax.net.ssl.SSLEngine.getNeedClientAuth()
javax.net.ssl.SSLParameters.getNeedClientAuth()
javax.net.ssl.SSLServerSocket.getNeedClientAuth()
javax.net.ssl.SSLSocket.getNeedClientAuth()
javax.rmi.ssl.SslRMIServerSocketFactory.getNeedClientAuth()


Occurences of getNeededLocation

getNeededLocation occurences:
javax.swing.plaf.basic.BasicSplitPaneDivider.DragController.getNeededLocation(int, int)
javax.swing.plaf.basic.BasicSplitPaneDivider.VerticalDragController.getNeededLocation(int, int)


Occurences of getNegotiatedProperty

getNegotiatedProperty occurences:
javax.security.sasl.SaslClient.getNegotiatedProperty(java.lang.String)
javax.security.sasl.SaslServer.getNegotiatedProperty(java.lang.String)


Occurences of getNestingKind

getNestingKind occurences:
javax.lang.model.element.TypeElement.getNestingKind()
javax.tools.ForwardingJavaFileObject.getNestingKind()
javax.tools.JavaFileObject.getNestingKind()
javax.tools.SimpleJavaFileObject.getNestingKind()


Occurences of getNewValue

getNewValue occurences:
java.beans.PropertyChangeEvent.getNewValue()
java.util.prefs.PreferenceChangeEvent.getNewValue()
javax.management.AttributeChangeNotification.getNewValue()
org.w3c.dom.events.MutationEvent.getNewValue()


Occurences of getNextEntry

getNextEntry occurences:
java.util.jar.JarInputStream.getNextEntry()
java.util.zip.ZipInputStream.getNextEntry()


Occurences of getNextLeftHit

getNextLeftHit occurences:
java.awt.font.TextLayout.getNextLeftHit(int)
java.awt.font.TextLayout.getNextLeftHit(int, java.awt.font.TextLayout.CaretPolicy)
java.awt.font.TextLayout.getNextLeftHit(java.awt.font.TextHitInfo)


Occurences of getNextMatch

getNextMatch occurences:
javax.swing.JList.getNextMatch(java.lang.String, int, javax.swing.text.Position.Bias)
javax.swing.JTree.getNextMatch(java.lang.String, int, javax.swing.text.Position.Bias)


Occurences of getNextNorthSouthVisualPositionFrom

getNextNorthSouthVisualPositionFrom occurences:
javax.swing.text.CompositeView.getNextNorthSouthVisualPositionFrom(int, javax.swing.text.Position.Bias, java.awt.Shape, int, javax.swing.text.Position.Bias[])
javax.swing.text.ParagraphView.getNextNorthSouthVisualPositionFrom(int, javax.swing.text.Position.Bias, java.awt.Shape, int, javax.swing.text.Position.Bias[])


Occurences of getNextRightHit

getNextRightHit occurences:
java.awt.font.TextLayout.getNextRightHit(int)
java.awt.font.TextLayout.getNextRightHit(int, java.awt.font.TextLayout.CaretPolicy)
java.awt.font.TextLayout.getNextRightHit(java.awt.font.TextHitInfo)


Occurences of getNextSibling

getNextSibling occurences:
javax.imageio.metadata.IIOMetadataNode.getNextSibling()
javax.swing.tree.DefaultMutableTreeNode.getNextSibling()
javax.xml.crypto.dsig.dom.DOMSignContext.getNextSibling()
javax.xml.transform.dom.DOMResult.getNextSibling()
org.w3c.dom.Node.getNextSibling()


Occurences of getNextValue

getNextValue occurences:
javax.swing.JSpinner.getNextValue()
javax.swing.SpinnerDateModel.getNextValue()
javax.swing.SpinnerListModel.getNextValue()
javax.swing.SpinnerModel.getNextValue()
javax.swing.SpinnerNumberModel.getNextValue()


Occurences of getNextVisualPositionFrom

getNextVisualPositionFrom occurences:
javax.swing.plaf.basic.BasicTextUI.getNextVisualPositionFrom(javax.swing.text.JTextComponent, int, javax.swing.text.Position.Bias, int, javax.swing.text.Position.Bias[])
javax.swing.plaf.multi.MultiTextUI.getNextVisualPositionFrom(javax.swing.text.JTextComponent, int, javax.swing.text.Position.Bias, int, javax.swing.text.Position.Bias[])
javax.swing.plaf.TextUI.getNextVisualPositionFrom(javax.swing.text.JTextComponent, int, javax.swing.text.Position.Bias, int, javax.swing.text.Position.Bias[])
javax.swing.text.AsyncBoxView.getNextVisualPositionFrom(int, javax.swing.text.Position.Bias, java.awt.Shape, int, javax.swing.text.Position.Bias[])
javax.swing.text.CompositeView.getNextVisualPositionFrom(int, javax.swing.text.Position.Bias, java.awt.Shape, int, javax.swing.text.Position.Bias[])
javax.swing.text.GlyphView.getNextVisualPositionFrom(int, javax.swing.text.Position.Bias, java.awt.Shape, int, javax.swing.text.Position.Bias[])
javax.swing.text.GlyphView.GlyphPainter.getNextVisualPositionFrom(javax.swing.text.GlyphView, int, javax.swing.text.Position.Bias, java.awt.Shape, int, javax.swing.text.Position.Bias[])
javax.swing.text.NavigationFilter.getNextVisualPositionFrom(javax.swing.text.JTextComponent, int, javax.swing.text.Position.Bias, int, javax.swing.text.Position.Bias[])
javax.swing.text.View.getNextVisualPositionFrom(int, javax.swing.text.Position.Bias, java.awt.Shape, int, javax.swing.text.Position.Bias[])


Occurences of getNextWarning

getNextWarning occurences:
java.sql.SQLWarning.getNextWarning()
javax.sql.rowset.RowSetWarning.getNextWarning()


Occurences of getNode

getNode occurences:
java.util.prefs.PreferenceChangeEvent.getNode()
javax.xml.bind.helpers.AbstractMarshallerImpl.getNode(java.lang.Object)
javax.xml.bind.helpers.ValidationEventLocatorImpl.getNode()
javax.xml.bind.Marshaller.getNode(java.lang.Object)
javax.xml.bind.ValidationEventLocator.getNode()
javax.xml.crypto.dom.DOMStructure.getNode()
javax.xml.crypto.dsig.dom.DOMValidateContext.getNode()
javax.xml.transform.dom.DOMResult.getNode()
javax.xml.transform.dom.DOMSource.getNode()


Occurences of getNodeDimensions

getNodeDimensions occurences:
javax.swing.plaf.basic.BasicTreeUI.NodeDimensionsHandler.getNodeDimensions(java.lang.Object, int, int, boolean, java.awt.Rectangle)
javax.swing.tree.AbstractLayoutCache.getNodeDimensions()
javax.swing.tree.AbstractLayoutCache.getNodeDimensions(java.lang.Object, int, int, boolean, java.awt.Rectangle)
javax.swing.tree.AbstractLayoutCache.NodeDimensions.getNodeDimensions(java.lang.Object, int, int, boolean, java.awt.Rectangle)


Occurences of getNodeName

getNodeName occurences:
javax.imageio.metadata.IIOMetadataNode.getNodeName()
org.w3c.dom.Node.getNodeName()


Occurences of getNodeType

getNodeType occurences:
javax.imageio.metadata.IIOMetadataNode.getNodeType()
org.w3c.dom.Node.getNodeType()


Occurences of getNodeValue

getNodeValue occurences:
javax.imageio.metadata.IIOMetadataNode.getNodeValue()
org.w3c.dom.Node.getNodeValue()


Occurences of getNonMatchingMimeHeaders

getNonMatchingMimeHeaders occurences:
javax.xml.soap.AttachmentPart.getNonMatchingMimeHeaders(java.lang.String[])
javax.xml.soap.SOAPPart.getNonMatchingMimeHeaders(java.lang.String[])


Occurences of getNormalizedComponents

getNormalizedComponents occurences:
java.awt.image.ColorModel.getNormalizedComponents(int[], int, float[], int)
java.awt.image.ColorModel.getNormalizedComponents(java.lang.Object, float[], int)
java.awt.image.ComponentColorModel.getNormalizedComponents(int[], int, float[], int)
java.awt.image.ComponentColorModel.getNormalizedComponents(java.lang.Object, float[], int)


Occurences of getNotAfter

getNotAfter occurences:
java.security.cert.X509Certificate.getNotAfter()
javax.security.cert.X509Certificate.getNotAfter()


Occurences of getNotationName

getNotationName occurences:
javax.xml.stream.events.EntityDeclaration.getNotationName()
org.w3c.dom.Entity.getNotationName()


Occurences of getNotations

getNotations occurences:
javax.xml.stream.events.DTD.getNotations()
org.w3c.dom.DocumentType.getNotations()


Occurences of getNotBefore

getNotBefore occurences:
java.security.cert.X509Certificate.getNotBefore()
javax.security.cert.X509Certificate.getNotBefore()


Occurences of getNotification

getNotification occurences:
javax.management.modelmbean.ModelMBeanInfo.getNotification(java.lang.String)
javax.management.modelmbean.ModelMBeanInfoSupport.getNotification(java.lang.String)
javax.management.remote.TargetedNotification.getNotification()
javax.naming.ldap.UnsolicitedNotificationEvent.getNotification()


Occurences of getNotificationIDs

getNotificationIDs occurences:
javax.management.timer.Timer.getNotificationIDs(java.lang.String)
javax.management.timer.TimerMBean.getNotificationIDs(java.lang.String)


Occurences of getNotificationInfo

getNotificationInfo occurences:
javax.management.MBeanServerDelegate.getNotificationInfo()
javax.management.modelmbean.RequiredModelMBean.getNotificationInfo()
javax.management.monitor.CounterMonitor.getNotificationInfo()
javax.management.monitor.GaugeMonitor.getNotificationInfo()
javax.management.monitor.StringMonitor.getNotificationInfo()
javax.management.NotificationBroadcaster.getNotificationInfo()
javax.management.NotificationBroadcasterSupport.getNotificationInfo()
javax.management.relation.RelationService.getNotificationInfo()
javax.management.remote.JMXConnectorServer.getNotificationInfo()
javax.management.StandardEmitterMBean.getNotificationInfo()
javax.management.timer.Timer.getNotificationInfo()


Occurences of getNotificationMessage

getNotificationMessage occurences:
javax.management.timer.Timer.getNotificationMessage(java.lang.Integer)
javax.management.timer.TimerMBean.getNotificationMessage(java.lang.Integer)


Occurences of getNotifications

getNotifications occurences:
javax.management.MBeanInfo.getNotifications()
javax.management.modelmbean.ModelMBeanInfo.getNotifications()
javax.management.openmbean.OpenMBeanInfo.getNotifications()


Occurences of getNotificationType

getNotificationType occurences:
javax.management.timer.Timer.getNotificationType(java.lang.Integer)
javax.management.timer.TimerMBean.getNotificationType(java.lang.Integer)


Occurences of getNotificationUserData

getNotificationUserData occurences:
javax.management.timer.Timer.getNotificationUserData(java.lang.Integer)
javax.management.timer.TimerMBean.getNotificationUserData(java.lang.Integer)


Occurences of getNotify

getNotify occurences:
javax.management.monitor.CounterMonitor.getNotify()
javax.management.monitor.CounterMonitorMBean.getNotify()


Occurences of getNotifyDiffer

getNotifyDiffer occurences:
javax.management.monitor.StringMonitor.getNotifyDiffer()
javax.management.monitor.StringMonitorMBean.getNotifyDiffer()


Occurences of getNotifyHigh

getNotifyHigh occurences:
javax.management.monitor.GaugeMonitor.getNotifyHigh()
javax.management.monitor.GaugeMonitorMBean.getNotifyHigh()


Occurences of getNotifyLow

getNotifyLow occurences:
javax.management.monitor.GaugeMonitor.getNotifyLow()
javax.management.monitor.GaugeMonitorMBean.getNotifyLow()


Occurences of getNotifyMatch

getNotifyMatch occurences:
javax.management.monitor.StringMonitor.getNotifyMatch()
javax.management.monitor.StringMonitorMBean.getNotifyMatch()


Occurences of getNString

getNString occurences:
java.sql.CallableStatement.getNString(int)
java.sql.CallableStatement.getNString(java.lang.String)
java.sql.ResultSet.getNString(int)
java.sql.ResultSet.getNString(java.lang.String)


Occurences of getNumBands

getNumBands occurences:
java.awt.image.Raster.getNumBands()
java.awt.image.SampleModel.getNumBands()
javax.imageio.ImageTypeSpecifier.getNumBands()


Occurences of getNumberInstance

getNumberInstance occurences:
java.text.NumberFormat.getNumberInstance()
java.text.NumberFormat.getNumberInstance(java.util.Locale)
java.text.spi.NumberFormatProvider.getNumberInstance(java.util.Locale)


Occurences of getNumberOfPages

getNumberOfPages occurences:
java.awt.print.Book.getNumberOfPages()
java.awt.print.Pageable.getNumberOfPages()


Occurences of getNumComponents

getNumComponents occurences:
java.awt.color.ColorSpace.getNumComponents()
java.awt.color.ICC_Profile.getNumComponents()
java.awt.image.ColorModel.getNumComponents()
java.awt.image.LookupTable.getNumComponents()
javax.imageio.ImageTypeSpecifier.getNumComponents()


Occurences of getNumDataElements

getNumDataElements occurences:
java.awt.image.ComponentSampleModel.getNumDataElements()
java.awt.image.MultiPixelPackedSampleModel.getNumDataElements()
java.awt.image.Raster.getNumDataElements()
java.awt.image.SampleModel.getNumDataElements()
java.awt.image.SinglePixelPackedSampleModel.getNumDataElements()


Occurences of getNumericValue

getNumericValue occurences:
java.lang.Character.getNumericValue(char)
java.lang.Character.getNumericValue(int)


Occurences of getNumGlyphs

getNumGlyphs occurences:
java.awt.Font.getNumGlyphs()
java.awt.font.GlyphVector.getNumGlyphs()


Occurences of getNumThumbnails

getNumThumbnails occurences:
javax.imageio.IIOImage.getNumThumbnails()
javax.imageio.ImageReader.getNumThumbnails(int)


Occurences of getNumXTiles

getNumXTiles occurences:
java.awt.image.BufferedImage.getNumXTiles()
java.awt.image.RenderedImage.getNumXTiles()


Occurences of getNumYTiles

getNumYTiles occurences:
java.awt.image.BufferedImage.getNumYTiles()
java.awt.image.RenderedImage.getNumYTiles()


Occurences of getObject

getObject occurences:
java.security.GuardedObject.getObject()
java.security.SignedObject.getObject()
java.sql.CallableStatement.getObject(int)
java.sql.CallableStatement.getObject(int, java.util.Map)
java.sql.CallableStatement.getObject(java.lang.String)
java.sql.CallableStatement.getObject(java.lang.String, java.util.Map)
java.sql.Ref.getObject()
java.sql.Ref.getObject(java.util.Map)
java.sql.ResultSet.getObject(int)
java.sql.ResultSet.getObject(int, java.util.Map)
java.sql.ResultSet.getObject(java.lang.String)
java.sql.ResultSet.getObject(java.lang.String, java.util.Map)
java.util.ResourceBundle.getObject(java.lang.String)
javax.crypto.SealedObject.getObject(java.security.Key)
javax.crypto.SealedObject.getObject(java.security.Key, java.lang.String)
javax.crypto.SealedObject.getObject(javax.crypto.Cipher)
javax.naming.Binding.getObject()
javax.naming.spi.DirStateFactory.Result.getObject()
javax.sql.rowset.serial.SerialJavaObject.getObject()
javax.sql.rowset.serial.SerialRef.getObject()
javax.sql.rowset.serial.SerialRef.getObject(java.util.Map)
javax.xml.bind.helpers.ValidationEventLocatorImpl.getObject()
javax.xml.bind.ValidationEventLocator.getObject()


Occurences of getObjectArrayMaxLength

getObjectArrayMaxLength occurences:
javax.imageio.metadata.IIOMetadataFormat.getObjectArrayMaxLength(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getObjectArrayMaxLength(java.lang.String)


Occurences of getObjectArrayMinLength

getObjectArrayMinLength occurences:
javax.imageio.metadata.IIOMetadataFormat.getObjectArrayMinLength(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getObjectArrayMinLength(java.lang.String)


Occurences of getObjectClass

getObjectClass occurences:
javax.imageio.metadata.IIOMetadataFormat.getObjectClass(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getObjectClass(java.lang.String)


Occurences of getObjectDefaultValue

getObjectDefaultValue occurences:
javax.imageio.metadata.IIOMetadataFormat.getObjectDefaultValue(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getObjectDefaultValue(java.lang.String)


Occurences of getObjectEnumerations

getObjectEnumerations occurences:
javax.imageio.metadata.IIOMetadataFormat.getObjectEnumerations(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getObjectEnumerations(java.lang.String)


Occurences of getObjectInstance

getObjectInstance occurences:
javax.management.MBeanServer.getObjectInstance(javax.management.ObjectName)
javax.management.MBeanServerConnection.getObjectInstance(javax.management.ObjectName)
javax.management.remote.rmi.RMIConnection.getObjectInstance(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.getObjectInstance(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.getObjectInstance(javax.management.ObjectName, javax.security.auth.Subject)
javax.naming.spi.DirectoryManager.getObjectInstance(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable, javax.naming.directory.Attributes)
javax.naming.spi.DirObjectFactory.getObjectInstance(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable, javax.naming.directory.Attributes)
javax.naming.spi.NamingManager.getObjectInstance(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable)
javax.naming.spi.ObjectFactory.getObjectInstance(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable)


Occurences of getObjectMaxValue

getObjectMaxValue occurences:
javax.imageio.metadata.IIOMetadataFormat.getObjectMaxValue(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getObjectMaxValue(java.lang.String)


Occurences of getObjectMinValue

getObjectMinValue occurences:
javax.imageio.metadata.IIOMetadataFormat.getObjectMinValue(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getObjectMinValue(java.lang.String)


Occurences of getObjectName

getObjectName occurences:
javax.management.MBeanServerInvocationHandler.getObjectName()
javax.management.ObjectInstance.getObjectName()
javax.management.relation.RelationNotification.getObjectName()


Occurences of getObjectValueType

getObjectValueType occurences:
javax.imageio.metadata.IIOMetadataFormat.getObjectValueType(java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.getObjectValueType(java.lang.String)


Occurences of getObservedAttribute

getObservedAttribute occurences:
javax.management.monitor.Monitor.getObservedAttribute()
javax.management.monitor.MonitorMBean.getObservedAttribute()
javax.management.monitor.MonitorNotification.getObservedAttribute()


Occurences of getObservedObject

getObservedObject occurences:
javax.management.monitor.Monitor.getObservedObject()
javax.management.monitor.MonitorMBean.getObservedObject()
javax.management.monitor.MonitorNotification.getObservedObject()


Occurences of getObservedObjects

getObservedObjects occurences:
javax.management.monitor.Monitor.getObservedObjects()
javax.management.monitor.MonitorMBean.getObservedObjects()


Occurences of getOffset

getOffset occurences:
java.awt.image.ComponentSampleModel.getOffset(int, int)
java.awt.image.ComponentSampleModel.getOffset(int, int, int)
java.awt.image.DataBuffer.getOffset()
java.awt.image.LookupTable.getOffset()
java.awt.image.MultiPixelPackedSampleModel.getOffset(int, int)
java.awt.image.SinglePixelPackedSampleModel.getOffset(int, int)
java.io.ObjectStreamField.getOffset()
java.net.DatagramPacket.getOffset()
java.text.CollationElementIterator.getOffset()
java.util.SimpleTimeZone.getOffset(int, int, int, int, int, int)
java.util.SimpleTimeZone.getOffset(long)
java.util.TimeZone.getOffset(int, int, int, int, int, int)
java.util.TimeZone.getOffset(long)
javax.imageio.stream.IIOByteBuffer.getOffset()
javax.management.monitor.CounterMonitor.getOffset()
javax.management.monitor.CounterMonitorMBean.getOffset()
javax.print.attribute.EnumSyntax.getOffset()
javax.print.attribute.standard.Finishings.getOffset()
javax.print.attribute.standard.OrientationRequested.getOffset()
javax.print.attribute.standard.PrintQuality.getOffset()
javax.swing.event.DocumentEvent.getOffset()
javax.swing.plaf.basic.BasicToolBarUI.DragWindow.getOffset()
javax.swing.text.AbstractDocument.DefaultDocumentEvent.getOffset()
javax.swing.text.BoxView.getOffset(int, int)
javax.swing.text.DefaultStyledDocument.ElementSpec.getOffset()
javax.swing.text.Position.getOffset()
javax.xml.bind.helpers.ValidationEventLocatorImpl.getOffset()
javax.xml.bind.ValidationEventLocator.getOffset()


Occurences of getOffsets

getOffsets occurences:
java.awt.image.DataBuffer.getOffsets()
java.awt.image.RescaleOp.getOffsets(float[])


Occurences of getOldValue

getOldValue occurences:
java.beans.PropertyChangeEvent.getOldValue()
javax.management.AttributeChangeNotification.getOldValue()


Occurences of getOpenType

getOpenType occurences:
javax.management.openmbean.OpenMBeanAttributeInfoSupport.getOpenType()
javax.management.openmbean.OpenMBeanParameterInfo.getOpenType()
javax.management.openmbean.OpenMBeanParameterInfoSupport.getOpenType()


Occurences of getOperation

getOperation occurences:
java.rmi.server.Operation.getOperation()
javax.management.modelmbean.ModelMBeanInfo.getOperation(java.lang.String)
javax.management.modelmbean.ModelMBeanInfoSupport.getOperation(java.lang.String)


Occurences of getOperations

getOperations occurences:
java.rmi.server.Skeleton.getOperations()
javax.management.MBeanInfo.getOperations()
javax.management.modelmbean.ModelMBeanInfo.getOperations()
javax.management.openmbean.OpenMBeanInfo.getOperations()


Occurences of getOptions

getOptions occurences:
com.sun.mirror.apt.AnnotationProcessorEnvironment.getOptions()
javax.annotation.processing.ProcessingEnvironment.getOptions()
javax.security.auth.callback.ConfirmationCallback.getOptions()
javax.security.auth.login.AppConfigurationEntry.getOptions()
javax.swing.JOptionPane.getOptions()


Occurences of getOptionType

getOptionType occurences:
javax.security.auth.callback.ConfirmationCallback.getOptionType()
javax.swing.JOptionPane.getOptionType()


Occurences of getOrientation

getOrientation occurences:
java.awt.Adjustable.getOrientation()
java.awt.ComponentOrientation.getOrientation(java.util.Locale)
java.awt.ComponentOrientation.getOrientation(java.util.ResourceBundle)
java.awt.print.PageFormat.getOrientation()
java.awt.Scrollbar.getOrientation()
java.awt.ScrollPaneAdjustable.getOrientation()
javax.swing.JProgressBar.getOrientation()
javax.swing.JScrollBar.getOrientation()
javax.swing.JSeparator.getOrientation()
javax.swing.JSlider.getOrientation()
javax.swing.JSplitPane.getOrientation()
javax.swing.JToolBar.getOrientation()
javax.swing.plaf.basic.BasicSplitPaneUI.getOrientation()
javax.swing.plaf.basic.BasicToolBarUI.DragWindow.getOrientation()


Occurences of getOriginal

getOriginal occurences:
javax.sql.rowset.CachedRowSet.getOriginal()
javax.sql.RowSetInternal.getOriginal()


Occurences of getOriginalRow

getOriginalRow occurences:
javax.sql.rowset.CachedRowSet.getOriginalRow()
javax.sql.RowSetInternal.getOriginalRow()


Occurences of getOriginatingProvider

getOriginatingProvider occurences:
javax.imageio.ImageReader.getOriginatingProvider()
javax.imageio.ImageWriter.getOriginatingProvider()


Occurences of getOtherPrimeInfo

getOtherPrimeInfo occurences:
java.security.interfaces.RSAMultiPrimePrivateCrtKey.getOtherPrimeInfo()
java.security.spec.RSAMultiPrimePrivateCrtKeySpec.getOtherPrimeInfo()


Occurences of getOutline

getOutline occurences:
java.awt.font.GlyphVector.getOutline()
java.awt.font.GlyphVector.getOutline(float, float)
java.awt.font.GraphicAttribute.getOutline(java.awt.geom.AffineTransform)
java.awt.font.ShapeGraphicAttribute.getOutline(java.awt.geom.AffineTransform)
java.awt.font.TextLayout.getOutline(java.awt.geom.AffineTransform)


Occurences of getOutputFormat

getOutputFormat occurences:
javax.print.StreamPrintService.getOutputFormat()
javax.print.StreamPrintServiceFactory.getOutputFormat()


Occurences of getOutputProperties

getOutputProperties occurences:
javax.xml.transform.Templates.getOutputProperties()
javax.xml.transform.Transformer.getOutputProperties()


Occurences of getOutputSize

getOutputSize occurences:
javax.crypto.Cipher.getOutputSize(int)
javax.crypto.ExemptionMechanism.getOutputSize(int)


Occurences of getOutputStream

getOutputStream occurences:
java.lang.Process.getOutputStream()
java.net.Socket.getOutputStream()
java.net.SocketImpl.getOutputStream()
java.net.URLConnection.getOutputStream()
java.rmi.server.LogStream.getOutputStream()
java.rmi.server.RemoteCall.getOutputStream()
javax.activation.DataHandler.getOutputStream()
javax.activation.DataSource.getOutputStream()
javax.activation.FileDataSource.getOutputStream()
javax.activation.URLDataSource.getOutputStream()
javax.print.StreamPrintService.getOutputStream()
javax.xml.transform.stream.StreamResult.getOutputStream()


Occurences of getOwner

getOwner occurences:
com.sun.mirror.declaration.TypeParameterDeclaration.getOwner()
java.awt.Window.getOwner()
java.beans.XMLDecoder.getOwner()
java.beans.XMLEncoder.getOwner()
java.util.concurrent.locks.ReentrantLock.getOwner()
java.util.concurrent.locks.ReentrantReadWriteLock.getOwner()


Occurences of getOwnerDocument

getOwnerDocument occurences:
javax.imageio.metadata.IIOMetadataNode.getOwnerDocument()
org.w3c.dom.Node.getOwnerDocument()


Occurences of getP

getP occurences:
java.security.interfaces.DSAParams.getP()
java.security.spec.DSAParameterSpec.getP()
java.security.spec.DSAPrivateKeySpec.getP()
java.security.spec.DSAPublicKeySpec.getP()
java.security.spec.ECFieldFp.getP()
javax.crypto.spec.DHParameterSpec.getP()
javax.crypto.spec.DHPrivateKeySpec.getP()
javax.crypto.spec.DHPublicKeySpec.getP()


Occurences of getP1

getP1 occurences:
java.awt.geom.CubicCurve2D.getP1()
java.awt.geom.CubicCurve2D.Double.getP1()
java.awt.geom.CubicCurve2D.Float.getP1()
java.awt.geom.Line2D.getP1()
java.awt.geom.Line2D.Double.getP1()
java.awt.geom.Line2D.Float.getP1()
java.awt.geom.QuadCurve2D.getP1()
java.awt.geom.QuadCurve2D.Double.getP1()
java.awt.geom.QuadCurve2D.Float.getP1()


Occurences of getP2

getP2 occurences:
java.awt.geom.CubicCurve2D.getP2()
java.awt.geom.CubicCurve2D.Double.getP2()
java.awt.geom.CubicCurve2D.Float.getP2()
java.awt.geom.Line2D.getP2()
java.awt.geom.Line2D.Double.getP2()
java.awt.geom.Line2D.Float.getP2()
java.awt.geom.QuadCurve2D.getP2()
java.awt.geom.QuadCurve2D.Double.getP2()
java.awt.geom.QuadCurve2D.Float.getP2()


Occurences of getPackage

getPackage occurences:
com.sun.mirror.apt.AnnotationProcessorEnvironment.getPackage(java.lang.String)
com.sun.mirror.declaration.TypeDeclaration.getPackage()
java.lang.Class.getPackage()
java.lang.ClassLoader.getPackage(java.lang.String)
java.lang.Package.getPackage(java.lang.String)


Occurences of getPackages

getPackages occurences:
java.lang.ClassLoader.getPackages()
java.lang.Package.getPackages()


Occurences of getPageFormat

getPageFormat occurences:
java.awt.print.Book.getPageFormat(int)
java.awt.print.Pageable.getPageFormat(int)
java.awt.print.PrinterJob.getPageFormat(javax.print.attribute.PrintRequestAttributeSet)


Occurences of getPainter

getPainter occurences:
javax.swing.plaf.synth.SynthStyle.getPainter(javax.swing.plaf.synth.SynthContext)
javax.swing.text.GlyphView.GlyphPainter.getPainter(javax.swing.text.GlyphView, int, int)
javax.swing.text.Highlighter.Highlight.getPainter()


Occurences of getParagraphElement

getParagraphElement occurences:
javax.swing.text.AbstractDocument.getParagraphElement(int)
javax.swing.text.DefaultStyledDocument.getParagraphElement(int)
javax.swing.text.PlainDocument.getParagraphElement(int)
javax.swing.text.StyledDocument.getParagraphElement(int)
javax.swing.text.Utilities.getParagraphElement(javax.swing.text.JTextComponent, int)


Occurences of getParameter

getParameter occurences:
com.sun.source.tree.CatchTree.getParameter()
java.applet.Applet.getParameter(java.lang.String)
java.applet.AppletStub.getParameter(java.lang.String)
java.awt.datatransfer.DataFlavor.getParameter(java.lang.String)
java.security.Signature.getParameter(java.lang.String)
java.sql.DataTruncation.getParameter()
javax.activation.MimeType.getParameter(java.lang.String)
javax.print.DocFlavor.getParameter(java.lang.String)
javax.script.ScriptEngineFactory.getParameter(java.lang.String)
javax.xml.transform.Transformer.getParameter(java.lang.String)
org.w3c.dom.DOMConfiguration.getParameter(java.lang.String)


Occurences of getParameterAnnotations

getParameterAnnotations occurences:
java.lang.reflect.Constructor.getParameterAnnotations()
java.lang.reflect.Method.getParameterAnnotations()


Occurences of getParameterName

getParameterName occurences:
javax.management.StandardMBean.getParameterName(javax.management.MBeanConstructorInfo, javax.management.MBeanParameterInfo, int)
javax.management.StandardMBean.getParameterName(javax.management.MBeanOperationInfo, javax.management.MBeanParameterInfo, int)


Occurences of getParameters

getParameters occurences:
com.sun.mirror.declaration.ExecutableDeclaration.getParameters()
com.sun.source.tree.MethodTree.getParameters()
java.awt.image.renderable.ParameterBlock.getParameters()
java.security.Policy.getParameters()
java.security.Signature.getParameters()
java.util.logging.LogRecord.getParameters()
javax.activation.MimeType.getParameters()
javax.crypto.Cipher.getParameters()
javax.lang.model.element.ExecutableElement.getParameters()
javax.net.ssl.CertPathTrustManagerParameters.getParameters()
javax.net.ssl.KeyStoreBuilderParameters.getParameters()
javax.security.auth.login.Configuration.getParameters()


Occurences of getParameterSpec

getParameterSpec occurences:
java.security.AlgorithmParameters.getParameterSpec(java.lang.Class)
javax.xml.crypto.AlgorithmMethod.getParameterSpec()
javax.xml.crypto.dsig.CanonicalizationMethod.getParameterSpec()
javax.xml.crypto.dsig.DigestMethod.getParameterSpec()
javax.xml.crypto.dsig.SignatureMethod.getParameterSpec()
javax.xml.crypto.dsig.Transform.getParameterSpec()


Occurences of getParameterTypes

getParameterTypes occurences:
java.lang.reflect.Constructor.getParameterTypes()
java.lang.reflect.Method.getParameterTypes()
javax.lang.model.type.ExecutableType.getParameterTypes()
javax.management.loading.MLetContent.getParameterTypes()


Occurences of getParams

getParams occurences:
java.security.interfaces.DSAKey.getParams()
java.security.interfaces.ECKey.getParams()
java.security.spec.ECPrivateKeySpec.getParams()
java.security.spec.ECPublicKeySpec.getParams()
javax.crypto.interfaces.DHKey.getParams()
javax.sql.rowset.BaseRowSet.getParams()
javax.sql.RowSetInternal.getParams()


Occurences of getParent

getParent occurences:
java.awt.Component.getParent()
java.awt.image.Raster.getParent()
java.awt.MenuComponent.getParent()
java.awt.PopupMenu.getParent()
java.io.File.getParent()
java.lang.ClassLoader.getParent()
java.lang.ThreadGroup.getParent()
java.net.NetworkInterface.getParent()
java.security.cert.PolicyNode.getParent()
java.util.logging.Logger.getParent()
java.util.prefs.NodeChangeEvent.getParent()
javax.swing.ActionMap.getParent()
javax.swing.InputMap.getParent()
javax.swing.text.AbstractDocument.AbstractElement.getParent()
javax.swing.text.View.getParent()
javax.swing.tree.DefaultMutableTreeNode.getParent()
javax.swing.tree.TreeNode.getParent()
javax.xml.crypto.dsig.dom.DOMSignContext.getParent()
javax.xml.stream.util.EventReaderDelegate.getParent()
javax.xml.stream.util.StreamReaderDelegate.getParent()
org.xml.sax.helpers.XMLFilterImpl.getParent()
org.xml.sax.XMLFilter.getParent()


Occurences of getParentElement

getParentElement occurences:
javax.swing.text.AbstractDocument.AbstractElement.getParentElement()
javax.swing.text.Element.getParentElement()
javax.xml.soap.Node.getParentElement()


Occurences of getParentNode

getParentNode occurences:
javax.imageio.metadata.IIOMetadataNode.getParentNode()
org.w3c.dom.Node.getParentNode()


Occurences of getParentPath

getParentPath occurences:
com.sun.source.util.TreePath.getParentPath()
javax.swing.tree.TreePath.getParentPath()


Occurences of getParser

getParser occurences:
javax.swing.text.html.HTMLDocument.getParser()
javax.swing.text.html.HTMLEditorKit.getParser()
javax.xml.parsers.SAXParser.getParser()


Occurences of getPartialSpan

getPartialSpan occurences:
javax.swing.text.GlyphView.getPartialSpan(int, int)
javax.swing.text.TabableView.getPartialSpan(int, int)


Occurences of getPassword

getPassword occurences:
java.net.PasswordAuthentication.getPassword()
java.security.KeyStore.PasswordProtection.getPassword()
javax.crypto.interfaces.PBEKey.getPassword()
javax.crypto.spec.PBEKeySpec.getPassword()
javax.security.auth.callback.PasswordCallback.getPassword()
javax.sql.RowSet.getPassword()
javax.sql.rowset.BaseRowSet.getPassword()
javax.swing.JPasswordField.getPassword()


Occurences of getPath

getPath occurences:
com.sun.source.util.TreePath.getPath(com.sun.source.tree.CompilationUnitTree, com.sun.source.tree.Tree)
com.sun.source.util.TreePath.getPath(com.sun.source.util.TreePath, com.sun.source.tree.Tree)
com.sun.source.util.Trees.getPath(com.sun.source.tree.CompilationUnitTree, com.sun.source.tree.Tree)
com.sun.source.util.Trees.getPath(javax.lang.model.element.Element)
com.sun.source.util.Trees.getPath(javax.lang.model.element.Element, javax.lang.model.element.AnnotationMirror)
com.sun.source.util.Trees.getPath(javax.lang.model.element.Element, javax.lang.model.element.AnnotationMirror, javax.lang.model.element.AnnotationValue)
java.io.File.getPath()
java.net.HttpCookie.getPath()
java.net.URI.getPath()
java.net.URL.getPath()
javax.swing.event.MenuDragMouseEvent.getPath()
javax.swing.event.MenuKeyEvent.getPath()
javax.swing.event.TreeExpansionEvent.getPath()
javax.swing.event.TreeModelEvent.getPath()
javax.swing.event.TreeSelectionEvent.getPath()
javax.swing.JTree.DropLocation.getPath()
javax.swing.plaf.basic.BasicMenuItemUI.getPath()
javax.swing.tree.DefaultMutableTreeNode.getPath()
javax.swing.tree.TreePath.getPath()


Occurences of getPathBounds

getPathBounds occurences:
javax.swing.JTree.getPathBounds(javax.swing.tree.TreePath)
javax.swing.plaf.basic.BasicTreeUI.getPathBounds(javax.swing.JTree, javax.swing.tree.TreePath)
javax.swing.plaf.multi.MultiTreeUI.getPathBounds(javax.swing.JTree, javax.swing.tree.TreePath)
javax.swing.plaf.TreeUI.getPathBounds(javax.swing.JTree, javax.swing.tree.TreePath)


Occurences of getPathClosestTo

getPathClosestTo occurences:
javax.swing.tree.AbstractLayoutCache.getPathClosestTo(int, int)
javax.swing.tree.FixedHeightLayoutCache.getPathClosestTo(int, int)
javax.swing.tree.VariableHeightLayoutCache.getPathClosestTo(int, int)


Occurences of getPathForRow

getPathForRow occurences:
javax.swing.JTree.getPathForRow(int)
javax.swing.plaf.basic.BasicTreeUI.getPathForRow(javax.swing.JTree, int)
javax.swing.plaf.multi.MultiTreeUI.getPathForRow(javax.swing.JTree, int)
javax.swing.plaf.TreeUI.getPathForRow(javax.swing.JTree, int)
javax.swing.tree.AbstractLayoutCache.getPathForRow(int)
javax.swing.tree.FixedHeightLayoutCache.getPathForRow(int)
javax.swing.tree.VariableHeightLayoutCache.getPathForRow(int)


Occurences of getPathIterator

getPathIterator occurences:
java.awt.geom.Arc2D.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.Area.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.Area.getPathIterator(java.awt.geom.AffineTransform, double)
java.awt.geom.CubicCurve2D.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.CubicCurve2D.getPathIterator(java.awt.geom.AffineTransform, double)
java.awt.geom.Ellipse2D.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.Line2D.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.Line2D.getPathIterator(java.awt.geom.AffineTransform, double)
java.awt.geom.Path2D.getPathIterator(java.awt.geom.AffineTransform, double)
java.awt.geom.Path2D.Double.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.Path2D.Float.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.QuadCurve2D.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.QuadCurve2D.getPathIterator(java.awt.geom.AffineTransform, double)
java.awt.geom.Rectangle2D.getPathIterator(java.awt.geom.AffineTransform)
java.awt.geom.Rectangle2D.getPathIterator(java.awt.geom.AffineTransform, double)
java.awt.geom.RectangularShape.getPathIterator(java.awt.geom.AffineTransform, double)
java.awt.geom.RoundRectangle2D.getPathIterator(java.awt.geom.AffineTransform)
java.awt.Polygon.getPathIterator(java.awt.geom.AffineTransform)
java.awt.Polygon.getPathIterator(java.awt.geom.AffineTransform, double)
java.awt.Shape.getPathIterator(java.awt.geom.AffineTransform)
java.awt.Shape.getPathIterator(java.awt.geom.AffineTransform, double)


Occurences of getPathToRoot

getPathToRoot occurences:
javax.swing.tree.DefaultMutableTreeNode.getPathToRoot(javax.swing.tree.TreeNode, int)
javax.swing.tree.DefaultTreeModel.getPathToRoot(javax.swing.tree.TreeNode)
javax.swing.tree.DefaultTreeModel.getPathToRoot(javax.swing.tree.TreeNode, int)


Occurences of getPayload

getPayload occurences:
javax.xml.ws.LogicalMessage.getPayload()
javax.xml.ws.LogicalMessage.getPayload(javax.xml.bind.JAXBContext)


Occurences of getPeer

getPeer occurences:
java.awt.Component.getPeer()
java.awt.Font.getPeer()
java.awt.MenuComponent.getPeer()


Occurences of getPeerCertificateChain

getPeerCertificateChain occurences:
javax.net.ssl.HandshakeCompletedEvent.getPeerCertificateChain()
javax.net.ssl.SSLSession.getPeerCertificateChain()


Occurences of getPeerCertificates

getPeerCertificates occurences:
javax.net.ssl.HandshakeCompletedEvent.getPeerCertificates()
javax.net.ssl.SSLSession.getPeerCertificates()


Occurences of getPeerHost

getPeerHost occurences:
javax.net.ssl.SSLEngine.getPeerHost()
javax.net.ssl.SSLSession.getPeerHost()


Occurences of getPeerPort

getPeerPort occurences:
javax.net.ssl.SSLEngine.getPeerPort()
javax.net.ssl.SSLSession.getPeerPort()


Occurences of getPeerPrincipal

getPeerPrincipal occurences:
java.net.SecureCacheResponse.getPeerPrincipal()
javax.net.ssl.HandshakeCompletedEvent.getPeerPrincipal()
javax.net.ssl.HttpsURLConnection.getPeerPrincipal()
javax.net.ssl.SSLSession.getPeerPrincipal()


Occurences of getPercentInstance

getPercentInstance occurences:
java.text.NumberFormat.getPercentInstance()
java.text.NumberFormat.getPercentInstance(java.util.Locale)
java.text.spi.NumberFormatProvider.getPercentInstance(java.util.Locale)


Occurences of getPeriod

getPeriod occurences:
javax.management.timer.Timer.getPeriod(java.lang.Integer)
javax.management.timer.TimerMBean.getPeriod(java.lang.Integer)


Occurences of getPermission

getPermission occurences:
java.net.HttpURLConnection.getPermission()
java.net.URLConnection.getPermission()
java.security.AccessControlException.getPermission()


Occurences of getPermissions

getPermissions occurences:
java.net.URLClassLoader.getPermissions(java.security.CodeSource)
java.security.acl.Acl.getPermissions(java.security.Principal)
java.security.Policy.getPermissions(java.security.CodeSource)
java.security.Policy.getPermissions(java.security.ProtectionDomain)
java.security.ProtectionDomain.getPermissions()
java.security.SecureClassLoader.getPermissions(java.security.CodeSource)
javax.security.auth.Policy.getPermissions(javax.security.auth.Subject, java.security.CodeSource)


Occurences of getPIData

getPIData occurences:
javax.xml.stream.util.StreamReaderDelegate.getPIData()
javax.xml.stream.XMLStreamReader.getPIData()


Occurences of getPITarget

getPITarget occurences:
javax.xml.stream.util.StreamReaderDelegate.getPITarget()
javax.xml.stream.XMLStreamReader.getPITarget()


Occurences of getPixel

getPixel occurences:
java.awt.image.BandedSampleModel.getPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.getPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.MultiPixelPackedSampleModel.getPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.Raster.getPixel(int, int, double[])
java.awt.image.Raster.getPixel(int, int, float[])
java.awt.image.Raster.getPixel(int, int, int[])
java.awt.image.SampleModel.getPixel(int, int, double[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.getPixel(int, int, float[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.getPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.getPixel(int, int, int[], java.awt.image.DataBuffer)


Occurences of getPixelBounds

getPixelBounds occurences:
java.awt.font.GlyphVector.getPixelBounds(java.awt.font.FontRenderContext, float, float)
java.awt.font.TextLayout.getPixelBounds(java.awt.font.FontRenderContext, float, float)


Occurences of getPixels

getPixels occurences:
java.awt.image.BandedSampleModel.getPixels(int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.getPixels(int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.PixelGrabber.getPixels()
java.awt.image.Raster.getPixels(int, int, int, int, double[])
java.awt.image.Raster.getPixels(int, int, int, int, float[])
java.awt.image.Raster.getPixels(int, int, int, int, int[])
java.awt.image.SampleModel.getPixels(int, int, int, int, double[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.getPixels(int, int, int, int, float[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.getPixels(int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.getPixels(int, int, int, int, int[], java.awt.image.DataBuffer)


Occurences of getPoint2D

getPoint2D occurences:
java.awt.image.AffineTransformOp.getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.image.BandCombineOp.getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.image.BufferedImageOp.getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.image.ColorConvertOp.getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.image.ConvolveOp.getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.image.LookupOp.getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.image.RasterOp.getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.image.RescaleOp.getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)


Occurences of getPointSize

getPointSize occurences:
javax.swing.text.html.StyleSheet.getPointSize(int)
javax.swing.text.html.StyleSheet.getPointSize(java.lang.String)


Occurences of getPolicy

getPolicy occurences:
java.security.cert.X509CertSelector.getPolicy()
java.security.Policy.getPolicy()
javax.security.auth.Policy.getPolicy()


Occurences of getPooledConnection

getPooledConnection occurences:
javax.sql.ConnectionPoolDataSource.getPooledConnection()
javax.sql.ConnectionPoolDataSource.getPooledConnection(java.lang.String, java.lang.String)


Occurences of getPopup

getPopup occurences:
javax.swing.plaf.multi.MultiPopupMenuUI.getPopup(javax.swing.JPopupMenu, int, int)
javax.swing.plaf.PopupMenuUI.getPopup(javax.swing.JPopupMenu, int, int)
javax.swing.PopupFactory.getPopup(java.awt.Component, java.awt.Component, int, int)


Occurences of getPopupMenu

getPopupMenu occurences:
java.awt.TrayIcon.getPopupMenu()
javax.swing.JMenu.getPopupMenu()


Occurences of getPopupMenuListeners

getPopupMenuListeners occurences:
javax.swing.JComboBox.getPopupMenuListeners()
javax.swing.JPopupMenu.getPopupMenuListeners()


Occurences of getPort

getPort occurences:
java.net.DatagramPacket.getPort()
java.net.DatagramSocket.getPort()
java.net.InetSocketAddress.getPort()
java.net.Socket.getPort()
java.net.SocketImpl.getPort()
java.net.URI.getPort()
java.net.URL.getPort()
java.security.cert.LDAPCertStoreParameters.getPort()
javax.management.remote.JMXServiceURL.getPort()
javax.xml.ws.Service.getPort(java.lang.Class)
javax.xml.ws.Service.getPort(javax.xml.namespace.QName, java.lang.Class)
javax.xml.ws.spi.ServiceDelegate.getPort(java.lang.Class)
javax.xml.ws.spi.ServiceDelegate.getPort(javax.xml.namespace.QName, java.lang.Class)


Occurences of getPorts

getPorts occurences:
javax.xml.ws.Service.getPorts()
javax.xml.ws.spi.ServiceDelegate.getPorts()


Occurences of getPosition

getPosition occurences:
com.sun.mirror.declaration.AnnotationMirror.getPosition()
com.sun.mirror.declaration.AnnotationValue.getPosition()
com.sun.mirror.declaration.Declaration.getPosition()
com.sun.source.tree.LineMap.getPosition(long, long)
java.awt.font.LineBreakMeasurer.getPosition()
javax.swing.JLayeredPane.getPosition(java.awt.Component)
javax.swing.SizeSequence.getPosition(int)
javax.swing.text.TabStop.getPosition()
javax.tools.Diagnostic.getPosition()
org.w3c.dom.ls.LSProgressEvent.getPosition()


Occurences of getPositionsInRange

getPositionsInRange occurences:
javax.swing.text.GapContent.getPositionsInRange(java.util.Vector, int, int)
javax.swing.text.StringContent.getPositionsInRange(java.util.Vector, int, int)


Occurences of getPrecision

getPrecision occurences:
java.math.MathContext.getPrecision()
java.sql.ParameterMetaData.getPrecision(int)
java.sql.ResultSetMetaData.getPrecision(int)
java.util.IllegalFormatPrecisionException.getPrecision()
javax.sound.sampled.FloatControl.getPrecision()
javax.sql.rowset.RowSetMetaDataImpl.getPrecision(int)


Occurences of getPreferredCommands

getPreferredCommands occurences:
javax.activation.CommandMap.getPreferredCommands(java.lang.String)
javax.activation.CommandMap.getPreferredCommands(java.lang.String, javax.activation.DataSource)
javax.activation.DataHandler.getPreferredCommands()
javax.activation.MailcapCommandMap.getPreferredCommands(java.lang.String)


Occurences of getPreferredHeight

getPreferredHeight occurences:
javax.swing.tree.AbstractLayoutCache.getPreferredHeight()
javax.swing.tree.VariableHeightLayoutCache.getPreferredHeight()


Occurences of getPreferredScrollableViewportSize

getPreferredScrollableViewportSize occurences:
javax.swing.JList.getPreferredScrollableViewportSize()
javax.swing.JTable.getPreferredScrollableViewportSize()
javax.swing.JTextArea.getPreferredScrollableViewportSize()
javax.swing.JTree.getPreferredScrollableViewportSize()
javax.swing.Scrollable.getPreferredScrollableViewportSize()
javax.swing.text.JTextComponent.getPreferredScrollableViewportSize()


Occurences of getPreferredSize

getPreferredSize occurences:
java.awt.Component.getPreferredSize()
java.awt.Container.getPreferredSize()
java.awt.List.getPreferredSize()
java.awt.List.getPreferredSize(int)
java.awt.TextArea.getPreferredSize()
java.awt.TextArea.getPreferredSize(int, int)
java.awt.TextField.getPreferredSize()
java.awt.TextField.getPreferredSize(int)
javax.swing.JComponent.getPreferredSize()
javax.swing.JEditorPane.getPreferredSize()
javax.swing.JTextArea.getPreferredSize()
javax.swing.JTextField.getPreferredSize()
javax.swing.JToolBar.Separator.getPreferredSize()
javax.swing.plaf.basic.BasicArrowButton.getPreferredSize()
javax.swing.plaf.basic.BasicButtonUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicComboBoxRenderer.getPreferredSize()
javax.swing.plaf.basic.BasicComboBoxUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopIconUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicInternalFrameUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicLabelUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicListUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuItemUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicOptionPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPopupMenuSeparatorUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicProgressBarUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicRadioButtonUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollBarUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSeparatorUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSplitPaneDivider.getPreferredSize()
javax.swing.plaf.basic.BasicSplitPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableHeaderUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextAreaUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolBarSeparatorUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolTipUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.getPreferredSize(javax.swing.JComponent, boolean)
javax.swing.plaf.ComponentUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalDesktopIconUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalFileChooserUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalPopupMenuSeparatorUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollBarUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollButton.getPreferredSize()
javax.swing.plaf.metal.MetalSeparatorUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolTipUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiButtonUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.getPreferredSize(javax.swing.JComponent)
javax.swing.plaf.synth.SynthGraphicsUtils.getPreferredSize(javax.swing.plaf.synth.SynthContext, java.awt.Font, java.lang.String, javax.swing.Icon, int, int, int, int, int, int)
javax.swing.tree.DefaultTreeCellEditor.DefaultTextField.getPreferredSize()
javax.swing.tree.DefaultTreeCellEditor.EditorContainer.getPreferredSize()
javax.swing.tree.DefaultTreeCellRenderer.getPreferredSize()


Occurences of getPreferredSpan

getPreferredSpan occurences:
javax.swing.text.AsyncBoxView.getPreferredSpan(int)
javax.swing.text.BoxView.getPreferredSpan(int)
javax.swing.text.ComponentView.getPreferredSpan(int)
javax.swing.text.FieldView.getPreferredSpan(int)
javax.swing.text.GlyphView.getPreferredSpan(int)
javax.swing.text.html.BlockView.getPreferredSpan(int)
javax.swing.text.html.ImageView.getPreferredSpan(int)
javax.swing.text.html.ParagraphView.getPreferredSpan(int)
javax.swing.text.IconView.getPreferredSpan(int)
javax.swing.text.PasswordView.getPreferredSpan(int)
javax.swing.text.PlainView.getPreferredSpan(int)
javax.swing.text.View.getPreferredSpan(int)
javax.swing.text.WrappedPlainView.getPreferredSpan(int)


Occurences of getPreferredWidth

getPreferredWidth occurences:
javax.swing.table.TableColumn.getPreferredWidth()
javax.swing.tree.AbstractLayoutCache.getPreferredWidth(java.awt.Rectangle)
javax.swing.tree.VariableHeightLayoutCache.getPreferredWidth(java.awt.Rectangle)


Occurences of getPrefix

getPrefix occurences:
javax.imageio.metadata.IIOMetadataNode.getPrefix()
javax.naming.CompositeName.getPrefix(int)
javax.naming.CompoundName.getPrefix(int)
javax.naming.ldap.LdapName.getPrefix(int)
javax.naming.Name.getPrefix(int)
javax.xml.namespace.NamespaceContext.getPrefix(java.lang.String)
javax.xml.namespace.QName.getPrefix()
javax.xml.soap.Name.getPrefix()
javax.xml.stream.events.Namespace.getPrefix()
javax.xml.stream.util.StreamReaderDelegate.getPrefix()
javax.xml.stream.XMLEventWriter.getPrefix(java.lang.String)
javax.xml.stream.XMLStreamReader.getPrefix()
javax.xml.stream.XMLStreamWriter.getPrefix(java.lang.String)
org.w3c.dom.Node.getPrefix()
org.xml.sax.helpers.NamespaceSupport.getPrefix(java.lang.String)


Occurences of getPrefixes

getPrefixes occurences:
javax.xml.namespace.NamespaceContext.getPrefixes(java.lang.String)
org.xml.sax.helpers.NamespaceSupport.getPrefixes()
org.xml.sax.helpers.NamespaceSupport.getPrefixes(java.lang.String)


Occurences of getPresentationName

getPresentationName occurences:
javax.swing.text.AbstractDocument.DefaultDocumentEvent.getPresentationName()
javax.swing.undo.AbstractUndoableEdit.getPresentationName()
javax.swing.undo.CompoundEdit.getPresentationName()
javax.swing.undo.StateEdit.getPresentationName()
javax.swing.undo.UndoableEdit.getPresentationName()


Occurences of getPreviewPanel

getPreviewPanel occurences:
javax.swing.colorchooser.ColorChooserComponentFactory.getPreviewPanel()
javax.swing.JColorChooser.getPreviewPanel()


Occurences of getPreviousSibling

getPreviousSibling occurences:
javax.imageio.metadata.IIOMetadataNode.getPreviousSibling()
javax.swing.tree.DefaultMutableTreeNode.getPreviousSibling()
org.w3c.dom.Node.getPreviousSibling()


Occurences of getPreviousValue

getPreviousValue occurences:
javax.swing.JSpinner.getPreviousValue()
javax.swing.SpinnerDateModel.getPreviousValue()
javax.swing.SpinnerListModel.getPreviousValue()
javax.swing.SpinnerModel.getPreviousValue()
javax.swing.SpinnerNumberModel.getPreviousValue()


Occurences of getPrimary1

getPrimary1 occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getPrimary1()
javax.swing.plaf.metal.MetalTheme.getPrimary1()
javax.swing.plaf.metal.OceanTheme.getPrimary1()


Occurences of getPrimary2

getPrimary2 occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getPrimary2()
javax.swing.plaf.metal.MetalTheme.getPrimary2()
javax.swing.plaf.metal.OceanTheme.getPrimary2()


Occurences of getPrimary3

getPrimary3 occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getPrimary3()
javax.swing.plaf.metal.MetalTheme.getPrimary3()
javax.swing.plaf.metal.OceanTheme.getPrimary3()


Occurences of getPrimaryControl

getPrimaryControl occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getPrimaryControl()
javax.swing.plaf.metal.MetalTheme.getPrimaryControl()


Occurences of getPrimaryControlDarkShadow

getPrimaryControlDarkShadow occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getPrimaryControlDarkShadow()
javax.swing.plaf.metal.MetalTheme.getPrimaryControlDarkShadow()


Occurences of getPrimaryControlHighlight

getPrimaryControlHighlight occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getPrimaryControlHighlight()
javax.swing.plaf.metal.MetalTheme.getPrimaryControlHighlight()


Occurences of getPrimaryControlInfo

getPrimaryControlInfo occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getPrimaryControlInfo()
javax.swing.plaf.metal.MetalTheme.getPrimaryControlInfo()


Occurences of getPrimaryControlShadow

getPrimaryControlShadow occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getPrimaryControlShadow()
javax.swing.plaf.metal.MetalTheme.getPrimaryControlShadow()


Occurences of getPrimaryType

getPrimaryType occurences:
java.awt.datatransfer.DataFlavor.getPrimaryType()
javax.activation.MimeType.getPrimaryType()


Occurences of getPrimeExponentP

getPrimeExponentP occurences:
java.security.interfaces.RSAMultiPrimePrivateCrtKey.getPrimeExponentP()
java.security.interfaces.RSAPrivateCrtKey.getPrimeExponentP()
java.security.spec.RSAMultiPrimePrivateCrtKeySpec.getPrimeExponentP()
java.security.spec.RSAPrivateCrtKeySpec.getPrimeExponentP()


Occurences of getPrimeExponentQ

getPrimeExponentQ occurences:
java.security.interfaces.RSAMultiPrimePrivateCrtKey.getPrimeExponentQ()
java.security.interfaces.RSAPrivateCrtKey.getPrimeExponentQ()
java.security.spec.RSAMultiPrimePrivateCrtKeySpec.getPrimeExponentQ()
java.security.spec.RSAPrivateCrtKeySpec.getPrimeExponentQ()


Occurences of getPrimeP

getPrimeP occurences:
java.security.interfaces.RSAMultiPrimePrivateCrtKey.getPrimeP()
java.security.interfaces.RSAPrivateCrtKey.getPrimeP()
java.security.spec.RSAMultiPrimePrivateCrtKeySpec.getPrimeP()
java.security.spec.RSAPrivateCrtKeySpec.getPrimeP()


Occurences of getPrimeQ

getPrimeQ occurences:
java.security.interfaces.RSAMultiPrimePrivateCrtKey.getPrimeQ()
java.security.interfaces.RSAPrivateCrtKey.getPrimeQ()
java.security.spec.RSAMultiPrimePrivateCrtKeySpec.getPrimeQ()
java.security.spec.RSAPrivateCrtKeySpec.getPrimeQ()


Occurences of getPrimitiveType

getPrimitiveType occurences:
com.sun.mirror.util.Types.getPrimitiveType(com.sun.mirror.type.PrimitiveType.Kind)
javax.lang.model.util.Types.getPrimitiveType(javax.lang.model.type.TypeKind)


Occurences of getPrincipal

getPrincipal occurences:
java.security.acl.AclEntry.getPrincipal()
java.security.Certificate.getPrincipal()
javax.security.auth.kerberos.KerberosKey.getPrincipal()


Occurences of getPrincipals

getPrincipals occurences:
java.security.ProtectionDomain.getPrincipals()
javax.security.auth.PrivateCredentialPermission.getPrincipals()
javax.security.auth.Subject.getPrincipals()
javax.security.auth.Subject.getPrincipals(java.lang.Class)


Occurences of getPrintable

getPrintable occurences:
java.awt.print.Book.getPrintable(int)
java.awt.print.Pageable.getPrintable(int)
javax.swing.JTable.getPrintable(javax.swing.JTable.PrintMode, java.text.MessageFormat, java.text.MessageFormat)
javax.swing.text.JTextComponent.getPrintable(java.text.MessageFormat, java.text.MessageFormat)


Occurences of getPrintData

getPrintData occurences:
javax.print.Doc.getPrintData()
javax.print.SimpleDoc.getPrintData()


Occurences of getPrinterJob

getPrinterJob occurences:
java.awt.print.PrinterGraphics.getPrinterJob()
java.awt.print.PrinterJob.getPrinterJob()


Occurences of getPrintJob

getPrintJob occurences:
java.awt.PrintGraphics.getPrintJob()
java.awt.Toolkit.getPrintJob(java.awt.Frame, java.lang.String, java.awt.JobAttributes, java.awt.PageAttributes)
java.awt.Toolkit.getPrintJob(java.awt.Frame, java.lang.String, java.util.Properties)
javax.print.event.PrintJobAttributeEvent.getPrintJob()
javax.print.event.PrintJobEvent.getPrintJob()


Occurences of getPrintService

getPrintService occurences:
java.awt.print.PrinterJob.getPrintService()
javax.print.DocPrintJob.getPrintService()
javax.print.event.PrintServiceAttributeEvent.getPrintService()
javax.print.StreamPrintServiceFactory.getPrintService(java.io.OutputStream)


Occurences of getPrintServices

getPrintServices occurences:
javax.print.PrintServiceLookup.getPrintServices()
javax.print.PrintServiceLookup.getPrintServices(javax.print.DocFlavor, javax.print.attribute.AttributeSet)


Occurences of getPrivateCredentials

getPrivateCredentials occurences:
javax.security.auth.Subject.getPrivateCredentials()
javax.security.auth.Subject.getPrivateCredentials(java.lang.Class)


Occurences of getPrivateExponent

getPrivateExponent occurences:
java.security.interfaces.RSAPrivateKey.getPrivateExponent()
java.security.spec.RSAPrivateKeySpec.getPrivateExponent()


Occurences of getPrivateKey

getPrivateKey occurences:
java.security.KeyStore.PrivateKeyEntry.getPrivateKey()
java.security.Signer.getPrivateKey()
javax.net.ssl.X509KeyManager.getPrivateKey(java.lang.String)
javax.security.auth.x500.X500PrivateCredential.getPrivateKey()


Occurences of getProgram

getProgram occurences:
javax.script.ScriptEngineFactory.getProgram(java.lang.String...)
javax.sound.midi.MidiChannel.getProgram()
javax.sound.midi.Patch.getProgram()


Occurences of getPrompt

getPrompt occurences:
javax.security.auth.callback.ChoiceCallback.getPrompt()
javax.security.auth.callback.ConfirmationCallback.getPrompt()
javax.security.auth.callback.NameCallback.getPrompt()
javax.security.auth.callback.PasswordCallback.getPrompt()
javax.security.auth.callback.TextInputCallback.getPrompt()


Occurences of getProperties

getProperties occurences:
java.lang.System.getProperties()
javax.xml.crypto.dsig.SignatureProperties.getProperties()
javax.xml.ws.Endpoint.getProperties()


Occurences of getProperty

getProperty occurences:
com.sun.jdi.request.EventRequest.getProperty(java.lang.Object)
java.awt.Image.getProperty(java.lang.String, java.awt.image.ImageObserver)
java.awt.image.BufferedImage.getProperty(java.lang.String)
java.awt.image.BufferedImage.getProperty(java.lang.String, java.awt.image.ImageObserver)
java.awt.image.renderable.ContextualRenderedImageFactory.getProperty(java.awt.image.renderable.ParameterBlock, java.lang.String)
java.awt.image.renderable.RenderableImage.getProperty(java.lang.String)
java.awt.image.renderable.RenderableImageOp.getProperty(java.lang.String)
java.awt.image.RenderedImage.getProperty(java.lang.String)
java.awt.Toolkit.getProperty(java.lang.String, java.lang.String)
java.lang.System.getProperty(java.lang.String)
java.lang.System.getProperty(java.lang.String, java.lang.String)
java.security.Provider.getProperty(java.lang.String)
java.security.Security.getProperty(java.lang.String)
java.util.logging.LogManager.getProperty(java.lang.String)
java.util.Properties.getProperty(java.lang.String)
java.util.Properties.getProperty(java.lang.String, java.lang.String)
javax.sound.midi.MidiFileFormat.getProperty(java.lang.String)
javax.sound.sampled.AudioFileFormat.getProperty(java.lang.String)
javax.sound.sampled.AudioFormat.getProperty(java.lang.String)
javax.swing.text.AbstractDocument.getProperty(java.lang.Object)
javax.swing.text.Document.getProperty(java.lang.Object)
javax.xml.bind.Binder.getProperty(java.lang.String)
javax.xml.bind.helpers.AbstractMarshallerImpl.getProperty(java.lang.String)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.getProperty(java.lang.String)
javax.xml.bind.Marshaller.getProperty(java.lang.String)
javax.xml.bind.Unmarshaller.getProperty(java.lang.String)
javax.xml.bind.Validator.getProperty(java.lang.String)
javax.xml.crypto.dom.DOMCryptoContext.getProperty(java.lang.String)
javax.xml.crypto.XMLCryptoContext.getProperty(java.lang.String)
javax.xml.parsers.SAXParser.getProperty(java.lang.String)
javax.xml.soap.SOAPMessage.getProperty(java.lang.String)
javax.xml.stream.util.EventReaderDelegate.getProperty(java.lang.String)
javax.xml.stream.util.StreamReaderDelegate.getProperty(java.lang.String)
javax.xml.stream.XMLEventReader.getProperty(java.lang.String)
javax.xml.stream.XMLInputFactory.getProperty(java.lang.String)
javax.xml.stream.XMLOutputFactory.getProperty(java.lang.String)
javax.xml.stream.XMLStreamReader.getProperty(java.lang.String)
javax.xml.stream.XMLStreamWriter.getProperty(java.lang.String)
javax.xml.validation.SchemaFactory.getProperty(java.lang.String)
javax.xml.validation.Validator.getProperty(java.lang.String)
javax.xml.validation.ValidatorHandler.getProperty(java.lang.String)
org.xml.sax.helpers.ParserAdapter.getProperty(java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.getProperty(java.lang.String)
org.xml.sax.XMLReader.getProperty(java.lang.String)


Occurences of getPropertyChangeListeners

getPropertyChangeListeners occurences:
java.awt.Component.getPropertyChangeListeners()
java.awt.Component.getPropertyChangeListeners(java.lang.String)
java.awt.KeyboardFocusManager.getPropertyChangeListeners()
java.awt.KeyboardFocusManager.getPropertyChangeListeners(java.lang.String)
java.awt.SystemTray.getPropertyChangeListeners(java.lang.String)
java.awt.Toolkit.getPropertyChangeListeners()
java.awt.Toolkit.getPropertyChangeListeners(java.lang.String)
java.beans.PropertyChangeSupport.getPropertyChangeListeners()
java.beans.PropertyChangeSupport.getPropertyChangeListeners(java.lang.String)
javax.swing.AbstractAction.getPropertyChangeListeners()
javax.swing.plaf.basic.BasicDirectoryModel.getPropertyChangeListeners()
javax.swing.table.TableColumn.getPropertyChangeListeners()
javax.swing.tree.DefaultTreeSelectionModel.getPropertyChangeListeners()
javax.swing.UIDefaults.getPropertyChangeListeners()
javax.swing.UIManager.getPropertyChangeListeners()


Occurences of getPropertyDescriptors

getPropertyDescriptors occurences:
java.beans.BeanInfo.getPropertyDescriptors()
java.beans.SimpleBeanInfo.getPropertyDescriptors()


Occurences of getPropertyName

getPropertyName occurences:
java.beans.PropertyChangeEvent.getPropertyName()
java.beans.PropertyChangeListenerProxy.getPropertyName()
java.beans.VetoableChangeListenerProxy.getPropertyName()


Occurences of getPropertyNames

getPropertyNames occurences:
java.awt.image.BufferedImage.getPropertyNames()
java.awt.image.renderable.ContextualRenderedImageFactory.getPropertyNames()
java.awt.image.renderable.RenderableImage.getPropertyNames()
java.awt.image.renderable.RenderableImageOp.getPropertyNames()
java.awt.image.RenderedImage.getPropertyNames()


Occurences of getPropertyPrefix

getPropertyPrefix occurences:
javax.swing.plaf.basic.BasicButtonUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicCheckBoxMenuItemUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicCheckBoxUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicEditorPaneUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicFormattedTextFieldUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicMenuItemUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicMenuUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicPasswordFieldUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicRadioButtonMenuItemUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicRadioButtonUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicTextAreaUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicTextFieldUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicTextPaneUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicTextUI.getPropertyPrefix()
javax.swing.plaf.basic.BasicToggleButtonUI.getPropertyPrefix()
javax.swing.plaf.metal.MetalCheckBoxUI.getPropertyPrefix()


Occurences of getProtectionParameter

getProtectionParameter occurences:
java.security.KeyStore.Builder.getProtectionParameter(java.lang.String)
java.security.KeyStore.LoadStoreParameter.getProtectionParameter()


Occurences of getProtocol

getProtocol occurences:
java.net.URL.getProtocol()
javax.management.remote.JMXServiceURL.getProtocol()
javax.management.remote.rmi.RMIIIOPServerImpl.getProtocol()
javax.management.remote.rmi.RMIJRMPServerImpl.getProtocol()
javax.management.remote.rmi.RMIServerImpl.getProtocol()
javax.net.ssl.SSLContext.getProtocol()
javax.net.ssl.SSLSession.getProtocol()


Occurences of getProvider

getProvider occurences:
java.security.AlgorithmParameterGenerator.getProvider()
java.security.AlgorithmParameters.getProvider()
java.security.cert.CertificateFactory.getProvider()
java.security.cert.CertPathBuilder.getProvider()
java.security.cert.CertPathValidator.getProvider()
java.security.cert.CertStore.getProvider()
java.security.KeyFactory.getProvider()
java.security.KeyPairGenerator.getProvider()
java.security.KeyStore.getProvider()
java.security.MessageDigest.getProvider()
java.security.Policy.getProvider()
java.security.Provider.Service.getProvider()
java.security.SecureRandom.getProvider()
java.security.Security.getProvider(java.lang.String)
java.security.Signature.getProvider()
javax.crypto.Cipher.getProvider()
javax.crypto.ExemptionMechanism.getProvider()
javax.crypto.KeyAgreement.getProvider()
javax.crypto.KeyGenerator.getProvider()
javax.crypto.Mac.getProvider()
javax.crypto.SecretKeyFactory.getProvider()
javax.net.ssl.KeyManagerFactory.getProvider()
javax.net.ssl.SSLContext.getProvider()
javax.net.ssl.TrustManagerFactory.getProvider()
javax.security.auth.login.Configuration.getProvider()
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.getProvider()
javax.xml.crypto.dsig.TransformService.getProvider()
javax.xml.crypto.dsig.XMLSignatureFactory.getProvider()


Occurences of getProviders

getProviders occurences:
java.security.Security.getProviders()
java.security.Security.getProviders(java.lang.String)
java.security.Security.getProviders(java.util.Map)


Occurences of getPublicCredentials

getPublicCredentials occurences:
javax.security.auth.Subject.getPublicCredentials()
javax.security.auth.Subject.getPublicCredentials(java.lang.Class)


Occurences of getPublicExponent

getPublicExponent occurences:
java.security.interfaces.RSAMultiPrimePrivateCrtKey.getPublicExponent()
java.security.interfaces.RSAPrivateCrtKey.getPublicExponent()
java.security.interfaces.RSAPublicKey.getPublicExponent()
java.security.spec.RSAKeyGenParameterSpec.getPublicExponent()
java.security.spec.RSAMultiPrimePrivateCrtKeySpec.getPublicExponent()
java.security.spec.RSAPrivateCrtKeySpec.getPublicExponent()
java.security.spec.RSAPublicKeySpec.getPublicExponent()


Occurences of getPublicId

getPublicId occurences:
javax.xml.stream.events.EntityDeclaration.getPublicId()
javax.xml.stream.events.NotationDeclaration.getPublicId()
javax.xml.stream.Location.getPublicId()
javax.xml.transform.SourceLocator.getPublicId()
javax.xml.transform.stream.StreamSource.getPublicId()
org.w3c.dom.DocumentType.getPublicId()
org.w3c.dom.Entity.getPublicId()
org.w3c.dom.ls.LSInput.getPublicId()
org.w3c.dom.Notation.getPublicId()
org.xml.sax.helpers.LocatorImpl.getPublicId()
org.xml.sax.InputSource.getPublicId()
org.xml.sax.Locator.getPublicId()
org.xml.sax.SAXParseException.getPublicId()


Occurences of getPublicKey

getPublicKey occurences:
java.security.cert.Certificate.getPublicKey()
java.security.cert.PKIXCertPathValidatorResult.getPublicKey()
java.security.Certificate.getPublicKey()
java.security.Identity.getPublicKey()
javax.security.cert.Certificate.getPublicKey()
javax.xml.crypto.dsig.keyinfo.KeyValue.getPublicKey()


Occurences of getPurgeFlag

getPurgeFlag occurences:
javax.management.relation.RelationService.getPurgeFlag()
javax.management.relation.RelationServiceMBean.getPurgeFlag()


Occurences of getQ

getQ occurences:
java.security.interfaces.DSAParams.getQ()
java.security.spec.DSAParameterSpec.getQ()
java.security.spec.DSAPrivateKeySpec.getQ()
java.security.spec.DSAPublicKeySpec.getQ()


Occurences of getQName

getQName occurences:
org.xml.sax.Attributes.getQName(int)
org.xml.sax.helpers.AttributesImpl.getQName(int)


Occurences of getQTables

getQTables occurences:
javax.imageio.plugins.jpeg.JPEGImageReadParam.getQTables()
javax.imageio.plugins.jpeg.JPEGImageWriteParam.getQTables()


Occurences of getQuadrantRotateInstance

getQuadrantRotateInstance occurences:
java.awt.geom.AffineTransform.getQuadrantRotateInstance(int)
java.awt.geom.AffineTransform.getQuadrantRotateInstance(int, double, double)


Occurences of getQualifiedName

getQualifiedName occurences:
com.sun.mirror.declaration.PackageDeclaration.getQualifiedName()
com.sun.mirror.declaration.TypeDeclaration.getQualifiedName()
com.sun.mirror.type.MirroredTypeException.getQualifiedName()
javax.lang.model.element.PackageElement.getQualifiedName()
javax.lang.model.element.TypeElement.getQualifiedName()
javax.xml.soap.Name.getQualifiedName()


Occurences of getQuery

getQuery occurences:
java.net.URI.getQuery()
java.net.URL.getQuery()


Occurences of getQueryTimeout

getQueryTimeout occurences:
java.sql.Statement.getQueryTimeout()
javax.sql.RowSet.getQueryTimeout()
javax.sql.rowset.BaseRowSet.getQueryTimeout()


Occurences of getQueue

getQueue occurences:
java.util.concurrent.ScheduledThreadPoolExecutor.getQueue()
java.util.concurrent.ThreadPoolExecutor.getQueue()


Occurences of getQueuedThreads

getQueuedThreads occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.getQueuedThreads()
java.util.concurrent.locks.AbstractQueuedSynchronizer.getQueuedThreads()
java.util.concurrent.locks.ReentrantLock.getQueuedThreads()
java.util.concurrent.locks.ReentrantReadWriteLock.getQueuedThreads()
java.util.concurrent.Semaphore.getQueuedThreads()


Occurences of getQueueLength

getQueueLength occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.getQueueLength()
java.util.concurrent.locks.AbstractQueuedSynchronizer.getQueueLength()
java.util.concurrent.locks.ReentrantLock.getQueueLength()
java.util.concurrent.locks.ReentrantReadWriteLock.getQueueLength()
java.util.concurrent.Semaphore.getQueueLength()


Occurences of getRadioButtonIcon

getRadioButtonIcon occurences:
javax.swing.plaf.basic.BasicIconFactory.getRadioButtonIcon()
javax.swing.plaf.metal.MetalIconFactory.getRadioButtonIcon()


Occurences of getRadioButtonMenuItemIcon

getRadioButtonMenuItemIcon occurences:
javax.swing.plaf.basic.BasicIconFactory.getRadioButtonMenuItemIcon()
javax.swing.plaf.metal.MetalIconFactory.getRadioButtonMenuItemIcon()


Occurences of getRaster

getRaster occurences:
java.awt.image.BufferedImage.getRaster()
java.awt.PaintContext.getRaster(int, int, int, int)
javax.imageio.IIOImage.getRaster()


Occurences of getRawOffset

getRawOffset occurences:
java.util.SimpleTimeZone.getRawOffset()
java.util.TimeZone.getRawOffset()


Occurences of getReader

getReader occurences:
javax.script.ScriptContext.getReader()
javax.script.SimpleScriptContext.getReader()
javax.swing.text.html.HTMLDocument.getReader(int)
javax.swing.text.html.HTMLDocument.getReader(int, int, int, javax.swing.text.html.HTML.Tag)
javax.xml.transform.stream.StreamSource.getReader()


Occurences of getReaderForText

getReaderForText occurences:
java.awt.datatransfer.DataFlavor.getReaderForText(java.awt.datatransfer.Transferable)
javax.print.Doc.getReaderForText()
javax.print.SimpleDoc.getReaderForText()


Occurences of getReason

getReason occurences:
java.net.HttpRetryException.getReason()
java.net.URISyntaxException.getReason()
javax.print.URIException.getReason()


Occurences of getReceiveBufferSize

getReceiveBufferSize occurences:
java.net.DatagramSocket.getReceiveBufferSize()
java.net.ServerSocket.getReceiveBufferSize()
java.net.Socket.getReceiveBufferSize()


Occurences of getReceiver

getReceiver occurences:
javax.sound.midi.MidiDevice.getReceiver()
javax.sound.midi.MidiSystem.getReceiver()
javax.sound.midi.Transmitter.getReceiver()


Occurences of getRed

getRed occurences:
java.awt.Color.getRed()
java.awt.image.ColorModel.getRed(int)
java.awt.image.ColorModel.getRed(java.lang.Object)
java.awt.image.ComponentColorModel.getRed(int)
java.awt.image.ComponentColorModel.getRed(java.lang.Object)
java.awt.image.DirectColorModel.getRed(int)
java.awt.image.DirectColorModel.getRed(java.lang.Object)
java.awt.image.IndexColorModel.getRed(int)


Occurences of getRedoPresentationName

getRedoPresentationName occurences:
javax.swing.text.AbstractDocument.DefaultDocumentEvent.getRedoPresentationName()
javax.swing.undo.AbstractUndoableEdit.getRedoPresentationName()
javax.swing.undo.CompoundEdit.getRedoPresentationName()
javax.swing.undo.UndoableEdit.getRedoPresentationName()
javax.swing.undo.UndoManager.getRedoPresentationName()


Occurences of getRef

getRef occurences:
java.net.URL.getRef()
java.rmi.server.RemoteObject.getRef()
java.sql.CallableStatement.getRef(int)
java.sql.CallableStatement.getRef(java.lang.String)
java.sql.ResultSet.getRef(int)
java.sql.ResultSet.getRef(java.lang.String)


Occurences of getReference

getReference occurences:
java.util.concurrent.atomic.AtomicMarkableReference.getReference()
java.util.concurrent.atomic.AtomicStampedReference.getReference()
javax.naming.Referenceable.getReference()


Occurences of getReferencedMBeans

getReferencedMBeans occurences:
javax.management.relation.Relation.getReferencedMBeans()
javax.management.relation.RelationService.getReferencedMBeans(java.lang.String)
javax.management.relation.RelationServiceMBean.getReferencedMBeans(java.lang.String)
javax.management.relation.RelationSupport.getReferencedMBeans()


Occurences of getReferences

getReferences occurences:
javax.xml.crypto.dsig.Manifest.getReferences()
javax.xml.crypto.dsig.SignedInfo.getReferences()


Occurences of getReferralContext

getReferralContext occurences:
javax.naming.ldap.LdapReferralException.getReferralContext()
javax.naming.ldap.LdapReferralException.getReferralContext(java.util.Hashtable)
javax.naming.ldap.LdapReferralException.getReferralContext(java.util.Hashtable, javax.naming.ldap.Control[])
javax.naming.ReferralException.getReferralContext()
javax.naming.ReferralException.getReferralContext(java.util.Hashtable)


Occurences of getRegion

getRegion occurences:
javax.swing.plaf.synth.SynthContext.getRegion()
javax.swing.plaf.synth.SynthLookAndFeel.getRegion(javax.swing.JComponent)


Occurences of getRegistry

getRegistry occurences:
java.rmi.registry.LocateRegistry.getRegistry()
java.rmi.registry.LocateRegistry.getRegistry(int)
java.rmi.registry.LocateRegistry.getRegistry(java.lang.String)
java.rmi.registry.LocateRegistry.getRegistry(java.lang.String, int)
java.rmi.registry.LocateRegistry.getRegistry(java.lang.String, int, java.rmi.server.RMIClientSocketFactory)


Occurences of getRelatedNode

getRelatedNode occurences:
org.w3c.dom.DOMLocator.getRelatedNode()
org.w3c.dom.events.MutationEvent.getRelatedNode()


Occurences of getRelationId

getRelationId occurences:
javax.management.relation.Relation.getRelationId()
javax.management.relation.RelationNotification.getRelationId()
javax.management.relation.RelationSupport.getRelationId()


Occurences of getRelationServiceName

getRelationServiceName occurences:
javax.management.relation.Relation.getRelationServiceName()
javax.management.relation.RelationSupport.getRelationServiceName()


Occurences of getRelationTypeName

getRelationTypeName occurences:
javax.management.relation.Relation.getRelationTypeName()
javax.management.relation.RelationNotification.getRelationTypeName()
javax.management.relation.RelationService.getRelationTypeName(java.lang.String)
javax.management.relation.RelationServiceMBean.getRelationTypeName(java.lang.String)
javax.management.relation.RelationSupport.getRelationTypeName()
javax.management.relation.RelationType.getRelationTypeName()
javax.management.relation.RelationTypeSupport.getRelationTypeName()


Occurences of getRemainingName

getRemainingName occurences:
javax.naming.NamingException.getRemainingName()
javax.naming.spi.ResolveResult.getRemainingName()


Occurences of getRemoteSocketAddress

getRemoteSocketAddress occurences:
java.net.DatagramSocket.getRemoteSocketAddress()
java.net.Socket.getRemoteSocketAddress()


Occurences of getRenderingHints

getRenderingHints occurences:
java.awt.Graphics2D.getRenderingHints()
java.awt.image.AffineTransformOp.getRenderingHints()
java.awt.image.BandCombineOp.getRenderingHints()
java.awt.image.BufferedImageOp.getRenderingHints()
java.awt.image.ColorConvertOp.getRenderingHints()
java.awt.image.ConvolveOp.getRenderingHints()
java.awt.image.LookupOp.getRenderingHints()
java.awt.image.RasterOp.getRenderingHints()
java.awt.image.renderable.RenderContext.getRenderingHints()
java.awt.image.RescaleOp.getRenderingHints()


Occurences of getRepresentationClass

getRepresentationClass occurences:
java.awt.datatransfer.DataFlavor.getRepresentationClass()
javax.activation.ActivationDataFlavor.getRepresentationClass()


Occurences of getRequestControls

getRequestControls occurences:
javax.naming.ldap.InitialLdapContext.getRequestControls()
javax.naming.ldap.LdapContext.getRequestControls()


Occurences of getResizeWeight

getResizeWeight occurences:
javax.swing.JSplitPane.getResizeWeight()
javax.swing.text.BoxView.getResizeWeight(int)
javax.swing.text.FieldView.getResizeWeight(int)
javax.swing.text.html.BlockView.getResizeWeight(int)
javax.swing.text.TableView.TableRow.getResizeWeight(int)
javax.swing.text.View.getResizeWeight(int)


Occurences of getResolution

getResolution occurences:
javax.print.attribute.ResolutionSyntax.getResolution(int)
javax.sound.midi.MidiFileFormat.getResolution()
javax.sound.midi.Sequence.getResolution()


Occurences of getResolvedObj

getResolvedObj occurences:
javax.naming.NamingException.getResolvedObj()
javax.naming.spi.ResolveResult.getResolvedObj()


Occurences of getResolveParent

getResolveParent occurences:
javax.swing.text.AbstractDocument.AbstractElement.getResolveParent()
javax.swing.text.AttributeSet.getResolveParent()
javax.swing.text.html.HTMLDocument.BlockElement.getResolveParent()
javax.swing.text.html.HTMLDocument.RunElement.getResolveParent()
javax.swing.text.Keymap.getResolveParent()
javax.swing.text.SimpleAttributeSet.getResolveParent()
javax.swing.text.StyleContext.NamedStyle.getResolveParent()
javax.swing.text.StyleContext.SmallAttributeSet.getResolveParent()


Occurences of getResource

getResource occurences:
java.beans.beancontext.BeanContext.getResource(java.lang.String, java.beans.beancontext.BeanContextChild)
java.beans.beancontext.BeanContextSupport.getResource(java.lang.String, java.beans.beancontext.BeanContextChild)
java.lang.Class.getResource(java.lang.String)
java.lang.ClassLoader.getResource(java.lang.String)
javax.annotation.processing.Filer.getResource(javax.tools.JavaFileManager.Location, java.lang.CharSequence, java.lang.CharSequence)
javax.management.loading.MLetMBean.getResource(java.lang.String)


Occurences of getResourceAsStream

getResourceAsStream occurences:
java.beans.beancontext.BeanContext.getResourceAsStream(java.lang.String, java.beans.beancontext.BeanContextChild)
java.beans.beancontext.BeanContextSupport.getResourceAsStream(java.lang.String, java.beans.beancontext.BeanContextChild)
java.lang.Class.getResourceAsStream(java.lang.String)
java.lang.ClassLoader.getResourceAsStream(java.lang.String)
javax.management.loading.MLetMBean.getResourceAsStream(java.lang.String)


Occurences of getResourceBundle

getResourceBundle occurences:
java.util.logging.Logger.getResourceBundle()
java.util.logging.LogRecord.getResourceBundle()


Occurences of getResourceBundleName

getResourceBundleName occurences:
java.util.logging.Level.getResourceBundleName()
java.util.logging.Logger.getResourceBundleName()
java.util.logging.LogRecord.getResourceBundleName()


Occurences of getResourceResolver

getResourceResolver occurences:
javax.xml.validation.SchemaFactory.getResourceResolver()
javax.xml.validation.Validator.getResourceResolver()
javax.xml.validation.ValidatorHandler.getResourceResolver()


Occurences of getResources

getResources occurences:
java.lang.ClassLoader.getResources(java.lang.String)
javax.management.loading.MLetMBean.getResources(java.lang.String)
javax.sound.midi.Soundbank.getResources()


Occurences of getResponseControls

getResponseControls occurences:
javax.naming.ldap.InitialLdapContext.getResponseControls()
javax.naming.ldap.LdapContext.getResponseControls()


Occurences of getResult

getResult occurences:
javax.xml.bind.UnmarshallerHandler.getResult()
javax.xml.bind.util.JAXBResult.getResult()
javax.xml.soap.SAAJResult.getResult()


Occurences of getResultSet

getResultSet occurences:
java.sql.Array.getResultSet()
java.sql.Array.getResultSet(java.util.Map)
java.sql.Array.getResultSet(long, int)
java.sql.Array.getResultSet(long, int, java.util.Map)
java.sql.Statement.getResultSet()
javax.sql.rowset.serial.SerialArray.getResultSet()
javax.sql.rowset.serial.SerialArray.getResultSet(java.util.Map)
javax.sql.rowset.serial.SerialArray.getResultSet(long, int)
javax.sql.rowset.serial.SerialArray.getResultSet(long, int, java.util.Map)


Occurences of getResultSetHoldability

getResultSetHoldability occurences:
java.sql.DatabaseMetaData.getResultSetHoldability()
java.sql.Statement.getResultSetHoldability()


Occurences of getReturnOpenType

getReturnOpenType occurences:
javax.management.openmbean.OpenMBeanOperationInfo.getReturnOpenType()
javax.management.openmbean.OpenMBeanOperationInfoSupport.getReturnOpenType()


Occurences of getReturnType

getReturnType occurences:
com.sun.mirror.declaration.MethodDeclaration.getReturnType()
com.sun.source.tree.MethodTree.getReturnType()
java.lang.reflect.Method.getReturnType()
javax.lang.model.element.ExecutableElement.getReturnType()
javax.lang.model.type.ExecutableType.getReturnType()
javax.management.MBeanOperationInfo.getReturnType()
javax.management.openmbean.OpenMBeanOperationInfo.getReturnType()


Occurences of getReuseAddress

getReuseAddress occurences:
java.net.DatagramSocket.getReuseAddress()
java.net.ServerSocket.getReuseAddress()
java.net.Socket.getReuseAddress()


Occurences of getRevokedCertificate

getRevokedCertificate occurences:
java.security.cert.X509CRL.getRevokedCertificate(java.math.BigInteger)
java.security.cert.X509CRL.getRevokedCertificate(java.security.cert.X509Certificate)


Occurences of getRGB

getRGB occurences:
java.awt.Color.getRGB()
java.awt.image.BufferedImage.getRGB(int, int)
java.awt.image.BufferedImage.getRGB(int, int, int, int, int[], int, int)
java.awt.image.ColorModel.getRGB(int)
java.awt.image.ColorModel.getRGB(java.lang.Object)
java.awt.image.ComponentColorModel.getRGB(int)
java.awt.image.ComponentColorModel.getRGB(java.lang.Object)
java.awt.image.DirectColorModel.getRGB(int)
java.awt.image.DirectColorModel.getRGB(java.lang.Object)
java.awt.image.IndexColorModel.getRGB(int)
java.awt.SystemColor.getRGB()


Occurences of getRightInset

getRightInset occurences:
javax.swing.text.AsyncBoxView.getRightInset()
javax.swing.text.CompositeView.getRightInset()


Occurences of getRole

getRole occurences:
javax.management.relation.Relation.getRole(java.lang.String)
javax.management.relation.RelationService.getRole(java.lang.String, java.lang.String)
javax.management.relation.RelationServiceMBean.getRole(java.lang.String, java.lang.String)
javax.management.relation.RelationSupport.getRole(java.lang.String)
javax.xml.soap.SOAPHeaderElement.getRole()


Occurences of getRoleCardinality

getRoleCardinality occurences:
javax.management.relation.Relation.getRoleCardinality(java.lang.String)
javax.management.relation.RelationService.getRoleCardinality(java.lang.String, java.lang.String)
javax.management.relation.RelationServiceMBean.getRoleCardinality(java.lang.String, java.lang.String)
javax.management.relation.RelationSupport.getRoleCardinality(java.lang.String)


Occurences of getRoleInfo

getRoleInfo occurences:
javax.management.relation.RelationService.getRoleInfo(java.lang.String, java.lang.String)
javax.management.relation.RelationServiceMBean.getRoleInfo(java.lang.String, java.lang.String)
javax.management.relation.RelationType.getRoleInfo(java.lang.String)
javax.management.relation.RelationTypeSupport.getRoleInfo(java.lang.String)


Occurences of getRoleInfos

getRoleInfos occurences:
javax.management.relation.RelationService.getRoleInfos(java.lang.String)
javax.management.relation.RelationServiceMBean.getRoleInfos(java.lang.String)
javax.management.relation.RelationType.getRoleInfos()
javax.management.relation.RelationTypeSupport.getRoleInfos()


Occurences of getRoleName

getRoleName occurences:
javax.management.relation.RelationNotification.getRoleName()
javax.management.relation.Role.getRoleName()
javax.management.relation.RoleUnresolved.getRoleName()


Occurences of getRoles

getRoles occurences:
javax.management.relation.Relation.getRoles(java.lang.String[])
javax.management.relation.RelationService.getRoles(java.lang.String, java.lang.String[])
javax.management.relation.RelationServiceMBean.getRoles(java.lang.String, java.lang.String[])
javax.management.relation.RelationSupport.getRoles(java.lang.String[])
javax.management.relation.RoleResult.getRoles()
javax.xml.ws.handler.soap.SOAPMessageContext.getRoles()
javax.xml.ws.soap.SOAPBinding.getRoles()


Occurences of getRoleValue

getRoleValue occurences:
javax.management.relation.Role.getRoleValue()
javax.management.relation.RoleUnresolved.getRoleValue()


Occurences of getRoot

getRoot occurences:
javax.swing.SwingUtilities.getRoot(java.awt.Component)
javax.swing.tree.DefaultMutableTreeNode.getRoot()
javax.swing.tree.DefaultTreeModel.getRoot()
javax.swing.tree.TreeModel.getRoot()


Occurences of getRootElements

getRootElements occurences:
javax.annotation.processing.RoundEnvironment.getRootElements()
javax.swing.text.AbstractDocument.getRootElements()
javax.swing.text.Document.getRootElements()


Occurences of getRootName

getRootName occurences:
javax.imageio.metadata.IIOMetadataFormat.getRootName()
javax.imageio.metadata.IIOMetadataFormatImpl.getRootName()


Occurences of getRootPane

getRootPane occurences:
javax.swing.JApplet.getRootPane()
javax.swing.JComponent.getRootPane()
javax.swing.JDialog.getRootPane()
javax.swing.JFrame.getRootPane()
javax.swing.JInternalFrame.getRootPane()
javax.swing.JWindow.getRootPane()
javax.swing.RootPaneContainer.getRootPane()
javax.swing.SwingUtilities.getRootPane(java.awt.Component)


Occurences of getRootView

getRootView occurences:
javax.swing.plaf.basic.BasicTextUI.getRootView(javax.swing.text.JTextComponent)
javax.swing.plaf.multi.MultiTextUI.getRootView(javax.swing.text.JTextComponent)
javax.swing.plaf.TextUI.getRootView(javax.swing.text.JTextComponent)


Occurences of getRotateInstance

getRotateInstance occurences:
java.awt.geom.AffineTransform.getRotateInstance(double)
java.awt.geom.AffineTransform.getRotateInstance(double, double)
java.awt.geom.AffineTransform.getRotateInstance(double, double, double)
java.awt.geom.AffineTransform.getRotateInstance(double, double, double, double)


Occurences of getRoundingMode

getRoundingMode occurences:
java.math.MathContext.getRoundingMode()
java.text.DecimalFormat.getRoundingMode()
java.text.NumberFormat.getRoundingMode()


Occurences of getRow

getRow occurences:
java.sql.ResultSet.getRow()
javax.swing.JTable.DropLocation.getRow()


Occurences of getRowCount

getRowCount occurences:
javax.swing.DefaultRowSorter.ModelWrapper.getRowCount()
javax.swing.JTable.getRowCount()
javax.swing.JTree.getRowCount()
javax.swing.plaf.basic.BasicTreeUI.getRowCount(javax.swing.JTree)
javax.swing.plaf.multi.MultiTreeUI.getRowCount(javax.swing.JTree)
javax.swing.plaf.TreeUI.getRowCount(javax.swing.JTree)
javax.swing.table.DefaultTableModel.getRowCount()
javax.swing.table.TableModel.getRowCount()
javax.swing.text.TableView.TableCell.getRowCount()
javax.swing.tree.AbstractLayoutCache.getRowCount()
javax.swing.tree.FixedHeightLayoutCache.getRowCount()
javax.swing.tree.VariableHeightLayoutCache.getRowCount()


Occurences of getRowForPath

getRowForPath occurences:
javax.swing.JTree.getRowForPath(javax.swing.tree.TreePath)
javax.swing.plaf.basic.BasicTreeUI.getRowForPath(javax.swing.JTree, javax.swing.tree.TreePath)
javax.swing.plaf.multi.MultiTreeUI.getRowForPath(javax.swing.JTree, javax.swing.tree.TreePath)
javax.swing.plaf.TreeUI.getRowForPath(javax.swing.JTree, javax.swing.tree.TreePath)
javax.swing.tree.AbstractLayoutCache.getRowForPath(javax.swing.tree.TreePath)
javax.swing.tree.FixedHeightLayoutCache.getRowForPath(javax.swing.tree.TreePath)
javax.swing.tree.VariableHeightLayoutCache.getRowForPath(javax.swing.tree.TreePath)


Occurences of getRowHeader

getRowHeader occurences:
javax.swing.JScrollPane.getRowHeader()
javax.swing.ScrollPaneLayout.getRowHeader()


Occurences of getRowHeight

getRowHeight occurences:
javax.swing.JTable.getRowHeight()
javax.swing.JTable.getRowHeight(int)
javax.swing.JTextArea.getRowHeight()
javax.swing.JTree.getRowHeight()
javax.swing.plaf.basic.BasicListUI.getRowHeight(int)
javax.swing.plaf.basic.BasicTreeUI.getRowHeight()
javax.swing.tree.AbstractLayoutCache.getRowHeight()


Occurences of getRowId

getRowId occurences:
java.sql.CallableStatement.getRowId(int)
java.sql.CallableStatement.getRowId(java.lang.String)
java.sql.ResultSet.getRowId(int)
java.sql.ResultSet.getRowId(java.lang.String)


Occurences of getRowMapper

getRowMapper occurences:
javax.swing.tree.DefaultTreeSelectionModel.getRowMapper()
javax.swing.tree.TreeSelectionModel.getRowMapper()


Occurences of getRows

getRows occurences:
java.awt.GridLayout.getRows()
java.awt.List.getRows()
java.awt.TextArea.getRows()
javax.swing.JTextArea.getRows()


Occurences of getRowSetWarnings

getRowSetWarnings occurences:
javax.sql.rowset.CachedRowSet.getRowSetWarnings()
javax.sql.rowset.JdbcRowSet.getRowSetWarnings()


Occurences of getRowsForPaths

getRowsForPaths occurences:
javax.swing.tree.AbstractLayoutCache.getRowsForPaths(javax.swing.tree.TreePath[])
javax.swing.tree.RowMapper.getRowsForPaths(javax.swing.tree.TreePath[])


Occurences of getRowX

getRowX occurences:
javax.swing.plaf.basic.BasicTreeUI.getRowX(int, int)
javax.swing.plaf.basic.BasicTreeUI.NodeDimensionsHandler.getRowX(int, int)


Occurences of getRule

getRule occurences:
java.awt.AlphaComposite.getRule()
javax.swing.text.html.StyleSheet.getRule(java.lang.String)
javax.swing.text.html.StyleSheet.getRule(javax.swing.text.html.HTML.Tag, javax.swing.text.Element)


Occurences of getRunLimit

getRunLimit occurences:
java.text.AttributedCharacterIterator.getRunLimit()
java.text.AttributedCharacterIterator.getRunLimit(java.text.AttributedCharacterIterator.Attribute)
java.text.AttributedCharacterIterator.getRunLimit(java.util.Set)
java.text.Bidi.getRunLimit(int)


Occurences of getRunStart

getRunStart occurences:
java.text.AttributedCharacterIterator.getRunStart()
java.text.AttributedCharacterIterator.getRunStart(java.text.AttributedCharacterIterator.Attribute)
java.text.AttributedCharacterIterator.getRunStart(java.util.Set)
java.text.Bidi.getRunStart(int)


Occurences of getS

getS occurences:
java.security.interfaces.ECPrivateKey.getS()
java.security.spec.ECPrivateKeySpec.getS()


Occurences of getSalt

getSalt occurences:
javax.crypto.interfaces.PBEKey.getSalt()
javax.crypto.spec.PBEKeySpec.getSalt()
javax.crypto.spec.PBEParameterSpec.getSalt()


Occurences of getSample

getSample occurences:
java.awt.image.BandedSampleModel.getSample(int, int, int, java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.getSample(int, int, int, java.awt.image.DataBuffer)
java.awt.image.MultiPixelPackedSampleModel.getSample(int, int, int, java.awt.image.DataBuffer)
java.awt.image.Raster.getSample(int, int, int)
java.awt.image.SampleModel.getSample(int, int, int, java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.getSample(int, int, int, java.awt.image.DataBuffer)


Occurences of getSampleDouble

getSampleDouble occurences:
java.awt.image.BandedSampleModel.getSampleDouble(int, int, int, java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.getSampleDouble(int, int, int, java.awt.image.DataBuffer)
java.awt.image.Raster.getSampleDouble(int, int, int)
java.awt.image.SampleModel.getSampleDouble(int, int, int, java.awt.image.DataBuffer)


Occurences of getSampleFloat

getSampleFloat occurences:
java.awt.image.BandedSampleModel.getSampleFloat(int, int, int, java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.getSampleFloat(int, int, int, java.awt.image.DataBuffer)
java.awt.image.Raster.getSampleFloat(int, int, int)
java.awt.image.SampleModel.getSampleFloat(int, int, int, java.awt.image.DataBuffer)


Occurences of getSampleModel

getSampleModel occurences:
java.awt.image.BufferedImage.getSampleModel()
java.awt.image.Raster.getSampleModel()
java.awt.image.RenderedImage.getSampleModel()
javax.imageio.ImageTypeSpecifier.getSampleModel()
javax.imageio.ImageTypeSpecifier.getSampleModel(int, int)


Occurences of getSamples

getSamples occurences:
java.awt.image.BandedSampleModel.getSamples(int, int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.getSamples(int, int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.Raster.getSamples(int, int, int, int, int, double[])
java.awt.image.Raster.getSamples(int, int, int, int, int, float[])
java.awt.image.Raster.getSamples(int, int, int, int, int, int[])
java.awt.image.SampleModel.getSamples(int, int, int, int, int, double[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.getSamples(int, int, int, int, int, float[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.getSamples(int, int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.getSamples(int, int, int, int, int, int[], java.awt.image.DataBuffer)


Occurences of getSampleSize

getSampleSize occurences:
java.awt.image.ComponentSampleModel.getSampleSize()
java.awt.image.ComponentSampleModel.getSampleSize(int)
java.awt.image.MultiPixelPackedSampleModel.getSampleSize()
java.awt.image.MultiPixelPackedSampleModel.getSampleSize(int)
java.awt.image.SampleModel.getSampleSize()
java.awt.image.SampleModel.getSampleSize(int)
java.awt.image.SinglePixelPackedSampleModel.getSampleSize()
java.awt.image.SinglePixelPackedSampleModel.getSampleSize(int)


Occurences of getScale

getScale occurences:
java.sql.ParameterMetaData.getScale(int)
java.sql.ResultSetMetaData.getScale(int)
javax.sql.rowset.RowSetMetaDataImpl.getScale(int)


Occurences of getScaledInstance

getScaledInstance occurences:
java.awt.Image.getScaledInstance(int, int, int)
javax.imageio.plugins.jpeg.JPEGQTable.getScaledInstance(float, boolean)


Occurences of getScanlineStride

getScanlineStride occurences:
java.awt.image.ComponentSampleModel.getScanlineStride()
java.awt.image.MultiPixelPackedSampleModel.getScanlineStride()
java.awt.image.SinglePixelPackedSampleModel.getScanlineStride()


Occurences of getSchema

getSchema occurences:
javax.naming.directory.DirContext.getSchema(java.lang.String)
javax.naming.directory.DirContext.getSchema(javax.naming.Name)
javax.naming.directory.InitialDirContext.getSchema(java.lang.String)
javax.naming.directory.InitialDirContext.getSchema(javax.naming.Name)
javax.xml.bind.Binder.getSchema()
javax.xml.bind.helpers.AbstractMarshallerImpl.getSchema()
javax.xml.bind.helpers.AbstractUnmarshallerImpl.getSchema()
javax.xml.bind.Marshaller.getSchema()
javax.xml.bind.Unmarshaller.getSchema()
javax.xml.parsers.DocumentBuilder.getSchema()
javax.xml.parsers.DocumentBuilderFactory.getSchema()
javax.xml.parsers.SAXParser.getSchema()
javax.xml.parsers.SAXParserFactory.getSchema()


Occurences of getSchemaClassDefinition

getSchemaClassDefinition occurences:
javax.naming.directory.DirContext.getSchemaClassDefinition(java.lang.String)
javax.naming.directory.DirContext.getSchemaClassDefinition(javax.naming.Name)
javax.naming.directory.InitialDirContext.getSchemaClassDefinition(java.lang.String)
javax.naming.directory.InitialDirContext.getSchemaClassDefinition(javax.naming.Name)


Occurences of getSchemaName

getSchemaName occurences:
java.sql.ResultSetMetaData.getSchemaName(int)
javax.sql.rowset.RowSetMetaDataImpl.getSchemaName(int)


Occurences of getSchemas

getSchemas occurences:
java.sql.DatabaseMetaData.getSchemas()
java.sql.DatabaseMetaData.getSchemas(java.lang.String, java.lang.String)


Occurences of getSchemaTypeInfo

getSchemaTypeInfo occurences:
javax.imageio.metadata.IIOMetadataNode.getSchemaTypeInfo()
org.w3c.dom.Attr.getSchemaTypeInfo()
org.w3c.dom.Element.getSchemaTypeInfo()


Occurences of getScope

getScope occurences:
com.sun.source.util.Trees.getScope(com.sun.source.util.TreePath)
java.security.Identity.getScope()
javax.xml.bind.JAXBElement.getScope()
javax.xml.ws.handler.MessageContext.getScope(java.lang.String)


Occurences of getScopes

getScopes occurences:
javax.script.ScriptContext.getScopes()
javax.script.SimpleScriptContext.getScopes()


Occurences of getScrollableBlockIncrement

getScrollableBlockIncrement occurences:
javax.swing.JList.getScrollableBlockIncrement(java.awt.Rectangle, int, int)
javax.swing.JTable.getScrollableBlockIncrement(java.awt.Rectangle, int, int)
javax.swing.JTree.getScrollableBlockIncrement(java.awt.Rectangle, int, int)
javax.swing.Scrollable.getScrollableBlockIncrement(java.awt.Rectangle, int, int)
javax.swing.text.JTextComponent.getScrollableBlockIncrement(java.awt.Rectangle, int, int)


Occurences of getScrollableTracksViewportHeight

getScrollableTracksViewportHeight occurences:
javax.swing.JEditorPane.getScrollableTracksViewportHeight()
javax.swing.JList.getScrollableTracksViewportHeight()
javax.swing.JTable.getScrollableTracksViewportHeight()
javax.swing.JTree.getScrollableTracksViewportHeight()
javax.swing.Scrollable.getScrollableTracksViewportHeight()
javax.swing.text.JTextComponent.getScrollableTracksViewportHeight()


Occurences of getScrollableTracksViewportWidth

getScrollableTracksViewportWidth occurences:
javax.swing.JEditorPane.getScrollableTracksViewportWidth()
javax.swing.JList.getScrollableTracksViewportWidth()
javax.swing.JTable.getScrollableTracksViewportWidth()
javax.swing.JTextArea.getScrollableTracksViewportWidth()
javax.swing.JTree.getScrollableTracksViewportWidth()
javax.swing.Scrollable.getScrollableTracksViewportWidth()
javax.swing.text.JTextComponent.getScrollableTracksViewportWidth()


Occurences of getScrollableUnitIncrement

getScrollableUnitIncrement occurences:
javax.swing.JList.getScrollableUnitIncrement(java.awt.Rectangle, int, int)
javax.swing.JTable.getScrollableUnitIncrement(java.awt.Rectangle, int, int)
javax.swing.JTextArea.getScrollableUnitIncrement(java.awt.Rectangle, int, int)
javax.swing.JTree.getScrollableUnitIncrement(java.awt.Rectangle, int, int)
javax.swing.Scrollable.getScrollableUnitIncrement(java.awt.Rectangle, int, int)
javax.swing.text.JTextComponent.getScrollableUnitIncrement(java.awt.Rectangle, int, int)


Occurences of getSecondary1

getSecondary1 occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getSecondary1()
javax.swing.plaf.metal.MetalTheme.getSecondary1()
javax.swing.plaf.metal.OceanTheme.getSecondary1()


Occurences of getSecondary2

getSecondary2 occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getSecondary2()
javax.swing.plaf.metal.MetalTheme.getSecondary2()
javax.swing.plaf.metal.OceanTheme.getSecondary2()


Occurences of getSecondary3

getSecondary3 occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getSecondary3()
javax.swing.plaf.metal.MetalTheme.getSecondary3()
javax.swing.plaf.metal.OceanTheme.getSecondary3()


Occurences of getSeconds

getSeconds occurences:
java.sql.Date.getSeconds()
java.util.Date.getSeconds()
javax.xml.datatype.Duration.getSeconds()


Occurences of getSecurityContext

getSecurityContext occurences:
java.lang.SecurityManager.getSecurityContext()
java.rmi.server.LoaderHandler.getSecurityContext(java.lang.ClassLoader)
java.rmi.server.RMIClassLoader.getSecurityContext(java.lang.ClassLoader)


Occurences of getSeed

getSeed occurences:
java.security.SecureRandom.getSeed(int)
java.security.spec.EllipticCurve.getSeed()


Occurences of getSelectColor

getSelectColor occurences:
javax.swing.plaf.metal.MetalButtonUI.getSelectColor()
javax.swing.plaf.metal.MetalRadioButtonUI.getSelectColor()
javax.swing.plaf.metal.MetalToggleButtonUI.getSelectColor()


Occurences of getSelectedAccessibleColumns

getSelectedAccessibleColumns occurences:
javax.accessibility.AccessibleTable.getSelectedAccessibleColumns()
javax.swing.JTable.AccessibleJTable.getSelectedAccessibleColumns()


Occurences of getSelectedAccessibleRows

getSelectedAccessibleRows occurences:
javax.accessibility.AccessibleTable.getSelectedAccessibleRows()
javax.swing.JTable.AccessibleJTable.getSelectedAccessibleRows()


Occurences of getSelectedColor

getSelectedColor occurences:
javax.swing.colorchooser.ColorSelectionModel.getSelectedColor()
javax.swing.colorchooser.DefaultColorSelectionModel.getSelectedColor()


Occurences of getSelectedColumnCount

getSelectedColumnCount occurences:
javax.swing.JTable.getSelectedColumnCount()
javax.swing.table.DefaultTableColumnModel.getSelectedColumnCount()
javax.swing.table.TableColumnModel.getSelectedColumnCount()


Occurences of getSelectedColumns

getSelectedColumns occurences:
javax.swing.JTable.getSelectedColumns()
javax.swing.table.DefaultTableColumnModel.getSelectedColumns()
javax.swing.table.TableColumnModel.getSelectedColumns()


Occurences of getSelectedIndex

getSelectedIndex occurences:
java.awt.Choice.getSelectedIndex()
java.awt.List.getSelectedIndex()
javax.security.auth.callback.ConfirmationCallback.getSelectedIndex()
javax.swing.DefaultSingleSelectionModel.getSelectedIndex()
javax.swing.JComboBox.getSelectedIndex()
javax.swing.JList.getSelectedIndex()
javax.swing.JTabbedPane.getSelectedIndex()
javax.swing.SingleSelectionModel.getSelectedIndex()


Occurences of getSelectedIndexes

getSelectedIndexes occurences:
java.awt.List.getSelectedIndexes()
javax.security.auth.callback.ChoiceCallback.getSelectedIndexes()


Occurences of getSelectedItem

getSelectedItem occurences:
java.awt.Choice.getSelectedItem()
java.awt.List.getSelectedItem()
javax.swing.ComboBoxModel.getSelectedItem()
javax.swing.DefaultComboBoxModel.getSelectedItem()
javax.swing.JComboBox.getSelectedItem()
javax.swing.plaf.metal.MetalFileChooserUI.DirectoryComboBoxModel.getSelectedItem()
javax.swing.plaf.metal.MetalFileChooserUI.FilterComboBoxModel.getSelectedItem()


Occurences of getSelectedObjects

getSelectedObjects occurences:
java.awt.Checkbox.getSelectedObjects()
java.awt.CheckboxMenuItem.getSelectedObjects()
java.awt.Choice.getSelectedObjects()
java.awt.ItemSelectable.getSelectedObjects()
java.awt.List.getSelectedObjects()
javax.swing.AbstractButton.getSelectedObjects()
javax.swing.DefaultButtonModel.getSelectedObjects()
javax.swing.JCheckBoxMenuItem.getSelectedObjects()
javax.swing.JComboBox.getSelectedObjects()


Occurences of getSelectedText

getSelectedText occurences:
Class ActiveClient.ActiveClient.getSelectedText(java.text.AttributedCharacterIterator.Attribute[])
java.awt.im.InputMethodRequests.getSelectedText(java.text.AttributedCharacterIterator.Attribute[])
java.awt.TextComponent.getSelectedText()
java.awt.TextComponent.AccessibleAWTTextComponent.getSelectedText()
javax.accessibility.AccessibleText.getSelectedText()
javax.swing.AbstractButton.AccessibleAbstractButton.getSelectedText()
javax.swing.JLabel.AccessibleJLabel.getSelectedText()
javax.swing.JSpinner.AccessibleJSpinner.getSelectedText()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getSelectedText()
javax.swing.text.JTextComponent.getSelectedText()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getSelectedText()


Occurences of getSelectionBackground

getSelectionBackground occurences:
javax.swing.JList.getSelectionBackground()
javax.swing.JTable.getSelectionBackground()
javax.swing.plaf.basic.BasicProgressBarUI.getSelectionBackground()


Occurences of getSelectionCount

getSelectionCount occurences:
javax.swing.JTree.getSelectionCount()
javax.swing.tree.DefaultTreeSelectionModel.getSelectionCount()
javax.swing.tree.TreeSelectionModel.getSelectionCount()


Occurences of getSelectionEnd

getSelectionEnd occurences:
java.awt.TextComponent.getSelectionEnd()
java.awt.TextComponent.AccessibleAWTTextComponent.getSelectionEnd()
javax.accessibility.AccessibleText.getSelectionEnd()
javax.swing.AbstractButton.AccessibleAbstractButton.getSelectionEnd()
javax.swing.JLabel.AccessibleJLabel.getSelectionEnd()
javax.swing.JSpinner.AccessibleJSpinner.getSelectionEnd()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getSelectionEnd()
javax.swing.text.JTextComponent.getSelectionEnd()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getSelectionEnd()


Occurences of getSelectionForeground

getSelectionForeground occurences:
javax.swing.JList.getSelectionForeground()
javax.swing.JTable.getSelectionForeground()
javax.swing.plaf.basic.BasicProgressBarUI.getSelectionForeground()


Occurences of getSelectionMode

getSelectionMode occurences:
javax.swing.DefaultListSelectionModel.getSelectionMode()
javax.swing.JList.getSelectionMode()
javax.swing.ListSelectionModel.getSelectionMode()
javax.swing.tree.DefaultTreeSelectionModel.getSelectionMode()
javax.swing.tree.TreeSelectionModel.getSelectionMode()


Occurences of getSelectionModel

getSelectionModel occurences:
javax.swing.JColorChooser.getSelectionModel()
javax.swing.JList.getSelectionModel()
javax.swing.JMenuBar.getSelectionModel()
javax.swing.JPopupMenu.getSelectionModel()
javax.swing.JTable.getSelectionModel()
javax.swing.JTree.getSelectionModel()
javax.swing.plaf.basic.BasicTreeUI.getSelectionModel()
javax.swing.table.DefaultTableColumnModel.getSelectionModel()
javax.swing.table.TableColumnModel.getSelectionModel()
javax.swing.tree.AbstractLayoutCache.getSelectionModel()


Occurences of getSelectionPath

getSelectionPath occurences:
javax.swing.JTree.getSelectionPath()
javax.swing.tree.DefaultTreeSelectionModel.getSelectionPath()
javax.swing.tree.TreeSelectionModel.getSelectionPath()


Occurences of getSelectionPaths

getSelectionPaths occurences:
javax.swing.JTree.getSelectionPaths()
javax.swing.tree.DefaultTreeSelectionModel.getSelectionPaths()
javax.swing.tree.TreeSelectionModel.getSelectionPaths()


Occurences of getSelectionRows

getSelectionRows occurences:
javax.swing.JTree.getSelectionRows()
javax.swing.tree.DefaultTreeSelectionModel.getSelectionRows()
javax.swing.tree.TreeSelectionModel.getSelectionRows()


Occurences of getSelectionStart

getSelectionStart occurences:
java.awt.TextComponent.getSelectionStart()
java.awt.TextComponent.AccessibleAWTTextComponent.getSelectionStart()
javax.accessibility.AccessibleText.getSelectionStart()
javax.swing.AbstractButton.AccessibleAbstractButton.getSelectionStart()
javax.swing.JLabel.AccessibleJLabel.getSelectionStart()
javax.swing.JSpinner.AccessibleJSpinner.getSelectionStart()
javax.swing.ProgressMonitor.AccessibleProgressMonitor.getSelectionStart()
javax.swing.text.JTextComponent.getSelectionStart()
javax.swing.text.JTextComponent.AccessibleJTextComponent.getSelectionStart()


Occurences of getSendBufferSize

getSendBufferSize occurences:
java.net.DatagramSocket.getSendBufferSize()
java.net.Socket.getSendBufferSize()


Occurences of getSendPastNotifications

getSendPastNotifications occurences:
javax.management.timer.Timer.getSendPastNotifications()
javax.management.timer.TimerMBean.getSendPastNotifications()


Occurences of getSentenceInstance

getSentenceInstance occurences:
java.text.BreakIterator.getSentenceInstance()
java.text.BreakIterator.getSentenceInstance(java.util.Locale)
java.text.spi.BreakIteratorProvider.getSentenceInstance(java.util.Locale)


Occurences of getSeparatorBackground

getSeparatorBackground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getSeparatorBackground()
javax.swing.plaf.metal.MetalTheme.getSeparatorBackground()


Occurences of getSeparatorForeground

getSeparatorForeground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getSeparatorForeground()
javax.swing.plaf.metal.MetalTheme.getSeparatorForeground()


Occurences of getSequence

getSequence occurences:
javax.sound.midi.MidiSystem.getSequence(java.io.File)
javax.sound.midi.MidiSystem.getSequence(java.io.InputStream)
javax.sound.midi.MidiSystem.getSequence(java.net.URL)
javax.sound.midi.Sequencer.getSequence()
javax.sound.midi.spi.MidiFileReader.getSequence(java.io.File)
javax.sound.midi.spi.MidiFileReader.getSequence(java.io.InputStream)
javax.sound.midi.spi.MidiFileReader.getSequence(java.net.URL)


Occurences of getSequenceNumber

getSequenceNumber occurences:
java.util.logging.LogRecord.getSequenceNumber()
javax.management.Notification.getSequenceNumber()


Occurences of getSequencer

getSequencer occurences:
javax.sound.midi.MidiSystem.getSequencer()
javax.sound.midi.MidiSystem.getSequencer(boolean)


Occurences of getSerialNumber

getSerialNumber occurences:
java.security.cert.X509Certificate.getSerialNumber()
java.security.cert.X509CertSelector.getSerialNumber()
java.security.cert.X509CRLEntry.getSerialNumber()
javax.security.cert.X509Certificate.getSerialNumber()
javax.xml.crypto.dsig.keyinfo.X509IssuerSerial.getSerialNumber()


Occurences of getService

getService occurences:
java.beans.beancontext.BeanContextServiceProvider.getService(java.beans.beancontext.BeanContextServices, java.lang.Object, java.lang.Class, java.lang.Object)
java.beans.beancontext.BeanContextServices.getService(java.beans.beancontext.BeanContextChild, java.lang.Object, java.lang.Class, java.lang.Object, java.beans.beancontext.BeanContextServiceRevokedListener)
java.beans.beancontext.BeanContextServicesSupport.getService(java.beans.beancontext.BeanContextChild, java.lang.Object, java.lang.Class, java.lang.Object, java.beans.beancontext.BeanContextServiceRevokedListener)
java.beans.beancontext.BeanContextServicesSupport.BCSSProxyServiceProvider.getService(java.beans.beancontext.BeanContextServices, java.lang.Object, java.lang.Class, java.lang.Object)
java.security.Provider.getService(java.lang.String, java.lang.String)


Occurences of getServiceClass

getServiceClass occurences:
java.beans.beancontext.BeanContextServiceAvailableEvent.getServiceClass()
java.beans.beancontext.BeanContextServiceRevokedEvent.getServiceClass()


Occurences of getServiceName

getServiceName occurences:
javax.xml.ws.handler.PortInfo.getServiceName()
javax.xml.ws.Service.getServiceName()
javax.xml.ws.spi.ServiceDelegate.getServiceName()


Occurences of getServiceProviders

getServiceProviders occurences:
javax.imageio.spi.ServiceRegistry.getServiceProviders(java.lang.Class, boolean)
javax.imageio.spi.ServiceRegistry.getServiceProviders(java.lang.Class, javax.imageio.spi.ServiceRegistry.Filter, boolean)


Occurences of getSession

getSession occurences:
javax.net.ssl.HandshakeCompletedEvent.getSession()
javax.net.ssl.SSLEngine.getSession()
javax.net.ssl.SSLSessionBindingEvent.getSession()
javax.net.ssl.SSLSessionContext.getSession(byte[])
javax.net.ssl.SSLSocket.getSession()


Occurences of getSeverity

getSeverity occurences:
javax.xml.bind.helpers.ValidationEventImpl.getSeverity()
javax.xml.bind.ValidationEvent.getSeverity()
org.w3c.dom.DOMError.getSeverity()


Occurences of getShadowColor

getShadowColor occurences:
javax.swing.border.EtchedBorder.getShadowColor()
javax.swing.border.EtchedBorder.getShadowColor(java.awt.Component)
javax.swing.plaf.basic.BasicSliderUI.getShadowColor()


Occurences of getShadowInnerColor

getShadowInnerColor occurences:
javax.swing.border.BevelBorder.getShadowInnerColor()
javax.swing.border.BevelBorder.getShadowInnerColor(java.awt.Component)


Occurences of getShadowOuterColor

getShadowOuterColor occurences:
javax.swing.border.BevelBorder.getShadowOuterColor()
javax.swing.border.BevelBorder.getShadowOuterColor(java.awt.Component)


Occurences of getSharedQueuedThreads

getSharedQueuedThreads occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.getSharedQueuedThreads()
java.util.concurrent.locks.AbstractQueuedSynchronizer.getSharedQueuedThreads()


Occurences of getShift

getShift occurences:
javax.swing.plaf.metal.MetalIconFactory.FileIcon16.getShift()
javax.swing.plaf.metal.MetalIconFactory.FolderIcon16.getShift()
javax.swing.plaf.metal.MetalIconFactory.TreeFolderIcon.getShift()
javax.swing.plaf.metal.MetalIconFactory.TreeLeafIcon.getShift()


Occurences of getShort

getShort occurences:
java.lang.reflect.Array.getShort(java.lang.Object, int)
java.lang.reflect.Field.getShort(java.lang.Object)
java.nio.ByteBuffer.getShort()
java.nio.ByteBuffer.getShort(int)
java.sql.CallableStatement.getShort(int)
java.sql.CallableStatement.getShort(java.lang.String)
java.sql.ResultSet.getShort(int)
java.sql.ResultSet.getShort(java.lang.String)


Occurences of getShowDeleted

getShowDeleted occurences:
javax.sql.rowset.BaseRowSet.getShowDeleted()
javax.sql.rowset.CachedRowSet.getShowDeleted()
javax.sql.rowset.JdbcRowSet.getShowDeleted()


Occurences of getShowsRootHandles

getShowsRootHandles occurences:
javax.swing.JTree.getShowsRootHandles()
javax.swing.plaf.basic.BasicTreeUI.getShowsRootHandles()


Occurences of getSigAlgName

getSigAlgName occurences:
java.security.cert.X509Certificate.getSigAlgName()
java.security.cert.X509CRL.getSigAlgName()
javax.security.cert.X509Certificate.getSigAlgName()


Occurences of getSigAlgOID

getSigAlgOID occurences:
java.security.cert.X509Certificate.getSigAlgOID()
java.security.cert.X509CRL.getSigAlgOID()
javax.security.cert.X509Certificate.getSigAlgOID()


Occurences of getSigAlgParams

getSigAlgParams occurences:
java.security.cert.X509Certificate.getSigAlgParams()
java.security.cert.X509CRL.getSigAlgParams()
javax.security.cert.X509Certificate.getSigAlgParams()


Occurences of getSignature

getSignature occurences:
java.security.cert.X509Certificate.getSignature()
java.security.cert.X509CRL.getSignature()
java.security.SignedObject.getSignature()
javax.management.MBeanConstructorInfo.getSignature()
javax.management.MBeanOperationInfo.getSignature()
javax.management.openmbean.OpenMBeanConstructorInfo.getSignature()
javax.management.openmbean.OpenMBeanOperationInfo.getSignature()


Occurences of getSignerCertPath

getSignerCertPath occurences:
java.security.CodeSigner.getSignerCertPath()
java.security.Timestamp.getSignerCertPath()


Occurences of getSimpleName

getSimpleName occurences:
com.sun.mirror.declaration.Declaration.getSimpleName()
com.sun.source.tree.ClassTree.getSimpleName()
java.lang.Class.getSimpleName()
javax.lang.model.element.Element.getSimpleName()


Occurences of getSize

getSize occurences:
java.awt.Component.getSize()
java.awt.Component.getSize(java.awt.Dimension)
java.awt.Component.AccessibleAWTComponent.getSize()
java.awt.Dimension.getSize()
java.awt.Font.getSize()
java.awt.image.DataBuffer.getSize()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.getSize()
java.awt.MenuComponent.AccessibleAWTMenuComponent.getSize()
java.awt.Rectangle.getSize()
java.awt.SplashScreen.getSize()
java.awt.TrayIcon.getSize()
java.util.zip.ZipEntry.getSize()
javax.accessibility.AccessibleComponent.getSize()
javax.print.attribute.Size2DSyntax.getSize(int)
javax.swing.DefaultComboBoxModel.getSize()
javax.swing.DefaultListModel.getSize()
javax.swing.JComponent.getSize(java.awt.Dimension)
javax.swing.JList.AccessibleJList.AccessibleJListChild.getSize()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.getSize()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.getSize()
javax.swing.ListModel.getSize()
javax.swing.plaf.basic.BasicDirectoryModel.getSize()
javax.swing.plaf.metal.MetalFileChooserUI.DirectoryComboBoxModel.getSize()
javax.swing.plaf.metal.MetalFileChooserUI.FilterComboBoxModel.getSize()
javax.swing.SizeSequence.getSize(int)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.getSize()
javax.xml.soap.AttachmentPart.getSize()


Occurences of getSizes

getSizes occurences:
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.getSizes()
javax.swing.SizeSequence.getSizes()


Occurences of getSocketFactory

getSocketFactory occurences:
java.rmi.server.RMISocketFactory.getSocketFactory()
javax.net.ssl.SSLContext.getSocketFactory()


Occurences of getSortKeys

getSortKeys occurences:
javax.swing.DefaultRowSorter.getSortKeys()
javax.swing.RowSorter.getSortKeys()


Occurences of getSoTimeout

getSoTimeout occurences:
java.net.DatagramSocket.getSoTimeout()
java.net.ServerSocket.getSoTimeout()
java.net.Socket.getSoTimeout()


Occurences of getSoundbank

getSoundbank occurences:
javax.sound.midi.MidiSystem.getSoundbank(java.io.File)
javax.sound.midi.MidiSystem.getSoundbank(java.io.InputStream)
javax.sound.midi.MidiSystem.getSoundbank(java.net.URL)
javax.sound.midi.SoundbankResource.getSoundbank()
javax.sound.midi.spi.SoundbankReader.getSoundbank(java.io.File)
javax.sound.midi.spi.SoundbankReader.getSoundbank(java.io.InputStream)
javax.sound.midi.spi.SoundbankReader.getSoundbank(java.net.URL)


Occurences of getSource

getSource occurences:
com.sun.mirror.apt.RoundCompleteEvent.getSource()
java.awt.Image.getSource()
java.awt.image.BufferedImage.getSource()
java.awt.image.renderable.ParameterBlock.getSource(int)
java.awt.image.VolatileImage.getSource()
java.beans.PropertyEditorSupport.getSource()
java.sql.SQLXML.getSource(java.lang.Class)
java.util.EventObject.getSource()
javax.swing.event.RowSorterEvent.getSource()
javax.tools.Diagnostic.getSource()


Occurences of getSourceActions

getSourceActions occurences:
java.awt.dnd.DragGestureRecognizer.getSourceActions()
java.awt.dnd.DragSourceContext.getSourceActions()
java.awt.dnd.DropTargetDragEvent.getSourceActions()
java.awt.dnd.DropTargetDropEvent.getSourceActions()
javax.swing.TransferHandler.getSourceActions(javax.swing.JComponent)


Occurences of getSourceAsBeanContextServices

getSourceAsBeanContextServices occurences:
java.beans.beancontext.BeanContextServiceAvailableEvent.getSourceAsBeanContextServices()
java.beans.beancontext.BeanContextServiceRevokedEvent.getSourceAsBeanContextServices()


Occurences of getSourceDataLine

getSourceDataLine occurences:
javax.sound.sampled.AudioSystem.getSourceDataLine(javax.sound.sampled.AudioFormat)
javax.sound.sampled.AudioSystem.getSourceDataLine(javax.sound.sampled.AudioFormat, javax.sound.sampled.Mixer.Info)


Occurences of getSourceFile

getSourceFile occurences:
com.sun.source.tree.CompilationUnitTree.getSourceFile()
com.sun.source.util.TaskEvent.getSourceFile()


Occurences of getSourceLineInfo

getSourceLineInfo occurences:
javax.sound.sampled.AudioSystem.getSourceLineInfo(javax.sound.sampled.Line.Info)
javax.sound.sampled.Mixer.getSourceLineInfo()
javax.sound.sampled.Mixer.getSourceLineInfo(javax.sound.sampled.Line.Info)


Occurences of getSourceRegion

getSourceRegion occurences:
javax.imageio.IIOParam.getSourceRegion()
javax.imageio.ImageReader.getSourceRegion(javax.imageio.ImageReadParam, int, int)


Occurences of getSources

getSources occurences:
java.awt.image.BufferedImage.getSources()
java.awt.image.renderable.ParameterBlock.getSources()
java.awt.image.renderable.RenderableImage.getSources()
java.awt.image.renderable.RenderableImageOp.getSources()
java.awt.image.RenderedImage.getSources()


Occurences of getSpan

getSpan occurences:
javax.swing.text.BoxView.getSpan(int, int)
javax.swing.text.GlyphView.GlyphPainter.getSpan(javax.swing.text.GlyphView, int, int, javax.swing.text.TabExpander, float)


Occurences of getSpecificationName

getSpecificationName occurences:
javax.management.MBeanServerDelegate.getSpecificationName()
javax.management.MBeanServerDelegateMBean.getSpecificationName()


Occurences of getSpecificationVendor

getSpecificationVendor occurences:
java.lang.Package.getSpecificationVendor()
javax.management.MBeanServerDelegate.getSpecificationVendor()
javax.management.MBeanServerDelegateMBean.getSpecificationVendor()


Occurences of getSpecificationVersion

getSpecificationVersion occurences:
java.lang.Package.getSpecificationVersion()
javax.management.MBeanServerDelegate.getSpecificationVersion()
javax.management.MBeanServerDelegateMBean.getSpecificationVersion()


Occurences of getSQLException

getSQLException occurences:
javax.sql.ConnectionEvent.getSQLException()
javax.sql.StatementEvent.getSQLException()


Occurences of getSQLTypeName

getSQLTypeName occurences:
java.sql.SQLData.getSQLTypeName()
java.sql.Struct.getSQLTypeName()
javax.sql.rowset.serial.SerialStruct.getSQLTypeName()


Occurences of getSQLXML

getSQLXML occurences:
java.sql.CallableStatement.getSQLXML(int)
java.sql.CallableStatement.getSQLXML(java.lang.String)
java.sql.ResultSet.getSQLXML(int)
java.sql.ResultSet.getSQLXML(java.lang.String)


Occurences of getSSLParameters

getSSLParameters occurences:
javax.net.ssl.SSLEngine.getSSLParameters()
javax.net.ssl.SSLSocket.getSSLParameters()


Occurences of getStackTrace

getStackTrace occurences:
java.lang.management.ThreadInfo.getStackTrace()
java.lang.Thread.getStackTrace()
java.lang.Throwable.getStackTrace()


Occurences of getStartIndex

getStartIndex occurences:
javax.accessibility.AccessibleHyperlink.getStartIndex()
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.HTMLLink.getStartIndex()


Occurences of getStartOffset

getStartOffset occurences:
javax.swing.text.AbstractDocument.AbstractElement.getStartOffset()
javax.swing.text.AbstractDocument.BranchElement.getStartOffset()
javax.swing.text.AbstractDocument.LeafElement.getStartOffset()
javax.swing.text.AbstractWriter.getStartOffset()
javax.swing.text.Element.getStartOffset()
javax.swing.text.GlyphView.getStartOffset()
javax.swing.text.Highlighter.Highlight.getStartOffset()
javax.swing.text.html.HTMLDocument.Iterator.getStartOffset()
javax.swing.text.View.getStartOffset()


Occurences of getStartPoint

getStartPoint occurences:
java.awt.geom.Arc2D.getStartPoint()
java.awt.LinearGradientPaint.getStartPoint()


Occurences of getStartPosition

getStartPosition occurences:
com.sun.source.tree.LineMap.getStartPosition(long)
com.sun.source.util.SourcePositions.getStartPosition(com.sun.source.tree.CompilationUnitTree, com.sun.source.tree.Tree)
javax.swing.text.AbstractDocument.getStartPosition()
javax.swing.text.Document.getStartPosition()
javax.tools.Diagnostic.getStartPosition()


Occurences of getStartTime

getStartTime occurences:
java.lang.management.RuntimeMXBean.getStartTime()
javax.security.auth.kerberos.KerberosTicket.getStartTime()


Occurences of getState

getState occurences:
java.awt.Checkbox.getState()
java.awt.CheckboxMenuItem.getState()
java.awt.Frame.getState()
java.awt.im.InputMethodHighlight.getState()
java.lang.Thread.getState()
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.getState()
java.util.concurrent.locks.AbstractQueuedSynchronizer.getState()
javax.swing.JCheckBoxMenuItem.getState()
javax.swing.SwingWorker.getState()


Occurences of getStatement

getStatement occurences:
com.sun.source.tree.DoWhileLoopTree.getStatement()
com.sun.source.tree.EnhancedForLoopTree.getStatement()
com.sun.source.tree.ForLoopTree.getStatement()
com.sun.source.tree.LabeledStatementTree.getStatement()
com.sun.source.tree.WhileLoopTree.getStatement()
java.sql.ResultSet.getStatement()
javax.sql.StatementEvent.getStatement()


Occurences of getStatements

getStatements occurences:
com.sun.source.tree.BlockTree.getStatements()
com.sun.source.tree.CaseTree.getStatements()


Occurences of getStateToBind

getStateToBind occurences:
javax.naming.spi.DirectoryManager.getStateToBind(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable, javax.naming.directory.Attributes)
javax.naming.spi.DirStateFactory.getStateToBind(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable, javax.naming.directory.Attributes)
javax.naming.spi.NamingManager.getStateToBind(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable)
javax.naming.spi.StateFactory.getStateToBind(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable)


Occurences of getStatus

getStatus occurences:
java.awt.image.PixelGrabber.getStatus()
javax.net.ssl.SSLEngineResult.getStatus()
javax.sound.midi.MidiMessage.getStatus()
javax.sql.rowset.spi.SyncResolver.getStatus()


Occurences of getStream

getStream occurences:
java.applet.AppletContext.getStream(java.lang.String)
javax.accessibility.AccessibleStreamable.getStream(java.awt.datatransfer.DataFlavor)
javax.swing.JEditorPane.getStream(java.net.URL)


Occurences of getStreamForBytes

getStreamForBytes occurences:
javax.print.Doc.getStreamForBytes()
javax.print.SimpleDoc.getStreamForBytes()


Occurences of getStreamMetadata

getStreamMetadata occurences:
javax.imageio.ImageReader.getStreamMetadata()
javax.imageio.ImageReader.getStreamMetadata(java.lang.String, java.util.Set)


Occurences of getStreamPosition

getStreamPosition occurences:
javax.imageio.stream.ImageInputStream.getStreamPosition()
javax.imageio.stream.ImageInputStreamImpl.getStreamPosition()


Occurences of getString

getString occurences:
java.sql.CallableStatement.getString(int)
java.sql.CallableStatement.getString(java.lang.String)
java.sql.ResultSet.getString(int)
java.sql.ResultSet.getString(java.lang.String)
java.sql.SQLXML.getString()
java.util.ResourceBundle.getString(java.lang.String)
javax.swing.JProgressBar.getString()
javax.swing.plaf.synth.SynthStyle.getString(javax.swing.plaf.synth.SynthContext, java.lang.Object, java.lang.String)
javax.swing.text.AbstractDocument.Content.getString(int, int)
javax.swing.text.GapContent.getString(int, int)
javax.swing.text.html.parser.Entity.getString()
javax.swing.text.StringContent.getString(int, int)
javax.swing.UIDefaults.getString(java.lang.Object)
javax.swing.UIDefaults.getString(java.lang.Object, java.util.Locale)
javax.swing.UIManager.getString(java.lang.Object)
javax.swing.UIManager.getString(java.lang.Object, java.util.Locale)


Occurences of getStringBounds

getStringBounds occurences:
java.awt.Font.getStringBounds(char[], int, int, java.awt.font.FontRenderContext)
java.awt.Font.getStringBounds(java.lang.String, int, int, java.awt.font.FontRenderContext)
java.awt.Font.getStringBounds(java.lang.String, java.awt.font.FontRenderContext)
java.awt.Font.getStringBounds(java.text.CharacterIterator, int, int, java.awt.font.FontRenderContext)
java.awt.FontMetrics.getStringBounds(char[], int, int, java.awt.Graphics)
java.awt.FontMetrics.getStringBounds(java.lang.String, int, int, java.awt.Graphics)
java.awt.FontMetrics.getStringBounds(java.lang.String, java.awt.Graphics)
java.awt.FontMetrics.getStringBounds(java.text.CharacterIterator, int, int, java.awt.Graphics)


Occurences of getStringTable

getStringTable occurences:
javax.print.attribute.EnumSyntax.getStringTable()
javax.print.attribute.standard.Chromaticity.getStringTable()
javax.print.attribute.standard.ColorSupported.getStringTable()
javax.print.attribute.standard.Compression.getStringTable()
javax.print.attribute.standard.Fidelity.getStringTable()
javax.print.attribute.standard.Finishings.getStringTable()
javax.print.attribute.standard.JobSheets.getStringTable()
javax.print.attribute.standard.JobState.getStringTable()
javax.print.attribute.standard.JobStateReason.getStringTable()
javax.print.attribute.standard.MediaName.getStringTable()
javax.print.attribute.standard.MediaSizeName.getStringTable()
javax.print.attribute.standard.MediaTray.getStringTable()
javax.print.attribute.standard.MultipleDocumentHandling.getStringTable()
javax.print.attribute.standard.OrientationRequested.getStringTable()
javax.print.attribute.standard.PDLOverrideSupported.getStringTable()
javax.print.attribute.standard.PresentationDirection.getStringTable()
javax.print.attribute.standard.PrinterIsAcceptingJobs.getStringTable()
javax.print.attribute.standard.PrinterState.getStringTable()
javax.print.attribute.standard.PrinterStateReason.getStringTable()
javax.print.attribute.standard.PrintQuality.getStringTable()
javax.print.attribute.standard.ReferenceUriSchemesSupported.getStringTable()
javax.print.attribute.standard.Severity.getStringTable()
javax.print.attribute.standard.SheetCollate.getStringTable()
javax.print.attribute.standard.Sides.getStringTable()


Occurences of getStringToCompare

getStringToCompare occurences:
javax.management.monitor.StringMonitor.getStringToCompare()
javax.management.monitor.StringMonitorMBean.getStringToCompare()


Occurences of getStyle

getStyle occurences:
java.awt.Font.getStyle()
java.awt.im.InputMethodHighlight.getStyle()
javax.swing.JTextPane.getStyle(java.lang.String)
javax.swing.plaf.synth.SynthContext.getStyle()
javax.swing.plaf.synth.SynthLookAndFeel.getStyle(javax.swing.JComponent, javax.swing.plaf.synth.Region)
javax.swing.plaf.synth.SynthStyleFactory.getStyle(javax.swing.JComponent, javax.swing.plaf.synth.Region)
javax.swing.text.DefaultStyledDocument.getStyle(java.lang.String)
javax.swing.text.StyleContext.getStyle(java.lang.String)
javax.swing.text.StyledDocument.getStyle(java.lang.String)


Occurences of getStyledDocument

getStyledDocument occurences:
javax.swing.JTextPane.getStyledDocument()
javax.swing.text.StyledEditorKit.StyledTextAction.getStyledDocument(javax.swing.JEditorPane)


Occurences of getStyledEditorKit

getStyledEditorKit occurences:
javax.swing.JTextPane.getStyledEditorKit()
javax.swing.text.StyledEditorKit.StyledTextAction.getStyledEditorKit(javax.swing.JEditorPane)


Occurences of getStyleNames

getStyleNames occurences:
javax.swing.text.DefaultStyledDocument.getStyleNames()
javax.swing.text.StyleContext.getStyleNames()


Occurences of getStyleSheet

getStyleSheet occurences:
javax.swing.text.html.BlockView.getStyleSheet()
javax.swing.text.html.HTMLDocument.getStyleSheet()
javax.swing.text.html.HTMLEditorKit.getStyleSheet()
javax.swing.text.html.ImageView.getStyleSheet()
javax.swing.text.html.InlineView.getStyleSheet()
javax.swing.text.html.ParagraphView.getStyleSheet()


Occurences of getSubElements

getSubElements occurences:
javax.swing.JMenu.getSubElements()
javax.swing.JMenuBar.getSubElements()
javax.swing.JMenuItem.getSubElements()
javax.swing.JPopupMenu.getSubElements()
javax.swing.MenuElement.getSubElements()


Occurences of getSubject

getSubject occurences:
java.security.cert.X509CertSelector.getSubject()
javax.security.auth.login.LoginContext.getSubject()
javax.security.auth.Subject.getSubject(java.security.AccessControlContext)
javax.security.auth.SubjectDomainCombiner.getSubject()


Occurences of getSubjectAlternativeNames

getSubjectAlternativeNames occurences:
java.security.cert.X509Certificate.getSubjectAlternativeNames()
java.security.cert.X509CertSelector.getSubjectAlternativeNames()


Occurences of getSubjectDN

getSubjectDN occurences:
java.security.cert.X509Certificate.getSubjectDN()
javax.security.cert.X509Certificate.getSubjectDN()


Occurences of getSubString

getSubString occurences:
java.sql.Clob.getSubString(long, int)
javax.sql.rowset.serial.SerialClob.getSubString(long, int)


Occurences of getSubTextFont

getSubTextFont occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getSubTextFont()
javax.swing.plaf.metal.MetalLookAndFeel.getSubTextFont()
javax.swing.plaf.metal.MetalTheme.getSubTextFont()


Occurences of getSubType

getSubType occurences:
java.awt.datatransfer.DataFlavor.getSubType()
javax.activation.MimeType.getSubType()


Occurences of getSuffix

getSuffix occurences:
javax.naming.CompositeName.getSuffix(int)
javax.naming.CompoundName.getSuffix(int)
javax.naming.ldap.LdapName.getSuffix(int)
javax.naming.Name.getSuffix(int)


Occurences of getSuperclass

getSuperclass occurences:
com.sun.mirror.declaration.ClassDeclaration.getSuperclass()
com.sun.mirror.type.ClassType.getSuperclass()
java.lang.Class.getSuperclass()
javax.lang.model.element.TypeElement.getSuperclass()


Occurences of getSuperinterfaces

getSuperinterfaces occurences:
com.sun.mirror.declaration.TypeDeclaration.getSuperinterfaces()
com.sun.mirror.type.DeclaredType.getSuperinterfaces()


Occurences of getSupportedAnnotationTypes

getSupportedAnnotationTypes occurences:
javax.annotation.processing.AbstractProcessor.getSupportedAnnotationTypes()
javax.annotation.processing.Processor.getSupportedAnnotationTypes()


Occurences of getSupportedCipherSuites

getSupportedCipherSuites occurences:
javax.net.ssl.SSLEngine.getSupportedCipherSuites()
javax.net.ssl.SSLServerSocket.getSupportedCipherSuites()
javax.net.ssl.SSLServerSocketFactory.getSupportedCipherSuites()
javax.net.ssl.SSLSocket.getSupportedCipherSuites()
javax.net.ssl.SSLSocketFactory.getSupportedCipherSuites()


Occurences of getSupportedDocFlavors

getSupportedDocFlavors occurences:
javax.print.PrintService.getSupportedDocFlavors()
javax.print.StreamPrintServiceFactory.getSupportedDocFlavors()


Occurences of getSupportedOptions

getSupportedOptions occurences:
javax.annotation.processing.AbstractProcessor.getSupportedOptions()
javax.annotation.processing.Processor.getSupportedOptions()


Occurences of getSupportedProtocols

getSupportedProtocols occurences:
javax.net.ssl.SSLEngine.getSupportedProtocols()
javax.net.ssl.SSLServerSocket.getSupportedProtocols()
javax.net.ssl.SSLSocket.getSupportedProtocols()


Occurences of getSupportedSourceVersion

getSupportedSourceVersion occurences:
javax.annotation.processing.AbstractProcessor.getSupportedSourceVersion()
javax.annotation.processing.Processor.getSupportedSourceVersion()


Occurences of getSupportsWindowDecorations

getSupportsWindowDecorations occurences:
javax.swing.LookAndFeel.getSupportsWindowDecorations()
javax.swing.plaf.metal.MetalLookAndFeel.getSupportsWindowDecorations()


Occurences of getSymbol

getSymbol occurences:
java.util.Currency.getSymbol()
java.util.Currency.getSymbol(java.util.Locale)
java.util.spi.CurrencyNameProvider.getSymbol(java.lang.String, java.util.Locale)


Occurences of getSystem

getSystem occurences:
java.rmi.activation.ActivationGroup.getSystem()
java.rmi.activation.ActivationGroupID.getSystem()


Occurences of getSystemId

getSystemId occurences:
javax.xml.stream.events.EntityDeclaration.getSystemId()
javax.xml.stream.events.NotationDeclaration.getSystemId()
javax.xml.stream.events.StartDocument.getSystemId()
javax.xml.stream.Location.getSystemId()
javax.xml.transform.dom.DOMResult.getSystemId()
javax.xml.transform.dom.DOMSource.getSystemId()
javax.xml.transform.Result.getSystemId()
javax.xml.transform.sax.SAXResult.getSystemId()
javax.xml.transform.sax.SAXSource.getSystemId()
javax.xml.transform.sax.TemplatesHandler.getSystemId()
javax.xml.transform.sax.TransformerHandler.getSystemId()
javax.xml.transform.Source.getSystemId()
javax.xml.transform.SourceLocator.getSystemId()
javax.xml.transform.stax.StAXResult.getSystemId()
javax.xml.transform.stax.StAXSource.getSystemId()
javax.xml.transform.stream.StreamResult.getSystemId()
javax.xml.transform.stream.StreamSource.getSystemId()
org.w3c.dom.DocumentType.getSystemId()
org.w3c.dom.Entity.getSystemId()
org.w3c.dom.ls.LSInput.getSystemId()
org.w3c.dom.ls.LSOutput.getSystemId()
org.w3c.dom.Notation.getSystemId()
org.xml.sax.helpers.LocatorImpl.getSystemId()
org.xml.sax.InputSource.getSystemId()
org.xml.sax.Locator.getSystemId()
org.xml.sax.SAXParseException.getSystemId()


Occurences of getSystemProperties

getSystemProperties occurences:
com.sun.tools.attach.VirtualMachine.getSystemProperties()
java.lang.management.RuntimeMXBean.getSystemProperties()


Occurences of getSystemTextColor

getSystemTextColor occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getSystemTextColor()
javax.swing.plaf.metal.MetalTheme.getSystemTextColor()


Occurences of getSystemTextFont

getSystemTextFont occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getSystemTextFont()
javax.swing.plaf.metal.MetalLookAndFeel.getSystemTextFont()
javax.swing.plaf.metal.MetalTheme.getSystemTextFont()


Occurences of getTabbedSpan

getTabbedSpan occurences:
javax.swing.text.GlyphView.getTabbedSpan(float, javax.swing.text.TabExpander)
javax.swing.text.TabableView.getTabbedSpan(float, javax.swing.text.TabExpander)


Occurences of getTabbedTextOffset

getTabbedTextOffset occurences:
javax.swing.text.Utilities.getTabbedTextOffset(javax.swing.text.Segment, java.awt.FontMetrics, int, int, javax.swing.text.TabExpander, int)
javax.swing.text.Utilities.getTabbedTextOffset(javax.swing.text.Segment, java.awt.FontMetrics, int, int, javax.swing.text.TabExpander, int, boolean)


Occurences of getTabBounds

getTabBounds occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.getTabBounds(int, java.awt.Rectangle)
javax.swing.plaf.basic.BasicTabbedPaneUI.getTabBounds(javax.swing.JTabbedPane, int)
javax.swing.plaf.multi.MultiTabbedPaneUI.getTabBounds(javax.swing.JTabbedPane, int)
javax.swing.plaf.TabbedPaneUI.getTabBounds(javax.swing.JTabbedPane, int)


Occurences of getTabCount

getTabCount occurences:
javax.swing.JTabbedPane.getTabCount()
javax.swing.text.TabSet.getTabCount()


Occurences of getTabLabelShiftX

getTabLabelShiftX occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.getTabLabelShiftX(int, int, boolean)
javax.swing.plaf.metal.MetalTabbedPaneUI.getTabLabelShiftX(int, int, boolean)


Occurences of getTabLabelShiftY

getTabLabelShiftY occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.getTabLabelShiftY(int, int, boolean)
javax.swing.plaf.metal.MetalTabbedPaneUI.getTabLabelShiftY(int, int, boolean)


Occurences of getTable

getTable occurences:
java.awt.image.ByteLookupTable.getTable()
java.awt.image.LookupOp.getTable()
java.awt.image.ShortLookupTable.getTable()
javax.imageio.plugins.jpeg.JPEGQTable.getTable()
javax.swing.table.JTableHeader.getTable()


Occurences of getTableCellEditorComponent

getTableCellEditorComponent occurences:
javax.swing.DefaultCellEditor.getTableCellEditorComponent(javax.swing.JTable, java.lang.Object, boolean, int, int)
javax.swing.table.TableCellEditor.getTableCellEditorComponent(javax.swing.JTable, java.lang.Object, boolean, int, int)


Occurences of getTableCellRendererComponent

getTableCellRendererComponent occurences:
javax.swing.table.DefaultTableCellRenderer.getTableCellRendererComponent(javax.swing.JTable, java.lang.Object, boolean, boolean, int, int)
javax.swing.table.TableCellRenderer.getTableCellRendererComponent(javax.swing.JTable, java.lang.Object, boolean, boolean, int, int)


Occurences of getTableName

getTableName occurences:
java.sql.ResultSetMetaData.getTableName(int)
javax.sql.rowset.CachedRowSet.getTableName()
javax.sql.rowset.RowSetMetaDataImpl.getTableName(int)


Occurences of getTabRunCount

getTabRunCount occurences:
javax.swing.JTabbedPane.getTabRunCount()
javax.swing.plaf.basic.BasicTabbedPaneUI.getTabRunCount(javax.swing.JTabbedPane)
javax.swing.plaf.multi.MultiTabbedPaneUI.getTabRunCount(javax.swing.JTabbedPane)
javax.swing.plaf.TabbedPaneUI.getTabRunCount(javax.swing.JTabbedPane)


Occurences of getTabRunOverlay

getTabRunOverlay occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.getTabRunOverlay(int)
javax.swing.plaf.metal.MetalTabbedPaneUI.getTabRunOverlay(int)


Occurences of getTabSet

getTabSet occurences:
javax.swing.text.ParagraphView.getTabSet()
javax.swing.text.StyleConstants.getTabSet(javax.swing.text.AttributeSet)


Occurences of getTabSize

getTabSize occurences:
javax.swing.JTextArea.getTabSize()
javax.swing.text.PlainView.getTabSize()
javax.swing.text.WrappedPlainView.getTabSize()


Occurences of getTabularType

getTabularType occurences:
javax.management.openmbean.TabularData.getTabularType()
javax.management.openmbean.TabularDataSupport.getTabularType()


Occurences of getTag

getTag occurences:
javax.swing.text.html.HTML.getTag(java.lang.String)
javax.swing.text.html.HTMLDocument.Iterator.getTag()


Occurences of getTagName

getTagName occurences:
javax.imageio.metadata.IIOMetadataNode.getTagName()
org.w3c.dom.Element.getTagName()


Occurences of getTags

getTags occurences:
java.beans.PropertyEditor.getTags()
java.beans.PropertyEditorSupport.getTags()


Occurences of getTail

getTail occurences:
java.util.logging.Formatter.getTail(java.util.logging.Handler)
java.util.logging.XMLFormatter.getTail(java.util.logging.Handler)


Occurences of getTarget

getTarget occurences:
java.beans.EventHandler.getTarget()
java.beans.Statement.getTarget()
javax.accessibility.AccessibleRelation.getTarget()
javax.rmi.CORBA.Tie.getTarget()
javax.swing.BoxLayout.getTarget()
javax.swing.OverlayLayout.getTarget()
javax.swing.text.html.HTMLFrameHyperlinkEvent.getTarget()
javax.xml.crypto.dsig.SignatureProperty.getTarget()
javax.xml.stream.events.ProcessingInstruction.getTarget()
org.w3c.dom.events.Event.getTarget()
org.w3c.dom.ProcessingInstruction.getTarget()


Occurences of getTargetActions

getTargetActions occurences:
java.awt.dnd.DragSourceDragEvent.getTargetActions()
java.awt.dnd.DropTargetContext.getTargetActions()


Occurences of getTargetDataLine

getTargetDataLine occurences:
javax.sound.sampled.AudioSystem.getTargetDataLine(javax.sound.sampled.AudioFormat)
javax.sound.sampled.AudioSystem.getTargetDataLine(javax.sound.sampled.AudioFormat, javax.sound.sampled.Mixer.Info)


Occurences of getTargetEncodings

getTargetEncodings occurences:
javax.sound.sampled.AudioSystem.getTargetEncodings(javax.sound.sampled.AudioFormat)
javax.sound.sampled.AudioSystem.getTargetEncodings(javax.sound.sampled.AudioFormat.Encoding)
javax.sound.sampled.spi.FormatConversionProvider.getTargetEncodings()
javax.sound.sampled.spi.FormatConversionProvider.getTargetEncodings(javax.sound.sampled.AudioFormat)


Occurences of getTargetException

getTargetException occurences:
java.lang.reflect.InvocationTargetException.getTargetException()
javax.management.MBeanException.getTargetException()
javax.management.ReflectionException.getTargetException()
javax.management.RuntimeMBeanException.getTargetException()
javax.management.RuntimeOperationsException.getTargetException()


Occurences of getTargetFormats

getTargetFormats occurences:
javax.sound.sampled.AudioSystem.getTargetFormats(javax.sound.sampled.AudioFormat.Encoding, javax.sound.sampled.AudioFormat)
javax.sound.sampled.spi.FormatConversionProvider.getTargetFormats(javax.sound.sampled.AudioFormat.Encoding, javax.sound.sampled.AudioFormat)


Occurences of getTargetLineInfo

getTargetLineInfo occurences:
javax.sound.sampled.AudioSystem.getTargetLineInfo(javax.sound.sampled.Line.Info)
javax.sound.sampled.Mixer.getTargetLineInfo()
javax.sound.sampled.Mixer.getTargetLineInfo(javax.sound.sampled.Line.Info)


Occurences of getText

getText occurences:
java.awt.event.InputMethodEvent.getText()
java.awt.Label.getText()
java.awt.TextComponent.getText()
java.text.BreakIterator.getText()
javax.security.auth.callback.TextInputCallback.getText()
javax.swing.AbstractButton.getText()
javax.swing.JEditorPane.getText()
javax.swing.JLabel.getText()
javax.swing.JPasswordField.getText()
javax.swing.JPasswordField.getText(int, int)
javax.swing.text.AbstractDocument.getText(int, int)
javax.swing.text.AbstractDocument.getText(int, int, javax.swing.text.Segment)
javax.swing.text.AbstractWriter.getText(javax.swing.text.Element)
javax.swing.text.Document.getText(int, int)
javax.swing.text.Document.getText(int, int, javax.swing.text.Segment)
javax.swing.text.GlyphView.getText(int, int)
javax.swing.text.JTextComponent.getText()
javax.swing.text.JTextComponent.getText(int, int)
javax.xml.stream.events.Comment.getText()
javax.xml.stream.util.StreamReaderDelegate.getText()
javax.xml.stream.XMLStreamReader.getText()


Occurences of getTextBounds

getTextBounds occurences:
javax.accessibility.AccessibleExtendedText.getTextBounds(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getTextBounds(int, int)


Occurences of getTextCharacters

getTextCharacters occurences:
javax.xml.stream.util.StreamReaderDelegate.getTextCharacters()
javax.xml.stream.util.StreamReaderDelegate.getTextCharacters(int, char[], int, int)
javax.xml.stream.XMLStreamReader.getTextCharacters()
javax.xml.stream.XMLStreamReader.getTextCharacters(int, char[], int, int)


Occurences of getTextContent

getTextContent occurences:
javax.imageio.metadata.IIOMetadataNode.getTextContent()
org.w3c.dom.Node.getTextContent()


Occurences of getTextFieldBorder

getTextFieldBorder occurences:
javax.swing.plaf.basic.BasicBorders.getTextFieldBorder()
javax.swing.plaf.metal.MetalBorders.getTextFieldBorder()


Occurences of getTextHighlightColor

getTextHighlightColor occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getTextHighlightColor()
javax.swing.plaf.metal.MetalTheme.getTextHighlightColor()


Occurences of getTextLength

getTextLength occurences:
javax.xml.stream.util.StreamReaderDelegate.getTextLength()
javax.xml.stream.XMLStreamReader.getTextLength()


Occurences of getTextLocation

getTextLocation occurences:
Class ActiveClient.ActiveClient.getTextLocation(java.awt.font.TextHitInfo)
java.awt.im.InputMethodRequests.getTextLocation(java.awt.font.TextHitInfo)


Occurences of getTextRange

getTextRange occurences:
javax.accessibility.AccessibleEditableText.getTextRange(int, int)
javax.accessibility.AccessibleExtendedText.getTextRange(int, int)
javax.swing.JPasswordField.AccessibleJPasswordField.getTextRange(int, int)
javax.swing.JSpinner.AccessibleJSpinner.getTextRange(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getTextRange(int, int)


Occurences of getTextSequenceAfter

getTextSequenceAfter occurences:
javax.accessibility.AccessibleExtendedText.getTextSequenceAfter(int, int)
javax.swing.JPasswordField.AccessibleJPasswordField.getTextSequenceAfter(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getTextSequenceAfter(int, int)


Occurences of getTextSequenceAt

getTextSequenceAt occurences:
javax.accessibility.AccessibleExtendedText.getTextSequenceAt(int, int)
javax.swing.JPasswordField.AccessibleJPasswordField.getTextSequenceAt(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getTextSequenceAt(int, int)


Occurences of getTextSequenceBefore

getTextSequenceBefore occurences:
javax.accessibility.AccessibleExtendedText.getTextSequenceBefore(int, int)
javax.swing.JPasswordField.AccessibleJPasswordField.getTextSequenceBefore(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.getTextSequenceBefore(int, int)


Occurences of getTextShiftOffset

getTextShiftOffset occurences:
javax.swing.plaf.basic.BasicButtonUI.getTextShiftOffset()
javax.swing.plaf.basic.BasicToggleButtonUI.getTextShiftOffset()


Occurences of getTextStart

getTextStart occurences:
javax.xml.stream.util.StreamReaderDelegate.getTextStart()
javax.xml.stream.XMLStreamReader.getTextStart()


Occurences of getThreadGroup

getThreadGroup occurences:
java.lang.SecurityManager.getThreadGroup()
java.lang.Thread.getThreadGroup()


Occurences of getThreadInfo

getThreadInfo occurences:
java.lang.management.ThreadMXBean.getThreadInfo(long)
java.lang.management.ThreadMXBean.getThreadInfo(long, int)
java.lang.management.ThreadMXBean.getThreadInfo(long[])
java.lang.management.ThreadMXBean.getThreadInfo(long[], boolean, boolean)
java.lang.management.ThreadMXBean.getThreadInfo(long[], int)


Occurences of getThreshold

getThreshold occurences:
javax.management.monitor.CounterMonitor.getThreshold()
javax.management.monitor.CounterMonitor.getThreshold(javax.management.ObjectName)
javax.management.monitor.CounterMonitorMBean.getThreshold()
javax.management.monitor.CounterMonitorMBean.getThreshold(javax.management.ObjectName)


Occurences of getThrownTypes

getThrownTypes occurences:
com.sun.mirror.declaration.ExecutableDeclaration.getThrownTypes()
javax.lang.model.element.ExecutableElement.getThrownTypes()
javax.lang.model.type.ExecutableType.getThrownTypes()


Occurences of getThumbSize

getThumbSize occurences:
javax.swing.plaf.basic.BasicSliderUI.getThumbSize()
javax.swing.plaf.metal.MetalSliderUI.getThumbSize()


Occurences of getTickLength

getTickLength occurences:
javax.sound.midi.Sequence.getTickLength()
javax.sound.midi.Sequencer.getTickLength()
javax.swing.plaf.basic.BasicSliderUI.getTickLength()
javax.swing.plaf.metal.MetalSliderUI.getTickLength()


Occurences of getTie

getTie occurences:
javax.rmi.CORBA.Util.getTie(java.rmi.Remote)
javax.rmi.CORBA.UtilDelegate.getTie(java.rmi.Remote)


Occurences of getTile

getTile occurences:
java.awt.image.BufferedImage.getTile(int, int)
java.awt.image.RenderedImage.getTile(int, int)


Occurences of getTileGridXOffset

getTileGridXOffset occurences:
java.awt.image.BufferedImage.getTileGridXOffset()
java.awt.image.RenderedImage.getTileGridXOffset()
javax.imageio.ImageReader.getTileGridXOffset(int)
javax.imageio.ImageWriteParam.getTileGridXOffset()


Occurences of getTileGridYOffset

getTileGridYOffset occurences:
java.awt.image.BufferedImage.getTileGridYOffset()
java.awt.image.RenderedImage.getTileGridYOffset()
javax.imageio.ImageReader.getTileGridYOffset(int)
javax.imageio.ImageWriteParam.getTileGridYOffset()


Occurences of getTileHeight

getTileHeight occurences:
java.awt.image.BufferedImage.getTileHeight()
java.awt.image.RenderedImage.getTileHeight()
javax.imageio.ImageReader.getTileHeight(int)
javax.imageio.ImageWriteParam.getTileHeight()


Occurences of getTileWidth

getTileWidth occurences:
java.awt.image.BufferedImage.getTileWidth()
java.awt.image.RenderedImage.getTileWidth()
javax.imageio.ImageReader.getTileWidth(int)
javax.imageio.ImageWriteParam.getTileWidth()


Occurences of getTime

getTime occurences:
java.sql.CallableStatement.getTime(int)
java.sql.CallableStatement.getTime(int, java.util.Calendar)
java.sql.CallableStatement.getTime(java.lang.String)
java.sql.CallableStatement.getTime(java.lang.String, java.util.Calendar)
java.sql.ResultSet.getTime(int)
java.sql.ResultSet.getTime(int, java.util.Calendar)
java.sql.ResultSet.getTime(java.lang.String)
java.sql.ResultSet.getTime(java.lang.String, java.util.Calendar)
java.sql.Timestamp.getTime()
java.util.Calendar.getTime()
java.util.Date.getTime()
java.util.zip.ZipEntry.getTime()


Occurences of getTimeInMillis

getTimeInMillis occurences:
java.util.Calendar.getTimeInMillis()
javax.xml.datatype.Duration.getTimeInMillis(java.util.Calendar)
javax.xml.datatype.Duration.getTimeInMillis(java.util.Date)


Occurences of getTimeInstance

getTimeInstance occurences:
java.text.DateFormat.getTimeInstance()
java.text.DateFormat.getTimeInstance(int)
java.text.DateFormat.getTimeInstance(int, java.util.Locale)
java.text.spi.DateFormatProvider.getTimeInstance(int, java.util.Locale)


Occurences of getTimeStamp

getTimeStamp occurences:
javax.management.Notification.getTimeStamp()
org.w3c.dom.events.Event.getTimeStamp()


Occurences of getTimestamp

getTimestamp occurences:
java.security.CodeSigner.getTimestamp()
java.security.Timestamp.getTimestamp()
java.sql.CallableStatement.getTimestamp(int)
java.sql.CallableStatement.getTimestamp(int, java.util.Calendar)
java.sql.CallableStatement.getTimestamp(java.lang.String)
java.sql.CallableStatement.getTimestamp(java.lang.String, java.util.Calendar)
java.sql.ResultSet.getTimestamp(int)
java.sql.ResultSet.getTimestamp(int, java.util.Calendar)
java.sql.ResultSet.getTimestamp(java.lang.String)
java.sql.ResultSet.getTimestamp(java.lang.String, java.util.Calendar)


Occurences of getTimeToLive

getTimeToLive occurences:
java.net.DatagramSocketImpl.getTimeToLive()
java.net.MulticastSocket.getTimeToLive()
java.util.ResourceBundle.Control.getTimeToLive(java.lang.String, java.util.Locale)


Occurences of getTimeZone

getTimeZone occurences:
java.text.DateFormat.getTimeZone()
java.util.Calendar.getTimeZone()
java.util.GregorianCalendar.getTimeZone()
java.util.TimeZone.getTimeZone(java.lang.String)
javax.xml.datatype.XMLGregorianCalendar.getTimeZone(int)


Occurences of getTitle

getTitle occurences:
java.awt.Dialog.getTitle()
java.awt.Frame.getTitle()
javax.swing.border.TitledBorder.getTitle()
javax.swing.JInternalFrame.getTitle()
javax.swing.plaf.basic.BasicInternalFrameTitlePane.getTitle(java.lang.String, java.awt.FontMetrics, int)


Occurences of getTitledBorderText

getTitledBorderText occurences:
javax.accessibility.AccessibleExtendedComponent.getTitledBorderText()
javax.swing.AbstractButton.AccessibleAbstractButton.getTitledBorderText()
javax.swing.JComponent.AccessibleJComponent.getTitledBorderText()
javax.swing.JLabel.AccessibleJLabel.getTitledBorderText()


Occurences of getToggleButtonBorder

getToggleButtonBorder occurences:
javax.swing.plaf.basic.BasicBorders.getToggleButtonBorder()
javax.swing.plaf.metal.MetalBorders.getToggleButtonBorder()


Occurences of getToolkit

getToolkit occurences:
java.awt.Component.getToolkit()
java.awt.Window.getToolkit()


Occurences of getToolTipText

getToolTipText occurences:
javax.accessibility.AccessibleExtendedComponent.getToolTipText()
javax.swing.AbstractButton.AccessibleAbstractButton.getToolTipText()
javax.swing.JComponent.getToolTipText()
javax.swing.JComponent.getToolTipText(java.awt.event.MouseEvent)
javax.swing.JComponent.AccessibleJComponent.getToolTipText()
javax.swing.JLabel.AccessibleJLabel.getToolTipText()
javax.swing.JList.getToolTipText(java.awt.event.MouseEvent)
javax.swing.JTabbedPane.getToolTipText(java.awt.event.MouseEvent)
javax.swing.JTable.getToolTipText(java.awt.event.MouseEvent)
javax.swing.JTree.getToolTipText(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTextUI.getToolTipText(javax.swing.text.JTextComponent, java.awt.Point)
javax.swing.plaf.multi.MultiTextUI.getToolTipText(javax.swing.text.JTextComponent, java.awt.Point)
javax.swing.plaf.TextUI.getToolTipText(javax.swing.text.JTextComponent, java.awt.Point)
javax.swing.table.JTableHeader.getToolTipText(java.awt.event.MouseEvent)
javax.swing.text.html.ImageView.getToolTipText(float, float, java.awt.Shape)
javax.swing.text.JTextComponent.getToolTipText(java.awt.event.MouseEvent)
javax.swing.text.View.getToolTipText(float, float, java.awt.Shape)


Occurences of getTopInset

getTopInset occurences:
javax.swing.text.AsyncBoxView.getTopInset()
javax.swing.text.CompositeView.getTopInset()


Occurences of getTotalColumnWidth

getTotalColumnWidth occurences:
javax.swing.table.DefaultTableColumnModel.getTotalColumnWidth()
javax.swing.table.TableColumnModel.getTotalColumnWidth()


Occurences of getTotalIn

getTotalIn occurences:
java.util.zip.Deflater.getTotalIn()
java.util.zip.Inflater.getTotalIn()


Occurences of getTotalOut

getTotalOut occurences:
java.util.zip.Deflater.getTotalOut()
java.util.zip.Inflater.getTotalOut()


Occurences of getTrafficClass

getTrafficClass occurences:
java.net.DatagramSocket.getTrafficClass()
java.net.Socket.getTrafficClass()


Occurences of getTransactionIsolation

getTransactionIsolation occurences:
java.sql.Connection.getTransactionIsolation()
javax.sql.RowSet.getTransactionIsolation()
javax.sql.rowset.BaseRowSet.getTransactionIsolation()


Occurences of getTransferable

getTransferable occurences:
java.awt.dnd.DragSourceContext.getTransferable()
java.awt.dnd.DropTargetContext.getTransferable()
java.awt.dnd.DropTargetDragEvent.getTransferable()
java.awt.dnd.DropTargetDropEvent.getTransferable()
javax.swing.TransferHandler.TransferSupport.getTransferable()


Occurences of getTransferData

getTransferData occurences:
java.awt.datatransfer.StringSelection.getTransferData(java.awt.datatransfer.DataFlavor)
java.awt.datatransfer.Transferable.getTransferData(java.awt.datatransfer.DataFlavor)
java.awt.dnd.DropTargetContext.TransferableProxy.getTransferData(java.awt.datatransfer.DataFlavor)
javax.activation.DataContentHandler.getTransferData(java.awt.datatransfer.DataFlavor, javax.activation.DataSource)
javax.activation.DataHandler.getTransferData(java.awt.datatransfer.DataFlavor)


Occurences of getTransferDataFlavors

getTransferDataFlavors occurences:
java.awt.datatransfer.StringSelection.getTransferDataFlavors()
java.awt.datatransfer.Transferable.getTransferDataFlavors()
java.awt.dnd.DropTargetContext.TransferableProxy.getTransferDataFlavors()
javax.activation.DataContentHandler.getTransferDataFlavors()
javax.activation.DataHandler.getTransferDataFlavors()


Occurences of getTransferHandler

getTransferHandler occurences:
javax.swing.JApplet.getTransferHandler()
javax.swing.JComponent.getTransferHandler()
javax.swing.JDialog.getTransferHandler()
javax.swing.JFrame.getTransferHandler()
javax.swing.JWindow.getTransferHandler()


Occurences of getTransferType

getTransferType occurences:
java.awt.image.ColorModel.getTransferType()
java.awt.image.MultiPixelPackedSampleModel.getTransferType()
java.awt.image.Raster.getTransferType()
java.awt.image.SampleModel.getTransferType()


Occurences of getTransform

getTransform occurences:
java.awt.Font.getTransform()
java.awt.font.FontRenderContext.getTransform()
java.awt.font.TransformAttribute.getTransform()
java.awt.Graphics2D.getTransform()
java.awt.image.AffineTransformOp.getTransform()
java.awt.image.renderable.RenderContext.getTransform()
java.awt.MultipleGradientPaint.getTransform()


Occurences of getTransforms

getTransforms occurences:
javax.xml.crypto.dsig.keyinfo.RetrievalMethod.getTransforms()
javax.xml.crypto.dsig.Reference.getTransforms()


Occurences of getTransmitter

getTransmitter occurences:
javax.sound.midi.MidiDevice.getTransmitter()
javax.sound.midi.MidiSystem.getTransmitter()


Occurences of getTransparency

getTransparency occurences:
java.awt.Color.getTransparency()
java.awt.GradientPaint.getTransparency()
java.awt.image.BufferedImage.getTransparency()
java.awt.image.ColorModel.getTransparency()
java.awt.image.IndexColorModel.getTransparency()
java.awt.image.VolatileImage.getTransparency()
java.awt.MultipleGradientPaint.getTransparency()
java.awt.TexturePaint.getTransparency()
java.awt.Transparency.getTransparency()


Occurences of getTRC

getTRC occurences:
java.awt.color.ICC_ProfileGray.getTRC()
java.awt.color.ICC_ProfileRGB.getTRC(int)


Occurences of getTree

getTree occurences:
com.sun.source.util.Trees.getTree(javax.lang.model.element.Element)
com.sun.source.util.Trees.getTree(javax.lang.model.element.Element, javax.lang.model.element.AnnotationMirror)
com.sun.source.util.Trees.getTree(javax.lang.model.element.Element, javax.lang.model.element.AnnotationMirror, javax.lang.model.element.AnnotationValue)
com.sun.source.util.Trees.getTree(javax.lang.model.element.ExecutableElement)
com.sun.source.util.Trees.getTree(javax.lang.model.element.TypeElement)


Occurences of getTreeCellEditorComponent

getTreeCellEditorComponent occurences:
javax.swing.DefaultCellEditor.getTreeCellEditorComponent(javax.swing.JTree, java.lang.Object, boolean, boolean, boolean, int)
javax.swing.tree.DefaultTreeCellEditor.getTreeCellEditorComponent(javax.swing.JTree, java.lang.Object, boolean, boolean, boolean, int)
javax.swing.tree.TreeCellEditor.getTreeCellEditorComponent(javax.swing.JTree, java.lang.Object, boolean, boolean, boolean, int)


Occurences of getTreeCellRendererComponent

getTreeCellRendererComponent occurences:
javax.swing.tree.DefaultTreeCellRenderer.getTreeCellRendererComponent(javax.swing.JTree, java.lang.Object, boolean, boolean, boolean, int, boolean)
javax.swing.tree.TreeCellRenderer.getTreeCellRendererComponent(javax.swing.JTree, java.lang.Object, boolean, boolean, boolean, int, boolean)


Occurences of getTreeLock

getTreeLock occurences:
java.awt.Component.getTreeLock()
java.awt.MenuComponent.getTreeLock()


Occurences of getTreeSelectionListeners

getTreeSelectionListeners occurences:
javax.swing.JTree.getTreeSelectionListeners()
javax.swing.tree.DefaultTreeSelectionModel.getTreeSelectionListeners()


Occurences of getTrigger

getTrigger occurences:
java.awt.dnd.DragSourceContext.getTrigger()
javax.management.monitor.MonitorNotification.getTrigger()


Occurences of getTriggerEvent

getTriggerEvent occurences:
java.awt.dnd.DragGestureEvent.getTriggerEvent()
java.awt.dnd.DragGestureRecognizer.getTriggerEvent()


Occurences of getTTL

getTTL occurences:
java.net.DatagramSocketImpl.getTTL()
java.net.MulticastSocket.getTTL()


Occurences of getType

getType occurences:
com.sun.mirror.declaration.FieldDeclaration.getType()
com.sun.mirror.declaration.ParameterDeclaration.getType()
com.sun.source.tree.ArrayTypeTree.getType()
com.sun.source.tree.InstanceOfTree.getType()
com.sun.source.tree.NewArrayTree.getType()
com.sun.source.tree.ParameterizedTypeTree.getType()
com.sun.source.tree.TypeCastTree.getType()
com.sun.source.tree.VariableTree.getType()
java.awt.color.ColorSpace.getType()
java.awt.Cursor.getType()
java.awt.font.GlyphMetrics.getType()
java.awt.geom.AffineTransform.getType()
java.awt.GraphicsDevice.getType()
java.awt.image.BufferedImage.getType()
java.io.ObjectStreamField.getType()
java.lang.Character.getType(char)
java.lang.Character.getType(int)
java.lang.management.MemoryPoolMXBean.getType()
java.lang.reflect.Field.getType()
java.security.cert.Certificate.getType()
java.security.cert.CertificateFactory.getType()
java.security.cert.CertPath.getType()
java.security.cert.CertStore.getType()
java.security.cert.CRL.getType()
java.security.KeyStore.getType()
java.security.Policy.getType()
java.security.Provider.Service.getType()
java.sql.ResultSet.getType()
javax.accessibility.AccessibleTableModelChange.getType()
javax.management.MBeanAttributeInfo.getType()
javax.management.MBeanParameterInfo.getType()
javax.management.Notification.getType()
javax.management.openmbean.CompositeType.getType(java.lang.String)
javax.naming.event.NamingEvent.getType()
javax.naming.ldap.Rdn.getType()
javax.naming.RefAddr.getType()
javax.security.auth.login.Configuration.getType()
javax.sound.midi.MetaMessage.getType()
javax.sound.midi.MidiFileFormat.getType()
javax.sound.sampled.AudioFileFormat.getType()
javax.sound.sampled.Control.getType()
javax.sound.sampled.LineEvent.getType()
javax.sql.rowset.BaseRowSet.getType()
javax.swing.event.DocumentEvent.getType()
javax.swing.event.ListDataEvent.getType()
javax.swing.event.RowSorterEvent.getType()
javax.swing.event.TableModelEvent.getType()
javax.swing.JTable.AccessibleJTable.AccessibleJTableModelChange.getType()
javax.swing.text.AbstractDocument.DefaultDocumentEvent.getType()
javax.swing.text.DefaultStyledDocument.ElementSpec.getType()
javax.swing.text.html.parser.AttributeList.getType()
javax.swing.text.html.parser.Element.getType()
javax.swing.text.html.parser.Entity.getType()
javax.xml.crypto.URIReference.getType()
org.w3c.dom.DOMError.getType()
org.w3c.dom.events.Event.getType()
org.xml.sax.AttributeList.getType(int)
org.xml.sax.AttributeList.getType(java.lang.String)
org.xml.sax.Attributes.getType(int)
org.xml.sax.Attributes.getType(java.lang.String)
org.xml.sax.Attributes.getType(java.lang.String, java.lang.String)
org.xml.sax.helpers.AttributeListImpl.getType(int)
org.xml.sax.helpers.AttributeListImpl.getType(java.lang.String)
org.xml.sax.helpers.AttributesImpl.getType(int)
org.xml.sax.helpers.AttributesImpl.getType(java.lang.String)
org.xml.sax.helpers.AttributesImpl.getType(java.lang.String, java.lang.String)


Occurences of getTypeArguments

getTypeArguments occurences:
com.sun.source.tree.MethodInvocationTree.getTypeArguments()
com.sun.source.tree.NewClassTree.getTypeArguments()
com.sun.source.tree.ParameterizedTypeTree.getTypeArguments()
javax.lang.model.type.DeclaredType.getTypeArguments()


Occurences of getTypeDescription

getTypeDescription occurences:
javax.swing.filechooser.FileView.getTypeDescription(java.io.File)
javax.swing.JFileChooser.getTypeDescription(java.io.File)
javax.swing.plaf.basic.BasicFileChooserUI.BasicFileView.getTypeDescription(java.io.File)


Occurences of getTypeElement

getTypeElement occurences:
com.sun.source.util.TaskEvent.getTypeElement()
javax.lang.model.util.Elements.getTypeElement(java.lang.CharSequence)


Occurences of getTypeMap

getTypeMap occurences:
java.sql.Connection.getTypeMap()
javax.sql.RowSet.getTypeMap()
javax.sql.rowset.BaseRowSet.getTypeMap()


Occurences of getTypeMirror

getTypeMirror occurences:
com.sun.mirror.type.MirroredTypeException.getTypeMirror()
com.sun.source.util.JavacTask.getTypeMirror(java.lang.Iterable)
com.sun.source.util.Trees.getTypeMirror(com.sun.source.util.TreePath)
javax.lang.model.type.MirroredTypeException.getTypeMirror()


Occurences of getTypeMirrors

getTypeMirrors occurences:
com.sun.mirror.type.MirroredTypesException.getTypeMirrors()
javax.lang.model.type.MirroredTypesException.getTypeMirrors()


Occurences of getTypeName

getTypeName occurences:
javax.management.openmbean.OpenType.getTypeName()
org.w3c.dom.TypeInfo.getTypeName()


Occurences of getTypeParameters

getTypeParameters occurences:
com.sun.source.tree.ClassTree.getTypeParameters()
com.sun.source.tree.MethodTree.getTypeParameters()
java.lang.Class.getTypeParameters()
java.lang.reflect.Constructor.getTypeParameters()
java.lang.reflect.GenericDeclaration.getTypeParameters()
java.lang.reflect.Method.getTypeParameters()
javax.lang.model.element.ExecutableElement.getTypeParameters()
javax.lang.model.element.TypeElement.getTypeParameters()


Occurences of getTypeUtils

getTypeUtils occurences:
com.sun.mirror.apt.AnnotationProcessorEnvironment.getTypeUtils()
javax.annotation.processing.ProcessingEnvironment.getTypeUtils()


Occurences of getUI

getUI occurences:
javax.print.ServiceUIFactory.getUI(int, java.lang.String)
javax.swing.AbstractButton.getUI()
javax.swing.JColorChooser.getUI()
javax.swing.JComboBox.getUI()
javax.swing.JDesktopPane.getUI()
javax.swing.JFileChooser.getUI()
javax.swing.JInternalFrame.getUI()
javax.swing.JInternalFrame.JDesktopIcon.getUI()
javax.swing.JLabel.getUI()
javax.swing.JList.getUI()
javax.swing.JMenuBar.getUI()
javax.swing.JOptionPane.getUI()
javax.swing.JPanel.getUI()
javax.swing.JPopupMenu.getUI()
javax.swing.JProgressBar.getUI()
javax.swing.JRootPane.getUI()
javax.swing.JScrollBar.getUI()
javax.swing.JScrollPane.getUI()
javax.swing.JSeparator.getUI()
javax.swing.JSlider.getUI()
javax.swing.JSpinner.getUI()
javax.swing.JSplitPane.getUI()
javax.swing.JTabbedPane.getUI()
javax.swing.JTable.getUI()
javax.swing.JToolBar.getUI()
javax.swing.JToolTip.getUI()
javax.swing.JTree.getUI()
javax.swing.JViewport.getUI()
javax.swing.table.JTableHeader.getUI()
javax.swing.text.JTextComponent.getUI()
javax.swing.UIDefaults.getUI(javax.swing.JComponent)
javax.swing.UIManager.getUI(javax.swing.JComponent)


Occurences of getUIClass

getUIClass occurences:
javax.swing.UIDefaults.getUIClass(java.lang.String)
javax.swing.UIDefaults.getUIClass(java.lang.String, java.lang.ClassLoader)


Occurences of getUIClassID

getUIClassID occurences:
javax.swing.JButton.getUIClassID()
javax.swing.JCheckBox.getUIClassID()
javax.swing.JCheckBoxMenuItem.getUIClassID()
javax.swing.JColorChooser.getUIClassID()
javax.swing.JComboBox.getUIClassID()
javax.swing.JComponent.getUIClassID()
javax.swing.JDesktopPane.getUIClassID()
javax.swing.JEditorPane.getUIClassID()
javax.swing.JFileChooser.getUIClassID()
javax.swing.JFormattedTextField.getUIClassID()
javax.swing.JInternalFrame.getUIClassID()
javax.swing.JInternalFrame.JDesktopIcon.getUIClassID()
javax.swing.JLabel.getUIClassID()
javax.swing.JList.getUIClassID()
javax.swing.JMenu.getUIClassID()
javax.swing.JMenuBar.getUIClassID()
javax.swing.JMenuItem.getUIClassID()
javax.swing.JOptionPane.getUIClassID()
javax.swing.JPanel.getUIClassID()
javax.swing.JPasswordField.getUIClassID()
javax.swing.JPopupMenu.getUIClassID()
javax.swing.JPopupMenu.Separator.getUIClassID()
javax.swing.JProgressBar.getUIClassID()
javax.swing.JRadioButton.getUIClassID()
javax.swing.JRadioButtonMenuItem.getUIClassID()
javax.swing.JRootPane.getUIClassID()
javax.swing.JScrollBar.getUIClassID()
javax.swing.JScrollPane.getUIClassID()
javax.swing.JSeparator.getUIClassID()
javax.swing.JSlider.getUIClassID()
javax.swing.JSpinner.getUIClassID()
javax.swing.JSplitPane.getUIClassID()
javax.swing.JTabbedPane.getUIClassID()
javax.swing.JTable.getUIClassID()
javax.swing.JTextArea.getUIClassID()
javax.swing.JTextField.getUIClassID()
javax.swing.JTextPane.getUIClassID()
javax.swing.JToggleButton.getUIClassID()
javax.swing.JToolBar.getUIClassID()
javax.swing.JToolBar.Separator.getUIClassID()
javax.swing.JToolTip.getUIClassID()
javax.swing.JTree.getUIClassID()
javax.swing.JViewport.getUIClassID()
javax.swing.table.JTableHeader.getUIClassID()


Occurences of getUIs

getUIs occurences:
javax.swing.plaf.multi.MultiButtonUI.getUIs()
javax.swing.plaf.multi.MultiColorChooserUI.getUIs()
javax.swing.plaf.multi.MultiComboBoxUI.getUIs()
javax.swing.plaf.multi.MultiDesktopIconUI.getUIs()
javax.swing.plaf.multi.MultiDesktopPaneUI.getUIs()
javax.swing.plaf.multi.MultiFileChooserUI.getUIs()
javax.swing.plaf.multi.MultiInternalFrameUI.getUIs()
javax.swing.plaf.multi.MultiLabelUI.getUIs()
javax.swing.plaf.multi.MultiListUI.getUIs()
javax.swing.plaf.multi.MultiMenuBarUI.getUIs()
javax.swing.plaf.multi.MultiMenuItemUI.getUIs()
javax.swing.plaf.multi.MultiOptionPaneUI.getUIs()
javax.swing.plaf.multi.MultiPanelUI.getUIs()
javax.swing.plaf.multi.MultiPopupMenuUI.getUIs()
javax.swing.plaf.multi.MultiProgressBarUI.getUIs()
javax.swing.plaf.multi.MultiRootPaneUI.getUIs()
javax.swing.plaf.multi.MultiScrollBarUI.getUIs()
javax.swing.plaf.multi.MultiScrollPaneUI.getUIs()
javax.swing.plaf.multi.MultiSeparatorUI.getUIs()
javax.swing.plaf.multi.MultiSliderUI.getUIs()
javax.swing.plaf.multi.MultiSpinnerUI.getUIs()
javax.swing.plaf.multi.MultiSplitPaneUI.getUIs()
javax.swing.plaf.multi.MultiTabbedPaneUI.getUIs()
javax.swing.plaf.multi.MultiTableHeaderUI.getUIs()
javax.swing.plaf.multi.MultiTableUI.getUIs()
javax.swing.plaf.multi.MultiTextUI.getUIs()
javax.swing.plaf.multi.MultiToolBarUI.getUIs()
javax.swing.plaf.multi.MultiToolTipUI.getUIs()
javax.swing.plaf.multi.MultiTreeUI.getUIs()
javax.swing.plaf.multi.MultiViewportUI.getUIs()


Occurences of getUndoableEditListeners

getUndoableEditListeners occurences:
javax.swing.text.AbstractDocument.getUndoableEditListeners()
javax.swing.undo.UndoableEditSupport.getUndoableEditListeners()


Occurences of getUndoPresentationName

getUndoPresentationName occurences:
javax.swing.text.AbstractDocument.DefaultDocumentEvent.getUndoPresentationName()
javax.swing.undo.AbstractUndoableEdit.getUndoPresentationName()
javax.swing.undo.CompoundEdit.getUndoPresentationName()
javax.swing.undo.UndoableEdit.getUndoPresentationName()
javax.swing.undo.UndoManager.getUndoPresentationName()


Occurences of getUnicodeStream

getUnicodeStream occurences:
java.sql.ResultSet.getUnicodeStream(int)
java.sql.ResultSet.getUnicodeStream(java.lang.String)


Occurences of getUnitIncrement

getUnitIncrement occurences:
java.awt.Adjustable.getUnitIncrement()
java.awt.Scrollbar.getUnitIncrement()
java.awt.ScrollPaneAdjustable.getUnitIncrement()
javax.swing.JScrollBar.getUnitIncrement()
javax.swing.JScrollBar.getUnitIncrement(int)
javax.swing.JScrollPane.ScrollBar.getUnitIncrement(int)


Occurences of getUnnormalizedComponents

getUnnormalizedComponents occurences:
java.awt.image.ColorModel.getUnnormalizedComponents(float[], int, int[], int)
java.awt.image.ComponentColorModel.getUnnormalizedComponents(float[], int, int[], int)


Occurences of getUnsupportedAttributes

getUnsupportedAttributes occurences:
javax.print.AttributeException.getUnsupportedAttributes()
javax.print.PrintService.getUnsupportedAttributes(javax.print.DocFlavor, javax.print.attribute.AttributeSet)


Occurences of getUpperBounds

getUpperBounds occurences:
com.sun.mirror.type.WildcardType.getUpperBounds()
java.lang.reflect.WildcardType.getUpperBounds()


Occurences of getURI

getURI occurences:
java.security.URIParameter.getURI()
javax.print.attribute.URISyntax.getURI()
javax.xml.crypto.dsig.keyinfo.RetrievalMethod.getURI()
javax.xml.crypto.OctetStreamData.getURI()
javax.xml.crypto.URIReference.getURI()
javax.xml.soap.Name.getURI()
org.xml.sax.Attributes.getURI(int)
org.xml.sax.helpers.AttributesImpl.getURI(int)
org.xml.sax.helpers.NamespaceSupport.getURI(java.lang.String)


Occurences of getURIDereferencer

getURIDereferencer occurences:
javax.xml.crypto.dom.DOMCryptoContext.getURIDereferencer()
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.getURIDereferencer()
javax.xml.crypto.dsig.XMLSignatureFactory.getURIDereferencer()
javax.xml.crypto.XMLCryptoContext.getURIDereferencer()


Occurences of getURIResolver

getURIResolver occurences:
javax.xml.transform.Transformer.getURIResolver()
javax.xml.transform.TransformerFactory.getURIResolver()


Occurences of getUrl

getUrl occurences:
javax.sql.RowSet.getUrl()
javax.sql.rowset.BaseRowSet.getUrl()


Occurences of getURL

getURL occurences:
java.net.URLConnection.getURL()
java.sql.CallableStatement.getURL(int)
java.sql.CallableStatement.getURL(java.lang.String)
java.sql.DatabaseMetaData.getURL()
java.sql.ResultSet.getURL(int)
java.sql.ResultSet.getURL(java.lang.String)
javax.activation.URLDataSource.getURL()
javax.swing.event.HyperlinkEvent.getURL()
javax.xml.bind.helpers.ValidationEventLocatorImpl.getURL()
javax.xml.bind.ValidationEventLocator.getURL()


Occurences of getURLOrDefaultInitCtx

getURLOrDefaultInitCtx occurences:
javax.naming.InitialContext.getURLOrDefaultInitCtx(java.lang.String)
javax.naming.InitialContext.getURLOrDefaultInitCtx(javax.naming.Name)


Occurences of getURLs

getURLs occurences:
java.net.URLClassLoader.getURLs()
javax.management.loading.MLet.getURLs()
javax.management.loading.MLetMBean.getURLs()


Occurences of getUsage

getUsage occurences:
java.lang.management.MemoryNotificationInfo.getUsage()
java.lang.management.MemoryPoolMXBean.getUsage()
org.ietf.jgss.GSSCredential.getUsage()
org.ietf.jgss.GSSCredential.getUsage(org.ietf.jgss.Oid)


Occurences of getUseClientMode

getUseClientMode occurences:
javax.net.ssl.SSLEngine.getUseClientMode()
javax.net.ssl.SSLServerSocket.getUseClientMode()
javax.net.ssl.SSLSocket.getUseClientMode()


Occurences of getUserData

getUserData occurences:
javax.imageio.metadata.IIOMetadataNode.getUserData(java.lang.String)
javax.management.Notification.getUserData()
org.w3c.dom.Node.getUserData(java.lang.String)


Occurences of getUserInfo

getUserInfo occurences:
java.net.URI.getUserInfo()
java.net.URL.getUserInfo()


Occurences of getUsername

getUsername occurences:
javax.sql.RowSet.getUsername()
javax.sql.rowset.BaseRowSet.getUsername()


Occurences of getUserName

getUserName occurences:
java.awt.print.PrinterJob.getUserName()
java.net.PasswordAuthentication.getUserName()
java.sql.DatabaseMetaData.getUserName()


Occurences of getUserObject

getUserObject occurences:
javax.imageio.metadata.IIOMetadataNode.getUserObject()
javax.swing.tree.DefaultMutableTreeNode.getUserObject()


Occurences of getUserTextColor

getUserTextColor occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getUserTextColor()
javax.swing.plaf.metal.MetalTheme.getUserTextColor()


Occurences of getUserTextFont

getUserTextFont occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getUserTextFont()
javax.swing.plaf.metal.MetalLookAndFeel.getUserTextFont()
javax.swing.plaf.metal.MetalTheme.getUserTextFont()


Occurences of getValue

getValue occurences:
com.sun.jdi.ArrayReference.getValue(int)
com.sun.jdi.ObjectReference.getValue(com.sun.jdi.Field)
com.sun.jdi.ReferenceType.getValue(com.sun.jdi.Field)
com.sun.jdi.StackFrame.getValue(com.sun.jdi.LocalVariable)
com.sun.mirror.declaration.AnnotationValue.getValue()
com.sun.source.tree.LiteralTree.getValue()
java.awt.Adjustable.getValue()
java.awt.event.AdjustmentEvent.getValue()
java.awt.Scrollbar.getValue()
java.awt.ScrollPaneAdjustable.getValue()
java.beans.Expression.getValue()
java.beans.FeatureDescriptor.getValue(java.lang.String)
java.beans.PropertyEditor.getValue()
java.beans.PropertyEditorSupport.getValue()
java.net.HttpCookie.getValue()
java.rmi.dgc.Lease.getValue()
java.text.Annotation.getValue()
java.util.AbstractMap.SimpleEntry.getValue()
java.util.AbstractMap.SimpleImmutableEntry.getValue()
java.util.jar.Attributes.getValue(java.lang.String)
java.util.jar.Attributes.getValue(java.util.jar.Attributes.Name)
java.util.Map.Entry.getValue()
java.util.zip.Adler32.getValue()
java.util.zip.Checksum.getValue()
java.util.zip.CRC32.getValue()
javax.annotation.processing.Completion.getValue()
javax.crypto.spec.PSource.PSpecified.getValue()
javax.lang.model.element.AnnotationValue.getValue()
javax.management.Attribute.getValue()
javax.management.StringValueExp.getValue()
javax.naming.ldap.Rdn.getValue()
javax.net.ssl.SSLSession.getValue(java.lang.String)
javax.print.attribute.DateTimeSyntax.getValue()
javax.print.attribute.EnumSyntax.getValue()
javax.print.attribute.IntegerSyntax.getValue()
javax.print.attribute.TextSyntax.getValue()
javax.sound.sampled.BooleanControl.getValue()
javax.sound.sampled.EnumControl.getValue()
javax.sound.sampled.FloatControl.getValue()
javax.swing.AbstractAction.getValue(java.lang.String)
javax.swing.Action.getValue(java.lang.String)
javax.swing.BoundedRangeModel.getValue()
javax.swing.DefaultBoundedRangeModel.getValue()
javax.swing.JFormattedTextField.getValue()
javax.swing.JOptionPane.getValue()
javax.swing.JProgressBar.getValue()
javax.swing.JScrollBar.getValue()
javax.swing.JSlider.getValue()
javax.swing.JSpinner.getValue()
javax.swing.RowFilter.Entry.getValue(int)
javax.swing.SpinnerDateModel.getValue()
javax.swing.SpinnerListModel.getValue()
javax.swing.SpinnerModel.getValue()
javax.swing.SpinnerNumberModel.getValue()
javax.swing.Spring.getValue()
javax.swing.text.html.Option.getValue()
javax.swing.text.html.parser.AttributeList.getValue()
javax.xml.bind.JAXBElement.getValue()
javax.xml.bind.JAXBIntrospector.getValue(java.lang.Object)
javax.xml.crypto.dsig.XMLSignature.SignatureValue.getValue()
javax.xml.soap.MimeHeader.getValue()
javax.xml.soap.Node.getValue()
javax.xml.stream.events.Attribute.getValue()
org.w3c.dom.Attr.getValue()
org.xml.sax.AttributeList.getValue(int)
org.xml.sax.AttributeList.getValue(java.lang.String)
org.xml.sax.Attributes.getValue(int)
org.xml.sax.Attributes.getValue(java.lang.String)
org.xml.sax.Attributes.getValue(java.lang.String, java.lang.String)
org.xml.sax.helpers.AttributeListImpl.getValue(int)
org.xml.sax.helpers.AttributeListImpl.getValue(java.lang.String)
org.xml.sax.helpers.AttributesImpl.getValue(int)
org.xml.sax.helpers.AttributesImpl.getValue(java.lang.String)
org.xml.sax.helpers.AttributesImpl.getValue(java.lang.String, java.lang.String)


Occurences of getValueAt

getValueAt occurences:
javax.swing.DefaultRowSorter.ModelWrapper.getValueAt(int, int)
javax.swing.JTable.getValueAt(int, int)
javax.swing.table.DefaultTableModel.getValueAt(int, int)
javax.swing.table.TableModel.getValueAt(int, int)


Occurences of getValueIsAdjusting

getValueIsAdjusting occurences:
java.awt.event.AdjustmentEvent.getValueIsAdjusting()
java.awt.Scrollbar.getValueIsAdjusting()
java.awt.ScrollPaneAdjustable.getValueIsAdjusting()
javax.swing.BoundedRangeModel.getValueIsAdjusting()
javax.swing.DefaultBoundedRangeModel.getValueIsAdjusting()
javax.swing.DefaultListSelectionModel.getValueIsAdjusting()
javax.swing.event.ListSelectionEvent.getValueIsAdjusting()
javax.swing.JList.getValueIsAdjusting()
javax.swing.JScrollBar.getValueIsAdjusting()
javax.swing.JSlider.getValueIsAdjusting()
javax.swing.ListSelectionModel.getValueIsAdjusting()


Occurences of getValues

getValues occurences:
com.sun.jdi.ArrayReference.getValues()
com.sun.jdi.ArrayReference.getValues(int, int)
com.sun.jdi.ObjectReference.getValues(java.util.List)
com.sun.jdi.ReferenceType.getValues(java.util.List)
com.sun.jdi.StackFrame.getValues(java.util.List)
javax.imageio.plugins.jpeg.JPEGHuffmanTable.getValues()
javax.sound.sampled.EnumControl.getValues()
javax.swing.text.html.parser.AttributeList.getValues()


Occurences of getVariable

getVariable occurences:
com.sun.source.tree.AssignmentTree.getVariable()
com.sun.source.tree.CompoundAssignmentTree.getVariable()
com.sun.source.tree.EnhancedForLoopTree.getVariable()


Occurences of getVendor

getVendor occurences:
javax.sound.midi.MidiDevice.Info.getVendor()
javax.sound.midi.Soundbank.getVendor()
javax.sound.sampled.Mixer.Info.getVendor()
javax.sql.rowset.spi.SyncProvider.getVendor()


Occurences of getVersion

getVersion occurences:
java.awt.font.OpenType.getVersion()
java.lang.management.OperatingSystemMXBean.getVersion()
java.net.HttpCookie.getVersion()
java.security.cert.X509Certificate.getVersion()
java.security.cert.X509CRL.getVersion()
java.security.Provider.getVersion()
javax.crypto.spec.RC5ParameterSpec.getVersion()
javax.imageio.spi.IIOServiceProvider.getVersion()
javax.management.loading.MLetContent.getVersion()
javax.management.remote.rmi.RMIServer.getVersion()
javax.management.remote.rmi.RMIServerImpl.getVersion()
javax.management.remote.rmi.RMIServerImpl_Stub.getVersion()
javax.security.cert.X509Certificate.getVersion()
javax.sound.midi.MidiDevice.Info.getVersion()
javax.sound.midi.Soundbank.getVersion()
javax.sound.sampled.Mixer.Info.getVersion()
javax.sql.rowset.spi.SyncProvider.getVersion()
javax.xml.stream.events.StartDocument.getVersion()
javax.xml.stream.util.StreamReaderDelegate.getVersion()
javax.xml.stream.XMLStreamReader.getVersion()


Occurences of getVerticalAlignment

getVerticalAlignment occurences:
javax.swing.AbstractButton.getVerticalAlignment()
javax.swing.JLabel.getVerticalAlignment()


Occurences of getVerticalScrollBar

getVerticalScrollBar occurences:
javax.swing.JScrollPane.getVerticalScrollBar()
javax.swing.ScrollPaneLayout.getVerticalScrollBar()


Occurences of getVerticalScrollBarPolicy

getVerticalScrollBarPolicy occurences:
javax.swing.JScrollPane.getVerticalScrollBarPolicy()
javax.swing.ScrollPaneLayout.getVerticalScrollBarPolicy()


Occurences of getVerticalTextPosition

getVerticalTextPosition occurences:
javax.swing.AbstractButton.getVerticalTextPosition()
javax.swing.JLabel.getVerticalTextPosition()


Occurences of getVetoableChangeListeners

getVetoableChangeListeners occurences:
java.awt.KeyboardFocusManager.getVetoableChangeListeners()
java.awt.KeyboardFocusManager.getVetoableChangeListeners(java.lang.String)
java.beans.VetoableChangeSupport.getVetoableChangeListeners()
java.beans.VetoableChangeSupport.getVetoableChangeListeners(java.lang.String)
javax.swing.JComponent.getVetoableChangeListeners()


Occurences of getVgap

getVgap occurences:
java.awt.BorderLayout.getVgap()
java.awt.CardLayout.getVgap()
java.awt.FlowLayout.getVgap()
java.awt.GridLayout.getVgap()


Occurences of getView

getView occurences:
javax.swing.JViewport.getView()
javax.swing.text.AsyncBoxView.getView(int)
javax.swing.text.CompositeView.getView(int)
javax.swing.text.View.getView(int)
org.w3c.dom.events.UIEvent.getView()


Occurences of getViewAtPoint

getViewAtPoint occurences:
javax.swing.text.BoxView.getViewAtPoint(int, int, java.awt.Rectangle)
javax.swing.text.CompositeView.getViewAtPoint(int, int, java.awt.Rectangle)


Occurences of getViewAtPosition

getViewAtPosition occurences:
javax.swing.text.CompositeView.getViewAtPosition(int, java.awt.Rectangle)
javax.swing.text.TableView.getViewAtPosition(int, java.awt.Rectangle)
javax.swing.text.TableView.TableRow.getViewAtPosition(int, java.awt.Rectangle)


Occurences of getViewCount

getViewCount occurences:
javax.swing.text.AsyncBoxView.getViewCount()
javax.swing.text.CompositeView.getViewCount()
javax.swing.text.View.getViewCount()


Occurences of getViewFactory

getViewFactory occurences:
javax.swing.text.DefaultEditorKit.getViewFactory()
javax.swing.text.EditorKit.getViewFactory()
javax.swing.text.html.HTMLEditorKit.getViewFactory()
javax.swing.text.StyledEditorKit.getViewFactory()
javax.swing.text.View.getViewFactory()


Occurences of getViewIndex

getViewIndex occurences:
javax.swing.text.AsyncBoxView.getViewIndex(int, javax.swing.text.Position.Bias)
javax.swing.text.CompositeView.getViewIndex(int, javax.swing.text.Position.Bias)
javax.swing.text.View.getViewIndex(float, float, java.awt.Shape)
javax.swing.text.View.getViewIndex(int, javax.swing.text.Position.Bias)


Occurences of getViewIndexAtPosition

getViewIndexAtPosition occurences:
javax.swing.text.AsyncBoxView.getViewIndexAtPosition(int, javax.swing.text.Position.Bias)
javax.swing.text.CompositeView.getViewIndexAtPosition(int)
javax.swing.text.FlowView.getViewIndexAtPosition(int)
javax.swing.text.ZoneView.getViewIndexAtPosition(int)


Occurences of getViewport

getViewport occurences:
javax.swing.JScrollPane.getViewport()
javax.swing.ScrollPaneLayout.getViewport()


Occurences of getViewportBorderBounds

getViewportBorderBounds occurences:
javax.swing.JScrollPane.getViewportBorderBounds()
javax.swing.ScrollPaneLayout.getViewportBorderBounds(javax.swing.JScrollPane)


Occurences of getViewRowCount

getViewRowCount occurences:
javax.swing.DefaultRowSorter.getViewRowCount()
javax.swing.RowSorter.getViewRowCount()


Occurences of getVisibleAmount

getVisibleAmount occurences:
java.awt.Adjustable.getVisibleAmount()
java.awt.Scrollbar.getVisibleAmount()
java.awt.ScrollPaneAdjustable.getVisibleAmount()
javax.swing.JScrollBar.getVisibleAmount()


Occurences of getVisibleChildCount

getVisibleChildCount occurences:
javax.swing.tree.AbstractLayoutCache.getVisibleChildCount(javax.swing.tree.TreePath)
javax.swing.tree.FixedHeightLayoutCache.getVisibleChildCount(javax.swing.tree.TreePath)
javax.swing.tree.VariableHeightLayoutCache.getVisibleChildCount(javax.swing.tree.TreePath)


Occurences of getVisiblePathsFrom

getVisiblePathsFrom occurences:
javax.swing.tree.AbstractLayoutCache.getVisiblePathsFrom(javax.swing.tree.TreePath)
javax.swing.tree.FixedHeightLayoutCache.getVisiblePathsFrom(javax.swing.tree.TreePath)
javax.swing.tree.VariableHeightLayoutCache.getVisiblePathsFrom(javax.swing.tree.TreePath)


Occurences of getVisibleRowCount

getVisibleRowCount occurences:
javax.swing.JList.getVisibleRowCount()
javax.swing.JTree.getVisibleRowCount()


Occurences of getVisualHighlightShape

getVisualHighlightShape occurences:
java.awt.font.TextLayout.getVisualHighlightShape(java.awt.font.TextHitInfo, java.awt.font.TextHitInfo)
java.awt.font.TextLayout.getVisualHighlightShape(java.awt.font.TextHitInfo, java.awt.font.TextHitInfo, java.awt.geom.Rectangle2D)


Occurences of getW

getW occurences:
java.security.interfaces.ECPublicKey.getW()
java.security.spec.ECPublicKeySpec.getW()


Occurences of getWaitingThreads

getWaitingThreads occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.getWaitingThreads(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject)
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.getWaitingThreads()
java.util.concurrent.locks.AbstractQueuedSynchronizer.getWaitingThreads(java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject)
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.getWaitingThreads()
java.util.concurrent.locks.ReentrantLock.getWaitingThreads(java.util.concurrent.locks.Condition)
java.util.concurrent.locks.ReentrantReadWriteLock.getWaitingThreads(java.util.concurrent.locks.Condition)


Occurences of getWaitQueueLength

getWaitQueueLength occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.getWaitQueueLength(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject)
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.getWaitQueueLength()
java.util.concurrent.locks.AbstractQueuedSynchronizer.getWaitQueueLength(java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject)
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.getWaitQueueLength()
java.util.concurrent.locks.ReentrantLock.getWaitQueueLength(java.util.concurrent.locks.Condition)
java.util.concurrent.locks.ReentrantReadWriteLock.getWaitQueueLength(java.util.concurrent.locks.Condition)


Occurences of getWantClientAuth

getWantClientAuth occurences:
javax.net.ssl.SSLEngine.getWantClientAuth()
javax.net.ssl.SSLParameters.getWantClientAuth()
javax.net.ssl.SSLServerSocket.getWantClientAuth()
javax.net.ssl.SSLSocket.getWantClientAuth()


Occurences of getWarnings

getWarnings occurences:
java.sql.Connection.getWarnings()
java.sql.ResultSet.getWarnings()
java.sql.Statement.getWarnings()


Occurences of getWarningString

getWarningString occurences:
java.awt.Window.getWarningString()
javax.swing.JInternalFrame.getWarningString()


Occurences of getWhatToShow

getWhatToShow occurences:
org.w3c.dom.ls.LSParserFilter.getWhatToShow()
org.w3c.dom.ls.LSSerializerFilter.getWhatToShow()


Occurences of getWhen

getWhen occurences:
java.awt.event.ActionEvent.getWhen()
java.awt.event.InputEvent.getWhen()
java.awt.event.InputMethodEvent.getWhen()
java.awt.event.InvocationEvent.getWhen()


Occurences of getWhite

getWhite occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getWhite()
javax.swing.plaf.metal.MetalTheme.getWhite()


Occurences of getWidth

getWidth occurences:
java.awt.Component.getWidth()
java.awt.Dimension.getWidth()
java.awt.DisplayMode.getWidth()
java.awt.geom.Arc2D.Double.getWidth()
java.awt.geom.Arc2D.Float.getWidth()
java.awt.geom.Dimension2D.getWidth()
java.awt.geom.Ellipse2D.Double.getWidth()
java.awt.geom.Ellipse2D.Float.getWidth()
java.awt.geom.Rectangle2D.Double.getWidth()
java.awt.geom.Rectangle2D.Float.getWidth()
java.awt.geom.RectangularShape.getWidth()
java.awt.geom.RoundRectangle2D.Double.getWidth()
java.awt.geom.RoundRectangle2D.Float.getWidth()
java.awt.Image.getWidth(java.awt.image.ImageObserver)
java.awt.image.BufferedImage.getWidth()
java.awt.image.BufferedImage.getWidth(java.awt.image.ImageObserver)
java.awt.image.Kernel.getWidth()
java.awt.image.PixelGrabber.getWidth()
java.awt.image.Raster.getWidth()
java.awt.image.renderable.RenderableImage.getWidth()
java.awt.image.renderable.RenderableImageOp.getWidth()
java.awt.image.RenderedImage.getWidth()
java.awt.image.SampleModel.getWidth()
java.awt.image.VolatileImage.getWidth()
java.awt.print.PageFormat.getWidth()
java.awt.print.Paper.getWidth()
java.awt.Rectangle.getWidth()
java.util.IllegalFormatWidthException.getWidth()
javax.imageio.ImageReader.getWidth(int)
javax.print.attribute.standard.MediaPrintableArea.getWidth(int)
javax.swing.JComponent.getWidth()
javax.swing.SpringLayout.Constraints.getWidth()
javax.swing.table.TableColumn.getWidth()
javax.swing.text.BoxView.getWidth()


Occurences of getWildcardType

getWildcardType occurences:
com.sun.mirror.util.Types.getWildcardType(java.util.Collection, java.util.Collection)
javax.lang.model.util.Types.getWildcardType(javax.lang.model.type.TypeMirror, javax.lang.model.type.TypeMirror)


Occurences of getWindingRule

getWindingRule occurences:
java.awt.geom.FlatteningPathIterator.getWindingRule()
java.awt.geom.Path2D.getWindingRule()
java.awt.geom.PathIterator.getWindingRule()


Occurences of getWindowBackground

getWindowBackground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getWindowBackground()
javax.swing.plaf.metal.MetalTheme.getWindowBackground()


Occurences of getWindowTitleBackground

getWindowTitleBackground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getWindowTitleBackground()
javax.swing.plaf.metal.MetalTheme.getWindowTitleBackground()


Occurences of getWindowTitleFont

getWindowTitleFont occurences:
javax.swing.plaf.metal.DefaultMetalTheme.getWindowTitleFont()
javax.swing.plaf.metal.MetalLookAndFeel.getWindowTitleFont()
javax.swing.plaf.metal.MetalTheme.getWindowTitleFont()


Occurences of getWindowTitleForeground

getWindowTitleForeground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getWindowTitleForeground()
javax.swing.plaf.metal.MetalTheme.getWindowTitleForeground()


Occurences of getWindowTitleInactiveBackground

getWindowTitleInactiveBackground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getWindowTitleInactiveBackground()
javax.swing.plaf.metal.MetalTheme.getWindowTitleInactiveBackground()


Occurences of getWindowTitleInactiveForeground

getWindowTitleInactiveForeground occurences:
javax.swing.plaf.metal.MetalLookAndFeel.getWindowTitleInactiveForeground()
javax.swing.plaf.metal.MetalTheme.getWindowTitleInactiveForeground()


Occurences of getWordInstance

getWordInstance occurences:
java.text.BreakIterator.getWordInstance()
java.text.BreakIterator.getWordInstance(java.util.Locale)
java.text.spi.BreakIteratorProvider.getWordInstance(java.util.Locale)


Occurences of getWritableTile

getWritableTile occurences:
java.awt.image.BufferedImage.getWritableTile(int, int)
java.awt.image.WritableRenderedImage.getWritableTile(int, int)


Occurences of getWritableTileIndices

getWritableTileIndices occurences:
java.awt.image.BufferedImage.getWritableTileIndices()
java.awt.image.WritableRenderedImage.getWritableTileIndices()


Occurences of getWriter

getWriter occurences:
javax.script.ScriptContext.getWriter()
javax.script.SimpleScriptContext.getWriter()
javax.swing.text.AbstractWriter.getWriter()
javax.xml.transform.stream.StreamResult.getWriter()


Occurences of getWSDLDocumentLocation

getWSDLDocumentLocation occurences:
javax.xml.ws.Service.getWSDLDocumentLocation()
javax.xml.ws.spi.ServiceDelegate.getWSDLDocumentLocation()


Occurences of getX

getX occurences:
java.awt.Component.getX()
java.awt.dnd.DragSourceEvent.getX()
java.awt.event.MouseEvent.getX()
java.awt.geom.Arc2D.Double.getX()
java.awt.geom.Arc2D.Float.getX()
java.awt.geom.Ellipse2D.Double.getX()
java.awt.geom.Ellipse2D.Float.getX()
java.awt.geom.Point2D.getX()
java.awt.geom.Point2D.Double.getX()
java.awt.geom.Point2D.Float.getX()
java.awt.geom.Rectangle2D.Double.getX()
java.awt.geom.Rectangle2D.Float.getX()
java.awt.geom.RectangularShape.getX()
java.awt.geom.RoundRectangle2D.Double.getX()
java.awt.geom.RoundRectangle2D.Float.getX()
java.awt.Point.getX()
java.awt.Rectangle.getX()
java.security.interfaces.DSAPrivateKey.getX()
java.security.spec.DSAPrivateKeySpec.getX()
javax.crypto.interfaces.DHPrivateKey.getX()
javax.crypto.spec.DHPrivateKeySpec.getX()
javax.print.attribute.Size2DSyntax.getX(int)
javax.print.attribute.standard.MediaPrintableArea.getX(int)
javax.swing.JComponent.getX()
javax.swing.SpringLayout.Constraints.getX()


Occurences of getX1

getX1 occurences:
java.awt.geom.CubicCurve2D.getX1()
java.awt.geom.CubicCurve2D.Double.getX1()
java.awt.geom.CubicCurve2D.Float.getX1()
java.awt.geom.Line2D.getX1()
java.awt.geom.Line2D.Double.getX1()
java.awt.geom.Line2D.Float.getX1()
java.awt.geom.QuadCurve2D.getX1()
java.awt.geom.QuadCurve2D.Double.getX1()
java.awt.geom.QuadCurve2D.Float.getX1()


Occurences of getX2

getX2 occurences:
java.awt.geom.CubicCurve2D.getX2()
java.awt.geom.CubicCurve2D.Double.getX2()
java.awt.geom.CubicCurve2D.Float.getX2()
java.awt.geom.Line2D.getX2()
java.awt.geom.Line2D.Double.getX2()
java.awt.geom.Line2D.Float.getX2()
java.awt.geom.QuadCurve2D.getX2()
java.awt.geom.QuadCurve2D.Double.getX2()
java.awt.geom.QuadCurve2D.Float.getX2()


Occurences of getXAConnection

getXAConnection occurences:
javax.sql.XADataSource.getXAConnection()
javax.sql.XADataSource.getXAConnection(java.lang.String, java.lang.String)


Occurences of getXmlEncoding

getXmlEncoding occurences:
org.w3c.dom.Document.getXmlEncoding()
org.w3c.dom.Entity.getXmlEncoding()


Occurences of getXMLReader

getXMLReader occurences:
javax.xml.bind.helpers.AbstractUnmarshallerImpl.getXMLReader()
javax.xml.parsers.SAXParser.getXMLReader()
javax.xml.transform.sax.SAXSource.getXMLReader()


Occurences of getXMLSchemaType

getXMLSchemaType occurences:
javax.xml.datatype.Duration.getXMLSchemaType()
javax.xml.datatype.XMLGregorianCalendar.getXMLSchemaType()


Occurences of getXmlVersion

getXmlVersion occurences:
org.w3c.dom.Document.getXmlVersion()
org.w3c.dom.Entity.getXmlVersion()


Occurences of getXMLVersion

getXMLVersion occurences:
org.xml.sax.ext.Locator2.getXMLVersion()
org.xml.sax.ext.Locator2Impl.getXMLVersion()


Occurences of getY

getY occurences:
java.awt.Component.getY()
java.awt.dnd.DragSourceEvent.getY()
java.awt.event.MouseEvent.getY()
java.awt.geom.Arc2D.Double.getY()
java.awt.geom.Arc2D.Float.getY()
java.awt.geom.Ellipse2D.Double.getY()
java.awt.geom.Ellipse2D.Float.getY()
java.awt.geom.Point2D.getY()
java.awt.geom.Point2D.Double.getY()
java.awt.geom.Point2D.Float.getY()
java.awt.geom.Rectangle2D.Double.getY()
java.awt.geom.Rectangle2D.Float.getY()
java.awt.geom.RectangularShape.getY()
java.awt.geom.RoundRectangle2D.Double.getY()
java.awt.geom.RoundRectangle2D.Float.getY()
java.awt.Point.getY()
java.awt.Rectangle.getY()
java.security.interfaces.DSAPublicKey.getY()
java.security.spec.DSAPublicKeySpec.getY()
javax.crypto.interfaces.DHPublicKey.getY()
javax.crypto.spec.DHPublicKeySpec.getY()
javax.print.attribute.Size2DSyntax.getY(int)
javax.print.attribute.standard.MediaPrintableArea.getY(int)
javax.swing.JComponent.getY()
javax.swing.SpringLayout.Constraints.getY()


Occurences of getY1

getY1 occurences:
java.awt.geom.CubicCurve2D.getY1()
java.awt.geom.CubicCurve2D.Double.getY1()
java.awt.geom.CubicCurve2D.Float.getY1()
java.awt.geom.Line2D.getY1()
java.awt.geom.Line2D.Double.getY1()
java.awt.geom.Line2D.Float.getY1()
java.awt.geom.QuadCurve2D.getY1()
java.awt.geom.QuadCurve2D.Double.getY1()
java.awt.geom.QuadCurve2D.Float.getY1()


Occurences of getY2

getY2 occurences:
java.awt.geom.CubicCurve2D.getY2()
java.awt.geom.CubicCurve2D.Double.getY2()
java.awt.geom.CubicCurve2D.Float.getY2()
java.awt.geom.Line2D.getY2()
java.awt.geom.Line2D.Double.getY2()
java.awt.geom.Line2D.Float.getY2()
java.awt.geom.QuadCurve2D.getY2()
java.awt.geom.QuadCurve2D.Double.getY2()
java.awt.geom.QuadCurve2D.Float.getY2()


Occurences of getYear

getYear occurences:
java.sql.Time.getYear()
java.util.Date.getYear()
javax.xml.datatype.XMLGregorianCalendar.getYear()


Occurences of get_any

get_any occurences:
org.omg.CORBA.DynAny.get_any()
org.omg.DynamicAny.DynAnyOperations.get_any()
org.omg.DynamicAny._DynAnyStub.get_any()
org.omg.DynamicAny._DynArrayStub.get_any()
org.omg.DynamicAny._DynEnumStub.get_any()
org.omg.DynamicAny._DynFixedStub.get_any()
org.omg.DynamicAny._DynSequenceStub.get_any()
org.omg.DynamicAny._DynStructStub.get_any()
org.omg.DynamicAny._DynUnionStub.get_any()
org.omg.DynamicAny._DynValueStub.get_any()


Occurences of get_as_string

get_as_string occurences:
org.omg.DynamicAny.DynEnumOperations.get_as_string()
org.omg.DynamicAny._DynEnumStub.get_as_string()


Occurences of get_as_ulong

get_as_ulong occurences:
org.omg.DynamicAny.DynEnumOperations.get_as_ulong()
org.omg.DynamicAny._DynEnumStub.get_as_ulong()


Occurences of get_boolean

get_boolean occurences:
org.omg.CORBA.DynAny.get_boolean()
org.omg.DynamicAny.DynAnyOperations.get_boolean()
org.omg.DynamicAny._DynAnyStub.get_boolean()
org.omg.DynamicAny._DynArrayStub.get_boolean()
org.omg.DynamicAny._DynEnumStub.get_boolean()
org.omg.DynamicAny._DynFixedStub.get_boolean()
org.omg.DynamicAny._DynSequenceStub.get_boolean()
org.omg.DynamicAny._DynStructStub.get_boolean()
org.omg.DynamicAny._DynUnionStub.get_boolean()
org.omg.DynamicAny._DynValueStub.get_boolean()


Occurences of get_char

get_char occurences:
org.omg.CORBA.DynAny.get_char()
org.omg.DynamicAny.DynAnyOperations.get_char()
org.omg.DynamicAny._DynAnyStub.get_char()
org.omg.DynamicAny._DynArrayStub.get_char()
org.omg.DynamicAny._DynEnumStub.get_char()
org.omg.DynamicAny._DynFixedStub.get_char()
org.omg.DynamicAny._DynSequenceStub.get_char()
org.omg.DynamicAny._DynStructStub.get_char()
org.omg.DynamicAny._DynUnionStub.get_char()
org.omg.DynamicAny._DynValueStub.get_char()


Occurences of get_discriminator

get_discriminator occurences:
org.omg.DynamicAny.DynUnionOperations.get_discriminator()
org.omg.DynamicAny._DynUnionStub.get_discriminator()


Occurences of get_double

get_double occurences:
org.omg.CORBA.DynAny.get_double()
org.omg.DynamicAny.DynAnyOperations.get_double()
org.omg.DynamicAny._DynAnyStub.get_double()
org.omg.DynamicAny._DynArrayStub.get_double()
org.omg.DynamicAny._DynEnumStub.get_double()
org.omg.DynamicAny._DynFixedStub.get_double()
org.omg.DynamicAny._DynSequenceStub.get_double()
org.omg.DynamicAny._DynStructStub.get_double()
org.omg.DynamicAny._DynUnionStub.get_double()
org.omg.DynamicAny._DynValueStub.get_double()


Occurences of get_dyn_any

get_dyn_any occurences:
org.omg.DynamicAny.DynAnyOperations.get_dyn_any()
org.omg.DynamicAny._DynAnyStub.get_dyn_any()
org.omg.DynamicAny._DynArrayStub.get_dyn_any()
org.omg.DynamicAny._DynEnumStub.get_dyn_any()
org.omg.DynamicAny._DynFixedStub.get_dyn_any()
org.omg.DynamicAny._DynSequenceStub.get_dyn_any()
org.omg.DynamicAny._DynStructStub.get_dyn_any()
org.omg.DynamicAny._DynUnionStub.get_dyn_any()
org.omg.DynamicAny._DynValueStub.get_dyn_any()


Occurences of get_elements

get_elements occurences:
org.omg.CORBA.DynArray.get_elements()
org.omg.CORBA.DynSequence.get_elements()
org.omg.DynamicAny.DynArrayOperations.get_elements()
org.omg.DynamicAny.DynSequenceOperations.get_elements()
org.omg.DynamicAny._DynArrayStub.get_elements()
org.omg.DynamicAny._DynSequenceStub.get_elements()


Occurences of get_elements_as_dyn_any

get_elements_as_dyn_any occurences:
org.omg.DynamicAny.DynArrayOperations.get_elements_as_dyn_any()
org.omg.DynamicAny.DynSequenceOperations.get_elements_as_dyn_any()
org.omg.DynamicAny._DynArrayStub.get_elements_as_dyn_any()
org.omg.DynamicAny._DynSequenceStub.get_elements_as_dyn_any()


Occurences of get_float

get_float occurences:
org.omg.CORBA.DynAny.get_float()
org.omg.DynamicAny.DynAnyOperations.get_float()
org.omg.DynamicAny._DynAnyStub.get_float()
org.omg.DynamicAny._DynArrayStub.get_float()
org.omg.DynamicAny._DynEnumStub.get_float()
org.omg.DynamicAny._DynFixedStub.get_float()
org.omg.DynamicAny._DynSequenceStub.get_float()
org.omg.DynamicAny._DynStructStub.get_float()
org.omg.DynamicAny._DynUnionStub.get_float()
org.omg.DynamicAny._DynValueStub.get_float()


Occurences of get_id

get_id occurences:
org.omg.CORBA.portable.BoxedValueHelper.get_id()
org.omg.CORBA.StringValueHelper.get_id()
org.omg.CORBA.WStringValueHelper.get_id()


Occurences of get_interface_def

get_interface_def occurences:
org.omg.CORBA.portable.Delegate.get_interface_def(org.omg.CORBA.Object)
org.omg.PortableServer.portable.Delegate.get_interface_def(org.omg.PortableServer.Servant)


Occurences of get_length

get_length occurences:
org.omg.DynamicAny.DynSequenceOperations.get_length()
org.omg.DynamicAny._DynSequenceStub.get_length()


Occurences of get_long

get_long occurences:
org.omg.CORBA.DynAny.get_long()
org.omg.DynamicAny.DynAnyOperations.get_long()
org.omg.DynamicAny._DynAnyStub.get_long()
org.omg.DynamicAny._DynArrayStub.get_long()
org.omg.DynamicAny._DynEnumStub.get_long()
org.omg.DynamicAny._DynFixedStub.get_long()
org.omg.DynamicAny._DynSequenceStub.get_long()
org.omg.DynamicAny._DynStructStub.get_long()
org.omg.DynamicAny._DynUnionStub.get_long()
org.omg.DynamicAny._DynValueStub.get_long()


Occurences of get_longlong

get_longlong occurences:
org.omg.CORBA.DynAny.get_longlong()
org.omg.DynamicAny.DynAnyOperations.get_longlong()
org.omg.DynamicAny._DynAnyStub.get_longlong()
org.omg.DynamicAny._DynArrayStub.get_longlong()
org.omg.DynamicAny._DynEnumStub.get_longlong()
org.omg.DynamicAny._DynFixedStub.get_longlong()
org.omg.DynamicAny._DynSequenceStub.get_longlong()
org.omg.DynamicAny._DynStructStub.get_longlong()
org.omg.DynamicAny._DynUnionStub.get_longlong()
org.omg.DynamicAny._DynValueStub.get_longlong()


Occurences of get_members

get_members occurences:
org.omg.CORBA.DynStruct.get_members()
org.omg.CORBA.DynValue.get_members()
org.omg.DynamicAny.DynStructOperations.get_members()
org.omg.DynamicAny.DynValueOperations.get_members()
org.omg.DynamicAny._DynStructStub.get_members()
org.omg.DynamicAny._DynValueStub.get_members()


Occurences of get_members_as_dyn_any

get_members_as_dyn_any occurences:
org.omg.DynamicAny.DynStructOperations.get_members_as_dyn_any()
org.omg.DynamicAny.DynValueOperations.get_members_as_dyn_any()
org.omg.DynamicAny._DynStructStub.get_members_as_dyn_any()
org.omg.DynamicAny._DynValueStub.get_members_as_dyn_any()


Occurences of get_octet

get_octet occurences:
org.omg.CORBA.DynAny.get_octet()
org.omg.DynamicAny.DynAnyOperations.get_octet()
org.omg.DynamicAny._DynAnyStub.get_octet()
org.omg.DynamicAny._DynArrayStub.get_octet()
org.omg.DynamicAny._DynEnumStub.get_octet()
org.omg.DynamicAny._DynFixedStub.get_octet()
org.omg.DynamicAny._DynSequenceStub.get_octet()
org.omg.DynamicAny._DynStructStub.get_octet()
org.omg.DynamicAny._DynUnionStub.get_octet()
org.omg.DynamicAny._DynValueStub.get_octet()


Occurences of get_reference

get_reference occurences:
org.omg.CORBA.DynAny.get_reference()
org.omg.DynamicAny.DynAnyOperations.get_reference()
org.omg.DynamicAny._DynAnyStub.get_reference()
org.omg.DynamicAny._DynArrayStub.get_reference()
org.omg.DynamicAny._DynEnumStub.get_reference()
org.omg.DynamicAny._DynFixedStub.get_reference()
org.omg.DynamicAny._DynSequenceStub.get_reference()
org.omg.DynamicAny._DynStructStub.get_reference()
org.omg.DynamicAny._DynUnionStub.get_reference()
org.omg.DynamicAny._DynValueStub.get_reference()


Occurences of get_short

get_short occurences:
org.omg.CORBA.DynAny.get_short()
org.omg.DynamicAny.DynAnyOperations.get_short()
org.omg.DynamicAny._DynAnyStub.get_short()
org.omg.DynamicAny._DynArrayStub.get_short()
org.omg.DynamicAny._DynEnumStub.get_short()
org.omg.DynamicAny._DynFixedStub.get_short()
org.omg.DynamicAny._DynSequenceStub.get_short()
org.omg.DynamicAny._DynStructStub.get_short()
org.omg.DynamicAny._DynUnionStub.get_short()
org.omg.DynamicAny._DynValueStub.get_short()


Occurences of get_slot

get_slot occurences:
org.omg.PortableInterceptor.CurrentOperations.get_slot(int)
org.omg.PortableInterceptor.RequestInfoOperations.get_slot(int)


Occurences of get_string

get_string occurences:
org.omg.CORBA.DynAny.get_string()
org.omg.DynamicAny.DynAnyOperations.get_string()
org.omg.DynamicAny._DynAnyStub.get_string()
org.omg.DynamicAny._DynArrayStub.get_string()
org.omg.DynamicAny._DynEnumStub.get_string()
org.omg.DynamicAny._DynFixedStub.get_string()
org.omg.DynamicAny._DynSequenceStub.get_string()
org.omg.DynamicAny._DynStructStub.get_string()
org.omg.DynamicAny._DynUnionStub.get_string()
org.omg.DynamicAny._DynValueStub.get_string()


Occurences of get_typecode

get_typecode occurences:
org.omg.CORBA.DynAny.get_typecode()
org.omg.DynamicAny.DynAnyOperations.get_typecode()
org.omg.DynamicAny._DynAnyStub.get_typecode()
org.omg.DynamicAny._DynArrayStub.get_typecode()
org.omg.DynamicAny._DynEnumStub.get_typecode()
org.omg.DynamicAny._DynFixedStub.get_typecode()
org.omg.DynamicAny._DynSequenceStub.get_typecode()
org.omg.DynamicAny._DynStructStub.get_typecode()
org.omg.DynamicAny._DynUnionStub.get_typecode()
org.omg.DynamicAny._DynValueStub.get_typecode()


Occurences of get_ulong

get_ulong occurences:
org.omg.CORBA.DynAny.get_ulong()
org.omg.DynamicAny.DynAnyOperations.get_ulong()
org.omg.DynamicAny._DynAnyStub.get_ulong()
org.omg.DynamicAny._DynArrayStub.get_ulong()
org.omg.DynamicAny._DynEnumStub.get_ulong()
org.omg.DynamicAny._DynFixedStub.get_ulong()
org.omg.DynamicAny._DynSequenceStub.get_ulong()
org.omg.DynamicAny._DynStructStub.get_ulong()
org.omg.DynamicAny._DynUnionStub.get_ulong()
org.omg.DynamicAny._DynValueStub.get_ulong()


Occurences of get_ulonglong

get_ulonglong occurences:
org.omg.CORBA.DynAny.get_ulonglong()
org.omg.DynamicAny.DynAnyOperations.get_ulonglong()
org.omg.DynamicAny._DynAnyStub.get_ulonglong()
org.omg.DynamicAny._DynArrayStub.get_ulonglong()
org.omg.DynamicAny._DynEnumStub.get_ulonglong()
org.omg.DynamicAny._DynFixedStub.get_ulonglong()
org.omg.DynamicAny._DynSequenceStub.get_ulonglong()
org.omg.DynamicAny._DynStructStub.get_ulonglong()
org.omg.DynamicAny._DynUnionStub.get_ulonglong()
org.omg.DynamicAny._DynValueStub.get_ulonglong()


Occurences of get_ushort

get_ushort occurences:
org.omg.CORBA.DynAny.get_ushort()
org.omg.DynamicAny.DynAnyOperations.get_ushort()
org.omg.DynamicAny._DynAnyStub.get_ushort()
org.omg.DynamicAny._DynArrayStub.get_ushort()
org.omg.DynamicAny._DynEnumStub.get_ushort()
org.omg.DynamicAny._DynFixedStub.get_ushort()
org.omg.DynamicAny._DynSequenceStub.get_ushort()
org.omg.DynamicAny._DynStructStub.get_ushort()
org.omg.DynamicAny._DynUnionStub.get_ushort()
org.omg.DynamicAny._DynValueStub.get_ushort()


Occurences of get_val

get_val occurences:
org.omg.CORBA.DynAny.get_val()
org.omg.DynamicAny.DynAnyOperations.get_val()
org.omg.DynamicAny._DynAnyStub.get_val()
org.omg.DynamicAny._DynArrayStub.get_val()
org.omg.DynamicAny._DynEnumStub.get_val()
org.omg.DynamicAny._DynFixedStub.get_val()
org.omg.DynamicAny._DynSequenceStub.get_val()
org.omg.DynamicAny._DynStructStub.get_val()
org.omg.DynamicAny._DynUnionStub.get_val()
org.omg.DynamicAny._DynValueStub.get_val()


Occurences of get_value

get_value occurences:
org.omg.CORBA.DynFixed.get_value()
org.omg.DynamicAny.DynFixedOperations.get_value()
org.omg.DynamicAny._DynFixedStub.get_value()


Occurences of get_wchar

get_wchar occurences:
org.omg.CORBA.DynAny.get_wchar()
org.omg.DynamicAny.DynAnyOperations.get_wchar()
org.omg.DynamicAny._DynAnyStub.get_wchar()
org.omg.DynamicAny._DynArrayStub.get_wchar()
org.omg.DynamicAny._DynEnumStub.get_wchar()
org.omg.DynamicAny._DynFixedStub.get_wchar()
org.omg.DynamicAny._DynSequenceStub.get_wchar()
org.omg.DynamicAny._DynStructStub.get_wchar()
org.omg.DynamicAny._DynUnionStub.get_wchar()
org.omg.DynamicAny._DynValueStub.get_wchar()


Occurences of get_wstring

get_wstring occurences:
org.omg.CORBA.DynAny.get_wstring()
org.omg.DynamicAny.DynAnyOperations.get_wstring()
org.omg.DynamicAny._DynAnyStub.get_wstring()
org.omg.DynamicAny._DynArrayStub.get_wstring()
org.omg.DynamicAny._DynEnumStub.get_wstring()
org.omg.DynamicAny._DynFixedStub.get_wstring()
org.omg.DynamicAny._DynSequenceStub.get_wstring()
org.omg.DynamicAny._DynStructStub.get_wstring()
org.omg.DynamicAny._DynUnionStub.get_wstring()
org.omg.DynamicAny._DynValueStub.get_wstring()


Occurences of GIF

GIF occurences:
javax.print.GIF
javax.print.GIF
javax.print.GIF


Occurences of GlyphMetrics (constructors)

GlyphMetrics (constructors) occurences:
java.awt.font.GlyphMetrics(boolean, float, float, java.awt.geom.Rectangle2D, byte)
java.awt.font.GlyphMetrics(float, java.awt.geom.Rectangle2D, byte)


Occurences of grabPixels

grabPixels occurences:
java.awt.image.PixelGrabber.grabPixels()
java.awt.image.PixelGrabber.grabPixels(long)


Occurences of GradientPaint (constructors)

GradientPaint (constructors) occurences:
java.awt.GradientPaint(float, float, java.awt.Color, float, float, java.awt.Color)
java.awt.GradientPaint(float, float, java.awt.Color, float, float, java.awt.Color, boolean)
java.awt.GradientPaint(java.awt.geom.Point2D, java.awt.Color, java.awt.geom.Point2D, java.awt.Color)
java.awt.GradientPaint(java.awt.geom.Point2D, java.awt.Color, java.awt.geom.Point2D, java.awt.Color, boolean)


Occurences of GregorianCalendar (constructors)

GregorianCalendar (constructors) occurences:
java.util.GregorianCalendar()
java.util.GregorianCalendar(int, int, int)
java.util.GregorianCalendar(int, int, int, int, int)
java.util.GregorianCalendar(int, int, int, int, int, int)
java.util.GregorianCalendar(java.util.Locale)
java.util.GregorianCalendar(java.util.TimeZone)
java.util.GregorianCalendar(java.util.TimeZone, java.util.Locale)


Occurences of GridBagConstraints (constructors)

GridBagConstraints (constructors) occurences:
java.awt.GridBagConstraints()
java.awt.GridBagConstraints(int, int, int, int, double, double, int, int, java.awt.Insets, int, int)


Occurences of GridLayout (constructors)

GridLayout (constructors) occurences:
java.awt.GridLayout()
java.awt.GridLayout(int, int)
java.awt.GridLayout(int, int, int, int)


Occurences of group

group occurences:
java.util.regex.Matcher.group()
java.util.regex.Matcher.group(int)
java.util.regex.MatchResult.group()
java.util.regex.MatchResult.group(int)
javax.swing.group


Occurences of groupCount

groupCount occurences:
java.util.regex.Matcher.groupCount()
java.util.regex.MatchResult.groupCount()


Occurences of GSSException (constructors)

GSSException (constructors) occurences:
org.ietf.jgss.GSSException(int)
org.ietf.jgss.GSSException(int, int, java.lang.String)


Occurences of GUJARATI

GUJARATI occurences:
java.awt.font.GUJARATI
java.lang.GUJARATI


Occurences of GURMUKHI

GURMUKHI occurences:
java.awt.font.GURMUKHI
java.lang.GURMUKHI


Occurences of GZIPInputStream (constructors)

GZIPInputStream (constructors) occurences:
java.util.zip.GZIPInputStream(java.io.InputStream)
java.util.zip.GZIPInputStream(java.io.InputStream, int)


Occurences of GZIPOutputStream (constructors)

GZIPOutputStream (constructors) occurences:
java.util.zip.GZIPOutputStream(java.io.OutputStream)
java.util.zip.GZIPOutputStream(java.io.OutputStream, int)


Occurences of handle

handle occurences:
javax.security.auth.callback.CallbackHandler.handle(javax.security.auth.callback.Callback[])
org.w3c.dom.UserDataHandler.handle(short, java.lang.String, java.lang.Object, org.w3c.dom.Node, org.w3c.dom.Node)


Occurences of handleComment

handleComment occurences:
javax.swing.text.html.HTMLDocument.HTMLReader.handleComment(char[], int)
javax.swing.text.html.HTMLEditorKit.ParserCallback.handleComment(char[], int)
javax.swing.text.html.parser.DocumentParser.handleComment(char[])
javax.swing.text.html.parser.Parser.handleComment(char[])


Occurences of handleEmptyTag

handleEmptyTag occurences:
javax.swing.text.html.parser.DocumentParser.handleEmptyTag(javax.swing.text.html.parser.TagElement)
javax.swing.text.html.parser.Parser.handleEmptyTag(javax.swing.text.html.parser.TagElement)


Occurences of handleEndOfLineString

handleEndOfLineString occurences:
javax.swing.text.html.HTMLDocument.HTMLReader.handleEndOfLineString(java.lang.String)
javax.swing.text.html.HTMLEditorKit.ParserCallback.handleEndOfLineString(java.lang.String)


Occurences of handleEndTag

handleEndTag occurences:
javax.swing.text.html.HTMLDocument.HTMLReader.handleEndTag(javax.swing.text.html.HTML.Tag, int)
javax.swing.text.html.HTMLEditorKit.ParserCallback.handleEndTag(javax.swing.text.html.HTML.Tag, int)
javax.swing.text.html.parser.DocumentParser.handleEndTag(javax.swing.text.html.parser.TagElement)
javax.swing.text.html.parser.Parser.handleEndTag(javax.swing.text.html.parser.TagElement)


Occurences of handleError

handleError occurences:
javax.swing.text.html.HTMLEditorKit.ParserCallback.handleError(java.lang.String, int)
javax.swing.text.html.parser.DocumentParser.handleError(int, java.lang.String)
javax.swing.text.html.parser.Parser.handleError(int, java.lang.String)
org.w3c.dom.DOMErrorHandler.handleError(org.w3c.dom.DOMError)


Occurences of handleEvent

handleEvent occurences:
java.awt.Component.handleEvent(java.awt.Event)
javax.xml.bind.helpers.DefaultValidationEventHandler.handleEvent(javax.xml.bind.ValidationEvent)
javax.xml.bind.util.ValidationEventCollector.handleEvent(javax.xml.bind.ValidationEvent)
javax.xml.bind.ValidationEventHandler.handleEvent(javax.xml.bind.ValidationEvent)
org.w3c.dom.events.EventListener.handleEvent(org.w3c.dom.events.Event)


Occurences of handleFault

handleFault occurences:
javax.xml.ws.handler.Handler.handleFault(C)
javax.xml.ws.handler.Handler.handleFault(javax.xml.ws.handler.MessageContext)


Occurences of handleGetObject

handleGetObject occurences:
java.util.ListResourceBundle.handleGetObject(java.lang.String)
java.util.PropertyResourceBundle.handleGetObject(java.lang.String)
java.util.ResourceBundle.handleGetObject(java.lang.String)


Occurences of handleKeySet

handleKeySet occurences:
java.util.ListResourceBundle.handleKeySet()
java.util.PropertyResourceBundle.handleKeySet()
java.util.ResourceBundle.handleKeySet()


Occurences of handleMBeanUnregistration

handleMBeanUnregistration occurences:
javax.management.relation.Relation.handleMBeanUnregistration(javax.management.ObjectName, java.lang.String)
javax.management.relation.RelationSupport.handleMBeanUnregistration(javax.management.ObjectName, java.lang.String)


Occurences of handleMessage

handleMessage occurences:
javax.xml.ws.handler.Handler.handleMessage(C)
javax.xml.ws.handler.Handler.handleMessage(javax.xml.ws.handler.MessageContext)


Occurences of handleNotification

handleNotification occurences:
javax.management.NotificationBroadcasterSupport.handleNotification(javax.management.NotificationListener, javax.management.Notification, java.lang.Object)
javax.management.NotificationListener.handleNotification(javax.management.Notification, java.lang.Object)
javax.management.relation.RelationService.handleNotification(javax.management.Notification, java.lang.Object)


Occurences of handleOption

handleOption occurences:
javax.tools.ForwardingJavaFileManager.handleOption(java.lang.String, java.util.Iterator)
javax.tools.JavaFileManager.handleOption(java.lang.String, java.util.Iterator)


Occurences of Handler

Handler occurences:
java.util.logging.Handler
javax.xml.ws.handler.Handler


Occurences of handleSimpleTag

handleSimpleTag occurences:
javax.swing.text.html.HTMLDocument.HTMLReader.handleSimpleTag(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet, int)
javax.swing.text.html.HTMLEditorKit.ParserCallback.handleSimpleTag(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet, int)


Occurences of handleStartTag

handleStartTag occurences:
javax.swing.text.html.HTMLDocument.HTMLReader.handleStartTag(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet, int)
javax.swing.text.html.HTMLEditorKit.ParserCallback.handleStartTag(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet, int)
javax.swing.text.html.parser.DocumentParser.handleStartTag(javax.swing.text.html.parser.TagElement)
javax.swing.text.html.parser.Parser.handleStartTag(javax.swing.text.html.parser.TagElement)


Occurences of handleText

handleText occurences:
javax.swing.text.html.HTMLDocument.HTMLReader.handleText(char[], int)
javax.swing.text.html.HTMLEditorKit.ParserCallback.handleText(char[], int)
javax.swing.text.html.parser.DocumentParser.handleText(char[])
javax.swing.text.html.parser.Parser.handleText(char[])


Occurences of HAND_CURSOR

HAND_CURSOR occurences:
java.awt.HAND_CURSOR
java.awt.HAND_CURSOR


Occurences of HANGING_BASELINE

HANGING_BASELINE occurences:
java.awt.font.HANGING_BASELINE
java.awt.HANGING_BASELINE


Occurences of hasArray

hasArray occurences:
java.nio.Buffer.hasArray()
java.nio.ByteBuffer.hasArray()
java.nio.CharBuffer.hasArray()
java.nio.DoubleBuffer.hasArray()
java.nio.FloatBuffer.hasArray()
java.nio.IntBuffer.hasArray()
java.nio.LongBuffer.hasArray()
java.nio.ShortBuffer.hasArray()


Occurences of hasAttribute

hasAttribute occurences:
javax.imageio.metadata.IIOMetadataNode.hasAttribute(java.lang.String)
org.w3c.dom.Element.hasAttribute(java.lang.String)


Occurences of hasAttributeNS

hasAttributeNS occurences:
javax.imageio.metadata.IIOMetadataNode.hasAttributeNS(java.lang.String, java.lang.String)
org.w3c.dom.Element.hasAttributeNS(java.lang.String, java.lang.String)


Occurences of hasAttributes

hasAttributes occurences:
javax.imageio.metadata.IIOMetadataNode.hasAttributes()
org.w3c.dom.Node.hasAttributes()


Occurences of hasChildNodes

hasChildNodes occurences:
javax.imageio.metadata.IIOMetadataNode.hasChildNodes()
org.w3c.dom.Node.hasChildNodes()


Occurences of hasContended

hasContended occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.hasContended()
java.util.concurrent.locks.AbstractQueuedSynchronizer.hasContended()


Occurences of hasController

hasController occurences:
javax.imageio.IIOParam.hasController()
javax.imageio.metadata.IIOMetadata.hasController()


Occurences of hasDefaultValue

hasDefaultValue occurences:
javax.management.openmbean.OpenMBeanAttributeInfoSupport.hasDefaultValue()
javax.management.openmbean.OpenMBeanParameterInfo.hasDefaultValue()
javax.management.openmbean.OpenMBeanParameterInfoSupport.hasDefaultValue()


Occurences of hasFocus

hasFocus occurences:
java.awt.Component.hasFocus()
javax.swing.plaf.basic.hasFocus
javax.swing.tree.hasFocus


Occurences of HashAttributeSet (constructors)

HashAttributeSet (constructors) occurences:
javax.print.attribute.HashAttributeSet()
javax.print.attribute.HashAttributeSet(java.lang.Class)
javax.print.attribute.HashAttributeSet(javax.print.attribute.Attribute)
javax.print.attribute.HashAttributeSet(javax.print.attribute.Attribute, java.lang.Class)
javax.print.attribute.HashAttributeSet(javax.print.attribute.AttributeSet)
javax.print.attribute.HashAttributeSet(javax.print.attribute.AttributeSet, java.lang.Class)
javax.print.attribute.HashAttributeSet(javax.print.attribute.Attribute[])
javax.print.attribute.HashAttributeSet(javax.print.attribute.Attribute[], java.lang.Class)


Occurences of hashCode

hashCode occurences:
com.sun.jdi.BooleanValue.hashCode()
com.sun.jdi.ByteValue.hashCode()
com.sun.jdi.CharValue.hashCode()
com.sun.jdi.DoubleValue.hashCode()
com.sun.jdi.Field.hashCode()
com.sun.jdi.FloatValue.hashCode()
com.sun.jdi.IntegerValue.hashCode()
com.sun.jdi.LocalVariable.hashCode()
com.sun.jdi.Location.hashCode()
com.sun.jdi.LongValue.hashCode()
com.sun.jdi.Method.hashCode()
com.sun.jdi.ObjectReference.hashCode()
com.sun.jdi.ReferenceType.hashCode()
com.sun.jdi.ShortValue.hashCode()
com.sun.jdi.VoidValue.hashCode()
com.sun.tools.attach.VirtualMachine.hashCode()
com.sun.tools.attach.VirtualMachineDescriptor.hashCode()
java.awt.AlphaComposite.hashCode()
java.awt.AWTKeyStroke.hashCode()
java.awt.BasicStroke.hashCode()
java.awt.BufferCapabilities.FlipContents.hashCode()
java.awt.Color.hashCode()
java.awt.datatransfer.DataFlavor.hashCode()
java.awt.Dimension.hashCode()
java.awt.DisplayMode.hashCode()
java.awt.Font.hashCode()
java.awt.font.FontRenderContext.hashCode()
java.awt.font.ImageGraphicAttribute.hashCode()
java.awt.font.NumericShaper.hashCode()
java.awt.font.ShapeGraphicAttribute.hashCode()
java.awt.font.TextHitInfo.hashCode()
java.awt.font.TextLayout.hashCode()
java.awt.font.TransformAttribute.hashCode()
java.awt.geom.AffineTransform.hashCode()
java.awt.geom.Arc2D.hashCode()
java.awt.geom.Ellipse2D.hashCode()
java.awt.geom.Point2D.hashCode()
java.awt.geom.Rectangle2D.hashCode()
java.awt.geom.RoundRectangle2D.hashCode()
java.awt.image.BandedSampleModel.hashCode()
java.awt.image.ColorModel.hashCode()
java.awt.image.ComponentSampleModel.hashCode()
java.awt.image.MultiPixelPackedSampleModel.hashCode()
java.awt.image.PixelInterleavedSampleModel.hashCode()
java.awt.image.SinglePixelPackedSampleModel.hashCode()
java.awt.Insets.hashCode()
java.awt.JobAttributes.hashCode()
java.awt.JobAttributes.DefaultSelectionType.hashCode()
java.awt.JobAttributes.DestinationType.hashCode()
java.awt.JobAttributes.DialogType.hashCode()
java.awt.JobAttributes.MultipleDocumentHandlingType.hashCode()
java.awt.JobAttributes.SidesType.hashCode()
java.awt.MenuShortcut.hashCode()
java.awt.PageAttributes.hashCode()
java.awt.PageAttributes.ColorType.hashCode()
java.awt.PageAttributes.MediaType.hashCode()
java.awt.PageAttributes.OrientationRequestedType.hashCode()
java.awt.PageAttributes.OriginType.hashCode()
java.awt.PageAttributes.PrintQualityType.hashCode()
java.awt.RenderingHints.hashCode()
java.awt.RenderingHints.Key.hashCode()
java.beans.IndexedPropertyDescriptor.hashCode()
java.beans.PropertyDescriptor.hashCode()
java.io.File.hashCode()
java.io.FilePermission.hashCode()
java.lang.annotation.Annotation.hashCode()
java.lang.Boolean.hashCode()
java.lang.Byte.hashCode()
java.lang.Character.hashCode()
java.lang.Character.Subset.hashCode()
java.lang.Double.hashCode()
java.lang.Enum.hashCode()
java.lang.Float.hashCode()
java.lang.Integer.hashCode()
java.lang.Long.hashCode()
java.lang.Object.hashCode()
java.lang.Package.hashCode()
java.lang.reflect.Constructor.hashCode()
java.lang.reflect.Field.hashCode()
java.lang.reflect.Method.hashCode()
java.lang.Short.hashCode()
java.lang.StackTraceElement.hashCode()
java.lang.String.hashCode()
java.math.BigDecimal.hashCode()
java.math.BigInteger.hashCode()
java.math.MathContext.hashCode()
java.net.HttpCookie.hashCode()
java.net.Inet4Address.hashCode()
java.net.Inet6Address.hashCode()
java.net.InetAddress.hashCode()
java.net.InetSocketAddress.hashCode()
java.net.InterfaceAddress.hashCode()
java.net.NetworkInterface.hashCode()
java.net.Proxy.hashCode()
java.net.SocketPermission.hashCode()
java.net.URI.hashCode()
java.net.URL.hashCode()
java.net.URLStreamHandler.hashCode(java.net.URL)
java.nio.ByteBuffer.hashCode()
java.nio.CharBuffer.hashCode()
java.nio.charset.Charset.hashCode()
java.nio.DoubleBuffer.hashCode()
java.nio.FloatBuffer.hashCode()
java.nio.IntBuffer.hashCode()
java.nio.LongBuffer.hashCode()
java.nio.ShortBuffer.hashCode()
java.rmi.activation.ActivationDesc.hashCode()
java.rmi.activation.ActivationGroupDesc.hashCode()
java.rmi.activation.ActivationGroupDesc.CommandEnvironment.hashCode()
java.rmi.activation.ActivationGroupID.hashCode()
java.rmi.activation.ActivationID.hashCode()
java.rmi.dgc.VMID.hashCode()
java.rmi.MarshalledObject.hashCode()
java.rmi.server.ObjID.hashCode()
java.rmi.server.RemoteObject.hashCode()
java.rmi.server.UID.hashCode()
java.security.AccessControlContext.hashCode()
java.security.AllPermission.hashCode()
java.security.BasicPermission.hashCode()
java.security.cert.Certificate.hashCode()
java.security.cert.CertPath.hashCode()
java.security.cert.X509CRL.hashCode()
java.security.cert.X509CRLEntry.hashCode()
java.security.CodeSigner.hashCode()
java.security.CodeSource.hashCode()
java.security.Identity.hashCode()
java.security.Permission.hashCode()
java.security.Principal.hashCode()
java.security.spec.ECFieldF2m.hashCode()
java.security.spec.ECFieldFp.hashCode()
java.security.spec.ECPoint.hashCode()
java.security.spec.EllipticCurve.hashCode()
java.security.Timestamp.hashCode()
java.security.UnresolvedPermission.hashCode()
java.sql.RowId.hashCode()
java.text.AttributedCharacterIterator.Attribute.hashCode()
java.text.ChoiceFormat.hashCode()
java.text.Collator.hashCode()
java.text.DateFormat.hashCode()
java.text.DateFormatSymbols.hashCode()
java.text.DecimalFormat.hashCode()
java.text.DecimalFormatSymbols.hashCode()
java.text.FieldPosition.hashCode()
java.text.MessageFormat.hashCode()
java.text.NumberFormat.hashCode()
java.text.ParsePosition.hashCode()
java.text.RuleBasedCollator.hashCode()
java.text.SimpleDateFormat.hashCode()
java.text.StringCharacterIterator.hashCode()
java.util.AbstractList.hashCode()
java.util.AbstractMap.hashCode()
java.util.AbstractMap.SimpleEntry.hashCode()
java.util.AbstractMap.SimpleImmutableEntry.hashCode()
java.util.AbstractSet.hashCode()
java.util.Arrays.hashCode(boolean[])
java.util.Arrays.hashCode(byte[])
java.util.Arrays.hashCode(char[])
java.util.Arrays.hashCode(double[])
java.util.Arrays.hashCode(float[])
java.util.Arrays.hashCode(int[])
java.util.Arrays.hashCode(java.lang.Object[])
java.util.Arrays.hashCode(long[])
java.util.Arrays.hashCode(short[])
java.util.BitSet.hashCode()
java.util.Calendar.hashCode()
java.util.Collection.hashCode()
java.util.concurrent.CopyOnWriteArrayList.hashCode()
java.util.Date.hashCode()
java.util.GregorianCalendar.hashCode()
java.util.Hashtable.hashCode()
java.util.IdentityHashMap.hashCode()
java.util.jar.Attributes.hashCode()
java.util.jar.Attributes.Name.hashCode()
java.util.jar.Manifest.hashCode()
java.util.List.hashCode()
java.util.Locale.hashCode()
java.util.logging.Level.hashCode()
java.util.Map.hashCode()
java.util.Map.Entry.hashCode()
java.util.PropertyPermission.hashCode()
java.util.Set.hashCode()
java.util.SimpleTimeZone.hashCode()
java.util.UUID.hashCode()
java.util.Vector.hashCode()
java.util.zip.ZipEntry.hashCode()
javax.crypto.spec.RC2ParameterSpec.hashCode()
javax.crypto.spec.RC5ParameterSpec.hashCode()
javax.crypto.spec.SecretKeySpec.hashCode()
javax.imageio.ImageTypeSpecifier.hashCode()
javax.lang.model.element.Element.hashCode()
javax.lang.model.element.Name.hashCode()
javax.lang.model.type.TypeMirror.hashCode()
javax.management.Attribute.hashCode()
javax.management.Descriptor.hashCode()
javax.management.ImmutableDescriptor.hashCode()
javax.management.MBeanAttributeInfo.hashCode()
javax.management.MBeanConstructorInfo.hashCode()
javax.management.MBeanFeatureInfo.hashCode()
javax.management.MBeanInfo.hashCode()
javax.management.MBeanNotificationInfo.hashCode()
javax.management.MBeanOperationInfo.hashCode()
javax.management.MBeanParameterInfo.hashCode()
javax.management.MBeanPermission.hashCode()
javax.management.MBeanServerPermission.hashCode()
javax.management.modelmbean.DescriptorSupport.hashCode()
javax.management.ObjectInstance.hashCode()
javax.management.ObjectName.hashCode()
javax.management.openmbean.ArrayType.hashCode()
javax.management.openmbean.CompositeData.hashCode()
javax.management.openmbean.CompositeDataSupport.hashCode()
javax.management.openmbean.CompositeType.hashCode()
javax.management.openmbean.OpenMBeanAttributeInfo.hashCode()
javax.management.openmbean.OpenMBeanAttributeInfoSupport.hashCode()
javax.management.openmbean.OpenMBeanConstructorInfo.hashCode()
javax.management.openmbean.OpenMBeanConstructorInfoSupport.hashCode()
javax.management.openmbean.OpenMBeanInfo.hashCode()
javax.management.openmbean.OpenMBeanInfoSupport.hashCode()
javax.management.openmbean.OpenMBeanOperationInfo.hashCode()
javax.management.openmbean.OpenMBeanOperationInfoSupport.hashCode()
javax.management.openmbean.OpenMBeanParameterInfo.hashCode()
javax.management.openmbean.OpenMBeanParameterInfoSupport.hashCode()
javax.management.openmbean.OpenType.hashCode()
javax.management.openmbean.SimpleType.hashCode()
javax.management.openmbean.TabularData.hashCode()
javax.management.openmbean.TabularDataSupport.hashCode()
javax.management.openmbean.TabularType.hashCode()
javax.management.remote.JMXPrincipal.hashCode()
javax.management.remote.JMXServiceURL.hashCode()
javax.naming.BinaryRefAddr.hashCode()
javax.naming.CompositeName.hashCode()
javax.naming.CompoundName.hashCode()
javax.naming.directory.BasicAttribute.hashCode()
javax.naming.directory.BasicAttributes.hashCode()
javax.naming.ldap.LdapName.hashCode()
javax.naming.ldap.Rdn.hashCode()
javax.naming.RefAddr.hashCode()
javax.naming.Reference.hashCode()
javax.print.attribute.AttributeSet.hashCode()
javax.print.attribute.DateTimeSyntax.hashCode()
javax.print.attribute.EnumSyntax.hashCode()
javax.print.attribute.HashAttributeSet.hashCode()
javax.print.attribute.IntegerSyntax.hashCode()
javax.print.attribute.ResolutionSyntax.hashCode()
javax.print.attribute.SetOfIntegerSyntax.hashCode()
javax.print.attribute.Size2DSyntax.hashCode()
javax.print.attribute.standard.MediaPrintableArea.hashCode()
javax.print.attribute.TextSyntax.hashCode()
javax.print.attribute.URISyntax.hashCode()
javax.print.DocFlavor.hashCode()
javax.print.PrintService.hashCode()
javax.rmi.CORBA.Stub.hashCode()
javax.rmi.CORBA.StubDelegate.hashCode(javax.rmi.CORBA.Stub)
javax.rmi.ssl.SslRMIClientSocketFactory.hashCode()
javax.rmi.ssl.SslRMIServerSocketFactory.hashCode()
javax.security.auth.kerberos.DelegationPermission.hashCode()
javax.security.auth.kerberos.KerberosKey.hashCode()
javax.security.auth.kerberos.KerberosPrincipal.hashCode()
javax.security.auth.kerberos.KerberosTicket.hashCode()
javax.security.auth.kerberos.ServicePermission.hashCode()
javax.security.auth.PrivateCredentialPermission.hashCode()
javax.security.auth.Subject.hashCode()
javax.security.auth.x500.X500Principal.hashCode()
javax.security.cert.Certificate.hashCode()
javax.sound.midi.MidiDevice.Info.hashCode()
javax.sound.midi.Sequencer.SyncMode.hashCode()
javax.sound.sampled.AudioFileFormat.Type.hashCode()
javax.sound.sampled.AudioFormat.Encoding.hashCode()
javax.sound.sampled.Control.Type.hashCode()
javax.sound.sampled.LineEvent.Type.hashCode()
javax.sound.sampled.Mixer.Info.hashCode()
javax.sound.sampled.Port.Info.hashCode()
javax.sound.sampled.ReverbType.hashCode()
javax.swing.RowSorter.SortKey.hashCode()
javax.swing.text.html.HTML.UnknownTag.hashCode()
javax.swing.text.SimpleAttributeSet.hashCode()
javax.swing.text.StyleContext.SmallAttributeSet.hashCode()
javax.swing.text.TabSet.hashCode()
javax.swing.text.TabStop.hashCode()
javax.swing.tree.TreePath.hashCode()
javax.xml.datatype.Duration.hashCode()
javax.xml.datatype.XMLGregorianCalendar.hashCode()
javax.xml.namespace.QName.hashCode()
org.ietf.jgss.ChannelBinding.hashCode()
org.ietf.jgss.GSSCredential.hashCode()
org.ietf.jgss.GSSName.hashCode()
org.ietf.jgss.Oid.hashCode()
org.omg.CORBA.portable.Delegate.hashCode(org.omg.CORBA.Object)
org.omg.CORBA.portable.ObjectImpl.hashCode()


Occurences of HashDocAttributeSet (constructors)

HashDocAttributeSet (constructors) occurences:
javax.print.attribute.HashDocAttributeSet()
javax.print.attribute.HashDocAttributeSet(javax.print.attribute.DocAttribute)
javax.print.attribute.HashDocAttributeSet(javax.print.attribute.DocAttributeSet)
javax.print.attribute.HashDocAttributeSet(javax.print.attribute.DocAttribute[])


Occurences of HashMap (constructors)

HashMap (constructors) occurences:
java.util.HashMap()
java.util.HashMap(int)
java.util.HashMap(int, float)
java.util.HashMap(java.util.Map)


Occurences of HashPrintJobAttributeSet (constructors)

HashPrintJobAttributeSet (constructors) occurences:
javax.print.attribute.HashPrintJobAttributeSet()
javax.print.attribute.HashPrintJobAttributeSet(javax.print.attribute.PrintJobAttribute)
javax.print.attribute.HashPrintJobAttributeSet(javax.print.attribute.PrintJobAttributeSet)
javax.print.attribute.HashPrintJobAttributeSet(javax.print.attribute.PrintJobAttribute[])


Occurences of HashPrintRequestAttributeSet (constructors)

HashPrintRequestAttributeSet (constructors) occurences:
javax.print.attribute.HashPrintRequestAttributeSet()
javax.print.attribute.HashPrintRequestAttributeSet(javax.print.attribute.PrintRequestAttribute)
javax.print.attribute.HashPrintRequestAttributeSet(javax.print.attribute.PrintRequestAttributeSet)
javax.print.attribute.HashPrintRequestAttributeSet(javax.print.attribute.PrintRequestAttribute[])


Occurences of HashPrintServiceAttributeSet (constructors)

HashPrintServiceAttributeSet (constructors) occurences:
javax.print.attribute.HashPrintServiceAttributeSet()
javax.print.attribute.HashPrintServiceAttributeSet(javax.print.attribute.PrintServiceAttribute)
javax.print.attribute.HashPrintServiceAttributeSet(javax.print.attribute.PrintServiceAttributeSet)
javax.print.attribute.HashPrintServiceAttributeSet(javax.print.attribute.PrintServiceAttribute[])


Occurences of HashSet (constructors)

HashSet (constructors) occurences:
java.util.HashSet()
java.util.HashSet(int)
java.util.HashSet(int, float)
java.util.HashSet(java.util.Collection)


Occurences of Hashtable (constructors)

Hashtable (constructors) occurences:
java.util.Hashtable()
java.util.Hashtable(int)
java.util.Hashtable(int, float)
java.util.Hashtable(java.util.Map)


Occurences of hasLegalValues

hasLegalValues occurences:
javax.management.openmbean.OpenMBeanAttributeInfoSupport.hasLegalValues()
javax.management.openmbean.OpenMBeanParameterInfo.hasLegalValues()
javax.management.openmbean.OpenMBeanParameterInfoSupport.hasLegalValues()


Occurences of hasListeners

hasListeners occurences:
java.beans.PropertyChangeSupport.hasListeners(java.lang.String)
java.beans.VetoableChangeSupport.hasListeners(java.lang.String)


Occurences of hasLocation

hasLocation occurences:
javax.tools.ForwardingJavaFileManager.hasLocation(javax.tools.JavaFileManager.Location)
javax.tools.JavaFileManager.hasLocation(javax.tools.JavaFileManager.Location)


Occurences of hasMaxValue

hasMaxValue occurences:
javax.management.openmbean.OpenMBeanAttributeInfoSupport.hasMaxValue()
javax.management.openmbean.OpenMBeanParameterInfo.hasMaxValue()
javax.management.openmbean.OpenMBeanParameterInfoSupport.hasMaxValue()


Occurences of hasMinValue

hasMinValue occurences:
javax.management.openmbean.OpenMBeanAttributeInfoSupport.hasMinValue()
javax.management.openmbean.OpenMBeanParameterInfo.hasMinValue()
javax.management.openmbean.OpenMBeanParameterInfoSupport.hasMinValue()


Occurences of hasMoreElements

hasMoreElements occurences:
java.util.Enumeration.hasMoreElements()
java.util.StringTokenizer.hasMoreElements()


Occurences of hasName

hasName occurences:
javax.xml.stream.util.StreamReaderDelegate.hasName()
javax.xml.stream.XMLStreamReader.hasName()


Occurences of hasNext

hasNext occurences:
java.beans.beancontext.BeanContextSupport.BCSIterator.hasNext()
java.util.Iterator.hasNext()
java.util.ListIterator.hasNext()
java.util.Scanner.hasNext()
java.util.Scanner.hasNext(java.lang.String)
java.util.Scanner.hasNext(java.util.regex.Pattern)
javax.xml.stream.util.EventReaderDelegate.hasNext()
javax.xml.stream.util.StreamReaderDelegate.hasNext()
javax.xml.stream.XMLEventReader.hasNext()
javax.xml.stream.XMLStreamReader.hasNext()


Occurences of hasNextBigInteger

hasNextBigInteger occurences:
java.util.Scanner.hasNextBigInteger()
java.util.Scanner.hasNextBigInteger(int)


Occurences of hasNextByte

hasNextByte occurences:
java.util.Scanner.hasNextByte()
java.util.Scanner.hasNextByte(int)


Occurences of hasNextInt

hasNextInt occurences:
java.util.Scanner.hasNextInt()
java.util.Scanner.hasNextInt(int)


Occurences of hasNextLong

hasNextLong occurences:
java.util.Scanner.hasNextLong()
java.util.Scanner.hasNextLong(int)


Occurences of hasNextShort

hasNextShort occurences:
java.util.Scanner.hasNextShort()
java.util.Scanner.hasNextShort(int)


Occurences of hasQueuedThread

hasQueuedThread occurences:
java.util.concurrent.locks.ReentrantLock.hasQueuedThread(java.lang.Thread)
java.util.concurrent.locks.ReentrantReadWriteLock.hasQueuedThread(java.lang.Thread)


Occurences of hasQueuedThreads

hasQueuedThreads occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.hasQueuedThreads()
java.util.concurrent.locks.AbstractQueuedSynchronizer.hasQueuedThreads()
java.util.concurrent.locks.ReentrantLock.hasQueuedThreads()
java.util.concurrent.locks.ReentrantReadWriteLock.hasQueuedThreads()
java.util.concurrent.Semaphore.hasQueuedThreads()


Occurences of hasRelation

hasRelation occurences:
javax.management.relation.RelationService.hasRelation(java.lang.String)
javax.management.relation.RelationServiceMBean.hasRelation(java.lang.String)


Occurences of hasSameRules

hasSameRules occurences:
java.util.SimpleTimeZone.hasSameRules(java.util.TimeZone)
java.util.TimeZone.hasSameRules(java.util.TimeZone)


Occurences of hasService

hasService occurences:
java.beans.beancontext.BeanContextServices.hasService(java.lang.Class)
java.beans.beancontext.BeanContextServicesSupport.hasService(java.lang.Class)


Occurences of hasText

hasText occurences:
javax.xml.stream.util.StreamReaderDelegate.hasText()
javax.xml.stream.XMLStreamReader.hasText()


Occurences of hasTileWriters

hasTileWriters occurences:
java.awt.image.BufferedImage.hasTileWriters()
java.awt.image.WritableRenderedImage.hasTileWriters()


Occurences of hasUniformLineMetrics

hasUniformLineMetrics occurences:
java.awt.Font.hasUniformLineMetrics()
java.awt.FontMetrics.hasUniformLineMetrics()


Occurences of hasWaiters

hasWaiters occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.hasWaiters(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject)
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.hasWaiters()
java.util.concurrent.locks.AbstractQueuedSynchronizer.hasWaiters(java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject)
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.hasWaiters()
java.util.concurrent.locks.ReentrantLock.hasWaiters(java.util.concurrent.locks.Condition)
java.util.concurrent.locks.ReentrantReadWriteLock.hasWaiters(java.util.concurrent.locks.Condition)


Occurences of has_no_active_member

has_no_active_member occurences:
org.omg.DynamicAny.DynUnionOperations.has_no_active_member()
org.omg.DynamicAny._DynUnionStub.has_no_active_member()


Occurences of header

header occurences:
javax.jws.WebParam.header()
javax.jws.WebResult.header()
javax.swing.plaf.basic.header


Occurences of HeadlessException (constructors)

HeadlessException (constructors) occurences:
java.awt.HeadlessException()
java.awt.HeadlessException(java.lang.String)


Occurences of headMap

headMap occurences:
java.util.concurrent.ConcurrentNavigableMap.headMap(java.lang.Object)
java.util.concurrent.ConcurrentNavigableMap.headMap(java.lang.Object,boolean)
java.util.concurrent.ConcurrentNavigableMap.headMap(K)
java.util.concurrent.ConcurrentNavigableMap.headMap(K, boolean)
java.util.concurrent.ConcurrentSkipListMap.headMap(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.headMap(java.lang.Object,boolean)
java.util.concurrent.ConcurrentSkipListMap.headMap(K)
java.util.concurrent.ConcurrentSkipListMap.headMap(K, boolean)
java.util.NavigableMap.headMap(java.lang.Object)
java.util.NavigableMap.headMap(java.lang.Object,boolean)
java.util.NavigableMap.headMap(K)
java.util.NavigableMap.headMap(K, boolean)
java.util.SortedMap.headMap(java.lang.Object)
java.util.SortedMap.headMap(K)
java.util.TreeMap.headMap(java.lang.Object)
java.util.TreeMap.headMap(java.lang.Object,boolean)
java.util.TreeMap.headMap(K)
java.util.TreeMap.headMap(K, boolean)


Occurences of headSet

headSet occurences:
java.util.concurrent.ConcurrentSkipListSet.headSet(E)
java.util.concurrent.ConcurrentSkipListSet.headSet(E, boolean)
java.util.concurrent.ConcurrentSkipListSet.headSet(java.lang.Object)
java.util.concurrent.ConcurrentSkipListSet.headSet(java.lang.Object,boolean)
java.util.NavigableSet.headSet(E)
java.util.NavigableSet.headSet(E, boolean)
java.util.NavigableSet.headSet(java.lang.Object)
java.util.NavigableSet.headSet(java.lang.Object,boolean)
java.util.SortedSet.headSet(E)
java.util.SortedSet.headSet(java.lang.Object)
java.util.TreeSet.headSet(E)
java.util.TreeSet.headSet(E, boolean)
java.util.TreeSet.headSet(java.lang.Object)
java.util.TreeSet.headSet(java.lang.Object,boolean)


Occurences of HEIGHT

HEIGHT occurences:
java.awt.image.HEIGHT
javax.swing.HEIGHT
javax.swing.text.html.HEIGHT
javax.swing.text.html.HEIGHT


Occurences of height

height occurences:
java.awt.geom.height
java.awt.geom.height
java.awt.geom.height
java.awt.geom.height
java.awt.geom.height
java.awt.geom.height
java.awt.geom.height
java.awt.geom.height
java.awt.height
java.awt.height
java.awt.height
java.awt.image.height
java.awt.image.height
javax.swing.Spring.height(java.awt.Component)


Occurences of helpers

helpers occurences:
javax.xml.bind.helpers
org.xml.sax.helpers


Occurences of hide

hide occurences:
java.awt.Component.hide()
java.awt.Dialog.hide()
java.awt.Window.hide()
javax.swing.JInternalFrame.hide()
javax.swing.plaf.basic.BasicComboPopup.hide()
javax.swing.plaf.basic.ComboPopup.hide()
javax.swing.Popup.hide()


Occurences of hides

hides occurences:
com.sun.mirror.util.Declarations.hides(com.sun.mirror.declaration.MemberDeclaration, com.sun.mirror.declaration.MemberDeclaration)
javax.lang.model.util.Elements.hides(javax.lang.model.element.Element, javax.lang.model.element.Element)


Occurences of Hierarchy

Hierarchy occurences:
Class Hierarchy
Class Hierarchy
Class Hierarchy
Class Hierarchy
Class Hierarchy
Class Hierarchy
Class Hierarchy
Class Hierarchy


Occurences of hierarchyChanged

hierarchyChanged occurences:
java.awt.AWTEventMulticaster.hierarchyChanged(java.awt.event.HierarchyEvent)
java.awt.event.HierarchyListener.hierarchyChanged(java.awt.event.HierarchyEvent)


Occurences of HierarchyEvent (constructors)

HierarchyEvent (constructors) occurences:
java.awt.event.HierarchyEvent(java.awt.Component, int, java.awt.Component, java.awt.Container)
java.awt.event.HierarchyEvent(java.awt.Component, int, java.awt.Component, java.awt.Container, long)


Occurences of HIGH

HIGH occurences:
java.awt.HIGH
javax.print.attribute.standard.HIGH


Occurences of higher

higher occurences:
java.util.concurrent.ConcurrentSkipListSet.higher(E)
java.util.concurrent.ConcurrentSkipListSet.higher(java.lang.Object)
java.util.NavigableSet.higher(E)
java.util.NavigableSet.higher(java.lang.Object)
java.util.TreeSet.higher(E)
java.util.TreeSet.higher(java.lang.Object)


Occurences of higherEntry

higherEntry occurences:
java.util.concurrent.ConcurrentSkipListMap.higherEntry(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.higherEntry(K)
java.util.NavigableMap.higherEntry(java.lang.Object)
java.util.NavigableMap.higherEntry(K)
java.util.TreeMap.higherEntry(java.lang.Object)
java.util.TreeMap.higherEntry(K)


Occurences of higherKey

higherKey occurences:
java.util.concurrent.ConcurrentSkipListMap.higherKey(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.higherKey(K)
java.util.NavigableMap.higherKey(java.lang.Object)
java.util.NavigableMap.higherKey(K)
java.util.TreeMap.higherKey(java.lang.Object)
java.util.TreeMap.higherKey(K)


Occurences of highestOneBit

highestOneBit occurences:
java.lang.Integer.highestOneBit(int)
java.lang.Long.highestOneBit(long)


Occurences of highlight

highlight occurences:
javax.swing.border.highlight
javax.swing.plaf.basic.highlight
javax.swing.plaf.basic.highlight
javax.swing.plaf.basic.highlight
javax.swing.plaf.basic.highlight
javax.swing.plaf.basic.highlight


Occurences of hitTestChar

hitTestChar occurences:
java.awt.font.TextLayout.hitTestChar(float, float)
java.awt.font.TextLayout.hitTestChar(float, float, java.awt.geom.Rectangle2D)


Occurences of Holder (constructors)

Holder (constructors) occurences:
javax.xml.ws.Holder()
javax.xml.ws.Holder(java.lang.Object)
javax.xml.ws.Holder(T)


Occurences of HOLDING

HOLDING occurences:
org.omg.PortableInterceptor.HOLDING
org.omg.PortableServer.POAManagerPackage.HOLDING


Occurences of HORIZONTAL

HORIZONTAL occurences:
java.awt.HORIZONTAL
java.awt.HORIZONTAL
java.awt.HORIZONTAL
javax.accessibility.HORIZONTAL
javax.swing.HORIZONTAL


Occurences of HOURS

HOURS occurences:
java.util.concurrent.HOURS
javax.xml.datatype.HOURS


Occurences of HTML

HTML occurences:
javax.swing.text.html.HTML
javax.swing.text.html.HTML
javax.tools.HTML


Occurences of html

html occurences:
javax.swing.text.html
javax.swing.text.html.html
javax.swing.text.html.parser.html


Occurences of HTML.Tag (constructors)

HTML.Tag (constructors) occurences:
javax.swing.text.html.HTML.Tag()
javax.swing.text.html.HTML.Tag(java.lang.String)
javax.swing.text.html.HTML.Tag(java.lang.String, boolean, boolean)


Occurences of HTMLDocument (constructors)

HTMLDocument (constructors) occurences:
javax.swing.text.html.HTMLDocument()
javax.swing.text.html.HTMLDocument(javax.swing.text.AbstractDocument.Content, javax.swing.text.html.StyleSheet)
javax.swing.text.html.HTMLDocument(javax.swing.text.html.StyleSheet)


Occurences of HTMLDocument.HTMLReader (constructors)

HTMLDocument.HTMLReader (constructors) occurences:
javax.swing.text.html.HTMLDocument.HTMLReader(int)
javax.swing.text.html.HTMLDocument.HTMLReader(int, int, int, javax.swing.text.html.HTML.Tag)


Occurences of HTMLEditorKit.InsertHTMLTextAction (constructors)

HTMLEditorKit.InsertHTMLTextAction (constructors) occurences:
javax.swing.text.html.HTMLEditorKit.InsertHTMLTextAction(java.lang.String, java.lang.String, javax.swing.text.html.HTML.Tag, javax.swing.text.html.HTML.Tag)
javax.swing.text.html.HTMLEditorKit.InsertHTMLTextAction(java.lang.String, java.lang.String, javax.swing.text.html.HTML.Tag, javax.swing.text.html.HTML.Tag, javax.swing.text.html.HTML.Tag, javax.swing.text.html.HTML.Tag)


Occurences of HTMLFrameHyperlinkEvent (constructors)

HTMLFrameHyperlinkEvent (constructors) occurences:
javax.swing.text.html.HTMLFrameHyperlinkEvent(java.lang.Object, javax.swing.event.HyperlinkEvent.EventType, java.net.URL, java.lang.String)
javax.swing.text.html.HTMLFrameHyperlinkEvent(java.lang.Object, javax.swing.event.HyperlinkEvent.EventType, java.net.URL, java.lang.String, java.lang.String)
javax.swing.text.html.HTMLFrameHyperlinkEvent(java.lang.Object, javax.swing.event.HyperlinkEvent.EventType, java.net.URL, java.lang.String, javax.swing.text.Element, java.lang.String)
javax.swing.text.html.HTMLFrameHyperlinkEvent(java.lang.Object, javax.swing.event.HyperlinkEvent.EventType, java.net.URL, javax.swing.text.Element, java.lang.String)


Occurences of HTMLWriter (constructors)

HTMLWriter (constructors) occurences:
javax.swing.text.html.HTMLWriter(java.io.Writer, javax.swing.text.html.HTMLDocument)
javax.swing.text.html.HTMLWriter(java.io.Writer, javax.swing.text.html.HTMLDocument, int, int)


Occurences of HTTP

HTTP occurences:
java.net.HTTP
javax.print.attribute.standard.HTTP


Occurences of HttpRetryException (constructors)

HttpRetryException (constructors) occurences:
java.net.HttpRetryException(java.lang.String, int)
java.net.HttpRetryException(java.lang.String, int, java.lang.String)


Occurences of HyperlinkEvent (constructors)

HyperlinkEvent (constructors) occurences:
javax.swing.event.HyperlinkEvent(java.lang.Object, javax.swing.event.HyperlinkEvent.EventType, java.net.URL)
javax.swing.event.HyperlinkEvent(java.lang.Object, javax.swing.event.HyperlinkEvent.EventType, java.net.URL, java.lang.String)
javax.swing.event.HyperlinkEvent(java.lang.Object, javax.swing.event.HyperlinkEvent.EventType, java.net.URL, java.lang.String, javax.swing.text.Element)


Occurences of hypot

hypot occurences:
java.lang.Math.hypot(double, double)
java.lang.StrictMath.hypot(double, double)


Occurences of icon

icon occurences:
javax.swing.icon
javax.swing.plaf.basic.icon


Occurences of ICONIFIED

ICONIFIED occurences:
java.awt.ICONIFIED
javax.accessibility.ICONIFIED


Occurences of iconifyFrame

iconifyFrame occurences:
javax.swing.DefaultDesktopManager.iconifyFrame(javax.swing.JInternalFrame)
javax.swing.DesktopManager.iconifyFrame(javax.swing.JInternalFrame)
javax.swing.plaf.basic.BasicInternalFrameUI.iconifyFrame(javax.swing.JInternalFrame)


Occurences of ID

ID occurences:
javax.swing.text.html.ID
javax.swing.text.html.parser.ID


Occurences of id

id occurences:
com.sun.tools.attach.VirtualMachine.id()
com.sun.tools.attach.VirtualMachineDescriptor.id()
java.awt.id
java.awt.id
javax.naming.ldap.id
org.omg.CORBA.AnySeqHelper.id()
org.omg.CORBA.BooleanSeqHelper.id()
org.omg.CORBA.CharSeqHelper.id()
org.omg.CORBA.CompletionStatusHelper.id()
org.omg.CORBA.CurrentHelper.id()
org.omg.CORBA.DefinitionKindHelper.id()
org.omg.CORBA.DoubleSeqHelper.id()
org.omg.CORBA.FieldNameHelper.id()
org.omg.CORBA.FloatSeqHelper.id()
org.omg.CORBA.id
org.omg.CORBA.id
org.omg.CORBA.IdentifierHelper.id()
org.omg.CORBA.IDLTypeHelper.id()
org.omg.CORBA.LongLongSeqHelper.id()
org.omg.CORBA.LongSeqHelper.id()
org.omg.CORBA.NameValuePairHelper.id()
org.omg.CORBA.ObjectHelper.id()
org.omg.CORBA.OctetSeqHelper.id()
org.omg.CORBA.ParameterModeHelper.id()
org.omg.CORBA.PolicyErrorCodeHelper.id()
org.omg.CORBA.PolicyErrorHelper.id()
org.omg.CORBA.PolicyHelper.id()
org.omg.CORBA.PolicyListHelper.id()
org.omg.CORBA.PolicyTypeHelper.id()
org.omg.CORBA.RepositoryIdHelper.id()
org.omg.CORBA.ServiceDetailHelper.id()
org.omg.CORBA.ServiceInformationHelper.id()
org.omg.CORBA.SetOverrideTypeHelper.id()
org.omg.CORBA.ShortSeqHelper.id()
org.omg.CORBA.StringSeqHelper.id()
org.omg.CORBA.StringValueHelper.id()
org.omg.CORBA.StructMemberHelper.id()
org.omg.CORBA.TypeCode.id()
org.omg.CORBA.ULongLongSeqHelper.id()
org.omg.CORBA.ULongSeqHelper.id()
org.omg.CORBA.UnionMemberHelper.id()
org.omg.CORBA.UnknownUserExceptionHelper.id()
org.omg.CORBA.UShortSeqHelper.id()
org.omg.CORBA.ValueBaseHelper.id()
org.omg.CORBA.ValueMemberHelper.id()
org.omg.CORBA.VersionSpecHelper.id()
org.omg.CORBA.VisibilityHelper.id()
org.omg.CORBA.WCharSeqHelper.id()
org.omg.CORBA.WrongTransactionHelper.id()
org.omg.CORBA.WStringSeqHelper.id()
org.omg.CORBA.WStringValueHelper.id()
org.omg.CosNaming.BindingHelper.id()
org.omg.CosNaming.BindingIteratorHelper.id()
org.omg.CosNaming.BindingListHelper.id()
org.omg.CosNaming.BindingTypeHelper.id()
org.omg.CosNaming.id
org.omg.CosNaming.IstringHelper.id()
org.omg.CosNaming.NameComponentHelper.id()
org.omg.CosNaming.NameHelper.id()
org.omg.CosNaming.NamingContextExtHelper.id()
org.omg.CosNaming.NamingContextExtPackage.AddressHelper.id()
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHelper.id()
org.omg.CosNaming.NamingContextExtPackage.StringNameHelper.id()
org.omg.CosNaming.NamingContextExtPackage.URLStringHelper.id()
org.omg.CosNaming.NamingContextHelper.id()
org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.id()
org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.id()
org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.id()
org.omg.CosNaming.NamingContextPackage.NotEmptyHelper.id()
org.omg.CosNaming.NamingContextPackage.NotFoundHelper.id()
org.omg.CosNaming.NamingContextPackage.NotFoundReasonHelper.id()
org.omg.DynamicAny.AnySeqHelper.id()
org.omg.DynamicAny.DynAnyFactoryHelper.id()
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCodeHelper.id()
org.omg.DynamicAny.DynAnyHelper.id()
org.omg.DynamicAny.DynAnyPackage.InvalidValueHelper.id()
org.omg.DynamicAny.DynAnyPackage.TypeMismatchHelper.id()
org.omg.DynamicAny.DynAnySeqHelper.id()
org.omg.DynamicAny.DynArrayHelper.id()
org.omg.DynamicAny.DynEnumHelper.id()
org.omg.DynamicAny.DynFixedHelper.id()
org.omg.DynamicAny.DynSequenceHelper.id()
org.omg.DynamicAny.DynStructHelper.id()
org.omg.DynamicAny.DynUnionHelper.id()
org.omg.DynamicAny.DynValueHelper.id()
org.omg.DynamicAny.FieldNameHelper.id()
org.omg.DynamicAny.id
org.omg.DynamicAny.id
org.omg.DynamicAny.NameDynAnyPairHelper.id()
org.omg.DynamicAny.NameDynAnyPairSeqHelper.id()
org.omg.DynamicAny.NameValuePairHelper.id()
org.omg.DynamicAny.NameValuePairSeqHelper.id()
org.omg.IOP.CodecFactoryHelper.id()
org.omg.IOP.CodecFactoryPackage.UnknownEncodingHelper.id()
org.omg.IOP.CodecPackage.FormatMismatchHelper.id()
org.omg.IOP.CodecPackage.InvalidTypeForEncodingHelper.id()
org.omg.IOP.CodecPackage.TypeMismatchHelper.id()
org.omg.IOP.ComponentIdHelper.id()
org.omg.IOP.IORHelper.id()
org.omg.IOP.MultipleComponentProfileHelper.id()
org.omg.IOP.ProfileIdHelper.id()
org.omg.IOP.ServiceContextHelper.id()
org.omg.IOP.ServiceContextListHelper.id()
org.omg.IOP.ServiceIdHelper.id()
org.omg.IOP.TaggedComponentHelper.id()
org.omg.IOP.TaggedProfileHelper.id()
org.omg.Messaging.SyncScopeHelper.id()
org.omg.PortableInterceptor.AdapterManagerIdHelper.id()
org.omg.PortableInterceptor.AdapterNameHelper.id()
org.omg.PortableInterceptor.AdapterStateHelper.id()
org.omg.PortableInterceptor.CurrentHelper.id()
org.omg.PortableInterceptor.ForwardRequestHelper.id()
org.omg.PortableInterceptor.InvalidSlotHelper.id()
org.omg.PortableInterceptor.IORInterceptor_3_0Helper.id()
org.omg.PortableInterceptor.ObjectIdHelper.id()
org.omg.PortableInterceptor.ObjectReferenceFactoryHelper.id()
org.omg.PortableInterceptor.ObjectReferenceTemplateHelper.id()
org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHelper.id()
org.omg.PortableInterceptor.ORBIdHelper.id()
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateNameHelper.id()
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidNameHelper.id()
org.omg.PortableInterceptor.ORBInitInfoPackage.ObjectIdHelper.id()
org.omg.PortableInterceptor.ServerIdHelper.id()
org.omg.PortableServer.CurrentHelper.id()
org.omg.PortableServer.CurrentPackage.NoContextHelper.id()
org.omg.PortableServer.ForwardRequestHelper.id()
org.omg.PortableServer.POAHelper.id()
org.omg.PortableServer.POAManagerPackage.AdapterInactiveHelper.id()
org.omg.PortableServer.POAOperations.id()
org.omg.PortableServer.POAPackage.AdapterAlreadyExistsHelper.id()
org.omg.PortableServer.POAPackage.AdapterNonExistentHelper.id()
org.omg.PortableServer.POAPackage.InvalidPolicyHelper.id()
org.omg.PortableServer.POAPackage.NoServantHelper.id()
org.omg.PortableServer.POAPackage.ObjectAlreadyActiveHelper.id()
org.omg.PortableServer.POAPackage.ObjectNotActiveHelper.id()
org.omg.PortableServer.POAPackage.ServantAlreadyActiveHelper.id()
org.omg.PortableServer.POAPackage.ServantNotActiveHelper.id()
org.omg.PortableServer.POAPackage.WrongAdapterHelper.id()
org.omg.PortableServer.POAPackage.WrongPolicyHelper.id()
org.omg.PortableServer.ServantActivatorHelper.id()
org.omg.PortableServer.ServantLocatorHelper.id()


Occurences of Identity (constructors)

Identity (constructors) occurences:
java.security.Identity()
java.security.Identity(java.lang.String)
java.security.Identity(java.lang.String, java.security.IdentityScope)


Occurences of IdentityHashMap (constructors)

IdentityHashMap (constructors) occurences:
java.util.IdentityHashMap()
java.util.IdentityHashMap(int)
java.util.IdentityHashMap(java.util.Map)


Occurences of IdentityScope (constructors)

IdentityScope (constructors) occurences:
java.security.IdentityScope()
java.security.IdentityScope(java.lang.String)
java.security.IdentityScope(java.lang.String, java.security.IdentityScope)


Occurences of IEEEremainder

IEEEremainder occurences:
java.lang.Math.IEEEremainder(double, double)
java.lang.StrictMath.IEEEremainder(double, double)


Occurences of ignorableWhitespace

ignorableWhitespace occurences:
org.xml.sax.ContentHandler.ignorableWhitespace(char[], int, int)
org.xml.sax.DocumentHandler.ignorableWhitespace(char[], int, int)
org.xml.sax.HandlerBase.ignorableWhitespace(char[], int, int)
org.xml.sax.helpers.DefaultHandler.ignorableWhitespace(char[], int, int)
org.xml.sax.helpers.ParserAdapter.ignorableWhitespace(char[], int, int)
org.xml.sax.helpers.XMLFilterImpl.ignorableWhitespace(char[], int, int)
org.xml.sax.helpers.XMLReaderAdapter.ignorableWhitespace(char[], int, int)


Occurences of IIOException (constructors)

IIOException (constructors) occurences:
javax.imageio.IIOException(java.lang.String)
javax.imageio.IIOException(java.lang.String, java.lang.Throwable)


Occurences of IIOImage (constructors)

IIOImage (constructors) occurences:
javax.imageio.IIOImage(java.awt.image.Raster, java.util.List, javax.imageio.metadata.IIOMetadata)
javax.imageio.IIOImage(java.awt.image.RenderedImage, java.util.List, javax.imageio.metadata.IIOMetadata)


Occurences of IIOInvalidTreeException (constructors)

IIOInvalidTreeException (constructors) occurences:
javax.imageio.metadata.IIOInvalidTreeException(java.lang.String, java.lang.Throwable, org.w3c.dom.Node)
javax.imageio.metadata.IIOInvalidTreeException(java.lang.String, org.w3c.dom.Node)


Occurences of IIOMetadata (constructors)

IIOMetadata (constructors) occurences:
javax.imageio.metadata.IIOMetadata()
javax.imageio.metadata.IIOMetadata(boolean, java.lang.String, java.lang.String, java.lang.String[], java.lang.String[])


Occurences of IIOMetadataFormatImpl (constructors)

IIOMetadataFormatImpl (constructors) occurences:
javax.imageio.metadata.IIOMetadataFormatImpl(java.lang.String, int)
javax.imageio.metadata.IIOMetadataFormatImpl(java.lang.String, int, int)


Occurences of IIOMetadataNode (constructors)

IIOMetadataNode (constructors) occurences:
javax.imageio.metadata.IIOMetadataNode()
javax.imageio.metadata.IIOMetadataNode(java.lang.String)


Occurences of IIOServiceProvider (constructors)

IIOServiceProvider (constructors) occurences:
javax.imageio.spi.IIOServiceProvider()
javax.imageio.spi.IIOServiceProvider(java.lang.String, java.lang.String)


Occurences of IllegalAccessError (constructors)

IllegalAccessError (constructors) occurences:
java.lang.IllegalAccessError()
java.lang.IllegalAccessError(java.lang.String)


Occurences of IllegalAccessException (constructors)

IllegalAccessException (constructors) occurences:
java.lang.IllegalAccessException()
java.lang.IllegalAccessException(java.lang.String)


Occurences of IllegalArgumentException (constructors)

IllegalArgumentException (constructors) occurences:
java.lang.IllegalArgumentException()
java.lang.IllegalArgumentException(java.lang.String)
java.lang.IllegalArgumentException(java.lang.String, java.lang.Throwable)
java.lang.IllegalArgumentException(java.lang.Throwable)


Occurences of IllegalBlockSizeException (constructors)

IllegalBlockSizeException (constructors) occurences:
javax.crypto.IllegalBlockSizeException()
javax.crypto.IllegalBlockSizeException(java.lang.String)


Occurences of IllegalClassFormatException (constructors)

IllegalClassFormatException (constructors) occurences:
java.lang.instrument.IllegalClassFormatException()
java.lang.instrument.IllegalClassFormatException(java.lang.String)


Occurences of IllegalComponentStateException (constructors)

IllegalComponentStateException (constructors) occurences:
java.awt.IllegalComponentStateException()
java.awt.IllegalComponentStateException(java.lang.String)


Occurences of IllegalConnectorArgumentsException (constructors)

IllegalConnectorArgumentsException (constructors) occurences:
com.sun.jdi.connect.IllegalConnectorArgumentsException(java.lang.String, java.lang.String)
com.sun.jdi.connect.IllegalConnectorArgumentsException(java.lang.String, java.util.List)


Occurences of IllegalMonitorStateException (constructors)

IllegalMonitorStateException (constructors) occurences:
java.lang.IllegalMonitorStateException()
java.lang.IllegalMonitorStateException(java.lang.String)


Occurences of IllegalPathStateException (constructors)

IllegalPathStateException (constructors) occurences:
java.awt.geom.IllegalPathStateException()
java.awt.geom.IllegalPathStateException(java.lang.String)


Occurences of IllegalStateException (constructors)

IllegalStateException (constructors) occurences:
java.lang.IllegalStateException()
java.lang.IllegalStateException(java.lang.String)
java.lang.IllegalStateException(java.lang.String, java.lang.Throwable)
java.lang.IllegalStateException(java.lang.Throwable)


Occurences of IllegalThreadStateException (constructors)

IllegalThreadStateException (constructors) occurences:
java.lang.IllegalThreadStateException()
java.lang.IllegalThreadStateException(java.lang.String)


Occurences of image

image occurences:
java.awt.image
javax.imageio.image


Occurences of imageComplete

imageComplete occurences:
java.awt.image.BufferedImageFilter.imageComplete(int)
java.awt.image.ImageConsumer.imageComplete(int)
java.awt.image.ImageFilter.imageComplete(int)
java.awt.image.PixelGrabber.imageComplete(int)
javax.imageio.event.IIOReadProgressListener.imageComplete(javax.imageio.ImageReader)
javax.imageio.event.IIOWriteProgressListener.imageComplete(javax.imageio.ImageWriter)


Occurences of ImageGraphicAttribute (constructors)

ImageGraphicAttribute (constructors) occurences:
java.awt.font.ImageGraphicAttribute(java.awt.Image, int)
java.awt.font.ImageGraphicAttribute(java.awt.Image, int, float, float)


Occurences of ImageIcon (constructors)

ImageIcon (constructors) occurences:
javax.swing.ImageIcon()
javax.swing.ImageIcon(byte[])
javax.swing.ImageIcon(byte[], java.lang.String)
javax.swing.ImageIcon(java.awt.Image)
javax.swing.ImageIcon(java.awt.Image, java.lang.String)
javax.swing.ImageIcon(java.lang.String)
javax.swing.ImageIcon(java.lang.String, java.lang.String)
javax.swing.ImageIcon(java.net.URL)
javax.swing.ImageIcon(java.net.URL, java.lang.String)


Occurences of ImageInputStreamSpi (constructors)

ImageInputStreamSpi (constructors) occurences:
javax.imageio.spi.ImageInputStreamSpi()
javax.imageio.spi.ImageInputStreamSpi(java.lang.String, java.lang.String, java.lang.Class)


Occurences of ImageOutputStreamSpi (constructors)

ImageOutputStreamSpi (constructors) occurences:
javax.imageio.spi.ImageOutputStreamSpi()
javax.imageio.spi.ImageOutputStreamSpi(java.lang.String, java.lang.String, java.lang.Class)


Occurences of imageProgress

imageProgress occurences:
javax.imageio.event.IIOReadProgressListener.imageProgress(javax.imageio.ImageReader, float)
javax.imageio.event.IIOWriteProgressListener.imageProgress(javax.imageio.ImageWriter, float)


Occurences of ImageReaderSpi (constructors)

ImageReaderSpi (constructors) occurences:
javax.imageio.spi.ImageReaderSpi()
javax.imageio.spi.ImageReaderSpi(java.lang.String, java.lang.String, java.lang.String[], java.lang.String[], java.lang.String[], java.lang.String, java.lang.Class[], java.lang.String[], boolean, java.lang.String, java.lang.String, java.lang.String[], java.lang.String[], boolean, java.lang.String, java.lang.String, java.lang.String[], java.lang.String[])


Occurences of ImageReaderWriterSpi (constructors)

ImageReaderWriterSpi (constructors) occurences:
javax.imageio.spi.ImageReaderWriterSpi()
javax.imageio.spi.ImageReaderWriterSpi(java.lang.String, java.lang.String, java.lang.String[], java.lang.String[], java.lang.String[], java.lang.String, boolean, java.lang.String, java.lang.String, java.lang.String[], java.lang.String[], boolean, java.lang.String, java.lang.String, java.lang.String[], java.lang.String[])


Occurences of imageStarted

imageStarted occurences:
javax.imageio.event.IIOReadProgressListener.imageStarted(javax.imageio.ImageReader, int)
javax.imageio.event.IIOWriteProgressListener.imageStarted(javax.imageio.ImageWriter, int)


Occurences of ImageTranscoderSpi (constructors)

ImageTranscoderSpi (constructors) occurences:
javax.imageio.spi.ImageTranscoderSpi()
javax.imageio.spi.ImageTranscoderSpi(java.lang.String, java.lang.String)


Occurences of ImageTypeSpecifier (constructors)

ImageTypeSpecifier (constructors) occurences:
javax.imageio.ImageTypeSpecifier(java.awt.image.ColorModel, java.awt.image.SampleModel)
javax.imageio.ImageTypeSpecifier(java.awt.image.RenderedImage)


Occurences of imageUpdate

imageUpdate occurences:
java.awt.Component.imageUpdate(java.awt.Image, int, int, int, int, int)
java.awt.image.ImageObserver.imageUpdate(java.awt.Image, int, int, int, int, int)
javax.imageio.event.IIOReadUpdateListener.imageUpdate(javax.imageio.ImageReader, java.awt.image.BufferedImage, int, int, int, int, int, int, int[])
javax.swing.AbstractButton.imageUpdate(java.awt.Image, int, int, int, int, int)
javax.swing.JLabel.imageUpdate(java.awt.Image, int, int, int, int, int)


Occurences of ImageWriteParam (constructors)

ImageWriteParam (constructors) occurences:
javax.imageio.ImageWriteParam()
javax.imageio.ImageWriteParam(java.util.Locale)


Occurences of ImageWriterSpi (constructors)

ImageWriterSpi (constructors) occurences:
javax.imageio.spi.ImageWriterSpi()
javax.imageio.spi.ImageWriterSpi(java.lang.String, java.lang.String, java.lang.String[], java.lang.String[], java.lang.String[], java.lang.String, java.lang.Class[], java.lang.String[], boolean, java.lang.String, java.lang.String, java.lang.String[], java.lang.String[], boolean, java.lang.String, java.lang.String, java.lang.String[], java.lang.String[])


Occurences of ImmutableDescriptor (constructors)

ImmutableDescriptor (constructors) occurences:
javax.management.ImmutableDescriptor(java.lang.String...)
javax.management.ImmutableDescriptor(java.lang.String[], java.lang.Object[])
javax.management.ImmutableDescriptor(java.util.Map)


Occurences of implCloseChannel

implCloseChannel occurences:
java.nio.channels.spi.AbstractInterruptibleChannel.implCloseChannel()
java.nio.channels.spi.AbstractSelectableChannel.implCloseChannel()


Occurences of implFlush

implFlush occurences:
java.nio.charset.CharsetDecoder.implFlush(java.nio.CharBuffer)
java.nio.charset.CharsetEncoder.implFlush(java.nio.ByteBuffer)


Occurences of IMPLIED

IMPLIED occurences:
javax.swing.text.html.IMPLIED
javax.swing.text.html.IMPLIED
javax.swing.text.html.parser.IMPLIED


Occurences of implies

implies occurences:
java.io.FilePermission.implies(java.security.Permission)
java.net.SocketPermission.implies(java.security.Permission)
java.security.AllPermission.implies(java.security.Permission)
java.security.BasicPermission.implies(java.security.Permission)
java.security.CodeSource.implies(java.security.CodeSource)
java.security.Permission.implies(java.security.Permission)
java.security.PermissionCollection.implies(java.security.Permission)
java.security.Permissions.implies(java.security.Permission)
java.security.Policy.implies(java.security.ProtectionDomain, java.security.Permission)
java.security.ProtectionDomain.implies(java.security.Permission)
java.security.UnresolvedPermission.implies(java.security.Permission)
java.util.PropertyPermission.implies(java.security.Permission)
javax.management.MBeanPermission.implies(java.security.Permission)
javax.management.MBeanServerPermission.implies(java.security.Permission)
javax.security.auth.kerberos.DelegationPermission.implies(java.security.Permission)
javax.security.auth.kerberos.ServicePermission.implies(java.security.Permission)
javax.security.auth.PrivateCredentialPermission.implies(java.security.Permission)


Occurences of implOnMalformedInput

implOnMalformedInput occurences:
java.nio.charset.CharsetDecoder.implOnMalformedInput(java.nio.charset.CodingErrorAction)
java.nio.charset.CharsetEncoder.implOnMalformedInput(java.nio.charset.CodingErrorAction)


Occurences of implOnUnmappableCharacter

implOnUnmappableCharacter occurences:
java.nio.charset.CharsetDecoder.implOnUnmappableCharacter(java.nio.charset.CodingErrorAction)
java.nio.charset.CharsetEncoder.implOnUnmappableCharacter(java.nio.charset.CodingErrorAction)


Occurences of implReplaceWith

implReplaceWith occurences:
java.nio.charset.CharsetDecoder.implReplaceWith(java.lang.String)
java.nio.charset.CharsetEncoder.implReplaceWith(byte[])


Occurences of implReset

implReset occurences:
java.nio.charset.CharsetDecoder.implReset()
java.nio.charset.CharsetEncoder.implReset()


Occurences of importData

importData occurences:
javax.swing.TransferHandler.importData(javax.swing.JComponent, java.awt.datatransfer.Transferable)
javax.swing.TransferHandler.importData(javax.swing.TransferHandler.TransferSupport)


Occurences of IMP_LIMIT (constructors)

IMP_LIMIT (constructors) occurences:
org.omg.CORBA.IMP_LIMIT()
org.omg.CORBA.IMP_LIMIT(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.IMP_LIMIT(java.lang.String)
org.omg.CORBA.IMP_LIMIT(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of in

in occurences:
java.io.in
java.io.in
java.io.in
java.io.in
java.lang.in
javax.management.Query.in(javax.management.ValueExp, javax.management.ValueExp[])


Occurences of INACTIVE

INACTIVE occurences:
org.omg.PortableInterceptor.INACTIVE
org.omg.PortableServer.POAManagerPackage.INACTIVE


Occurences of inactiveGroup

inactiveGroup occurences:
java.rmi.activation.ActivationGroup.inactiveGroup()
java.rmi.activation.ActivationMonitor.inactiveGroup(java.rmi.activation.ActivationGroupID, long)


Occurences of inactiveObject

inactiveObject occurences:
java.rmi.activation.ActivationGroup.inactiveObject(java.rmi.activation.ActivationID)
java.rmi.activation.ActivationMonitor.inactiveObject(java.rmi.activation.ActivationID)


Occurences of incarnate

incarnate occurences:
org.omg.PortableServer.ServantActivatorOperations.incarnate(byte[], org.omg.PortableServer.POA)
org.omg.PortableServer._ServantActivatorStub.incarnate(byte[], org.omg.PortableServer.POA)


Occurences of INCH

INCH occurences:
javax.print.attribute.INCH
javax.print.attribute.standard.INCH


Occurences of IncompatibleClassChangeError (constructors)

IncompatibleClassChangeError (constructors) occurences:
java.lang.IncompatibleClassChangeError()
java.lang.IncompatibleClassChangeError(java.lang.String)


Occurences of IncompatibleThreadStateException (constructors)

IncompatibleThreadStateException (constructors) occurences:
com.sun.jdi.IncompatibleThreadStateException()
com.sun.jdi.IncompatibleThreadStateException(java.lang.String)


Occurences of InconsistentDebugInfoException (constructors)

InconsistentDebugInfoException (constructors) occurences:
com.sun.jdi.InconsistentDebugInfoException()
com.sun.jdi.InconsistentDebugInfoException(java.lang.String)


Occurences of InconsistentTypeCode

InconsistentTypeCode occurences:
org.omg.CORBA.ORBPackage.InconsistentTypeCode
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode


Occurences of InconsistentTypeCode (constructors)

InconsistentTypeCode (constructors) occurences:
org.omg.CORBA.ORBPackage.InconsistentTypeCode()
org.omg.CORBA.ORBPackage.InconsistentTypeCode(java.lang.String)
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode()
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode(java.lang.String)


Occurences of incrementAndGet

incrementAndGet occurences:
java.util.concurrent.atomic.AtomicInteger.incrementAndGet()
java.util.concurrent.atomic.AtomicIntegerArray.incrementAndGet(int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.incrementAndGet(java.lang.Object)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.incrementAndGet(T)
java.util.concurrent.atomic.AtomicLong.incrementAndGet()
java.util.concurrent.atomic.AtomicLongArray.incrementAndGet(int)
java.util.concurrent.atomic.AtomicLongFieldUpdater.incrementAndGet(java.lang.Object)
java.util.concurrent.atomic.AtomicLongFieldUpdater.incrementAndGet(T)


Occurences of inDaylightTime

inDaylightTime occurences:
java.util.SimpleTimeZone.inDaylightTime(java.util.Date)
java.util.TimeZone.inDaylightTime(java.util.Date)


Occurences of INDEFINITE_LIFETIME

INDEFINITE_LIFETIME occurences:
org.ietf.jgss.INDEFINITE_LIFETIME
org.ietf.jgss.INDEFINITE_LIFETIME


Occurences of INDENT

INDENT occurences:
javax.swing.INDENT
javax.xml.transform.INDENT


Occurences of INDETERMINATE

INDETERMINATE occurences:
javax.accessibility.INDETERMINATE
javax.xml.datatype.INDETERMINATE


Occurences of Index

Index occurences:
Index
Index
Index
Index
Index
Index
Index
Index


Occurences of IndexColorModel (constructors)

IndexColorModel (constructors) occurences:
java.awt.image.IndexColorModel(int, int, byte[], byte[], byte[])
java.awt.image.IndexColorModel(int, int, byte[], byte[], byte[], byte[])
java.awt.image.IndexColorModel(int, int, byte[], byte[], byte[], int)
java.awt.image.IndexColorModel(int, int, byte[], int, boolean)
java.awt.image.IndexColorModel(int, int, byte[], int, boolean, int)
java.awt.image.IndexColorModel(int, int, int[], int, boolean, int, int)
java.awt.image.IndexColorModel(int, int, int[], int, int, java.math.BigInteger)


Occurences of IndexedPropertyDescriptor (constructors)

IndexedPropertyDescriptor (constructors) occurences:
java.beans.IndexedPropertyDescriptor(java.lang.String, java.lang.Class)
java.beans.IndexedPropertyDescriptor(java.lang.String, java.lang.Class, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
java.beans.IndexedPropertyDescriptor(java.lang.String, java.lang.reflect.Method, java.lang.reflect.Method, java.lang.reflect.Method, java.lang.reflect.Method)


Occurences of IndexOutOfBoundsException (constructors)

IndexOutOfBoundsException (constructors) occurences:
java.lang.IndexOutOfBoundsException()
java.lang.IndexOutOfBoundsException(java.lang.String)


Occurences of InetSocketAddress (constructors)

InetSocketAddress (constructors) occurences:
java.net.InetSocketAddress(int)
java.net.InetSocketAddress(java.lang.String, int)
java.net.InetSocketAddress(java.net.InetAddress, int)


Occurences of inf

inf occurences:
java.util.zip.inf
java.util.zip.inf


Occurences of inferBinaryName

inferBinaryName occurences:
javax.tools.ForwardingJavaFileManager.inferBinaryName(javax.tools.JavaFileManager.Location, javax.tools.JavaFileObject)
javax.tools.JavaFileManager.inferBinaryName(javax.tools.JavaFileManager.Location, javax.tools.JavaFileObject)


Occurences of inflate

inflate occurences:
java.util.zip.Inflater.inflate(byte[])
java.util.zip.Inflater.inflate(byte[], int, int)


Occurences of Inflater (constructors)

Inflater (constructors) occurences:
java.util.zip.Inflater()
java.util.zip.Inflater(boolean)


Occurences of InflaterInputStream (constructors)

InflaterInputStream (constructors) occurences:
java.util.zip.InflaterInputStream(java.io.InputStream)
java.util.zip.InflaterInputStream(java.io.InputStream, java.util.zip.Inflater)
java.util.zip.InflaterInputStream(java.io.InputStream, java.util.zip.Inflater, int)


Occurences of InflaterOutputStream (constructors)

InflaterOutputStream (constructors) occurences:
java.util.zip.InflaterOutputStream(java.io.OutputStream)
java.util.zip.InflaterOutputStream(java.io.OutputStream, java.util.zip.Inflater)
java.util.zip.InflaterOutputStream(java.io.OutputStream, java.util.zip.Inflater, int)


Occurences of info

info occurences:
java.awt.info
java.util.logging.Logger.info(java.lang.String)


Occurences of INFO

INFO occurences:
java.awt.INFO
java.awt.INFO
java.util.logging.INFO
javax.management.INFO


Occurences of INFORMATION

INFORMATION occurences:
javax.security.auth.callback.INFORMATION
javax.security.auth.callback.INFORMATION


Occurences of inheritedChannel

inheritedChannel occurences:
java.lang.System.inheritedChannel()
java.nio.channels.spi.SelectorProvider.inheritedChannel()


Occurences of init

init occurences:
java.applet.Applet.init()
java.security.AlgorithmParameterGenerator.init(int)
java.security.AlgorithmParameterGenerator.init(int, java.security.SecureRandom)
java.security.AlgorithmParameterGenerator.init(java.security.spec.AlgorithmParameterSpec)
java.security.AlgorithmParameterGenerator.init(java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
java.security.AlgorithmParameters.init(byte[])
java.security.AlgorithmParameters.init(byte[], java.lang.String)
java.security.AlgorithmParameters.init(java.security.spec.AlgorithmParameterSpec)
java.security.cert.PKIXCertPathChecker.init(boolean)
javax.annotation.processing.AbstractProcessor.init(javax.annotation.processing.ProcessingEnvironment)
javax.annotation.processing.Processor.init(javax.annotation.processing.ProcessingEnvironment)
javax.crypto.Cipher.init(int, java.security.cert.Certificate)
javax.crypto.Cipher.init(int, java.security.cert.Certificate, java.security.SecureRandom)
javax.crypto.Cipher.init(int, java.security.Key)
javax.crypto.Cipher.init(int, java.security.Key, java.security.AlgorithmParameters)
javax.crypto.Cipher.init(int, java.security.Key, java.security.AlgorithmParameters, java.security.SecureRandom)
javax.crypto.Cipher.init(int, java.security.Key, java.security.SecureRandom)
javax.crypto.Cipher.init(int, java.security.Key, java.security.spec.AlgorithmParameterSpec)
javax.crypto.Cipher.init(int, java.security.Key, java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
javax.crypto.ExemptionMechanism.init(java.security.Key)
javax.crypto.ExemptionMechanism.init(java.security.Key, java.security.AlgorithmParameters)
javax.crypto.ExemptionMechanism.init(java.security.Key, java.security.spec.AlgorithmParameterSpec)
javax.crypto.KeyAgreement.init(java.security.Key)
javax.crypto.KeyAgreement.init(java.security.Key, java.security.SecureRandom)
javax.crypto.KeyAgreement.init(java.security.Key, java.security.spec.AlgorithmParameterSpec)
javax.crypto.KeyAgreement.init(java.security.Key, java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
javax.crypto.KeyGenerator.init(int)
javax.crypto.KeyGenerator.init(int, java.security.SecureRandom)
javax.crypto.KeyGenerator.init(java.security.SecureRandom)
javax.crypto.KeyGenerator.init(java.security.spec.AlgorithmParameterSpec)
javax.crypto.KeyGenerator.init(java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
javax.crypto.Mac.init(java.security.Key)
javax.crypto.Mac.init(java.security.Key, java.security.spec.AlgorithmParameterSpec)
javax.naming.InitialContext.init(java.util.Hashtable)
javax.net.ssl.KeyManagerFactory.init(java.security.KeyStore, char[])
javax.net.ssl.KeyManagerFactory.init(javax.net.ssl.ManagerFactoryParameters)
javax.net.ssl.SSLContext.init(javax.net.ssl.KeyManager[], javax.net.ssl.TrustManager[], java.security.SecureRandom)
javax.net.ssl.TrustManagerFactory.init(java.security.KeyStore)
javax.net.ssl.TrustManagerFactory.init(javax.net.ssl.ManagerFactoryParameters)
javax.swing.AbstractButton.init(java.lang.String, javax.swing.Icon)
javax.swing.JMenuItem.init(java.lang.String, javax.swing.Icon)
javax.swing.undo.StateEdit.init(javax.swing.undo.StateEditable, java.lang.String)
javax.xml.crypto.dsig.TransformService.init(javax.xml.crypto.dsig.spec.TransformParameterSpec)
javax.xml.crypto.dsig.TransformService.init(javax.xml.crypto.XMLStructure, javax.xml.crypto.XMLCryptoContext)
org.omg.CORBA.ORB.init()
org.omg.CORBA.ORB.init(java.applet.Applet, java.util.Properties)
org.omg.CORBA.ORB.init(java.lang.String[], java.util.Properties)


Occurences of initCause

initCause occurences:
java.lang.Throwable.initCause(java.lang.Throwable)
javax.naming.NamingException.initCause(java.lang.Throwable)
javax.security.sasl.SaslException.initCause(java.lang.Throwable)
javax.xml.soap.SOAPException.initCause(java.lang.Throwable)
javax.xml.transform.TransformerException.initCause(java.lang.Throwable)


Occurences of initClassDefaults

initClassDefaults occurences:
javax.swing.plaf.basic.BasicLookAndFeel.initClassDefaults(javax.swing.UIDefaults)
javax.swing.plaf.metal.MetalLookAndFeel.initClassDefaults(javax.swing.UIDefaults)


Occurences of initComponentDefaults

initComponentDefaults occurences:
javax.swing.plaf.basic.BasicLookAndFeel.initComponentDefaults(javax.swing.UIDefaults)
javax.swing.plaf.metal.MetalLookAndFeel.initComponentDefaults(javax.swing.UIDefaults)


Occurences of InitialContext (constructors)

InitialContext (constructors) occurences:
javax.naming.InitialContext()
javax.naming.InitialContext(boolean)
javax.naming.InitialContext(java.util.Hashtable)


Occurences of InitialDirContext (constructors)

InitialDirContext (constructors) occurences:
javax.naming.directory.InitialDirContext()
javax.naming.directory.InitialDirContext(boolean)
javax.naming.directory.InitialDirContext(java.util.Hashtable)


Occurences of initialize

initialize occurences:
java.beans.AppletInitializer.initialize(java.applet.Applet, java.beans.beancontext.BeanContext)
java.beans.beancontext.BeanContextServicesSupport.initialize()
java.beans.beancontext.BeanContextSupport.initialize()
java.beans.DefaultPersistenceDelegate.initialize(java.lang.Class, java.lang.Object, java.lang.Object, java.beans.Encoder)
java.beans.PersistenceDelegate.initialize(java.lang.Class, java.lang.Object, java.lang.Object, java.beans.Encoder)
java.security.interfaces.DSAKeyPairGenerator.initialize(int, boolean, java.security.SecureRandom)
java.security.interfaces.DSAKeyPairGenerator.initialize(java.security.interfaces.DSAParams, java.security.SecureRandom)
java.security.KeyPairGenerator.initialize(int)
java.security.KeyPairGenerator.initialize(int, java.security.SecureRandom)
java.security.KeyPairGenerator.initialize(java.security.spec.AlgorithmParameterSpec)
java.security.KeyPairGenerator.initialize(java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
java.security.KeyPairGeneratorSpi.initialize(int, java.security.SecureRandom)
java.security.KeyPairGeneratorSpi.initialize(java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom)
javax.security.auth.spi.LoginModule.initialize(javax.security.auth.Subject, javax.security.auth.callback.CallbackHandler, java.util.Map, java.util.Map)
javax.swing.LookAndFeel.initialize()
javax.swing.plaf.basic.BasicLookAndFeel.initialize()
javax.swing.plaf.synth.SynthLookAndFeel.initialize()


Occurences of INITIALIZE (constructors)

INITIALIZE (constructors) occurences:
org.omg.CORBA.INITIALIZE()
org.omg.CORBA.INITIALIZE(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INITIALIZE(java.lang.String)
org.omg.CORBA.INITIALIZE(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of initializeBeanContextResources

initializeBeanContextResources occurences:
java.beans.beancontext.BeanContextChildSupport.initializeBeanContextResources()
java.beans.beancontext.BeanContextServicesSupport.initializeBeanContextResources()


Occurences of initializeLocalVars

initializeLocalVars occurences:
javax.swing.JTable.initializeLocalVars()
javax.swing.table.JTableHeader.initializeLocalVars()


Occurences of InitialLdapContext (constructors)

InitialLdapContext (constructors) occurences:
javax.naming.ldap.InitialLdapContext()
javax.naming.ldap.InitialLdapContext(java.util.Hashtable, javax.naming.ldap.Control[])


Occurences of initialValue

initialValue occurences:
java.lang.ThreadLocal.initialValue()
javax.swing.initialValue


Occurences of initParams

initParams occurences:
javax.jws.soap.SOAPMessageHandler.initParams()
javax.sql.rowset.BaseRowSet.initParams()


Occurences of initSecContext

initSecContext occurences:
org.ietf.jgss.GSSContext.initSecContext(byte[], int, int)
org.ietf.jgss.GSSContext.initSecContext(java.io.InputStream, java.io.OutputStream)


Occurences of initSign

initSign occurences:
java.security.Signature.initSign(java.security.PrivateKey)
java.security.Signature.initSign(java.security.PrivateKey, java.security.SecureRandom)


Occurences of initSystemColorDefaults

initSystemColorDefaults occurences:
javax.swing.plaf.basic.BasicLookAndFeel.initSystemColorDefaults(javax.swing.UIDefaults)
javax.swing.plaf.metal.MetalLookAndFeel.initSystemColorDefaults(javax.swing.UIDefaults)


Occurences of initVerify

initVerify occurences:
java.security.Signature.initVerify(java.security.cert.Certificate)
java.security.Signature.initVerify(java.security.PublicKey)


Occurences of inlineTags

inlineTags occurences:
com.sun.javadoc.Doc.inlineTags()
com.sun.javadoc.Tag.inlineTags()


Occurences of innerClasses

innerClasses occurences:
com.sun.javadoc.ClassDoc.innerClasses()
com.sun.javadoc.ClassDoc.innerClasses(boolean)


Occurences of InputMethodEvent (constructors)

InputMethodEvent (constructors) occurences:
java.awt.event.InputMethodEvent(java.awt.Component, int, java.awt.font.TextHitInfo, java.awt.font.TextHitInfo)
java.awt.event.InputMethodEvent(java.awt.Component, int, java.text.AttributedCharacterIterator, int, java.awt.font.TextHitInfo, java.awt.font.TextHitInfo)
java.awt.event.InputMethodEvent(java.awt.Component, int, long, java.text.AttributedCharacterIterator, int, java.awt.font.TextHitInfo, java.awt.font.TextHitInfo)


Occurences of InputMethodHighlight (constructors)

InputMethodHighlight (constructors) occurences:
java.awt.im.InputMethodHighlight(boolean, int)
java.awt.im.InputMethodHighlight(boolean, int, int)
java.awt.im.InputMethodHighlight(boolean, int, int, java.util.Map)


Occurences of inputMethodTextChanged

inputMethodTextChanged occurences:
Class ActiveClient.ActiveClient.inputMethodTextChanged(java.awt.event.InputMethodEvent)
java.awt.AWTEventMulticaster.inputMethodTextChanged(java.awt.event.InputMethodEvent)
java.awt.event.InputMethodListener.inputMethodTextChanged(java.awt.event.InputMethodEvent)


Occurences of InputMismatchException (constructors)

InputMismatchException (constructors) occurences:
java.util.InputMismatchException()
java.util.InputMismatchException(java.lang.String)


Occurences of InputSource (constructors)

InputSource (constructors) occurences:
org.xml.sax.InputSource()
org.xml.sax.InputSource(java.io.InputStream)
org.xml.sax.InputSource(java.io.Reader)
org.xml.sax.InputSource(java.lang.String)


Occurences of InputStream

InputStream occurences:
java.io.InputStream
org.omg.CORBA.portable.InputStream
org.omg.CORBA_2_3.portable.InputStream


Occurences of InputStream (constructors)

InputStream (constructors) occurences:
java.io.InputStream()
org.omg.CORBA.portable.InputStream()
org.omg.CORBA_2_3.portable.InputStream()


Occurences of InputStreamReader (constructors)

InputStreamReader (constructors) occurences:
java.io.InputStreamReader(java.io.InputStream)
java.io.InputStreamReader(java.io.InputStream, java.lang.String)
java.io.InputStreamReader(java.io.InputStream, java.nio.charset.Charset)
java.io.InputStreamReader(java.io.InputStream, java.nio.charset.CharsetDecoder)


Occurences of INSERT

INSERT occurences:
java.awt.INSERT
javax.accessibility.INSERT
javax.swing.event.INSERT
javax.swing.event.INSERT
javax.swing.INSERT


Occurences of insert

insert occurences:
java.awt.Choice.insert(java.lang.String, int)
java.awt.Menu.insert(java.awt.MenuItem, int)
java.awt.Menu.insert(java.lang.String, int)
java.awt.TextArea.insert(java.lang.String, int)
java.lang.StringBuffer.insert(int, boolean)
java.lang.StringBuffer.insert(int, char)
java.lang.StringBuffer.insert(int, char[])
java.lang.StringBuffer.insert(int, char[], int, int)
java.lang.StringBuffer.insert(int, double)
java.lang.StringBuffer.insert(int, float)
java.lang.StringBuffer.insert(int, int)
java.lang.StringBuffer.insert(int, java.lang.CharSequence)
java.lang.StringBuffer.insert(int, java.lang.CharSequence, int, int)
java.lang.StringBuffer.insert(int, java.lang.Object)
java.lang.StringBuffer.insert(int, java.lang.String)
java.lang.StringBuffer.insert(int, long)
java.lang.StringBuilder.insert(int, boolean)
java.lang.StringBuilder.insert(int, char)
java.lang.StringBuilder.insert(int, char[])
java.lang.StringBuilder.insert(int, char[], int, int)
java.lang.StringBuilder.insert(int, double)
java.lang.StringBuilder.insert(int, float)
java.lang.StringBuilder.insert(int, int)
java.lang.StringBuilder.insert(int, java.lang.CharSequence)
java.lang.StringBuilder.insert(int, java.lang.CharSequence, int, int)
java.lang.StringBuilder.insert(int, java.lang.Object)
java.lang.StringBuilder.insert(int, java.lang.String)
java.lang.StringBuilder.insert(int, long)
javax.swing.JMenu.insert(java.lang.String, int)
javax.swing.JMenu.insert(javax.swing.Action, int)
javax.swing.JMenu.insert(javax.swing.JMenuItem, int)
javax.swing.JPopupMenu.insert(java.awt.Component, int)
javax.swing.JPopupMenu.insert(javax.swing.Action, int)
javax.swing.JTextArea.insert(java.lang.String, int)
javax.swing.text.DefaultStyledDocument.insert(int, javax.swing.text.DefaultStyledDocument.ElementSpec[])
javax.swing.text.DefaultStyledDocument.ElementBuffer.insert(int, int, javax.swing.text.DefaultStyledDocument.ElementSpec[], javax.swing.text.AbstractDocument.DefaultDocumentEvent)
javax.swing.text.html.HTMLDocument.insert(int, javax.swing.text.DefaultStyledDocument.ElementSpec[])
javax.swing.text.View.insert(int, javax.swing.text.View)
javax.swing.tree.DefaultMutableTreeNode.insert(javax.swing.tree.MutableTreeNode, int)
javax.swing.tree.MutableTreeNode.insert(javax.swing.tree.MutableTreeNode, int)
org.omg.CORBA.AnySeqHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.Any[])
org.omg.CORBA.BooleanSeqHelper.insert(org.omg.CORBA.Any, boolean[])
org.omg.CORBA.CharSeqHelper.insert(org.omg.CORBA.Any, char[])
org.omg.CORBA.CompletionStatusHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.CurrentHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.Current)
org.omg.CORBA.DefinitionKindHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.DefinitionKind)
org.omg.CORBA.DoubleSeqHelper.insert(org.omg.CORBA.Any, double[])
org.omg.CORBA.FieldNameHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CORBA.FloatSeqHelper.insert(org.omg.CORBA.Any, float[])
org.omg.CORBA.IdentifierHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CORBA.IDLTypeHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.IDLType)
org.omg.CORBA.LongLongSeqHelper.insert(org.omg.CORBA.Any, long[])
org.omg.CORBA.LongSeqHelper.insert(org.omg.CORBA.Any, int[])
org.omg.CORBA.NameValuePairHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.NameValuePair)
org.omg.CORBA.ObjectHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.Object)
org.omg.CORBA.OctetSeqHelper.insert(org.omg.CORBA.Any, byte[])
org.omg.CORBA.ParameterModeHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.ParameterMode)
org.omg.CORBA.PolicyErrorCodeHelper.insert(org.omg.CORBA.Any, short)
org.omg.CORBA.PolicyErrorHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.PolicyError)
org.omg.CORBA.PolicyHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.Policy)
org.omg.CORBA.PolicyListHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.Policy[])
org.omg.CORBA.PolicyTypeHelper.insert(org.omg.CORBA.Any, int)
org.omg.CORBA.RepositoryIdHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CORBA.ServiceDetailHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.ServiceDetail)
org.omg.CORBA.ServiceInformationHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.ServiceInformation)
org.omg.CORBA.SetOverrideTypeHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.SetOverrideType)
org.omg.CORBA.ShortSeqHelper.insert(org.omg.CORBA.Any, short[])
org.omg.CORBA.StringSeqHelper.insert(org.omg.CORBA.Any, java.lang.String[])
org.omg.CORBA.StringValueHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CORBA.StructMemberHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.StructMember)
org.omg.CORBA.ULongLongSeqHelper.insert(org.omg.CORBA.Any, long[])
org.omg.CORBA.ULongSeqHelper.insert(org.omg.CORBA.Any, int[])
org.omg.CORBA.UnionMemberHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.UnionMember)
org.omg.CORBA.UnknownUserExceptionHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.UnknownUserException)
org.omg.CORBA.UShortSeqHelper.insert(org.omg.CORBA.Any, short[])
org.omg.CORBA.ValueBaseHelper.insert(org.omg.CORBA.Any, java.io.Serializable)
org.omg.CORBA.ValueMemberHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.ValueMember)
org.omg.CORBA.VersionSpecHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CORBA.VisibilityHelper.insert(org.omg.CORBA.Any, short)
org.omg.CORBA.WCharSeqHelper.insert(org.omg.CORBA.Any, char[])
org.omg.CORBA.WrongTransactionHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.WrongTransaction)
org.omg.CORBA.WStringSeqHelper.insert(org.omg.CORBA.Any, java.lang.String[])
org.omg.CORBA.WStringValueHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CosNaming.BindingHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.Binding)
org.omg.CosNaming.BindingIteratorHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.BindingIterator)
org.omg.CosNaming.BindingListHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.Binding[])
org.omg.CosNaming.BindingTypeHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.BindingType)
org.omg.CosNaming.IstringHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CosNaming.NameComponentHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NameComponent)
org.omg.CosNaming.NameHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NameComponent[])
org.omg.CosNaming.NamingContextExtHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContextExt)
org.omg.CosNaming.NamingContextExtPackage.AddressHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContextExtPackage.InvalidAddress)
org.omg.CosNaming.NamingContextExtPackage.StringNameHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CosNaming.NamingContextExtPackage.URLStringHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.CosNaming.NamingContextHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContext)
org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContextPackage.AlreadyBound)
org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContextPackage.CannotProceed)
org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContextPackage.InvalidName)
org.omg.CosNaming.NamingContextPackage.NotEmptyHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContextPackage.NotEmpty)
org.omg.CosNaming.NamingContextPackage.NotFoundHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContextPackage.NotFound)
org.omg.CosNaming.NamingContextPackage.NotFoundReasonHelper.insert(org.omg.CORBA.Any, org.omg.CosNaming.NamingContextPackage.NotFoundReason)
org.omg.DynamicAny.AnySeqHelper.insert(org.omg.CORBA.Any, org.omg.CORBA.Any[])
org.omg.DynamicAny.DynAnyFactoryHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynAnyFactory)
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCodeHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode)
org.omg.DynamicAny.DynAnyHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynAny)
org.omg.DynamicAny.DynAnyPackage.InvalidValueHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynAnyPackage.InvalidValue)
org.omg.DynamicAny.DynAnyPackage.TypeMismatchHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynAnyPackage.TypeMismatch)
org.omg.DynamicAny.DynAnySeqHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynAny[])
org.omg.DynamicAny.DynArrayHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynArray)
org.omg.DynamicAny.DynEnumHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynEnum)
org.omg.DynamicAny.DynFixedHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynFixed)
org.omg.DynamicAny.DynSequenceHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynSequence)
org.omg.DynamicAny.DynStructHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynStruct)
org.omg.DynamicAny.DynUnionHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynUnion)
org.omg.DynamicAny.DynValueHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.DynValue)
org.omg.DynamicAny.FieldNameHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.DynamicAny.NameDynAnyPairHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.NameDynAnyPair)
org.omg.DynamicAny.NameDynAnyPairSeqHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.NameDynAnyPair[])
org.omg.DynamicAny.NameValuePairHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.NameValuePair)
org.omg.DynamicAny.NameValuePairSeqHelper.insert(org.omg.CORBA.Any, org.omg.DynamicAny.NameValuePair[])
org.omg.IOP.CodecFactoryHelper.insert(org.omg.CORBA.Any, org.omg.IOP.CodecFactory)
org.omg.IOP.CodecFactoryPackage.UnknownEncodingHelper.insert(org.omg.CORBA.Any, org.omg.IOP.CodecFactoryPackage.UnknownEncoding)
org.omg.IOP.CodecPackage.FormatMismatchHelper.insert(org.omg.CORBA.Any, org.omg.IOP.CodecPackage.FormatMismatch)
org.omg.IOP.CodecPackage.InvalidTypeForEncodingHelper.insert(org.omg.CORBA.Any, org.omg.IOP.CodecPackage.InvalidTypeForEncoding)
org.omg.IOP.CodecPackage.TypeMismatchHelper.insert(org.omg.CORBA.Any, org.omg.IOP.CodecPackage.TypeMismatch)
org.omg.IOP.ComponentIdHelper.insert(org.omg.CORBA.Any, int)
org.omg.IOP.IORHelper.insert(org.omg.CORBA.Any, org.omg.IOP.IOR)
org.omg.IOP.MultipleComponentProfileHelper.insert(org.omg.CORBA.Any, org.omg.IOP.TaggedComponent[])
org.omg.IOP.ProfileIdHelper.insert(org.omg.CORBA.Any, int)
org.omg.IOP.ServiceContextHelper.insert(org.omg.CORBA.Any, org.omg.IOP.ServiceContext)
org.omg.IOP.ServiceContextListHelper.insert(org.omg.CORBA.Any, org.omg.IOP.ServiceContext[])
org.omg.IOP.ServiceIdHelper.insert(org.omg.CORBA.Any, int)
org.omg.IOP.TaggedComponentHelper.insert(org.omg.CORBA.Any, org.omg.IOP.TaggedComponent)
org.omg.IOP.TaggedProfileHelper.insert(org.omg.CORBA.Any, org.omg.IOP.TaggedProfile)
org.omg.Messaging.SyncScopeHelper.insert(org.omg.CORBA.Any, short)
org.omg.PortableInterceptor.AdapterManagerIdHelper.insert(org.omg.CORBA.Any, int)
org.omg.PortableInterceptor.AdapterNameHelper.insert(org.omg.CORBA.Any, java.lang.String[])
org.omg.PortableInterceptor.AdapterStateHelper.insert(org.omg.CORBA.Any, short)
org.omg.PortableInterceptor.CurrentHelper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.Current)
org.omg.PortableInterceptor.ForwardRequestHelper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.ForwardRequest)
org.omg.PortableInterceptor.InvalidSlotHelper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.InvalidSlot)
org.omg.PortableInterceptor.IORInterceptor_3_0Helper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.IORInterceptor_3_0)
org.omg.PortableInterceptor.ObjectIdHelper.insert(org.omg.CORBA.Any, byte[])
org.omg.PortableInterceptor.ObjectReferenceFactoryHelper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.ObjectReferenceFactory)
org.omg.PortableInterceptor.ObjectReferenceTemplateHelper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.ObjectReferenceTemplate)
org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHelper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.ObjectReferenceTemplate[])
org.omg.PortableInterceptor.ORBIdHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateNameHelper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName)
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidNameHelper.insert(org.omg.CORBA.Any, org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidName)
org.omg.PortableInterceptor.ORBInitInfoPackage.ObjectIdHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.PortableInterceptor.ServerIdHelper.insert(org.omg.CORBA.Any, java.lang.String)
org.omg.PortableServer.CurrentHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.Current)
org.omg.PortableServer.CurrentPackage.NoContextHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.CurrentPackage.NoContext)
org.omg.PortableServer.ForwardRequestHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.ForwardRequest)
org.omg.PortableServer.POAHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POA)
org.omg.PortableServer.POAManagerPackage.AdapterInactiveHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAManagerPackage.AdapterInactive)
org.omg.PortableServer.POAPackage.AdapterAlreadyExistsHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.AdapterAlreadyExists)
org.omg.PortableServer.POAPackage.AdapterNonExistentHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.AdapterNonExistent)
org.omg.PortableServer.POAPackage.InvalidPolicyHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.InvalidPolicy)
org.omg.PortableServer.POAPackage.NoServantHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.NoServant)
org.omg.PortableServer.POAPackage.ObjectAlreadyActiveHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.ObjectAlreadyActive)
org.omg.PortableServer.POAPackage.ObjectNotActiveHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.ObjectNotActive)
org.omg.PortableServer.POAPackage.ServantAlreadyActiveHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.ServantAlreadyActive)
org.omg.PortableServer.POAPackage.ServantNotActiveHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.ServantNotActive)
org.omg.PortableServer.POAPackage.WrongAdapterHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.WrongAdapter)
org.omg.PortableServer.POAPackage.WrongPolicyHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.POAPackage.WrongPolicy)
org.omg.PortableServer.ServantActivatorHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.ServantActivator)
org.omg.PortableServer.ServantLocatorHelper.insert(org.omg.CORBA.Any, org.omg.PortableServer.ServantLocator)


Occurences of insertBefore

insertBefore occurences:
javax.imageio.metadata.IIOMetadataNode.insertBefore(org.w3c.dom.Node, org.w3c.dom.Node)
org.w3c.dom.Node.insertBefore(org.w3c.dom.Node, org.w3c.dom.Node)


Occurences of insertChar

insertChar occurences:
java.awt.font.LineBreakMeasurer.insertChar(java.text.AttributedCharacterIterator, int)
java.awt.font.TextMeasurer.insertChar(java.text.AttributedCharacterIterator, int)


Occurences of insertElementAt

insertElementAt occurences:
java.util.Vector.insertElementAt(E, int)
java.util.Vector.insertElementAt(java.lang.Object,int)
javax.swing.DefaultComboBoxModel.insertElementAt(java.lang.Object, int)
javax.swing.DefaultListModel.insertElementAt(java.lang.Object, int)
javax.swing.MutableComboBoxModel.insertElementAt(java.lang.Object, int)


Occurences of insertHTML

insertHTML occurences:
javax.swing.text.html.HTMLEditorKit.insertHTML(javax.swing.text.html.HTMLDocument, int, java.lang.String, int, int, javax.swing.text.html.HTML.Tag)
javax.swing.text.html.HTMLEditorKit.InsertHTMLTextAction.insertHTML(javax.swing.JEditorPane, javax.swing.text.html.HTMLDocument, int, java.lang.String, int, int, javax.swing.text.html.HTML.Tag)


Occurences of insertIndexInterval

insertIndexInterval occurences:
javax.swing.DefaultListSelectionModel.insertIndexInterval(int, int, boolean)
javax.swing.ListSelectionModel.insertIndexInterval(int, int, boolean)


Occurences of insertRow

insertRow occurences:
java.sql.ResultSet.insertRow()
javax.swing.table.DefaultTableModel.insertRow(int, java.lang.Object[])
javax.swing.table.DefaultTableModel.insertRow(int, java.util.Vector)


Occurences of insertSeparator

insertSeparator occurences:
java.awt.Menu.insertSeparator(int)
javax.swing.JMenu.insertSeparator(int)


Occurences of insertString

insertString occurences:
javax.swing.text.AbstractDocument.insertString(int, java.lang.String, javax.swing.text.AttributeSet)
javax.swing.text.AbstractDocument.Content.insertString(int, java.lang.String)
javax.swing.text.Document.insertString(int, java.lang.String, javax.swing.text.AttributeSet)
javax.swing.text.DocumentFilter.insertString(javax.swing.text.DocumentFilter.FilterBypass, int, java.lang.String, javax.swing.text.AttributeSet)
javax.swing.text.DocumentFilter.FilterBypass.insertString(int, java.lang.String, javax.swing.text.AttributeSet)
javax.swing.text.GapContent.insertString(int, java.lang.String)
javax.swing.text.PlainDocument.insertString(int, java.lang.String, javax.swing.text.AttributeSet)
javax.swing.text.StringContent.insertString(int, java.lang.String)


Occurences of insertTextAtIndex

insertTextAtIndex occurences:
javax.accessibility.AccessibleEditableText.insertTextAtIndex(int, java.lang.String)
javax.swing.JSpinner.AccessibleJSpinner.insertTextAtIndex(int, java.lang.String)
javax.swing.text.JTextComponent.AccessibleJTextComponent.insertTextAtIndex(int, java.lang.String)


Occurences of insertUpdate

insertUpdate occurences:
javax.swing.event.DocumentListener.insertUpdate(javax.swing.event.DocumentEvent)
javax.swing.text.AbstractDocument.insertUpdate(javax.swing.text.AbstractDocument.DefaultDocumentEvent, javax.swing.text.AttributeSet)
javax.swing.text.DefaultStyledDocument.insertUpdate(javax.swing.text.AbstractDocument.DefaultDocumentEvent, javax.swing.text.AttributeSet)
javax.swing.text.DefaultStyledDocument.ElementBuffer.insertUpdate(javax.swing.text.DefaultStyledDocument.ElementSpec[])
javax.swing.text.FieldView.insertUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.FlowView.insertUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.FlowView.FlowStrategy.insertUpdate(javax.swing.text.FlowView, javax.swing.event.DocumentEvent, java.awt.Rectangle)
javax.swing.text.GlyphView.insertUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.html.HTMLDocument.insertUpdate(javax.swing.text.AbstractDocument.DefaultDocumentEvent, javax.swing.text.AttributeSet)
javax.swing.text.html.InlineView.insertUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.JTextComponent.AccessibleJTextComponent.insertUpdate(javax.swing.event.DocumentEvent)
javax.swing.text.PlainDocument.insertUpdate(javax.swing.text.AbstractDocument.DefaultDocumentEvent, javax.swing.text.AttributeSet)
javax.swing.text.PlainView.insertUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.View.insertUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.WrappedPlainView.insertUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.ZoneView.insertUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)


Occurences of insert_any

insert_any occurences:
org.omg.CORBA.Any.insert_any(org.omg.CORBA.Any)
org.omg.CORBA.DynAny.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny.DynAnyOperations.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynAnyStub.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynArrayStub.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynEnumStub.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynFixedStub.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynSequenceStub.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynStructStub.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynUnionStub.insert_any(org.omg.CORBA.Any)
org.omg.DynamicAny._DynValueStub.insert_any(org.omg.CORBA.Any)


Occurences of insert_boolean

insert_boolean occurences:
org.omg.CORBA.Any.insert_boolean(boolean)
org.omg.CORBA.DynAny.insert_boolean(boolean)
org.omg.DynamicAny.DynAnyOperations.insert_boolean(boolean)
org.omg.DynamicAny._DynAnyStub.insert_boolean(boolean)
org.omg.DynamicAny._DynArrayStub.insert_boolean(boolean)
org.omg.DynamicAny._DynEnumStub.insert_boolean(boolean)
org.omg.DynamicAny._DynFixedStub.insert_boolean(boolean)
org.omg.DynamicAny._DynSequenceStub.insert_boolean(boolean)
org.omg.DynamicAny._DynStructStub.insert_boolean(boolean)
org.omg.DynamicAny._DynUnionStub.insert_boolean(boolean)
org.omg.DynamicAny._DynValueStub.insert_boolean(boolean)


Occurences of insert_char

insert_char occurences:
org.omg.CORBA.Any.insert_char(char)
org.omg.CORBA.DynAny.insert_char(char)
org.omg.DynamicAny.DynAnyOperations.insert_char(char)
org.omg.DynamicAny._DynAnyStub.insert_char(char)
org.omg.DynamicAny._DynArrayStub.insert_char(char)
org.omg.DynamicAny._DynEnumStub.insert_char(char)
org.omg.DynamicAny._DynFixedStub.insert_char(char)
org.omg.DynamicAny._DynSequenceStub.insert_char(char)
org.omg.DynamicAny._DynStructStub.insert_char(char)
org.omg.DynamicAny._DynUnionStub.insert_char(char)
org.omg.DynamicAny._DynValueStub.insert_char(char)


Occurences of insert_double

insert_double occurences:
org.omg.CORBA.Any.insert_double(double)
org.omg.CORBA.DynAny.insert_double(double)
org.omg.DynamicAny.DynAnyOperations.insert_double(double)
org.omg.DynamicAny._DynAnyStub.insert_double(double)
org.omg.DynamicAny._DynArrayStub.insert_double(double)
org.omg.DynamicAny._DynEnumStub.insert_double(double)
org.omg.DynamicAny._DynFixedStub.insert_double(double)
org.omg.DynamicAny._DynSequenceStub.insert_double(double)
org.omg.DynamicAny._DynStructStub.insert_double(double)
org.omg.DynamicAny._DynUnionStub.insert_double(double)
org.omg.DynamicAny._DynValueStub.insert_double(double)


Occurences of insert_dyn_any

insert_dyn_any occurences:
org.omg.DynamicAny.DynAnyOperations.insert_dyn_any(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynAnyStub.insert_dyn_any(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynArrayStub.insert_dyn_any(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynEnumStub.insert_dyn_any(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynFixedStub.insert_dyn_any(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynSequenceStub.insert_dyn_any(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynStructStub.insert_dyn_any(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynUnionStub.insert_dyn_any(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynValueStub.insert_dyn_any(org.omg.DynamicAny.DynAny)


Occurences of insert_fixed

insert_fixed occurences:
org.omg.CORBA.Any.insert_fixed(java.math.BigDecimal)
org.omg.CORBA.Any.insert_fixed(java.math.BigDecimal, org.omg.CORBA.TypeCode)


Occurences of insert_float

insert_float occurences:
org.omg.CORBA.Any.insert_float(float)
org.omg.CORBA.DynAny.insert_float(float)
org.omg.DynamicAny.DynAnyOperations.insert_float(float)
org.omg.DynamicAny._DynAnyStub.insert_float(float)
org.omg.DynamicAny._DynArrayStub.insert_float(float)
org.omg.DynamicAny._DynEnumStub.insert_float(float)
org.omg.DynamicAny._DynFixedStub.insert_float(float)
org.omg.DynamicAny._DynSequenceStub.insert_float(float)
org.omg.DynamicAny._DynStructStub.insert_float(float)
org.omg.DynamicAny._DynUnionStub.insert_float(float)
org.omg.DynamicAny._DynValueStub.insert_float(float)


Occurences of insert_long

insert_long occurences:
org.omg.CORBA.Any.insert_long(int)
org.omg.CORBA.DynAny.insert_long(int)
org.omg.DynamicAny.DynAnyOperations.insert_long(int)
org.omg.DynamicAny._DynAnyStub.insert_long(int)
org.omg.DynamicAny._DynArrayStub.insert_long(int)
org.omg.DynamicAny._DynEnumStub.insert_long(int)
org.omg.DynamicAny._DynFixedStub.insert_long(int)
org.omg.DynamicAny._DynSequenceStub.insert_long(int)
org.omg.DynamicAny._DynStructStub.insert_long(int)
org.omg.DynamicAny._DynUnionStub.insert_long(int)
org.omg.DynamicAny._DynValueStub.insert_long(int)


Occurences of insert_longlong

insert_longlong occurences:
org.omg.CORBA.Any.insert_longlong(long)
org.omg.CORBA.DynAny.insert_longlong(long)
org.omg.DynamicAny.DynAnyOperations.insert_longlong(long)
org.omg.DynamicAny._DynAnyStub.insert_longlong(long)
org.omg.DynamicAny._DynArrayStub.insert_longlong(long)
org.omg.DynamicAny._DynEnumStub.insert_longlong(long)
org.omg.DynamicAny._DynFixedStub.insert_longlong(long)
org.omg.DynamicAny._DynSequenceStub.insert_longlong(long)
org.omg.DynamicAny._DynStructStub.insert_longlong(long)
org.omg.DynamicAny._DynUnionStub.insert_longlong(long)
org.omg.DynamicAny._DynValueStub.insert_longlong(long)


Occurences of insert_Object

insert_Object occurences:
org.omg.CORBA.Any.insert_Object(org.omg.CORBA.Object)
org.omg.CORBA.Any.insert_Object(org.omg.CORBA.Object, org.omg.CORBA.TypeCode)


Occurences of insert_octet

insert_octet occurences:
org.omg.CORBA.Any.insert_octet(byte)
org.omg.CORBA.DynAny.insert_octet(byte)
org.omg.DynamicAny.DynAnyOperations.insert_octet(byte)
org.omg.DynamicAny._DynAnyStub.insert_octet(byte)
org.omg.DynamicAny._DynArrayStub.insert_octet(byte)
org.omg.DynamicAny._DynEnumStub.insert_octet(byte)
org.omg.DynamicAny._DynFixedStub.insert_octet(byte)
org.omg.DynamicAny._DynSequenceStub.insert_octet(byte)
org.omg.DynamicAny._DynStructStub.insert_octet(byte)
org.omg.DynamicAny._DynUnionStub.insert_octet(byte)
org.omg.DynamicAny._DynValueStub.insert_octet(byte)


Occurences of insert_reference

insert_reference occurences:
org.omg.CORBA.DynAny.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny.DynAnyOperations.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny._DynAnyStub.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny._DynArrayStub.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny._DynEnumStub.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny._DynFixedStub.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny._DynSequenceStub.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny._DynStructStub.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny._DynUnionStub.insert_reference(org.omg.CORBA.Object)
org.omg.DynamicAny._DynValueStub.insert_reference(org.omg.CORBA.Object)


Occurences of insert_short

insert_short occurences:
org.omg.CORBA.Any.insert_short(short)
org.omg.CORBA.DynAny.insert_short(short)
org.omg.DynamicAny.DynAnyOperations.insert_short(short)
org.omg.DynamicAny._DynAnyStub.insert_short(short)
org.omg.DynamicAny._DynArrayStub.insert_short(short)
org.omg.DynamicAny._DynEnumStub.insert_short(short)
org.omg.DynamicAny._DynFixedStub.insert_short(short)
org.omg.DynamicAny._DynSequenceStub.insert_short(short)
org.omg.DynamicAny._DynStructStub.insert_short(short)
org.omg.DynamicAny._DynUnionStub.insert_short(short)
org.omg.DynamicAny._DynValueStub.insert_short(short)


Occurences of insert_string

insert_string occurences:
org.omg.CORBA.Any.insert_string(java.lang.String)
org.omg.CORBA.DynAny.insert_string(java.lang.String)
org.omg.DynamicAny.DynAnyOperations.insert_string(java.lang.String)
org.omg.DynamicAny._DynAnyStub.insert_string(java.lang.String)
org.omg.DynamicAny._DynArrayStub.insert_string(java.lang.String)
org.omg.DynamicAny._DynEnumStub.insert_string(java.lang.String)
org.omg.DynamicAny._DynFixedStub.insert_string(java.lang.String)
org.omg.DynamicAny._DynSequenceStub.insert_string(java.lang.String)
org.omg.DynamicAny._DynStructStub.insert_string(java.lang.String)
org.omg.DynamicAny._DynUnionStub.insert_string(java.lang.String)
org.omg.DynamicAny._DynValueStub.insert_string(java.lang.String)


Occurences of insert_typecode

insert_typecode occurences:
org.omg.CORBA.DynAny.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny.DynAnyOperations.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynAnyStub.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynArrayStub.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynEnumStub.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynFixedStub.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynSequenceStub.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynStructStub.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynUnionStub.insert_typecode(org.omg.CORBA.TypeCode)
org.omg.DynamicAny._DynValueStub.insert_typecode(org.omg.CORBA.TypeCode)


Occurences of insert_ulong

insert_ulong occurences:
org.omg.CORBA.Any.insert_ulong(int)
org.omg.CORBA.DynAny.insert_ulong(int)
org.omg.DynamicAny.DynAnyOperations.insert_ulong(int)
org.omg.DynamicAny._DynAnyStub.insert_ulong(int)
org.omg.DynamicAny._DynArrayStub.insert_ulong(int)
org.omg.DynamicAny._DynEnumStub.insert_ulong(int)
org.omg.DynamicAny._DynFixedStub.insert_ulong(int)
org.omg.DynamicAny._DynSequenceStub.insert_ulong(int)
org.omg.DynamicAny._DynStructStub.insert_ulong(int)
org.omg.DynamicAny._DynUnionStub.insert_ulong(int)
org.omg.DynamicAny._DynValueStub.insert_ulong(int)


Occurences of insert_ulonglong

insert_ulonglong occurences:
org.omg.CORBA.Any.insert_ulonglong(long)
org.omg.CORBA.DynAny.insert_ulonglong(long)
org.omg.DynamicAny.DynAnyOperations.insert_ulonglong(long)
org.omg.DynamicAny._DynAnyStub.insert_ulonglong(long)
org.omg.DynamicAny._DynArrayStub.insert_ulonglong(long)
org.omg.DynamicAny._DynEnumStub.insert_ulonglong(long)
org.omg.DynamicAny._DynFixedStub.insert_ulonglong(long)
org.omg.DynamicAny._DynSequenceStub.insert_ulonglong(long)
org.omg.DynamicAny._DynStructStub.insert_ulonglong(long)
org.omg.DynamicAny._DynUnionStub.insert_ulonglong(long)
org.omg.DynamicAny._DynValueStub.insert_ulonglong(long)


Occurences of insert_ushort

insert_ushort occurences:
org.omg.CORBA.Any.insert_ushort(short)
org.omg.CORBA.DynAny.insert_ushort(short)
org.omg.DynamicAny.DynAnyOperations.insert_ushort(short)
org.omg.DynamicAny._DynAnyStub.insert_ushort(short)
org.omg.DynamicAny._DynArrayStub.insert_ushort(short)
org.omg.DynamicAny._DynEnumStub.insert_ushort(short)
org.omg.DynamicAny._DynFixedStub.insert_ushort(short)
org.omg.DynamicAny._DynSequenceStub.insert_ushort(short)
org.omg.DynamicAny._DynStructStub.insert_ushort(short)
org.omg.DynamicAny._DynUnionStub.insert_ushort(short)
org.omg.DynamicAny._DynValueStub.insert_ushort(short)


Occurences of insert_val

insert_val occurences:
org.omg.CORBA.DynAny.insert_val(java.io.Serializable)
org.omg.DynamicAny.DynAnyOperations.insert_val(java.io.Serializable)
org.omg.DynamicAny._DynAnyStub.insert_val(java.io.Serializable)
org.omg.DynamicAny._DynArrayStub.insert_val(java.io.Serializable)
org.omg.DynamicAny._DynEnumStub.insert_val(java.io.Serializable)
org.omg.DynamicAny._DynFixedStub.insert_val(java.io.Serializable)
org.omg.DynamicAny._DynSequenceStub.insert_val(java.io.Serializable)
org.omg.DynamicAny._DynStructStub.insert_val(java.io.Serializable)
org.omg.DynamicAny._DynUnionStub.insert_val(java.io.Serializable)
org.omg.DynamicAny._DynValueStub.insert_val(java.io.Serializable)


Occurences of insert_Value

insert_Value occurences:
org.omg.CORBA.Any.insert_Value(java.io.Serializable)
org.omg.CORBA.Any.insert_Value(java.io.Serializable, org.omg.CORBA.TypeCode)


Occurences of insert_wchar

insert_wchar occurences:
org.omg.CORBA.Any.insert_wchar(char)
org.omg.CORBA.DynAny.insert_wchar(char)
org.omg.DynamicAny.DynAnyOperations.insert_wchar(char)
org.omg.DynamicAny._DynAnyStub.insert_wchar(char)
org.omg.DynamicAny._DynArrayStub.insert_wchar(char)
org.omg.DynamicAny._DynEnumStub.insert_wchar(char)
org.omg.DynamicAny._DynFixedStub.insert_wchar(char)
org.omg.DynamicAny._DynSequenceStub.insert_wchar(char)
org.omg.DynamicAny._DynStructStub.insert_wchar(char)
org.omg.DynamicAny._DynUnionStub.insert_wchar(char)
org.omg.DynamicAny._DynValueStub.insert_wchar(char)


Occurences of insert_wstring

insert_wstring occurences:
org.omg.CORBA.Any.insert_wstring(java.lang.String)
org.omg.CORBA.DynAny.insert_wstring(java.lang.String)
org.omg.DynamicAny.DynAnyOperations.insert_wstring(java.lang.String)
org.omg.DynamicAny._DynAnyStub.insert_wstring(java.lang.String)
org.omg.DynamicAny._DynArrayStub.insert_wstring(java.lang.String)
org.omg.DynamicAny._DynEnumStub.insert_wstring(java.lang.String)
org.omg.DynamicAny._DynFixedStub.insert_wstring(java.lang.String)
org.omg.DynamicAny._DynSequenceStub.insert_wstring(java.lang.String)
org.omg.DynamicAny._DynStructStub.insert_wstring(java.lang.String)
org.omg.DynamicAny._DynUnionStub.insert_wstring(java.lang.String)
org.omg.DynamicAny._DynValueStub.insert_wstring(java.lang.String)


Occurences of insets

insets occurences:
java.awt.Container.insets()
java.awt.insets


Occurences of inside

inside occurences:
java.awt.Component.inside(int, int)
java.awt.Polygon.inside(int, int)
java.awt.Rectangle.inside(int, int)


Occurences of install

install occurences:
javax.swing.JFormattedTextField.AbstractFormatter.install(javax.swing.JFormattedTextField)
javax.swing.text.Caret.install(javax.swing.text.JTextComponent)
javax.swing.text.DefaultCaret.install(javax.swing.text.JTextComponent)
javax.swing.text.DefaultFormatter.install(javax.swing.JFormattedTextField)
javax.swing.text.DefaultHighlighter.install(javax.swing.text.JTextComponent)
javax.swing.text.EditorKit.install(javax.swing.JEditorPane)
javax.swing.text.Highlighter.install(javax.swing.text.JTextComponent)
javax.swing.text.html.HTMLEditorKit.install(javax.swing.JEditorPane)
javax.swing.text.InternationalFormatter.install(javax.swing.JFormattedTextField)
javax.swing.text.MaskFormatter.install(javax.swing.JFormattedTextField)
javax.swing.text.StyledEditorKit.install(javax.swing.JEditorPane)


Occurences of installComponents

installComponents occurences:
javax.swing.plaf.basic.BasicComboBoxUI.installComponents()
javax.swing.plaf.basic.BasicDesktopIconUI.installComponents()
javax.swing.plaf.basic.BasicFileChooserUI.installComponents(javax.swing.JFileChooser)
javax.swing.plaf.basic.BasicInternalFrameUI.installComponents()
javax.swing.plaf.basic.BasicLabelUI.installComponents(javax.swing.JLabel)
javax.swing.plaf.basic.BasicMenuItemUI.installComponents(javax.swing.JMenuItem)
javax.swing.plaf.basic.BasicOptionPaneUI.installComponents()
javax.swing.plaf.basic.BasicRootPaneUI.installComponents(javax.swing.JRootPane)
javax.swing.plaf.basic.BasicScrollBarUI.installComponents()
javax.swing.plaf.basic.BasicTabbedPaneUI.installComponents()
javax.swing.plaf.basic.BasicToolBarUI.installComponents()
javax.swing.plaf.basic.BasicTreeUI.installComponents()
javax.swing.plaf.metal.MetalDesktopIconUI.installComponents()
javax.swing.plaf.metal.MetalFileChooserUI.installComponents(javax.swing.JFileChooser)


Occurences of installDefaults

installDefaults occurences:
javax.swing.plaf.basic.BasicButtonUI.installDefaults(javax.swing.AbstractButton)
javax.swing.plaf.basic.BasicColorChooserUI.installDefaults()
javax.swing.plaf.basic.BasicComboBoxUI.installDefaults()
javax.swing.plaf.basic.BasicDesktopIconUI.installDefaults()
javax.swing.plaf.basic.BasicDesktopPaneUI.installDefaults()
javax.swing.plaf.basic.BasicFileChooserUI.installDefaults(javax.swing.JFileChooser)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.installDefaults()
javax.swing.plaf.basic.BasicInternalFrameUI.installDefaults()
javax.swing.plaf.basic.BasicLabelUI.installDefaults(javax.swing.JLabel)
javax.swing.plaf.basic.BasicListUI.installDefaults()
javax.swing.plaf.basic.BasicMenuBarUI.installDefaults()
javax.swing.plaf.basic.BasicMenuItemUI.installDefaults()
javax.swing.plaf.basic.BasicMenuUI.installDefaults()
javax.swing.plaf.basic.BasicOptionPaneUI.installDefaults()
javax.swing.plaf.basic.BasicPanelUI.installDefaults(javax.swing.JPanel)
javax.swing.plaf.basic.BasicPasswordFieldUI.installDefaults()
javax.swing.plaf.basic.BasicPopupMenuUI.installDefaults()
javax.swing.plaf.basic.BasicProgressBarUI.installDefaults()
javax.swing.plaf.basic.BasicRadioButtonUI.installDefaults(javax.swing.AbstractButton)
javax.swing.plaf.basic.BasicRootPaneUI.installDefaults(javax.swing.JRootPane)
javax.swing.plaf.basic.BasicScrollBarUI.installDefaults()
javax.swing.plaf.basic.BasicScrollPaneUI.installDefaults(javax.swing.JScrollPane)
javax.swing.plaf.basic.BasicSeparatorUI.installDefaults(javax.swing.JSeparator)
javax.swing.plaf.basic.BasicSliderUI.installDefaults(javax.swing.JSlider)
javax.swing.plaf.basic.BasicSpinnerUI.installDefaults()
javax.swing.plaf.basic.BasicSplitPaneUI.installDefaults()
javax.swing.plaf.basic.BasicTabbedPaneUI.installDefaults()
javax.swing.plaf.basic.BasicTableHeaderUI.installDefaults()
javax.swing.plaf.basic.BasicTableUI.installDefaults()
javax.swing.plaf.basic.BasicTextAreaUI.installDefaults()
javax.swing.plaf.basic.BasicTextUI.installDefaults()
javax.swing.plaf.basic.BasicToolBarSeparatorUI.installDefaults(javax.swing.JSeparator)
javax.swing.plaf.basic.BasicToolBarUI.installDefaults()
javax.swing.plaf.basic.BasicToolTipUI.installDefaults(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.installDefaults()
javax.swing.plaf.basic.BasicViewportUI.installDefaults(javax.swing.JComponent)
javax.swing.plaf.metal.MetalButtonUI.installDefaults(javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalCheckBoxUI.installDefaults(javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalDesktopIconUI.installDefaults()
javax.swing.plaf.metal.MetalInternalFrameTitlePane.installDefaults()
javax.swing.plaf.metal.MetalRadioButtonUI.installDefaults(javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalScrollBarUI.installDefaults()
javax.swing.plaf.metal.MetalSeparatorUI.installDefaults(javax.swing.JSeparator)
javax.swing.plaf.metal.MetalTabbedPaneUI.installDefaults()
javax.swing.plaf.metal.MetalToggleButtonUI.installDefaults(javax.swing.AbstractButton)
javax.swing.plaf.synth.SynthStyle.installDefaults(javax.swing.plaf.synth.SynthContext)


Occurences of installKeyboardActions

installKeyboardActions occurences:
javax.swing.plaf.basic.BasicButtonListener.installKeyboardActions(javax.swing.JComponent)
javax.swing.plaf.basic.BasicButtonUI.installKeyboardActions(javax.swing.AbstractButton)
javax.swing.plaf.basic.BasicComboBoxUI.installKeyboardActions()
javax.swing.plaf.basic.BasicComboPopup.installKeyboardActions()
javax.swing.plaf.basic.BasicDesktopPaneUI.installKeyboardActions()
javax.swing.plaf.basic.BasicInternalFrameUI.installKeyboardActions()
javax.swing.plaf.basic.BasicLabelUI.installKeyboardActions(javax.swing.JLabel)
javax.swing.plaf.basic.BasicListUI.installKeyboardActions()
javax.swing.plaf.basic.BasicMenuBarUI.installKeyboardActions()
javax.swing.plaf.basic.BasicMenuItemUI.installKeyboardActions()
javax.swing.plaf.basic.BasicMenuUI.installKeyboardActions()
javax.swing.plaf.basic.BasicOptionPaneUI.installKeyboardActions()
javax.swing.plaf.basic.BasicPopupMenuUI.installKeyboardActions()
javax.swing.plaf.basic.BasicRootPaneUI.installKeyboardActions(javax.swing.JRootPane)
javax.swing.plaf.basic.BasicScrollBarUI.installKeyboardActions()
javax.swing.plaf.basic.BasicScrollPaneUI.installKeyboardActions(javax.swing.JScrollPane)
javax.swing.plaf.basic.BasicSliderUI.installKeyboardActions(javax.swing.JSlider)
javax.swing.plaf.basic.BasicSpinnerUI.installKeyboardActions()
javax.swing.plaf.basic.BasicSplitPaneUI.installKeyboardActions()
javax.swing.plaf.basic.BasicTabbedPaneUI.installKeyboardActions()
javax.swing.plaf.basic.BasicTableHeaderUI.installKeyboardActions()
javax.swing.plaf.basic.BasicTableUI.installKeyboardActions()
javax.swing.plaf.basic.BasicTextUI.installKeyboardActions()
javax.swing.plaf.basic.BasicToolBarUI.installKeyboardActions()
javax.swing.plaf.basic.BasicTreeUI.installKeyboardActions()
javax.swing.plaf.metal.MetalInternalFrameUI.installKeyboardActions()


Occurences of installListeners

installListeners occurences:
javax.swing.plaf.basic.BasicButtonUI.installListeners(javax.swing.AbstractButton)
javax.swing.plaf.basic.BasicColorChooserUI.installListeners()
javax.swing.plaf.basic.BasicComboBoxUI.installListeners()
javax.swing.plaf.basic.BasicDesktopIconUI.installListeners()
javax.swing.plaf.basic.BasicDesktopPaneUI.installListeners()
javax.swing.plaf.basic.BasicFileChooserUI.installListeners(javax.swing.JFileChooser)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.installListeners()
javax.swing.plaf.basic.BasicInternalFrameUI.installListeners()
javax.swing.plaf.basic.BasicLabelUI.installListeners(javax.swing.JLabel)
javax.swing.plaf.basic.BasicListUI.installListeners()
javax.swing.plaf.basic.BasicMenuBarUI.installListeners()
javax.swing.plaf.basic.BasicMenuItemUI.installListeners()
javax.swing.plaf.basic.BasicMenuUI.installListeners()
javax.swing.plaf.basic.BasicOptionPaneUI.installListeners()
javax.swing.plaf.basic.BasicPopupMenuUI.installListeners()
javax.swing.plaf.basic.BasicProgressBarUI.installListeners()
javax.swing.plaf.basic.BasicRootPaneUI.installListeners(javax.swing.JRootPane)
javax.swing.plaf.basic.BasicScrollBarUI.installListeners()
javax.swing.plaf.basic.BasicScrollPaneUI.installListeners(javax.swing.JScrollPane)
javax.swing.plaf.basic.BasicSeparatorUI.installListeners(javax.swing.JSeparator)
javax.swing.plaf.basic.BasicSliderUI.installListeners(javax.swing.JSlider)
javax.swing.plaf.basic.BasicSpinnerUI.installListeners()
javax.swing.plaf.basic.BasicSplitPaneUI.installListeners()
javax.swing.plaf.basic.BasicTabbedPaneUI.installListeners()
javax.swing.plaf.basic.BasicTableHeaderUI.installListeners()
javax.swing.plaf.basic.BasicTableUI.installListeners()
javax.swing.plaf.basic.BasicTextUI.installListeners()
javax.swing.plaf.basic.BasicToolBarUI.installListeners()
javax.swing.plaf.basic.BasicToolTipUI.installListeners(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.installListeners()
javax.swing.plaf.metal.MetalDesktopIconUI.installListeners()
javax.swing.plaf.metal.MetalFileChooserUI.installListeners(javax.swing.JFileChooser)
javax.swing.plaf.metal.MetalInternalFrameUI.installListeners()
javax.swing.plaf.metal.MetalScrollBarUI.installListeners()
javax.swing.plaf.metal.MetalScrollPaneUI.installListeners(javax.swing.JScrollPane)
javax.swing.plaf.metal.MetalToolBarUI.installListeners()


Occurences of installLookAndFeel

installLookAndFeel occurences:
javax.swing.UIManager.installLookAndFeel(java.lang.String, java.lang.String)
javax.swing.UIManager.installLookAndFeel(javax.swing.UIManager.LookAndFeelInfo)


Occurences of installStrings

installStrings occurences:
javax.swing.plaf.basic.BasicFileChooserUI.installStrings(javax.swing.JFileChooser)
javax.swing.plaf.metal.MetalFileChooserUI.installStrings(javax.swing.JFileChooser)


Occurences of installUI

installUI occurences:
javax.swing.plaf.basic.BasicButtonUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicColorChooserUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicComboBoxUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopIconUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicEditorPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicFileChooserUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicInternalFrameUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicLabelUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicListUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuItemUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicOptionPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPanelUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPopupMenuUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicProgressBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicRootPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSeparatorUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSpinnerUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSplitPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTabbedPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableHeaderUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolTipUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.installUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicViewportUI.installUI(javax.swing.JComponent)
javax.swing.plaf.ComponentUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalFileChooserUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalInternalFrameUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalMenuBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalRootPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalSliderUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolTipUI.installUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalTreeUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiButtonUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.installUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.installUI(javax.swing.JComponent)


Occurences of instance

instance occurences:
com.sun.source.util.Trees.instance(javax.annotation.processing.ProcessingEnvironment)
com.sun.source.util.Trees.instance(javax.tools.JavaCompiler.CompilationTask)


Occurences of InstanceAlreadyExistsException (constructors)

InstanceAlreadyExistsException (constructors) occurences:
javax.management.InstanceAlreadyExistsException()
javax.management.InstanceAlreadyExistsException(java.lang.String)


Occurences of InstanceNotFoundException (constructors)

InstanceNotFoundException (constructors) occurences:
javax.management.InstanceNotFoundException()
javax.management.InstanceNotFoundException(java.lang.String)


Occurences of instantiate

instantiate occurences:
java.beans.Beans.instantiate(java.lang.ClassLoader, java.lang.String)
java.beans.Beans.instantiate(java.lang.ClassLoader, java.lang.String, java.beans.beancontext.BeanContext)
java.beans.Beans.instantiate(java.lang.ClassLoader, java.lang.String, java.beans.beancontext.BeanContext, java.beans.AppletInitializer)
java.beans.DefaultPersistenceDelegate.instantiate(java.lang.Object, java.beans.Encoder)
java.beans.PersistenceDelegate.instantiate(java.lang.Object, java.beans.Encoder)
javax.management.MBeanServer.instantiate(java.lang.String)
javax.management.MBeanServer.instantiate(java.lang.String, java.lang.Object[], java.lang.String[])
javax.management.MBeanServer.instantiate(java.lang.String, javax.management.ObjectName)
javax.management.MBeanServer.instantiate(java.lang.String, javax.management.ObjectName, java.lang.Object[], java.lang.String[])


Occurences of instantiateChild

instantiateChild occurences:
java.beans.beancontext.BeanContext.instantiateChild(java.lang.String)
java.beans.beancontext.BeanContextSupport.instantiateChild(java.lang.String)


Occurences of InstantiationError (constructors)

InstantiationError (constructors) occurences:
java.lang.InstantiationError()
java.lang.InstantiationError(java.lang.String)


Occurences of InstantiationException (constructors)

InstantiationException (constructors) occurences:
java.lang.InstantiationException()
java.lang.InstantiationException(java.lang.String)


Occurences of InsufficientResourcesException (constructors)

InsufficientResourcesException (constructors) occurences:
javax.naming.InsufficientResourcesException()
javax.naming.InsufficientResourcesException(java.lang.String)


Occurences of INT

INT occurences:
com.sun.mirror.type.INT
javax.lang.model.type.INT


Occurences of INTEGER

INTEGER occurences:
java.sql.INTEGER
java.text.INTEGER
javax.management.openmbean.INTEGER


Occurences of Integer (constructors)

Integer (constructors) occurences:
java.lang.Integer(int)
java.lang.Integer(java.lang.String)


Occurences of IntegerSyntax (constructors)

IntegerSyntax (constructors) occurences:
javax.print.attribute.IntegerSyntax(int)
javax.print.attribute.IntegerSyntax(int, int, int)


Occurences of interestOps

interestOps occurences:
java.nio.channels.SelectionKey.interestOps()
java.nio.channels.SelectionKey.interestOps(int)


Occurences of INTERFACE

INTERFACE occurences:
java.lang.reflect.INTERFACE
javax.lang.model.element.INTERFACE


Occurences of interfaces

interfaces occurences:
com.sun.javadoc.ClassDoc.interfaces()
com.sun.javadoc.PackageDoc.interfaces()
com.sun.jdi.ClassType.interfaces()
java.security.interfaces
javax.crypto.interfaces


Occurences of InterfaceType

InterfaceType occurences:
com.sun.jdi.InterfaceType
com.sun.mirror.type.InterfaceType


Occurences of interfaceTypes

interfaceTypes occurences:
com.sun.javadoc.ClassDoc.interfaceTypes()
com.sun.javadoc.ParameterizedType.interfaceTypes()


Occurences of INTERNAL (constructors)

INTERNAL (constructors) occurences:
org.omg.CORBA.INTERNAL()
org.omg.CORBA.INTERNAL(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INTERNAL(java.lang.String)
org.omg.CORBA.INTERNAL(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of internalEntityDecl

internalEntityDecl occurences:
org.xml.sax.ext.DeclHandler.internalEntityDecl(java.lang.String, java.lang.String)
org.xml.sax.ext.DefaultHandler2.internalEntityDecl(java.lang.String, java.lang.String)


Occurences of InternalError (constructors)

InternalError (constructors) occurences:
java.lang.InternalError()
java.lang.InternalError(java.lang.String)


Occurences of InternalException (constructors)

InternalException (constructors) occurences:
com.sun.jdi.InternalException()
com.sun.jdi.InternalException(int)
com.sun.jdi.InternalException(java.lang.String)
com.sun.jdi.InternalException(java.lang.String, int)


Occurences of internalFrameActivated

internalFrameActivated occurences:
javax.swing.event.InternalFrameAdapter.internalFrameActivated(javax.swing.event.InternalFrameEvent)
javax.swing.event.InternalFrameListener.internalFrameActivated(javax.swing.event.InternalFrameEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BasicInternalFrameListener.internalFrameActivated(javax.swing.event.InternalFrameEvent)


Occurences of internalFrameClosed

internalFrameClosed occurences:
javax.swing.event.InternalFrameAdapter.internalFrameClosed(javax.swing.event.InternalFrameEvent)
javax.swing.event.InternalFrameListener.internalFrameClosed(javax.swing.event.InternalFrameEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BasicInternalFrameListener.internalFrameClosed(javax.swing.event.InternalFrameEvent)


Occurences of internalFrameClosing

internalFrameClosing occurences:
javax.swing.event.InternalFrameAdapter.internalFrameClosing(javax.swing.event.InternalFrameEvent)
javax.swing.event.InternalFrameListener.internalFrameClosing(javax.swing.event.InternalFrameEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BasicInternalFrameListener.internalFrameClosing(javax.swing.event.InternalFrameEvent)


Occurences of internalFrameDeactivated

internalFrameDeactivated occurences:
javax.swing.event.InternalFrameAdapter.internalFrameDeactivated(javax.swing.event.InternalFrameEvent)
javax.swing.event.InternalFrameListener.internalFrameDeactivated(javax.swing.event.InternalFrameEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BasicInternalFrameListener.internalFrameDeactivated(javax.swing.event.InternalFrameEvent)


Occurences of internalFrameDeiconified

internalFrameDeiconified occurences:
javax.swing.event.InternalFrameAdapter.internalFrameDeiconified(javax.swing.event.InternalFrameEvent)
javax.swing.event.InternalFrameListener.internalFrameDeiconified(javax.swing.event.InternalFrameEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BasicInternalFrameListener.internalFrameDeiconified(javax.swing.event.InternalFrameEvent)


Occurences of internalFrameIconified

internalFrameIconified occurences:
javax.swing.event.InternalFrameAdapter.internalFrameIconified(javax.swing.event.InternalFrameEvent)
javax.swing.event.InternalFrameListener.internalFrameIconified(javax.swing.event.InternalFrameEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BasicInternalFrameListener.internalFrameIconified(javax.swing.event.InternalFrameEvent)


Occurences of internalFrameOpened

internalFrameOpened occurences:
javax.swing.event.InternalFrameAdapter.internalFrameOpened(javax.swing.event.InternalFrameEvent)
javax.swing.event.InternalFrameListener.internalFrameOpened(javax.swing.event.InternalFrameEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BasicInternalFrameListener.internalFrameOpened(javax.swing.event.InternalFrameEvent)


Occurences of INTERNAL_FRAME

INTERNAL_FRAME occurences:
javax.accessibility.INTERNAL_FRAME
javax.swing.plaf.synth.INTERNAL_FRAME


Occurences of InternationalFormatter (constructors)

InternationalFormatter (constructors) occurences:
javax.swing.text.InternationalFormatter()
javax.swing.text.InternationalFormatter(java.text.Format)


Occurences of interrupt

interrupt occurences:
com.sun.jdi.ThreadReference.interrupt()
java.lang.Thread.interrupt()
java.lang.ThreadGroup.interrupt()


Occurences of InterruptedException (constructors)

InterruptedException (constructors) occurences:
java.lang.InterruptedException()
java.lang.InterruptedException(java.lang.String)


Occurences of InterruptedIOException (constructors)

InterruptedIOException (constructors) occurences:
java.io.InterruptedIOException()
java.io.InterruptedIOException(java.lang.String)


Occurences of InterruptedNamingException (constructors)

InterruptedNamingException (constructors) occurences:
javax.naming.InterruptedNamingException()
javax.naming.InterruptedNamingException(java.lang.String)


Occurences of intersect

intersect occurences:
java.awt.geom.Area.intersect(java.awt.geom.Area)
java.awt.geom.Rectangle2D.intersect(java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D)


Occurences of intersects

intersects occurences:
java.awt.geom.Arc2D.intersects(double, double, double, double)
java.awt.geom.Area.intersects(double, double, double, double)
java.awt.geom.Area.intersects(java.awt.geom.Rectangle2D)
java.awt.geom.CubicCurve2D.intersects(double, double, double, double)
java.awt.geom.CubicCurve2D.intersects(java.awt.geom.Rectangle2D)
java.awt.geom.Ellipse2D.intersects(double, double, double, double)
java.awt.geom.Line2D.intersects(double, double, double, double)
java.awt.geom.Line2D.intersects(java.awt.geom.Rectangle2D)
java.awt.geom.Path2D.intersects(double, double, double, double)
java.awt.geom.Path2D.intersects(java.awt.geom.PathIterator, double, double, double, double)
java.awt.geom.Path2D.intersects(java.awt.geom.PathIterator, java.awt.geom.Rectangle2D)
java.awt.geom.Path2D.intersects(java.awt.geom.Rectangle2D)
java.awt.geom.QuadCurve2D.intersects(double, double, double, double)
java.awt.geom.QuadCurve2D.intersects(java.awt.geom.Rectangle2D)
java.awt.geom.Rectangle2D.intersects(double, double, double, double)
java.awt.geom.RectangularShape.intersects(java.awt.geom.Rectangle2D)
java.awt.geom.RoundRectangle2D.intersects(double, double, double, double)
java.awt.Polygon.intersects(double, double, double, double)
java.awt.Polygon.intersects(java.awt.geom.Rectangle2D)
java.awt.Rectangle.intersects(java.awt.Rectangle)
java.awt.Shape.intersects(double, double, double, double)
java.awt.Shape.intersects(java.awt.geom.Rectangle2D)
java.util.BitSet.intersects(java.util.BitSet)


Occurences of intersectsLine

intersectsLine occurences:
java.awt.geom.Line2D.intersectsLine(double, double, double, double)
java.awt.geom.Line2D.intersectsLine(java.awt.geom.Line2D)
java.awt.geom.Rectangle2D.intersectsLine(double, double, double, double)
java.awt.geom.Rectangle2D.intersectsLine(java.awt.geom.Line2D)


Occurences of intervalAdded

intervalAdded occurences:
javax.swing.event.ListDataListener.intervalAdded(javax.swing.event.ListDataEvent)
javax.swing.JComboBox.intervalAdded(javax.swing.event.ListDataEvent)
javax.swing.JList.AccessibleJList.intervalAdded(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicComboBoxUI.ListDataHandler.intervalAdded(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicComboPopup.ListDataHandler.intervalAdded(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicDirectoryModel.intervalAdded(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicListUI.ListDataHandler.intervalAdded(javax.swing.event.ListDataEvent)


Occurences of intervalRemoved

intervalRemoved occurences:
javax.swing.event.ListDataListener.intervalRemoved(javax.swing.event.ListDataEvent)
javax.swing.JComboBox.intervalRemoved(javax.swing.event.ListDataEvent)
javax.swing.JList.AccessibleJList.intervalRemoved(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicComboBoxUI.ListDataHandler.intervalRemoved(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicComboPopup.ListDataHandler.intervalRemoved(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicDirectoryModel.intervalRemoved(javax.swing.event.ListDataEvent)
javax.swing.plaf.basic.BasicListUI.ListDataHandler.intervalRemoved(javax.swing.event.ListDataEvent)


Occurences of INTF_REPOS (constructors)

INTF_REPOS (constructors) occurences:
org.omg.CORBA.INTF_REPOS()
org.omg.CORBA.INTF_REPOS(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INTF_REPOS(java.lang.String)
org.omg.CORBA.INTF_REPOS(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of IntHolder (constructors)

IntHolder (constructors) occurences:
org.omg.CORBA.IntHolder()
org.omg.CORBA.IntHolder(int)


Occurences of Introduction

Introduction occurences:
Introduction
Introduction
Introduction


Occurences of IntrospectionException

IntrospectionException occurences:
java.beans.IntrospectionException
javax.management.IntrospectionException


Occurences of IntrospectionException (constructors)

IntrospectionException (constructors) occurences:
java.beans.IntrospectionException(java.lang.String)
javax.management.IntrospectionException()
javax.management.IntrospectionException(java.lang.String)


Occurences of intValue

intValue occurences:
com.sun.jdi.connect.Connector.IntegerArgument.intValue()
com.sun.jdi.PrimitiveValue.intValue()
java.lang.Byte.intValue()
java.lang.Double.intValue()
java.lang.Float.intValue()
java.lang.Integer.intValue()
java.lang.Long.intValue()
java.lang.Number.intValue()
java.lang.Short.intValue()
java.math.BigDecimal.intValue()
java.math.BigInteger.intValue()
java.util.concurrent.atomic.AtomicInteger.intValue()
java.util.concurrent.atomic.AtomicLong.intValue()
java.util.logging.Level.intValue()


Occurences of Invalid (constructors)

Invalid (constructors) occurences:
org.omg.CORBA.DynAnyPackage.Invalid()
org.omg.CORBA.DynAnyPackage.Invalid(java.lang.String)


Occurences of InvalidActivityException (constructors)

InvalidActivityException (constructors) occurences:
javax.activity.InvalidActivityException()
javax.activity.InvalidActivityException(java.lang.String)
javax.activity.InvalidActivityException(java.lang.String, java.lang.Throwable)
javax.activity.InvalidActivityException(java.lang.Throwable)


Occurences of InvalidAddress (constructors)

InvalidAddress (constructors) occurences:
org.omg.CosNaming.NamingContextExtPackage.InvalidAddress()
org.omg.CosNaming.NamingContextExtPackage.InvalidAddress(java.lang.String)


Occurences of InvalidAddressHolder (constructors)

InvalidAddressHolder (constructors) occurences:
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHolder()
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHolder(org.omg.CosNaming.NamingContextExtPackage.InvalidAddress)


Occurences of InvalidAlgorithmParameterException (constructors)

InvalidAlgorithmParameterException (constructors) occurences:
java.security.InvalidAlgorithmParameterException()
java.security.InvalidAlgorithmParameterException(java.lang.String)
java.security.InvalidAlgorithmParameterException(java.lang.String, java.lang.Throwable)
java.security.InvalidAlgorithmParameterException(java.lang.Throwable)


Occurences of invalidate

invalidate occurences:
java.awt.Component.invalidate()
java.awt.Container.invalidate()
java.awt.Polygon.invalidate()
javax.net.ssl.SSLSession.invalidate()
javax.swing.CellRendererPane.invalidate()
javax.swing.DefaultListCellRenderer.invalidate()
javax.swing.table.DefaultTableCellRenderer.invalidate()
javax.swing.tree.DefaultTreeCellRenderer.invalidate()


Occurences of invalidateLayout

invalidateLayout occurences:
java.awt.BorderLayout.invalidateLayout(java.awt.Container)
java.awt.CardLayout.invalidateLayout(java.awt.Container)
java.awt.GridBagLayout.invalidateLayout(java.awt.Container)
java.awt.LayoutManager2.invalidateLayout(java.awt.Container)
javax.swing.BoxLayout.invalidateLayout(java.awt.Container)
javax.swing.GroupLayout.invalidateLayout(java.awt.Container)
javax.swing.JRootPane.RootLayout.invalidateLayout(java.awt.Container)
javax.swing.OverlayLayout.invalidateLayout(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.invalidateLayout(java.awt.Container)
javax.swing.SpringLayout.invalidateLayout(java.awt.Container)


Occurences of invalidatePathBounds

invalidatePathBounds occurences:
javax.swing.tree.AbstractLayoutCache.invalidatePathBounds(javax.swing.tree.TreePath)
javax.swing.tree.FixedHeightLayoutCache.invalidatePathBounds(javax.swing.tree.TreePath)
javax.swing.tree.VariableHeightLayoutCache.invalidatePathBounds(javax.swing.tree.TreePath)


Occurences of invalidateSizes

invalidateSizes occurences:
javax.swing.tree.AbstractLayoutCache.invalidateSizes()
javax.swing.tree.FixedHeightLayoutCache.invalidateSizes()
javax.swing.tree.VariableHeightLayoutCache.invalidateSizes()


Occurences of InvalidAttributeIdentifierException (constructors)

InvalidAttributeIdentifierException (constructors) occurences:
javax.naming.directory.InvalidAttributeIdentifierException()
javax.naming.directory.InvalidAttributeIdentifierException(java.lang.String)


Occurences of InvalidAttributesException (constructors)

InvalidAttributesException (constructors) occurences:
javax.naming.directory.InvalidAttributesException()
javax.naming.directory.InvalidAttributesException(java.lang.String)


Occurences of InvalidAttributeValueException

InvalidAttributeValueException occurences:
javax.management.InvalidAttributeValueException
javax.naming.directory.InvalidAttributeValueException


Occurences of InvalidAttributeValueException (constructors)

InvalidAttributeValueException (constructors) occurences:
javax.management.InvalidAttributeValueException()
javax.management.InvalidAttributeValueException(java.lang.String)
javax.naming.directory.InvalidAttributeValueException()
javax.naming.directory.InvalidAttributeValueException(java.lang.String)


Occurences of InvalidClassException (constructors)

InvalidClassException (constructors) occurences:
java.io.InvalidClassException(java.lang.String)
java.io.InvalidClassException(java.lang.String, java.lang.String)


Occurences of InvalidCodeIndexException (constructors)

InvalidCodeIndexException (constructors) occurences:
com.sun.jdi.InvalidCodeIndexException()
com.sun.jdi.InvalidCodeIndexException(java.lang.String)


Occurences of InvalidDnDOperationException (constructors)

InvalidDnDOperationException (constructors) occurences:
java.awt.dnd.InvalidDnDOperationException()
java.awt.dnd.InvalidDnDOperationException(java.lang.String)


Occurences of invalidEdit

invalidEdit occurences:
javax.swing.JFormattedTextField.invalidEdit()
javax.swing.JFormattedTextField.AbstractFormatter.invalidEdit()


Occurences of InvalidKeyException

InvalidKeyException occurences:
java.security.InvalidKeyException
javax.management.openmbean.InvalidKeyException


Occurences of InvalidKeyException (constructors)

InvalidKeyException (constructors) occurences:
java.security.InvalidKeyException()
java.security.InvalidKeyException(java.lang.String)
java.security.InvalidKeyException(java.lang.String, java.lang.Throwable)
java.security.InvalidKeyException(java.lang.Throwable)
javax.management.openmbean.InvalidKeyException()
javax.management.openmbean.InvalidKeyException(java.lang.String)


Occurences of InvalidKeySpecException (constructors)

InvalidKeySpecException (constructors) occurences:
java.security.spec.InvalidKeySpecException()
java.security.spec.InvalidKeySpecException(java.lang.String)
java.security.spec.InvalidKeySpecException(java.lang.String, java.lang.Throwable)
java.security.spec.InvalidKeySpecException(java.lang.Throwable)


Occurences of InvalidLineNumberException (constructors)

InvalidLineNumberException (constructors) occurences:
com.sun.jdi.InvalidLineNumberException()
com.sun.jdi.InvalidLineNumberException(java.lang.String)


Occurences of InvalidMidiDataException (constructors)

InvalidMidiDataException (constructors) occurences:
javax.sound.midi.InvalidMidiDataException()
javax.sound.midi.InvalidMidiDataException(java.lang.String)


Occurences of InvalidName

InvalidName occurences:
org.omg.CORBA.ORBPackage.InvalidName
org.omg.CosNaming.NamingContextPackage.InvalidName
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidName


Occurences of InvalidName (constructors)

InvalidName (constructors) occurences:
org.omg.CORBA.ORBPackage.InvalidName()
org.omg.CORBA.ORBPackage.InvalidName(java.lang.String)
org.omg.CosNaming.NamingContextPackage.InvalidName()
org.omg.CosNaming.NamingContextPackage.InvalidName(java.lang.String)
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidName()
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidName(java.lang.String)


Occurences of InvalidNameException (constructors)

InvalidNameException (constructors) occurences:
javax.naming.InvalidNameException()
javax.naming.InvalidNameException(java.lang.String)


Occurences of InvalidNameHelper

InvalidNameHelper occurences:
org.omg.CosNaming.NamingContextPackage.InvalidNameHelper
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidNameHelper


Occurences of InvalidNameHelper (constructors)

InvalidNameHelper (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.InvalidNameHelper()
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidNameHelper()


Occurences of InvalidNameHolder (constructors)

InvalidNameHolder (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.InvalidNameHolder()
org.omg.CosNaming.NamingContextPackage.InvalidNameHolder(org.omg.CosNaming.NamingContextPackage.InvalidName)


Occurences of InvalidOpenTypeException (constructors)

InvalidOpenTypeException (constructors) occurences:
javax.management.openmbean.InvalidOpenTypeException()
javax.management.openmbean.InvalidOpenTypeException(java.lang.String)


Occurences of InvalidParameterException (constructors)

InvalidParameterException (constructors) occurences:
java.security.InvalidParameterException()
java.security.InvalidParameterException(java.lang.String)


Occurences of InvalidParameterSpecException (constructors)

InvalidParameterSpecException (constructors) occurences:
java.security.spec.InvalidParameterSpecException()
java.security.spec.InvalidParameterSpecException(java.lang.String)


Occurences of InvalidPolicy (constructors)

InvalidPolicy (constructors) occurences:
org.omg.PortableServer.POAPackage.InvalidPolicy()
org.omg.PortableServer.POAPackage.InvalidPolicy(java.lang.String, short)
org.omg.PortableServer.POAPackage.InvalidPolicy(short)


Occurences of InvalidPreferencesFormatException (constructors)

InvalidPreferencesFormatException (constructors) occurences:
java.util.prefs.InvalidPreferencesFormatException(java.lang.String)
java.util.prefs.InvalidPreferencesFormatException(java.lang.String, java.lang.Throwable)
java.util.prefs.InvalidPreferencesFormatException(java.lang.Throwable)


Occurences of InvalidPropertiesFormatException (constructors)

InvalidPropertiesFormatException (constructors) occurences:
java.util.InvalidPropertiesFormatException(java.lang.String)
java.util.InvalidPropertiesFormatException(java.lang.Throwable)


Occurences of InvalidRelationIdException (constructors)

InvalidRelationIdException (constructors) occurences:
javax.management.relation.InvalidRelationIdException()
javax.management.relation.InvalidRelationIdException(java.lang.String)


Occurences of InvalidRelationServiceException (constructors)

InvalidRelationServiceException (constructors) occurences:
javax.management.relation.InvalidRelationServiceException()
javax.management.relation.InvalidRelationServiceException(java.lang.String)


Occurences of InvalidRelationTypeException (constructors)

InvalidRelationTypeException (constructors) occurences:
javax.management.relation.InvalidRelationTypeException()
javax.management.relation.InvalidRelationTypeException(java.lang.String)


Occurences of InvalidRequestStateException (constructors)

InvalidRequestStateException (constructors) occurences:
com.sun.jdi.request.InvalidRequestStateException()
com.sun.jdi.request.InvalidRequestStateException(java.lang.String)


Occurences of InvalidRoleInfoException (constructors)

InvalidRoleInfoException (constructors) occurences:
javax.management.relation.InvalidRoleInfoException()
javax.management.relation.InvalidRoleInfoException(java.lang.String)


Occurences of InvalidRoleValueException (constructors)

InvalidRoleValueException (constructors) occurences:
javax.management.relation.InvalidRoleValueException()
javax.management.relation.InvalidRoleValueException(java.lang.String)


Occurences of InvalidSearchControlsException (constructors)

InvalidSearchControlsException (constructors) occurences:
javax.naming.directory.InvalidSearchControlsException()
javax.naming.directory.InvalidSearchControlsException(java.lang.String)


Occurences of InvalidSearchFilterException (constructors)

InvalidSearchFilterException (constructors) occurences:
javax.naming.directory.InvalidSearchFilterException()
javax.naming.directory.InvalidSearchFilterException(java.lang.String)


Occurences of InvalidSeq (constructors)

InvalidSeq (constructors) occurences:
org.omg.CORBA.DynAnyPackage.InvalidSeq()
org.omg.CORBA.DynAnyPackage.InvalidSeq(java.lang.String)


Occurences of InvalidSlot (constructors)

InvalidSlot (constructors) occurences:
org.omg.PortableInterceptor.InvalidSlot()
org.omg.PortableInterceptor.InvalidSlot(java.lang.String)


Occurences of InvalidStackFrameException (constructors)

InvalidStackFrameException (constructors) occurences:
com.sun.jdi.InvalidStackFrameException()
com.sun.jdi.InvalidStackFrameException(java.lang.String)


Occurences of InvalidTargetObjectTypeException (constructors)

InvalidTargetObjectTypeException (constructors) occurences:
javax.management.modelmbean.InvalidTargetObjectTypeException()
javax.management.modelmbean.InvalidTargetObjectTypeException(java.lang.Exception, java.lang.String)
javax.management.modelmbean.InvalidTargetObjectTypeException(java.lang.String)


Occurences of InvalidTransactionException (constructors)

InvalidTransactionException (constructors) occurences:
javax.transaction.InvalidTransactionException()
javax.transaction.InvalidTransactionException(java.lang.String)


Occurences of InvalidTypeException (constructors)

InvalidTypeException (constructors) occurences:
com.sun.jdi.InvalidTypeException()
com.sun.jdi.InvalidTypeException(java.lang.String)


Occurences of InvalidTypeForEncoding (constructors)

InvalidTypeForEncoding (constructors) occurences:
org.omg.IOP.CodecPackage.InvalidTypeForEncoding()
org.omg.IOP.CodecPackage.InvalidTypeForEncoding(java.lang.String)


Occurences of InvalidValue

InvalidValue occurences:
org.omg.CORBA.DynAnyPackage.InvalidValue
org.omg.DynamicAny.DynAnyPackage.InvalidValue


Occurences of InvalidValue (constructors)

InvalidValue (constructors) occurences:
org.omg.CORBA.DynAnyPackage.InvalidValue()
org.omg.CORBA.DynAnyPackage.InvalidValue(java.lang.String)
org.omg.DynamicAny.DynAnyPackage.InvalidValue()
org.omg.DynamicAny.DynAnyPackage.InvalidValue(java.lang.String)


Occurences of INVALID_ACTIVITY (constructors)

INVALID_ACTIVITY (constructors) occurences:
org.omg.CORBA.INVALID_ACTIVITY()
org.omg.CORBA.INVALID_ACTIVITY(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INVALID_ACTIVITY(java.lang.String)
org.omg.CORBA.INVALID_ACTIVITY(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of INVALID_TRANSACTION (constructors)

INVALID_TRANSACTION (constructors) occurences:
org.omg.CORBA.INVALID_TRANSACTION()
org.omg.CORBA.INVALID_TRANSACTION(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INVALID_TRANSACTION(java.lang.String)
org.omg.CORBA.INVALID_TRANSACTION(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of inverseTransform

inverseTransform occurences:
java.awt.geom.AffineTransform.inverseTransform(double[], int, double[], int, int)
java.awt.geom.AffineTransform.inverseTransform(java.awt.geom.Point2D, java.awt.geom.Point2D)


Occurences of InvocationEvent (constructors)

InvocationEvent (constructors) occurences:
java.awt.event.InvocationEvent(java.lang.Object, int, java.lang.Runnable, java.lang.Object, boolean)
java.awt.event.InvocationEvent(java.lang.Object, java.lang.Runnable)
java.awt.event.InvocationEvent(java.lang.Object, java.lang.Runnable, java.lang.Object, boolean)


Occurences of InvocationTargetException (constructors)

InvocationTargetException (constructors) occurences:
java.lang.reflect.InvocationTargetException()
java.lang.reflect.InvocationTargetException(java.lang.Throwable)
java.lang.reflect.InvocationTargetException(java.lang.Throwable, java.lang.String)


Occurences of INVOICE

INVOICE occurences:
java.awt.INVOICE
javax.print.attribute.standard.INVOICE
javax.print.attribute.standard.INVOICE


Occurences of invoke

invoke occurences:
java.beans.EventHandler.invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
java.lang.reflect.InvocationHandler.invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
java.lang.reflect.Method.invoke(java.lang.Object, java.lang.Object...)
java.rmi.server.RemoteObjectInvocationHandler.invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
java.rmi.server.RemoteRef.invoke(java.rmi.Remote, java.lang.reflect.Method, java.lang.Object[], long)
java.rmi.server.RemoteRef.invoke(java.rmi.server.RemoteCall)
javax.management.DynamicMBean.invoke(java.lang.String, java.lang.Object[], java.lang.String[])
javax.management.MBeanServer.invoke(javax.management.ObjectName, java.lang.String, java.lang.Object[], java.lang.String[])
javax.management.MBeanServerConnection.invoke(javax.management.ObjectName, java.lang.String, java.lang.Object[], java.lang.String[])
javax.management.MBeanServerInvocationHandler.invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
javax.management.modelmbean.RequiredModelMBean.invoke(java.lang.String, java.lang.Object[], java.lang.String[])
javax.management.openmbean.CompositeDataInvocationHandler.invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
javax.management.remote.rmi.RMIConnection.invoke(javax.management.ObjectName, java.lang.String, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.invoke(javax.management.ObjectName, java.lang.String, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.invoke(javax.management.ObjectName, java.lang.String, java.rmi.MarshalledObject, java.lang.String[], javax.security.auth.Subject)
javax.management.StandardMBean.invoke(java.lang.String, java.lang.Object[], java.lang.String[])
javax.xml.ws.Dispatch.invoke(java.lang.Object)
javax.xml.ws.Dispatch.invoke(T)
javax.xml.ws.Provider.invoke(java.lang.Object)
javax.xml.ws.Provider.invoke(T)
org.omg.CORBA.DynamicImplementation.invoke(org.omg.CORBA.ServerRequest)
org.omg.CORBA.portable.Delegate.invoke(org.omg.CORBA.Object, org.omg.CORBA.portable.OutputStream)
org.omg.CORBA.Request.invoke()
org.omg.CosNaming._BindingIteratorImplBase.invoke(org.omg.CORBA.ServerRequest)
org.omg.CosNaming._NamingContextImplBase.invoke(org.omg.CORBA.ServerRequest)
org.omg.PortableServer.DynamicImplementation.invoke(org.omg.CORBA.ServerRequest)


Occurences of invokeAll

invokeAll occurences:
java.util.concurrent.AbstractExecutorService.invokeAll(java.util.Collection)
java.util.concurrent.AbstractExecutorService.invokeAll(java.util.Collection, long, java.util.concurrent.TimeUnit)
java.util.concurrent.ExecutorService.invokeAll(java.util.Collection)
java.util.concurrent.ExecutorService.invokeAll(java.util.Collection, long, java.util.concurrent.TimeUnit)


Occurences of invokeAndWait

invokeAndWait occurences:
java.awt.EventQueue.invokeAndWait(java.lang.Runnable)
javax.swing.SwingUtilities.invokeAndWait(java.lang.Runnable)


Occurences of invokeAny

invokeAny occurences:
java.util.concurrent.AbstractExecutorService.invokeAny(java.util.Collection)
java.util.concurrent.AbstractExecutorService.invokeAny(java.util.Collection, long, java.util.concurrent.TimeUnit)
java.util.concurrent.ExecutorService.invokeAny(java.util.Collection)
java.util.concurrent.ExecutorService.invokeAny(java.util.Collection, long, java.util.concurrent.TimeUnit)


Occurences of invokeAsync

invokeAsync occurences:
javax.xml.ws.Dispatch.invokeAsync(java.lang.Object)
javax.xml.ws.Dispatch.invokeAsync(java.lang.Object,javax.xml.ws.AsyncHandler)
javax.xml.ws.Dispatch.invokeAsync(T)
javax.xml.ws.Dispatch.invokeAsync(T, javax.xml.ws.AsyncHandler)


Occurences of invokeLater

invokeLater occurences:
java.awt.EventQueue.invokeLater(java.lang.Runnable)
javax.swing.SwingUtilities.invokeLater(java.lang.Runnable)


Occurences of invokeMethod

invokeMethod occurences:
com.sun.jdi.ClassType.invokeMethod(com.sun.jdi.ThreadReference, com.sun.jdi.Method, java.util.List, int)
com.sun.jdi.ObjectReference.invokeMethod(com.sun.jdi.ThreadReference, com.sun.jdi.Method, java.util.List, int)
javax.script.Invocable.invokeMethod(java.lang.Object, java.lang.String, java.lang.Object...)


Occurences of invokeOneWay

invokeOneWay occurences:
javax.xml.ws.Dispatch.invokeOneWay(java.lang.Object)
javax.xml.ws.Dispatch.invokeOneWay(T)


Occurences of INVOKE_SINGLE_THREADED

INVOKE_SINGLE_THREADED occurences:
com.sun.jdi.INVOKE_SINGLE_THREADED
com.sun.jdi.INVOKE_SINGLE_THREADED


Occurences of INV_FLAG (constructors)

INV_FLAG (constructors) occurences:
org.omg.CORBA.INV_FLAG()
org.omg.CORBA.INV_FLAG(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INV_FLAG(java.lang.String)
org.omg.CORBA.INV_FLAG(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of INV_IDENT (constructors)

INV_IDENT (constructors) occurences:
org.omg.CORBA.INV_IDENT()
org.omg.CORBA.INV_IDENT(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INV_IDENT(java.lang.String)
org.omg.CORBA.INV_IDENT(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of INV_OBJREF (constructors)

INV_OBJREF (constructors) occurences:
org.omg.CORBA.INV_OBJREF()
org.omg.CORBA.INV_OBJREF(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INV_OBJREF(java.lang.String)
org.omg.CORBA.INV_OBJREF(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of INV_POLICY (constructors)

INV_POLICY (constructors) occurences:
org.omg.CORBA.INV_POLICY()
org.omg.CORBA.INV_POLICY(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.INV_POLICY(java.lang.String)
org.omg.CORBA.INV_POLICY(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of ioException

ioException occurences:
java.util.Formatter.ioException()
java.util.Scanner.ioException()


Occurences of IOException (constructors)

IOException (constructors) occurences:
java.io.IOException()
java.io.IOException(java.lang.String)
java.io.IOException(java.lang.String, java.lang.Throwable)
java.io.IOException(java.lang.Throwable)


Occurences of IOR (constructors)

IOR (constructors) occurences:
org.omg.IOP.IOR()
org.omg.IOP.IOR(java.lang.String, org.omg.IOP.TaggedProfile[])


Occurences of IORHolder (constructors)

IORHolder (constructors) occurences:
org.omg.IOP.IORHolder()
org.omg.IOP.IORHolder(org.omg.IOP.IOR)


Occurences of IORInterceptor_3_0Holder (constructors)

IORInterceptor_3_0Holder (constructors) occurences:
org.omg.PortableInterceptor.IORInterceptor_3_0Holder()
org.omg.PortableInterceptor.IORInterceptor_3_0Holder(org.omg.PortableInterceptor.IORInterceptor_3_0)


Occurences of isAbsolute

isAbsolute occurences:
java.io.File.isAbsolute()
java.net.URI.isAbsolute()


Occurences of isAbstract

isAbstract occurences:
com.sun.javadoc.ClassDoc.isAbstract()
com.sun.javadoc.MethodDoc.isAbstract()
com.sun.jdi.Method.isAbstract()
com.sun.jdi.ReferenceType.isAbstract()
java.lang.reflect.Modifier.isAbstract(int)


Occurences of isAccessible

isAccessible occurences:
com.sun.source.util.Trees.isAccessible(com.sun.source.tree.Scope, javax.lang.model.element.Element, javax.lang.model.type.DeclaredType)
com.sun.source.util.Trees.isAccessible(com.sun.source.tree.Scope, javax.lang.model.element.TypeElement)
java.lang.reflect.AccessibleObject.isAccessible()


Occurences of isAccessibleChildSelected

isAccessibleChildSelected occurences:
java.awt.List.AccessibleAWTList.isAccessibleChildSelected(int)
java.awt.MenuComponent.AccessibleAWTMenuComponent.isAccessibleChildSelected(int)
javax.accessibility.AccessibleSelection.isAccessibleChildSelected(int)
javax.swing.JComboBox.AccessibleJComboBox.isAccessibleChildSelected(int)
javax.swing.JList.AccessibleJList.isAccessibleChildSelected(int)
javax.swing.JMenu.AccessibleJMenu.isAccessibleChildSelected(int)
javax.swing.JMenuBar.AccessibleJMenuBar.isAccessibleChildSelected(int)
javax.swing.JTabbedPane.AccessibleJTabbedPane.isAccessibleChildSelected(int)
javax.swing.JTable.AccessibleJTable.isAccessibleChildSelected(int)
javax.swing.JTree.AccessibleJTree.isAccessibleChildSelected(int)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.isAccessibleChildSelected(int)


Occurences of isAccessibleColumnSelected

isAccessibleColumnSelected occurences:
javax.accessibility.AccessibleTable.isAccessibleColumnSelected(int)
javax.swing.JTable.AccessibleJTable.isAccessibleColumnSelected(int)


Occurences of isAccessibleRowSelected

isAccessibleRowSelected occurences:
javax.accessibility.AccessibleTable.isAccessibleRowSelected(int)
javax.swing.JTable.AccessibleJTable.isAccessibleRowSelected(int)


Occurences of isAccessibleSelected

isAccessibleSelected occurences:
javax.accessibility.AccessibleTable.isAccessibleSelected(int, int)
javax.swing.JTable.AccessibleJTable.isAccessibleSelected(int, int)


Occurences of isActive

isActive occurences:
java.applet.Applet.isActive()
java.applet.AppletStub.isActive()
java.awt.dnd.DropTarget.isActive()
java.awt.Window.isActive()
javax.management.monitor.Monitor.isActive()
javax.management.monitor.MonitorMBean.isActive()
javax.management.relation.RelationService.isActive()
javax.management.relation.RelationServiceMBean.isActive()
javax.management.remote.JMXConnectorServerMBean.isActive()
javax.management.remote.rmi.RMIConnectorServer.isActive()
javax.management.timer.Timer.isActive()
javax.management.timer.TimerMBean.isActive()
javax.sound.sampled.DataLine.isActive()
javax.swing.text.DefaultCaret.isActive()


Occurences of isAddedPath

isAddedPath occurences:
javax.swing.event.TreeSelectionEvent.isAddedPath()
javax.swing.event.TreeSelectionEvent.isAddedPath(int)
javax.swing.event.TreeSelectionEvent.isAddedPath(javax.swing.tree.TreePath)


Occurences of isAfter

isAfter occurences:
javax.swing.text.BoxView.isAfter(int, int, java.awt.Rectangle)
javax.swing.text.CompositeView.isAfter(int, int, java.awt.Rectangle)


Occurences of isAlphaPremultiplied

isAlphaPremultiplied occurences:
java.awt.image.BufferedImage.isAlphaPremultiplied()
java.awt.image.ColorModel.isAlphaPremultiplied()


Occurences of isAlwaysOnTopSupported

isAlwaysOnTopSupported occurences:
java.awt.Toolkit.isAlwaysOnTopSupported()
java.awt.Window.isAlwaysOnTopSupported()


Occurences of isAnnotationPresent

isAnnotationPresent occurences:
java.lang.Class.isAnnotationPresent(java.lang.Class)
java.lang.Package.isAnnotationPresent(java.lang.Class)
java.lang.reflect.AccessibleObject.isAnnotationPresent(java.lang.Class)
java.lang.reflect.AnnotatedElement.isAnnotationPresent(java.lang.Class)


Occurences of isAnyLocalAddress

isAnyLocalAddress occurences:
java.net.Inet4Address.isAnyLocalAddress()
java.net.Inet6Address.isAnyLocalAddress()
java.net.InetAddress.isAnyLocalAddress()


Occurences of isArmed

isArmed occurences:
javax.swing.ButtonModel.isArmed()
javax.swing.DefaultButtonModel.isArmed()
javax.swing.JMenuItem.isArmed()


Occurences of isArray

isArray occurences:
java.lang.Class.isArray()
javax.management.openmbean.OpenType.isArray()


Occurences of isAssignable

isAssignable occurences:
com.sun.mirror.util.Types.isAssignable(com.sun.mirror.type.TypeMirror, com.sun.mirror.type.TypeMirror)
javax.lang.model.util.Types.isAssignable(javax.lang.model.type.TypeMirror, javax.lang.model.type.TypeMirror)


Occurences of isAttributeRequired

isAttributeRequired occurences:
javax.imageio.metadata.IIOMetadataFormat.isAttributeRequired(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataFormatImpl.isAttributeRequired(java.lang.String, java.lang.String)


Occurences of isAttributeSpecified

isAttributeSpecified occurences:
javax.xml.stream.util.StreamReaderDelegate.isAttributeSpecified(int)
javax.xml.stream.XMLStreamReader.isAttributeSpecified(int)


Occurences of isAutoIncrement

isAutoIncrement occurences:
java.sql.ResultSetMetaData.isAutoIncrement(int)
javax.sql.rowset.RowSetMetaDataImpl.isAutoIncrement(int)


Occurences of isBefore

isBefore occurences:
javax.swing.text.BoxView.isBefore(int, int, java.awt.Rectangle)
javax.swing.text.CompositeView.isBefore(int, int, java.awt.Rectangle)


Occurences of isBlocking

isBlocking occurences:
java.nio.channels.SelectableChannel.isBlocking()
java.nio.channels.spi.AbstractSelectableChannel.isBlocking()


Occurences of isBold

isBold occurences:
java.awt.Font.isBold()
javax.swing.text.StyleConstants.isBold(javax.swing.text.AttributeSet)


Occurences of isBorderOpaque

isBorderOpaque occurences:
javax.swing.border.AbstractBorder.isBorderOpaque()
javax.swing.border.BevelBorder.isBorderOpaque()
javax.swing.border.Border.isBorderOpaque()
javax.swing.border.CompoundBorder.isBorderOpaque()
javax.swing.border.EmptyBorder.isBorderOpaque()
javax.swing.border.EtchedBorder.isBorderOpaque()
javax.swing.border.LineBorder.isBorderOpaque()
javax.swing.border.MatteBorder.isBorderOpaque()
javax.swing.border.SoftBevelBorder.isBorderOpaque()
javax.swing.border.TitledBorder.isBorderOpaque()
javax.swing.plaf.basic.BasicBorders.SplitPaneBorder.isBorderOpaque()
javax.swing.plaf.BorderUIResource.isBorderOpaque()


Occurences of isBorderPainted

isBorderPainted occurences:
javax.swing.AbstractButton.isBorderPainted()
javax.swing.JMenuBar.isBorderPainted()
javax.swing.JPopupMenu.isBorderPainted()
javax.swing.JProgressBar.isBorderPainted()
javax.swing.JToolBar.isBorderPainted()


Occurences of isBound

isBound occurences:
java.beans.PropertyDescriptor.isBound()
java.net.DatagramSocket.isBound()
java.net.ServerSocket.isBound()
java.net.Socket.isBound()


Occurences of isBridge

isBridge occurences:
com.sun.jdi.Method.isBridge()
java.lang.reflect.Method.isBridge()


Occurences of isCached

isCached occurences:
javax.imageio.stream.FileCacheImageInputStream.isCached()
javax.imageio.stream.FileCacheImageOutputStream.isCached()
javax.imageio.stream.ImageInputStream.isCached()
javax.imageio.stream.ImageInputStreamImpl.isCached()
javax.imageio.stream.MemoryCacheImageInputStream.isCached()
javax.imageio.stream.MemoryCacheImageOutputStream.isCached()


Occurences of isCachedFile

isCachedFile occurences:
javax.imageio.stream.FileCacheImageInputStream.isCachedFile()
javax.imageio.stream.FileCacheImageOutputStream.isCachedFile()
javax.imageio.stream.ImageInputStream.isCachedFile()
javax.imageio.stream.ImageInputStreamImpl.isCachedFile()
javax.imageio.stream.MemoryCacheImageInputStream.isCachedFile()
javax.imageio.stream.MemoryCacheImageOutputStream.isCachedFile()


Occurences of isCachedMemory

isCachedMemory occurences:
javax.imageio.stream.FileCacheImageInputStream.isCachedMemory()
javax.imageio.stream.FileCacheImageOutputStream.isCachedMemory()
javax.imageio.stream.ImageInputStream.isCachedMemory()
javax.imageio.stream.ImageInputStreamImpl.isCachedMemory()
javax.imageio.stream.MemoryCacheImageInputStream.isCachedMemory()
javax.imageio.stream.MemoryCacheImageOutputStream.isCachedMemory()


Occurences of isCancelled

isCancelled occurences:
java.awt.print.PrinterJob.isCancelled()
java.util.concurrent.Future.isCancelled()
java.util.concurrent.FutureTask.isCancelled()
javax.swing.SwingWorker.isCancelled()


Occurences of isCaseIgnored

isCaseIgnored occurences:
javax.naming.directory.Attributes.isCaseIgnored()
javax.naming.directory.BasicAttributes.isCaseIgnored()


Occurences of isCaseSensitive

isCaseSensitive occurences:
java.sql.ResultSetMetaData.isCaseSensitive(int)
javax.sql.rowset.RowSetMetaDataImpl.isCaseSensitive(int)


Occurences of isCellEditable

isCellEditable occurences:
javax.swing.AbstractCellEditor.isCellEditable(java.util.EventObject)
javax.swing.CellEditor.isCellEditable(java.util.EventObject)
javax.swing.DefaultCellEditor.isCellEditable(java.util.EventObject)
javax.swing.DefaultCellEditor.EditorDelegate.isCellEditable(java.util.EventObject)
javax.swing.JTable.isCellEditable(int, int)
javax.swing.table.AbstractTableModel.isCellEditable(int, int)
javax.swing.table.DefaultTableModel.isCellEditable(int, int)
javax.swing.table.TableModel.isCellEditable(int, int)
javax.swing.tree.DefaultTreeCellEditor.isCellEditable(java.util.EventObject)


Occurences of isCharacters

isCharacters occurences:
javax.xml.stream.events.XMLEvent.isCharacters()
javax.xml.stream.util.StreamReaderDelegate.isCharacters()
javax.xml.stream.XMLStreamReader.isCharacters()


Occurences of isClass

isClass occurences:
com.sun.javadoc.Doc.isClass()
javax.lang.model.element.ElementKind.isClass()


Occurences of isClosed

isClosed occurences:
java.net.DatagramSocket.isClosed()
java.net.ServerSocket.isClosed()
java.net.Socket.isClosed()
java.sql.Connection.isClosed()
java.sql.ResultSet.isClosed()
java.sql.Statement.isClosed()
javax.swing.isClosed
javax.swing.JInternalFrame.isClosed()


Occurences of isCollapsed

isCollapsed occurences:
javax.swing.JTree.isCollapsed(int)
javax.swing.JTree.isCollapsed(javax.swing.tree.TreePath)


Occurences of isCompatibleRaster

isCompatibleRaster occurences:
java.awt.image.ColorModel.isCompatibleRaster(java.awt.image.Raster)
java.awt.image.ComponentColorModel.isCompatibleRaster(java.awt.image.Raster)
java.awt.image.DirectColorModel.isCompatibleRaster(java.awt.image.Raster)
java.awt.image.IndexColorModel.isCompatibleRaster(java.awt.image.Raster)


Occurences of isCompatibleSampleModel

isCompatibleSampleModel occurences:
java.awt.image.ColorModel.isCompatibleSampleModel(java.awt.image.SampleModel)
java.awt.image.ComponentColorModel.isCompatibleSampleModel(java.awt.image.SampleModel)
java.awt.image.IndexColorModel.isCompatibleSampleModel(java.awt.image.SampleModel)
java.awt.image.PackedColorModel.isCompatibleSampleModel(java.awt.image.SampleModel)


Occurences of isComplete

isComplete occurences:
javax.security.sasl.SaslClient.isComplete()
javax.security.sasl.SaslServer.isComplete()


Occurences of isCompositionEnabled

isCompositionEnabled occurences:
java.awt.im.InputContext.isCompositionEnabled()
java.awt.im.spi.InputMethod.isCompositionEnabled()


Occurences of isCompressionLossless

isCompressionLossless occurences:
javax.imageio.ImageWriteParam.isCompressionLossless()
javax.imageio.plugins.jpeg.JPEGImageWriteParam.isCompressionLossless()


Occurences of isConnected

isConnected occurences:
java.net.DatagramSocket.isConnected()
java.net.Socket.isConnected()
java.nio.channels.DatagramChannel.isConnected()
java.nio.channels.SocketChannel.isConnected()


Occurences of isConstructor

isConstructor occurences:
com.sun.javadoc.Doc.isConstructor()
com.sun.jdi.Method.isConstructor()


Occurences of isConsumed

isConsumed occurences:
java.awt.AWTEvent.isConsumed()
java.awt.event.InputEvent.isConsumed()
java.awt.event.InputMethodEvent.isConsumed()


Occurences of isConsumer

isConsumer occurences:
java.awt.image.FilteredImageSource.isConsumer(java.awt.image.ImageConsumer)
java.awt.image.ImageProducer.isConsumer(java.awt.image.ImageConsumer)
java.awt.image.MemoryImageSource.isConsumer(java.awt.image.ImageConsumer)
java.awt.image.renderable.RenderableImageProducer.isConsumer(java.awt.image.ImageConsumer)


Occurences of isContinuousLayout

isContinuousLayout occurences:
javax.swing.JSplitPane.isContinuousLayout()
javax.swing.plaf.basic.BasicSplitPaneUI.isContinuousLayout()


Occurences of isConversionSupported

isConversionSupported occurences:
javax.sound.sampled.AudioSystem.isConversionSupported(javax.sound.sampled.AudioFormat, javax.sound.sampled.AudioFormat)
javax.sound.sampled.AudioSystem.isConversionSupported(javax.sound.sampled.AudioFormat.Encoding, javax.sound.sampled.AudioFormat)
javax.sound.sampled.spi.FormatConversionProvider.isConversionSupported(javax.sound.sampled.AudioFormat, javax.sound.sampled.AudioFormat)
javax.sound.sampled.spi.FormatConversionProvider.isConversionSupported(javax.sound.sampled.AudioFormat.Encoding, javax.sound.sampled.AudioFormat)


Occurences of isCritical

isCritical occurences:
java.security.cert.PolicyNode.isCritical()
javax.naming.ldap.BasicControl.isCritical()
javax.naming.ldap.Control.isCritical()


Occurences of isCurrency

isCurrency occurences:
java.sql.ResultSetMetaData.isCurrency(int)
javax.sql.rowset.RowSetMetaDataImpl.isCurrency(int)


Occurences of isCurrent

isCurrent occurences:
javax.security.auth.kerberos.KerberosTicket.isCurrent()
javax.security.auth.Refreshable.isCurrent()


Occurences of isDaemon

isDaemon occurences:
java.lang.Thread.isDaemon()
java.lang.ThreadGroup.isDaemon()


Occurences of isDataFlavorSupported

isDataFlavorSupported occurences:
java.awt.datatransfer.StringSelection.isDataFlavorSupported(java.awt.datatransfer.DataFlavor)
java.awt.datatransfer.Transferable.isDataFlavorSupported(java.awt.datatransfer.DataFlavor)
java.awt.dnd.DropTargetContext.isDataFlavorSupported(java.awt.datatransfer.DataFlavor)
java.awt.dnd.DropTargetContext.TransferableProxy.isDataFlavorSupported(java.awt.datatransfer.DataFlavor)
java.awt.dnd.DropTargetDragEvent.isDataFlavorSupported(java.awt.datatransfer.DataFlavor)
java.awt.dnd.DropTargetDropEvent.isDataFlavorSupported(java.awt.datatransfer.DataFlavor)
javax.activation.DataHandler.isDataFlavorSupported(java.awt.datatransfer.DataFlavor)
javax.swing.TransferHandler.TransferSupport.isDataFlavorSupported(java.awt.datatransfer.DataFlavor)


Occurences of isDeclared

isDeclared occurences:
org.xml.sax.ext.Attributes2.isDeclared(int)
org.xml.sax.ext.Attributes2.isDeclared(java.lang.String)
org.xml.sax.ext.Attributes2.isDeclared(java.lang.String, java.lang.String)
org.xml.sax.ext.Attributes2Impl.isDeclared(int)
org.xml.sax.ext.Attributes2Impl.isDeclared(java.lang.String)
org.xml.sax.ext.Attributes2Impl.isDeclared(java.lang.String, java.lang.String)


Occurences of isDefaultLookAndFeelDecorated

isDefaultLookAndFeelDecorated occurences:
javax.swing.JDialog.isDefaultLookAndFeelDecorated()
javax.swing.JFrame.isDefaultLookAndFeelDecorated()


Occurences of isDefaultNamespace

isDefaultNamespace occurences:
javax.imageio.metadata.IIOMetadataNode.isDefaultNamespace(java.lang.String)
org.w3c.dom.Node.isDefaultNamespace(java.lang.String)


Occurences of isDefined

isDefined occurences:
java.lang.Character.isDefined(char)
java.lang.Character.isDefined(int)
javax.swing.text.AbstractDocument.AbstractElement.isDefined(java.lang.Object)
javax.swing.text.AttributeSet.isDefined(java.lang.Object)
javax.swing.text.SimpleAttributeSet.isDefined(java.lang.Object)
javax.swing.text.StyleContext.NamedStyle.isDefined(java.lang.Object)
javax.swing.text.StyleContext.SmallAttributeSet.isDefined(java.lang.Object)


Occurences of isDefinitelyWritable

isDefinitelyWritable occurences:
java.sql.ResultSetMetaData.isDefinitelyWritable(int)
javax.sql.rowset.RowSetMetaDataImpl.isDefinitelyWritable(int)


Occurences of isDesignTime

isDesignTime occurences:
java.beans.beancontext.BeanContextSupport.isDesignTime()
java.beans.Beans.isDesignTime()
java.beans.DesignMode.isDesignTime()


Occurences of isDestroyed

isDestroyed occurences:
java.lang.ThreadGroup.isDestroyed()
java.security.KeyStore.PasswordProtection.isDestroyed()
javax.security.auth.Destroyable.isDestroyed()
javax.security.auth.kerberos.KerberosKey.isDestroyed()
javax.security.auth.kerberos.KerberosTicket.isDestroyed()
javax.security.auth.x500.X500PrivateCredential.isDestroyed()


Occurences of isDigit

isDigit occurences:
java.lang.Character.isDigit(char)
java.lang.Character.isDigit(int)


Occurences of isDirect

isDirect occurences:
java.nio.Buffer.isDirect()
java.nio.ByteBuffer.isDirect()
java.nio.CharBuffer.isDirect()
java.nio.DoubleBuffer.isDirect()
java.nio.FloatBuffer.isDirect()
java.nio.IntBuffer.isDirect()
java.nio.LongBuffer.isDirect()
java.nio.ShortBuffer.isDirect()


Occurences of isDirectory

isDirectory occurences:
java.io.File.isDirectory()
java.util.zip.ZipEntry.isDirectory()


Occurences of isDone

isDone occurences:
java.awt.geom.FlatteningPathIterator.isDone()
java.awt.geom.PathIterator.isDone()
java.util.concurrent.Future.isDone()
java.util.concurrent.FutureTask.isDone()
javax.swing.SwingWorker.isDone()


Occurences of isDoubleBuffered

isDoubleBuffered occurences:
java.awt.Component.isDoubleBuffered()
javax.swing.JComponent.isDoubleBuffered()


Occurences of isDragging

isDragging occurences:
javax.swing.plaf.basic.BasicSliderUI.isDragging()
javax.swing.plaf.basic.isDragging
javax.swing.plaf.basic.isDragging


Occurences of isDynamic

isDynamic occurences:
java.awt.image.renderable.ContextualRenderedImageFactory.isDynamic()
java.awt.image.renderable.RenderableImage.isDynamic()
java.awt.image.renderable.RenderableImageOp.isDynamic()


Occurences of isEditable

isEditable occurences:
java.awt.TextComponent.isEditable()
javax.swing.isEditable
javax.swing.JComboBox.isEditable()
javax.swing.JTree.isEditable()
javax.swing.plaf.basic.BasicTreeUI.isEditable()
javax.swing.text.JTextComponent.isEditable()


Occurences of isEditing

isEditing occurences:
javax.swing.JTable.isEditing()
javax.swing.JTree.isEditing()
javax.swing.plaf.basic.BasicTreeUI.isEditing(javax.swing.JTree)
javax.swing.plaf.multi.MultiTreeUI.isEditing(javax.swing.JTree)
javax.swing.plaf.TreeUI.isEditing(javax.swing.JTree)


Occurences of isEmpty

isEmpty occurences:
java.awt.geom.Arc2D.Double.isEmpty()
java.awt.geom.Arc2D.Float.isEmpty()
java.awt.geom.Area.isEmpty()
java.awt.geom.Ellipse2D.Double.isEmpty()
java.awt.geom.Ellipse2D.Float.isEmpty()
java.awt.geom.Rectangle2D.Double.isEmpty()
java.awt.geom.Rectangle2D.Float.isEmpty()
java.awt.geom.RectangularShape.isEmpty()
java.awt.geom.RoundRectangle2D.Double.isEmpty()
java.awt.geom.RoundRectangle2D.Float.isEmpty()
java.awt.Rectangle.isEmpty()
java.awt.RenderingHints.isEmpty()
java.beans.beancontext.BeanContextSupport.isEmpty()
java.lang.String.isEmpty()
java.util.AbstractCollection.isEmpty()
java.util.AbstractMap.isEmpty()
java.util.ArrayDeque.isEmpty()
java.util.ArrayList.isEmpty()
java.util.BitSet.isEmpty()
java.util.Collection.isEmpty()
java.util.concurrent.ConcurrentHashMap.isEmpty()
java.util.concurrent.ConcurrentLinkedQueue.isEmpty()
java.util.concurrent.ConcurrentSkipListMap.isEmpty()
java.util.concurrent.ConcurrentSkipListSet.isEmpty()
java.util.concurrent.CopyOnWriteArrayList.isEmpty()
java.util.concurrent.CopyOnWriteArraySet.isEmpty()
java.util.concurrent.SynchronousQueue.isEmpty()
java.util.Dictionary.isEmpty()
java.util.HashMap.isEmpty()
java.util.HashSet.isEmpty()
java.util.Hashtable.isEmpty()
java.util.IdentityHashMap.isEmpty()
java.util.jar.Attributes.isEmpty()
java.util.List.isEmpty()
java.util.Map.isEmpty()
java.util.Set.isEmpty()
java.util.TreeSet.isEmpty()
java.util.Vector.isEmpty()
java.util.WeakHashMap.isEmpty()
javax.activation.MimeTypeParameterList.isEmpty()
javax.management.openmbean.TabularData.isEmpty()
javax.management.openmbean.TabularDataSupport.isEmpty()
javax.management.timer.Timer.isEmpty()
javax.management.timer.TimerMBean.isEmpty()
javax.naming.CompositeName.isEmpty()
javax.naming.CompoundName.isEmpty()
javax.naming.ldap.LdapName.isEmpty()
javax.naming.Name.isEmpty()
javax.print.attribute.AttributeSet.isEmpty()
javax.print.attribute.HashAttributeSet.isEmpty()
javax.script.SimpleBindings.isEmpty()
javax.swing.DefaultListModel.isEmpty()
javax.swing.text.html.parser.Element.isEmpty()
javax.swing.text.SimpleAttributeSet.isEmpty()


Occurences of isEnabled

isEnabled occurences:
com.sun.jdi.request.EventRequest.isEnabled()
java.awt.Component.isEnabled()
java.awt.Component.AccessibleAWTComponent.isEnabled()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.isEnabled()
java.awt.MenuComponent.AccessibleAWTMenuComponent.isEnabled()
java.awt.MenuItem.isEnabled()
javax.accessibility.AccessibleComponent.isEnabled()
javax.swing.AbstractAction.isEnabled()
javax.swing.Action.isEnabled()
javax.swing.ButtonModel.isEnabled()
javax.swing.DefaultButtonModel.isEnabled()
javax.swing.JList.AccessibleJList.AccessibleJListChild.isEnabled()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.isEnabled()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.isEnabled()
javax.swing.plaf.basic.BasicDesktopPaneUI.CloseAction.isEnabled()
javax.swing.plaf.basic.BasicDesktopPaneUI.MaximizeAction.isEnabled()
javax.swing.plaf.basic.BasicDesktopPaneUI.MinimizeAction.isEnabled()
javax.swing.plaf.basic.BasicDesktopPaneUI.NavigateAction.isEnabled()
javax.swing.plaf.basic.BasicDesktopPaneUI.OpenAction.isEnabled()
javax.swing.plaf.basic.BasicSliderUI.ActionScroller.isEnabled()
javax.swing.plaf.basic.BasicTreeUI.TreeCancelEditingAction.isEnabled()
javax.swing.plaf.basic.BasicTreeUI.TreeHomeAction.isEnabled()
javax.swing.plaf.basic.BasicTreeUI.TreeIncrementAction.isEnabled()
javax.swing.plaf.basic.BasicTreeUI.TreePageAction.isEnabled()
javax.swing.plaf.basic.BasicTreeUI.TreeToggleAction.isEnabled()
javax.swing.plaf.basic.BasicTreeUI.TreeTraverseAction.isEnabled()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.isEnabled()
javax.swing.ToolTipManager.isEnabled()


Occurences of isEndElement

isEndElement occurences:
javax.xml.stream.events.XMLEvent.isEndElement()
javax.xml.stream.util.StreamReaderDelegate.isEndElement()
javax.xml.stream.XMLStreamReader.isEndElement()


Occurences of isEnum

isEnum occurences:
com.sun.javadoc.Doc.isEnum()
com.sun.jdi.ClassType.isEnum()
java.lang.Class.isEnum()


Occurences of isEnumConstant

isEnumConstant occurences:
com.sun.javadoc.Doc.isEnumConstant()
com.sun.jdi.Field.isEnumConstant()
java.lang.reflect.Field.isEnumConstant()


Occurences of isEqual

isEqual occurences:
java.security.MessageDigest.isEqual(byte[], byte[])
javax.swing.text.AbstractDocument.AbstractElement.isEqual(javax.swing.text.AttributeSet)
javax.swing.text.AttributeSet.isEqual(javax.swing.text.AttributeSet)
javax.swing.text.SimpleAttributeSet.isEqual(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.NamedStyle.isEqual(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.SmallAttributeSet.isEqual(javax.swing.text.AttributeSet)


Occurences of isEqualNode

isEqualNode occurences:
javax.imageio.metadata.IIOMetadataNode.isEqualNode(org.w3c.dom.Node)
org.w3c.dom.Node.isEqualNode(org.w3c.dom.Node)


Occurences of isError

isError occurences:
com.sun.javadoc.Doc.isError()
java.nio.charset.CoderResult.isError()


Occurences of isExpanded

isExpanded occurences:
javax.swing.JTree.isExpanded(int)
javax.swing.JTree.isExpanded(javax.swing.tree.TreePath)
javax.swing.tree.AbstractLayoutCache.isExpanded(javax.swing.tree.TreePath)
javax.swing.tree.FixedHeightLayoutCache.isExpanded(javax.swing.tree.TreePath)
javax.swing.tree.VariableHeightLayoutCache.isExpanded(javax.swing.tree.TreePath)


Occurences of isFair

isFair occurences:
java.util.concurrent.locks.ReentrantLock.isFair()
java.util.concurrent.locks.ReentrantReadWriteLock.isFair()
java.util.concurrent.Semaphore.isFair()


Occurences of isFeatureSupported

isFeatureSupported occurences:
javax.xml.crypto.dom.DOMStructure.isFeatureSupported(java.lang.String)
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.isFeatureSupported(java.lang.String)
javax.xml.crypto.dsig.XMLSignatureFactory.isFeatureSupported(java.lang.String)
javax.xml.crypto.XMLStructure.isFeatureSupported(java.lang.String)


Occurences of isField

isField occurences:
com.sun.javadoc.Doc.isField()
javax.lang.model.element.ElementKind.isField()


Occurences of isFileTypeSupported

isFileTypeSupported occurences:
javax.sound.midi.MidiSystem.isFileTypeSupported(int)
javax.sound.midi.MidiSystem.isFileTypeSupported(int, javax.sound.midi.Sequence)
javax.sound.midi.spi.MidiFileWriter.isFileTypeSupported(int)
javax.sound.midi.spi.MidiFileWriter.isFileTypeSupported(int, javax.sound.midi.Sequence)
javax.sound.sampled.AudioSystem.isFileTypeSupported(javax.sound.sampled.AudioFileFormat.Type)
javax.sound.sampled.AudioSystem.isFileTypeSupported(javax.sound.sampled.AudioFileFormat.Type, javax.sound.sampled.AudioInputStream)
javax.sound.sampled.spi.AudioFileWriter.isFileTypeSupported(javax.sound.sampled.AudioFileFormat.Type)
javax.sound.sampled.spi.AudioFileWriter.isFileTypeSupported(javax.sound.sampled.AudioFileFormat.Type, javax.sound.sampled.AudioInputStream)


Occurences of isFinal

isFinal occurences:
com.sun.javadoc.ProgramElementDoc.isFinal()
com.sun.jdi.ReferenceType.isFinal()
com.sun.jdi.TypeComponent.isFinal()
java.lang.reflect.Modifier.isFinal(int)


Occurences of isFixedRowHeight

isFixedRowHeight occurences:
javax.swing.JTree.isFixedRowHeight()
javax.swing.tree.AbstractLayoutCache.isFixedRowHeight()


Occurences of isFocusCycleRoot

isFocusCycleRoot occurences:
java.awt.Component.isFocusCycleRoot(java.awt.Container)
java.awt.Container.isFocusCycleRoot()
java.awt.Container.isFocusCycleRoot(java.awt.Container)
java.awt.Window.isFocusCycleRoot()
javax.swing.JInternalFrame.isFocusCycleRoot()


Occurences of isFocusTraversable

isFocusTraversable occurences:
java.awt.Component.isFocusTraversable()
java.awt.Component.AccessibleAWTComponent.isFocusTraversable()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.isFocusTraversable()
java.awt.MenuComponent.AccessibleAWTMenuComponent.isFocusTraversable()
javax.accessibility.AccessibleComponent.isFocusTraversable()
javax.swing.JList.AccessibleJList.AccessibleJListChild.isFocusTraversable()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.isFocusTraversable()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.isFocusTraversable()
javax.swing.plaf.basic.BasicArrowButton.isFocusTraversable()
javax.swing.plaf.basic.BasicComboBoxUI.isFocusTraversable(javax.swing.JComboBox)
javax.swing.plaf.basic.BasicComboPopup.isFocusTraversable()
javax.swing.plaf.basic.BasicInternalFrameTitlePane.SystemMenuBar.isFocusTraversable()
javax.swing.plaf.ComboBoxUI.isFocusTraversable(javax.swing.JComboBox)
javax.swing.plaf.metal.MetalComboBoxButton.isFocusTraversable()
javax.swing.plaf.multi.MultiComboBoxUI.isFocusTraversable(javax.swing.JComboBox)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.isFocusTraversable()


Occurences of isHeldByCurrentThread

isHeldByCurrentThread occurences:
java.util.concurrent.locks.ReentrantLock.isHeldByCurrentThread()
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.isHeldByCurrentThread()


Occurences of isHeldExclusively

isHeldExclusively occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.isHeldExclusively()
java.util.concurrent.locks.AbstractQueuedSynchronizer.isHeldExclusively()


Occurences of isHidden

isHidden occurences:
java.beans.FeatureDescriptor.isHidden()
java.io.File.isHidden()
javax.swing.plaf.basic.BasicFileChooserUI.BasicFileView.isHidden(java.io.File)


Occurences of isIcon

isIcon occurences:
javax.swing.isIcon
javax.swing.JInternalFrame.isIcon()


Occurences of isIdentifierIgnorable

isIdentifierIgnorable occurences:
java.lang.Character.isIdentifierIgnorable(char)
java.lang.Character.isIdentifierIgnorable(int)


Occurences of isIdentity

isIdentity occurences:
java.awt.font.TransformAttribute.isIdentity()
java.awt.geom.AffineTransform.isIdentity()


Occurences of isInfinite

isInfinite occurences:
java.lang.Double.isInfinite()
java.lang.Double.isInfinite(double)
java.lang.Float.isInfinite()
java.lang.Float.isInfinite(float)


Occurences of isInitialized

isInitialized occurences:
com.sun.jdi.ReferenceType.isInitialized()
javax.annotation.processing.AbstractProcessor.isInitialized()


Occurences of isInRelationService

isInRelationService occurences:
javax.management.relation.RelationSupport.isInRelationService()
javax.management.relation.RelationSupportMBean.isInRelationService()


Occurences of isInstanceOf

isInstanceOf occurences:
java.beans.Beans.isInstanceOf(java.lang.Object, java.lang.Class)
javax.management.MBeanServer.isInstanceOf(javax.management.ObjectName, java.lang.String)
javax.management.MBeanServerConnection.isInstanceOf(javax.management.ObjectName, java.lang.String)
javax.management.Query.isInstanceOf(javax.management.StringValueExp)
javax.management.remote.rmi.RMIConnection.isInstanceOf(javax.management.ObjectName, java.lang.String, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.isInstanceOf(javax.management.ObjectName, java.lang.String, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.isInstanceOf(javax.management.ObjectName, java.lang.String, javax.security.auth.Subject)


Occurences of isInterface

isInterface occurences:
com.sun.javadoc.Doc.isInterface()
java.lang.Class.isInterface()
java.lang.reflect.Modifier.isInterface(int)
javax.lang.model.element.ElementKind.isInterface()


Occurences of isIs

isIs occurences:
javax.management.MBeanAttributeInfo.isIs()
javax.management.openmbean.OpenMBeanAttributeInfo.isIs()


Occurences of isISOControl

isISOControl occurences:
java.lang.Character.isISOControl(char)
java.lang.Character.isISOControl(int)


Occurences of isItalic

isItalic occurences:
java.awt.Font.isItalic()
javax.swing.text.StyleConstants.isItalic(javax.swing.text.AttributeSet)


Occurences of isJavaIdentifierPart

isJavaIdentifierPart occurences:
java.lang.Character.isJavaIdentifierPart(char)
java.lang.Character.isJavaIdentifierPart(int)


Occurences of isJavaIdentifierStart

isJavaIdentifierStart occurences:
java.lang.Character.isJavaIdentifierStart(char)
java.lang.Character.isJavaIdentifierStart(int)


Occurences of isLargeModel

isLargeModel occurences:
javax.swing.JTree.isLargeModel()
javax.swing.plaf.basic.BasicTreeUI.isLargeModel()


Occurences of isLayoutValid

isLayoutValid occurences:
javax.swing.text.AsyncBoxView.ChildState.isLayoutValid()
javax.swing.text.BoxView.isLayoutValid(int)


Occurences of isLeaf

isLeaf occurences:
javax.swing.JTree.DynamicUtilTreeNode.isLeaf()
javax.swing.plaf.basic.BasicTreeUI.isLeaf(int)
javax.swing.text.AbstractDocument.AbstractElement.isLeaf()
javax.swing.text.AbstractDocument.BranchElement.isLeaf()
javax.swing.text.AbstractDocument.LeafElement.isLeaf()
javax.swing.text.Element.isLeaf()
javax.swing.tree.DefaultMutableTreeNode.isLeaf()
javax.swing.tree.DefaultTreeModel.isLeaf(java.lang.Object)
javax.swing.tree.TreeModel.isLeaf(java.lang.Object)
javax.swing.tree.TreeNode.isLeaf()


Occurences of isLeftToRight

isLeftToRight occurences:
java.awt.ComponentOrientation.isLeftToRight()
java.awt.font.TextLayout.isLeftToRight()
java.text.Bidi.isLeftToRight()


Occurences of isLenient

isLenient occurences:
java.text.DateFormat.isLenient()
java.util.Calendar.isLenient()


Occurences of isLetter

isLetter occurences:
java.lang.Character.isLetter(char)
java.lang.Character.isLetter(int)


Occurences of isLetterOrDigit

isLetterOrDigit occurences:
java.lang.Character.isLetterOrDigit(char)
java.lang.Character.isLetterOrDigit(int)


Occurences of isLightWeightPopupEnabled

isLightWeightPopupEnabled occurences:
javax.swing.JComboBox.isLightWeightPopupEnabled()
javax.swing.JPopupMenu.isLightWeightPopupEnabled()
javax.swing.ToolTipManager.isLightWeightPopupEnabled()


Occurences of isLineSupported

isLineSupported occurences:
javax.sound.sampled.AudioSystem.isLineSupported(javax.sound.sampled.Line.Info)
javax.sound.sampled.Mixer.isLineSupported(javax.sound.sampled.Line.Info)


Occurences of isLinkLocalAddress

isLinkLocalAddress occurences:
java.net.Inet4Address.isLinkLocalAddress()
java.net.Inet6Address.isLinkLocalAddress()
java.net.InetAddress.isLinkLocalAddress()


Occurences of isLocal

isLocal occurences:
java.awt.dnd.isLocal
javax.rmi.CORBA.Util.isLocal(javax.rmi.CORBA.Stub)
javax.rmi.CORBA.UtilDelegate.isLocal(javax.rmi.CORBA.Stub)


Occurences of isLocationInExpandControl

isLocationInExpandControl occurences:
javax.swing.plaf.basic.BasicTreeUI.isLocationInExpandControl(javax.swing.tree.TreePath, int, int)
javax.swing.plaf.metal.MetalTreeUI.isLocationInExpandControl(int, int, int, int)


Occurences of isLoggable

isLoggable occurences:
java.util.logging.Filter.isLoggable(java.util.logging.LogRecord)
java.util.logging.Handler.isLoggable(java.util.logging.LogRecord)
java.util.logging.Logger.isLoggable(java.util.logging.Level)
java.util.logging.MemoryHandler.isLoggable(java.util.logging.LogRecord)
java.util.logging.StreamHandler.isLoggable(java.util.logging.LogRecord)


Occurences of isLoopbackAddress

isLoopbackAddress occurences:
java.net.Inet4Address.isLoopbackAddress()
java.net.Inet6Address.isLoopbackAddress()
java.net.InetAddress.isLoopbackAddress()


Occurences of isLowerCase

isLowerCase occurences:
java.lang.Character.isLowerCase(char)
java.lang.Character.isLowerCase(int)


Occurences of isMaximum

isMaximum occurences:
javax.swing.isMaximum
javax.swing.JInternalFrame.isMaximum()


Occurences of isMCGlobal

isMCGlobal occurences:
java.net.Inet4Address.isMCGlobal()
java.net.Inet6Address.isMCGlobal()
java.net.InetAddress.isMCGlobal()


Occurences of isMCLinkLocal

isMCLinkLocal occurences:
java.net.Inet4Address.isMCLinkLocal()
java.net.Inet6Address.isMCLinkLocal()
java.net.InetAddress.isMCLinkLocal()


Occurences of isMCNodeLocal

isMCNodeLocal occurences:
java.net.Inet4Address.isMCNodeLocal()
java.net.Inet6Address.isMCNodeLocal()
java.net.InetAddress.isMCNodeLocal()


Occurences of isMCOrgLocal

isMCOrgLocal occurences:
java.net.Inet4Address.isMCOrgLocal()
java.net.Inet6Address.isMCOrgLocal()
java.net.InetAddress.isMCOrgLocal()


Occurences of isMCSiteLocal

isMCSiteLocal occurences:
java.net.Inet4Address.isMCSiteLocal()
java.net.Inet6Address.isMCSiteLocal()
java.net.InetAddress.isMCSiteLocal()


Occurences of isMimeTypeEqual

isMimeTypeEqual occurences:
java.awt.datatransfer.DataFlavor.isMimeTypeEqual(java.awt.datatransfer.DataFlavor)
java.awt.datatransfer.DataFlavor.isMimeTypeEqual(java.lang.String)
javax.activation.ActivationDataFlavor.isMimeTypeEqual(java.lang.String)


Occurences of isMirrored

isMirrored occurences:
java.lang.Character.isMirrored(char)
java.lang.Character.isMirrored(int)


Occurences of isMulticastAddress

isMulticastAddress occurences:
java.net.Inet4Address.isMulticastAddress()
java.net.Inet6Address.isMulticastAddress()
java.net.InetAddress.isMulticastAddress()


Occurences of isNameCompatible

isNameCompatible occurences:
javax.tools.ForwardingJavaFileObject.isNameCompatible(java.lang.String, javax.tools.JavaFileObject.Kind)
javax.tools.JavaFileObject.isNameCompatible(java.lang.String, javax.tools.JavaFileObject.Kind)
javax.tools.SimpleJavaFileObject.isNameCompatible(java.lang.String, javax.tools.JavaFileObject.Kind)


Occurences of isNamespaceAware

isNamespaceAware occurences:
javax.xml.parsers.DocumentBuilder.isNamespaceAware()
javax.xml.parsers.DocumentBuilderFactory.isNamespaceAware()
javax.xml.parsers.SAXParser.isNamespaceAware()
javax.xml.parsers.SAXParserFactory.isNamespaceAware()


Occurences of isNaN

isNaN occurences:
java.lang.Double.isNaN()
java.lang.Double.isNaN(double)
java.lang.Float.isNaN()
java.lang.Float.isNaN(float)


Occurences of isNative

isNative occurences:
com.sun.javadoc.ExecutableMemberDoc.isNative()
com.sun.jdi.Method.isNative()
java.lang.reflect.Modifier.isNative(int)


Occurences of isNativeLookAndFeel

isNativeLookAndFeel occurences:
javax.swing.LookAndFeel.isNativeLookAndFeel()
javax.swing.plaf.metal.MetalLookAndFeel.isNativeLookAndFeel()
javax.swing.plaf.multi.MultiLookAndFeel.isNativeLookAndFeel()
javax.swing.plaf.synth.SynthLookAndFeel.isNativeLookAndFeel()


Occurences of isNotificationEnabled

isNotificationEnabled occurences:
javax.management.AttributeChangeNotificationFilter.isNotificationEnabled(javax.management.Notification)
javax.management.NotificationFilter.isNotificationEnabled(javax.management.Notification)
javax.management.NotificationFilterSupport.isNotificationEnabled(javax.management.Notification)
javax.management.relation.MBeanServerNotificationFilter.isNotificationEnabled(javax.management.Notification)


Occurences of isNullable

isNullable occurences:
java.sql.ParameterMetaData.isNullable(int)
java.sql.ResultSetMetaData.isNullable(int)
javax.sql.rowset.RowSetMetaDataImpl.isNullable(int)


Occurences of isOpaque

isOpaque occurences:
java.awt.Component.isOpaque()
java.net.URI.isOpaque()
javax.swing.DefaultListCellRenderer.isOpaque()
javax.swing.JComponent.isOpaque()
javax.swing.plaf.basic.BasicInternalFrameTitlePane.SystemMenuBar.isOpaque()
javax.swing.plaf.synth.SynthStyle.isOpaque(javax.swing.plaf.synth.SynthContext)
javax.swing.table.DefaultTableCellRenderer.isOpaque()


Occurences of isOpen

isOpen occurences:
com.sun.jdi.connect.spi.Connection.isOpen()
java.nio.channels.Channel.isOpen()
java.nio.channels.Selector.isOpen()
java.nio.channels.spi.AbstractInterruptibleChannel.isOpen()
java.nio.channels.spi.AbstractSelector.isOpen()
javax.sound.midi.MidiDevice.isOpen()
javax.sound.sampled.Line.isOpen()


Occurences of isOptimizedDrawingEnabled

isOptimizedDrawingEnabled occurences:
javax.swing.JComponent.isOptimizedDrawingEnabled()
javax.swing.JLayeredPane.isOptimizedDrawingEnabled()
javax.swing.JRootPane.isOptimizedDrawingEnabled()
javax.swing.JViewport.isOptimizedDrawingEnabled()


Occurences of isOrdered

isOrdered occurences:
javax.naming.directory.Attribute.isOrdered()
javax.naming.directory.BasicAttribute.isOrdered()


Occurences of isOutputLocation

isOutputLocation occurences:
javax.tools.JavaFileManager.Location.isOutputLocation()
javax.tools.StandardLocation.isOutputLocation()


Occurences of ISO_A0

ISO_A0 occurences:
java.awt.ISO_A0
javax.print.attribute.standard.ISO_A0


Occurences of ISO_A1

ISO_A1 occurences:
java.awt.ISO_A1
javax.print.attribute.standard.ISO_A1


Occurences of ISO_A10

ISO_A10 occurences:
java.awt.ISO_A10
javax.print.attribute.standard.ISO_A10


Occurences of ISO_A2

ISO_A2 occurences:
java.awt.ISO_A2
javax.print.attribute.standard.ISO_A2


Occurences of ISO_A3

ISO_A3 occurences:
java.awt.ISO_A3
javax.print.attribute.standard.ISO_A3


Occurences of ISO_A4

ISO_A4 occurences:
java.awt.ISO_A4
javax.print.attribute.standard.ISO_A4


Occurences of ISO_A5

ISO_A5 occurences:
java.awt.ISO_A5
javax.print.attribute.standard.ISO_A5


Occurences of ISO_A6

ISO_A6 occurences:
java.awt.ISO_A6
javax.print.attribute.standard.ISO_A6


Occurences of ISO_A7

ISO_A7 occurences:
java.awt.ISO_A7
javax.print.attribute.standard.ISO_A7


Occurences of ISO_A8

ISO_A8 occurences:
java.awt.ISO_A8
javax.print.attribute.standard.ISO_A8


Occurences of ISO_A9

ISO_A9 occurences:
java.awt.ISO_A9
javax.print.attribute.standard.ISO_A9


Occurences of ISO_B0

ISO_B0 occurences:
java.awt.ISO_B0
javax.print.attribute.standard.ISO_B0


Occurences of ISO_B1

ISO_B1 occurences:
java.awt.ISO_B1
javax.print.attribute.standard.ISO_B1


Occurences of ISO_B10

ISO_B10 occurences:
java.awt.ISO_B10
javax.print.attribute.standard.ISO_B10


Occurences of ISO_B2

ISO_B2 occurences:
java.awt.ISO_B2
javax.print.attribute.standard.ISO_B2


Occurences of ISO_B3

ISO_B3 occurences:
java.awt.ISO_B3
javax.print.attribute.standard.ISO_B3


Occurences of ISO_B4

ISO_B4 occurences:
java.awt.ISO_B4
javax.print.attribute.standard.ISO_B4


Occurences of ISO_B5

ISO_B5 occurences:
java.awt.ISO_B5
javax.print.attribute.standard.ISO_B5


Occurences of ISO_B6

ISO_B6 occurences:
java.awt.ISO_B6
javax.print.attribute.standard.ISO_B6


Occurences of ISO_B7

ISO_B7 occurences:
java.awt.ISO_B7
javax.print.attribute.standard.ISO_B7


Occurences of ISO_B8

ISO_B8 occurences:
java.awt.ISO_B8
javax.print.attribute.standard.ISO_B8


Occurences of ISO_B9

ISO_B9 occurences:
java.awt.ISO_B9
javax.print.attribute.standard.ISO_B9


Occurences of ISO_C0

ISO_C0 occurences:
java.awt.ISO_C0
javax.print.attribute.standard.ISO_C0


Occurences of ISO_C1

ISO_C1 occurences:
java.awt.ISO_C1
javax.print.attribute.standard.ISO_C1


Occurences of ISO_C2

ISO_C2 occurences:
java.awt.ISO_C2
javax.print.attribute.standard.ISO_C2


Occurences of ISO_C3

ISO_C3 occurences:
java.awt.ISO_C3
javax.print.attribute.standard.ISO_C3


Occurences of ISO_C4

ISO_C4 occurences:
java.awt.ISO_C4
javax.print.attribute.standard.ISO_C4


Occurences of ISO_C5

ISO_C5 occurences:
java.awt.ISO_C5
javax.print.attribute.standard.ISO_C5


Occurences of ISO_C6

ISO_C6 occurences:
java.awt.ISO_C6
javax.print.attribute.standard.ISO_C6


Occurences of ISO_DESIGNATED_LONG

ISO_DESIGNATED_LONG occurences:
java.awt.ISO_DESIGNATED_LONG
javax.print.attribute.standard.ISO_DESIGNATED_LONG


Occurences of isPackagePrivate

isPackagePrivate occurences:
com.sun.javadoc.ProgramElementDoc.isPackagePrivate()
com.sun.jdi.Accessible.isPackagePrivate()


Occurences of isPaintable

isPaintable occurences:
java.beans.PropertyEditor.isPaintable()
java.beans.PropertyEditorSupport.isPaintable()


Occurences of isParityAdjusted

isParityAdjusted occurences:
javax.crypto.spec.DESedeKeySpec.isParityAdjusted(byte[], int)
javax.crypto.spec.DESKeySpec.isParityAdjusted(byte[], int)


Occurences of isPathSelected

isPathSelected occurences:
javax.swing.JTree.isPathSelected(javax.swing.tree.TreePath)
javax.swing.tree.DefaultTreeSelectionModel.isPathSelected(javax.swing.tree.TreePath)
javax.swing.tree.TreeSelectionModel.isPathSelected(javax.swing.tree.TreePath)


Occurences of isPopupTrigger

isPopupTrigger occurences:
java.awt.event.MouseEvent.isPopupTrigger()
javax.swing.JPopupMenu.isPopupTrigger(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicPopupMenuUI.isPopupTrigger(java.awt.event.MouseEvent)
javax.swing.plaf.multi.MultiPopupMenuUI.isPopupTrigger(java.awt.event.MouseEvent)
javax.swing.plaf.PopupMenuUI.isPopupTrigger(java.awt.event.MouseEvent)


Occurences of isPopupVisible

isPopupVisible occurences:
javax.swing.JComboBox.isPopupVisible()
javax.swing.plaf.basic.BasicComboBoxUI.isPopupVisible(javax.swing.JComboBox)
javax.swing.plaf.ComboBoxUI.isPopupVisible(javax.swing.JComboBox)
javax.swing.plaf.multi.MultiComboBoxUI.isPopupVisible(javax.swing.JComboBox)


Occurences of isPreformatted

isPreformatted occurences:
javax.swing.text.html.HTML.Tag.isPreformatted()
javax.swing.text.html.parser.TagElement.isPreformatted()


Occurences of isPressed

isPressed occurences:
javax.swing.ButtonModel.isPressed()
javax.swing.DefaultButtonModel.isPressed()


Occurences of isPrimitive

isPrimitive occurences:
com.sun.javadoc.Type.isPrimitive()
java.io.ObjectStreamField.isPrimitive()
java.lang.Class.isPrimitive()
javax.lang.model.type.TypeKind.isPrimitive()


Occurences of isPrivate

isPrivate occurences:
com.sun.javadoc.ProgramElementDoc.isPrivate()
com.sun.jdi.Accessible.isPrivate()
java.lang.reflect.Modifier.isPrivate(int)


Occurences of isPropertySupported

isPropertySupported occurences:
javax.xml.stream.XMLInputFactory.isPropertySupported(java.lang.String)
javax.xml.stream.XMLOutputFactory.isPropertySupported(java.lang.String)


Occurences of isPropertyValuePattern

isPropertyValuePattern occurences:
javax.management.ObjectName.isPropertyValuePattern()
javax.management.ObjectName.isPropertyValuePattern(java.lang.String)


Occurences of isProtected

isProtected occurences:
com.sun.javadoc.ProgramElementDoc.isProtected()
com.sun.jdi.Accessible.isProtected()
java.lang.reflect.Modifier.isProtected(int)


Occurences of isPublic

isPublic occurences:
com.sun.javadoc.ProgramElementDoc.isPublic()
com.sun.jdi.Accessible.isPublic()
java.lang.reflect.Modifier.isPublic(int)


Occurences of isQueued

isQueued occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.isQueued(java.lang.Thread)
java.util.concurrent.locks.AbstractQueuedSynchronizer.isQueued(java.lang.Thread)


Occurences of isReachable

isReachable occurences:
java.net.InetAddress.isReachable(int)
java.net.InetAddress.isReachable(java.net.NetworkInterface, int, int)


Occurences of isReadable

isReadable occurences:
java.nio.channels.SelectionKey.isReadable()
javax.management.MBeanAttributeInfo.isReadable()
javax.management.openmbean.OpenMBeanAttributeInfo.isReadable()
javax.management.relation.RoleInfo.isReadable()


Occurences of isReadOnly

isReadOnly occurences:
java.nio.Buffer.isReadOnly()
java.security.PermissionCollection.isReadOnly()
java.sql.Connection.isReadOnly()
java.sql.DatabaseMetaData.isReadOnly()
java.sql.ResultSetMetaData.isReadOnly(int)
javax.imageio.metadata.IIOMetadata.isReadOnly()
javax.security.auth.Subject.isReadOnly()
javax.sql.RowSet.isReadOnly()
javax.sql.rowset.BaseRowSet.isReadOnly()
javax.sql.rowset.RowSetMetaDataImpl.isReadOnly(int)


Occurences of isRegistered

isRegistered occurences:
java.nio.channels.SelectableChannel.isRegistered()
java.nio.channels.spi.AbstractSelectableChannel.isRegistered()
java.nio.charset.Charset.isRegistered()
javax.management.MBeanServer.isRegistered(javax.management.ObjectName)
javax.management.MBeanServerConnection.isRegistered(javax.management.ObjectName)
javax.management.remote.rmi.RMIConnection.isRegistered(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.isRegistered(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.isRegistered(javax.management.ObjectName, javax.security.auth.Subject)


Occurences of isRelation

isRelation occurences:
javax.management.relation.RelationService.isRelation(javax.management.ObjectName)
javax.management.relation.RelationServiceMBean.isRelation(javax.management.ObjectName)


Occurences of isRelationMBean

isRelationMBean occurences:
javax.management.relation.RelationService.isRelationMBean(java.lang.String)
javax.management.relation.RelationServiceMBean.isRelationMBean(java.lang.String)


Occurences of isResizable

isResizable occurences:
java.awt.Dialog.isResizable()
java.awt.Frame.isResizable()
javax.swing.JInternalFrame.isResizable()
javax.swing.table.isResizable


Occurences of isRollover

isRollover occurences:
javax.swing.ButtonModel.isRollover()
javax.swing.DefaultButtonModel.isRollover()
javax.swing.JToolBar.isRollover()


Occurences of isRoot

isRoot occurences:
javax.swing.filechooser.FileSystemView.isRoot(java.io.File)
javax.swing.tree.DefaultMutableTreeNode.isRoot()


Occurences of isRootPaneCheckingEnabled

isRootPaneCheckingEnabled occurences:
javax.swing.JApplet.isRootPaneCheckingEnabled()
javax.swing.JDialog.isRootPaneCheckingEnabled()
javax.swing.JFrame.isRootPaneCheckingEnabled()
javax.swing.JInternalFrame.isRootPaneCheckingEnabled()
javax.swing.JWindow.isRootPaneCheckingEnabled()


Occurences of isRootVisible

isRootVisible occurences:
javax.swing.JTree.isRootVisible()
javax.swing.plaf.basic.BasicTreeUI.isRootVisible()
javax.swing.tree.AbstractLayoutCache.isRootVisible()


Occurences of isRowSelected

isRowSelected occurences:
javax.swing.JTable.isRowSelected(int)
javax.swing.JTree.isRowSelected(int)
javax.swing.tree.DefaultTreeSelectionModel.isRowSelected(int)
javax.swing.tree.TreeSelectionModel.isRowSelected(int)


Occurences of isRunning

isRunning occurences:
javax.sound.midi.Sequencer.isRunning()
javax.sound.sampled.DataLine.isRunning()
javax.swing.Timer.isRunning()


Occurences of isSameFile

isSameFile occurences:
javax.tools.ForwardingJavaFileManager.isSameFile(javax.tools.FileObject, javax.tools.FileObject)
javax.tools.JavaFileManager.isSameFile(javax.tools.FileObject, javax.tools.FileObject)
javax.tools.StandardJavaFileManager.isSameFile(javax.tools.FileObject, javax.tools.FileObject)


Occurences of isSameNode

isSameNode occurences:
javax.imageio.metadata.IIOMetadataNode.isSameNode(org.w3c.dom.Node)
org.w3c.dom.Node.isSameNode(org.w3c.dom.Node)


Occurences of isSealed

isSealed occurences:
java.lang.Package.isSealed()
java.lang.Package.isSealed(java.net.URL)


Occurences of isSearchable

isSearchable occurences:
java.sql.ResultSetMetaData.isSearchable(int)
javax.sql.rowset.RowSetMetaDataImpl.isSearchable(int)


Occurences of isSelected

isSelected occurences:
java.awt.im.InputMethodHighlight.isSelected()
java.awt.List.isSelected(int)
javax.swing.AbstractButton.isSelected()
javax.swing.ButtonGroup.isSelected(javax.swing.ButtonModel)
javax.swing.ButtonModel.isSelected()
javax.swing.DefaultButtonModel.isSelected()
javax.swing.DefaultSingleSelectionModel.isSelected()
javax.swing.isSelected
javax.swing.JInternalFrame.isSelected()
javax.swing.JMenu.isSelected()
javax.swing.JMenuBar.isSelected()
javax.swing.JToggleButton.ToggleButtonModel.isSelected()
javax.swing.plaf.basic.isSelected
javax.swing.SingleSelectionModel.isSelected()
javax.swing.text.html.Option.isSelected()


Occurences of isSelectedIndex

isSelectedIndex occurences:
javax.swing.DefaultListSelectionModel.isSelectedIndex(int)
javax.swing.JList.isSelectedIndex(int)
javax.swing.ListSelectionModel.isSelectedIndex(int)


Occurences of isSelectionEmpty

isSelectionEmpty occurences:
javax.swing.DefaultListSelectionModel.isSelectionEmpty()
javax.swing.JList.isSelectionEmpty()
javax.swing.JTree.isSelectionEmpty()
javax.swing.ListSelectionModel.isSelectionEmpty()
javax.swing.tree.DefaultTreeSelectionModel.isSelectionEmpty()
javax.swing.tree.TreeSelectionModel.isSelectionEmpty()


Occurences of isSelectionVisible

isSelectionVisible occurences:
javax.swing.text.Caret.isSelectionVisible()
javax.swing.text.DefaultCaret.isSelectionVisible()


Occurences of isSet

isSet occurences:
java.util.Calendar.isSet(int)
java.util.isSet
javax.xml.datatype.Duration.isSet(javax.xml.datatype.DatatypeConstants.Field)


Occurences of isShowing

isShowing occurences:
java.awt.Component.isShowing()
java.awt.Component.AccessibleAWTComponent.isShowing()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.isShowing()
java.awt.MenuComponent.AccessibleAWTMenuComponent.isShowing()
java.awt.Window.isShowing()
javax.accessibility.AccessibleComponent.isShowing()
javax.swing.JList.AccessibleJList.AccessibleJListChild.isShowing()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.isShowing()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.isShowing()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.isShowing()


Occurences of isShutdown

isShutdown occurences:
java.util.concurrent.ExecutorService.isShutdown()
java.util.concurrent.ThreadPoolExecutor.isShutdown()


Occurences of isSigned

isSigned occurences:
java.sql.ParameterMetaData.isSigned(int)
java.sql.ResultSetMetaData.isSigned(int)
javax.sql.rowset.RowSetMetaDataImpl.isSigned(int)


Occurences of isSignificant

isSignificant occurences:
javax.swing.text.AbstractDocument.DefaultDocumentEvent.isSignificant()
javax.swing.undo.AbstractUndoableEdit.isSignificant()
javax.swing.undo.CompoundEdit.isSignificant()
javax.swing.undo.UndoableEdit.isSignificant()


Occurences of isSiteLocalAddress

isSiteLocalAddress occurences:
java.net.Inet4Address.isSiteLocalAddress()
java.net.Inet6Address.isSiteLocalAddress()
java.net.InetAddress.isSiteLocalAddress()


Occurences of isSpaceChar

isSpaceChar occurences:
java.lang.Character.isSpaceChar(char)
java.lang.Character.isSpaceChar(int)


Occurences of isSpecified

isSpecified occurences:
javax.xml.stream.events.Attribute.isSpecified()
javax.xml.validation.TypeInfoProvider.isSpecified(int)
org.xml.sax.ext.Attributes2.isSpecified(int)
org.xml.sax.ext.Attributes2.isSpecified(java.lang.String)
org.xml.sax.ext.Attributes2.isSpecified(java.lang.String, java.lang.String)
org.xml.sax.ext.Attributes2Impl.isSpecified(int)
org.xml.sax.ext.Attributes2Impl.isSpecified(java.lang.String)
org.xml.sax.ext.Attributes2Impl.isSpecified(java.lang.String, java.lang.String)


Occurences of isStandalone

isStandalone occurences:
javax.xml.stream.events.StartDocument.isStandalone()
javax.xml.stream.util.StreamReaderDelegate.isStandalone()
javax.xml.stream.XMLStreamReader.isStandalone()


Occurences of isStartElement

isStartElement occurences:
javax.xml.stream.events.XMLEvent.isStartElement()
javax.xml.stream.util.StreamReaderDelegate.isStartElement()
javax.xml.stream.XMLStreamReader.isStartElement()


Occurences of isStatic

isStatic occurences:
com.sun.javadoc.ProgramElementDoc.isStatic()
com.sun.jdi.ReferenceType.isStatic()
com.sun.jdi.TypeComponent.isStatic()
com.sun.source.tree.BlockTree.isStatic()
com.sun.source.tree.ImportTree.isStatic()
java.lang.reflect.Modifier.isStatic(int)


Occurences of isStrikeThrough

isStrikeThrough occurences:
javax.swing.text.GlyphView.isStrikeThrough()
javax.swing.text.LabelView.isStrikeThrough()
javax.swing.text.StyleConstants.isStrikeThrough(javax.swing.text.AttributeSet)


Occurences of isSubscript

isSubscript occurences:
javax.swing.text.GlyphView.isSubscript()
javax.swing.text.LabelView.isSubscript()
javax.swing.text.StyleConstants.isSubscript(javax.swing.text.AttributeSet)


Occurences of isSubtype

isSubtype occurences:
com.sun.mirror.util.Types.isSubtype(com.sun.mirror.type.TypeMirror, com.sun.mirror.type.TypeMirror)
javax.lang.model.util.Types.isSubtype(javax.lang.model.type.TypeMirror, javax.lang.model.type.TypeMirror)


Occurences of isSuperscript

isSuperscript occurences:
javax.swing.text.GlyphView.isSuperscript()
javax.swing.text.LabelView.isSuperscript()
javax.swing.text.StyleConstants.isSuperscript(javax.swing.text.AttributeSet)


Occurences of isSupported

isSupported occurences:
java.awt.Desktop.isSupported(java.awt.Desktop.Action)
java.awt.SystemTray.isSupported()
java.nio.charset.Charset.isSupported(java.lang.String)
javax.imageio.metadata.IIOMetadataNode.isSupported(java.lang.String, java.lang.String)
org.w3c.dom.Node.isSupported(java.lang.String, java.lang.String)


Occurences of isSupportedLookAndFeel

isSupportedLookAndFeel occurences:
javax.swing.LookAndFeel.isSupportedLookAndFeel()
javax.swing.plaf.metal.MetalLookAndFeel.isSupportedLookAndFeel()
javax.swing.plaf.multi.MultiLookAndFeel.isSupportedLookAndFeel()
javax.swing.plaf.synth.SynthLookAndFeel.isSupportedLookAndFeel()


Occurences of isSupportedOption

isSupportedOption occurences:
javax.tools.ForwardingJavaFileManager.isSupportedOption(java.lang.String)
javax.tools.OptionChecker.isSupportedOption(java.lang.String)


Occurences of isSuspended

isSuspended occurences:
com.sun.jdi.ThreadReference.isSuspended()
java.lang.management.ThreadInfo.isSuspended()


Occurences of isSynchronized

isSynchronized occurences:
com.sun.javadoc.ExecutableMemberDoc.isSynchronized()
com.sun.jdi.Method.isSynchronized()
java.lang.reflect.Modifier.isSynchronized(int)


Occurences of isSynthetic

isSynthetic occurences:
com.sun.javadoc.MemberDoc.isSynthetic()
com.sun.jdi.TypeComponent.isSynthetic()
java.lang.Class.isSynthetic()
java.lang.reflect.Constructor.isSynthetic()
java.lang.reflect.Field.isSynthetic()
java.lang.reflect.Member.isSynthetic()
java.lang.reflect.Method.isSynthetic()


Occurences of isTearOff

isTearOff occurences:
java.awt.Menu.isTearOff()
javax.swing.JMenu.isTearOff()


Occurences of isTerminated

isTerminated occurences:
java.util.concurrent.ExecutorService.isTerminated()
java.util.concurrent.ThreadPoolExecutor.isTerminated()


Occurences of isTileWritable

isTileWritable occurences:
java.awt.image.BufferedImage.isTileWritable(int, int)
java.awt.image.WritableRenderedImage.isTileWritable(int, int)


Occurences of isTitleCase

isTitleCase occurences:
java.lang.Character.isTitleCase(char)
java.lang.Character.isTitleCase(int)


Occurences of isTransformed

isTransformed occurences:
java.awt.Font.isTransformed()
java.awt.font.FontRenderContext.isTransformed()


Occurences of isTransient

isTransient occurences:
com.sun.javadoc.FieldDoc.isTransient()
com.sun.jdi.Field.isTransient()
java.lang.reflect.Modifier.isTransient(int)


Occurences of isTraversable

isTraversable occurences:
javax.swing.filechooser.FileSystemView.isTraversable(java.io.File)
javax.swing.filechooser.FileView.isTraversable(java.io.File)
javax.swing.JFileChooser.isTraversable(java.io.File)


Occurences of isUndecorated

isUndecorated occurences:
java.awt.Dialog.isUndecorated()
java.awt.Frame.isUndecorated()


Occurences of isUnderline

isUnderline occurences:
javax.swing.text.GlyphView.isUnderline()
javax.swing.text.LabelView.isUnderline()
javax.swing.text.StyleConstants.isUnderline(javax.swing.text.AttributeSet)


Occurences of isUnicodeIdentifierPart

isUnicodeIdentifierPart occurences:
java.lang.Character.isUnicodeIdentifierPart(char)
java.lang.Character.isUnicodeIdentifierPart(int)


Occurences of isUnicodeIdentifierStart

isUnicodeIdentifierStart occurences:
java.lang.Character.isUnicodeIdentifierStart(char)
java.lang.Character.isUnicodeIdentifierStart(int)


Occurences of isUpperCase

isUpperCase occurences:
java.lang.Character.isUpperCase(char)
java.lang.Character.isUpperCase(int)


Occurences of isUserNode

isUserNode occurences:
java.util.prefs.AbstractPreferences.isUserNode()
java.util.prefs.Preferences.isUserNode()


Occurences of isValid

isValid occurences:
com.sun.jdi.connect.Connector.Argument.isValid(java.lang.String)
com.sun.jdi.connect.Connector.BooleanArgument.isValid(java.lang.String)
com.sun.jdi.connect.Connector.IntegerArgument.isValid(int)
com.sun.jdi.connect.Connector.IntegerArgument.isValid(java.lang.String)
com.sun.jdi.connect.Connector.SelectedArgument.isValid(java.lang.String)
com.sun.jdi.connect.Connector.StringArgument.isValid(java.lang.String)
java.awt.Component.isValid()
java.awt.image.IndexColorModel.isValid()
java.awt.image.IndexColorModel.isValid(int)
java.lang.management.MemoryManagerMXBean.isValid()
java.lang.management.MemoryPoolMXBean.isValid()
java.nio.channels.FileLock.isValid()
java.nio.channels.SelectionKey.isValid()
java.nio.channels.spi.AbstractSelectionKey.isValid()
java.sql.Connection.isValid(int)
javax.accessibility.AccessibleHyperlink.isValid()
javax.management.Descriptor.isValid()
javax.management.ImmutableDescriptor.isValid()
javax.management.modelmbean.DescriptorSupport.isValid()
javax.net.ssl.SSLSession.isValid()
javax.swing.JEditorPane.JEditorPaneAccessibleHypertextSupport.HTMLLink.isValid()
javax.swing.plaf.basic.BasicSplitPaneDivider.DragController.isValid()
javax.swing.text.html.HTMLDocument.Iterator.isValid()
javax.xml.datatype.XMLGregorianCalendar.isValid()


Occurences of isValidateRoot

isValidateRoot occurences:
javax.swing.JComponent.isValidateRoot()
javax.swing.JRootPane.isValidateRoot()
javax.swing.JScrollPane.isValidateRoot()
javax.swing.JSplitPane.isValidateRoot()
javax.swing.JTextField.isValidateRoot()


Occurences of isValidating

isValidating occurences:
javax.xml.bind.helpers.AbstractUnmarshallerImpl.isValidating()
javax.xml.bind.Unmarshaller.isValidating()
javax.xml.parsers.DocumentBuilder.isValidating()
javax.xml.parsers.DocumentBuilderFactory.isValidating()
javax.xml.parsers.SAXParser.isValidating()
javax.xml.parsers.SAXParserFactory.isValidating()


Occurences of isValue

isValue occurences:
javax.management.openmbean.ArrayType.isValue(java.lang.Object)
javax.management.openmbean.CompositeType.isValue(java.lang.Object)
javax.management.openmbean.OpenMBeanAttributeInfoSupport.isValue(java.lang.Object)
javax.management.openmbean.OpenMBeanParameterInfo.isValue(java.lang.Object)
javax.management.openmbean.OpenMBeanParameterInfoSupport.isValue(java.lang.Object)
javax.management.openmbean.OpenType.isValue(java.lang.Object)
javax.management.openmbean.SimpleType.isValue(java.lang.Object)
javax.management.openmbean.TabularType.isValue(java.lang.Object)


Occurences of isVarArgs

isVarArgs occurences:
com.sun.javadoc.ExecutableMemberDoc.isVarArgs()
com.sun.jdi.Method.isVarArgs()
com.sun.mirror.declaration.ExecutableDeclaration.isVarArgs()
java.lang.reflect.Constructor.isVarArgs()
java.lang.reflect.Method.isVarArgs()
javax.lang.model.element.ExecutableElement.isVarArgs()


Occurences of isVerbose

isVerbose occurences:
java.lang.management.ClassLoadingMXBean.isVerbose()
java.lang.management.MemoryMXBean.isVerbose()


Occurences of isVisible

isVisible occurences:
com.sun.jdi.LocalVariable.isVisible(com.sun.jdi.StackFrame)
java.awt.Component.isVisible()
java.awt.Component.AccessibleAWTComponent.isVisible()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.isVisible()
java.awt.MenuComponent.AccessibleAWTMenuComponent.isVisible()
java.awt.SplashScreen.isVisible()
javax.accessibility.AccessibleComponent.isVisible()
javax.swing.JList.AccessibleJList.AccessibleJListChild.isVisible()
javax.swing.JPopupMenu.isVisible()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.isVisible()
javax.swing.JTree.isVisible(javax.swing.tree.TreePath)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.isVisible()
javax.swing.plaf.basic.ComboPopup.isVisible()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.isVisible()
javax.swing.text.Caret.isVisible()
javax.swing.text.DefaultCaret.isVisible()
javax.swing.text.html.ParagraphView.isVisible()
javax.swing.text.View.isVisible()


Occurences of isVolatile

isVolatile occurences:
com.sun.javadoc.FieldDoc.isVolatile()
com.sun.jdi.Field.isVolatile()
java.lang.reflect.Modifier.isVolatile(int)


Occurences of isWheelScrollingEnabled

isWheelScrollingEnabled occurences:
java.awt.ScrollPane.isWheelScrollingEnabled()
javax.swing.JScrollPane.isWheelScrollingEnabled()


Occurences of isWhitespace

isWhitespace occurences:
java.awt.font.GlyphMetrics.isWhitespace()
java.lang.Character.isWhitespace(char)
java.lang.Character.isWhitespace(int)


Occurences of isWhiteSpace

isWhiteSpace occurences:
javax.xml.bind.annotation.adapters.CollapsedStringAdapter.isWhiteSpace(char)
javax.xml.stream.events.Characters.isWhiteSpace()
javax.xml.stream.util.StreamReaderDelegate.isWhiteSpace()
javax.xml.stream.XMLStreamReader.isWhiteSpace()


Occurences of isWrapperFor

isWrapperFor occurences:
java.sql.Wrapper.isWrapperFor(java.lang.Class)
javax.sql.rowset.RowSetMetaDataImpl.isWrapperFor(java.lang.Class)


Occurences of isWritable

isWritable occurences:
java.nio.channels.SelectionKey.isWritable()
java.sql.ResultSetMetaData.isWritable(int)
javax.management.MBeanAttributeInfo.isWritable()
javax.management.openmbean.OpenMBeanAttributeInfo.isWritable()
javax.management.relation.RoleInfo.isWritable()
javax.sql.rowset.RowSetMetaDataImpl.isWritable(int)


Occurences of isXIncludeAware

isXIncludeAware occurences:
javax.xml.parsers.DocumentBuilder.isXIncludeAware()
javax.xml.parsers.DocumentBuilderFactory.isXIncludeAware()
javax.xml.parsers.SAXParser.isXIncludeAware()
javax.xml.parsers.SAXParserFactory.isXIncludeAware()


Occurences of isXOPPackage

isXOPPackage occurences:
javax.xml.bind.attachment.AttachmentMarshaller.isXOPPackage()
javax.xml.bind.attachment.AttachmentUnmarshaller.isXOPPackage()


Occurences of is_a

is_a occurences:
org.omg.CORBA.portable.Delegate.is_a(org.omg.CORBA.Object, java.lang.String)
org.omg.PortableServer.portable.Delegate.is_a(org.omg.PortableServer.Servant, java.lang.String)


Occurences of is_null

is_null occurences:
org.omg.DynamicAny.DynValueCommonOperations.is_null()
org.omg.DynamicAny._DynValueStub.is_null()


Occurences of ITALY

ITALY occurences:
java.awt.ITALY
java.util.ITALY


Occurences of ITALY_ENVELOPE

ITALY_ENVELOPE occurences:
java.awt.ITALY_ENVELOPE
javax.print.attribute.standard.ITALY_ENVELOPE
javax.print.attribute.standard.ITALY_ENVELOPE


Occurences of item

item occurences:
javax.imageio.metadata.IIOMetadataNode.item(int)
org.omg.CORBA.ContextList.item(int)
org.omg.CORBA.ExceptionList.item(int)
org.omg.CORBA.NVList.item(int)
org.w3c.dom.DOMImplementationList.item(int)
org.w3c.dom.DOMStringList.item(int)
org.w3c.dom.NamedNodeMap.item(int)
org.w3c.dom.NodeList.item(int)


Occurences of itemListener

itemListener occurences:
javax.swing.itemListener
javax.swing.plaf.basic.itemListener
javax.swing.plaf.basic.itemListener


Occurences of itemStateChanged

itemStateChanged occurences:
java.awt.AWTEventMulticaster.itemStateChanged(java.awt.event.ItemEvent)
java.awt.Checkbox.AccessibleAWTCheckbox.itemStateChanged(java.awt.event.ItemEvent)
java.awt.event.ItemListener.itemStateChanged(java.awt.event.ItemEvent)
java.awt.List.AccessibleAWTList.itemStateChanged(java.awt.event.ItemEvent)
javax.swing.DefaultCellEditor.EditorDelegate.itemStateChanged(java.awt.event.ItemEvent)
javax.swing.JToggleButton.AccessibleJToggleButton.itemStateChanged(java.awt.event.ItemEvent)
javax.swing.plaf.basic.BasicComboBoxUI.ItemHandler.itemStateChanged(java.awt.event.ItemEvent)
javax.swing.plaf.basic.BasicComboPopup.ItemHandler.itemStateChanged(java.awt.event.ItemEvent)


Occurences of iterator

iterator occurences:
com.sun.source.util.TreePath.iterator()
java.awt.dnd.DragGestureEvent.iterator()
java.beans.beancontext.BeanContextMembershipEvent.iterator()
java.beans.beancontext.BeanContextSupport.iterator()
java.lang.Iterable.iterator()
java.sql.SQLException.iterator()
java.util.AbstractCollection.iterator()
java.util.AbstractList.iterator()
java.util.AbstractSequentialList.iterator()
java.util.ArrayDeque.iterator()
java.util.Collection.iterator()
java.util.concurrent.ArrayBlockingQueue.iterator()
java.util.concurrent.BlockingDeque.iterator()
java.util.concurrent.ConcurrentLinkedQueue.iterator()
java.util.concurrent.ConcurrentSkipListSet.iterator()
java.util.concurrent.CopyOnWriteArrayList.iterator()
java.util.concurrent.CopyOnWriteArraySet.iterator()
java.util.concurrent.DelayQueue.iterator()
java.util.concurrent.LinkedBlockingDeque.iterator()
java.util.concurrent.LinkedBlockingQueue.iterator()
java.util.concurrent.PriorityBlockingQueue.iterator()
java.util.concurrent.SynchronousQueue.iterator()
java.util.Deque.iterator()
java.util.HashSet.iterator()
java.util.List.iterator()
java.util.NavigableSet.iterator()
java.util.PriorityQueue.iterator()
java.util.ServiceLoader.iterator()
java.util.Set.iterator()
java.util.TreeSet.iterator()
javax.xml.crypto.dom.DOMCryptoContext.iterator()
javax.xml.crypto.NodeSetData.iterator()


Occurences of IvParameterSpec (constructors)

IvParameterSpec (constructors) occurences:
javax.crypto.spec.IvParameterSpec(byte[])
javax.crypto.spec.IvParameterSpec(byte[], int, int)


Occurences of JAAS Login Configuration File

JAAS Login Configuration File occurences:
JAAS Login Configuration File
JAAS Login Configuration File


Occurences of JANUARY

JANUARY occurences:
java.util.JANUARY
javax.xml.datatype.JANUARY


Occurences of JAPANESE_DOUBLE_POSTCARD

JAPANESE_DOUBLE_POSTCARD occurences:
javax.print.attribute.standard.JAPANESE_DOUBLE_POSTCARD
javax.print.attribute.standard.JAPANESE_DOUBLE_POSTCARD


Occurences of JAPANESE_POSTCARD

JAPANESE_POSTCARD occurences:
javax.print.attribute.standard.JAPANESE_POSTCARD
javax.print.attribute.standard.JAPANESE_POSTCARD


Occurences of jar-The Java Archive Tool

jar-The Java Archive Tool occurences:
jar-The Java Archive Tool
jar-The Java Archive Tool


Occurences of JarEntry (constructors)

JarEntry (constructors) occurences:
java.util.jar.JarEntry(java.lang.String)
java.util.jar.JarEntry(java.util.jar.JarEntry)
java.util.jar.JarEntry(java.util.zip.ZipEntry)


Occurences of JarException (constructors)

JarException (constructors) occurences:
java.util.jar.JarException()
java.util.jar.JarException(java.lang.String)


Occurences of JarFile (constructors)

JarFile (constructors) occurences:
java.util.jar.JarFile(java.io.File)
java.util.jar.JarFile(java.io.File, boolean)
java.util.jar.JarFile(java.io.File, boolean, int)
java.util.jar.JarFile(java.lang.String)
java.util.jar.JarFile(java.lang.String, boolean)


Occurences of JarInputStream (constructors)

JarInputStream (constructors) occurences:
java.util.jar.JarInputStream(java.io.InputStream)
java.util.jar.JarInputStream(java.io.InputStream, boolean)


Occurences of JarOutputStream (constructors)

JarOutputStream (constructors) occurences:
java.util.jar.JarOutputStream(java.io.OutputStream)
java.util.jar.JarOutputStream(java.io.OutputStream, java.util.jar.Manifest)


Occurences of jarsigner-JAR Signing and Verification Tool

jarsigner-JAR Signing and Verification Tool occurences:
jarsigner-JAR Signing and Verification Tool
jarsigner-JAR Signing and Verification Tool


Occurences of java - the Java application launcher

java - the Java application launcher occurences:
java - the Java application launcher
java - the Java application launcher


Occurences of Java Console

Java Console occurences:
Java Console
Java Console


Occurences of Java Control Panel

Java Control Panel occurences:
Java Control Panel
Java Control Panel


Occurences of Java Core Reflection

Java Core Reflection occurences:
Java Core Reflection
Java Core Reflection


Occurences of Java Image I/O API Guide

Java Image I/O API Guide occurences:
Java Image I/O API Guide
Java Image I/O API Guide


Occurences of Java Management Extensions

Java Management Extensions occurences:
Java Management Extensions
Java Management Extensions


Occurences of Java Platform Debugger Architecture

Java Platform Debugger Architecture occurences:
Java Platform Debugger Architecture
Java Platform Debugger Architecture
Java Platform Debugger Architecture


Occurences of Java SE Monitoring and Management Guide

Java SE Monitoring and Management Guide occurences:
Java SE Monitoring and Management Guide
Java SE Monitoring and Management Guide
Java SE Monitoring and Management Guide
Java SE Monitoring and Management Guide
Java SE Monitoring and Management Guide
Java SE Monitoring and Management Guide
Java SE Monitoring and Management Guide
Java SE Monitoring and Management Guide
Java SE Monitoring and Management Guide


Occurences of Java(tm) Debug Wire Protocol

Java(tm) Debug Wire Protocol occurences:
Java(tm) Debug Wire Protocol
Java(tm) Debug Wire Protocol


Occurences of Java(tm) Platform Debugger Architecture

Java(tm) Platform Debugger Architecture occurences:
Java(tm) Platform Debugger Architecture
Java(tm) Platform Debugger Architecture


Occurences of java.lang.ClassNotFoundException thrown ...

java.lang.ClassNotFoundException thrown ... occurences:
java.lang.ClassNotFoundException thrown ...
java.lang.ClassNotFoundException thrown ...


Occurences of java.lang.instrument

java.lang.instrument occurences:
java.lang.instrument
java.lang.instrument


Occurences of java.security.AccessControlException thrown ...

java.security.AccessControlException thrown ... occurences:
java.security.AccessControlException thrown ...
java.security.AccessControlException thrown ...


Occurences of javac - Java programming language compiler

javac - Java programming language compiler occurences:
javac - Java programming language compiler
javac - Java programming language compiler


Occurences of javadoc-The Java API Documentation Generator

javadoc-The Java API Documentation Generator occurences:
javadoc-The Java API Documentation Generator
javadoc-The Java API Documentation Generator


Occurences of javah - C Header and Stub File Generator

javah - C Header and Stub File Generator occurences:
javah - C Header and Stub File Generator
javah - C Header and Stub File Generator


Occurences of javap - The Java Class File Disassembler

javap - The Java Class File Disassembler occurences:
javap - The Java Class File Disassembler
javap - The Java Class File Disassembler


Occurences of JAXBElement (constructors)

JAXBElement (constructors) occurences:
javax.xml.bind.JAXBElement(javax.xml.namespace.QName, java.lang.Class, java.lang.Class, T)
javax.xml.bind.JAXBElement(javax.xml.namespace.QName, java.lang.Class, T)
javax.xml.bind.JAXBElement(javax.xml.namespace.QName,java.lang.Class,java.lang.Class,java.lang.Object)
javax.xml.bind.JAXBElement(javax.xml.namespace.QName,java.lang.Class,java.lang.Object)


Occurences of JAXBException (constructors)

JAXBException (constructors) occurences:
javax.xml.bind.JAXBException(java.lang.String)
javax.xml.bind.JAXBException(java.lang.String, java.lang.String)
javax.xml.bind.JAXBException(java.lang.String, java.lang.String, java.lang.Throwable)
javax.xml.bind.JAXBException(java.lang.String, java.lang.Throwable)
javax.xml.bind.JAXBException(java.lang.Throwable)


Occurences of JAXBResult (constructors)

JAXBResult (constructors) occurences:
javax.xml.bind.util.JAXBResult(javax.xml.bind.JAXBContext)
javax.xml.bind.util.JAXBResult(javax.xml.bind.Unmarshaller)


Occurences of JAXBSource (constructors)

JAXBSource (constructors) occurences:
javax.xml.bind.util.JAXBSource(javax.xml.bind.JAXBContext, java.lang.Object)
javax.xml.bind.util.JAXBSource(javax.xml.bind.Marshaller, java.lang.Object)


Occurences of JAXP Compatibility

JAXP Compatibility occurences:
JAXP Compatibility
JAXP Compatibility


Occurences of JButton (constructors)

JButton (constructors) occurences:
javax.swing.JButton()
javax.swing.JButton(java.lang.String)
javax.swing.JButton(java.lang.String, javax.swing.Icon)
javax.swing.JButton(javax.swing.Action)
javax.swing.JButton(javax.swing.Icon)


Occurences of JCheckBox (constructors)

JCheckBox (constructors) occurences:
javax.swing.JCheckBox()
javax.swing.JCheckBox(java.lang.String)
javax.swing.JCheckBox(java.lang.String, boolean)
javax.swing.JCheckBox(java.lang.String, javax.swing.Icon)
javax.swing.JCheckBox(java.lang.String, javax.swing.Icon, boolean)
javax.swing.JCheckBox(javax.swing.Action)
javax.swing.JCheckBox(javax.swing.Icon)
javax.swing.JCheckBox(javax.swing.Icon, boolean)


Occurences of JCheckBoxMenuItem (constructors)

JCheckBoxMenuItem (constructors) occurences:
javax.swing.JCheckBoxMenuItem()
javax.swing.JCheckBoxMenuItem(java.lang.String)
javax.swing.JCheckBoxMenuItem(java.lang.String, boolean)
javax.swing.JCheckBoxMenuItem(java.lang.String, javax.swing.Icon)
javax.swing.JCheckBoxMenuItem(java.lang.String, javax.swing.Icon, boolean)
javax.swing.JCheckBoxMenuItem(javax.swing.Action)
javax.swing.JCheckBoxMenuItem(javax.swing.Icon)


Occurences of JColorChooser (constructors)

JColorChooser (constructors) occurences:
javax.swing.JColorChooser()
javax.swing.JColorChooser(java.awt.Color)
javax.swing.JColorChooser(javax.swing.colorchooser.ColorSelectionModel)


Occurences of JComboBox (constructors)

JComboBox (constructors) occurences:
javax.swing.JComboBox()
javax.swing.JComboBox(java.lang.Object[])
javax.swing.JComboBox(java.util.Vector)
javax.swing.JComboBox(javax.swing.ComboBoxModel)


Occurences of jdb - The Java Debugger

jdb - The Java Debugger occurences:
jdb - The Java Debugger
jdb - The Java Debugger


Occurences of JDBC-ODBC Bridge Enhancements

JDBC-ODBC Bridge Enhancements occurences:
JDBC-ODBC Bridge Enhancements
JDBC-ODBC Bridge Enhancements


Occurences of jdi

jdi occurences:
com.sun.jdi
Overview


Occurences of JDialog (constructors)

JDialog (constructors) occurences:
javax.swing.JDialog()
javax.swing.JDialog(java.awt.Dialog)
javax.swing.JDialog(java.awt.Dialog, boolean)
javax.swing.JDialog(java.awt.Dialog, java.lang.String)
javax.swing.JDialog(java.awt.Dialog, java.lang.String, boolean)
javax.swing.JDialog(java.awt.Dialog, java.lang.String, boolean, java.awt.GraphicsConfiguration)
javax.swing.JDialog(java.awt.Frame)
javax.swing.JDialog(java.awt.Frame, boolean)
javax.swing.JDialog(java.awt.Frame, java.lang.String)
javax.swing.JDialog(java.awt.Frame, java.lang.String, boolean)
javax.swing.JDialog(java.awt.Frame, java.lang.String, boolean, java.awt.GraphicsConfiguration)
javax.swing.JDialog(java.awt.Window)
javax.swing.JDialog(java.awt.Window, java.awt.Dialog.ModalityType)
javax.swing.JDialog(java.awt.Window, java.lang.String)
javax.swing.JDialog(java.awt.Window, java.lang.String, java.awt.Dialog.ModalityType)
javax.swing.JDialog(java.awt.Window, java.lang.String, java.awt.Dialog.ModalityType, java.awt.GraphicsConfiguration)


Occurences of JDIPermission (constructors)

JDIPermission (constructors) occurences:
com.sun.jdi.JDIPermission(java.lang.String)
com.sun.jdi.JDIPermission(java.lang.String, java.lang.String)


Occurences of JEditorPane (constructors)

JEditorPane (constructors) occurences:
javax.swing.JEditorPane()
javax.swing.JEditorPane(java.lang.String)
javax.swing.JEditorPane(java.lang.String, java.lang.String)
javax.swing.JEditorPane(java.net.URL)


Occurences of JFileChooser (constructors)

JFileChooser (constructors) occurences:
javax.swing.JFileChooser()
javax.swing.JFileChooser(java.io.File)
javax.swing.JFileChooser(java.io.File, javax.swing.filechooser.FileSystemView)
javax.swing.JFileChooser(java.lang.String)
javax.swing.JFileChooser(java.lang.String, javax.swing.filechooser.FileSystemView)
javax.swing.JFileChooser(javax.swing.filechooser.FileSystemView)


Occurences of JFormattedTextField (constructors)

JFormattedTextField (constructors) occurences:
javax.swing.JFormattedTextField()
javax.swing.JFormattedTextField(java.lang.Object)
javax.swing.JFormattedTextField(java.text.Format)
javax.swing.JFormattedTextField(javax.swing.JFormattedTextField.AbstractFormatter)
javax.swing.JFormattedTextField(javax.swing.JFormattedTextField.AbstractFormatterFactory)
javax.swing.JFormattedTextField(javax.swing.JFormattedTextField.AbstractFormatterFactory, java.lang.Object)


Occurences of JFrame (constructors)

JFrame (constructors) occurences:
javax.swing.JFrame()
javax.swing.JFrame(java.awt.GraphicsConfiguration)
javax.swing.JFrame(java.lang.String)
javax.swing.JFrame(java.lang.String, java.awt.GraphicsConfiguration)


Occurences of JInternalFrame (constructors)

JInternalFrame (constructors) occurences:
javax.swing.JInternalFrame()
javax.swing.JInternalFrame(java.lang.String)
javax.swing.JInternalFrame(java.lang.String, boolean)
javax.swing.JInternalFrame(java.lang.String, boolean, boolean)
javax.swing.JInternalFrame(java.lang.String, boolean, boolean, boolean)
javax.swing.JInternalFrame(java.lang.String, boolean, boolean, boolean, boolean)


Occurences of JIS_B0

JIS_B0 occurences:
java.awt.JIS_B0
javax.print.attribute.standard.JIS_B0


Occurences of JIS_B1

JIS_B1 occurences:
java.awt.JIS_B1
javax.print.attribute.standard.JIS_B1


Occurences of JIS_B10

JIS_B10 occurences:
java.awt.JIS_B10
javax.print.attribute.standard.JIS_B10


Occurences of JIS_B2

JIS_B2 occurences:
java.awt.JIS_B2
javax.print.attribute.standard.JIS_B2


Occurences of JIS_B3

JIS_B3 occurences:
java.awt.JIS_B3
javax.print.attribute.standard.JIS_B3


Occurences of JIS_B4

JIS_B4 occurences:
java.awt.JIS_B4
javax.print.attribute.standard.JIS_B4


Occurences of JIS_B5

JIS_B5 occurences:
java.awt.JIS_B5
javax.print.attribute.standard.JIS_B5


Occurences of JIS_B6

JIS_B6 occurences:
java.awt.JIS_B6
javax.print.attribute.standard.JIS_B6


Occurences of JIS_B7

JIS_B7 occurences:
java.awt.JIS_B7
javax.print.attribute.standard.JIS_B7


Occurences of JIS_B8

JIS_B8 occurences:
java.awt.JIS_B8
javax.print.attribute.standard.JIS_B8


Occurences of JIS_B9

JIS_B9 occurences:
java.awt.JIS_B9
javax.print.attribute.standard.JIS_B9


Occurences of JLabel (constructors)

JLabel (constructors) occurences:
javax.swing.JLabel()
javax.swing.JLabel(java.lang.String)
javax.swing.JLabel(java.lang.String, int)
javax.swing.JLabel(java.lang.String, javax.swing.Icon, int)
javax.swing.JLabel(javax.swing.Icon)
javax.swing.JLabel(javax.swing.Icon, int)


Occurences of JList (constructors)

JList (constructors) occurences:
javax.swing.JList()
javax.swing.JList(java.lang.Object[])
javax.swing.JList(java.util.Vector)
javax.swing.JList(javax.swing.ListModel)


Occurences of JMenu (constructors)

JMenu (constructors) occurences:
javax.swing.JMenu()
javax.swing.JMenu(java.lang.String)
javax.swing.JMenu(java.lang.String, boolean)
javax.swing.JMenu(javax.swing.Action)


Occurences of JMenuItem (constructors)

JMenuItem (constructors) occurences:
javax.swing.JMenuItem()
javax.swing.JMenuItem(java.lang.String)
javax.swing.JMenuItem(java.lang.String, int)
javax.swing.JMenuItem(java.lang.String, javax.swing.Icon)
javax.swing.JMenuItem(javax.swing.Action)
javax.swing.JMenuItem(javax.swing.Icon)


Occurences of JMException (constructors)

JMException (constructors) occurences:
javax.management.JMException()
javax.management.JMException(java.lang.String)


Occurences of JMRuntimeException (constructors)

JMRuntimeException (constructors) occurences:
javax.management.JMRuntimeException()
javax.management.JMRuntimeException(java.lang.String)


Occurences of JMXConnectorServer (constructors)

JMXConnectorServer (constructors) occurences:
javax.management.remote.JMXConnectorServer()
javax.management.remote.JMXConnectorServer(javax.management.MBeanServer)


Occurences of JMXProviderException (constructors)

JMXProviderException (constructors) occurences:
javax.management.remote.JMXProviderException()
javax.management.remote.JMXProviderException(java.lang.String)
javax.management.remote.JMXProviderException(java.lang.String, java.lang.Throwable)


Occurences of JMXServiceURL (constructors)

JMXServiceURL (constructors) occurences:
javax.management.remote.JMXServiceURL(java.lang.String)
javax.management.remote.JMXServiceURL(java.lang.String, java.lang.String, int)
javax.management.remote.JMXServiceURL(java.lang.String, java.lang.String, int, java.lang.String)


Occurences of JNDI Change History

JNDI Change History occurences:
JNDI Change History
JNDI Change History


Occurences of JNI Functions

JNI Functions occurences:
JNI Functions
JNI Functions


Occurences of JNI Types and Data Structures

JNI Types and Data Structures occurences:
JNI Types and Data Structures
JNI Types and Data Structures


Occurences of JobAttributes (constructors)

JobAttributes (constructors) occurences:
java.awt.JobAttributes()
java.awt.JobAttributes(int, java.awt.JobAttributes.DefaultSelectionType, java.awt.JobAttributes.DestinationType, java.awt.JobAttributes.DialogType, java.lang.String, int, int, java.awt.JobAttributes.MultipleDocumentHandlingType, int[][], java.lang.String, java.awt.JobAttributes.SidesType)
java.awt.JobAttributes(java.awt.JobAttributes)


Occurences of JobStateReasons (constructors)

JobStateReasons (constructors) occurences:
javax.print.attribute.standard.JobStateReasons()
javax.print.attribute.standard.JobStateReasons(int)
javax.print.attribute.standard.JobStateReasons(int, float)
javax.print.attribute.standard.JobStateReasons(java.util.Collection)


Occurences of join

join occurences:
java.lang.Thread.join()
java.lang.Thread.join(long)
java.lang.Thread.join(long, int)
java.net.DatagramSocketImpl.join(java.net.InetAddress)


Occurences of joinGroup

joinGroup occurences:
java.net.DatagramSocketImpl.joinGroup(java.net.SocketAddress, java.net.NetworkInterface)
java.net.MulticastSocket.joinGroup(java.net.InetAddress)
java.net.MulticastSocket.joinGroup(java.net.SocketAddress, java.net.NetworkInterface)


Occurences of JOptionPane (constructors)

JOptionPane (constructors) occurences:
javax.swing.JOptionPane()
javax.swing.JOptionPane(java.lang.Object)
javax.swing.JOptionPane(java.lang.Object, int)
javax.swing.JOptionPane(java.lang.Object, int, int)
javax.swing.JOptionPane(java.lang.Object, int, int, javax.swing.Icon)
javax.swing.JOptionPane(java.lang.Object, int, int, javax.swing.Icon, java.lang.Object[])
javax.swing.JOptionPane(java.lang.Object, int, int, javax.swing.Icon, java.lang.Object[], java.lang.Object)


Occurences of JPanel (constructors)

JPanel (constructors) occurences:
javax.swing.JPanel()
javax.swing.JPanel(boolean)
javax.swing.JPanel(java.awt.LayoutManager)
javax.swing.JPanel(java.awt.LayoutManager, boolean)


Occurences of JPasswordField (constructors)

JPasswordField (constructors) occurences:
javax.swing.JPasswordField()
javax.swing.JPasswordField(int)
javax.swing.JPasswordField(java.lang.String)
javax.swing.JPasswordField(java.lang.String, int)
javax.swing.JPasswordField(javax.swing.text.Document, java.lang.String, int)


Occurences of JPEG

JPEG occurences:
javax.print.JPEG
javax.print.JPEG
javax.print.JPEG


Occurences of JPopupMenu (constructors)

JPopupMenu (constructors) occurences:
javax.swing.JPopupMenu()
javax.swing.JPopupMenu(java.lang.String)


Occurences of JProgressBar (constructors)

JProgressBar (constructors) occurences:
javax.swing.JProgressBar()
javax.swing.JProgressBar(int)
javax.swing.JProgressBar(int, int)
javax.swing.JProgressBar(int, int, int)
javax.swing.JProgressBar(javax.swing.BoundedRangeModel)


Occurences of JRadioButton (constructors)

JRadioButton (constructors) occurences:
javax.swing.JRadioButton()
javax.swing.JRadioButton(java.lang.String)
javax.swing.JRadioButton(java.lang.String, boolean)
javax.swing.JRadioButton(java.lang.String, javax.swing.Icon)
javax.swing.JRadioButton(java.lang.String, javax.swing.Icon, boolean)
javax.swing.JRadioButton(javax.swing.Action)
javax.swing.JRadioButton(javax.swing.Icon)
javax.swing.JRadioButton(javax.swing.Icon, boolean)


Occurences of JRadioButtonMenuItem (constructors)

JRadioButtonMenuItem (constructors) occurences:
javax.swing.JRadioButtonMenuItem()
javax.swing.JRadioButtonMenuItem(java.lang.String)
javax.swing.JRadioButtonMenuItem(java.lang.String, boolean)
javax.swing.JRadioButtonMenuItem(java.lang.String, javax.swing.Icon)
javax.swing.JRadioButtonMenuItem(java.lang.String, javax.swing.Icon, boolean)
javax.swing.JRadioButtonMenuItem(javax.swing.Action)
javax.swing.JRadioButtonMenuItem(javax.swing.Icon)
javax.swing.JRadioButtonMenuItem(javax.swing.Icon, boolean)


Occurences of jrunscript JavaScript built-ins All Classes

jrunscript JavaScript built-ins All Classes occurences:
jrunscript JavaScript built-ins All Classes
jrunscript JavaScript built-ins All Classes


Occurences of JScrollBar (constructors)

JScrollBar (constructors) occurences:
javax.swing.JScrollBar()
javax.swing.JScrollBar(int)
javax.swing.JScrollBar(int, int, int, int, int)


Occurences of JScrollPane (constructors)

JScrollPane (constructors) occurences:
javax.swing.JScrollPane()
javax.swing.JScrollPane(int, int)
javax.swing.JScrollPane(java.awt.Component)
javax.swing.JScrollPane(java.awt.Component, int, int)


Occurences of JSeparator (constructors)

JSeparator (constructors) occurences:
javax.swing.JSeparator()
javax.swing.JSeparator(int)


Occurences of JSlider (constructors)

JSlider (constructors) occurences:
javax.swing.JSlider()
javax.swing.JSlider(int)
javax.swing.JSlider(int, int)
javax.swing.JSlider(int, int, int)
javax.swing.JSlider(int, int, int, int)
javax.swing.JSlider(javax.swing.BoundedRangeModel)


Occurences of JSpinner (constructors)

JSpinner (constructors) occurences:
javax.swing.JSpinner()
javax.swing.JSpinner(javax.swing.SpinnerModel)


Occurences of JSpinner.DateEditor (constructors)

JSpinner.DateEditor (constructors) occurences:
javax.swing.JSpinner.DateEditor(javax.swing.JSpinner)
javax.swing.JSpinner.DateEditor(javax.swing.JSpinner, java.lang.String)


Occurences of JSpinner.NumberEditor (constructors)

JSpinner.NumberEditor (constructors) occurences:
javax.swing.JSpinner.NumberEditor(javax.swing.JSpinner)
javax.swing.JSpinner.NumberEditor(javax.swing.JSpinner, java.lang.String)


Occurences of JSplitPane (constructors)

JSplitPane (constructors) occurences:
javax.swing.JSplitPane()
javax.swing.JSplitPane(int)
javax.swing.JSplitPane(int, boolean)
javax.swing.JSplitPane(int, boolean, java.awt.Component, java.awt.Component)
javax.swing.JSplitPane(int, java.awt.Component, java.awt.Component)


Occurences of JTabbedPane (constructors)

JTabbedPane (constructors) occurences:
javax.swing.JTabbedPane()
javax.swing.JTabbedPane(int)
javax.swing.JTabbedPane(int, int)


Occurences of JTable (constructors)

JTable (constructors) occurences:
javax.swing.JTable()
javax.swing.JTable(int, int)
javax.swing.JTable(java.lang.Object[][], java.lang.Object[])
javax.swing.JTable(java.util.Vector, java.util.Vector)
javax.swing.JTable(javax.swing.table.TableModel)
javax.swing.JTable(javax.swing.table.TableModel, javax.swing.table.TableColumnModel)
javax.swing.JTable(javax.swing.table.TableModel, javax.swing.table.TableColumnModel, javax.swing.ListSelectionModel)


Occurences of JTableHeader (constructors)

JTableHeader (constructors) occurences:
javax.swing.table.JTableHeader()
javax.swing.table.JTableHeader(javax.swing.table.TableColumnModel)


Occurences of JTextArea (constructors)

JTextArea (constructors) occurences:
javax.swing.JTextArea()
javax.swing.JTextArea(int, int)
javax.swing.JTextArea(java.lang.String)
javax.swing.JTextArea(java.lang.String, int, int)
javax.swing.JTextArea(javax.swing.text.Document)
javax.swing.JTextArea(javax.swing.text.Document, java.lang.String, int, int)


Occurences of JTextField (constructors)

JTextField (constructors) occurences:
javax.swing.JTextField()
javax.swing.JTextField(int)
javax.swing.JTextField(java.lang.String)
javax.swing.JTextField(java.lang.String, int)
javax.swing.JTextField(javax.swing.text.Document, java.lang.String, int)


Occurences of JTextPane (constructors)

JTextPane (constructors) occurences:
javax.swing.JTextPane()
javax.swing.JTextPane(javax.swing.text.StyledDocument)


Occurences of JToggleButton (constructors)

JToggleButton (constructors) occurences:
javax.swing.JToggleButton()
javax.swing.JToggleButton(java.lang.String)
javax.swing.JToggleButton(java.lang.String, boolean)
javax.swing.JToggleButton(java.lang.String, javax.swing.Icon)
javax.swing.JToggleButton(java.lang.String, javax.swing.Icon, boolean)
javax.swing.JToggleButton(javax.swing.Action)
javax.swing.JToggleButton(javax.swing.Icon)
javax.swing.JToggleButton(javax.swing.Icon, boolean)


Occurences of JToolBar (constructors)

JToolBar (constructors) occurences:
javax.swing.JToolBar()
javax.swing.JToolBar(int)
javax.swing.JToolBar(java.lang.String)
javax.swing.JToolBar(java.lang.String, int)


Occurences of JToolBar.Separator (constructors)

JToolBar.Separator (constructors) occurences:
javax.swing.JToolBar.Separator()
javax.swing.JToolBar.Separator(java.awt.Dimension)


Occurences of JTree (constructors)

JTree (constructors) occurences:
javax.swing.JTree()
javax.swing.JTree(java.lang.Object[])
javax.swing.JTree(java.util.Hashtable)
javax.swing.JTree(java.util.Vector)
javax.swing.JTree(javax.swing.tree.TreeModel)
javax.swing.JTree(javax.swing.tree.TreeNode)
javax.swing.JTree(javax.swing.tree.TreeNode, boolean)


Occurences of JULY

JULY occurences:
java.util.JULY
javax.xml.datatype.JULY


Occurences of JUNE

JUNE occurences:
java.util.JUNE
javax.xml.datatype.JUNE


Occurences of JWindow (constructors)

JWindow (constructors) occurences:
javax.swing.JWindow()
javax.swing.JWindow(java.awt.Frame)
javax.swing.JWindow(java.awt.GraphicsConfiguration)
javax.swing.JWindow(java.awt.Window)
javax.swing.JWindow(java.awt.Window, java.awt.GraphicsConfiguration)


Occurences of KANNADA

KANNADA occurences:
java.awt.font.KANNADA
java.lang.KANNADA


Occurences of KEEP

KEEP occurences:
java.util.jar.KEEP
java.util.jar.KEEP


Occurences of KerberosKey (constructors)

KerberosKey (constructors) occurences:
javax.security.auth.kerberos.KerberosKey(javax.security.auth.kerberos.KerberosPrincipal, byte[], int, int)
javax.security.auth.kerberos.KerberosKey(javax.security.auth.kerberos.KerberosPrincipal, char[], java.lang.String)


Occurences of KerberosPrincipal (constructors)

KerberosPrincipal (constructors) occurences:
javax.security.auth.kerberos.KerberosPrincipal(java.lang.String)
javax.security.auth.kerberos.KerberosPrincipal(java.lang.String, int)


Occurences of key

key occurences:
java.awt.key
javax.accessibility.key
javax.swing.text.key


Occurences of KeyAlreadyExistsException (constructors)

KeyAlreadyExistsException (constructors) occurences:
javax.management.openmbean.KeyAlreadyExistsException()
javax.management.openmbean.KeyAlreadyExistsException(java.lang.String)


Occurences of KeyEvent (constructors)

KeyEvent (constructors) occurences:
java.awt.event.KeyEvent(java.awt.Component, int, long, int, int)
java.awt.event.KeyEvent(java.awt.Component, int, long, int, int, char)
java.awt.event.KeyEvent(java.awt.Component, int, long, int, int, char, int)


Occurences of KeyException (constructors)

KeyException (constructors) occurences:
java.security.KeyException()
java.security.KeyException(java.lang.String)
java.security.KeyException(java.lang.String, java.lang.Throwable)
java.security.KeyException(java.lang.Throwable)


Occurences of keyFor

keyFor occurences:
java.nio.channels.SelectableChannel.keyFor(java.nio.channels.Selector)
java.nio.channels.spi.AbstractSelectableChannel.keyFor(java.nio.channels.Selector)


Occurences of keyListener

keyListener occurences:
javax.swing.plaf.basic.keyListener
javax.swing.plaf.basic.keyListener
javax.swing.plaf.basic.keyListener


Occurences of KeyManagementException (constructors)

KeyManagementException (constructors) occurences:
java.security.KeyManagementException()
java.security.KeyManagementException(java.lang.String)
java.security.KeyManagementException(java.lang.String, java.lang.Throwable)
java.security.KeyManagementException(java.lang.Throwable)


Occurences of keyPressed

keyPressed occurences:
Class LWTextComponent.LWTextComponent.keyPressed(java.awt.event.KeyEvent)
java.awt.AWTEventMulticaster.keyPressed(java.awt.event.KeyEvent)
java.awt.event.KeyAdapter.keyPressed(java.awt.event.KeyEvent)
java.awt.event.KeyListener.keyPressed(java.awt.event.KeyEvent)
javax.swing.plaf.basic.BasicComboBoxUI.KeyHandler.keyPressed(java.awt.event.KeyEvent)
javax.swing.plaf.basic.BasicTableUI.KeyHandler.keyPressed(java.awt.event.KeyEvent)
javax.swing.plaf.basic.BasicTreeUI.KeyHandler.keyPressed(java.awt.event.KeyEvent)


Occurences of keyReleased

keyReleased occurences:
Class LWTextComponent.LWTextComponent.keyReleased(java.awt.event.KeyEvent)
java.awt.AWTEventMulticaster.keyReleased(java.awt.event.KeyEvent)
java.awt.event.KeyAdapter.keyReleased(java.awt.event.KeyEvent)
java.awt.event.KeyListener.keyReleased(java.awt.event.KeyEvent)
javax.swing.plaf.basic.BasicComboPopup.InvocationKeyHandler.keyReleased(java.awt.event.KeyEvent)
javax.swing.plaf.basic.BasicTableUI.KeyHandler.keyReleased(java.awt.event.KeyEvent)
javax.swing.plaf.basic.BasicTreeUI.KeyHandler.keyReleased(java.awt.event.KeyEvent)


Occurences of keys

keys occurences:
java.nio.channels.Selector.keys()
java.security.Provider.keys()
java.util.concurrent.ConcurrentHashMap.keys()
java.util.Dictionary.keys()
java.util.Hashtable.keys()
java.util.prefs.AbstractPreferences.keys()
java.util.prefs.Preferences.keys()
javax.swing.ActionMap.keys()
javax.swing.InputMap.keys()


Occurences of KeySelectorException (constructors)

KeySelectorException (constructors) occurences:
javax.xml.crypto.KeySelectorException()
javax.xml.crypto.KeySelectorException(java.lang.String)
javax.xml.crypto.KeySelectorException(java.lang.String, java.lang.Throwable)
javax.xml.crypto.KeySelectorException(java.lang.Throwable)


Occurences of keySet

keySet occurences:
java.awt.RenderingHints.keySet()
java.security.Provider.keySet()
java.util.AbstractMap.keySet()
java.util.concurrent.ConcurrentHashMap.keySet()
java.util.concurrent.ConcurrentNavigableMap.keySet()
java.util.concurrent.ConcurrentSkipListMap.keySet()
java.util.EnumMap.keySet()
java.util.HashMap.keySet()
java.util.Hashtable.keySet()
java.util.IdentityHashMap.keySet()
java.util.jar.Attributes.keySet()
java.util.Map.keySet()
java.util.ResourceBundle.keySet()
java.util.SortedMap.keySet()
java.util.TreeMap.keySet()
java.util.WeakHashMap.keySet()
javax.management.openmbean.CompositeType.keySet()
javax.management.openmbean.TabularData.keySet()
javax.management.openmbean.TabularDataSupport.keySet()
javax.script.SimpleBindings.keySet()


Occurences of KeyStoreBuilderParameters (constructors)

KeyStoreBuilderParameters (constructors) occurences:
javax.net.ssl.KeyStoreBuilderParameters(java.security.KeyStore.Builder)
javax.net.ssl.KeyStoreBuilderParameters(java.util.List)


Occurences of KeyStoreException (constructors)

KeyStoreException (constructors) occurences:
java.security.KeyStoreException()
java.security.KeyStoreException(java.lang.String)
java.security.KeyStoreException(java.lang.String, java.lang.Throwable)
java.security.KeyStoreException(java.lang.Throwable)


Occurences of keytool-Key and Certificate Management Tool

keytool-Key and Certificate Management Tool occurences:
keytool-Key and Certificate Management Tool
keytool-Key and Certificate Management Tool


Occurences of keyTyped

keyTyped occurences:
Class LWTextComponent.LWTextComponent.keyTyped(java.awt.event.KeyEvent)
java.awt.AWTEventMulticaster.keyTyped(java.awt.event.KeyEvent)
java.awt.event.KeyAdapter.keyTyped(java.awt.event.KeyEvent)
java.awt.event.KeyListener.keyTyped(java.awt.event.KeyEvent)
javax.swing.plaf.basic.BasicTableUI.KeyHandler.keyTyped(java.awt.event.KeyEvent)
javax.swing.plaf.basic.BasicTreeUI.KeyHandler.keyTyped(java.awt.event.KeyEvent)


Occurences of KHMER

KHMER occurences:
java.awt.font.KHMER
java.lang.KHMER


Occurences of kind

kind occurences:
com.sun.javadoc.Tag.kind()
javax.tools.kind
org.omg.CORBA.TypeCode.kind()
org.omg.CosNaming.kind


Occurences of label

label occurences:
com.sun.javadoc.SeeTag.label()
com.sun.jdi.connect.Connector.Argument.label()
org.omg.CORBA.label


Occurences of LABEL

LABEL occurences:
javax.accessibility.LABEL
javax.swing.plaf.synth.LABEL


Occurences of Label (constructors)

Label (constructors) occurences:
java.awt.Label()
java.awt.Label(java.lang.String)
java.awt.Label(java.lang.String, int)


Occurences of LANDSCAPE

LANDSCAPE occurences:
java.awt.LANDSCAPE
java.awt.print.LANDSCAPE
javax.print.attribute.standard.LANDSCAPE


Occurences of LANGUAGE

LANGUAGE occurences:
java.text.LANGUAGE
javax.naming.LANGUAGE
javax.script.LANGUAGE
javax.swing.text.html.LANGUAGE


Occurences of LAO

LAO occurences:
java.awt.font.LAO
java.lang.LAO


Occurences of largeModel

largeModel occurences:
javax.swing.largeModel
javax.swing.plaf.basic.largeModel


Occurences of last

last occurences:
java.awt.CardLayout.last(java.awt.Container)
java.sql.ResultSet.last()
java.text.BreakIterator.last()
java.text.CharacterIterator.last()
java.text.StringCharacterIterator.last()
java.util.concurrent.ConcurrentSkipListSet.last()
java.util.SortedSet.last()
java.util.TreeSet.last()
javax.swing.text.Segment.last()


Occurences of lastElement

lastElement occurences:
java.util.Vector.lastElement()
javax.swing.DefaultListModel.lastElement()


Occurences of lastEntry

lastEntry occurences:
java.util.concurrent.ConcurrentSkipListMap.lastEntry()
java.util.NavigableMap.lastEntry()
java.util.TreeMap.lastEntry()


Occurences of lastIndexOf

lastIndexOf occurences:
java.lang.String.lastIndexOf(int)
java.lang.String.lastIndexOf(int, int)
java.lang.String.lastIndexOf(java.lang.String)
java.lang.String.lastIndexOf(java.lang.String, int)
java.lang.StringBuffer.lastIndexOf(java.lang.String)
java.lang.StringBuffer.lastIndexOf(java.lang.String, int)
java.lang.StringBuilder.lastIndexOf(java.lang.String)
java.lang.StringBuilder.lastIndexOf(java.lang.String, int)
java.util.AbstractList.lastIndexOf(java.lang.Object)
java.util.ArrayList.lastIndexOf(java.lang.Object)
java.util.concurrent.CopyOnWriteArrayList.lastIndexOf(E, int)
java.util.concurrent.CopyOnWriteArrayList.lastIndexOf(java.lang.Object)
java.util.concurrent.CopyOnWriteArrayList.lastIndexOf(java.lang.Object,int)
java.util.LinkedList.lastIndexOf(java.lang.Object)
java.util.List.lastIndexOf(java.lang.Object)
java.util.Vector.lastIndexOf(java.lang.Object)
java.util.Vector.lastIndexOf(java.lang.Object, int)
javax.swing.DefaultListModel.lastIndexOf(java.lang.Object)
javax.swing.DefaultListModel.lastIndexOf(java.lang.Object, int)


Occurences of lastKey

lastKey occurences:
java.util.concurrent.ConcurrentSkipListMap.lastKey()
java.util.SortedMap.lastKey()
java.util.TreeMap.lastKey()


Occurences of lastRow

lastRow occurences:
javax.swing.event.lastRow
javax.swing.lastRow
javax.swing.tree.lastRow


Occurences of layout

layout occurences:
java.awt.Component.layout()
java.awt.Container.layout()
java.awt.ScrollPane.layout()
javax.swing.text.BoxView.layout(int, int)
javax.swing.text.FlowView.layout(int, int)
javax.swing.text.FlowView.FlowStrategy.layout(javax.swing.text.FlowView)


Occurences of layoutCompoundLabel

layoutCompoundLabel occurences:
javax.swing.SwingUtilities.layoutCompoundLabel(java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int)
javax.swing.SwingUtilities.layoutCompoundLabel(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int)


Occurences of layoutContainer

layoutContainer occurences:
java.awt.BorderLayout.layoutContainer(java.awt.Container)
java.awt.CardLayout.layoutContainer(java.awt.Container)
java.awt.FlowLayout.layoutContainer(java.awt.Container)
java.awt.GridBagLayout.layoutContainer(java.awt.Container)
java.awt.GridLayout.layoutContainer(java.awt.Container)
java.awt.LayoutManager.layoutContainer(java.awt.Container)
javax.swing.BoxLayout.layoutContainer(java.awt.Container)
javax.swing.GroupLayout.layoutContainer(java.awt.Container)
javax.swing.JRootPane.RootLayout.layoutContainer(java.awt.Container)
javax.swing.JSpinner.DefaultEditor.layoutContainer(java.awt.Container)
javax.swing.OverlayLayout.layoutContainer(java.awt.Container)
javax.swing.plaf.basic.BasicComboBoxUI.ComboBoxLayoutManager.layoutContainer(java.awt.Container)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.TitlePaneLayout.layoutContainer(java.awt.Container)
javax.swing.plaf.basic.BasicInternalFrameUI.InternalFrameLayout.layoutContainer(java.awt.Container)
javax.swing.plaf.basic.BasicOptionPaneUI.ButtonAreaLayout.layoutContainer(java.awt.Container)
javax.swing.plaf.basic.BasicScrollBarUI.layoutContainer(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneDivider.DividerLayout.layoutContainer(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.layoutContainer(java.awt.Container)
javax.swing.plaf.basic.BasicTabbedPaneUI.TabbedPaneLayout.layoutContainer(java.awt.Container)
javax.swing.plaf.metal.MetalComboBoxUI.MetalComboBoxLayoutManager.layoutContainer(java.awt.Container)
javax.swing.ScrollPaneLayout.layoutContainer(java.awt.Container)
javax.swing.SpringLayout.layoutContainer(java.awt.Container)
javax.swing.ViewportLayout.layoutContainer(java.awt.Container)


Occurences of layoutMajorAxis

layoutMajorAxis occurences:
javax.swing.text.BoxView.layoutMajorAxis(int, int, int[], int[])
javax.swing.text.TableView.TableRow.layoutMajorAxis(int, int, int[], int[])


Occurences of layoutMinorAxis

layoutMinorAxis occurences:
javax.swing.text.BoxView.layoutMinorAxis(int, int, int[], int[])
javax.swing.text.html.BlockView.layoutMinorAxis(int, int, int[], int[])
javax.swing.text.TableView.layoutMinorAxis(int, int, int[], int[])
javax.swing.text.TableView.TableRow.layoutMinorAxis(int, int, int[], int[])


Occurences of lazySet

lazySet occurences:
java.util.concurrent.atomic.AtomicBoolean.lazySet(boolean)
java.util.concurrent.atomic.AtomicInteger.lazySet(int)
java.util.concurrent.atomic.AtomicIntegerArray.lazySet(int, int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.lazySet(java.lang.Object,int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.lazySet(T, int)
java.util.concurrent.atomic.AtomicLong.lazySet(long)
java.util.concurrent.atomic.AtomicLongArray.lazySet(int, long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.lazySet(java.lang.Object,long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.lazySet(T, long)
java.util.concurrent.atomic.AtomicReference.lazySet(java.lang.Object)
java.util.concurrent.atomic.AtomicReference.lazySet(V)
java.util.concurrent.atomic.AtomicReferenceArray.lazySet(int, E)
java.util.concurrent.atomic.AtomicReferenceArray.lazySet(int,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.lazySet(java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.lazySet(T, V)


Occurences of LDAPCertStoreParameters (constructors)

LDAPCertStoreParameters (constructors) occurences:
java.security.cert.LDAPCertStoreParameters()
java.security.cert.LDAPCertStoreParameters(java.lang.String)
java.security.cert.LDAPCertStoreParameters(java.lang.String, int)


Occurences of LdapName (constructors)

LdapName (constructors) occurences:
javax.naming.ldap.LdapName(java.lang.String)
javax.naming.ldap.LdapName(java.util.List)


Occurences of LdapReferralException (constructors)

LdapReferralException (constructors) occurences:
javax.naming.ldap.LdapReferralException()
javax.naming.ldap.LdapReferralException(java.lang.String)


Occurences of LEADING

LEADING occurences:
java.awt.LEADING
javax.swing.border.LEADING
javax.swing.LEADING
javax.swing.LEADING


Occurences of leaveGroup

leaveGroup occurences:
java.net.DatagramSocketImpl.leaveGroup(java.net.SocketAddress, java.net.NetworkInterface)
java.net.MulticastSocket.leaveGroup(java.net.InetAddress)
java.net.MulticastSocket.leaveGroup(java.net.SocketAddress, java.net.NetworkInterface)


Occurences of LEDGER

LEDGER occurences:
java.awt.LEDGER
javax.print.attribute.standard.LEDGER
javax.print.attribute.standard.LEDGER


Occurences of left

left occurences:
java.awt.left
javax.swing.border.left


Occurences of LEFT

LEFT occurences:
java.awt.LEFT
java.awt.LEFT
java.awt.LEFT
javax.swing.border.LEFT
javax.swing.LEFT
javax.swing.LEFT


Occurences of leftKey

leftKey occurences:
javax.swing.plaf.basic.leftKey
javax.swing.plaf.basic.leftKey
javax.swing.plaf.basic.leftKey


Occurences of LEGAL

LEGAL occurences:
java.awt.LEGAL
javax.print.attribute.standard.LEGAL


Occurences of Legend for Class Diagram

Legend for Class Diagram occurences:
Legend for Class Diagram
Legend for Class Diagram


Occurences of length

length occurences:
com.sun.jdi.ArrayReference.length()
java.io.File.length()
java.io.length
java.io.RandomAccessFile.length()
java.lang.CharSequence.length()
java.lang.String.length()
java.lang.StringBuffer.length()
java.lang.StringBuilder.length()
java.nio.CharBuffer.length()
java.nio.charset.CoderResult.length()
java.sql.Blob.length()
java.sql.Clob.length()
java.util.BitSet.length()
java.util.concurrent.atomic.AtomicIntegerArray.length()
java.util.concurrent.atomic.AtomicLongArray.length()
java.util.concurrent.atomic.AtomicReferenceArray.length()
javax.imageio.stream.FileCacheImageOutputStream.length()
javax.imageio.stream.FileImageInputStream.length()
javax.imageio.stream.FileImageOutputStream.length()
javax.imageio.stream.ImageInputStream.length()
javax.imageio.stream.ImageInputStreamImpl.length()
javax.imageio.stream.MemoryCacheImageOutputStream.length()
javax.sound.midi.length
javax.sql.rowset.serial.SerialBlob.length()
javax.sql.rowset.serial.SerialClob.length()
javax.swing.text.AbstractDocument.Content.length()
javax.swing.text.GapContent.length()
javax.swing.text.Segment.length()
javax.swing.text.StringContent.length()
org.omg.CORBA.DynSequence.length()
org.omg.CORBA.DynSequence.length(int)
org.omg.CORBA.TypeCode.length()


Occurences of LETTER

LETTER occurences:
java.awt.LETTER
javax.print.attribute.standard.LETTER


Occurences of Level (constructors)

Level (constructors) occurences:
java.util.logging.Level(java.lang.String, int)
java.util.logging.Level(java.lang.String, int, java.lang.String)


Occurences of lightHighlight

lightHighlight occurences:
javax.swing.plaf.basic.lightHighlight
javax.swing.plaf.basic.lightHighlight
javax.swing.plaf.basic.lightHighlight


Occurences of lightWeightPopupEnabled

lightWeightPopupEnabled occurences:
javax.swing.lightWeightPopupEnabled
javax.swing.lightWeightPopupEnabled


Occurences of limit

limit occurences:
java.nio.Buffer.limit()
java.nio.Buffer.limit(int)


Occurences of LimitExceededException (constructors)

LimitExceededException (constructors) occurences:
javax.naming.LimitExceededException()
javax.naming.LimitExceededException(java.lang.String)


Occurences of line

line occurences:
com.sun.javadoc.SourcePosition.line()
com.sun.mirror.util.SourcePosition.line()
java.text.line


Occurences of Line2D.Double (constructors)

Line2D.Double (constructors) occurences:
java.awt.geom.Line2D.Double()
java.awt.geom.Line2D.Double(double, double, double, double)
java.awt.geom.Line2D.Double(java.awt.geom.Point2D, java.awt.geom.Point2D)


Occurences of Line2D.Float (constructors)

Line2D.Float (constructors) occurences:
java.awt.geom.Line2D.Float()
java.awt.geom.Line2D.Float(float, float, float, float)
java.awt.geom.Line2D.Float(java.awt.geom.Point2D, java.awt.geom.Point2D)


Occurences of LinearGradientPaint (constructors)

LinearGradientPaint (constructors) occurences:
java.awt.LinearGradientPaint(float, float, float, float, float[], java.awt.Color[])
java.awt.LinearGradientPaint(float, float, float, float, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod)
java.awt.LinearGradientPaint(java.awt.geom.Point2D, java.awt.geom.Point2D, float[], java.awt.Color[])
java.awt.LinearGradientPaint(java.awt.geom.Point2D, java.awt.geom.Point2D, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod)
java.awt.LinearGradientPaint(java.awt.geom.Point2D, java.awt.geom.Point2D, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod, java.awt.MultipleGradientPaint.ColorSpaceType, java.awt.geom.AffineTransform)


Occurences of LineBorder (constructors)

LineBorder (constructors) occurences:
javax.swing.border.LineBorder(java.awt.Color)
javax.swing.border.LineBorder(java.awt.Color, int)
javax.swing.border.LineBorder(java.awt.Color, int, boolean)


Occurences of LineBreakMeasurer (constructors)

LineBreakMeasurer (constructors) occurences:
java.awt.font.LineBreakMeasurer(java.text.AttributedCharacterIterator, java.awt.font.FontRenderContext)
java.awt.font.LineBreakMeasurer(java.text.AttributedCharacterIterator, java.text.BreakIterator, java.awt.font.FontRenderContext)


Occurences of lineNumber

lineNumber occurences:
com.sun.jdi.Location.lineNumber()
com.sun.jdi.Location.lineNumber(java.lang.String)


Occurences of LineNumberReader (constructors)

LineNumberReader (constructors) occurences:
java.io.LineNumberReader(java.io.Reader)
java.io.LineNumberReader(java.io.Reader, int)


Occurences of lineTo

lineTo occurences:
java.awt.geom.Path2D.lineTo(double, double)
java.awt.geom.Path2D.Double.lineTo(double, double)
java.awt.geom.Path2D.Float.lineTo(double, double)
java.awt.geom.Path2D.Float.lineTo(float, float)


Occurences of LineUnavailableException (constructors)

LineUnavailableException (constructors) occurences:
javax.sound.sampled.LineUnavailableException()
javax.sound.sampled.LineUnavailableException(java.lang.String)


Occurences of LINE_END

LINE_END occurences:
java.awt.LINE_END
java.awt.LINE_END


Occurences of LINE_START

LINE_START occurences:
java.awt.LINE_START
java.awt.LINE_START


Occurences of LINK

LINK occurences:
javax.swing.LINK
javax.swing.text.html.LINK
javax.swing.text.html.LINK


Occurences of LinkageError (constructors)

LinkageError (constructors) occurences:
java.lang.LinkageError()
java.lang.LinkageError(java.lang.String)


Occurences of LinkedBlockingDeque (constructors)

LinkedBlockingDeque (constructors) occurences:
java.util.concurrent.LinkedBlockingDeque()
java.util.concurrent.LinkedBlockingDeque(int)
java.util.concurrent.LinkedBlockingDeque(java.util.Collection)


Occurences of LinkedBlockingQueue (constructors)

LinkedBlockingQueue (constructors) occurences:
java.util.concurrent.LinkedBlockingQueue()
java.util.concurrent.LinkedBlockingQueue(int)
java.util.concurrent.LinkedBlockingQueue(java.util.Collection)


Occurences of LinkedHashMap (constructors)

LinkedHashMap (constructors) occurences:
java.util.LinkedHashMap()
java.util.LinkedHashMap(int)
java.util.LinkedHashMap(int, float)
java.util.LinkedHashMap(int, float, boolean)
java.util.LinkedHashMap(java.util.Map)


Occurences of LinkedHashSet (constructors)

LinkedHashSet (constructors) occurences:
java.util.LinkedHashSet()
java.util.LinkedHashSet(int)
java.util.LinkedHashSet(int, float)
java.util.LinkedHashSet(java.util.Collection)


Occurences of LinkedList (constructors)

LinkedList (constructors) occurences:
java.util.LinkedList()
java.util.LinkedList(java.util.Collection)


Occurences of LinkException (constructors)

LinkException (constructors) occurences:
javax.naming.LinkException()
javax.naming.LinkException(java.lang.String)


Occurences of LinkLoopException (constructors)

LinkLoopException (constructors) occurences:
javax.naming.LinkLoopException()
javax.naming.LinkLoopException(java.lang.String)


Occurences of LinkRef (constructors)

LinkRef (constructors) occurences:
javax.naming.LinkRef(java.lang.String)
javax.naming.LinkRef(javax.naming.Name)


Occurences of linkSize

linkSize occurences:
javax.swing.GroupLayout.linkSize(int, java.awt.Component...)
javax.swing.GroupLayout.linkSize(java.awt.Component...)


Occurences of list

list occurences:
com.sun.tools.attach.VirtualMachine.list()
java.awt.Component.list()
java.awt.Component.list(java.io.PrintStream)
java.awt.Component.list(java.io.PrintStream, int)
java.awt.Component.list(java.io.PrintWriter)
java.awt.Component.list(java.io.PrintWriter, int)
java.awt.Container.list(java.io.PrintStream, int)
java.awt.Container.list(java.io.PrintWriter, int)
java.io.File.list()
java.io.File.list(java.io.FilenameFilter)
java.lang.ThreadGroup.list()
java.rmi.Naming.list(java.lang.String)
java.rmi.registry.Registry.list()
java.util.Collections.list(java.util.Enumeration)
java.util.Properties.list(java.io.PrintStream)
java.util.Properties.list(java.io.PrintWriter)
javax.naming.Context.list(java.lang.String)
javax.naming.Context.list(javax.naming.Name)
javax.naming.InitialContext.list(java.lang.String)
javax.naming.InitialContext.list(javax.naming.Name)
javax.swing.plaf.basic.list
javax.swing.plaf.basic.list
javax.tools.ForwardingJavaFileManager.list(javax.tools.JavaFileManager.Location, java.lang.String, java.util.Set, boolean)
javax.tools.JavaFileManager.list(javax.tools.JavaFileManager.Location, java.lang.String, java.util.Set, boolean)
org.omg.CosNaming.NamingContextOperations.list(int, org.omg.CosNaming.BindingListHolder, org.omg.CosNaming.BindingIteratorHolder)
org.omg.CosNaming._NamingContextExtStub.list(int, org.omg.CosNaming.BindingListHolder, org.omg.CosNaming.BindingIteratorHolder)
org.omg.CosNaming._NamingContextStub.list(int, org.omg.CosNaming.BindingListHolder, org.omg.CosNaming.BindingIteratorHolder)


Occurences of List

List occurences:
java.awt.List
java.util.List


Occurences of LIST

LIST occurences:
javax.accessibility.LIST
javax.swing.plaf.synth.LIST


Occurences of List (constructors)

List (constructors) occurences:
java.awt.List()
java.awt.List(int)
java.awt.List(int, boolean)


Occurences of listBindings

listBindings occurences:
javax.naming.Context.listBindings(java.lang.String)
javax.naming.Context.listBindings(javax.naming.Name)
javax.naming.InitialContext.listBindings(java.lang.String)
javax.naming.InitialContext.listBindings(javax.naming.Name)


Occurences of listBox

listBox occurences:
javax.swing.plaf.basic.listBox
javax.swing.plaf.metal.listBox


Occurences of listDataListener

listDataListener occurences:
javax.swing.plaf.basic.listDataListener
javax.swing.plaf.basic.listDataListener
javax.swing.plaf.basic.listDataListener


Occurences of listenerList

listenerList occurences:
javax.swing.colorchooser.listenerList
javax.swing.event.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.listenerList
javax.swing.table.listenerList
javax.swing.table.listenerList
javax.swing.text.listenerList
javax.swing.text.listenerList
javax.swing.text.listenerList
javax.swing.tree.listenerList
javax.swing.tree.listenerList


Occurences of ListenerNotFoundException (constructors)

ListenerNotFoundException (constructors) occurences:
javax.management.ListenerNotFoundException()
javax.management.ListenerNotFoundException(java.lang.String)


Occurences of listFiles

listFiles occurences:
java.io.File.listFiles()
java.io.File.listFiles(java.io.FileFilter)
java.io.File.listFiles(java.io.FilenameFilter)


Occurences of listIterator

listIterator occurences:
java.util.AbstractList.listIterator()
java.util.AbstractList.listIterator(int)
java.util.AbstractSequentialList.listIterator(int)
java.util.concurrent.CopyOnWriteArrayList.listIterator()
java.util.concurrent.CopyOnWriteArrayList.listIterator(int)
java.util.LinkedList.listIterator(int)
java.util.List.listIterator()
java.util.List.listIterator(int)


Occurences of listSelectionListener

listSelectionListener occurences:
javax.swing.plaf.basic.listSelectionListener
javax.swing.plaf.basic.listSelectionListener


Occurences of LITERAL

LITERAL occurences:
java.util.regex.LITERAL
javax.jws.soap.LITERAL


Occurences of load

load occurences:
Class GLOBALS.load
java.lang.Runtime.load(java.lang.String)
java.lang.System.load(java.lang.String)
java.nio.MappedByteBuffer.load()
java.security.KeyStore.load(java.io.InputStream, char[])
java.security.KeyStore.load(java.security.KeyStore.LoadStoreParameter)
java.security.Provider.load(java.io.InputStream)
java.util.Properties.load(java.io.InputStream)
java.util.Properties.load(java.io.Reader)
java.util.ServiceLoader.load(java.lang.Class)
java.util.ServiceLoader.load(java.lang.Class, java.lang.ClassLoader)
javax.management.modelmbean.RequiredModelMBean.load()
javax.management.PersistentMBean.load()
javax.swing.plaf.synth.SynthLookAndFeel.load(java.io.InputStream, java.lang.Class)
javax.swing.plaf.synth.SynthLookAndFeel.load(java.net.URL)


Occurences of loadAgent

loadAgent occurences:
com.sun.tools.attach.VirtualMachine.loadAgent(java.lang.String)
com.sun.tools.attach.VirtualMachine.loadAgent(java.lang.String, java.lang.String)


Occurences of loadAgentLibrary

loadAgentLibrary occurences:
com.sun.tools.attach.VirtualMachine.loadAgentLibrary(java.lang.String)
com.sun.tools.attach.VirtualMachine.loadAgentLibrary(java.lang.String, java.lang.String)


Occurences of loadAgentPath

loadAgentPath occurences:
com.sun.tools.attach.VirtualMachine.loadAgentPath(java.lang.String)
com.sun.tools.attach.VirtualMachine.loadAgentPath(java.lang.String, java.lang.String)


Occurences of loadChildren

loadChildren occurences:
javax.swing.JTree.DynamicUtilTreeNode.loadChildren()
javax.swing.text.AsyncBoxView.loadChildren(javax.swing.text.ViewFactory)
javax.swing.text.CompositeView.loadChildren(javax.swing.text.ViewFactory)
javax.swing.text.FlowView.loadChildren(javax.swing.text.ViewFactory)
javax.swing.text.WrappedPlainView.loadChildren(javax.swing.text.ViewFactory)
javax.swing.text.ZoneView.loadChildren(javax.swing.text.ViewFactory)


Occurences of loadClass

loadClass occurences:
java.lang.ClassLoader.loadClass(java.lang.String)
java.lang.ClassLoader.loadClass(java.lang.String, boolean)
java.rmi.server.LoaderHandler.loadClass(java.lang.String)
java.rmi.server.LoaderHandler.loadClass(java.net.URL, java.lang.String)
java.rmi.server.RMIClassLoader.loadClass(java.lang.String)
java.rmi.server.RMIClassLoader.loadClass(java.lang.String, java.lang.String)
java.rmi.server.RMIClassLoader.loadClass(java.lang.String, java.lang.String, java.lang.ClassLoader)
java.rmi.server.RMIClassLoader.loadClass(java.net.URL, java.lang.String)
java.rmi.server.RMIClassLoaderSpi.loadClass(java.lang.String, java.lang.String, java.lang.ClassLoader)
javax.management.DefaultLoaderRepository.loadClass(java.lang.String)
javax.management.loading.ClassLoaderRepository.loadClass(java.lang.String)
javax.management.loading.DefaultLoaderRepository.loadClass(java.lang.String)
javax.management.loading.MLet.loadClass(java.lang.String, javax.management.loading.ClassLoaderRepository)
javax.rmi.CORBA.Util.loadClass(java.lang.String, java.lang.String, java.lang.ClassLoader)
javax.rmi.CORBA.UtilDelegate.loadClass(java.lang.String, java.lang.String, java.lang.ClassLoader)


Occurences of loadClassWithout

loadClassWithout occurences:
javax.management.DefaultLoaderRepository.loadClassWithout(java.lang.ClassLoader, java.lang.String)
javax.management.loading.ClassLoaderRepository.loadClassWithout(java.lang.ClassLoader, java.lang.String)
javax.management.loading.DefaultLoaderRepository.loadClassWithout(java.lang.ClassLoader, java.lang.String)


Occurences of loadImage

loadImage occurences:
java.beans.SimpleBeanInfo.loadImage(java.lang.String)
javax.swing.ImageIcon.loadImage(java.awt.Image)


Occurences of loadLibrary

loadLibrary occurences:
java.lang.Runtime.loadLibrary(java.lang.String)
java.lang.System.loadLibrary(java.lang.String)


Occurences of loadProxyClass

loadProxyClass occurences:
java.rmi.server.RMIClassLoader.loadProxyClass(java.lang.String, java.lang.String[], java.lang.ClassLoader)
java.rmi.server.RMIClassLoaderSpi.loadProxyClass(java.lang.String, java.lang.String[], java.lang.ClassLoader)


Occurences of loadSystemColors

loadSystemColors occurences:
java.awt.Toolkit.loadSystemColors(int[])
javax.swing.plaf.basic.BasicLookAndFeel.loadSystemColors(javax.swing.UIDefaults, java.lang.String[], boolean)


Occurences of locale

locale occurences:
java.beans.beancontext.locale
java.util.Formatter.locale()
java.util.Scanner.locale()
javax.imageio.locale
javax.imageio.locale
javax.imageio.locale


Occurences of Locale (constructors)

Locale (constructors) occurences:
java.util.Locale(java.lang.String)
java.util.Locale(java.lang.String, java.lang.String)
java.util.Locale(java.lang.String, java.lang.String, java.lang.String)


Occurences of localName

localName occurences:
javax.xml.ws.RequestWrapper.localName()
javax.xml.ws.ResponseWrapper.localName()


Occurences of LOCAL_VARIABLE

LOCAL_VARIABLE occurences:
java.lang.annotation.LOCAL_VARIABLE
javax.lang.model.element.LOCAL_VARIABLE


Occurences of locate

locate occurences:
java.awt.Component.locate(int, int)
java.awt.Container.locate(int, int)


Occurences of Location

Location occurences:
com.sun.jdi.Location
javax.xml.stream.Location


Occurences of location

location occurences:
com.sun.jdi.Locatable.location()
com.sun.jdi.Method.location()
com.sun.jdi.request.BreakpointRequest.location()
com.sun.jdi.StackFrame.location()
java.awt.Component.location()
java.awt.GridBagLayout.location(int, int)
javax.xml.stream.location


Occurences of locationsOfLine

locationsOfLine occurences:
com.sun.jdi.Method.locationsOfLine(int)
com.sun.jdi.Method.locationsOfLine(java.lang.String, java.lang.String, int)
com.sun.jdi.ReferenceType.locationsOfLine(int)
com.sun.jdi.ReferenceType.locationsOfLine(java.lang.String, java.lang.String, int)


Occurences of locationToIndex

locationToIndex occurences:
javax.swing.JList.locationToIndex(java.awt.Point)
javax.swing.plaf.basic.BasicListUI.locationToIndex(javax.swing.JList, java.awt.Point)
javax.swing.plaf.ListUI.locationToIndex(javax.swing.JList, java.awt.Point)
javax.swing.plaf.multi.MultiListUI.locationToIndex(javax.swing.JList, java.awt.Point)


Occurences of Locator2Impl (constructors)

Locator2Impl (constructors) occurences:
org.xml.sax.ext.Locator2Impl()
org.xml.sax.ext.Locator2Impl(org.xml.sax.Locator)


Occurences of LocatorImpl (constructors)

LocatorImpl (constructors) occurences:
org.xml.sax.helpers.LocatorImpl()
org.xml.sax.helpers.LocatorImpl(org.xml.sax.Locator)


Occurences of LOCCRC

LOCCRC occurences:
java.util.jar.LOCCRC
java.util.jar.LOCCRC
java.util.jar.LOCCRC
java.util.jar.LOCCRC
java.util.zip.LOCCRC
java.util.zip.LOCCRC
java.util.zip.LOCCRC
java.util.zip.LOCCRC


Occurences of LOCEXT

LOCEXT occurences:
java.util.jar.LOCEXT
java.util.jar.LOCEXT
java.util.jar.LOCEXT
java.util.jar.LOCEXT
java.util.zip.LOCEXT
java.util.zip.LOCEXT
java.util.zip.LOCEXT
java.util.zip.LOCEXT


Occurences of LOCFLG

LOCFLG occurences:
java.util.jar.LOCFLG
java.util.jar.LOCFLG
java.util.jar.LOCFLG
java.util.jar.LOCFLG
java.util.zip.LOCFLG
java.util.zip.LOCFLG
java.util.zip.LOCFLG
java.util.zip.LOCFLG


Occurences of LOCHDR

LOCHDR occurences:
java.util.jar.LOCHDR
java.util.jar.LOCHDR
java.util.jar.LOCHDR
java.util.jar.LOCHDR
java.util.zip.LOCHDR
java.util.zip.LOCHDR
java.util.zip.LOCHDR
java.util.zip.LOCHDR


Occurences of LOCHOW

LOCHOW occurences:
java.util.jar.LOCHOW
java.util.jar.LOCHOW
java.util.jar.LOCHOW
java.util.jar.LOCHOW
java.util.zip.LOCHOW
java.util.zip.LOCHOW
java.util.zip.LOCHOW
java.util.zip.LOCHOW


Occurences of lock

lock occurences:
java.io.lock
java.io.lock
java.nio.channels.FileChannel.lock()
java.nio.channels.FileChannel.lock(long, long, boolean)
java.util.concurrent.locks.Lock.lock()
java.util.concurrent.locks.ReentrantLock.lock()
java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.lock()
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.lock()
java.util.prefs.lock


Occurences of lockInterruptibly

lockInterruptibly occurences:
java.util.concurrent.locks.Lock.lockInterruptibly()
java.util.concurrent.locks.ReentrantLock.lockInterruptibly()
java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.lockInterruptibly()
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.lockInterruptibly()


Occurences of LOCLEN

LOCLEN occurences:
java.util.jar.LOCLEN
java.util.jar.LOCLEN
java.util.jar.LOCLEN
java.util.jar.LOCLEN
java.util.zip.LOCLEN
java.util.zip.LOCLEN
java.util.zip.LOCLEN
java.util.zip.LOCLEN


Occurences of LOCNAM

LOCNAM occurences:
java.util.jar.LOCNAM
java.util.jar.LOCNAM
java.util.jar.LOCNAM
java.util.jar.LOCNAM
java.util.zip.LOCNAM
java.util.zip.LOCNAM
java.util.zip.LOCNAM
java.util.zip.LOCNAM


Occurences of LOCSIG

LOCSIG occurences:
java.util.jar.LOCSIG
java.util.jar.LOCSIG
java.util.jar.LOCSIG
java.util.jar.LOCSIG
java.util.zip.LOCSIG
java.util.zip.LOCSIG
java.util.zip.LOCSIG
java.util.zip.LOCSIG


Occurences of LOCSIZ

LOCSIZ occurences:
java.util.jar.LOCSIZ
java.util.jar.LOCSIZ
java.util.jar.LOCSIZ
java.util.jar.LOCSIZ
java.util.zip.LOCSIZ
java.util.zip.LOCSIZ
java.util.zip.LOCSIZ
java.util.zip.LOCSIZ


Occurences of LOCTIM

LOCTIM occurences:
java.util.jar.LOCTIM
java.util.jar.LOCTIM
java.util.jar.LOCTIM
java.util.jar.LOCTIM
java.util.zip.LOCTIM
java.util.zip.LOCTIM
java.util.zip.LOCTIM
java.util.zip.LOCTIM


Occurences of LOCVER

LOCVER occurences:
java.util.jar.LOCVER
java.util.jar.LOCVER
java.util.jar.LOCVER
java.util.jar.LOCVER
java.util.zip.LOCVER
java.util.zip.LOCVER
java.util.zip.LOCVER
java.util.zip.LOCVER


Occurences of log

log occurences:
java.lang.Math.log(double)
java.lang.StrictMath.log(double)
java.rmi.server.LogStream.log(java.lang.String)
java.util.logging.Logger.log(java.util.logging.Level, java.lang.String)
java.util.logging.Logger.log(java.util.logging.Level, java.lang.String, java.lang.Object)
java.util.logging.Logger.log(java.util.logging.Level, java.lang.String, java.lang.Object[])
java.util.logging.Logger.log(java.util.logging.Level, java.lang.String, java.lang.Throwable)
java.util.logging.Logger.log(java.util.logging.LogRecord)


Occurences of log10

log10 occurences:
java.lang.Math.log10(double)
java.lang.StrictMath.log10(double)


Occurences of log1p

log1p occurences:
java.lang.Math.log1p(double)
java.lang.StrictMath.log1p(double)


Occurences of login

login occurences:
java.security.AuthProvider.login(javax.security.auth.Subject, javax.security.auth.callback.CallbackHandler)
javax.security.auth.login
javax.security.auth.login.LoginContext.login()
javax.security.auth.spi.LoginModule.login()


Occurences of LoginContext (constructors)

LoginContext (constructors) occurences:
javax.security.auth.login.LoginContext(java.lang.String)
javax.security.auth.login.LoginContext(java.lang.String, javax.security.auth.callback.CallbackHandler)
javax.security.auth.login.LoginContext(java.lang.String, javax.security.auth.Subject)
javax.security.auth.login.LoginContext(java.lang.String, javax.security.auth.Subject, javax.security.auth.callback.CallbackHandler)
javax.security.auth.login.LoginContext(java.lang.String, javax.security.auth.Subject, javax.security.auth.callback.CallbackHandler, javax.security.auth.login.Configuration)


Occurences of LoginException (constructors)

LoginException (constructors) occurences:
javax.security.auth.login.LoginException()
javax.security.auth.login.LoginException(java.lang.String)


Occurences of logout

logout occurences:
java.security.AuthProvider.logout()
javax.security.auth.login.LoginContext.logout()
javax.security.auth.spi.LoginModule.logout()


Occurences of logp

logp occurences:
java.util.logging.Logger.logp(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String)
java.util.logging.Logger.logp(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String, java.lang.Object)
java.util.logging.Logger.logp(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String, java.lang.Object[])
java.util.logging.Logger.logp(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String, java.lang.Throwable)


Occurences of logrb

logrb occurences:
java.util.logging.Logger.logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
java.util.logging.Logger.logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Object)
java.util.logging.Logger.logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Object[])
java.util.logging.Logger.logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Throwable)


Occurences of LONG

LONG occurences:
com.sun.mirror.type.LONG
java.text.LONG
java.util.LONG
java.util.LONG
javax.lang.model.type.LONG
javax.management.openmbean.LONG


Occurences of Long (constructors)

Long (constructors) occurences:
java.lang.Long(java.lang.String)
java.lang.Long(long)


Occurences of LongHolder (constructors)

LongHolder (constructors) occurences:
org.omg.CORBA.LongHolder()
org.omg.CORBA.LongHolder(long)


Occurences of LongLongSeqHolder (constructors)

LongLongSeqHolder (constructors) occurences:
org.omg.CORBA.LongLongSeqHolder()
org.omg.CORBA.LongLongSeqHolder(long[])


Occurences of LongSeqHolder (constructors)

LongSeqHolder (constructors) occurences:
org.omg.CORBA.LongSeqHolder()
org.omg.CORBA.LongSeqHolder(int[])


Occurences of longValue

longValue occurences:
com.sun.jdi.PrimitiveValue.longValue()
java.lang.Byte.longValue()
java.lang.Double.longValue()
java.lang.Float.longValue()
java.lang.Integer.longValue()
java.lang.Long.longValue()
java.lang.Number.longValue()
java.lang.Short.longValue()
java.math.BigDecimal.longValue()
java.math.BigInteger.longValue()
java.util.concurrent.atomic.AtomicInteger.longValue()
java.util.concurrent.atomic.AtomicLong.longValue()


Occurences of lookup

lookup occurences:
java.io.ObjectStreamClass.lookup(java.lang.Class)
java.rmi.Naming.lookup(java.lang.String)
java.rmi.registry.Registry.lookup(java.lang.String)
javax.naming.Context.lookup(java.lang.String)
javax.naming.Context.lookup(javax.naming.Name)
javax.naming.InitialContext.lookup(java.lang.String)
javax.naming.InitialContext.lookup(javax.naming.Name)


Occurences of lookupLink

lookupLink occurences:
javax.naming.Context.lookupLink(java.lang.String)
javax.naming.Context.lookupLink(javax.naming.Name)
javax.naming.InitialContext.lookupLink(java.lang.String)
javax.naming.InitialContext.lookupLink(javax.naming.Name)


Occurences of lookupNamespaceURI

lookupNamespaceURI occurences:
javax.imageio.metadata.IIOMetadataNode.lookupNamespaceURI(java.lang.String)
org.w3c.dom.Node.lookupNamespaceURI(java.lang.String)


Occurences of lookupPixel

lookupPixel occurences:
java.awt.image.ByteLookupTable.lookupPixel(byte[], byte[])
java.awt.image.ByteLookupTable.lookupPixel(int[], int[])
java.awt.image.LookupTable.lookupPixel(int[], int[])
java.awt.image.ShortLookupTable.lookupPixel(int[], int[])
java.awt.image.ShortLookupTable.lookupPixel(short[], short[])


Occurences of lookupPrefix

lookupPrefix occurences:
javax.imageio.metadata.IIOMetadataNode.lookupPrefix(java.lang.String)
org.w3c.dom.Node.lookupPrefix(java.lang.String)


Occurences of lookupPrintServices

lookupPrintServices occurences:
java.awt.print.PrinterJob.lookupPrintServices()
javax.print.PrintServiceLookup.lookupPrintServices(javax.print.DocFlavor, javax.print.attribute.AttributeSet)


Occurences of lookupProviders

lookupProviders occurences:
javax.imageio.spi.ServiceRegistry.lookupProviders(java.lang.Class)
javax.imageio.spi.ServiceRegistry.lookupProviders(java.lang.Class, java.lang.ClassLoader)


Occurences of loop

loop occurences:
java.applet.AudioClip.loop()
javax.sound.sampled.Clip.loop(int)


Occurences of LOOP_CONTINUOUSLY

LOOP_CONTINUOUSLY occurences:
javax.sound.midi.LOOP_CONTINUOUSLY
javax.sound.sampled.LOOP_CONTINUOUSLY


Occurences of lostOwnership

lostOwnership occurences:
java.awt.datatransfer.ClipboardOwner.lostOwnership(java.awt.datatransfer.Clipboard, java.awt.datatransfer.Transferable)
java.awt.datatransfer.StringSelection.lostOwnership(java.awt.datatransfer.Clipboard, java.awt.datatransfer.Transferable)


Occurences of lower

lower occurences:
java.util.concurrent.ConcurrentSkipListSet.lower(E)
java.util.concurrent.ConcurrentSkipListSet.lower(java.lang.Object)
java.util.NavigableSet.lower(E)
java.util.NavigableSet.lower(java.lang.Object)
java.util.TreeSet.lower(E)
java.util.TreeSet.lower(java.lang.Object)


Occurences of LOWERED

LOWERED occurences:
javax.swing.border.LOWERED
javax.swing.border.LOWERED


Occurences of lowerEntry

lowerEntry occurences:
java.util.concurrent.ConcurrentSkipListMap.lowerEntry(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.lowerEntry(K)
java.util.NavigableMap.lowerEntry(java.lang.Object)
java.util.NavigableMap.lowerEntry(K)
java.util.TreeMap.lowerEntry(java.lang.Object)
java.util.TreeMap.lowerEntry(K)


Occurences of lowerKey

lowerKey occurences:
java.util.concurrent.ConcurrentSkipListMap.lowerKey(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.lowerKey(K)
java.util.NavigableMap.lowerKey(java.lang.Object)
java.util.NavigableMap.lowerKey(K)
java.util.TreeMap.lowerKey(java.lang.Object)
java.util.TreeMap.lowerKey(K)


Occurences of lowerLeft

lowerLeft occurences:
javax.swing.lowerLeft
javax.swing.lowerLeft


Occurences of lowerRight

lowerRight occurences:
javax.swing.lowerRight
javax.swing.lowerRight


Occurences of lowestOneBit

lowestOneBit occurences:
java.lang.Integer.lowestOneBit(int)
java.lang.Long.lowestOneBit(long)


Occurences of ls

ls occurences:
Class GLOBALS.ls
org.w3c.dom.ls


Occurences of lt

lt occurences:
java.io.lt
java.util.regex.lt
javax.management.Query.lt(javax.management.ValueExp, javax.management.ValueExp)
javax.swing.plaf.basic.BasicDirectoryModel.lt(java.io.File, java.io.File)


Occurences of mail

mail occurences:
java.awt.Desktop.mail()
java.awt.Desktop.mail(java.net.URI)


Occurences of MailcapCommandMap (constructors)

MailcapCommandMap (constructors) occurences:
javax.activation.MailcapCommandMap()
javax.activation.MailcapCommandMap(java.io.InputStream)
javax.activation.MailcapCommandMap(java.lang.String)


Occurences of makeBounds

makeBounds occurences:
java.awt.geom.Arc2D.makeBounds(double, double, double, double)
java.awt.geom.Arc2D.Double.makeBounds(double, double, double, double)
java.awt.geom.Arc2D.Float.makeBounds(double, double, double, double)


Occurences of makeClient

makeClient occurences:
javax.management.remote.rmi.RMIIIOPServerImpl.makeClient(java.lang.String, javax.security.auth.Subject)
javax.management.remote.rmi.RMIJRMPServerImpl.makeClient(java.lang.String, javax.security.auth.Subject)
javax.management.remote.rmi.RMIServerImpl.makeClient(java.lang.String, javax.security.auth.Subject)


Occurences of makeParser

makeParser occurences:
org.xml.sax.helpers.ParserFactory.makeParser()
org.xml.sax.helpers.ParserFactory.makeParser(java.lang.String)


Occurences of makeTag

makeTag occurences:
javax.swing.text.html.parser.Parser.makeTag(javax.swing.text.html.parser.Element)
javax.swing.text.html.parser.Parser.makeTag(javax.swing.text.html.parser.Element, boolean)


Occurences of makeVisible

makeVisible occurences:
java.awt.List.makeVisible(int)
javax.swing.JTree.makeVisible(javax.swing.tree.TreePath)


Occurences of MALAYALAM

MALAYALAM occurences:
java.awt.font.MALAYALAM
java.lang.MALAYALAM


Occurences of malformedInputAction

malformedInputAction occurences:
java.nio.charset.CharsetDecoder.malformedInputAction()
java.nio.charset.CharsetEncoder.malformedInputAction()


Occurences of MalformedLinkException (constructors)

MalformedLinkException (constructors) occurences:
javax.naming.MalformedLinkException()
javax.naming.MalformedLinkException(java.lang.String)


Occurences of MalformedObjectNameException (constructors)

MalformedObjectNameException (constructors) occurences:
javax.management.MalformedObjectNameException()
javax.management.MalformedObjectNameException(java.lang.String)


Occurences of MalformedURLException (constructors)

MalformedURLException (constructors) occurences:
java.net.MalformedURLException()
java.net.MalformedURLException(java.lang.String)


Occurences of management

management occurences:
java.lang.management
javax.management


Occurences of ManagementPermission (constructors)

ManagementPermission (constructors) occurences:
java.lang.management.ManagementPermission(java.lang.String)
java.lang.management.ManagementPermission(java.lang.String, java.lang.String)


Occurences of ManageReferralControl (constructors)

ManageReferralControl (constructors) occurences:
javax.naming.ldap.ManageReferralControl()
javax.naming.ldap.ManageReferralControl(boolean)


Occurences of Manifest

Manifest occurences:
java.util.jar.Manifest
javax.xml.crypto.dsig.Manifest


Occurences of Manifest (constructors)

Manifest (constructors) occurences:
java.util.jar.Manifest()
java.util.jar.Manifest(java.io.InputStream)
java.util.jar.Manifest(java.util.jar.Manifest)


Occurences of map

map occurences:
java.nio.channels.FileChannel.map(java.nio.channels.FileChannel.MapMode, long, long)
java.util.jar.map


Occurences of mappedName

mappedName occurences:
javax.annotation.Resource.mappedName()
javax.xml.ws.WebServiceRef.mappedName()


Occurences of mapSystemException

mapSystemException occurences:
javax.rmi.CORBA.Util.mapSystemException(org.omg.CORBA.SystemException)
javax.rmi.CORBA.UtilDelegate.mapSystemException(org.omg.CORBA.SystemException)


Occurences of MARCH

MARCH occurences:
java.util.MARCH
javax.xml.datatype.MARCH


Occurences of mark

mark occurences:
java.io.BufferedInputStream.mark(int)
java.io.BufferedReader.mark(int)
java.io.ByteArrayInputStream.mark(int)
java.io.CharArrayReader.mark(int)
java.io.FilterInputStream.mark(int)
java.io.FilterReader.mark(int)
java.io.InputStream.mark(int)
java.io.LineNumberInputStream.mark(int)
java.io.LineNumberReader.mark(int)
java.io.mark
java.io.PushbackInputStream.mark(int)
java.io.PushbackReader.mark(int)
java.io.Reader.mark(int)
java.io.StringReader.mark(int)
java.nio.Buffer.mark()
java.util.zip.DeflaterInputStream.mark(int)
java.util.zip.InflaterInputStream.mark(int)
javax.imageio.stream.ImageInputStream.mark()
javax.imageio.stream.ImageInputStreamImpl.mark()
javax.sound.sampled.AudioInputStream.mark(int)


Occurences of markSupported

markSupported occurences:
java.io.BufferedInputStream.markSupported()
java.io.BufferedReader.markSupported()
java.io.ByteArrayInputStream.markSupported()
java.io.CharArrayReader.markSupported()
java.io.FilterInputStream.markSupported()
java.io.FilterReader.markSupported()
java.io.InputStream.markSupported()
java.io.PushbackInputStream.markSupported()
java.io.PushbackReader.markSupported()
java.io.Reader.markSupported()
java.io.StringReader.markSupported()
java.util.zip.DeflaterInputStream.markSupported()
java.util.zip.InflaterInputStream.markSupported()
javax.crypto.CipherInputStream.markSupported()
javax.sound.sampled.AudioInputStream.markSupported()


Occurences of marshal

marshal occurences:
javax.xml.bind.annotation.adapters.CollapsedStringAdapter.marshal(java.lang.String)
javax.xml.bind.annotation.adapters.HexBinaryAdapter.marshal(byte[])
javax.xml.bind.annotation.adapters.NormalizedStringAdapter.marshal(java.lang.String)
javax.xml.bind.annotation.adapters.XmlAdapter.marshal(BoundType)
javax.xml.bind.annotation.adapters.XmlAdapter.marshal(java.lang.Object)
javax.xml.bind.annotation.DomHandler.marshal(ElementT, javax.xml.bind.ValidationEventHandler)
javax.xml.bind.annotation.DomHandler.marshal(java.lang.Object,javax.xml.bind.ValidationEventHandler)
javax.xml.bind.annotation.W3CDomHandler.marshal(org.w3c.dom.Element, javax.xml.bind.ValidationEventHandler)
javax.xml.bind.Binder.marshal(java.lang.Object, XmlNode)
javax.xml.bind.Binder.marshal(java.lang.Object,java.lang.Object)
javax.xml.bind.helpers.AbstractMarshallerImpl.marshal(java.lang.Object, java.io.OutputStream)
javax.xml.bind.helpers.AbstractMarshallerImpl.marshal(java.lang.Object, java.io.Writer)
javax.xml.bind.helpers.AbstractMarshallerImpl.marshal(java.lang.Object, javax.xml.stream.XMLEventWriter)
javax.xml.bind.helpers.AbstractMarshallerImpl.marshal(java.lang.Object, javax.xml.stream.XMLStreamWriter)
javax.xml.bind.helpers.AbstractMarshallerImpl.marshal(java.lang.Object, org.w3c.dom.Node)
javax.xml.bind.helpers.AbstractMarshallerImpl.marshal(java.lang.Object, org.xml.sax.ContentHandler)
javax.xml.bind.Marshaller.marshal(java.lang.Object, java.io.OutputStream)
javax.xml.bind.Marshaller.marshal(java.lang.Object, java.io.Writer)
javax.xml.bind.Marshaller.marshal(java.lang.Object, javax.xml.stream.XMLEventWriter)
javax.xml.bind.Marshaller.marshal(java.lang.Object, javax.xml.stream.XMLStreamWriter)
javax.xml.bind.Marshaller.marshal(java.lang.Object, javax.xml.transform.Result)
javax.xml.bind.Marshaller.marshal(java.lang.Object, org.w3c.dom.Node)
javax.xml.bind.Marshaller.marshal(java.lang.Object, org.xml.sax.ContentHandler)
javax.xml.crypto.dsig.keyinfo.KeyInfo.marshal(javax.xml.crypto.XMLStructure, javax.xml.crypto.XMLCryptoContext)
org.omg.CORBA.CustomMarshal.marshal(org.omg.CORBA.DataOutputStream)


Occurences of MARSHAL (constructors)

MARSHAL (constructors) occurences:
org.omg.CORBA.MARSHAL()
org.omg.CORBA.MARSHAL(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.MARSHAL(java.lang.String)
org.omg.CORBA.MARSHAL(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of MarshalException

MarshalException occurences:
java.rmi.MarshalException
javax.xml.bind.MarshalException
javax.xml.crypto.MarshalException


Occurences of MarshalException (constructors)

MarshalException (constructors) occurences:
java.rmi.MarshalException(java.lang.String)
java.rmi.MarshalException(java.lang.String, java.lang.Exception)
javax.xml.bind.MarshalException(java.lang.String)
javax.xml.bind.MarshalException(java.lang.String, java.lang.String)
javax.xml.bind.MarshalException(java.lang.String, java.lang.String, java.lang.Throwable)
javax.xml.bind.MarshalException(java.lang.String, java.lang.Throwable)
javax.xml.bind.MarshalException(java.lang.Throwable)
javax.xml.crypto.MarshalException()
javax.xml.crypto.MarshalException(java.lang.String)
javax.xml.crypto.MarshalException(java.lang.String, java.lang.Throwable)
javax.xml.crypto.MarshalException(java.lang.Throwable)


Occurences of MarshalledObject (constructors)

MarshalledObject (constructors) occurences:
java.rmi.MarshalledObject(java.lang.Object)
java.rmi.MarshalledObject(T)


Occurences of MaskFormatter (constructors)

MaskFormatter (constructors) occurences:
javax.swing.text.MaskFormatter()
javax.swing.text.MaskFormatter(java.lang.String)


Occurences of match

match occurences:
java.awt.datatransfer.DataFlavor.match(java.awt.datatransfer.DataFlavor)
java.security.cert.CertSelector.match(java.security.cert.Certificate)
java.security.cert.CRLSelector.match(java.security.cert.CRL)
java.security.cert.X509CertSelector.match(java.security.cert.Certificate)
java.security.cert.X509CRLSelector.match(java.security.cert.CRL)
java.util.Scanner.match()
javax.activation.MimeType.match(java.lang.String)
javax.activation.MimeType.match(javax.activation.MimeType)
javax.management.Query.match(javax.management.AttributeValueExp, javax.management.StringValueExp)


Occurences of matches

matches occurences:
com.sun.mirror.util.DeclarationFilter.matches(com.sun.mirror.declaration.Declaration)
java.lang.String.matches(java.lang.String)
java.util.regex.Matcher.matches()
java.util.regex.Pattern.matches(java.lang.String, java.lang.CharSequence)
javax.sound.sampled.AudioFormat.matches(javax.sound.sampled.AudioFormat)
javax.sound.sampled.DataLine.Info.matches(javax.sound.sampled.Line.Info)
javax.sound.sampled.Line.Info.matches(javax.sound.sampled.Line.Info)
javax.sound.sampled.Port.Info.matches(javax.sound.sampled.Line.Info)


Occurences of MathContext (constructors)

MathContext (constructors) occurences:
java.math.MathContext(int)
java.math.MathContext(int, java.math.RoundingMode)
java.math.MathContext(java.lang.String)


Occurences of MatteBorder (constructors)

MatteBorder (constructors) occurences:
javax.swing.border.MatteBorder(int, int, int, int, java.awt.Color)
javax.swing.border.MatteBorder(int, int, int, int, javax.swing.Icon)
javax.swing.border.MatteBorder(java.awt.Insets, java.awt.Color)
javax.swing.border.MatteBorder(java.awt.Insets, javax.swing.Icon)
javax.swing.border.MatteBorder(javax.swing.Icon)


Occurences of max

max occurences:
com.sun.jdi.connect.Connector.IntegerArgument.max()
java.lang.Math.max(double, double)
java.lang.Math.max(float, float)
java.lang.Math.max(int, int)
java.lang.Math.max(long, long)
java.lang.StrictMath.max(double, double)
java.lang.StrictMath.max(float, float)
java.lang.StrictMath.max(int, int)
java.lang.StrictMath.max(long, long)
java.math.BigDecimal.max(java.math.BigDecimal)
java.math.BigInteger.max(java.math.BigInteger)
java.util.Collections.max(java.util.Collection)
java.util.Collections.max(java.util.Collection, java.util.Comparator)
javax.swing.Spring.max(javax.swing.Spring, javax.swing.Spring)


Occurences of maximizeFrame

maximizeFrame occurences:
javax.swing.DefaultDesktopManager.maximizeFrame(javax.swing.JInternalFrame)
javax.swing.DesktopManager.maximizeFrame(javax.swing.JInternalFrame)
javax.swing.plaf.basic.BasicInternalFrameUI.maximizeFrame(javax.swing.JInternalFrame)


Occurences of maximumLayoutSize

maximumLayoutSize occurences:
java.awt.BorderLayout.maximumLayoutSize(java.awt.Container)
java.awt.CardLayout.maximumLayoutSize(java.awt.Container)
java.awt.GridBagLayout.maximumLayoutSize(java.awt.Container)
java.awt.LayoutManager2.maximumLayoutSize(java.awt.Container)
javax.swing.BoxLayout.maximumLayoutSize(java.awt.Container)
javax.swing.GroupLayout.maximumLayoutSize(java.awt.Container)
javax.swing.JRootPane.RootLayout.maximumLayoutSize(java.awt.Container)
javax.swing.OverlayLayout.maximumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.maximumLayoutSize(java.awt.Container)
javax.swing.SpringLayout.maximumLayoutSize(java.awt.Container)


Occurences of MAX_EXPONENT

MAX_EXPONENT occurences:
java.lang.MAX_EXPONENT
java.lang.MAX_EXPONENT


Occurences of MAX_VALUE

MAX_VALUE occurences:
java.lang.MAX_VALUE
java.lang.MAX_VALUE
java.lang.MAX_VALUE
java.lang.MAX_VALUE
java.lang.MAX_VALUE
java.lang.MAX_VALUE
java.lang.MAX_VALUE


Occurences of MAY

MAY occurences:
java.util.MAY
javax.xml.datatype.MAY


Occurences of MBeanAttributeInfo (constructors)

MBeanAttributeInfo (constructors) occurences:
javax.management.MBeanAttributeInfo(java.lang.String, java.lang.String, java.lang.reflect.Method, java.lang.reflect.Method)
javax.management.MBeanAttributeInfo(java.lang.String, java.lang.String, java.lang.String, boolean, boolean, boolean)
javax.management.MBeanAttributeInfo(java.lang.String, java.lang.String, java.lang.String, boolean, boolean, boolean, javax.management.Descriptor)


Occurences of MBeanConstructorInfo (constructors)

MBeanConstructorInfo (constructors) occurences:
javax.management.MBeanConstructorInfo(java.lang.String, java.lang.reflect.Constructor)
javax.management.MBeanConstructorInfo(java.lang.String, java.lang.String, javax.management.MBeanParameterInfo[])
javax.management.MBeanConstructorInfo(java.lang.String, java.lang.String, javax.management.MBeanParameterInfo[], javax.management.Descriptor)


Occurences of MBeanException (constructors)

MBeanException (constructors) occurences:
javax.management.MBeanException(java.lang.Exception)
javax.management.MBeanException(java.lang.Exception, java.lang.String)


Occurences of MBeanFeatureInfo (constructors)

MBeanFeatureInfo (constructors) occurences:
javax.management.MBeanFeatureInfo(java.lang.String, java.lang.String)
javax.management.MBeanFeatureInfo(java.lang.String, java.lang.String, javax.management.Descriptor)


Occurences of MBeanInfo (constructors)

MBeanInfo (constructors) occurences:
javax.management.MBeanInfo(java.lang.String, java.lang.String, javax.management.MBeanAttributeInfo[], javax.management.MBeanConstructorInfo[], javax.management.MBeanOperationInfo[], javax.management.MBeanNotificationInfo[])
javax.management.MBeanInfo(java.lang.String, java.lang.String, javax.management.MBeanAttributeInfo[], javax.management.MBeanConstructorInfo[], javax.management.MBeanOperationInfo[], javax.management.MBeanNotificationInfo[], javax.management.Descriptor)


Occurences of MBeanNotificationInfo (constructors)

MBeanNotificationInfo (constructors) occurences:
javax.management.MBeanNotificationInfo(java.lang.String[], java.lang.String, java.lang.String)
javax.management.MBeanNotificationInfo(java.lang.String[], java.lang.String, java.lang.String, javax.management.Descriptor)


Occurences of MBeanOperationInfo (constructors)

MBeanOperationInfo (constructors) occurences:
javax.management.MBeanOperationInfo(java.lang.String, java.lang.reflect.Method)
javax.management.MBeanOperationInfo(java.lang.String, java.lang.String, javax.management.MBeanParameterInfo[], java.lang.String, int)
javax.management.MBeanOperationInfo(java.lang.String, java.lang.String, javax.management.MBeanParameterInfo[], java.lang.String, int, javax.management.Descriptor)


Occurences of MBeanParameterInfo (constructors)

MBeanParameterInfo (constructors) occurences:
javax.management.MBeanParameterInfo(java.lang.String, java.lang.String, java.lang.String)
javax.management.MBeanParameterInfo(java.lang.String, java.lang.String, java.lang.String, javax.management.Descriptor)


Occurences of MBeanPermission (constructors)

MBeanPermission (constructors) occurences:
javax.management.MBeanPermission(java.lang.String, java.lang.String)
javax.management.MBeanPermission(java.lang.String, java.lang.String, javax.management.ObjectName, java.lang.String)


Occurences of MBeanRegistrationException (constructors)

MBeanRegistrationException (constructors) occurences:
javax.management.MBeanRegistrationException(java.lang.Exception)
javax.management.MBeanRegistrationException(java.lang.Exception, java.lang.String)


Occurences of MBeanServerInvocationHandler (constructors)

MBeanServerInvocationHandler (constructors) occurences:
javax.management.MBeanServerInvocationHandler(javax.management.MBeanServerConnection, javax.management.ObjectName)
javax.management.MBeanServerInvocationHandler(javax.management.MBeanServerConnection, javax.management.ObjectName, boolean)


Occurences of MBeanServerPermission (constructors)

MBeanServerPermission (constructors) occurences:
javax.management.MBeanServerPermission(java.lang.String)
javax.management.MBeanServerPermission(java.lang.String, java.lang.String)


Occurences of MBeanTrustPermission (constructors)

MBeanTrustPermission (constructors) occurences:
javax.management.MBeanTrustPermission(java.lang.String)
javax.management.MBeanTrustPermission(java.lang.String, java.lang.String)


Occurences of MediaPrintableArea (constructors)

MediaPrintableArea (constructors) occurences:
javax.print.attribute.standard.MediaPrintableArea(float, float, float, float, int)
javax.print.attribute.standard.MediaPrintableArea(int, int, int, int, int)


Occurences of MediaSize (constructors)

MediaSize (constructors) occurences:
javax.print.attribute.standard.MediaSize(float, float, int)
javax.print.attribute.standard.MediaSize(float, float, int, javax.print.attribute.standard.MediaSizeName)
javax.print.attribute.standard.MediaSize(int, int, int)
javax.print.attribute.standard.MediaSize(int, int, int, javax.print.attribute.standard.MediaSizeName)


Occurences of member

member occurences:
org.omg.CORBA.DynUnion.member()
org.omg.DynamicAny.DynUnionOperations.member()
org.omg.DynamicAny._DynUnionStub.member()


Occurences of member_kind

member_kind occurences:
org.omg.CORBA.DynUnion.member_kind()
org.omg.DynamicAny.DynUnionOperations.member_kind()
org.omg.DynamicAny._DynUnionStub.member_kind()


Occurences of member_name

member_name occurences:
org.omg.CORBA.DynUnion.member_name()
org.omg.CORBA.DynUnion.member_name(java.lang.String)
org.omg.CORBA.TypeCode.member_name(int)
org.omg.DynamicAny.DynUnionOperations.member_name()
org.omg.DynamicAny._DynUnionStub.member_name()


Occurences of MemoryHandler (constructors)

MemoryHandler (constructors) occurences:
java.util.logging.MemoryHandler()
java.util.logging.MemoryHandler(java.util.logging.Handler, int, java.util.logging.Level)


Occurences of MemoryImageSource (constructors)

MemoryImageSource (constructors) occurences:
java.awt.image.MemoryImageSource(int, int, int[], int, int)
java.awt.image.MemoryImageSource(int, int, int[], int, int, java.util.Hashtable)
java.awt.image.MemoryImageSource(int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.MemoryImageSource(int, int, java.awt.image.ColorModel, byte[], int, int, java.util.Hashtable)
java.awt.image.MemoryImageSource(int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.MemoryImageSource(int, int, java.awt.image.ColorModel, int[], int, int, java.util.Hashtable)


Occurences of menu

menu occurences:
java.awt.menu
javax.swing.plaf.basic.menu


Occurences of MENU

MENU occurences:
java.awt.MENU
javax.accessibility.MENU
javax.swing.plaf.synth.MENU
javax.swing.text.html.MENU


Occurences of Menu (constructors)

Menu (constructors) occurences:
java.awt.Menu()
java.awt.Menu(java.lang.String)
java.awt.Menu(java.lang.String, boolean)


Occurences of menuBar

menuBar occurences:
javax.swing.menuBar
javax.swing.plaf.basic.menuBar
javax.swing.plaf.basic.menuBar


Occurences of MenuDragMouseEvent (constructors)

MenuDragMouseEvent (constructors) occurences:
javax.swing.event.MenuDragMouseEvent(java.awt.Component, int, long, int, int, int, int, boolean, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.event.MenuDragMouseEvent(java.awt.Component, int, long, int, int, int, int, int, int, boolean, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)


Occurences of MenuItem (constructors)

MenuItem (constructors) occurences:
java.awt.MenuItem()
java.awt.MenuItem(java.lang.String)
java.awt.MenuItem(java.lang.String, java.awt.MenuShortcut)


Occurences of menuSelectionChanged

menuSelectionChanged occurences:
javax.swing.JMenu.menuSelectionChanged(boolean)
javax.swing.JMenuBar.menuSelectionChanged(boolean)
javax.swing.JMenuItem.menuSelectionChanged(boolean)
javax.swing.JPopupMenu.menuSelectionChanged(boolean)
javax.swing.MenuElement.menuSelectionChanged(boolean)


Occurences of MenuShortcut (constructors)

MenuShortcut (constructors) occurences:
java.awt.MenuShortcut(int)
java.awt.MenuShortcut(int, boolean)


Occurences of MENU_BAR

MENU_BAR occurences:
javax.accessibility.MENU_BAR
javax.swing.plaf.synth.MENU_BAR


Occurences of MENU_ITEM

MENU_ITEM occurences:
javax.accessibility.MENU_ITEM
javax.swing.plaf.synth.MENU_ITEM


Occurences of message

message occurences:
javax.swing.message
javax.swing.message


Occurences of MessageFormat (constructors)

MessageFormat (constructors) occurences:
java.text.MessageFormat(java.lang.String)
java.text.MessageFormat(java.lang.String, java.util.Locale)


Occurences of MessageProp (constructors)

MessageProp (constructors) occurences:
org.ietf.jgss.MessageProp(boolean)
org.ietf.jgss.MessageProp(int, boolean)


Occurences of Messager

Messager occurences:
com.sun.mirror.apt.Messager
javax.annotation.processing.Messager


Occurences of META

META occurences:
javax.sound.midi.META
javax.swing.text.html.META


Occurences of meta

meta occurences:
javax.sound.midi.MetaEventListener.meta(javax.sound.midi.MetaMessage)
javax.swing.text.html.parser.meta


Occurences of metadata

metadata occurences:
javax.imageio.metadata
javax.imageio.metadata


Occurences of MetalComboBoxButton (constructors)

MetalComboBoxButton (constructors) occurences:
javax.swing.plaf.metal.MetalComboBoxButton(javax.swing.JComboBox, javax.swing.Icon, boolean, javax.swing.CellRendererPane, javax.swing.JList)
javax.swing.plaf.metal.MetalComboBoxButton(javax.swing.JComboBox, javax.swing.Icon, javax.swing.CellRendererPane, javax.swing.JList)


Occurences of MetaMessage (constructors)

MetaMessage (constructors) occurences:
javax.sound.midi.MetaMessage()
javax.sound.midi.MetaMessage(byte[])


Occurences of META_MASK

META_MASK occurences:
java.awt.event.META_MASK
java.awt.event.META_MASK
java.awt.META_MASK


Occurences of METHOD

METHOD occurences:
com.sun.source.tree.METHOD
java.lang.annotation.METHOD
javax.lang.model.element.METHOD
javax.swing.text.html.METHOD
javax.xml.transform.METHOD


Occurences of Method

Method occurences:
com.sun.jdi.Method
java.lang.reflect.Method


Occurences of method

method occurences:
com.sun.jdi.event.MethodEntryEvent.method()
com.sun.jdi.event.MethodExitEvent.method()
com.sun.jdi.Location.method()
java.net.method


Occurences of MethodDescriptor (constructors)

MethodDescriptor (constructors) occurences:
java.beans.MethodDescriptor(java.lang.reflect.Method)
java.beans.MethodDescriptor(java.lang.reflect.Method, java.beans.ParameterDescriptor[])


Occurences of MidiFileFormat (constructors)

MidiFileFormat (constructors) occurences:
javax.sound.midi.MidiFileFormat(int, float, int, int, long)
javax.sound.midi.MidiFileFormat(int, float, int, int, long, java.util.Map)


Occurences of MidiUnavailableException (constructors)

MidiUnavailableException (constructors) occurences:
javax.sound.midi.MidiUnavailableException()
javax.sound.midi.MidiUnavailableException(java.lang.String)


Occurences of MIDI_TIME_CODE

MIDI_TIME_CODE occurences:
javax.sound.midi.MIDI_TIME_CODE
javax.sound.midi.MIDI_TIME_CODE


Occurences of MILLISECOND

MILLISECOND occurences:
java.text.MILLISECOND
java.util.MILLISECOND


Occurences of MimeType (constructors)

MimeType (constructors) occurences:
javax.activation.MimeType()
javax.activation.MimeType(java.lang.String)
javax.activation.MimeType(java.lang.String, java.lang.String)


Occurences of MimeTypeParameterList (constructors)

MimeTypeParameterList (constructors) occurences:
javax.activation.MimeTypeParameterList()
javax.activation.MimeTypeParameterList(java.lang.String)


Occurences of MimeTypeParseException

MimeTypeParseException occurences:
java.awt.datatransfer.MimeTypeParseException
javax.activation.MimeTypeParseException


Occurences of MimeTypeParseException (constructors)

MimeTypeParseException (constructors) occurences:
java.awt.datatransfer.MimeTypeParseException()
java.awt.datatransfer.MimeTypeParseException(java.lang.String)
javax.activation.MimeTypeParseException()
javax.activation.MimeTypeParseException(java.lang.String)


Occurences of MimetypesFileTypeMap (constructors)

MimetypesFileTypeMap (constructors) occurences:
javax.activation.MimetypesFileTypeMap()
javax.activation.MimetypesFileTypeMap(java.io.InputStream)
javax.activation.MimetypesFileTypeMap(java.lang.String)


Occurences of min

min occurences:
com.sun.jdi.connect.Connector.IntegerArgument.min()
java.lang.Math.min(double, double)
java.lang.Math.min(float, float)
java.lang.Math.min(int, int)
java.lang.Math.min(long, long)
java.lang.StrictMath.min(double, double)
java.lang.StrictMath.min(float, float)
java.lang.StrictMath.min(int, int)
java.lang.StrictMath.min(long, long)
java.math.BigDecimal.min(java.math.BigDecimal)
java.math.BigInteger.min(java.math.BigInteger)
java.util.Collections.min(java.util.Collection)
java.util.Collections.min(java.util.Collection, java.util.Comparator)


Occurences of MinimalHTMLWriter (constructors)

MinimalHTMLWriter (constructors) occurences:
javax.swing.text.html.MinimalHTMLWriter(java.io.Writer, javax.swing.text.StyledDocument)
javax.swing.text.html.MinimalHTMLWriter(java.io.Writer, javax.swing.text.StyledDocument, int, int)


Occurences of minimizeFrame

minimizeFrame occurences:
javax.swing.DefaultDesktopManager.minimizeFrame(javax.swing.JInternalFrame)
javax.swing.DesktopManager.minimizeFrame(javax.swing.JInternalFrame)
javax.swing.plaf.basic.BasicInternalFrameUI.minimizeFrame(javax.swing.JInternalFrame)


Occurences of minimumLayoutSize

minimumLayoutSize occurences:
java.awt.BorderLayout.minimumLayoutSize(java.awt.Container)
java.awt.CardLayout.minimumLayoutSize(java.awt.Container)
java.awt.FlowLayout.minimumLayoutSize(java.awt.Container)
java.awt.GridBagLayout.minimumLayoutSize(java.awt.Container)
java.awt.GridLayout.minimumLayoutSize(java.awt.Container)
java.awt.LayoutManager.minimumLayoutSize(java.awt.Container)
javax.swing.BoxLayout.minimumLayoutSize(java.awt.Container)
javax.swing.GroupLayout.minimumLayoutSize(java.awt.Container)
javax.swing.JRootPane.RootLayout.minimumLayoutSize(java.awt.Container)
javax.swing.JSpinner.DefaultEditor.minimumLayoutSize(java.awt.Container)
javax.swing.OverlayLayout.minimumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicComboBoxUI.ComboBoxLayoutManager.minimumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.TitlePaneLayout.minimumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicInternalFrameUI.InternalFrameLayout.minimumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicOptionPaneUI.ButtonAreaLayout.minimumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicScrollBarUI.minimumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneDivider.DividerLayout.minimumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.minimumLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicTabbedPaneUI.TabbedPaneLayout.minimumLayoutSize(java.awt.Container)
javax.swing.ScrollPaneLayout.minimumLayoutSize(java.awt.Container)
javax.swing.SpringLayout.minimumLayoutSize(java.awt.Container)
javax.swing.ViewportLayout.minimumLayoutSize(java.awt.Container)


Occurences of minimumSize

minimumSize occurences:
java.awt.Component.minimumSize()
java.awt.Container.minimumSize()
java.awt.List.minimumSize()
java.awt.List.minimumSize(int)
java.awt.TextArea.minimumSize()
java.awt.TextArea.minimumSize(int, int)
java.awt.TextField.minimumSize()
java.awt.TextField.minimumSize(int)
javax.swing.plaf.basic.minimumSize


Occurences of MINUS

MINUS occurences:
com.sun.source.tree.MINUS
javax.management.MINUS


Occurences of minus

minus occurences:
javax.management.Query.minus(javax.management.ValueExp, javax.management.ValueExp)
javax.swing.Spring.minus(javax.swing.Spring)


Occurences of MINUTE

MINUTE occurences:
java.text.MINUTE
java.util.MINUTE


Occurences of MINUTES

MINUTES occurences:
java.util.concurrent.MINUTES
javax.xml.datatype.MINUTES


Occurences of MIN_EXPONENT

MIN_EXPONENT occurences:
java.lang.MIN_EXPONENT
java.lang.MIN_EXPONENT


Occurences of MIN_NORMAL

MIN_NORMAL occurences:
java.lang.MIN_NORMAL
java.lang.MIN_NORMAL


Occurences of MIN_VALUE

MIN_VALUE occurences:
java.lang.MIN_VALUE
java.lang.MIN_VALUE
java.lang.MIN_VALUE
java.lang.MIN_VALUE
java.lang.MIN_VALUE
java.lang.MIN_VALUE
java.lang.MIN_VALUE


Occurences of MirroredTypeException

MirroredTypeException occurences:
com.sun.mirror.type.MirroredTypeException
javax.lang.model.type.MirroredTypeException


Occurences of MirroredTypeException (constructors)

MirroredTypeException (constructors) occurences:
com.sun.mirror.type.MirroredTypeException(com.sun.mirror.type.TypeMirror)
javax.lang.model.type.MirroredTypeException(javax.lang.model.type.TypeMirror)


Occurences of MirroredTypesException

MirroredTypesException occurences:
com.sun.mirror.type.MirroredTypesException
javax.lang.model.type.MirroredTypesException


Occurences of MirroredTypesException (constructors)

MirroredTypesException (constructors) occurences:
com.sun.mirror.type.MirroredTypesException(java.util.Collection)
javax.lang.model.type.MirroredTypesException(java.util.List)


Occurences of mirrorOf

mirrorOf occurences:
com.sun.jdi.VirtualMachine.mirrorOf(boolean)
com.sun.jdi.VirtualMachine.mirrorOf(byte)
com.sun.jdi.VirtualMachine.mirrorOf(char)
com.sun.jdi.VirtualMachine.mirrorOf(double)
com.sun.jdi.VirtualMachine.mirrorOf(float)
com.sun.jdi.VirtualMachine.mirrorOf(int)
com.sun.jdi.VirtualMachine.mirrorOf(java.lang.String)
com.sun.jdi.VirtualMachine.mirrorOf(long)
com.sun.jdi.VirtualMachine.mirrorOf(short)


Occurences of mkdir

mkdir occurences:
Class GLOBALS.mkdir
java.io.File.mkdir()


Occurences of mkdirs

mkdirs occurences:
Class GLOBALS.mkdirs
java.io.File.mkdirs()


Occurences of MLet (constructors)

MLet (constructors) occurences:
javax.management.loading.MLet()
javax.management.loading.MLet(java.net.URL[])
javax.management.loading.MLet(java.net.URL[], boolean)
javax.management.loading.MLet(java.net.URL[], java.lang.ClassLoader)
javax.management.loading.MLet(java.net.URL[], java.lang.ClassLoader, boolean)
javax.management.loading.MLet(java.net.URL[], java.lang.ClassLoader, java.net.URLStreamHandlerFactory)
javax.management.loading.MLet(java.net.URL[], java.lang.ClassLoader, java.net.URLStreamHandlerFactory, boolean)


Occurences of MM

MM occurences:
javax.print.attribute.MM
javax.print.attribute.standard.MM


Occurences of mode

mode occurences:
java.io.mode
javax.jws.WebParam.mode()
org.omg.Dynamic.mode


Occurences of model

model occurences:
javax.lang.model
javax.swing.model
javax.swing.model
javax.swing.model
javax.swing.model


Occurences of modelChanged

modelChanged occurences:
javax.swing.plaf.basic.BasicTextUI.modelChanged()
javax.swing.plaf.basic.modelChanged


Occurences of ModelMBeanAttributeInfo (constructors)

ModelMBeanAttributeInfo (constructors) occurences:
javax.management.modelmbean.ModelMBeanAttributeInfo(java.lang.String, java.lang.String, java.lang.reflect.Method, java.lang.reflect.Method)
javax.management.modelmbean.ModelMBeanAttributeInfo(java.lang.String, java.lang.String, java.lang.reflect.Method, java.lang.reflect.Method, javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanAttributeInfo(java.lang.String, java.lang.String, java.lang.String, boolean, boolean, boolean)
javax.management.modelmbean.ModelMBeanAttributeInfo(java.lang.String, java.lang.String, java.lang.String, boolean, boolean, boolean, javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanAttributeInfo(javax.management.modelmbean.ModelMBeanAttributeInfo)


Occurences of ModelMBeanConstructorInfo (constructors)

ModelMBeanConstructorInfo (constructors) occurences:
javax.management.modelmbean.ModelMBeanConstructorInfo(java.lang.String, java.lang.reflect.Constructor)
javax.management.modelmbean.ModelMBeanConstructorInfo(java.lang.String, java.lang.reflect.Constructor, javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanConstructorInfo(java.lang.String, java.lang.String, javax.management.MBeanParameterInfo[])
javax.management.modelmbean.ModelMBeanConstructorInfo(java.lang.String, java.lang.String, javax.management.MBeanParameterInfo[], javax.management.Descriptor)


Occurences of ModelMBeanInfoSupport (constructors)

ModelMBeanInfoSupport (constructors) occurences:
javax.management.modelmbean.ModelMBeanInfoSupport(java.lang.String, java.lang.String, javax.management.modelmbean.ModelMBeanAttributeInfo[], javax.management.modelmbean.ModelMBeanConstructorInfo[], javax.management.modelmbean.ModelMBeanOperationInfo[], javax.management.modelmbean.ModelMBeanNotificationInfo[])
javax.management.modelmbean.ModelMBeanInfoSupport(java.lang.String, java.lang.String, javax.management.modelmbean.ModelMBeanAttributeInfo[], javax.management.modelmbean.ModelMBeanConstructorInfo[], javax.management.modelmbean.ModelMBeanOperationInfo[], javax.management.modelmbean.ModelMBeanNotificationInfo[], javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanInfoSupport(javax.management.modelmbean.ModelMBeanInfo)


Occurences of ModelMBeanNotificationInfo (constructors)

ModelMBeanNotificationInfo (constructors) occurences:
javax.management.modelmbean.ModelMBeanNotificationInfo(java.lang.String[], java.lang.String, java.lang.String)
javax.management.modelmbean.ModelMBeanNotificationInfo(java.lang.String[], java.lang.String, java.lang.String, javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanNotificationInfo(javax.management.modelmbean.ModelMBeanNotificationInfo)


Occurences of ModelMBeanOperationInfo (constructors)

ModelMBeanOperationInfo (constructors) occurences:
javax.management.modelmbean.ModelMBeanOperationInfo(java.lang.String, java.lang.reflect.Method)
javax.management.modelmbean.ModelMBeanOperationInfo(java.lang.String, java.lang.reflect.Method, javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanOperationInfo(java.lang.String, java.lang.String, javax.management.MBeanParameterInfo[], java.lang.String, int)
javax.management.modelmbean.ModelMBeanOperationInfo(java.lang.String, java.lang.String, javax.management.MBeanParameterInfo[], java.lang.String, int, javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanOperationInfo(javax.management.modelmbean.ModelMBeanOperationInfo)


Occurences of modelStructureChanged

modelStructureChanged occurences:
javax.swing.DefaultRowSorter.modelStructureChanged()
javax.swing.RowSorter.modelStructureChanged()


Occurences of modelToView

modelToView occurences:
javax.swing.plaf.basic.BasicTextUI.modelToView(javax.swing.text.JTextComponent, int)
javax.swing.plaf.basic.BasicTextUI.modelToView(javax.swing.text.JTextComponent, int, javax.swing.text.Position.Bias)
javax.swing.plaf.multi.MultiTextUI.modelToView(javax.swing.text.JTextComponent, int)
javax.swing.plaf.multi.MultiTextUI.modelToView(javax.swing.text.JTextComponent, int, javax.swing.text.Position.Bias)
javax.swing.plaf.TextUI.modelToView(javax.swing.text.JTextComponent, int)
javax.swing.plaf.TextUI.modelToView(javax.swing.text.JTextComponent, int, javax.swing.text.Position.Bias)
javax.swing.text.AsyncBoxView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.BoxView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.ComponentView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.CompositeView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.CompositeView.modelToView(int, javax.swing.text.Position.Bias, int, javax.swing.text.Position.Bias, java.awt.Shape)
javax.swing.text.FieldView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.GlyphView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.GlyphView.GlyphPainter.modelToView(javax.swing.text.GlyphView, int, javax.swing.text.Position.Bias, java.awt.Shape)
javax.swing.text.html.ImageView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.IconView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.JTextComponent.modelToView(int)
javax.swing.text.PasswordView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.PlainView.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.View.modelToView(int, java.awt.Shape)
javax.swing.text.View.modelToView(int, java.awt.Shape, javax.swing.text.Position.Bias)
javax.swing.text.View.modelToView(int, javax.swing.text.Position.Bias, int, javax.swing.text.Position.Bias, java.awt.Shape)


Occurences of Modifier

Modifier occurences:
com.sun.mirror.declaration.Modifier
java.lang.reflect.Modifier
javax.lang.model.element.Modifier


Occurences of modifiers

modifiers occurences:
com.sun.javadoc.ProgramElementDoc.modifiers()
com.sun.jdi.Accessible.modifiers()
java.awt.modifiers


Occurences of modifyAttributes

modifyAttributes occurences:
javax.naming.directory.DirContext.modifyAttributes(java.lang.String, int, javax.naming.directory.Attributes)
javax.naming.directory.DirContext.modifyAttributes(java.lang.String, javax.naming.directory.ModificationItem[])
javax.naming.directory.DirContext.modifyAttributes(javax.naming.Name, int, javax.naming.directory.Attributes)
javax.naming.directory.DirContext.modifyAttributes(javax.naming.Name, javax.naming.directory.ModificationItem[])
javax.naming.directory.InitialDirContext.modifyAttributes(java.lang.String, int, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.modifyAttributes(java.lang.String, javax.naming.directory.ModificationItem[])
javax.naming.directory.InitialDirContext.modifyAttributes(javax.naming.Name, int, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.modifyAttributes(javax.naming.Name, javax.naming.directory.ModificationItem[])


Occurences of MONARCH_ENVELOPE

MONARCH_ENVELOPE occurences:
java.awt.MONARCH_ENVELOPE
javax.print.attribute.standard.MONARCH_ENVELOPE
javax.print.attribute.standard.MONARCH_ENVELOPE


Occurences of MONGOLIAN

MONGOLIAN occurences:
java.awt.font.MONGOLIAN
java.lang.MONGOLIAN


Occurences of monitor

monitor occurences:
com.sun.jdi.event.MonitorContendedEnteredEvent.monitor()
com.sun.jdi.event.MonitorContendedEnterEvent.monitor()
com.sun.jdi.event.MonitorWaitedEvent.monitor()
com.sun.jdi.event.MonitorWaitEvent.monitor()
com.sun.jdi.MonitorInfo.monitor()
javax.management.monitor


Occurences of MonitorInfo

MonitorInfo occurences:
com.sun.jdi.MonitorInfo
java.lang.management.MonitorInfo


Occurences of MonitorSettingException (constructors)

MonitorSettingException (constructors) occurences:
javax.management.monitor.MonitorSettingException()
javax.management.monitor.MonitorSettingException(java.lang.String)


Occurences of MONOCHROME

MONOCHROME occurences:
java.awt.MONOCHROME
javax.print.attribute.standard.MONOCHROME


Occurences of MONTH

MONTH occurences:
java.text.MONTH
java.util.MONTH


Occurences of mouseClicked

mouseClicked occurences:
java.awt.AWTEventMulticaster.mouseClicked(java.awt.event.MouseEvent)
java.awt.dnd.MouseDragGestureRecognizer.mouseClicked(java.awt.event.MouseEvent)
java.awt.event.MouseAdapter.mouseClicked(java.awt.event.MouseEvent)
java.awt.event.MouseListener.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicButtonListener.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicFileChooserUI.DoubleClickListener.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BorderListener.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.GlassPaneDispatcher.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicListUI.MouseInputHandler.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuItemUI.MouseInputHandler.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuUI.MouseInputHandler.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableHeaderUI.MouseInputHandler.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableUI.MouseInputHandler.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicToolBarUI.DockingListener.mouseClicked(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseInputHandler.mouseClicked(java.awt.event.MouseEvent)
javax.swing.text.DefaultCaret.mouseClicked(java.awt.event.MouseEvent)
javax.swing.text.html.HTMLEditorKit.LinkController.mouseClicked(java.awt.event.MouseEvent)


Occurences of mouseDragged

mouseDragged occurences:
java.awt.AWTEventMulticaster.mouseDragged(java.awt.event.MouseEvent)
java.awt.dnd.MouseDragGestureRecognizer.mouseDragged(java.awt.event.MouseEvent)
java.awt.event.MouseAdapter.mouseDragged(java.awt.event.MouseEvent)
java.awt.event.MouseMotionAdapter.mouseDragged(java.awt.event.MouseEvent)
java.awt.event.MouseMotionListener.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicButtonListener.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicComboPopup.InvocationMouseMotionHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicDesktopIconUI.MouseInputHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BorderListener.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.GlassPaneDispatcher.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicListUI.MouseInputHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuItemUI.MouseInputHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuUI.MouseInputHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicScrollBarUI.TrackListener.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSliderUI.TrackListener.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSplitPaneDivider.MouseHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableHeaderUI.MouseInputHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableUI.MouseInputHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicToolBarUI.DockingListener.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseInputHandler.mouseDragged(java.awt.event.MouseEvent)
javax.swing.plaf.metal.MetalToolBarUI.MetalDockingListener.mouseDragged(java.awt.event.MouseEvent)
javax.swing.text.DefaultCaret.mouseDragged(java.awt.event.MouseEvent)
javax.swing.text.html.HTMLEditorKit.LinkController.mouseDragged(java.awt.event.MouseEvent)
javax.swing.ToolTipManager.mouseDragged(java.awt.event.MouseEvent)


Occurences of MouseDragGestureRecognizer (constructors)

MouseDragGestureRecognizer (constructors) occurences:
java.awt.dnd.MouseDragGestureRecognizer(java.awt.dnd.DragSource)
java.awt.dnd.MouseDragGestureRecognizer(java.awt.dnd.DragSource, java.awt.Component)
java.awt.dnd.MouseDragGestureRecognizer(java.awt.dnd.DragSource, java.awt.Component, int)
java.awt.dnd.MouseDragGestureRecognizer(java.awt.dnd.DragSource, java.awt.Component, int, java.awt.dnd.DragGestureListener)


Occurences of mouseEntered

mouseEntered occurences:
java.awt.AWTEventMulticaster.mouseEntered(java.awt.event.MouseEvent)
java.awt.dnd.MouseDragGestureRecognizer.mouseEntered(java.awt.event.MouseEvent)
java.awt.event.MouseAdapter.mouseEntered(java.awt.event.MouseEvent)
java.awt.event.MouseListener.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicButtonListener.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicFileChooserUI.DoubleClickListener.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BorderListener.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.GlassPaneDispatcher.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicListUI.MouseInputHandler.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuItemUI.MouseInputHandler.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuUI.MouseInputHandler.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSplitPaneDivider.MouseHandler.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableHeaderUI.MouseInputHandler.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableUI.MouseInputHandler.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicToolBarUI.DockingListener.mouseEntered(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseInputHandler.mouseEntered(java.awt.event.MouseEvent)
javax.swing.text.DefaultCaret.mouseEntered(java.awt.event.MouseEvent)
javax.swing.ToolTipManager.mouseEntered(java.awt.event.MouseEvent)


Occurences of MouseEvent

MouseEvent occurences:
java.awt.event.MouseEvent
org.w3c.dom.events.MouseEvent


Occurences of MouseEvent (constructors)

MouseEvent (constructors) occurences:
java.awt.event.MouseEvent(java.awt.Component, int, long, int, int, int, int, boolean)
java.awt.event.MouseEvent(java.awt.Component, int, long, int, int, int, int, boolean, int)
java.awt.event.MouseEvent(java.awt.Component, int, long, int, int, int, int, int, int, boolean, int)


Occurences of mouseExited

mouseExited occurences:
java.awt.AWTEventMulticaster.mouseExited(java.awt.event.MouseEvent)
java.awt.dnd.MouseDragGestureRecognizer.mouseExited(java.awt.event.MouseEvent)
java.awt.event.MouseAdapter.mouseExited(java.awt.event.MouseEvent)
java.awt.event.MouseListener.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicButtonListener.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BorderListener.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.GlassPaneDispatcher.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicListUI.MouseInputHandler.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuItemUI.MouseInputHandler.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuUI.MouseInputHandler.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicScrollBarUI.TrackListener.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSplitPaneDivider.MouseHandler.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableHeaderUI.MouseInputHandler.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableUI.MouseInputHandler.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicToolBarUI.DockingListener.mouseExited(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseInputHandler.mouseExited(java.awt.event.MouseEvent)
javax.swing.text.DefaultCaret.mouseExited(java.awt.event.MouseEvent)
javax.swing.ToolTipManager.mouseExited(java.awt.event.MouseEvent)


Occurences of mouseInputListener

mouseInputListener occurences:
javax.swing.plaf.basic.mouseInputListener
javax.swing.plaf.basic.mouseInputListener
javax.swing.plaf.basic.mouseInputListener
javax.swing.plaf.basic.mouseInputListener


Occurences of mouseListener

mouseListener occurences:
javax.swing.plaf.basic.mouseListener
javax.swing.plaf.basic.mouseListener


Occurences of mouseMove

mouseMove occurences:
java.awt.Component.mouseMove(java.awt.Event, int, int)
java.awt.Robot.mouseMove(int, int)


Occurences of mouseMoved

mouseMoved occurences:
java.awt.AWTEventMulticaster.mouseMoved(java.awt.event.MouseEvent)
java.awt.dnd.MouseDragGestureRecognizer.mouseMoved(java.awt.event.MouseEvent)
java.awt.event.MouseAdapter.mouseMoved(java.awt.event.MouseEvent)
java.awt.event.MouseMotionAdapter.mouseMoved(java.awt.event.MouseEvent)
java.awt.event.MouseMotionListener.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicButtonListener.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicComboPopup.ListMouseMotionHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicDesktopIconUI.MouseInputHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BorderListener.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.GlassPaneDispatcher.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicListUI.MouseInputHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuItemUI.MouseInputHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuUI.MouseInputHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicScrollBarUI.TrackListener.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSliderUI.TrackListener.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSplitPaneDivider.MouseHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableHeaderUI.MouseInputHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableUI.MouseInputHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicToolBarUI.DockingListener.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseInputHandler.mouseMoved(java.awt.event.MouseEvent)
javax.swing.text.DefaultCaret.mouseMoved(java.awt.event.MouseEvent)
javax.swing.text.html.HTMLEditorKit.LinkController.mouseMoved(java.awt.event.MouseEvent)
javax.swing.ToolTipManager.mouseMoved(java.awt.event.MouseEvent)


Occurences of mousePressed

mousePressed occurences:
java.awt.AWTEventMulticaster.mousePressed(java.awt.event.MouseEvent)
java.awt.dnd.MouseDragGestureRecognizer.mousePressed(java.awt.event.MouseEvent)
java.awt.event.MouseAdapter.mousePressed(java.awt.event.MouseEvent)
java.awt.event.MouseListener.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicButtonListener.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicComboPopup.InvocationMouseHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicComboPopup.ListMouseHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicDesktopIconUI.MouseInputHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BorderListener.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.GlassPaneDispatcher.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicListUI.MouseInputHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuItemUI.MouseInputHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuUI.MouseInputHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicScrollBarUI.ArrowButtonListener.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicScrollBarUI.TrackListener.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSliderUI.TrackListener.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSplitPaneDivider.MouseHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTabbedPaneUI.MouseHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableHeaderUI.MouseInputHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableUI.MouseInputHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicToolBarUI.DockingListener.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseInputHandler.mousePressed(java.awt.event.MouseEvent)
javax.swing.plaf.metal.MetalToolBarUI.MetalDockingListener.mousePressed(java.awt.event.MouseEvent)
javax.swing.text.DefaultCaret.mousePressed(java.awt.event.MouseEvent)
javax.swing.ToolTipManager.mousePressed(java.awt.event.MouseEvent)


Occurences of mouseReleased

mouseReleased occurences:
java.awt.AWTEventMulticaster.mouseReleased(java.awt.event.MouseEvent)
java.awt.dnd.MouseDragGestureRecognizer.mouseReleased(java.awt.event.MouseEvent)
java.awt.event.MouseAdapter.mouseReleased(java.awt.event.MouseEvent)
java.awt.event.MouseListener.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicButtonListener.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicComboPopup.InvocationMouseHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicComboPopup.ListMouseHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicDesktopIconUI.MouseInputHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.BorderListener.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.GlassPaneDispatcher.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicListUI.MouseInputHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuItemUI.MouseInputHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicMenuUI.MouseInputHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicScrollBarUI.ArrowButtonListener.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicScrollBarUI.TrackListener.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSliderUI.TrackListener.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSplitPaneDivider.MouseHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableHeaderUI.MouseInputHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTableUI.MouseInputHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicToolBarUI.DockingListener.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicTreeUI.MouseInputHandler.mouseReleased(java.awt.event.MouseEvent)
javax.swing.text.DefaultCaret.mouseReleased(java.awt.event.MouseEvent)
javax.swing.text.html.FormView.MouseEventListener.mouseReleased(java.awt.event.MouseEvent)


Occurences of MouseWheelEvent (constructors)

MouseWheelEvent (constructors) occurences:
java.awt.event.MouseWheelEvent(java.awt.Component, int, long, int, int, int, int, boolean, int, int, int)
java.awt.event.MouseWheelEvent(java.awt.Component, int, long, int, int, int, int, int, int, boolean, int, int, int)


Occurences of mouseWheelMoved

mouseWheelMoved occurences:
java.awt.AWTEventMulticaster.mouseWheelMoved(java.awt.event.MouseWheelEvent)
java.awt.event.MouseAdapter.mouseWheelMoved(java.awt.event.MouseWheelEvent)
java.awt.event.MouseWheelListener.mouseWheelMoved(java.awt.event.MouseWheelEvent)
javax.swing.plaf.basic.BasicScrollPaneUI.MouseWheelHandler.mouseWheelMoved(java.awt.event.MouseWheelEvent)


Occurences of move

move occurences:
java.awt.Component.move(int, int)
java.awt.Point.move(int, int)
java.awt.Rectangle.move(int, int)


Occurences of moveColumn

moveColumn occurences:
javax.swing.JTable.moveColumn(int, int)
javax.swing.table.DefaultTableColumnModel.moveColumn(int, int)
javax.swing.table.TableColumnModel.moveColumn(int, int)


Occurences of moveDot

moveDot occurences:
javax.swing.text.Caret.moveDot(int)
javax.swing.text.DefaultCaret.moveDot(int)
javax.swing.text.DefaultCaret.moveDot(int, javax.swing.text.Position.Bias)
javax.swing.text.NavigationFilter.moveDot(javax.swing.text.NavigationFilter.FilterBypass, int, javax.swing.text.Position.Bias)
javax.swing.text.NavigationFilter.FilterBypass.moveDot(int, javax.swing.text.Position.Bias)


Occurences of moveTo

moveTo occurences:
java.awt.geom.Path2D.moveTo(double, double)
java.awt.geom.Path2D.Double.moveTo(double, double)
java.awt.geom.Path2D.Float.moveTo(double, double)
java.awt.geom.Path2D.Float.moveTo(float, float)


Occurences of moveToBack

moveToBack occurences:
javax.swing.JInternalFrame.moveToBack()
javax.swing.JLayeredPane.moveToBack(java.awt.Component)


Occurences of moveToFront

moveToFront occurences:
javax.swing.JInternalFrame.moveToFront()
javax.swing.JLayeredPane.moveToFront(java.awt.Component)


Occurences of MOVE_CURSOR

MOVE_CURSOR occurences:
java.awt.MOVE_CURSOR
java.awt.MOVE_CURSOR


Occurences of MulticastSocket (constructors)

MulticastSocket (constructors) occurences:
java.net.MulticastSocket()
java.net.MulticastSocket(int)
java.net.MulticastSocket(java.net.SocketAddress)


Occurences of MultiPixelPackedSampleModel (constructors)

MultiPixelPackedSampleModel (constructors) occurences:
java.awt.image.MultiPixelPackedSampleModel(int, int, int, int)
java.awt.image.MultiPixelPackedSampleModel(int, int, int, int, int, int)


Occurences of MultipleComponentProfileHolder (constructors)

MultipleComponentProfileHolder (constructors) occurences:
org.omg.IOP.MultipleComponentProfileHolder()
org.omg.IOP.MultipleComponentProfileHolder(org.omg.IOP.TaggedComponent[])


Occurences of multiply

multiply occurences:
java.math.BigDecimal.multiply(java.math.BigDecimal)
java.math.BigDecimal.multiply(java.math.BigDecimal, java.math.MathContext)
java.math.BigInteger.multiply(java.math.BigInteger)
javax.xml.datatype.Duration.multiply(int)
javax.xml.datatype.Duration.multiply(java.math.BigDecimal)


Occurences of mutatesTo

mutatesTo occurences:
java.beans.DefaultPersistenceDelegate.mutatesTo(java.lang.Object, java.lang.Object)
java.beans.PersistenceDelegate.mutatesTo(java.lang.Object, java.lang.Object)


Occurences of MXBean

MXBean occurences:
java.lang.management.MXBean
javax.management.MXBean


Occurences of MYANMAR

MYANMAR occurences:
java.awt.font.MYANMAR
java.lang.MYANMAR


Occurences of NAME

NAME occurences:
javax.script.NAME
javax.swing.NAME
javax.swing.text.html.NAME
javax.swing.text.html.parser.NAME


Occurences of name

name occurences:
com.sun.javadoc.Doc.name()
com.sun.javadoc.Parameter.name()
com.sun.javadoc.Tag.name()
com.sun.jdi.connect.Connector.name()
com.sun.jdi.connect.Connector.Argument.name()
com.sun.jdi.connect.spi.TransportService.name()
com.sun.jdi.connect.Transport.name()
com.sun.jdi.LocalVariable.name()
com.sun.jdi.ReferenceType.name()
com.sun.jdi.ThreadGroupReference.name()
com.sun.jdi.ThreadReference.name()
com.sun.jdi.Type.name()
com.sun.jdi.TypeComponent.name()
com.sun.jdi.VirtualMachine.name()
com.sun.tools.attach.spi.AttachProvider.name()
java.awt.name
java.awt.name
java.lang.Enum.name()
java.lang.name
java.nio.charset.Charset.name()
java.sql.name
java.util.prefs.AbstractPreferences.name()
java.util.prefs.Preferences.name()
javax.annotation.Resource.name()
javax.jws.HandlerChain.name()
javax.jws.soap.InitParam.name()
javax.jws.soap.SOAPMessageHandler.name()
javax.jws.WebParam.name()
javax.jws.WebResult.name()
javax.jws.WebService.name()
javax.management.name
javax.swing.text.html.parser.name
javax.swing.text.html.parser.name
javax.swing.text.html.parser.name
javax.swing.text.html.parser.name
javax.xml.bind.annotation.XmlAttribute.name()
javax.xml.bind.annotation.XmlElement.name()
javax.xml.bind.annotation.XmlElementDecl.name()
javax.xml.bind.annotation.XmlElementRef.name()
javax.xml.bind.annotation.XmlElementWrapper.name()
javax.xml.bind.annotation.XmlRootElement.name()
javax.xml.bind.annotation.XmlSchemaType.name()
javax.xml.bind.annotation.XmlType.name()
javax.xml.bind.name
javax.xml.ws.WebEndpoint.name()
javax.xml.ws.WebFault.name()
javax.xml.ws.WebServiceClient.name()
javax.xml.ws.WebServiceRef.name()
org.omg.CORBA.name
org.omg.CORBA.name
org.omg.CORBA.name
org.omg.CORBA.NamedValue.name()
org.omg.CORBA.Principal.name()
org.omg.CORBA.Principal.name(byte[])
org.omg.CORBA.TypeCode.name()
org.omg.PortableInterceptor.InterceptorOperations.name()
org.omg.PortableInterceptor.ORBInitInfoPackage.name


Occurences of Name

Name occurences:
javax.lang.model.element.Name
javax.naming.Name
javax.xml.soap.Name


Occurences of name2type

name2type occurences:
javax.swing.text.html.parser.AttributeList.name2type(java.lang.String)
javax.swing.text.html.parser.Element.name2type(java.lang.String)
javax.swing.text.html.parser.Entity.name2type(java.lang.String)


Occurences of NameAlreadyBoundException (constructors)

NameAlreadyBoundException (constructors) occurences:
javax.naming.NameAlreadyBoundException()
javax.naming.NameAlreadyBoundException(java.lang.String)


Occurences of NameAttribute

NameAttribute occurences:
javax.swing.text.NameAttribute
javax.swing.text.NameAttribute


Occurences of NameCallback (constructors)

NameCallback (constructors) occurences:
javax.security.auth.callback.NameCallback(java.lang.String)
javax.security.auth.callback.NameCallback(java.lang.String, java.lang.String)


Occurences of NameClassPair (constructors)

NameClassPair (constructors) occurences:
javax.naming.NameClassPair(java.lang.String, java.lang.String)
javax.naming.NameClassPair(java.lang.String, java.lang.String, boolean)


Occurences of NameComponent (constructors)

NameComponent (constructors) occurences:
org.omg.CosNaming.NameComponent()
org.omg.CosNaming.NameComponent(java.lang.String, java.lang.String)


Occurences of NameComponentHolder (constructors)

NameComponentHolder (constructors) occurences:
org.omg.CosNaming.NameComponentHolder()
org.omg.CosNaming.NameComponentHolder(org.omg.CosNaming.NameComponent)


Occurences of NameDynAnyPair (constructors)

NameDynAnyPair (constructors) occurences:
org.omg.DynamicAny.NameDynAnyPair()
org.omg.DynamicAny.NameDynAnyPair(java.lang.String, org.omg.DynamicAny.DynAny)


Occurences of NameHolder (constructors)

NameHolder (constructors) occurences:
org.omg.CosNaming.NameHolder()
org.omg.CosNaming.NameHolder(org.omg.CosNaming.NameComponent[])


Occurences of NameNotFoundException (constructors)

NameNotFoundException (constructors) occurences:
javax.naming.NameNotFoundException()
javax.naming.NameNotFoundException(java.lang.String)


Occurences of names

names occurences:
java.nio.charset.names
javax.imageio.spi.names


Occurences of namespace

namespace occurences:
javax.xml.bind.annotation.XmlAttribute.namespace()
javax.xml.bind.annotation.XmlElement.namespace()
javax.xml.bind.annotation.XmlElementDecl.namespace()
javax.xml.bind.annotation.XmlElementRef.namespace()
javax.xml.bind.annotation.XmlElementWrapper.namespace()
javax.xml.bind.annotation.XmlRootElement.namespace()
javax.xml.bind.annotation.XmlSchema.namespace()
javax.xml.bind.annotation.XmlSchemaType.namespace()
javax.xml.bind.annotation.XmlType.namespace()
javax.xml.namespace


Occurences of NameValuePair

NameValuePair occurences:
org.omg.CORBA.NameValuePair
org.omg.DynamicAny.NameValuePair


Occurences of NameValuePair (constructors)

NameValuePair (constructors) occurences:
org.omg.CORBA.NameValuePair()
org.omg.CORBA.NameValuePair(java.lang.String, org.omg.CORBA.Any)
org.omg.DynamicAny.NameValuePair()
org.omg.DynamicAny.NameValuePair(java.lang.String, org.omg.CORBA.Any)


Occurences of NameValuePairHelper

NameValuePairHelper occurences:
org.omg.CORBA.NameValuePairHelper
org.omg.DynamicAny.NameValuePairHelper


Occurences of NameValuePairHelper (constructors)

NameValuePairHelper (constructors) occurences:
org.omg.CORBA.NameValuePairHelper()
org.omg.DynamicAny.NameValuePairHelper()


Occurences of NamingContextExtHolder (constructors)

NamingContextExtHolder (constructors) occurences:
org.omg.CosNaming.NamingContextExtHolder()
org.omg.CosNaming.NamingContextExtHolder(org.omg.CosNaming.NamingContextExt)


Occurences of NamingContextHolder (constructors)

NamingContextHolder (constructors) occurences:
org.omg.CosNaming.NamingContextHolder()
org.omg.CosNaming.NamingContextHolder(org.omg.CosNaming.NamingContext)


Occurences of NamingException (constructors)

NamingException (constructors) occurences:
javax.naming.NamingException()
javax.naming.NamingException(java.lang.String)


Occurences of NamingSecurityException (constructors)

NamingSecurityException (constructors) occurences:
javax.naming.NamingSecurityException()
javax.naming.NamingSecurityException(java.lang.String)


Occurences of NaN

NaN occurences:
java.lang.NaN
java.lang.NaN


Occurences of narrow

narrow occurences:
javax.rmi.CORBA.PortableRemoteObjectDelegate.narrow(java.lang.Object, java.lang.Class)
javax.rmi.PortableRemoteObject.narrow(java.lang.Object, java.lang.Class)
org.omg.CORBA.CurrentHelper.narrow(org.omg.CORBA.Object)
org.omg.CORBA.IDLTypeHelper.narrow(org.omg.CORBA.Object)
org.omg.CORBA.PolicyHelper.narrow(org.omg.CORBA.Object)
org.omg.CosNaming.BindingIteratorHelper.narrow(org.omg.CORBA.Object)
org.omg.CosNaming.NamingContextExtHelper.narrow(org.omg.CORBA.Object)
org.omg.CosNaming.NamingContextHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynAnyFactoryHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynAnyHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynArrayHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynEnumHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynFixedHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynSequenceHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynStructHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynUnionHelper.narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynValueHelper.narrow(org.omg.CORBA.Object)
org.omg.IOP.CodecFactoryHelper.narrow(org.omg.CORBA.Object)
org.omg.PortableInterceptor.CurrentHelper.narrow(org.omg.CORBA.Object)
org.omg.PortableInterceptor.IORInterceptor_3_0Helper.narrow(org.omg.CORBA.Object)
org.omg.PortableServer.CurrentHelper.narrow(org.omg.CORBA.Object)
org.omg.PortableServer.POAHelper.narrow(org.omg.CORBA.Object)
org.omg.PortableServer.ServantActivatorHelper.narrow(org.omg.CORBA.Object)
org.omg.PortableServer.ServantLocatorHelper.narrow(org.omg.CORBA.Object)


Occurences of NATIVE

NATIVE occurences:
com.sun.mirror.declaration.NATIVE
java.awt.NATIVE
java.lang.reflect.NATIVE
javax.lang.model.element.NATIVE


Occurences of Native-to-ASCII Converter

Native-to-ASCII Converter occurences:
Native-to-ASCII Converter
Native-to-ASCII Converter


Occurences of NativeMethodException (constructors)

NativeMethodException (constructors) occurences:
com.sun.jdi.NativeMethodException()
com.sun.jdi.NativeMethodException(java.lang.String)


Occurences of navigableKeySet

navigableKeySet occurences:
java.util.concurrent.ConcurrentNavigableMap.navigableKeySet()
java.util.concurrent.ConcurrentSkipListMap.navigableKeySet()
java.util.NavigableMap.navigableKeySet()
java.util.TreeMap.navigableKeySet()


Occurences of NA_10X13_ENVELOPE

NA_10X13_ENVELOPE occurences:
java.awt.NA_10X13_ENVELOPE
javax.print.attribute.standard.NA_10X13_ENVELOPE


Occurences of NA_10X14_ENVELOPE

NA_10X14_ENVELOPE occurences:
java.awt.NA_10X14_ENVELOPE
javax.print.attribute.standard.NA_10X14_ENVELOPE


Occurences of NA_10X15_ENVELOPE

NA_10X15_ENVELOPE occurences:
java.awt.NA_10X15_ENVELOPE
javax.print.attribute.standard.NA_10X15_ENVELOPE
javax.print.attribute.standard.NA_10X15_ENVELOPE


Occurences of NA_5X7

NA_5X7 occurences:
javax.print.attribute.standard.NA_5X7
javax.print.attribute.standard.NA_5X7


Occurences of NA_6X9_ENVELOPE

NA_6X9_ENVELOPE occurences:
java.awt.NA_6X9_ENVELOPE
javax.print.attribute.standard.NA_6X9_ENVELOPE
javax.print.attribute.standard.NA_6X9_ENVELOPE


Occurences of NA_7X9_ENVELOPE

NA_7X9_ENVELOPE occurences:
java.awt.NA_7X9_ENVELOPE
javax.print.attribute.standard.NA_7X9_ENVELOPE
javax.print.attribute.standard.NA_7X9_ENVELOPE


Occurences of NA_8X10

NA_8X10 occurences:
javax.print.attribute.standard.NA_8X10
javax.print.attribute.standard.NA_8X10


Occurences of NA_9X11_ENVELOPE

NA_9X11_ENVELOPE occurences:
java.awt.NA_9X11_ENVELOPE
javax.print.attribute.standard.NA_9X11_ENVELOPE


Occurences of NA_9X12_ENVELOPE

NA_9X12_ENVELOPE occurences:
java.awt.NA_9X12_ENVELOPE
javax.print.attribute.standard.NA_9X12_ENVELOPE


Occurences of NA_LEGAL

NA_LEGAL occurences:
java.awt.NA_LEGAL
javax.print.attribute.standard.NA_LEGAL


Occurences of NA_LETTER

NA_LETTER occurences:
java.awt.NA_LETTER
javax.print.attribute.standard.NA_LETTER


Occurences of NA_NUMBER_10_ENVELOPE

NA_NUMBER_10_ENVELOPE occurences:
java.awt.NA_NUMBER_10_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_10_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_10_ENVELOPE


Occurences of NA_NUMBER_11_ENVELOPE

NA_NUMBER_11_ENVELOPE occurences:
java.awt.NA_NUMBER_11_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_11_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_11_ENVELOPE


Occurences of NA_NUMBER_12_ENVELOPE

NA_NUMBER_12_ENVELOPE occurences:
java.awt.NA_NUMBER_12_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_12_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_12_ENVELOPE


Occurences of NA_NUMBER_14_ENVELOPE

NA_NUMBER_14_ENVELOPE occurences:
java.awt.NA_NUMBER_14_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_14_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_14_ENVELOPE


Occurences of NA_NUMBER_9_ENVELOPE

NA_NUMBER_9_ENVELOPE occurences:
java.awt.NA_NUMBER_9_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_9_ENVELOPE
javax.print.attribute.standard.NA_NUMBER_9_ENVELOPE


Occurences of nCopies

nCopies occurences:
java.util.Collections.nCopies(int, T)
java.util.Collections.nCopies(int,java.lang.Object)


Occurences of needsCacheFile

needsCacheFile occurences:
javax.imageio.spi.ImageInputStreamSpi.needsCacheFile()
javax.imageio.spi.ImageOutputStreamSpi.needsCacheFile()


Occurences of needsGui

needsGui occurences:
java.beans.beancontext.BeanContextSupport.needsGui()
java.beans.Visibility.needsGui()


Occurences of needsInput

needsInput occurences:
java.util.zip.Deflater.needsInput()
java.util.zip.Inflater.needsInput()


Occurences of negate

negate occurences:
java.math.BigDecimal.negate()
java.math.BigDecimal.negate(java.math.MathContext)
java.math.BigInteger.negate()
javax.xml.datatype.Duration.negate()


Occurences of NegativeArraySizeException (constructors)

NegativeArraySizeException (constructors) occurences:
java.lang.NegativeArraySizeException()
java.lang.NegativeArraySizeException(java.lang.String)


Occurences of NEGATIVE_INFINITY

NEGATIVE_INFINITY occurences:
java.lang.NEGATIVE_INFINITY
java.lang.NEGATIVE_INFINITY


Occurences of negotiate

negotiate occurences:
javax.naming.ldap.StartTlsResponse.negotiate()
javax.naming.ldap.StartTlsResponse.negotiate(javax.net.ssl.SSLSocketFactory)


Occurences of nested_class_summary

nested_class_summary occurences:
com.sun.javadoc.nested_class_summary
com.sun.jdi.connect.nested_class_summary
com.sun.jdi.connect.nested_class_summary
com.sun.jdi.connect.nested_class_summary
com.sun.jdi.connect.nested_class_summary
com.sun.jdi.connect.spi.nested_class_summary
com.sun.mirror.apt.nested_class_summary
com.sun.mirror.type.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.tree.nested_class_summary
com.sun.source.util.nested_class_summary
com.sun.tools.jconsole.nested_class_summary
java.applet.nested_class_summary
java.applet.nested_class_summary
java.awt.dnd.nested_class_summary
java.awt.dnd.nested_class_summary
java.awt.font.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.geom.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.awt.nested_class_summary
java.beans.beancontext.nested_class_summary
java.beans.beancontext.nested_class_summary
java.io.nested_class_summary
java.io.nested_class_summary
java.lang.nested_class_summary
java.lang.nested_class_summary
java.net.nested_class_summary
java.net.nested_class_summary
java.nio.channels.nested_class_summary
java.nio.channels.nested_class_summary
java.rmi.activation.nested_class_summary
java.security.cert.nested_class_summary
java.security.cert.nested_class_summary
java.security.cert.nested_class_summary
java.security.nested_class_summary
java.security.nested_class_summary
java.security.nested_class_summary
java.security.nested_class_summary
java.security.nested_class_summary
java.text.nested_class_summary
java.text.nested_class_summary
java.text.nested_class_summary
java.text.nested_class_summary
java.text.nested_class_summary
java.text.nested_class_summary
java.text.nested_class_summary
java.text.nested_class_summary
java.text.nested_class_summary
java.util.concurrent.locks.nested_class_summary
java.util.concurrent.locks.nested_class_summary
java.util.concurrent.locks.nested_class_summary
java.util.concurrent.nested_class_summary
java.util.concurrent.nested_class_summary
java.util.concurrent.nested_class_summary
java.util.concurrent.nested_class_summary
java.util.concurrent.nested_class_summary
java.util.concurrent.nested_class_summary
java.util.jar.nested_class_summary
java.util.jar.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
java.util.nested_class_summary
javax.accessibility.nested_class_summary
javax.crypto.spec.nested_class_summary
javax.crypto.spec.nested_class_summary
javax.imageio.spi.nested_class_summary
javax.imageio.spi.nested_class_summary
javax.management.openmbean.nested_class_summary
javax.naming.spi.nested_class_summary
javax.net.ssl.nested_class_summary
javax.print.attribute.standard.nested_class_summary
javax.print.attribute.standard.nested_class_summary
javax.print.nested_class_summary
javax.print.nested_class_summary
javax.print.nested_class_summary
javax.print.nested_class_summary
javax.print.nested_class_summary
javax.print.nested_class_summary
javax.print.nested_class_summary
javax.print.nested_class_summary
javax.script.nested_class_summary
javax.script.nested_class_summary
javax.security.auth.login.nested_class_summary
javax.security.auth.login.nested_class_summary
javax.sound.midi.nested_class_summary
javax.sound.midi.nested_class_summary
javax.sound.midi.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.sound.sampled.nested_class_summary
javax.swing.colorchooser.nested_class_summary
javax.swing.event.nested_class_summary
javax.swing.event.nested_class_summary
javax.swing.event.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.basic.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.metal.nested_class_summary
javax.swing.plaf.nested_class_summary
javax.swing.table.nested_class_summary
javax.swing.table.nested_class_summary
javax.swing.table.nested_class_summary
javax.swing.table.nested_class_summary
javax.swing.table.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.html.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.nested_class_summary
javax.swing.text.rtf.nested_class_summary
javax.swing.tree.nested_class_summary
javax.swing.tree.nested_class_summary
javax.swing.tree.nested_class_summary
javax.swing.tree.nested_class_summary
javax.swing.tree.nested_class_summary
javax.swing.tree.nested_class_summary
javax.swing.tree.nested_class_summary
javax.tools.nested_class_summary
javax.tools.nested_class_summary
javax.tools.nested_class_summary
javax.tools.nested_class_summary
javax.tools.nested_class_summary
javax.tools.nested_class_summary
javax.tools.nested_class_summary
javax.tools.nested_class_summary
javax.xml.bind.helpers.nested_class_summary
javax.xml.bind.helpers.nested_class_summary
javax.xml.bind.nested_class_summary
javax.xml.bind.nested_class_summary
javax.xml.bind.nested_class_summary
javax.xml.crypto.dsig.nested_class_summary
javax.xml.crypto.dsig.spec.nested_class_summary
javax.xml.crypto.nested_class_summary
javax.xml.datatype.nested_class_summary
javax.xml.ws.handler.nested_class_summary
javax.xml.ws.handler.nested_class_summary
javax.xml.ws.handler.soap.nested_class_summary
javax.xml.ws.nested_class_summary


Occurences of net

net occurences:
java.net
javax.net


Occurences of NetPermission (constructors)

NetPermission (constructors) occurences:
java.net.NetPermission(java.lang.String)
java.net.NetPermission(java.lang.String, java.lang.String)


Occurences of Networking Features

Networking Features occurences:
Networking Features
Networking Features
Networking Features


Occurences of New Features in Java 2D(TM) Technology

New Features in Java 2D(TM) Technology occurences:
New Features in Java 2D(TM) Technology
New Features in Java 2D(TM) Technology


Occurences of newCachedThreadPool

newCachedThreadPool occurences:
java.util.concurrent.Executors.newCachedThreadPool()
java.util.concurrent.Executors.newCachedThreadPool(java.util.concurrent.ThreadFactory)


Occurences of newCanonicalizationMethod

newCanonicalizationMethod occurences:
javax.xml.crypto.dsig.XMLSignatureFactory.newCanonicalizationMethod(java.lang.String, javax.xml.crypto.dsig.spec.C14NMethodParameterSpec)
javax.xml.crypto.dsig.XMLSignatureFactory.newCanonicalizationMethod(java.lang.String, javax.xml.crypto.XMLStructure)


Occurences of newChannel

newChannel occurences:
java.nio.channels.Channels.newChannel(java.io.InputStream)
java.nio.channels.Channels.newChannel(java.io.OutputStream)


Occurences of newClient

newClient occurences:
javax.management.remote.rmi.RMIServer.newClient(java.lang.Object)
javax.management.remote.rmi.RMIServerImpl.newClient(java.lang.Object)
javax.management.remote.rmi.RMIServerImpl_Stub.newClient(java.lang.Object)


Occurences of newCondition

newCondition occurences:
java.util.concurrent.locks.Lock.newCondition()
java.util.concurrent.locks.ReentrantLock.newCondition()
java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.newCondition()
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.newCondition()


Occurences of newDuration

newDuration occurences:
javax.xml.datatype.DatatypeFactory.newDuration(boolean, int, int, int, int, int, int)
javax.xml.datatype.DatatypeFactory.newDuration(boolean, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger, java.math.BigDecimal)
javax.xml.datatype.DatatypeFactory.newDuration(java.lang.String)
javax.xml.datatype.DatatypeFactory.newDuration(long)


Occurences of newDurationDayTime

newDurationDayTime occurences:
javax.xml.datatype.DatatypeFactory.newDurationDayTime(boolean, int, int, int, int)
javax.xml.datatype.DatatypeFactory.newDurationDayTime(boolean, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger)
javax.xml.datatype.DatatypeFactory.newDurationDayTime(java.lang.String)
javax.xml.datatype.DatatypeFactory.newDurationDayTime(long)


Occurences of newDurationYearMonth

newDurationYearMonth occurences:
javax.xml.datatype.DatatypeFactory.newDurationYearMonth(boolean, int, int)
javax.xml.datatype.DatatypeFactory.newDurationYearMonth(boolean, java.math.BigInteger, java.math.BigInteger)
javax.xml.datatype.DatatypeFactory.newDurationYearMonth(java.lang.String)
javax.xml.datatype.DatatypeFactory.newDurationYearMonth(long)


Occurences of newFixedThreadPool

newFixedThreadPool occurences:
java.util.concurrent.Executors.newFixedThreadPool(int)
java.util.concurrent.Executors.newFixedThreadPool(int, java.util.concurrent.ThreadFactory)


Occurences of newInstance

newInstance occurences:
com.sun.jdi.ArrayType.newInstance(int)
com.sun.jdi.ClassType.newInstance(com.sun.jdi.ThreadReference, com.sun.jdi.Method, java.util.List, int)
java.lang.Class.newInstance()
java.lang.reflect.Array.newInstance(java.lang.Class, int)
java.lang.reflect.Array.newInstance(java.lang.Class, int...)
java.lang.reflect.Constructor.newInstance(java.lang.Object...)
java.net.URLClassLoader.newInstance(java.net.URL[])
java.net.URLClassLoader.newInstance(java.net.URL[], java.lang.ClassLoader)
java.rmi.activation.ActivationGroup_Stub.newInstance(java.rmi.activation.ActivationID, java.rmi.activation.ActivationDesc)
java.rmi.activation.ActivationInstantiator.newInstance(java.rmi.activation.ActivationID, java.rmi.activation.ActivationDesc)
java.security.KeyStore.Builder.newInstance(java.lang.String, java.security.Provider, java.io.File, java.security.KeyStore.ProtectionParameter)
java.security.KeyStore.Builder.newInstance(java.lang.String, java.security.Provider, java.security.KeyStore.ProtectionParameter)
java.security.KeyStore.Builder.newInstance(java.security.KeyStore, java.security.KeyStore.ProtectionParameter)
java.security.Provider.Service.newInstance(java.lang.Object)
javax.naming.ldap.InitialLdapContext.newInstance(javax.naming.ldap.Control[])
javax.naming.ldap.LdapContext.newInstance(javax.naming.ldap.Control[])
javax.xml.bind.JAXBContext.newInstance(java.lang.Class...)
javax.xml.bind.JAXBContext.newInstance(java.lang.Class[], java.util.Map)
javax.xml.bind.JAXBContext.newInstance(java.lang.String)
javax.xml.bind.JAXBContext.newInstance(java.lang.String, java.lang.ClassLoader)
javax.xml.bind.JAXBContext.newInstance(java.lang.String, java.lang.ClassLoader, java.util.Map)
javax.xml.datatype.DatatypeFactory.newInstance()
javax.xml.datatype.DatatypeFactory.newInstance(java.lang.String, java.lang.ClassLoader)
javax.xml.parsers.DocumentBuilderFactory.newInstance()
javax.xml.parsers.DocumentBuilderFactory.newInstance(java.lang.String, java.lang.ClassLoader)
javax.xml.parsers.SAXParserFactory.newInstance()
javax.xml.parsers.SAXParserFactory.newInstance(java.lang.String, java.lang.ClassLoader)
javax.xml.soap.MessageFactory.newInstance()
javax.xml.soap.MessageFactory.newInstance(java.lang.String)
javax.xml.soap.SOAPConnectionFactory.newInstance()
javax.xml.soap.SOAPElementFactory.newInstance()
javax.xml.soap.SOAPFactory.newInstance()
javax.xml.soap.SOAPFactory.newInstance(java.lang.String)
javax.xml.stream.util.XMLEventAllocator.newInstance()
javax.xml.stream.XMLEventFactory.newInstance()
javax.xml.stream.XMLEventFactory.newInstance(java.lang.String, java.lang.ClassLoader)
javax.xml.stream.XMLInputFactory.newInstance()
javax.xml.stream.XMLInputFactory.newInstance(java.lang.String, java.lang.ClassLoader)
javax.xml.stream.XMLOutputFactory.newInstance()
javax.xml.stream.XMLOutputFactory.newInstance(java.lang.String, java.lang.ClassLoader)
javax.xml.transform.TransformerFactory.newInstance()
javax.xml.transform.TransformerFactory.newInstance(java.lang.String, java.lang.ClassLoader)
javax.xml.validation.SchemaFactory.newInstance(java.lang.String)
javax.xml.validation.SchemaFactory.newInstance(java.lang.String, java.lang.String, java.lang.ClassLoader)
javax.xml.xpath.XPathFactory.newInstance()
javax.xml.xpath.XPathFactory.newInstance(java.lang.String)
javax.xml.xpath.XPathFactory.newInstance(java.lang.String, java.lang.String, java.lang.ClassLoader)
org.w3c.dom.bootstrap.DOMImplementationRegistry.newInstance()


Occurences of newJMXConnector

newJMXConnector occurences:
javax.management.remote.JMXConnectorFactory.newJMXConnector(javax.management.remote.JMXServiceURL, java.util.Map)
javax.management.remote.JMXConnectorProvider.newJMXConnector(javax.management.remote.JMXServiceURL, java.util.Map)


Occurences of newJMXConnectorServer

newJMXConnectorServer occurences:
javax.management.remote.JMXConnectorServerFactory.newJMXConnectorServer(javax.management.remote.JMXServiceURL, java.util.Map, javax.management.MBeanServer)
javax.management.remote.JMXConnectorServerProvider.newJMXConnectorServer(javax.management.remote.JMXServiceURL, java.util.Map, javax.management.MBeanServer)


Occurences of newKeyInfo

newKeyInfo occurences:
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.newKeyInfo(java.util.List)
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.newKeyInfo(java.util.List, java.lang.String)


Occurences of newManifest

newManifest occurences:
javax.xml.crypto.dsig.XMLSignatureFactory.newManifest(java.util.List)
javax.xml.crypto.dsig.XMLSignatureFactory.newManifest(java.util.List, java.lang.String)


Occurences of newMBeanProxy

newMBeanProxy occurences:
javax.management.JMX.newMBeanProxy(javax.management.MBeanServerConnection, javax.management.ObjectName, java.lang.Class)
javax.management.JMX.newMBeanProxy(javax.management.MBeanServerConnection, javax.management.ObjectName, java.lang.Class, boolean)


Occurences of newMBeanServer

newMBeanServer occurences:
javax.management.MBeanServerBuilder.newMBeanServer(java.lang.String, javax.management.MBeanServer, javax.management.MBeanServerDelegate)
javax.management.MBeanServerFactory.newMBeanServer()
javax.management.MBeanServerFactory.newMBeanServer(java.lang.String)


Occurences of newMXBeanProxy

newMXBeanProxy occurences:
javax.management.JMX.newMXBeanProxy(javax.management.MBeanServerConnection, javax.management.ObjectName, java.lang.Class)
javax.management.JMX.newMXBeanProxy(javax.management.MBeanServerConnection, javax.management.ObjectName, java.lang.Class, boolean)


Occurences of newPermissionCollection

newPermissionCollection occurences:
java.io.FilePermission.newPermissionCollection()
java.net.SocketPermission.newPermissionCollection()
java.security.AllPermission.newPermissionCollection()
java.security.BasicPermission.newPermissionCollection()
java.security.Permission.newPermissionCollection()
java.security.UnresolvedPermission.newPermissionCollection()
java.util.PropertyPermission.newPermissionCollection()
javax.management.MBeanServerPermission.newPermissionCollection()
javax.security.auth.kerberos.DelegationPermission.newPermissionCollection()
javax.security.auth.kerberos.ServicePermission.newPermissionCollection()
javax.security.auth.PrivateCredentialPermission.newPermissionCollection()


Occurences of newPGPData

newPGPData occurences:
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.newPGPData(byte[])
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.newPGPData(byte[], byte[], java.util.List)
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.newPGPData(byte[], java.util.List)


Occurences of newPixels

newPixels occurences:
java.awt.image.MemoryImageSource.newPixels()
java.awt.image.MemoryImageSource.newPixels(byte[], java.awt.image.ColorModel, int, int)
java.awt.image.MemoryImageSource.newPixels(int, int, int, int)
java.awt.image.MemoryImageSource.newPixels(int, int, int, int, boolean)
java.awt.image.MemoryImageSource.newPixels(int[], java.awt.image.ColorModel, int, int)


Occurences of newProxyInstance

newProxyInstance occurences:
java.lang.reflect.Proxy.newProxyInstance(java.lang.ClassLoader, java.lang.Class[], java.lang.reflect.InvocationHandler)
javax.management.MBeanServerInvocationHandler.newProxyInstance(javax.management.MBeanServerConnection, javax.management.ObjectName, java.lang.Class, boolean)


Occurences of newReader

newReader occurences:
java.nio.channels.Channels.newReader(java.nio.channels.ReadableByteChannel, java.lang.String)
java.nio.channels.Channels.newReader(java.nio.channels.ReadableByteChannel, java.nio.charset.CharsetDecoder, int)


Occurences of newReference

newReference occurences:
javax.xml.crypto.dsig.XMLSignatureFactory.newReference(java.lang.String, javax.xml.crypto.dsig.DigestMethod)
javax.xml.crypto.dsig.XMLSignatureFactory.newReference(java.lang.String, javax.xml.crypto.dsig.DigestMethod, java.util.List, java.lang.String, java.lang.String)
javax.xml.crypto.dsig.XMLSignatureFactory.newReference(java.lang.String, javax.xml.crypto.dsig.DigestMethod, java.util.List, java.lang.String, java.lang.String, byte[])
javax.xml.crypto.dsig.XMLSignatureFactory.newReference(java.lang.String, javax.xml.crypto.dsig.DigestMethod, java.util.List, javax.xml.crypto.Data, java.util.List, java.lang.String, java.lang.String)


Occurences of newRetrievalMethod

newRetrievalMethod occurences:
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.newRetrievalMethod(java.lang.String)
javax.xml.crypto.dsig.keyinfo.KeyInfoFactory.newRetrievalMethod(java.lang.String, java.lang.String, java.util.List)


Occurences of newScheduledThreadPool

newScheduledThreadPool occurences:
java.util.concurrent.Executors.newScheduledThreadPool(int)
java.util.concurrent.Executors.newScheduledThreadPool(int, java.util.concurrent.ThreadFactory)


Occurences of newSchema

newSchema occurences:
javax.xml.validation.SchemaFactory.newSchema()
javax.xml.validation.SchemaFactory.newSchema(java.io.File)
javax.xml.validation.SchemaFactory.newSchema(java.net.URL)
javax.xml.validation.SchemaFactory.newSchema(javax.xml.transform.Source)
javax.xml.validation.SchemaFactory.newSchema(javax.xml.transform.Source[])


Occurences of newSignedInfo

newSignedInfo occurences:
javax.xml.crypto.dsig.XMLSignatureFactory.newSignedInfo(javax.xml.crypto.dsig.CanonicalizationMethod, javax.xml.crypto.dsig.SignatureMethod, java.util.List)
javax.xml.crypto.dsig.XMLSignatureFactory.newSignedInfo(javax.xml.crypto.dsig.CanonicalizationMethod, javax.xml.crypto.dsig.SignatureMethod, java.util.List, java.lang.String)


Occurences of newSingleThreadExecutor

newSingleThreadExecutor occurences:
java.util.concurrent.Executors.newSingleThreadExecutor()
java.util.concurrent.Executors.newSingleThreadExecutor(java.util.concurrent.ThreadFactory)


Occurences of newSingleThreadScheduledExecutor

newSingleThreadScheduledExecutor occurences:
java.util.concurrent.Executors.newSingleThreadScheduledExecutor()
java.util.concurrent.Executors.newSingleThreadScheduledExecutor(java.util.concurrent.ThreadFactory)


Occurences of newTaskFor

newTaskFor occurences:
java.util.concurrent.AbstractExecutorService.newTaskFor(java.lang.Runnable, T)
java.util.concurrent.AbstractExecutorService.newTaskFor(java.lang.Runnable,java.lang.Object)
java.util.concurrent.AbstractExecutorService.newTaskFor(java.util.concurrent.Callable)


Occurences of newTransform

newTransform occurences:
javax.xml.crypto.dsig.XMLSignatureFactory.newTransform(java.lang.String, javax.xml.crypto.dsig.spec.TransformParameterSpec)
javax.xml.crypto.dsig.XMLSignatureFactory.newTransform(java.lang.String, javax.xml.crypto.XMLStructure)


Occurences of newTransformer

newTransformer occurences:
javax.xml.transform.Templates.newTransformer()
javax.xml.transform.TransformerFactory.newTransformer()
javax.xml.transform.TransformerFactory.newTransformer(javax.xml.transform.Source)


Occurences of newTransformerHandler

newTransformerHandler occurences:
javax.xml.transform.sax.SAXTransformerFactory.newTransformerHandler()
javax.xml.transform.sax.SAXTransformerFactory.newTransformerHandler(javax.xml.transform.Source)
javax.xml.transform.sax.SAXTransformerFactory.newTransformerHandler(javax.xml.transform.Templates)


Occurences of newUpdater

newUpdater occurences:
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.newUpdater(java.lang.Class, java.lang.String)
java.util.concurrent.atomic.AtomicLongFieldUpdater.newUpdater(java.lang.Class, java.lang.String)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.newUpdater(java.lang.Class, java.lang.Class, java.lang.String)


Occurences of newWriter

newWriter occurences:
java.nio.channels.Channels.newWriter(java.nio.channels.WritableByteChannel, java.lang.String)
java.nio.channels.Channels.newWriter(java.nio.channels.WritableByteChannel, java.nio.charset.CharsetEncoder, int)


Occurences of newXMLFilter

newXMLFilter occurences:
javax.xml.transform.sax.SAXTransformerFactory.newXMLFilter(javax.xml.transform.Source)
javax.xml.transform.sax.SAXTransformerFactory.newXMLFilter(javax.xml.transform.Templates)


Occurences of newXMLGregorianCalendar

newXMLGregorianCalendar occurences:
javax.xml.datatype.DatatypeFactory.newXMLGregorianCalendar()
javax.xml.datatype.DatatypeFactory.newXMLGregorianCalendar(int, int, int, int, int, int, int, int)
javax.xml.datatype.DatatypeFactory.newXMLGregorianCalendar(java.lang.String)
javax.xml.datatype.DatatypeFactory.newXMLGregorianCalendar(java.math.BigInteger, int, int, int, int, int, java.math.BigDecimal, int)
javax.xml.datatype.DatatypeFactory.newXMLGregorianCalendar(java.util.GregorianCalendar)


Occurences of newXMLGregorianCalendarTime

newXMLGregorianCalendarTime occurences:
javax.xml.datatype.DatatypeFactory.newXMLGregorianCalendarTime(int, int, int, int)
javax.xml.datatype.DatatypeFactory.newXMLGregorianCalendarTime(int, int, int, int, int)
javax.xml.datatype.DatatypeFactory.newXMLGregorianCalendarTime(int, int, int, java.math.BigDecimal, int)


Occurences of newXMLSignature

newXMLSignature occurences:
javax.xml.crypto.dsig.XMLSignatureFactory.newXMLSignature(javax.xml.crypto.dsig.SignedInfo, javax.xml.crypto.dsig.keyinfo.KeyInfo)
javax.xml.crypto.dsig.XMLSignatureFactory.newXMLSignature(javax.xml.crypto.dsig.SignedInfo, javax.xml.crypto.dsig.keyinfo.KeyInfo, java.util.List, java.lang.String, java.lang.String)


Occurences of new_context

new_context occurences:
org.omg.CosNaming.NamingContextOperations.new_context()
org.omg.CosNaming._NamingContextExtStub.new_context()
org.omg.CosNaming._NamingContextStub.new_context()


Occurences of next

next occurences:
java.awt.CardLayout.next(java.awt.Container)
java.awt.geom.FlatteningPathIterator.next()
java.awt.geom.PathIterator.next()
java.beans.beancontext.BeanContextSupport.BCSIterator.next()
java.security.SecureRandom.next(int)
java.sql.ResultSet.next()
java.text.BreakIterator.next()
java.text.BreakIterator.next(int)
java.text.CharacterIterator.next()
java.text.CollationElementIterator.next()
java.text.StringCharacterIterator.next()
java.util.Iterator.next()
java.util.ListIterator.next()
java.util.Random.next(int)
java.util.Scanner.next()
java.util.Scanner.next(java.lang.String)
java.util.Scanner.next(java.util.regex.Pattern)
javax.naming.NamingEnumeration.next()
javax.print.attribute.SetOfIntegerSyntax.next(int)
javax.print.MultiDoc.next()
javax.swing.text.ElementIterator.next()
javax.swing.text.html.HTMLDocument.Iterator.next()
javax.swing.text.html.parser.next
javax.swing.text.html.parser.next
javax.swing.text.Segment.next()
javax.xml.stream.util.EventReaderDelegate.next()
javax.xml.stream.util.StreamReaderDelegate.next()
javax.xml.stream.XMLStreamReader.next()
org.omg.CORBA.DynAny.next()
org.omg.DynamicAny.DynAnyOperations.next()
org.omg.DynamicAny._DynAnyStub.next()
org.omg.DynamicAny._DynArrayStub.next()
org.omg.DynamicAny._DynEnumStub.next()
org.omg.DynamicAny._DynFixedStub.next()
org.omg.DynamicAny._DynSequenceStub.next()
org.omg.DynamicAny._DynStructStub.next()
org.omg.DynamicAny._DynUnionStub.next()
org.omg.DynamicAny._DynValueStub.next()


Occurences of nextAfter

nextAfter occurences:
java.lang.Math.nextAfter(double, double)
java.lang.Math.nextAfter(float, double)
java.lang.StrictMath.nextAfter(double, double)
java.lang.StrictMath.nextAfter(float, double)


Occurences of nextBigInteger

nextBigInteger occurences:
java.util.Scanner.nextBigInteger()
java.util.Scanner.nextBigInteger(int)


Occurences of nextBoolean

nextBoolean occurences:
java.util.Random.nextBoolean()
java.util.Scanner.nextBoolean()


Occurences of nextByte

nextByte occurences:
java.util.Scanner.nextByte()
java.util.Scanner.nextByte(int)


Occurences of nextBytes

nextBytes occurences:
java.security.SecureRandom.nextBytes(byte[])
java.util.Random.nextBytes(byte[])


Occurences of nextDouble

nextDouble occurences:
java.text.ChoiceFormat.nextDouble(double)
java.text.ChoiceFormat.nextDouble(double, boolean)
java.util.Random.nextDouble()
java.util.Scanner.nextDouble()


Occurences of nextElement

nextElement occurences:
java.util.Enumeration.nextElement()
java.util.StringTokenizer.nextElement()


Occurences of nextEvent

nextEvent occurences:
com.sun.jdi.event.EventIterator.nextEvent()
javax.xml.stream.util.EventReaderDelegate.nextEvent()
javax.xml.stream.XMLEventReader.nextEvent()


Occurences of nextFloat

nextFloat occurences:
java.util.Random.nextFloat()
java.util.Scanner.nextFloat()


Occurences of nextInt

nextInt occurences:
java.util.Random.nextInt()
java.util.Random.nextInt(int)
java.util.Scanner.nextInt()
java.util.Scanner.nextInt(int)


Occurences of nextLayout

nextLayout occurences:
java.awt.font.LineBreakMeasurer.nextLayout(float)
java.awt.font.LineBreakMeasurer.nextLayout(float, int, boolean)


Occurences of nextLong

nextLong occurences:
java.util.Random.nextLong()
java.util.Scanner.nextLong()
java.util.Scanner.nextLong(int)


Occurences of nextOffset

nextOffset occurences:
java.awt.font.LineBreakMeasurer.nextOffset(float)
java.awt.font.LineBreakMeasurer.nextOffset(float, int, boolean)


Occurences of nextShort

nextShort occurences:
java.util.Scanner.nextShort()
java.util.Scanner.nextShort(int)


Occurences of nextTabStop

nextTabStop occurences:
javax.swing.text.ParagraphView.nextTabStop(float, int)
javax.swing.text.PlainView.nextTabStop(float, int)
javax.swing.text.TabExpander.nextTabStop(float, int)
javax.swing.text.WrappedPlainView.nextTabStop(float, int)


Occurences of nextTag

nextTag occurences:
javax.xml.stream.util.EventReaderDelegate.nextTag()
javax.xml.stream.util.StreamReaderDelegate.nextTag()
javax.xml.stream.XMLEventReader.nextTag()
javax.xml.stream.XMLStreamReader.nextTag()


Occurences of nextToken

nextToken occurences:
java.io.StreamTokenizer.nextToken()
java.util.StringTokenizer.nextToken()
java.util.StringTokenizer.nextToken(java.lang.String)


Occurences of nextUp

nextUp occurences:
java.lang.Math.nextUp(double)
java.lang.Math.nextUp(float)
java.lang.StrictMath.nextUp(double)
java.lang.StrictMath.nextUp(float)


Occurences of next_n

next_n occurences:
org.omg.CosNaming.BindingIteratorOperations.next_n(int, org.omg.CosNaming.BindingListHolder)
org.omg.CosNaming._BindingIteratorStub.next_n(int, org.omg.CosNaming.BindingListHolder)


Occurences of next_one

next_one occurences:
org.omg.CosNaming.BindingIteratorOperations.next_one(org.omg.CosNaming.BindingHolder)
org.omg.CosNaming._BindingIteratorStub.next_one(org.omg.CosNaming.BindingHolder)


Occurences of NE_RESIZE_CURSOR

NE_RESIZE_CURSOR occurences:
java.awt.NE_RESIZE_CURSOR
java.awt.NE_RESIZE_CURSOR


Occurences of nillable

nillable occurences:
javax.xml.bind.annotation.XmlElement.nillable()
javax.xml.bind.annotation.XmlElementWrapper.nillable()


Occurences of NoClassDefFoundError (constructors)

NoClassDefFoundError (constructors) occurences:
java.lang.NoClassDefFoundError()
java.lang.NoClassDefFoundError(java.lang.String)


Occurences of NoContext (constructors)

NoContext (constructors) occurences:
org.omg.PortableServer.CurrentPackage.NoContext()
org.omg.PortableServer.CurrentPackage.NoContext(java.lang.String)


Occurences of node

node occurences:
java.util.prefs.AbstractPreferences.node(java.lang.String)
java.util.prefs.Preferences.node(java.lang.String)
java.util.UUID.node()


Occurences of Node

Node occurences:
javax.xml.soap.Node
org.w3c.dom.Node


Occurences of nodeDimensions

nodeDimensions occurences:
javax.swing.plaf.basic.nodeDimensions
javax.swing.tree.nodeDimensions


Occurences of nodeExists

nodeExists occurences:
java.util.prefs.AbstractPreferences.nodeExists(java.lang.String)
java.util.prefs.Preferences.nodeExists(java.lang.String)


Occurences of noFocusBorder

noFocusBorder occurences:
javax.swing.noFocusBorder
javax.swing.plaf.basic.noFocusBorder
javax.swing.table.noFocusBorder


Occurences of NoInitialContextException (constructors)

NoInitialContextException (constructors) occurences:
javax.naming.NoInitialContextException()
javax.naming.NoInitialContextException(java.lang.String)


Occurences of NONE

NONE occurences:
java.awt.NONE
java.awt.NONE
java.awt.NONE
javax.lang.model.type.NONE
javax.print.attribute.standard.NONE
javax.print.attribute.standard.NONE
javax.print.attribute.standard.NONE
javax.swing.NONE
javax.swing.NONE
javax.xml.bind.annotation.NONE


Occurences of non_existent

non_existent occurences:
org.omg.CORBA.portable.Delegate.non_existent(org.omg.CORBA.Object)
org.omg.PortableServer.portable.Delegate.non_existent(org.omg.PortableServer.Servant)


Occurences of NoPermissionException (constructors)

NoPermissionException (constructors) occurences:
javax.naming.NoPermissionException()
javax.naming.NoPermissionException(java.lang.String)


Occurences of NORMAL

NORMAL occurences:
java.awt.NORMAL
java.awt.NORMAL
javax.print.attribute.standard.NORMAL
javax.swing.NORMAL


Occurences of normalize

normalize occurences:
java.net.URI.normalize()
java.text.Normalizer.normalize(java.lang.CharSequence, java.text.Normalizer.Form)
javax.imageio.metadata.IIOMetadataNode.normalize()
javax.xml.datatype.XMLGregorianCalendar.normalize()
org.w3c.dom.Node.normalize()


Occurences of normalizeMimeType

normalizeMimeType occurences:
java.awt.datatransfer.DataFlavor.normalizeMimeType(java.lang.String)
javax.activation.ActivationDataFlavor.normalizeMimeType(java.lang.String)


Occurences of normalizeMimeTypeParameter

normalizeMimeTypeParameter occurences:
java.awt.datatransfer.DataFlavor.normalizeMimeTypeParameter(java.lang.String, java.lang.String)
javax.activation.ActivationDataFlavor.normalizeMimeTypeParameter(java.lang.String, java.lang.String)


Occurences of normalizeTabRuns

normalizeTabRuns occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.TabbedPaneLayout.normalizeTabRuns(int, int, int, int)
javax.swing.plaf.metal.MetalTabbedPaneUI.TabbedPaneLayout.normalizeTabRuns(int, int, int, int)


Occurences of NoRouteToHostException (constructors)

NoRouteToHostException (constructors) occurences:
java.net.NoRouteToHostException()
java.net.NoRouteToHostException(java.lang.String)


Occurences of NORTH

NORTH occurences:
java.awt.NORTH
java.awt.NORTH
javax.swing.NORTH
javax.swing.NORTH


Occurences of NoServant (constructors)

NoServant (constructors) occurences:
org.omg.PortableServer.POAPackage.NoServant()
org.omg.PortableServer.POAPackage.NoServant(java.lang.String)


Occurences of NoSuchAlgorithmException (constructors)

NoSuchAlgorithmException (constructors) occurences:
java.security.NoSuchAlgorithmException()
java.security.NoSuchAlgorithmException(java.lang.String)
java.security.NoSuchAlgorithmException(java.lang.String, java.lang.Throwable)
java.security.NoSuchAlgorithmException(java.lang.Throwable)


Occurences of NoSuchAttributeException (constructors)

NoSuchAttributeException (constructors) occurences:
javax.naming.directory.NoSuchAttributeException()
javax.naming.directory.NoSuchAttributeException(java.lang.String)


Occurences of NoSuchElementException (constructors)

NoSuchElementException (constructors) occurences:
java.util.NoSuchElementException()
java.util.NoSuchElementException(java.lang.String)


Occurences of NoSuchFieldError (constructors)

NoSuchFieldError (constructors) occurences:
java.lang.NoSuchFieldError()
java.lang.NoSuchFieldError(java.lang.String)


Occurences of NoSuchFieldException (constructors)

NoSuchFieldException (constructors) occurences:
java.lang.NoSuchFieldException()
java.lang.NoSuchFieldException(java.lang.String)


Occurences of NoSuchMechanismException (constructors)

NoSuchMechanismException (constructors) occurences:
javax.xml.crypto.NoSuchMechanismException()
javax.xml.crypto.NoSuchMechanismException(java.lang.String)
javax.xml.crypto.NoSuchMechanismException(java.lang.String, java.lang.Throwable)
javax.xml.crypto.NoSuchMechanismException(java.lang.Throwable)


Occurences of NoSuchMethodError (constructors)

NoSuchMethodError (constructors) occurences:
java.lang.NoSuchMethodError()
java.lang.NoSuchMethodError(java.lang.String)


Occurences of NoSuchMethodException (constructors)

NoSuchMethodException (constructors) occurences:
java.lang.NoSuchMethodException()
java.lang.NoSuchMethodException(java.lang.String)


Occurences of NoSuchPaddingException (constructors)

NoSuchPaddingException (constructors) occurences:
javax.crypto.NoSuchPaddingException()
javax.crypto.NoSuchPaddingException(java.lang.String)


Occurences of NoSuchProviderException (constructors)

NoSuchProviderException (constructors) occurences:
java.security.NoSuchProviderException()
java.security.NoSuchProviderException(java.lang.String)


Occurences of not

not occurences:
com.sun.mirror.util.DeclarationFilter.not()
java.math.BigInteger.not()
javax.management.Query.not(javax.management.QueryExp)


Occurences of NotActiveException (constructors)

NotActiveException (constructors) occurences:
java.io.NotActiveException()
java.io.NotActiveException(java.lang.String)


Occurences of notationDecl

notationDecl occurences:
org.xml.sax.DTDHandler.notationDecl(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.HandlerBase.notationDecl(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.helpers.DefaultHandler.notationDecl(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.notationDecl(java.lang.String, java.lang.String, java.lang.String)


Occurences of NotBoundException (constructors)

NotBoundException (constructors) occurences:
java.rmi.NotBoundException()
java.rmi.NotBoundException(java.lang.String)


Occurences of NotCompliantMBeanException (constructors)

NotCompliantMBeanException (constructors) occurences:
javax.management.NotCompliantMBeanException()
javax.management.NotCompliantMBeanException(java.lang.String)


Occurences of NotContextException (constructors)

NotContextException (constructors) occurences:
javax.naming.NotContextException()
javax.naming.NotContextException(java.lang.String)


Occurences of NOTE

NOTE occurences:
java.awt.NOTE
javax.tools.NOTE


Occurences of NotEmpty (constructors)

NotEmpty (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.NotEmpty()
org.omg.CosNaming.NamingContextPackage.NotEmpty(java.lang.String)


Occurences of NotEmptyHolder (constructors)

NotEmptyHolder (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.NotEmptyHolder()
org.omg.CosNaming.NamingContextPackage.NotEmptyHolder(org.omg.CosNaming.NamingContextPackage.NotEmpty)


Occurences of noteOff

noteOff occurences:
javax.sound.midi.MidiChannel.noteOff(int)
javax.sound.midi.MidiChannel.noteOff(int, int)


Occurences of NotFound (constructors)

NotFound (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.NotFound()
org.omg.CosNaming.NamingContextPackage.NotFound(java.lang.String, org.omg.CosNaming.NamingContextPackage.NotFoundReason, org.omg.CosNaming.NameComponent[])
org.omg.CosNaming.NamingContextPackage.NotFound(org.omg.CosNaming.NamingContextPackage.NotFoundReason, org.omg.CosNaming.NameComponent[])


Occurences of NotFoundHolder (constructors)

NotFoundHolder (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.NotFoundHolder()
org.omg.CosNaming.NamingContextPackage.NotFoundHolder(org.omg.CosNaming.NamingContextPackage.NotFound)


Occurences of NotFoundReasonHolder (constructors)

NotFoundReasonHolder (constructors) occurences:
org.omg.CosNaming.NamingContextPackage.NotFoundReasonHolder()
org.omg.CosNaming.NamingContextPackage.NotFoundReasonHolder(org.omg.CosNaming.NamingContextPackage.NotFoundReason)


Occurences of NotIdentifiableEventImpl (constructors)

NotIdentifiableEventImpl (constructors) occurences:
javax.xml.bind.helpers.NotIdentifiableEventImpl(int, java.lang.String, javax.xml.bind.ValidationEventLocator)
javax.xml.bind.helpers.NotIdentifiableEventImpl(int, java.lang.String, javax.xml.bind.ValidationEventLocator, java.lang.Throwable)


Occurences of Notification (constructors)

Notification (constructors) occurences:
javax.management.Notification(java.lang.String, java.lang.Object, long)
javax.management.Notification(java.lang.String, java.lang.Object, long, java.lang.String)
javax.management.Notification(java.lang.String, java.lang.Object, long, long)
javax.management.Notification(java.lang.String, java.lang.Object, long, long, java.lang.String)


Occurences of NotificationBroadcasterSupport (constructors)

NotificationBroadcasterSupport (constructors) occurences:
javax.management.NotificationBroadcasterSupport()
javax.management.NotificationBroadcasterSupport(java.util.concurrent.Executor)
javax.management.NotificationBroadcasterSupport(java.util.concurrent.Executor, javax.management.MBeanNotificationInfo...)
javax.management.NotificationBroadcasterSupport(javax.management.MBeanNotificationInfo...)


Occurences of notifyAction

notifyAction occurences:
javax.swing.notifyAction
javax.swing.SwingUtilities.notifyAction(javax.swing.Action, javax.swing.KeyStroke, java.awt.event.KeyEvent, java.lang.Object, int)


Occurences of notifyObservers

notifyObservers occurences:
java.util.Observable.notifyObservers()
java.util.Observable.notifyObservers(java.lang.Object)


Occurences of NotSerializableException (constructors)

NotSerializableException (constructors) occurences:
java.io.NotSerializableException()
java.io.NotSerializableException(java.lang.String)


Occurences of NOVEMBER

NOVEMBER occurences:
java.util.NOVEMBER
javax.xml.datatype.NOVEMBER


Occurences of NO_IMPLEMENT (constructors)

NO_IMPLEMENT (constructors) occurences:
org.omg.CORBA.NO_IMPLEMENT()
org.omg.CORBA.NO_IMPLEMENT(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.NO_IMPLEMENT(java.lang.String)
org.omg.CORBA.NO_IMPLEMENT(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of NO_MEMORY (constructors)

NO_MEMORY (constructors) occurences:
org.omg.CORBA.NO_MEMORY()
org.omg.CORBA.NO_MEMORY(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.NO_MEMORY(java.lang.String)
org.omg.CORBA.NO_MEMORY(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of NO_OP

NO_OP occurences:
com.sun.mirror.apt.NO_OP
com.sun.mirror.util.NO_OP


Occurences of NO_PERMISSION (constructors)

NO_PERMISSION (constructors) occurences:
org.omg.CORBA.NO_PERMISSION()
org.omg.CORBA.NO_PERMISSION(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.NO_PERMISSION(java.lang.String)
org.omg.CORBA.NO_PERMISSION(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of NO_RESOURCES (constructors)

NO_RESOURCES (constructors) occurences:
org.omg.CORBA.NO_RESOURCES()
org.omg.CORBA.NO_RESOURCES(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.NO_RESOURCES(java.lang.String)
org.omg.CORBA.NO_RESOURCES(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of NO_RESPONSE (constructors)

NO_RESPONSE (constructors) occurences:
org.omg.CORBA.NO_RESPONSE()
org.omg.CORBA.NO_RESPONSE(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.NO_RESPONSE(java.lang.String)
org.omg.CORBA.NO_RESPONSE(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of NULL

NULL occurences:
java.sql.NULL
javax.lang.model.type.NULL


Occurences of NullPointerException (constructors)

NullPointerException (constructors) occurences:
java.lang.NullPointerException()
java.lang.NullPointerException(java.lang.String)


Occurences of numBands

numBands occurences:
java.awt.image.numBands
java.awt.image.numBands
java.awt.image.numBands


Occurences of NUMBER

NUMBER occurences:
javax.swing.text.html.parser.NUMBER
javax.xml.xpath.NUMBER


Occurences of NumberFormatException (constructors)

NumberFormatException (constructors) occurences:
java.lang.NumberFormatException()
java.lang.NumberFormatException(java.lang.String)


Occurences of NumberFormatter (constructors)

NumberFormatter (constructors) occurences:
javax.swing.text.NumberFormatter()
javax.swing.text.NumberFormatter(java.text.NumberFormat)


Occurences of numberOfLeadingZeros

numberOfLeadingZeros occurences:
java.lang.Integer.numberOfLeadingZeros(int)
java.lang.Long.numberOfLeadingZeros(long)


Occurences of numberOfTrailingZeros

numberOfTrailingZeros occurences:
java.lang.Integer.numberOfTrailingZeros(int)
java.lang.Long.numberOfTrailingZeros(long)


Occurences of NumberUpSupported (constructors)

NumberUpSupported (constructors) occurences:
javax.print.attribute.standard.NumberUpSupported(int)
javax.print.attribute.standard.NumberUpSupported(int, int)
javax.print.attribute.standard.NumberUpSupported(int[][])


Occurences of NW_RESIZE_CURSOR

NW_RESIZE_CURSOR occurences:
java.awt.NW_RESIZE_CURSOR
java.awt.NW_RESIZE_CURSOR


Occurences of N_RESIZE_CURSOR

N_RESIZE_CURSOR occurences:
java.awt.N_RESIZE_CURSOR
java.awt.N_RESIZE_CURSOR


Occurences of object

object occurences:
com.sun.jdi.event.WatchpointEvent.object()
javax.swing.undo.object


Occurences of Object

Object occurences:
java.lang.Object
org.omg.CORBA.Object


Occurences of ObjectAlreadyActive (constructors)

ObjectAlreadyActive (constructors) occurences:
org.omg.PortableServer.POAPackage.ObjectAlreadyActive()
org.omg.PortableServer.POAPackage.ObjectAlreadyActive(java.lang.String)


Occurences of ObjectCollectedException (constructors)

ObjectCollectedException (constructors) occurences:
com.sun.jdi.ObjectCollectedException()
com.sun.jdi.ObjectCollectedException(java.lang.String)


Occurences of ObjectHolder (constructors)

ObjectHolder (constructors) occurences:
org.omg.CORBA.ObjectHolder()
org.omg.CORBA.ObjectHolder(org.omg.CORBA.Object)


Occurences of ObjectIdHelper

ObjectIdHelper occurences:
org.omg.PortableInterceptor.ObjectIdHelper
org.omg.PortableInterceptor.ORBInitInfoPackage.ObjectIdHelper


Occurences of ObjectIdHelper (constructors)

ObjectIdHelper (constructors) occurences:
org.omg.PortableInterceptor.ObjectIdHelper()
org.omg.PortableInterceptor.ORBInitInfoPackage.ObjectIdHelper()


Occurences of ObjectImpl

ObjectImpl occurences:
org.omg.CORBA.portable.ObjectImpl
org.omg.CORBA_2_3.portable.ObjectImpl


Occurences of ObjectImpl (constructors)

ObjectImpl (constructors) occurences:
org.omg.CORBA.portable.ObjectImpl()
org.omg.CORBA_2_3.portable.ObjectImpl()


Occurences of ObjectInputStream (constructors)

ObjectInputStream (constructors) occurences:
java.io.ObjectInputStream()
java.io.ObjectInputStream(java.io.InputStream)


Occurences of ObjectInstance (constructors)

ObjectInstance (constructors) occurences:
javax.management.ObjectInstance(java.lang.String, java.lang.String)
javax.management.ObjectInstance(javax.management.ObjectName, java.lang.String)


Occurences of ObjectName (constructors)

ObjectName (constructors) occurences:
javax.management.ObjectName(java.lang.String)
javax.management.ObjectName(java.lang.String, java.lang.String, java.lang.String)
javax.management.ObjectName(java.lang.String, java.util.Hashtable)


Occurences of ObjectNotActive (constructors)

ObjectNotActive (constructors) occurences:
org.omg.PortableServer.POAPackage.ObjectNotActive()
org.omg.PortableServer.POAPackage.ObjectNotActive(java.lang.String)


Occurences of ObjectOutputStream (constructors)

ObjectOutputStream (constructors) occurences:
java.io.ObjectOutputStream()
java.io.ObjectOutputStream(java.io.OutputStream)


Occurences of ObjectReferenceFactoryHolder (constructors)

ObjectReferenceFactoryHolder (constructors) occurences:
org.omg.PortableInterceptor.ObjectReferenceFactoryHolder()
org.omg.PortableInterceptor.ObjectReferenceFactoryHolder(org.omg.PortableInterceptor.ObjectReferenceFactory)


Occurences of ObjectReferenceTemplateHolder (constructors)

ObjectReferenceTemplateHolder (constructors) occurences:
org.omg.PortableInterceptor.ObjectReferenceTemplateHolder()
org.omg.PortableInterceptor.ObjectReferenceTemplateHolder(org.omg.PortableInterceptor.ObjectReferenceTemplate)


Occurences of ObjectReferenceTemplateSeqHolder (constructors)

ObjectReferenceTemplateSeqHolder (constructors) occurences:
org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHolder()
org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHolder(org.omg.PortableInterceptor.ObjectReferenceTemplate[])


Occurences of ObjectStreamException (constructors)

ObjectStreamException (constructors) occurences:
java.io.ObjectStreamException()
java.io.ObjectStreamException(java.lang.String)


Occurences of ObjectStreamField (constructors)

ObjectStreamField (constructors) occurences:
java.io.ObjectStreamField(java.lang.String, java.lang.Class)
java.io.ObjectStreamField(java.lang.String, java.lang.Class, boolean)


Occurences of object_id

object_id occurences:
org.omg.PortableInterceptor.ServerRequestInfoOperations.object_id()
org.omg.PortableServer.portable.Delegate.object_id(org.omg.PortableServer.Servant)


Occurences of OBJECT_NOT_EXIST (constructors)

OBJECT_NOT_EXIST (constructors) occurences:
org.omg.CORBA.OBJECT_NOT_EXIST()
org.omg.CORBA.OBJECT_NOT_EXIST(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.OBJECT_NOT_EXIST(java.lang.String)
org.omg.CORBA.OBJECT_NOT_EXIST(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of OBJECT_SCOPE

OBJECT_SCOPE occurences:
javax.naming.directory.OBJECT_SCOPE
javax.naming.event.OBJECT_SCOPE


Occurences of ObjID (constructors)

ObjID (constructors) occurences:
java.rmi.server.ObjID()
java.rmi.server.ObjID(int)


Occurences of OBJ_ADAPTER (constructors)

OBJ_ADAPTER (constructors) occurences:
org.omg.CORBA.OBJ_ADAPTER()
org.omg.CORBA.OBJ_ADAPTER(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.OBJ_ADAPTER(java.lang.String)
org.omg.CORBA.OBJ_ADAPTER(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of OctetSeqHolder (constructors)

OctetSeqHolder (constructors) occurences:
org.omg.CORBA.OctetSeqHolder()
org.omg.CORBA.OctetSeqHolder(byte[])


Occurences of OctetStreamData (constructors)

OctetStreamData (constructors) occurences:
javax.xml.crypto.OctetStreamData(java.io.InputStream)
javax.xml.crypto.OctetStreamData(java.io.InputStream, java.lang.String, java.lang.String)


Occurences of OCTOBER

OCTOBER occurences:
java.util.OCTOBER
javax.xml.datatype.OCTOBER


Occurences of of

of occurences:
java.lang.Character.UnicodeBlock.of(char)
java.lang.Character.UnicodeBlock.of(int)
java.util.EnumSet.of(E)
java.util.EnumSet.of(E, E)
java.util.EnumSet.of(E, E, E)
java.util.EnumSet.of(E, E, E, E)
java.util.EnumSet.of(E, E, E, E, E)
java.util.EnumSet.of(E, E...)
java.util.EnumSet.of(java.lang.Enum)
java.util.EnumSet.of(java.lang.Enum,java.lang.Enum)
java.util.EnumSet.of(java.lang.Enum,java.lang.Enum,java.lang.Enum)
java.util.EnumSet.of(java.lang.Enum,java.lang.Enum,java.lang.Enum,java.lang.Enum)
java.util.EnumSet.of(java.lang.Enum,java.lang.Enum,java.lang.Enum,java.lang.Enum,java.lang.Enum)
java.util.EnumSet.of(java.lang.Enum,java.lang.Enum[])
javax.annotation.processing.Completions.of(java.lang.String)
javax.annotation.processing.Completions.of(java.lang.String, java.lang.String)


Occurences of offer

offer occurences:
java.util.ArrayDeque.offer(E)
java.util.ArrayDeque.offer(java.lang.Object)
java.util.concurrent.ArrayBlockingQueue.offer(E)
java.util.concurrent.ArrayBlockingQueue.offer(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.ArrayBlockingQueue.offer(java.lang.Object)
java.util.concurrent.ArrayBlockingQueue.offer(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.BlockingDeque.offer(E)
java.util.concurrent.BlockingDeque.offer(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.BlockingDeque.offer(java.lang.Object)
java.util.concurrent.BlockingDeque.offer(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.BlockingQueue.offer(E)
java.util.concurrent.BlockingQueue.offer(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.BlockingQueue.offer(java.lang.Object)
java.util.concurrent.BlockingQueue.offer(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.ConcurrentLinkedQueue.offer(E)
java.util.concurrent.ConcurrentLinkedQueue.offer(java.lang.Object)
java.util.concurrent.DelayQueue.offer(E)
java.util.concurrent.DelayQueue.offer(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.DelayQueue.offer(java.util.concurrent.Delayed)
java.util.concurrent.DelayQueue.offer(java.util.concurrent.Delayed,long,java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingDeque.offer(E)
java.util.concurrent.LinkedBlockingDeque.offer(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingDeque.offer(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.offer(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingQueue.offer(E)
java.util.concurrent.LinkedBlockingQueue.offer(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingQueue.offer(java.lang.Object)
java.util.concurrent.LinkedBlockingQueue.offer(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.PriorityBlockingQueue.offer(E)
java.util.concurrent.PriorityBlockingQueue.offer(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.PriorityBlockingQueue.offer(java.lang.Object)
java.util.concurrent.PriorityBlockingQueue.offer(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.SynchronousQueue.offer(E)
java.util.concurrent.SynchronousQueue.offer(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.SynchronousQueue.offer(java.lang.Object)
java.util.concurrent.SynchronousQueue.offer(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.Deque.offer(E)
java.util.Deque.offer(java.lang.Object)
java.util.LinkedList.offer(E)
java.util.LinkedList.offer(java.lang.Object)
java.util.PriorityQueue.offer(E)
java.util.PriorityQueue.offer(java.lang.Object)
java.util.Queue.offer(E)
java.util.Queue.offer(java.lang.Object)


Occurences of offerFirst

offerFirst occurences:
java.util.ArrayDeque.offerFirst(E)
java.util.ArrayDeque.offerFirst(java.lang.Object)
java.util.concurrent.BlockingDeque.offerFirst(E)
java.util.concurrent.BlockingDeque.offerFirst(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.BlockingDeque.offerFirst(java.lang.Object)
java.util.concurrent.BlockingDeque.offerFirst(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingDeque.offerFirst(E)
java.util.concurrent.LinkedBlockingDeque.offerFirst(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingDeque.offerFirst(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.offerFirst(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.Deque.offerFirst(E)
java.util.Deque.offerFirst(java.lang.Object)
java.util.LinkedList.offerFirst(E)
java.util.LinkedList.offerFirst(java.lang.Object)


Occurences of offerLast

offerLast occurences:
java.util.ArrayDeque.offerLast(E)
java.util.ArrayDeque.offerLast(java.lang.Object)
java.util.concurrent.BlockingDeque.offerLast(E)
java.util.concurrent.BlockingDeque.offerLast(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.BlockingDeque.offerLast(java.lang.Object)
java.util.concurrent.BlockingDeque.offerLast(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingDeque.offerLast(E)
java.util.concurrent.LinkedBlockingDeque.offerLast(E, long, java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingDeque.offerLast(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.offerLast(java.lang.Object,long,java.util.concurrent.TimeUnit)
java.util.Deque.offerLast(E)
java.util.Deque.offerLast(java.lang.Object)
java.util.LinkedList.offerLast(E)
java.util.LinkedList.offerLast(java.lang.Object)


Occurences of offset

offset occurences:
java.awt.image.offset
javax.swing.plaf.basic.offset
javax.swing.plaf.basic.offset
javax.swing.text.offset
javax.swing.tree.offset
org.omg.CORBA.portable.offset


Occurences of offsetByCodePoints

offsetByCodePoints occurences:
java.lang.Character.offsetByCodePoints(char[], int, int, int, int)
java.lang.Character.offsetByCodePoints(java.lang.CharSequence, int, int)
java.lang.String.offsetByCodePoints(int, int)
java.lang.StringBuffer.offsetByCodePoints(int, int)
java.lang.StringBuilder.offsetByCodePoints(int, int)


Occurences of OID

OID occurences:
javax.naming.ldap.OID
javax.naming.ldap.OID
javax.naming.ldap.OID
javax.naming.ldap.OID
javax.naming.ldap.OID
javax.naming.ldap.OID
javax.naming.ldap.OID


Occurences of Oid (constructors)

Oid (constructors) occurences:
org.ietf.jgss.Oid(byte[])
org.ietf.jgss.Oid(java.io.InputStream)
org.ietf.jgss.Oid(java.lang.String)


Occurences of OK

OK occurences:
javax.net.ssl.OK
javax.security.auth.callback.OK


Occurences of okToUseGui

okToUseGui occurences:
java.beans.beancontext.BeanContextSupport.okToUseGui()
java.beans.beancontext.okToUseGui
java.beans.Visibility.okToUseGui()


Occurences of OK_CANCEL_OPTION

OK_CANCEL_OPTION occurences:
javax.security.auth.callback.OK_CANCEL_OPTION
javax.swing.OK_CANCEL_OPTION


Occurences of on

on occurences:
java.security.DigestInputStream.on(boolean)
java.security.DigestOutputStream.on(boolean)


Occurences of onDeregistration

onDeregistration occurences:
javax.imageio.spi.IIOServiceProvider.onDeregistration(javax.imageio.spi.ServiceRegistry, java.lang.Class)
javax.imageio.spi.RegisterableService.onDeregistration(javax.imageio.spi.ServiceRegistry, java.lang.Class)


Occurences of ONE

ONE occurences:
java.math.ONE
java.math.ONE


Occurences of ONELEVEL_SCOPE

ONELEVEL_SCOPE occurences:
javax.naming.directory.ONELEVEL_SCOPE
javax.naming.event.ONELEVEL_SCOPE


Occurences of ONE_SIDED

ONE_SIDED occurences:
java.awt.ONE_SIDED
javax.print.attribute.standard.ONE_SIDED


Occurences of onMalformedInput

onMalformedInput occurences:
java.nio.charset.CharsetDecoder.onMalformedInput(java.nio.charset.CodingErrorAction)
java.nio.charset.CharsetEncoder.onMalformedInput(java.nio.charset.CodingErrorAction)


Occurences of onRegistration

onRegistration occurences:
javax.imageio.spi.IIOServiceProvider.onRegistration(javax.imageio.spi.ServiceRegistry, java.lang.Class)
javax.imageio.spi.RegisterableService.onRegistration(javax.imageio.spi.ServiceRegistry, java.lang.Class)


Occurences of onUnmappableCharacter

onUnmappableCharacter occurences:
java.nio.charset.CharsetDecoder.onUnmappableCharacter(java.nio.charset.CodingErrorAction)
java.nio.charset.CharsetEncoder.onUnmappableCharacter(java.nio.charset.CodingErrorAction)


Occurences of OPAQUE

OPAQUE occurences:
java.awt.OPAQUE
javax.accessibility.OPAQUE


Occurences of OPEN

OPEN occurences:
java.awt.geom.OPEN
java.awt.OPEN
javax.sound.sampled.OPEN


Occurences of open

open occurences:
java.awt.Desktop.open(java.io.File)
java.nio.channels.DatagramChannel.open()
java.nio.channels.Pipe.open()
java.nio.channels.Selector.open()
java.nio.channels.ServerSocketChannel.open()
java.nio.channels.SocketChannel.open()
java.nio.channels.SocketChannel.open(java.net.SocketAddress)
javax.sound.midi.MidiDevice.open()
javax.sound.sampled.Clip.open(javax.sound.sampled.AudioFormat, byte[], int, int)
javax.sound.sampled.Clip.open(javax.sound.sampled.AudioInputStream)
javax.sound.sampled.Line.open()
javax.sound.sampled.SourceDataLine.open(javax.sound.sampled.AudioFormat)
javax.sound.sampled.SourceDataLine.open(javax.sound.sampled.AudioFormat, int)
javax.sound.sampled.TargetDataLine.open(javax.sound.sampled.AudioFormat)
javax.sound.sampled.TargetDataLine.open(javax.sound.sampled.AudioFormat, int)


Occurences of openConnection

openConnection occurences:
java.net.URL.openConnection()
java.net.URL.openConnection(java.net.Proxy)
java.net.URLStreamHandler.openConnection(java.net.URL)
java.net.URLStreamHandler.openConnection(java.net.URL, java.net.Proxy)


Occurences of OpenDataException (constructors)

OpenDataException (constructors) occurences:
javax.management.openmbean.OpenDataException()
javax.management.openmbean.OpenDataException(java.lang.String)


Occurences of openFrame

openFrame occurences:
javax.swing.DefaultDesktopManager.openFrame(javax.swing.JInternalFrame)
javax.swing.DesktopManager.openFrame(javax.swing.JInternalFrame)


Occurences of openInputStream

openInputStream occurences:
javax.tools.FileObject.openInputStream()
javax.tools.ForwardingFileObject.openInputStream()
javax.tools.SimpleJavaFileObject.openInputStream()


Occurences of OpenMBeanAttributeInfoSupport (constructors)

OpenMBeanAttributeInfoSupport (constructors) occurences:
javax.management.openmbean.OpenMBeanAttributeInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, boolean, boolean, boolean)
javax.management.openmbean.OpenMBeanAttributeInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, boolean, boolean, boolean, javax.management.Descriptor)
javax.management.openmbean.OpenMBeanAttributeInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, boolean, boolean, boolean, T)
javax.management.openmbean.OpenMBeanAttributeInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, boolean, boolean, boolean, T, java.lang.Comparable, java.lang.Comparable)
javax.management.openmbean.OpenMBeanAttributeInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, boolean, boolean, boolean, T, T[])
javax.management.openmbean.OpenMBeanAttributeInfoSupport(java.lang.String,java.lang.String,javax.management.openmbean.OpenType,boolean,boolean,boolean,java.lang.Object)
javax.management.openmbean.OpenMBeanAttributeInfoSupport(java.lang.String,java.lang.String,javax.management.openmbean.OpenType,boolean,boolean,boolean,java.lang.Object,java.lang.Comparable,java.lang.Comparable)
javax.management.openmbean.OpenMBeanAttributeInfoSupport(java.lang.String,java.lang.String,javax.management.openmbean.OpenType,boolean,boolean,boolean,java.lang.Object,java.lang.Object[])


Occurences of OpenMBeanConstructorInfoSupport (constructors)

OpenMBeanConstructorInfoSupport (constructors) occurences:
javax.management.openmbean.OpenMBeanConstructorInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenMBeanParameterInfo[])
javax.management.openmbean.OpenMBeanConstructorInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenMBeanParameterInfo[], javax.management.Descriptor)


Occurences of OpenMBeanInfoSupport (constructors)

OpenMBeanInfoSupport (constructors) occurences:
javax.management.openmbean.OpenMBeanInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenMBeanAttributeInfo[], javax.management.openmbean.OpenMBeanConstructorInfo[], javax.management.openmbean.OpenMBeanOperationInfo[], javax.management.MBeanNotificationInfo[])
javax.management.openmbean.OpenMBeanInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenMBeanAttributeInfo[], javax.management.openmbean.OpenMBeanConstructorInfo[], javax.management.openmbean.OpenMBeanOperationInfo[], javax.management.MBeanNotificationInfo[], javax.management.Descriptor)


Occurences of OpenMBeanOperationInfoSupport (constructors)

OpenMBeanOperationInfoSupport (constructors) occurences:
javax.management.openmbean.OpenMBeanOperationInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenMBeanParameterInfo[], javax.management.openmbean.OpenType, int)
javax.management.openmbean.OpenMBeanOperationInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenMBeanParameterInfo[], javax.management.openmbean.OpenType, int, javax.management.Descriptor)


Occurences of OpenMBeanParameterInfoSupport (constructors)

OpenMBeanParameterInfoSupport (constructors) occurences:
javax.management.openmbean.OpenMBeanParameterInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType)
javax.management.openmbean.OpenMBeanParameterInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, javax.management.Descriptor)
javax.management.openmbean.OpenMBeanParameterInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, T)
javax.management.openmbean.OpenMBeanParameterInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, T, java.lang.Comparable, java.lang.Comparable)
javax.management.openmbean.OpenMBeanParameterInfoSupport(java.lang.String, java.lang.String, javax.management.openmbean.OpenType, T, T[])
javax.management.openmbean.OpenMBeanParameterInfoSupport(java.lang.String,java.lang.String,javax.management.openmbean.OpenType,java.lang.Object)
javax.management.openmbean.OpenMBeanParameterInfoSupport(java.lang.String,java.lang.String,javax.management.openmbean.OpenType,java.lang.Object,java.lang.Comparable,java.lang.Comparable)
javax.management.openmbean.OpenMBeanParameterInfoSupport(java.lang.String,java.lang.String,javax.management.openmbean.OpenType,java.lang.Object,java.lang.Object[])


Occurences of openOutputStream

openOutputStream occurences:
javax.tools.FileObject.openOutputStream()
javax.tools.ForwardingFileObject.openOutputStream()
javax.tools.SimpleJavaFileObject.openOutputStream()


Occurences of openReader

openReader occurences:
javax.tools.FileObject.openReader(boolean)
javax.tools.ForwardingFileObject.openReader(boolean)
javax.tools.SimpleJavaFileObject.openReader(boolean)


Occurences of OpenType

OpenType occurences:
java.awt.font.OpenType
javax.management.openmbean.OpenType


Occurences of openWriter

openWriter occurences:
javax.tools.FileObject.openWriter()
javax.tools.ForwardingFileObject.openWriter()
javax.tools.SimpleJavaFileObject.openWriter()


Occurences of operation

operation occurences:
org.omg.CORBA.Request.operation()
org.omg.CORBA.ServerRequest.operation()
org.omg.PortableInterceptor.RequestInfoOperations.operation()


Occurences of OperationNotSupportedException (constructors)

OperationNotSupportedException (constructors) occurences:
javax.naming.OperationNotSupportedException()
javax.naming.OperationNotSupportedException(java.lang.String)


Occurences of OperationsException (constructors)

OperationsException (constructors) occurences:
javax.management.OperationsException()
javax.management.OperationsException(java.lang.String)


Occurences of options

options occurences:
com.sun.javadoc.RootDoc.options()
javax.swing.options


Occurences of OPTION_PANE

OPTION_PANE occurences:
javax.accessibility.OPTION_PANE
javax.swing.plaf.synth.OPTION_PANE


Occurences of or

or occurences:
com.sun.mirror.util.DeclarationFilter.or(com.sun.mirror.util.DeclarationFilter)
java.math.BigInteger.or(java.math.BigInteger)
java.util.BitSet.or(java.util.BitSet)
javax.management.Query.or(javax.management.QueryExp, javax.management.QueryExp)


Occurences of ORB

ORB occurences:
org.omg.CORBA.ORB
org.omg.CORBA_2_3.ORB


Occurences of orb

orb occurences:
javax.rmi.CORBA.Tie.orb()
javax.rmi.CORBA.Tie.orb(org.omg.CORBA.ORB)
org.omg.CORBA.portable.Delegate.orb(org.omg.CORBA.Object)
org.omg.CORBA.portable.InputStream.orb()
org.omg.CORBA.portable.OutputStream.orb()
org.omg.PortableServer.portable.Delegate.orb(org.omg.PortableServer.Servant)


Occurences of ORB (constructors)

ORB (constructors) occurences:
org.omg.CORBA.ORB()
org.omg.CORBA_2_3.ORB()


Occurences of orb_id

orb_id occurences:
org.omg.PortableInterceptor.ObjectReferenceTemplate.orb_id()
org.omg.PortableInterceptor.ORBInitInfoOperations.orb_id()
org.omg.PortableInterceptor.ServerRequestInfoOperations.orb_id()


Occurences of order

order occurences:
java.nio.ByteBuffer.order()
java.nio.ByteBuffer.order(java.nio.ByteOrder)
java.nio.CharBuffer.order()
java.nio.DoubleBuffer.order()
java.nio.FloatBuffer.order()
java.nio.IntBuffer.order()
java.nio.LongBuffer.order()
java.nio.ShortBuffer.order()


Occurences of orientation

orientation occurences:
javax.swing.orientation
javax.swing.orientation
javax.swing.orientation
javax.swing.orientation
javax.swing.plaf.basic.orientation


Occurences of originatingProvider

originatingProvider occurences:
javax.imageio.originatingProvider
javax.imageio.originatingProvider


Occurences of ORIYA

ORIYA occurences:
java.awt.font.ORIYA
java.lang.ORIYA


Occurences of OTHER

OTHER occurences:
com.sun.source.tree.OTHER
java.awt.OTHER
java.sql.OTHER
javax.lang.model.element.OTHER
javax.lang.model.type.OTHER
javax.print.attribute.standard.OTHER
javax.tools.OTHER
javax.tools.OTHER


Occurences of out

out occurences:
java.io.out
java.io.out
java.io.out
java.io.out
java.io.out
java.lang.out
java.util.Formatter.out()


Occurences of outcode

outcode occurences:
java.awt.geom.Rectangle2D.outcode(double, double)
java.awt.geom.Rectangle2D.outcode(java.awt.geom.Point2D)
java.awt.geom.Rectangle2D.Double.outcode(double, double)
java.awt.geom.Rectangle2D.Float.outcode(double, double)
java.awt.Rectangle.outcode(double, double)


Occurences of OutOfMemoryError (constructors)

OutOfMemoryError (constructors) occurences:
java.lang.OutOfMemoryError()
java.lang.OutOfMemoryError(java.lang.String)


Occurences of output

output occurences:
javax.imageio.output
javax.swing.text.AbstractWriter.output(char[], int, int)
javax.swing.text.html.HTMLWriter.output(char[], int, int)


Occurences of OutputStream

OutputStream occurences:
java.io.OutputStream
org.omg.CORBA.portable.OutputStream
org.omg.CORBA_2_3.portable.OutputStream


Occurences of OutputStream (constructors)

OutputStream (constructors) occurences:
java.io.OutputStream()
org.omg.CORBA.portable.OutputStream()
org.omg.CORBA_2_3.portable.OutputStream()


Occurences of OutputStreamWriter (constructors)

OutputStreamWriter (constructors) occurences:
java.io.OutputStreamWriter(java.io.OutputStream)
java.io.OutputStreamWriter(java.io.OutputStream, java.lang.String)
java.io.OutputStreamWriter(java.io.OutputStream, java.nio.charset.Charset)
java.io.OutputStreamWriter(java.io.OutputStream, java.nio.charset.CharsetEncoder)


Occurences of override

override occurences:
javax.swing.override
javax.swing.table.override
javax.swing.tree.override


Occurences of overrides

overrides occurences:
com.sun.javadoc.MethodDoc.overrides(com.sun.javadoc.MethodDoc)
com.sun.mirror.util.Declarations.overrides(com.sun.mirror.declaration.MethodDeclaration, com.sun.mirror.declaration.MethodDeclaration)
javax.lang.model.util.Elements.overrides(javax.lang.model.element.ExecutableElement, javax.lang.model.element.ExecutableElement, javax.lang.model.element.TypeElement)


Occurences of Overview

Overview occurences:
Overview
Overview


Occurences of Overview List

Overview List occurences:
Overview List
Overview List
Overview List
Overview List
Overview List


Occurences of owner

owner occurences:
com.sun.javadoc.TypeVariable.owner()
java.awt.datatransfer.owner


Occurences of owns

owns occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.owns(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject)
java.util.concurrent.locks.AbstractQueuedSynchronizer.owns(java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject)


Occurences of pack

pack occurences:
java.awt.Window.pack()
java.util.jar.Pack200.Packer.pack(java.util.jar.JarFile, java.io.OutputStream)
java.util.jar.Pack200.Packer.pack(java.util.jar.JarInputStream, java.io.OutputStream)
javax.swing.JInternalFrame.pack()
javax.swing.JPopupMenu.pack()


Occurences of PACKAGE

PACKAGE occurences:
java.lang.annotation.PACKAGE
javax.lang.model.element.PACKAGE
javax.lang.model.type.PACKAGE


Occurences of packagePrefix

packagePrefix occurences:
java.rmi.server.packagePrefix
java.rmi.server.packagePrefix


Occurences of packagesIn

packagesIn occurences:
javax.lang.model.util.ElementFilter.packagesIn(java.lang.Iterable)
javax.lang.model.util.ElementFilter.packagesIn(java.util.Set)


Occurences of PackedColorModel (constructors)

PackedColorModel (constructors) occurences:
java.awt.image.PackedColorModel(java.awt.color.ColorSpace, int, int, int, int, int, boolean, int, int)
java.awt.image.PackedColorModel(java.awt.color.ColorSpace, int, int[], int, boolean, int, int)


Occurences of padSelectedTab

padSelectedTab occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.TabbedPaneLayout.padSelectedTab(int, int)
javax.swing.plaf.metal.MetalTabbedPaneUI.TabbedPaneLayout.padSelectedTab(int, int)


Occurences of PageAttributes (constructors)

PageAttributes (constructors) occurences:
java.awt.PageAttributes()
java.awt.PageAttributes(java.awt.PageAttributes)
java.awt.PageAttributes(java.awt.PageAttributes.ColorType, java.awt.PageAttributes.MediaType, java.awt.PageAttributes.OrientationRequestedType, java.awt.PageAttributes.OriginType, java.awt.PageAttributes.PrintQualityType, int[])


Occurences of pageDialog

pageDialog occurences:
java.awt.print.PrinterJob.pageDialog(java.awt.print.PageFormat)
java.awt.print.PrinterJob.pageDialog(javax.print.attribute.PrintRequestAttributeSet)


Occurences of PagedResultsControl (constructors)

PagedResultsControl (constructors) occurences:
javax.naming.ldap.PagedResultsControl(int, boolean)
javax.naming.ldap.PagedResultsControl(int, byte[], boolean)


Occurences of PageRanges (constructors)

PageRanges (constructors) occurences:
javax.print.attribute.standard.PageRanges(int)
javax.print.attribute.standard.PageRanges(int, int)
javax.print.attribute.standard.PageRanges(int[][])
javax.print.attribute.standard.PageRanges(java.lang.String)


Occurences of PAGE_END

PAGE_END occurences:
java.awt.PAGE_END
java.awt.PAGE_END


Occurences of PAGE_START

PAGE_START occurences:
java.awt.PAGE_START
java.awt.PAGE_START


Occurences of paint

paint occurences:
Class LWTextComponent.LWTextComponent.paint(java.awt.Graphics)
java.awt.Canvas.paint(java.awt.Graphics)
java.awt.Component.paint(java.awt.Graphics)
java.awt.Container.paint(java.awt.Graphics)
javax.swing.CellRendererPane.paint(java.awt.Graphics)
javax.swing.colorchooser.AbstractColorChooserPanel.paint(java.awt.Graphics)
javax.swing.JComponent.paint(java.awt.Graphics)
javax.swing.JLayeredPane.paint(java.awt.Graphics)
javax.swing.JViewport.paint(java.awt.Graphics)
javax.swing.plaf.basic.BasicArrowButton.paint(java.awt.Graphics)
javax.swing.plaf.basic.BasicButtonUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicComboBoxUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.SystemMenuBar.paint(java.awt.Graphics)
javax.swing.plaf.basic.BasicLabelUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicListUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuItemUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicPopupMenuSeparatorUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicProgressBarUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicRadioButtonUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollBarUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicSeparatorUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicSplitPaneDivider.paint(java.awt.Graphics)
javax.swing.plaf.basic.BasicSplitPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicTabbedPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableHeaderUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicToggleButtonUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolBarSeparatorUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolBarUI.DragWindow.paint(java.awt.Graphics)
javax.swing.plaf.basic.BasicToolTipUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.ComponentUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalComboBoxUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalPopupMenuSeparatorUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalRadioButtonUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollButton.paint(java.awt.Graphics)
javax.swing.plaf.metal.MetalSeparatorUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalTabbedPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolTipUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalTreeUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiButtonUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.paint(java.awt.Graphics, javax.swing.JComponent)
javax.swing.text.AsyncBoxView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.BoxView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.Caret.paint(java.awt.Graphics)
javax.swing.text.ComponentView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.DefaultCaret.paint(java.awt.Graphics)
javax.swing.text.DefaultHighlighter.paint(java.awt.Graphics)
javax.swing.text.DefaultHighlighter.DefaultHighlightPainter.paint(java.awt.Graphics, int, int, java.awt.Shape, javax.swing.text.JTextComponent)
javax.swing.text.FieldView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.GlyphView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.GlyphView.GlyphPainter.paint(javax.swing.text.GlyphView, java.awt.Graphics, java.awt.Shape, int, int)
javax.swing.text.Highlighter.paint(java.awt.Graphics)
javax.swing.text.Highlighter.HighlightPainter.paint(java.awt.Graphics, int, int, java.awt.Shape, javax.swing.text.JTextComponent)
javax.swing.text.html.BlockView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.html.ImageView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.html.ListView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.html.ParagraphView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.html.StyleSheet.BoxPainter.paint(java.awt.Graphics, float, float, float, float, javax.swing.text.View)
javax.swing.text.html.StyleSheet.ListPainter.paint(java.awt.Graphics, float, float, float, float, javax.swing.text.View, int)
javax.swing.text.IconView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.ParagraphView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.PlainView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.View.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.text.WrappedPlainView.paint(java.awt.Graphics, java.awt.Shape)
javax.swing.tree.DefaultTreeCellEditor.EditorContainer.paint(java.awt.Graphics)
javax.swing.tree.DefaultTreeCellRenderer.paint(java.awt.Graphics)


Occurences of paintBackground

paintBackground occurences:
javax.swing.plaf.basic.BasicMenuItemUI.paintBackground(java.awt.Graphics, javax.swing.JMenuItem, java.awt.Color)
javax.swing.plaf.basic.BasicTextUI.paintBackground(java.awt.Graphics)


Occurences of paintBorder

paintBorder occurences:
javax.swing.AbstractButton.paintBorder(java.awt.Graphics)
javax.swing.border.AbstractBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.BevelBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.Border.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.CompoundBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.EmptyBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.EtchedBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.LineBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.MatteBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.SoftBevelBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.border.TitledBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.JComponent.paintBorder(java.awt.Graphics)
javax.swing.JMenuBar.paintBorder(java.awt.Graphics)
javax.swing.JPopupMenu.paintBorder(java.awt.Graphics)
javax.swing.JProgressBar.paintBorder(java.awt.Graphics)
javax.swing.JToolBar.paintBorder(java.awt.Graphics)
javax.swing.paintBorder
javax.swing.plaf.basic.BasicBorders.ButtonBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.basic.BasicBorders.FieldBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.basic.BasicBorders.MenuBarBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.basic.BasicBorders.RadioButtonBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.basic.BasicBorders.RolloverButtonBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.basic.BasicBorders.SplitPaneBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.basic.BasicBorders.ToggleButtonBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.BorderUIResource.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.ButtonBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.Flush3DBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.InternalFrameBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.MenuBarBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.MenuItemBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.OptionDialogBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.PaletteBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.PopupMenuBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.RolloverButtonBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.ScrollPaneBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.TableHeaderBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.TextFieldBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.ToggleButtonBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.metal.MetalBorders.ToolBarBorder.paintBorder(java.awt.Component, java.awt.Graphics, int, int, int, int)


Occurences of paintButtonPressed

paintButtonPressed occurences:
javax.swing.plaf.basic.BasicButtonUI.paintButtonPressed(java.awt.Graphics, javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalButtonUI.paintButtonPressed(java.awt.Graphics, javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalToggleButtonUI.paintButtonPressed(java.awt.Graphics, javax.swing.AbstractButton)


Occurences of paintChild

paintChild occurences:
javax.swing.text.BoxView.paintChild(java.awt.Graphics, java.awt.Rectangle, int)
javax.swing.text.html.ListView.paintChild(java.awt.Graphics, java.awt.Rectangle, int)


Occurences of paintChildren

paintChildren occurences:
javax.swing.JComponent.paintChildren(java.awt.Graphics)
javax.swing.JSplitPane.paintChildren(java.awt.Graphics)
javax.swing.text.AsyncBoxView.ChildLocator.paintChildren(java.awt.Graphics)


Occurences of paintComponent

paintComponent occurences:
javax.swing.Box.paintComponent(java.awt.Graphics)
javax.swing.Box.Filler.paintComponent(java.awt.Graphics)
javax.swing.CellRendererPane.paintComponent(java.awt.Graphics, java.awt.Component, java.awt.Container, int, int, int, int)
javax.swing.CellRendererPane.paintComponent(java.awt.Graphics, java.awt.Component, java.awt.Container, int, int, int, int, boolean)
javax.swing.CellRendererPane.paintComponent(java.awt.Graphics, java.awt.Component, java.awt.Container, java.awt.Rectangle)
javax.swing.JComponent.paintComponent(java.awt.Graphics)
javax.swing.JInternalFrame.paintComponent(java.awt.Graphics)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.paintComponent(java.awt.Graphics)
javax.swing.plaf.metal.MetalComboBoxButton.paintComponent(java.awt.Graphics)
javax.swing.plaf.metal.MetalInternalFrameTitlePane.paintComponent(java.awt.Graphics)
javax.swing.SwingUtilities.paintComponent(java.awt.Graphics, java.awt.Component, java.awt.Container, int, int, int, int)
javax.swing.SwingUtilities.paintComponent(java.awt.Graphics, java.awt.Component, java.awt.Container, java.awt.Rectangle)


Occurences of paintContentBorderBottomEdge

paintContentBorderBottomEdge occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.paintContentBorderBottomEdge(java.awt.Graphics, int, int, int, int, int, int)
javax.swing.plaf.metal.MetalTabbedPaneUI.paintContentBorderBottomEdge(java.awt.Graphics, int, int, int, int, int, int)


Occurences of paintContentBorderLeftEdge

paintContentBorderLeftEdge occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.paintContentBorderLeftEdge(java.awt.Graphics, int, int, int, int, int, int)
javax.swing.plaf.metal.MetalTabbedPaneUI.paintContentBorderLeftEdge(java.awt.Graphics, int, int, int, int, int, int)


Occurences of paintContentBorderRightEdge

paintContentBorderRightEdge occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.paintContentBorderRightEdge(java.awt.Graphics, int, int, int, int, int, int)
javax.swing.plaf.metal.MetalTabbedPaneUI.paintContentBorderRightEdge(java.awt.Graphics, int, int, int, int, int, int)


Occurences of paintContentBorderTopEdge

paintContentBorderTopEdge occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.paintContentBorderTopEdge(java.awt.Graphics, int, int, int, int, int, int)
javax.swing.plaf.metal.MetalTabbedPaneUI.paintContentBorderTopEdge(java.awt.Graphics, int, int, int, int, int, int)


Occurences of paintCurrentValue

paintCurrentValue occurences:
javax.swing.plaf.basic.BasicComboBoxUI.paintCurrentValue(java.awt.Graphics, java.awt.Rectangle, boolean)
javax.swing.plaf.metal.MetalComboBoxUI.paintCurrentValue(java.awt.Graphics, java.awt.Rectangle, boolean)


Occurences of paintCurrentValueBackground

paintCurrentValueBackground occurences:
javax.swing.plaf.basic.BasicComboBoxUI.paintCurrentValueBackground(java.awt.Graphics, java.awt.Rectangle, boolean)
javax.swing.plaf.metal.MetalComboBoxUI.paintCurrentValueBackground(java.awt.Graphics, java.awt.Rectangle, boolean)


Occurences of paintDeterminate

paintDeterminate occurences:
javax.swing.plaf.basic.BasicProgressBarUI.paintDeterminate(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalProgressBarUI.paintDeterminate(java.awt.Graphics, javax.swing.JComponent)


Occurences of paintDisabledText

paintDisabledText occurences:
javax.swing.plaf.basic.BasicLabelUI.paintDisabledText(javax.swing.JLabel, java.awt.Graphics, java.lang.String, int, int)
javax.swing.plaf.metal.MetalLabelUI.paintDisabledText(javax.swing.JLabel, java.awt.Graphics, java.lang.String, int, int)


Occurences of paintFocus

paintFocus occurences:
javax.swing.plaf.basic.BasicButtonUI.paintFocus(java.awt.Graphics, javax.swing.AbstractButton, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle)
javax.swing.plaf.basic.BasicRadioButtonUI.paintFocus(java.awt.Graphics, java.awt.Rectangle, java.awt.Dimension)
javax.swing.plaf.basic.BasicSliderUI.paintFocus(java.awt.Graphics)
javax.swing.plaf.metal.MetalButtonUI.paintFocus(java.awt.Graphics, javax.swing.AbstractButton, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle)
javax.swing.plaf.metal.MetalRadioButtonUI.paintFocus(java.awt.Graphics, java.awt.Rectangle, java.awt.Dimension)
javax.swing.plaf.metal.MetalSliderUI.paintFocus(java.awt.Graphics)
javax.swing.plaf.metal.MetalToggleButtonUI.paintFocus(java.awt.Graphics, javax.swing.AbstractButton, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle)


Occurences of paintFocusIndicator

paintFocusIndicator occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.paintFocusIndicator(java.awt.Graphics, int, java.awt.Rectangle[], int, java.awt.Rectangle, java.awt.Rectangle, boolean)
javax.swing.plaf.metal.MetalTabbedPaneUI.paintFocusIndicator(java.awt.Graphics, int, java.awt.Rectangle[], int, java.awt.Rectangle, java.awt.Rectangle, boolean)


Occurences of paintHorizontalPartOfLeg

paintHorizontalPartOfLeg occurences:
javax.swing.plaf.basic.BasicTreeUI.paintHorizontalPartOfLeg(java.awt.Graphics, java.awt.Rectangle, java.awt.Insets, java.awt.Rectangle, javax.swing.tree.TreePath, int, boolean, boolean, boolean)
javax.swing.plaf.metal.MetalTreeUI.paintHorizontalPartOfLeg(java.awt.Graphics, java.awt.Rectangle, java.awt.Insets, java.awt.Rectangle, javax.swing.tree.TreePath, int, boolean, boolean, boolean)


Occurences of paintIcon

paintIcon occurences:
javax.swing.Icon.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.ImageIcon.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.plaf.basic.BasicButtonUI.paintIcon(java.awt.Graphics, javax.swing.JComponent, java.awt.Rectangle)
javax.swing.plaf.basic.BasicTabbedPaneUI.paintIcon(java.awt.Graphics, int, int, javax.swing.Icon, java.awt.Rectangle, boolean)
javax.swing.plaf.basic.BasicToggleButtonUI.paintIcon(java.awt.Graphics, javax.swing.AbstractButton, java.awt.Rectangle)
javax.swing.plaf.IconUIResource.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.plaf.metal.MetalCheckBoxIcon.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.plaf.metal.MetalComboBoxIcon.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.plaf.metal.MetalIconFactory.FileIcon16.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.plaf.metal.MetalIconFactory.FolderIcon16.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.plaf.metal.MetalIconFactory.PaletteCloseIcon.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.plaf.metal.MetalIconFactory.TreeControlIcon.paintIcon(java.awt.Component, java.awt.Graphics, int, int)
javax.swing.plaf.metal.MetalToggleButtonUI.paintIcon(java.awt.Graphics, javax.swing.AbstractButton, java.awt.Rectangle)


Occurences of paintImmediately

paintImmediately occurences:
javax.swing.JComponent.paintImmediately(int, int, int, int)
javax.swing.JComponent.paintImmediately(java.awt.Rectangle)


Occurences of paintIndeterminate

paintIndeterminate occurences:
javax.swing.plaf.basic.BasicProgressBarUI.paintIndeterminate(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalProgressBarUI.paintIndeterminate(java.awt.Graphics, javax.swing.JComponent)


Occurences of paintLayer

paintLayer occurences:
javax.swing.text.DefaultHighlighter.DefaultHighlightPainter.paintLayer(java.awt.Graphics, int, int, java.awt.Shape, javax.swing.text.JTextComponent, javax.swing.text.View)
javax.swing.text.LayeredHighlighter.LayerPainter.paintLayer(java.awt.Graphics, int, int, java.awt.Shape, javax.swing.text.JTextComponent, javax.swing.text.View)


Occurences of paintLayeredHighlights

paintLayeredHighlights occurences:
javax.swing.text.DefaultHighlighter.paintLayeredHighlights(java.awt.Graphics, int, int, java.awt.Shape, javax.swing.text.JTextComponent, javax.swing.text.View)
javax.swing.text.LayeredHighlighter.paintLayeredHighlights(java.awt.Graphics, int, int, java.awt.Shape, javax.swing.text.JTextComponent, javax.swing.text.View)


Occurences of paintMajorTickForHorizSlider

paintMajorTickForHorizSlider occurences:
javax.swing.plaf.basic.BasicSliderUI.paintMajorTickForHorizSlider(java.awt.Graphics, java.awt.Rectangle, int)
javax.swing.plaf.metal.MetalSliderUI.paintMajorTickForHorizSlider(java.awt.Graphics, java.awt.Rectangle, int)


Occurences of paintMajorTickForVertSlider

paintMajorTickForVertSlider occurences:
javax.swing.plaf.basic.BasicSliderUI.paintMajorTickForVertSlider(java.awt.Graphics, java.awt.Rectangle, int)
javax.swing.plaf.metal.MetalSliderUI.paintMajorTickForVertSlider(java.awt.Graphics, java.awt.Rectangle, int)


Occurences of paintMinorTickForHorizSlider

paintMinorTickForHorizSlider occurences:
javax.swing.plaf.basic.BasicSliderUI.paintMinorTickForHorizSlider(java.awt.Graphics, java.awt.Rectangle, int)
javax.swing.plaf.metal.MetalSliderUI.paintMinorTickForHorizSlider(java.awt.Graphics, java.awt.Rectangle, int)


Occurences of paintMinorTickForVertSlider

paintMinorTickForVertSlider occurences:
javax.swing.plaf.basic.BasicSliderUI.paintMinorTickForVertSlider(java.awt.Graphics, java.awt.Rectangle, int)
javax.swing.plaf.metal.MetalSliderUI.paintMinorTickForVertSlider(java.awt.Graphics, java.awt.Rectangle, int)


Occurences of paintProgressBarBackground

paintProgressBarBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintProgressBarBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintProgressBarBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintProgressBarBorder

paintProgressBarBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintProgressBarBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintProgressBarBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintScrollBarBackground

paintScrollBarBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintScrollBarBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintScrollBarBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintScrollBarBorder

paintScrollBarBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintScrollBarBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintScrollBarBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintScrollBarTrackBackground

paintScrollBarTrackBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintScrollBarTrackBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintScrollBarTrackBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintScrollBarTrackBorder

paintScrollBarTrackBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintScrollBarTrackBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintScrollBarTrackBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintSeparatorBackground

paintSeparatorBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintSeparatorBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintSeparatorBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintSeparatorBorder

paintSeparatorBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintSeparatorBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintSeparatorBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintSliderBackground

paintSliderBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintSliderBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintSliderBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintSliderBorder

paintSliderBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintSliderBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintSliderBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintSliderTrackBackground

paintSliderTrackBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintSliderTrackBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintSliderTrackBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintSliderTrackBorder

paintSliderTrackBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintSliderTrackBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintSliderTrackBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintSplitPaneDividerBackground

paintSplitPaneDividerBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintSplitPaneDividerBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintSplitPaneDividerBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintString

paintString occurences:
javax.swing.paintString
javax.swing.plaf.basic.BasicProgressBarUI.paintString(java.awt.Graphics, int, int, int, int, int, java.awt.Insets)


Occurences of paintTabBackground

paintTabBackground occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.paintTabBackground(java.awt.Graphics, int, int, int, int, int, int, boolean)
javax.swing.plaf.metal.MetalTabbedPaneUI.paintTabBackground(java.awt.Graphics, int, int, int, int, int, int, boolean)


Occurences of paintTabbedPaneTabAreaBackground

paintTabbedPaneTabAreaBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintTabbedPaneTabAreaBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintTabbedPaneTabAreaBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintTabbedPaneTabAreaBorder

paintTabbedPaneTabAreaBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintTabbedPaneTabAreaBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintTabbedPaneTabAreaBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintTabbedPaneTabBackground

paintTabbedPaneTabBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintTabbedPaneTabBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintTabbedPaneTabBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int, int)


Occurences of paintTabbedPaneTabBorder

paintTabbedPaneTabBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintTabbedPaneTabBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintTabbedPaneTabBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int, int)


Occurences of paintTabBorder

paintTabBorder occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.paintTabBorder(java.awt.Graphics, int, int, int, int, int, int, boolean)
javax.swing.plaf.metal.MetalTabbedPaneUI.paintTabBorder(java.awt.Graphics, int, int, int, int, int, int, boolean)


Occurences of paintText

paintText occurences:
javax.swing.plaf.basic.BasicButtonUI.paintText(java.awt.Graphics, javax.swing.AbstractButton, java.awt.Rectangle, java.lang.String)
javax.swing.plaf.basic.BasicButtonUI.paintText(java.awt.Graphics, javax.swing.JComponent, java.awt.Rectangle, java.lang.String)
javax.swing.plaf.basic.BasicMenuItemUI.paintText(java.awt.Graphics, javax.swing.JMenuItem, java.awt.Rectangle, java.lang.String)
javax.swing.plaf.basic.BasicTabbedPaneUI.paintText(java.awt.Graphics, int, java.awt.Font, java.awt.FontMetrics, int, java.lang.String, java.awt.Rectangle, boolean)
javax.swing.plaf.metal.MetalButtonUI.paintText(java.awt.Graphics, javax.swing.JComponent, java.awt.Rectangle, java.lang.String)
javax.swing.plaf.metal.MetalToggleButtonUI.paintText(java.awt.Graphics, javax.swing.JComponent, java.awt.Rectangle, java.lang.String)
javax.swing.plaf.synth.SynthGraphicsUtils.paintText(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, java.lang.String, int, int, int)
javax.swing.plaf.synth.SynthGraphicsUtils.paintText(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, java.lang.String, java.awt.Rectangle, int)
javax.swing.plaf.synth.SynthGraphicsUtils.paintText(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, java.lang.String, javax.swing.Icon, int, int, int, int, int, int, int)


Occurences of paintThumb

paintThumb occurences:
javax.swing.plaf.basic.BasicScrollBarUI.paintThumb(java.awt.Graphics, javax.swing.JComponent, java.awt.Rectangle)
javax.swing.plaf.basic.BasicSliderUI.paintThumb(java.awt.Graphics)
javax.swing.plaf.metal.MetalScrollBarUI.paintThumb(java.awt.Graphics, javax.swing.JComponent, java.awt.Rectangle)
javax.swing.plaf.metal.MetalSliderUI.paintThumb(java.awt.Graphics)


Occurences of paintToolBarBackground

paintToolBarBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintToolBarBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintToolBarBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintToolBarBorder

paintToolBarBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintToolBarBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintToolBarBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintToolBarContentBackground

paintToolBarContentBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintToolBarContentBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintToolBarContentBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintToolBarContentBorder

paintToolBarContentBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintToolBarContentBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintToolBarContentBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintToolBarDragWindowBackground

paintToolBarDragWindowBackground occurences:
javax.swing.plaf.synth.SynthPainter.paintToolBarDragWindowBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintToolBarDragWindowBackground(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintToolBarDragWindowBorder

paintToolBarDragWindowBorder occurences:
javax.swing.plaf.synth.SynthPainter.paintToolBarDragWindowBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int)
javax.swing.plaf.synth.SynthPainter.paintToolBarDragWindowBorder(javax.swing.plaf.synth.SynthContext, java.awt.Graphics, int, int, int, int, int)


Occurences of paintTrack

paintTrack occurences:
javax.swing.plaf.basic.BasicScrollBarUI.paintTrack(java.awt.Graphics, javax.swing.JComponent, java.awt.Rectangle)
javax.swing.plaf.basic.BasicSliderUI.paintTrack(java.awt.Graphics)
javax.swing.plaf.metal.MetalScrollBarUI.paintTrack(java.awt.Graphics, javax.swing.JComponent, java.awt.Rectangle)
javax.swing.plaf.metal.MetalSliderUI.paintTrack(java.awt.Graphics)


Occurences of paintValue

paintValue occurences:
java.beans.PropertyEditor.paintValue(java.awt.Graphics, java.awt.Rectangle)
java.beans.PropertyEditorSupport.paintValue(java.awt.Graphics, java.awt.Rectangle)


Occurences of paintVerticalPartOfLeg

paintVerticalPartOfLeg occurences:
javax.swing.plaf.basic.BasicTreeUI.paintVerticalPartOfLeg(java.awt.Graphics, java.awt.Rectangle, java.awt.Insets, javax.swing.tree.TreePath)
javax.swing.plaf.metal.MetalTreeUI.paintVerticalPartOfLeg(java.awt.Graphics, java.awt.Rectangle, java.awt.Insets, javax.swing.tree.TreePath)


Occurences of PANEL

PANEL occurences:
javax.accessibility.PANEL
javax.swing.plaf.synth.PANEL


Occurences of Panel (constructors)

Panel (constructors) occurences:
java.awt.Panel()
java.awt.Panel(java.awt.LayoutManager)


Occurences of ParagraphView

ParagraphView occurences:
javax.swing.text.ParagraphView
javax.swing.text.html.ParagraphView


Occurences of ParagraphView (constructors)

ParagraphView (constructors) occurences:
javax.swing.text.ParagraphView(javax.swing.text.Element)
javax.swing.text.html.ParagraphView(javax.swing.text.Element)


Occurences of Parameter

Parameter occurences:
com.sun.javadoc.Parameter
org.omg.Dynamic.Parameter


Occurences of PARAMETER

PARAMETER occurences:
java.lang.annotation.PARAMETER
javax.lang.model.element.PARAMETER
javax.swing.text.html.parser.PARAMETER


Occurences of Parameter (constructors)

Parameter (constructors) occurences:
org.omg.Dynamic.Parameter()
org.omg.Dynamic.Parameter(org.omg.CORBA.Any, org.omg.CORBA.ParameterMode)


Occurences of ParameterBlock (constructors)

ParameterBlock (constructors) occurences:
java.awt.image.renderable.ParameterBlock()
java.awt.image.renderable.ParameterBlock(java.util.Vector)
java.awt.image.renderable.ParameterBlock(java.util.Vector, java.util.Vector)


Occurences of ParameterizedType

ParameterizedType occurences:
com.sun.javadoc.ParameterizedType
java.lang.reflect.ParameterizedType


Occurences of ParameterModeHolder (constructors)

ParameterModeHolder (constructors) occurences:
org.omg.CORBA.ParameterModeHolder()
org.omg.CORBA.ParameterModeHolder(org.omg.CORBA.ParameterMode)


Occurences of parameters

parameters occurences:
com.sun.javadoc.ExecutableMemberDoc.parameters()
java.awt.image.renderable.parameters


Occurences of paramString

paramString occurences:
java.awt.AWTEvent.paramString()
java.awt.Button.paramString()
java.awt.Checkbox.paramString()
java.awt.CheckboxMenuItem.paramString()
java.awt.Choice.paramString()
java.awt.Component.paramString()
java.awt.Container.paramString()
java.awt.Dialog.paramString()
java.awt.Event.paramString()
java.awt.event.ActionEvent.paramString()
java.awt.event.AdjustmentEvent.paramString()
java.awt.event.ComponentEvent.paramString()
java.awt.event.ContainerEvent.paramString()
java.awt.event.FocusEvent.paramString()
java.awt.event.HierarchyEvent.paramString()
java.awt.event.InputMethodEvent.paramString()
java.awt.event.InvocationEvent.paramString()
java.awt.event.ItemEvent.paramString()
java.awt.event.KeyEvent.paramString()
java.awt.event.MouseEvent.paramString()
java.awt.event.MouseWheelEvent.paramString()
java.awt.event.PaintEvent.paramString()
java.awt.event.TextEvent.paramString()
java.awt.event.WindowEvent.paramString()
java.awt.FileDialog.paramString()
java.awt.Frame.paramString()
java.awt.Label.paramString()
java.awt.List.paramString()
java.awt.Menu.paramString()
java.awt.MenuComponent.paramString()
java.awt.MenuItem.paramString()
java.awt.MenuShortcut.paramString()
java.awt.Scrollbar.paramString()
java.awt.ScrollPane.paramString()
java.awt.ScrollPaneAdjustable.paramString()
java.awt.TextArea.paramString()
java.awt.TextComponent.paramString()
java.awt.TextField.paramString()
javax.swing.AbstractButton.paramString()
javax.swing.event.InternalFrameEvent.paramString()
javax.swing.JApplet.paramString()
javax.swing.JButton.paramString()
javax.swing.JCheckBox.paramString()
javax.swing.JCheckBoxMenuItem.paramString()
javax.swing.JColorChooser.paramString()
javax.swing.JComboBox.paramString()
javax.swing.JComponent.paramString()
javax.swing.JDesktopPane.paramString()
javax.swing.JDialog.paramString()
javax.swing.JEditorPane.paramString()
javax.swing.JFileChooser.paramString()
javax.swing.JFrame.paramString()
javax.swing.JInternalFrame.paramString()
javax.swing.JLabel.paramString()
javax.swing.JLayeredPane.paramString()
javax.swing.JList.paramString()
javax.swing.JMenu.paramString()
javax.swing.JMenuBar.paramString()
javax.swing.JMenuItem.paramString()
javax.swing.JOptionPane.paramString()
javax.swing.JPanel.paramString()
javax.swing.JPasswordField.paramString()
javax.swing.JPopupMenu.paramString()
javax.swing.JProgressBar.paramString()
javax.swing.JRadioButton.paramString()
javax.swing.JRadioButtonMenuItem.paramString()
javax.swing.JRootPane.paramString()
javax.swing.JScrollBar.paramString()
javax.swing.JScrollPane.paramString()
javax.swing.JSeparator.paramString()
javax.swing.JSlider.paramString()
javax.swing.JSplitPane.paramString()
javax.swing.JTabbedPane.paramString()
javax.swing.JTable.paramString()
javax.swing.JTextArea.paramString()
javax.swing.JTextField.paramString()
javax.swing.JTextPane.paramString()
javax.swing.JToggleButton.paramString()
javax.swing.JToolBar.paramString()
javax.swing.JToolTip.paramString()
javax.swing.JTree.paramString()
javax.swing.JViewport.paramString()
javax.swing.JWindow.paramString()
javax.swing.table.JTableHeader.paramString()
javax.swing.text.JTextComponent.paramString()


Occurences of parent

parent occurences:
com.sun.jdi.ThreadGroupReference.parent()
java.awt.image.parent
java.util.parent
java.util.prefs.AbstractPreferences.parent()
java.util.prefs.Preferences.parent()
javax.swing.tree.parent
org.omg.CORBA.Context.parent()


Occurences of park

park occurences:
java.util.concurrent.locks.LockSupport.park()
java.util.concurrent.locks.LockSupport.park(java.lang.Object)


Occurences of parkNanos

parkNanos occurences:
java.util.concurrent.locks.LockSupport.parkNanos(java.lang.Object, long)
java.util.concurrent.locks.LockSupport.parkNanos(long)


Occurences of parkUntil

parkUntil occurences:
java.util.concurrent.locks.LockSupport.parkUntil(java.lang.Object, long)
java.util.concurrent.locks.LockSupport.parkUntil(long)


Occurences of parse

parse occurences:
com.sun.source.util.JavacTask.parse()
java.net.HttpCookie.parse(java.lang.String)
java.text.ChoiceFormat.parse(java.lang.String, java.text.ParsePosition)
java.text.DateFormat.parse(java.lang.String)
java.text.DateFormat.parse(java.lang.String, java.text.ParsePosition)
java.text.DecimalFormat.parse(java.lang.String, java.text.ParsePosition)
java.text.MessageFormat.parse(java.lang.String)
java.text.MessageFormat.parse(java.lang.String, java.text.ParsePosition)
java.text.NumberFormat.parse(java.lang.String)
java.text.NumberFormat.parse(java.lang.String, java.text.ParsePosition)
java.text.SimpleDateFormat.parse(java.lang.String, java.text.ParsePosition)
java.util.Date.parse(java.lang.String)
java.util.logging.Level.parse(java.lang.String)
javax.activation.MimeTypeParameterList.parse(java.lang.String)
javax.naming.NameParser.parse(java.lang.String)
javax.swing.text.html.HTMLEditorKit.Parser.parse(java.io.Reader, javax.swing.text.html.HTMLEditorKit.ParserCallback, boolean)
javax.swing.text.html.parser.DocumentParser.parse(java.io.Reader, javax.swing.text.html.HTMLEditorKit.ParserCallback, boolean)
javax.swing.text.html.parser.Parser.parse(java.io.Reader)
javax.swing.text.html.parser.ParserDelegator.parse(java.io.Reader, javax.swing.text.html.HTMLEditorKit.ParserCallback, boolean)
javax.xml.parsers.DocumentBuilder.parse(java.io.File)
javax.xml.parsers.DocumentBuilder.parse(java.io.InputStream)
javax.xml.parsers.DocumentBuilder.parse(java.io.InputStream, java.lang.String)
javax.xml.parsers.DocumentBuilder.parse(java.lang.String)
javax.xml.parsers.DocumentBuilder.parse(org.xml.sax.InputSource)
javax.xml.parsers.SAXParser.parse(java.io.File, org.xml.sax.HandlerBase)
javax.xml.parsers.SAXParser.parse(java.io.File, org.xml.sax.helpers.DefaultHandler)
javax.xml.parsers.SAXParser.parse(java.io.InputStream, org.xml.sax.HandlerBase)
javax.xml.parsers.SAXParser.parse(java.io.InputStream, org.xml.sax.HandlerBase, java.lang.String)
javax.xml.parsers.SAXParser.parse(java.io.InputStream, org.xml.sax.helpers.DefaultHandler)
javax.xml.parsers.SAXParser.parse(java.io.InputStream, org.xml.sax.helpers.DefaultHandler, java.lang.String)
javax.xml.parsers.SAXParser.parse(java.lang.String, org.xml.sax.HandlerBase)
javax.xml.parsers.SAXParser.parse(java.lang.String, org.xml.sax.helpers.DefaultHandler)
javax.xml.parsers.SAXParser.parse(org.xml.sax.InputSource, org.xml.sax.HandlerBase)
javax.xml.parsers.SAXParser.parse(org.xml.sax.InputSource, org.xml.sax.helpers.DefaultHandler)
org.w3c.dom.ls.LSParser.parse(org.w3c.dom.ls.LSInput)
org.xml.sax.helpers.ParserAdapter.parse(java.lang.String)
org.xml.sax.helpers.ParserAdapter.parse(org.xml.sax.InputSource)
org.xml.sax.helpers.XMLFilterImpl.parse(java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.parse(org.xml.sax.InputSource)
org.xml.sax.helpers.XMLReaderAdapter.parse(java.lang.String)
org.xml.sax.helpers.XMLReaderAdapter.parse(org.xml.sax.InputSource)
org.xml.sax.Parser.parse(java.lang.String)
org.xml.sax.Parser.parse(org.xml.sax.InputSource)
org.xml.sax.XMLReader.parse(java.lang.String)
org.xml.sax.XMLReader.parse(org.xml.sax.InputSource)


Occurences of parseAnySimpleType

parseAnySimpleType occurences:
javax.xml.bind.DatatypeConverter.parseAnySimpleType(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseAnySimpleType(java.lang.String)


Occurences of parseBase64Binary

parseBase64Binary occurences:
javax.xml.bind.DatatypeConverter.parseBase64Binary(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseBase64Binary(java.lang.String)


Occurences of parseBoolean

parseBoolean occurences:
java.lang.Boolean.parseBoolean(java.lang.String)
javax.xml.bind.DatatypeConverter.parseBoolean(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseBoolean(java.lang.String)


Occurences of parseByte

parseByte occurences:
java.lang.Byte.parseByte(java.lang.String)
java.lang.Byte.parseByte(java.lang.String, int)
javax.xml.bind.DatatypeConverter.parseByte(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseByte(java.lang.String)


Occurences of ParseConversionEventImpl (constructors)

ParseConversionEventImpl (constructors) occurences:
javax.xml.bind.helpers.ParseConversionEventImpl(int, java.lang.String, javax.xml.bind.ValidationEventLocator)
javax.xml.bind.helpers.ParseConversionEventImpl(int, java.lang.String, javax.xml.bind.ValidationEventLocator, java.lang.Throwable)


Occurences of parseDate

parseDate occurences:
javax.xml.bind.DatatypeConverter.parseDate(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseDate(java.lang.String)


Occurences of parseDateTime

parseDateTime occurences:
javax.xml.bind.DatatypeConverter.parseDateTime(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseDateTime(java.lang.String)


Occurences of parseDecimal

parseDecimal occurences:
javax.xml.bind.DatatypeConverter.parseDecimal(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseDecimal(java.lang.String)


Occurences of parseDouble

parseDouble occurences:
java.lang.Double.parseDouble(java.lang.String)
javax.xml.bind.DatatypeConverter.parseDouble(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseDouble(java.lang.String)


Occurences of parseFloat

parseFloat occurences:
java.lang.Float.parseFloat(java.lang.String)
javax.xml.bind.DatatypeConverter.parseFloat(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseFloat(java.lang.String)


Occurences of parseHexBinary

parseHexBinary occurences:
javax.xml.bind.DatatypeConverter.parseHexBinary(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseHexBinary(java.lang.String)


Occurences of parseInt

parseInt occurences:
java.lang.Integer.parseInt(java.lang.String)
java.lang.Integer.parseInt(java.lang.String, int)
javax.xml.bind.DatatypeConverter.parseInt(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseInt(java.lang.String)


Occurences of parseInteger

parseInteger occurences:
javax.xml.bind.DatatypeConverter.parseInteger(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseInteger(java.lang.String)


Occurences of parseLong

parseLong occurences:
java.lang.Long.parseLong(java.lang.String)
java.lang.Long.parseLong(java.lang.String, int)
javax.xml.bind.DatatypeConverter.parseLong(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseLong(java.lang.String)


Occurences of parseObject

parseObject occurences:
java.text.DateFormat.parseObject(java.lang.String, java.text.ParsePosition)
java.text.Format.parseObject(java.lang.String)
java.text.Format.parseObject(java.lang.String, java.text.ParsePosition)
java.text.MessageFormat.parseObject(java.lang.String, java.text.ParsePosition)
java.text.NumberFormat.parseObject(java.lang.String, java.text.ParsePosition)


Occurences of parseQName

parseQName occurences:
javax.xml.bind.DatatypeConverter.parseQName(java.lang.String, javax.xml.namespace.NamespaceContext)
javax.xml.bind.DatatypeConverterInterface.parseQName(java.lang.String, javax.xml.namespace.NamespaceContext)


Occurences of Parser

Parser occurences:
javax.swing.text.html.parser.Parser
org.xml.sax.Parser


Occurences of ParserAdapter (constructors)

ParserAdapter (constructors) occurences:
org.xml.sax.helpers.ParserAdapter()
org.xml.sax.helpers.ParserAdapter(org.xml.sax.Parser)


Occurences of ParserConfigurationException (constructors)

ParserConfigurationException (constructors) occurences:
javax.xml.parsers.ParserConfigurationException()
javax.xml.parsers.ParserConfigurationException(java.lang.String)


Occurences of parseShort

parseShort occurences:
java.lang.Short.parseShort(java.lang.String)
java.lang.Short.parseShort(java.lang.String, int)
javax.xml.bind.DatatypeConverter.parseShort(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseShort(java.lang.String)


Occurences of parseString

parseString occurences:
javax.xml.bind.DatatypeConverter.parseString(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseString(java.lang.String)


Occurences of parseTime

parseTime occurences:
javax.xml.bind.DatatypeConverter.parseTime(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseTime(java.lang.String)


Occurences of parseUnsignedInt

parseUnsignedInt occurences:
javax.xml.bind.DatatypeConverter.parseUnsignedInt(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseUnsignedInt(java.lang.String)


Occurences of parseUnsignedShort

parseUnsignedShort occurences:
javax.xml.bind.DatatypeConverter.parseUnsignedShort(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.parseUnsignedShort(java.lang.String)


Occurences of PartialResultException (constructors)

PartialResultException (constructors) occurences:
javax.naming.PartialResultException()
javax.naming.PartialResultException(java.lang.String)


Occurences of partName

partName occurences:
java.io.partName
javax.jws.WebParam.partName()
javax.jws.WebResult.partName()


Occurences of paste

paste occurences:
javax.accessibility.AccessibleEditableText.paste(int)
javax.swing.JSpinner.AccessibleJSpinner.paste(int)
javax.swing.text.JTextComponent.paste()
javax.swing.text.JTextComponent.AccessibleJTextComponent.paste(int)


Occurences of path

path occurences:
javax.swing.event.path
javax.swing.event.path


Occurences of Path2D.Double (constructors)

Path2D.Double (constructors) occurences:
java.awt.geom.Path2D.Double()
java.awt.geom.Path2D.Double(int)
java.awt.geom.Path2D.Double(int, int)
java.awt.geom.Path2D.Double(java.awt.Shape)
java.awt.geom.Path2D.Double(java.awt.Shape, java.awt.geom.AffineTransform)


Occurences of Path2D.Float (constructors)

Path2D.Float (constructors) occurences:
java.awt.geom.Path2D.Float()
java.awt.geom.Path2D.Float(int)
java.awt.geom.Path2D.Float(int, int)
java.awt.geom.Path2D.Float(java.awt.Shape)
java.awt.geom.Path2D.Float(java.awt.Shape, java.awt.geom.AffineTransform)


Occurences of pattern

pattern occurences:
java.util.regex.Matcher.pattern()
java.util.regex.Pattern.pattern()


Occurences of PBEKeySpec (constructors)

PBEKeySpec (constructors) occurences:
javax.crypto.spec.PBEKeySpec(char[])
javax.crypto.spec.PBEKeySpec(char[], byte[], int)
javax.crypto.spec.PBEKeySpec(char[], byte[], int, int)


Occurences of PCL

PCL occurences:
javax.print.PCL
javax.print.PCL
javax.print.PCL


Occurences of PDF

PDF occurences:
javax.print.PDF
javax.print.PDF
javax.print.PDF


Occurences of peek

peek occurences:
java.net.DatagramSocketImpl.peek(java.net.InetAddress)
java.util.ArrayDeque.peek()
java.util.concurrent.ArrayBlockingQueue.peek()
java.util.concurrent.BlockingDeque.peek()
java.util.concurrent.ConcurrentLinkedQueue.peek()
java.util.concurrent.DelayQueue.peek()
java.util.concurrent.LinkedBlockingDeque.peek()
java.util.concurrent.LinkedBlockingQueue.peek()
java.util.concurrent.PriorityBlockingQueue.peek()
java.util.concurrent.SynchronousQueue.peek()
java.util.Deque.peek()
java.util.LinkedList.peek()
java.util.PriorityQueue.peek()
java.util.Queue.peek()
java.util.Stack.peek()
javax.xml.stream.util.EventReaderDelegate.peek()
javax.xml.stream.XMLEventReader.peek()


Occurences of peekEvent

peekEvent occurences:
java.awt.EventQueue.peekEvent()
java.awt.EventQueue.peekEvent(int)


Occurences of peekFirst

peekFirst occurences:
java.util.ArrayDeque.peekFirst()
java.util.concurrent.LinkedBlockingDeque.peekFirst()
java.util.Deque.peekFirst()
java.util.LinkedList.peekFirst()


Occurences of peekLast

peekLast occurences:
java.util.ArrayDeque.peekLast()
java.util.concurrent.LinkedBlockingDeque.peekLast()
java.util.Deque.peekLast()
java.util.LinkedList.peekLast()


Occurences of PENDING

PENDING occurences:
javax.print.attribute.standard.PENDING
javax.swing.PENDING


Occurences of Permission

Permission occurences:
java.security.Permission
java.security.acl.Permission


Occurences of PERSIST_STORE (constructors)

PERSIST_STORE (constructors) occurences:
org.omg.CORBA.PERSIST_STORE()
org.omg.CORBA.PERSIST_STORE(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.PERSIST_STORE(java.lang.String)
org.omg.CORBA.PERSIST_STORE(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of PERSONAL_ENVELOPE

PERSONAL_ENVELOPE occurences:
java.awt.PERSONAL_ENVELOPE
javax.print.attribute.standard.PERSONAL_ENVELOPE
javax.print.attribute.standard.PERSONAL_ENVELOPE


Occurences of PhantomReference (constructors)

PhantomReference (constructors) occurences:
java.lang.ref.PhantomReference(java.lang.Object,java.lang.ref.ReferenceQueue)
java.lang.ref.PhantomReference(T, java.lang.ref.ReferenceQueue)


Occurences of PI

PI occurences:
java.lang.PI
java.lang.PI
javax.swing.text.html.parser.PI


Occurences of PipedInputStream (constructors)

PipedInputStream (constructors) occurences:
java.io.PipedInputStream()
java.io.PipedInputStream(int)
java.io.PipedInputStream(java.io.PipedOutputStream)
java.io.PipedInputStream(java.io.PipedOutputStream, int)


Occurences of PipedOutputStream (constructors)

PipedOutputStream (constructors) occurences:
java.io.PipedOutputStream()
java.io.PipedOutputStream(java.io.PipedInputStream)


Occurences of PipedReader (constructors)

PipedReader (constructors) occurences:
java.io.PipedReader()
java.io.PipedReader(int)
java.io.PipedReader(java.io.PipedWriter)
java.io.PipedReader(java.io.PipedWriter, int)


Occurences of PipedWriter (constructors)

PipedWriter (constructors) occurences:
java.io.PipedWriter()
java.io.PipedWriter(java.io.PipedReader)


Occurences of PixelGrabber (constructors)

PixelGrabber (constructors) occurences:
java.awt.image.PixelGrabber(java.awt.Image, int, int, int, int, boolean)
java.awt.image.PixelGrabber(java.awt.Image, int, int, int, int, int[], int, int)
java.awt.image.PixelGrabber(java.awt.image.ImageProducer, int, int, int, int, int[], int, int)


Occurences of PKIXBuilderParameters (constructors)

PKIXBuilderParameters (constructors) occurences:
java.security.cert.PKIXBuilderParameters(java.security.KeyStore, java.security.cert.CertSelector)
java.security.cert.PKIXBuilderParameters(java.util.Set, java.security.cert.CertSelector)


Occurences of PKIXParameters (constructors)

PKIXParameters (constructors) occurences:
java.security.cert.PKIXParameters(java.security.KeyStore)
java.security.cert.PKIXParameters(java.util.Set)


Occurences of PlainDocument (constructors)

PlainDocument (constructors) occurences:
javax.swing.text.PlainDocument()
javax.swing.text.PlainDocument(javax.swing.text.AbstractDocument.Content)


Occurences of play

play occurences:
java.applet.Applet.play(java.net.URL)
java.applet.Applet.play(java.net.URL, java.lang.String)
java.applet.AudioClip.play()


Occurences of PLUS

PLUS occurences:
com.sun.source.tree.PLUS
javax.management.PLUS


Occurences of plus

plus occurences:
java.math.BigDecimal.plus()
java.math.BigDecimal.plus(java.math.MathContext)
javax.management.Query.plus(javax.management.ValueExp, javax.management.ValueExp)


Occurences of PNG

PNG occurences:
javax.print.PNG
javax.print.PNG
javax.print.PNG


Occurences of Point (constructors)

Point (constructors) occurences:
java.awt.Point()
java.awt.Point(int, int)
java.awt.Point(java.awt.Point)


Occurences of Point2D.Double (constructors)

Point2D.Double (constructors) occurences:
java.awt.geom.Point2D.Double()
java.awt.geom.Point2D.Double(double, double)


Occurences of Point2D.Float (constructors)

Point2D.Float (constructors) occurences:
java.awt.geom.Point2D.Float()
java.awt.geom.Point2D.Float(float, float)


Occurences of Policy

Policy occurences:
java.security.Policy
javax.security.auth.Policy
org.omg.CORBA.Policy


Occurences of Policy (constructors)

Policy (constructors) occurences:
java.security.Policy()
javax.security.auth.Policy()


Occurences of PolicyError (constructors)

PolicyError (constructors) occurences:
org.omg.CORBA.PolicyError()
org.omg.CORBA.PolicyError(java.lang.String, short)
org.omg.CORBA.PolicyError(short)


Occurences of PolicyErrorHolder (constructors)

PolicyErrorHolder (constructors) occurences:
org.omg.CORBA.PolicyErrorHolder()
org.omg.CORBA.PolicyErrorHolder(org.omg.CORBA.PolicyError)


Occurences of PolicyHolder (constructors)

PolicyHolder (constructors) occurences:
org.omg.CORBA.PolicyHolder()
org.omg.CORBA.PolicyHolder(org.omg.CORBA.Policy)


Occurences of PolicyListHolder (constructors)

PolicyListHolder (constructors) occurences:
org.omg.CORBA.PolicyListHolder()
org.omg.CORBA.PolicyListHolder(org.omg.CORBA.Policy[])


Occurences of policytool - Policy File Admin GUI

policytool - Policy File Admin GUI occurences:
policytool - Policy File Admin GUI
policytool - Policy File Admin GUI


Occurences of policy_type

policy_type occurences:
org.omg.CORBA.PolicyOperations.policy_type()
org.omg.CORBA._PolicyStub.policy_type()


Occurences of poll

poll occurences:
java.lang.ref.ReferenceQueue.poll()
java.util.ArrayDeque.poll()
java.util.concurrent.ArrayBlockingQueue.poll()
java.util.concurrent.ArrayBlockingQueue.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.BlockingDeque.poll()
java.util.concurrent.BlockingDeque.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.BlockingQueue.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.CompletionService.poll()
java.util.concurrent.CompletionService.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.ConcurrentLinkedQueue.poll()
java.util.concurrent.DelayQueue.poll()
java.util.concurrent.DelayQueue.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.ExecutorCompletionService.poll()
java.util.concurrent.ExecutorCompletionService.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingDeque.poll()
java.util.concurrent.LinkedBlockingDeque.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.LinkedBlockingQueue.poll()
java.util.concurrent.LinkedBlockingQueue.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.PriorityBlockingQueue.poll()
java.util.concurrent.PriorityBlockingQueue.poll(long, java.util.concurrent.TimeUnit)
java.util.concurrent.SynchronousQueue.poll()
java.util.concurrent.SynchronousQueue.poll(long, java.util.concurrent.TimeUnit)
java.util.Deque.poll()
java.util.LinkedList.poll()
java.util.PriorityQueue.poll()
java.util.Queue.poll()


Occurences of pollFirst

pollFirst occurences:
java.util.ArrayDeque.pollFirst()
java.util.concurrent.BlockingDeque.pollFirst(long, java.util.concurrent.TimeUnit)
java.util.concurrent.ConcurrentSkipListSet.pollFirst()
java.util.concurrent.LinkedBlockingDeque.pollFirst()
java.util.concurrent.LinkedBlockingDeque.pollFirst(long, java.util.concurrent.TimeUnit)
java.util.Deque.pollFirst()
java.util.LinkedList.pollFirst()
java.util.NavigableSet.pollFirst()
java.util.TreeSet.pollFirst()


Occurences of pollFirstEntry

pollFirstEntry occurences:
java.util.concurrent.ConcurrentSkipListMap.pollFirstEntry()
java.util.NavigableMap.pollFirstEntry()
java.util.TreeMap.pollFirstEntry()


Occurences of pollLast

pollLast occurences:
java.util.ArrayDeque.pollLast()
java.util.concurrent.BlockingDeque.pollLast(long, java.util.concurrent.TimeUnit)
java.util.concurrent.ConcurrentSkipListSet.pollLast()
java.util.concurrent.LinkedBlockingDeque.pollLast()
java.util.concurrent.LinkedBlockingDeque.pollLast(long, java.util.concurrent.TimeUnit)
java.util.Deque.pollLast()
java.util.LinkedList.pollLast()
java.util.NavigableSet.pollLast()
java.util.TreeSet.pollLast()


Occurences of pollLastEntry

pollLastEntry occurences:
java.util.concurrent.ConcurrentSkipListMap.pollLastEntry()
java.util.NavigableMap.pollLastEntry()
java.util.TreeMap.pollLastEntry()


Occurences of Polygon (constructors)

Polygon (constructors) occurences:
java.awt.Polygon()
java.awt.Polygon(int[], int[], int)


Occurences of pop

pop occurences:
java.awt.EventQueue.pop()
java.util.ArrayDeque.pop()
java.util.concurrent.LinkedBlockingDeque.pop()
java.util.Deque.pop()
java.util.LinkedList.pop()
java.util.Stack.pop()


Occurences of populate

populate occurences:
javax.sql.rowset.CachedRowSet.populate(java.sql.ResultSet)
javax.sql.rowset.CachedRowSet.populate(java.sql.ResultSet, int)


Occurences of Popup (constructors)

Popup (constructors) occurences:
javax.swing.Popup()
javax.swing.Popup(java.awt.Component, java.awt.Component, int, int)


Occurences of PopupMenu (constructors)

PopupMenu (constructors) occurences:
java.awt.PopupMenu()
java.awt.PopupMenu(java.lang.String)


Occurences of POPUP_MENU

POPUP_MENU occurences:
javax.accessibility.POPUP_MENU
javax.swing.plaf.synth.POPUP_MENU


Occurences of portable

portable occurences:
org.omg.CORBA.portable
org.omg.CORBA_2_3.portable
org.omg.PortableServer.portable


Occurences of portName

portName occurences:
javax.jws.WebService.portName()
javax.xml.ws.WebServiceProvider.portName()


Occurences of PORTRAIT

PORTRAIT occurences:
java.awt.PORTRAIT
java.awt.print.PORTRAIT
javax.print.attribute.standard.PORTRAIT


Occurences of PortUnreachableException (constructors)

PortUnreachableException (constructors) occurences:
java.net.PortUnreachableException()
java.net.PortUnreachableException(java.lang.String)


Occurences of pos

pos occurences:
java.io.pos
java.io.pos
java.io.pos
java.io.pos
java.io.pos


Occurences of position

position occurences:
com.sun.javadoc.Doc.position()
com.sun.javadoc.Tag.position()
java.nio.Buffer.position()
java.nio.Buffer.position(int)
java.nio.channels.FileChannel.position()
java.nio.channels.FileChannel.position(long)
java.nio.channels.FileLock.position()
java.sql.Blob.position(byte[], long)
java.sql.Blob.position(java.sql.Blob, long)
java.sql.Clob.position(java.lang.String, long)
java.sql.Clob.position(java.sql.Clob, long)
javax.sql.rowset.serial.SerialBlob.position(byte[], long)
javax.sql.rowset.serial.SerialBlob.position(java.sql.Blob, long)
javax.sql.rowset.serial.SerialClob.position(java.lang.String, long)
javax.sql.rowset.serial.SerialClob.position(java.sql.Clob, long)


Occurences of positionForMouseEvent

positionForMouseEvent occurences:
javax.swing.plaf.basic.BasicSplitPaneDivider.DragController.positionForMouseEvent(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicSplitPaneDivider.VerticalDragController.positionForMouseEvent(java.awt.event.MouseEvent)


Occurences of POSITIVE_INFINITY

POSITIVE_INFINITY occurences:
java.lang.POSITIVE_INFINITY
java.lang.POSITIVE_INFINITY


Occurences of postDeregister

postDeregister occurences:
javax.management.loading.MLet.postDeregister()
javax.management.MBeanRegistration.postDeregister()
javax.management.modelmbean.RequiredModelMBean.postDeregister()
javax.management.monitor.Monitor.postDeregister()
javax.management.relation.RelationService.postDeregister()
javax.management.relation.RelationSupport.postDeregister()
javax.management.remote.JMXConnectorServer.postDeregister()
javax.management.StandardMBean.postDeregister()
javax.management.timer.Timer.postDeregister()


Occurences of postEvent

postEvent occurences:
java.awt.Component.postEvent(java.awt.Event)
java.awt.EventQueue.postEvent(java.awt.AWTEvent)
java.awt.MenuComponent.postEvent(java.awt.Event)
java.awt.MenuContainer.postEvent(java.awt.Event)
java.awt.Window.postEvent(java.awt.Event)


Occurences of postinvoke

postinvoke occurences:
org.omg.PortableServer.ServantLocatorOperations.postinvoke(byte[], org.omg.PortableServer.POA, java.lang.String, java.lang.Object, org.omg.PortableServer.Servant)
org.omg.PortableServer._ServantLocatorStub.postinvoke(byte[], org.omg.PortableServer.POA, java.lang.String, java.lang.Object, org.omg.PortableServer.Servant)


Occurences of postProcessKeyEvent

postProcessKeyEvent occurences:
java.awt.DefaultKeyboardFocusManager.postProcessKeyEvent(java.awt.event.KeyEvent)
java.awt.KeyboardFocusManager.postProcessKeyEvent(java.awt.event.KeyEvent)
java.awt.KeyEventPostProcessor.postProcessKeyEvent(java.awt.event.KeyEvent)


Occurences of postRegister

postRegister occurences:
javax.management.loading.MLet.postRegister(java.lang.Boolean)
javax.management.MBeanRegistration.postRegister(java.lang.Boolean)
javax.management.modelmbean.RequiredModelMBean.postRegister(java.lang.Boolean)
javax.management.monitor.Monitor.postRegister(java.lang.Boolean)
javax.management.relation.RelationService.postRegister(java.lang.Boolean)
javax.management.relation.RelationSupport.postRegister(java.lang.Boolean)
javax.management.remote.JMXConnectorServer.postRegister(java.lang.Boolean)
javax.management.StandardMBean.postRegister(java.lang.Boolean)
javax.management.timer.Timer.postRegister(java.lang.Boolean)


Occurences of POSTSCRIPT

POSTSCRIPT occurences:
javax.print.POSTSCRIPT
javax.print.POSTSCRIPT
javax.print.POSTSCRIPT


Occurences of pow

pow occurences:
java.lang.Math.pow(double, double)
java.lang.StrictMath.pow(double, double)
java.math.BigDecimal.pow(int)
java.math.BigDecimal.pow(int, java.math.MathContext)
java.math.BigInteger.pow(int)


Occurences of preDeregister

preDeregister occurences:
javax.management.loading.MLet.preDeregister()
javax.management.MBeanRegistration.preDeregister()
javax.management.modelmbean.RequiredModelMBean.preDeregister()
javax.management.monitor.Monitor.preDeregister()
javax.management.relation.RelationService.preDeregister()
javax.management.relation.RelationSupport.preDeregister()
javax.management.remote.JMXConnectorServer.preDeregister()
javax.management.StandardMBean.preDeregister()
javax.management.timer.Timer.preDeregister()


Occurences of Preface

Preface occurences:
Preface
Preface
Preface
Preface


Occurences of preferenceChanged

preferenceChanged occurences:
javax.swing.text.AsyncBoxView.preferenceChanged(javax.swing.text.View, boolean, boolean)
javax.swing.text.AsyncBoxView.ChildState.preferenceChanged(boolean, boolean)
javax.swing.text.BoxView.preferenceChanged(javax.swing.text.View, boolean, boolean)
javax.swing.text.View.preferenceChanged(javax.swing.text.View, boolean, boolean)


Occurences of preferredLayoutSize

preferredLayoutSize occurences:
java.awt.BorderLayout.preferredLayoutSize(java.awt.Container)
java.awt.CardLayout.preferredLayoutSize(java.awt.Container)
java.awt.FlowLayout.preferredLayoutSize(java.awt.Container)
java.awt.GridBagLayout.preferredLayoutSize(java.awt.Container)
java.awt.GridLayout.preferredLayoutSize(java.awt.Container)
java.awt.LayoutManager.preferredLayoutSize(java.awt.Container)
javax.swing.BoxLayout.preferredLayoutSize(java.awt.Container)
javax.swing.GroupLayout.preferredLayoutSize(java.awt.Container)
javax.swing.JRootPane.RootLayout.preferredLayoutSize(java.awt.Container)
javax.swing.JSpinner.DefaultEditor.preferredLayoutSize(java.awt.Container)
javax.swing.OverlayLayout.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicComboBoxUI.ComboBoxLayoutManager.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.TitlePaneLayout.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicInternalFrameUI.InternalFrameLayout.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicOptionPaneUI.ButtonAreaLayout.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicScrollBarUI.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneDivider.DividerLayout.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.BasicTabbedPaneUI.TabbedPaneLayout.preferredLayoutSize(java.awt.Container)
javax.swing.plaf.basic.DefaultMenuLayout.preferredLayoutSize(java.awt.Container)
javax.swing.ScrollPaneLayout.preferredLayoutSize(java.awt.Container)
javax.swing.SpringLayout.preferredLayoutSize(java.awt.Container)
javax.swing.ViewportLayout.preferredLayoutSize(java.awt.Container)


Occurences of preferredSize

preferredSize occurences:
java.awt.Component.preferredSize()
java.awt.Container.preferredSize()
java.awt.List.preferredSize()
java.awt.List.preferredSize(int)
java.awt.TextArea.preferredSize()
java.awt.TextArea.preferredSize(int, int)
java.awt.TextField.preferredSize()
java.awt.TextField.preferredSize(int)
javax.swing.plaf.basic.preferredSize


Occurences of preinvoke

preinvoke occurences:
org.omg.PortableServer.ServantLocatorOperations.preinvoke(byte[], org.omg.PortableServer.POA, java.lang.String, org.omg.PortableServer.ServantLocatorPackage.CookieHolder)
org.omg.PortableServer._ServantLocatorStub.preinvoke(byte[], org.omg.PortableServer.POA, java.lang.String, org.omg.PortableServer.ServantLocatorPackage.CookieHolder)


Occurences of prepareCall

prepareCall occurences:
java.sql.Connection.prepareCall(java.lang.String)
java.sql.Connection.prepareCall(java.lang.String, int, int)
java.sql.Connection.prepareCall(java.lang.String, int, int, int)


Occurences of PreparedStatement

PreparedStatement occurences:
java.sql.PreparedStatement
PreparedStatement


Occurences of prepareImage

prepareImage occurences:
java.awt.Component.prepareImage(java.awt.Image, int, int, java.awt.image.ImageObserver)
java.awt.Component.prepareImage(java.awt.Image, java.awt.image.ImageObserver)
java.awt.Toolkit.prepareImage(java.awt.Image, int, int, java.awt.image.ImageObserver)


Occurences of prepareStatement

prepareStatement occurences:
java.sql.Connection.prepareStatement(java.lang.String)
java.sql.Connection.prepareStatement(java.lang.String, int)
java.sql.Connection.prepareStatement(java.lang.String, int, int)
java.sql.Connection.prepareStatement(java.lang.String, int, int, int)
java.sql.Connection.prepareStatement(java.lang.String, int[])
java.sql.Connection.prepareStatement(java.lang.String, java.lang.String[])


Occurences of preRegister

preRegister occurences:
javax.management.loading.MLet.preRegister(javax.management.MBeanServer, javax.management.ObjectName)
javax.management.MBeanRegistration.preRegister(javax.management.MBeanServer, javax.management.ObjectName)
javax.management.modelmbean.RequiredModelMBean.preRegister(javax.management.MBeanServer, javax.management.ObjectName)
javax.management.monitor.Monitor.preRegister(javax.management.MBeanServer, javax.management.ObjectName)
javax.management.relation.RelationService.preRegister(javax.management.MBeanServer, javax.management.ObjectName)
javax.management.relation.RelationSupport.preRegister(javax.management.MBeanServer, javax.management.ObjectName)
javax.management.remote.JMXConnectorServer.preRegister(javax.management.MBeanServer, javax.management.ObjectName)
javax.management.StandardMBean.preRegister(javax.management.MBeanServer, javax.management.ObjectName)
javax.management.timer.Timer.preRegister(javax.management.MBeanServer, javax.management.ObjectName)


Occurences of PRESSED

PRESSED occurences:
javax.accessibility.PRESSED
javax.swing.plaf.synth.PRESSED
javax.swing.PRESSED


Occurences of previous

previous occurences:
java.awt.CardLayout.previous(java.awt.Container)
java.sql.ResultSet.previous()
java.text.BreakIterator.previous()
java.text.CharacterIterator.previous()
java.text.CollationElementIterator.previous()
java.text.StringCharacterIterator.previous()
java.util.ListIterator.previous()
javax.swing.text.ElementIterator.previous()
javax.swing.text.Segment.previous()


Occurences of PrimitiveType

PrimitiveType occurences:
com.sun.jdi.PrimitiveType
com.sun.mirror.type.PrimitiveType
javax.lang.model.type.PrimitiveType


Occurences of Principal

Principal occurences:
java.security.Principal
org.omg.CORBA.Principal


Occurences of PrincipalHolder (constructors)

PrincipalHolder (constructors) occurences:
org.omg.CORBA.PrincipalHolder()
org.omg.CORBA.PrincipalHolder(org.omg.CORBA.Principal)


Occurences of print

print occurences:
java.awt.Component.print(java.awt.Graphics)
java.awt.Container.print(java.awt.Graphics)
java.awt.Desktop.print(java.io.File)
java.awt.print
java.awt.print.Printable.print(java.awt.Graphics, java.awt.print.PageFormat, int)
java.awt.print.PrinterJob.print()
java.awt.print.PrinterJob.print(javax.print.attribute.PrintRequestAttributeSet)
java.io.PrintStream.print(boolean)
java.io.PrintStream.print(char)
java.io.PrintStream.print(char[])
java.io.PrintStream.print(double)
java.io.PrintStream.print(float)
java.io.PrintStream.print(int)
java.io.PrintStream.print(java.lang.Object)
java.io.PrintStream.print(java.lang.String)
java.io.PrintStream.print(long)
java.io.PrintWriter.print(boolean)
java.io.PrintWriter.print(char)
java.io.PrintWriter.print(char[])
java.io.PrintWriter.print(double)
java.io.PrintWriter.print(float)
java.io.PrintWriter.print(int)
java.io.PrintWriter.print(java.lang.Object)
java.io.PrintWriter.print(java.lang.String)
java.io.PrintWriter.print(long)
javax.print
javax.print.DocPrintJob.print(javax.print.Doc, javax.print.attribute.PrintRequestAttributeSet)
javax.print.MultiDocPrintJob.print(javax.print.MultiDoc, javax.print.attribute.PrintRequestAttributeSet)
javax.swing.JComponent.print(java.awt.Graphics)
javax.swing.JTable.print()
javax.swing.JTable.print(javax.swing.JTable.PrintMode)
javax.swing.JTable.print(javax.swing.JTable.PrintMode, java.text.MessageFormat, java.text.MessageFormat)
javax.swing.JTable.print(javax.swing.JTable.PrintMode, java.text.MessageFormat, java.text.MessageFormat, boolean, javax.print.attribute.PrintRequestAttributeSet, boolean)
javax.swing.JTable.print(javax.swing.JTable.PrintMode, java.text.MessageFormat, java.text.MessageFormat, boolean, javax.print.attribute.PrintRequestAttributeSet, boolean, javax.print.PrintService)
javax.swing.text.JTextComponent.print()
javax.swing.text.JTextComponent.print(java.text.MessageFormat, java.text.MessageFormat)
javax.swing.text.JTextComponent.print(java.text.MessageFormat, java.text.MessageFormat, boolean, javax.print.PrintService, javax.print.attribute.PrintRequestAttributeSet, boolean)


Occurences of PRINTABLE

PRINTABLE occurences:
java.awt.PRINTABLE
javax.print.PRINTABLE


Occurences of printAll

printAll occurences:
java.awt.Component.printAll(java.awt.Graphics)
javax.swing.JComponent.printAll(java.awt.Graphics)


Occurences of printAnySimpleType

printAnySimpleType occurences:
javax.xml.bind.DatatypeConverter.printAnySimpleType(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.printAnySimpleType(java.lang.String)


Occurences of printBase64Binary

printBase64Binary occurences:
javax.xml.bind.DatatypeConverter.printBase64Binary(byte[])
javax.xml.bind.DatatypeConverterInterface.printBase64Binary(byte[])


Occurences of printBoolean

printBoolean occurences:
javax.xml.bind.DatatypeConverter.printBoolean(boolean)
javax.xml.bind.DatatypeConverterInterface.printBoolean(boolean)


Occurences of printByte

printByte occurences:
javax.xml.bind.DatatypeConverter.printByte(byte)
javax.xml.bind.DatatypeConverterInterface.printByte(byte)


Occurences of printComponents

printComponents occurences:
java.awt.Container.printComponents(java.awt.Graphics)
java.awt.ScrollPane.printComponents(java.awt.Graphics)


Occurences of PrintConversionEventImpl (constructors)

PrintConversionEventImpl (constructors) occurences:
javax.xml.bind.helpers.PrintConversionEventImpl(int, java.lang.String, javax.xml.bind.ValidationEventLocator)
javax.xml.bind.helpers.PrintConversionEventImpl(int, java.lang.String, javax.xml.bind.ValidationEventLocator, java.lang.Throwable)


Occurences of printDataTransferCompleted

printDataTransferCompleted occurences:
javax.print.event.PrintJobAdapter.printDataTransferCompleted(javax.print.event.PrintJobEvent)
javax.print.event.PrintJobListener.printDataTransferCompleted(javax.print.event.PrintJobEvent)


Occurences of printDate

printDate occurences:
javax.xml.bind.DatatypeConverter.printDate(java.util.Calendar)
javax.xml.bind.DatatypeConverterInterface.printDate(java.util.Calendar)


Occurences of printDateTime

printDateTime occurences:
javax.xml.bind.DatatypeConverter.printDateTime(java.util.Calendar)
javax.xml.bind.DatatypeConverterInterface.printDateTime(java.util.Calendar)


Occurences of printDecimal

printDecimal occurences:
javax.xml.bind.DatatypeConverter.printDecimal(java.math.BigDecimal)
javax.xml.bind.DatatypeConverterInterface.printDecimal(java.math.BigDecimal)


Occurences of printDialog

printDialog occurences:
java.awt.print.PrinterJob.printDialog()
java.awt.print.PrinterJob.printDialog(javax.print.attribute.PrintRequestAttributeSet)
javax.print.ServiceUI.printDialog(java.awt.GraphicsConfiguration, int, int, javax.print.PrintService[], javax.print.PrintService, javax.print.DocFlavor, javax.print.attribute.PrintRequestAttributeSet)


Occurences of printDouble

printDouble occurences:
javax.xml.bind.DatatypeConverter.printDouble(double)
javax.xml.bind.DatatypeConverterInterface.printDouble(double)


Occurences of PrinterAbortException (constructors)

PrinterAbortException (constructors) occurences:
java.awt.print.PrinterAbortException()
java.awt.print.PrinterAbortException(java.lang.String)


Occurences of PrinterException (constructors)

PrinterException (constructors) occurences:
java.awt.print.PrinterException()
java.awt.print.PrinterException(java.lang.String)


Occurences of printError

printError occurences:
com.sun.javadoc.DocErrorReporter.printError(com.sun.javadoc.SourcePosition, java.lang.String)
com.sun.javadoc.DocErrorReporter.printError(java.lang.String)
com.sun.mirror.apt.Messager.printError(com.sun.mirror.util.SourcePosition, java.lang.String)
com.sun.mirror.apt.Messager.printError(java.lang.String)


Occurences of PrinterStateReasons (constructors)

PrinterStateReasons (constructors) occurences:
javax.print.attribute.standard.PrinterStateReasons()
javax.print.attribute.standard.PrinterStateReasons(int)
javax.print.attribute.standard.PrinterStateReasons(int, float)
javax.print.attribute.standard.PrinterStateReasons(java.util.Map)


Occurences of PrintException (constructors)

PrintException (constructors) occurences:
javax.print.PrintException()
javax.print.PrintException(java.lang.Exception)
javax.print.PrintException(java.lang.String)
javax.print.PrintException(java.lang.String, java.lang.Exception)


Occurences of printf

printf occurences:
Class GLOBALS.printf
java.io.Console.printf(java.lang.String, java.lang.Object...)
java.io.PrintStream.printf(java.lang.String, java.lang.Object...)
java.io.PrintStream.printf(java.util.Locale, java.lang.String, java.lang.Object...)
java.io.PrintWriter.printf(java.lang.String, java.lang.Object...)
java.io.PrintWriter.printf(java.util.Locale, java.lang.String, java.lang.Object...)


Occurences of printFloat

printFloat occurences:
javax.xml.bind.DatatypeConverter.printFloat(float)
javax.xml.bind.DatatypeConverterInterface.printFloat(float)


Occurences of printHexBinary

printHexBinary occurences:
javax.xml.bind.DatatypeConverter.printHexBinary(byte[])
javax.xml.bind.DatatypeConverterInterface.printHexBinary(byte[])


Occurences of printInt

printInt occurences:
javax.xml.bind.DatatypeConverter.printInt(int)
javax.xml.bind.DatatypeConverterInterface.printInt(int)


Occurences of printInteger

printInteger occurences:
javax.xml.bind.DatatypeConverter.printInteger(java.math.BigInteger)
javax.xml.bind.DatatypeConverterInterface.printInteger(java.math.BigInteger)


Occurences of printJobCanceled

printJobCanceled occurences:
javax.print.event.PrintJobAdapter.printJobCanceled(javax.print.event.PrintJobEvent)
javax.print.event.PrintJobListener.printJobCanceled(javax.print.event.PrintJobEvent)


Occurences of printJobCompleted

printJobCompleted occurences:
javax.print.event.PrintJobAdapter.printJobCompleted(javax.print.event.PrintJobEvent)
javax.print.event.PrintJobListener.printJobCompleted(javax.print.event.PrintJobEvent)


Occurences of printJobFailed

printJobFailed occurences:
javax.print.event.PrintJobAdapter.printJobFailed(javax.print.event.PrintJobEvent)
javax.print.event.PrintJobListener.printJobFailed(javax.print.event.PrintJobEvent)


Occurences of printJobNoMoreEvents

printJobNoMoreEvents occurences:
javax.print.event.PrintJobAdapter.printJobNoMoreEvents(javax.print.event.PrintJobEvent)
javax.print.event.PrintJobListener.printJobNoMoreEvents(javax.print.event.PrintJobEvent)


Occurences of printJobRequiresAttention

printJobRequiresAttention occurences:
javax.print.event.PrintJobAdapter.printJobRequiresAttention(javax.print.event.PrintJobEvent)
javax.print.event.PrintJobListener.printJobRequiresAttention(javax.print.event.PrintJobEvent)


Occurences of println

println occurences:
java.io.PrintStream.println()
java.io.PrintStream.println(boolean)
java.io.PrintStream.println(char)
java.io.PrintStream.println(char[])
java.io.PrintStream.println(double)
java.io.PrintStream.println(float)
java.io.PrintStream.println(int)
java.io.PrintStream.println(java.lang.Object)
java.io.PrintStream.println(java.lang.String)
java.io.PrintStream.println(long)
java.io.PrintWriter.println()
java.io.PrintWriter.println(boolean)
java.io.PrintWriter.println(char)
java.io.PrintWriter.println(char[])
java.io.PrintWriter.println(double)
java.io.PrintWriter.println(float)
java.io.PrintWriter.println(int)
java.io.PrintWriter.println(java.lang.Object)
java.io.PrintWriter.println(java.lang.String)
java.io.PrintWriter.println(long)
java.sql.DriverManager.println(java.lang.String)


Occurences of printLong

printLong occurences:
javax.xml.bind.DatatypeConverter.printLong(long)
javax.xml.bind.DatatypeConverterInterface.printLong(long)


Occurences of printMessage

printMessage occurences:
javax.annotation.processing.Messager.printMessage(javax.tools.Diagnostic.Kind, java.lang.CharSequence)
javax.annotation.processing.Messager.printMessage(javax.tools.Diagnostic.Kind, java.lang.CharSequence, javax.lang.model.element.Element)
javax.annotation.processing.Messager.printMessage(javax.tools.Diagnostic.Kind, java.lang.CharSequence, javax.lang.model.element.Element, javax.lang.model.element.AnnotationMirror)
javax.annotation.processing.Messager.printMessage(javax.tools.Diagnostic.Kind, java.lang.CharSequence, javax.lang.model.element.Element, javax.lang.model.element.AnnotationMirror, javax.lang.model.element.AnnotationValue)


Occurences of printNotice

printNotice occurences:
com.sun.javadoc.DocErrorReporter.printNotice(com.sun.javadoc.SourcePosition, java.lang.String)
com.sun.javadoc.DocErrorReporter.printNotice(java.lang.String)
com.sun.mirror.apt.Messager.printNotice(com.sun.mirror.util.SourcePosition, java.lang.String)
com.sun.mirror.apt.Messager.printNotice(java.lang.String)


Occurences of printQName

printQName occurences:
javax.xml.bind.DatatypeConverter.printQName(javax.xml.namespace.QName, javax.xml.namespace.NamespaceContext)
javax.xml.bind.DatatypeConverterInterface.printQName(javax.xml.namespace.QName, javax.xml.namespace.NamespaceContext)


Occurences of printShort

printShort occurences:
javax.xml.bind.DatatypeConverter.printShort(short)
javax.xml.bind.DatatypeConverterInterface.printShort(short)


Occurences of printStackTrace

printStackTrace occurences:
java.lang.Throwable.printStackTrace()
java.lang.Throwable.printStackTrace(java.io.PrintStream)
java.lang.Throwable.printStackTrace(java.io.PrintWriter)
javax.xml.bind.JAXBException.printStackTrace()
javax.xml.bind.JAXBException.printStackTrace(java.io.PrintStream)
javax.xml.bind.JAXBException.printStackTrace(java.io.PrintWriter)
javax.xml.bind.TypeConstraintException.printStackTrace()
javax.xml.bind.TypeConstraintException.printStackTrace(java.io.PrintStream)
javax.xml.crypto.dsig.TransformException.printStackTrace()
javax.xml.crypto.dsig.TransformException.printStackTrace(java.io.PrintStream)
javax.xml.crypto.dsig.TransformException.printStackTrace(java.io.PrintWriter)
javax.xml.crypto.dsig.XMLSignatureException.printStackTrace()
javax.xml.crypto.dsig.XMLSignatureException.printStackTrace(java.io.PrintStream)
javax.xml.crypto.dsig.XMLSignatureException.printStackTrace(java.io.PrintWriter)
javax.xml.crypto.KeySelectorException.printStackTrace()
javax.xml.crypto.KeySelectorException.printStackTrace(java.io.PrintStream)
javax.xml.crypto.KeySelectorException.printStackTrace(java.io.PrintWriter)
javax.xml.crypto.MarshalException.printStackTrace()
javax.xml.crypto.MarshalException.printStackTrace(java.io.PrintStream)
javax.xml.crypto.MarshalException.printStackTrace(java.io.PrintWriter)
javax.xml.crypto.NoSuchMechanismException.printStackTrace()
javax.xml.crypto.NoSuchMechanismException.printStackTrace(java.io.PrintStream)
javax.xml.crypto.NoSuchMechanismException.printStackTrace(java.io.PrintWriter)
javax.xml.crypto.URIReferenceException.printStackTrace()
javax.xml.crypto.URIReferenceException.printStackTrace(java.io.PrintStream)
javax.xml.crypto.URIReferenceException.printStackTrace(java.io.PrintWriter)
javax.xml.transform.TransformerException.printStackTrace()
javax.xml.transform.TransformerException.printStackTrace(java.io.PrintStream)
javax.xml.transform.TransformerException.printStackTrace(java.io.PrintWriter)
javax.xml.xpath.XPathException.printStackTrace()
javax.xml.xpath.XPathException.printStackTrace(java.io.PrintStream)
javax.xml.xpath.XPathException.printStackTrace(java.io.PrintWriter)


Occurences of PrintStream (constructors)

PrintStream (constructors) occurences:
java.io.PrintStream(java.io.File)
java.io.PrintStream(java.io.File, java.lang.String)
java.io.PrintStream(java.io.OutputStream)
java.io.PrintStream(java.io.OutputStream, boolean)
java.io.PrintStream(java.io.OutputStream, boolean, java.lang.String)
java.io.PrintStream(java.lang.String)
java.io.PrintStream(java.lang.String, java.lang.String)


Occurences of printString

printString occurences:
javax.xml.bind.DatatypeConverter.printString(java.lang.String)
javax.xml.bind.DatatypeConverterInterface.printString(java.lang.String)


Occurences of printTime

printTime occurences:
javax.xml.bind.DatatypeConverter.printTime(java.util.Calendar)
javax.xml.bind.DatatypeConverterInterface.printTime(java.util.Calendar)


Occurences of printUnsignedInt

printUnsignedInt occurences:
javax.xml.bind.DatatypeConverter.printUnsignedInt(long)
javax.xml.bind.DatatypeConverterInterface.printUnsignedInt(long)


Occurences of printUnsignedShort

printUnsignedShort occurences:
javax.xml.bind.DatatypeConverter.printUnsignedShort(int)
javax.xml.bind.DatatypeConverterInterface.printUnsignedShort(int)


Occurences of printWarning

printWarning occurences:
com.sun.javadoc.DocErrorReporter.printWarning(com.sun.javadoc.SourcePosition, java.lang.String)
com.sun.javadoc.DocErrorReporter.printWarning(java.lang.String)
com.sun.mirror.apt.Messager.printWarning(com.sun.mirror.util.SourcePosition, java.lang.String)
com.sun.mirror.apt.Messager.printWarning(java.lang.String)


Occurences of PrintWriter (constructors)

PrintWriter (constructors) occurences:
java.io.PrintWriter(java.io.File)
java.io.PrintWriter(java.io.File, java.lang.String)
java.io.PrintWriter(java.io.OutputStream)
java.io.PrintWriter(java.io.OutputStream, boolean)
java.io.PrintWriter(java.io.Writer)
java.io.PrintWriter(java.io.Writer, boolean)
java.io.PrintWriter(java.lang.String)
java.io.PrintWriter(java.lang.String, java.lang.String)


Occurences of PriorityBlockingQueue (constructors)

PriorityBlockingQueue (constructors) occurences:
java.util.concurrent.PriorityBlockingQueue()
java.util.concurrent.PriorityBlockingQueue(int)
java.util.concurrent.PriorityBlockingQueue(int, java.util.Comparator)
java.util.concurrent.PriorityBlockingQueue(java.util.Collection)


Occurences of PriorityQueue (constructors)

PriorityQueue (constructors) occurences:
java.util.PriorityQueue()
java.util.PriorityQueue(int)
java.util.PriorityQueue(int, java.util.Comparator)
java.util.PriorityQueue(java.util.Collection)
java.util.PriorityQueue(java.util.PriorityQueue)
java.util.PriorityQueue(java.util.SortedSet)


Occurences of PRIVATE

PRIVATE occurences:
com.sun.mirror.declaration.PRIVATE
java.lang.reflect.PRIVATE
java.nio.channels.PRIVATE
java.security.PRIVATE
javax.lang.model.element.PRIVATE


Occurences of PrivateMLet (constructors)

PrivateMLet (constructors) occurences:
javax.management.loading.PrivateMLet(java.net.URL[], boolean)
javax.management.loading.PrivateMLet(java.net.URL[], java.lang.ClassLoader, boolean)
javax.management.loading.PrivateMLet(java.net.URL[], java.lang.ClassLoader, java.net.URLStreamHandlerFactory, boolean)


Occurences of process

process occurences:
com.sun.jdi.connect.VMStartException.process()
com.sun.jdi.VirtualMachine.process()
com.sun.mirror.apt.AnnotationProcessor.process()
javax.annotation.processing.AbstractProcessor.process(java.util.Set, javax.annotation.processing.RoundEnvironment)
javax.annotation.processing.Processor.process(java.util.Set, javax.annotation.processing.RoundEnvironment)
javax.swing.SwingWorker.process(java.util.List)


Occurences of processActionEvent

processActionEvent occurences:
java.awt.Button.processActionEvent(java.awt.event.ActionEvent)
java.awt.List.processActionEvent(java.awt.event.ActionEvent)
java.awt.MenuItem.processActionEvent(java.awt.event.ActionEvent)
java.awt.TextField.processActionEvent(java.awt.event.ActionEvent)


Occurences of ProcessBuilder (constructors)

ProcessBuilder (constructors) occurences:
java.lang.ProcessBuilder(java.lang.String...)
java.lang.ProcessBuilder(java.util.List)


Occurences of processEvent

processEvent occurences:
java.awt.Button.processEvent(java.awt.AWTEvent)
java.awt.Checkbox.processEvent(java.awt.AWTEvent)
java.awt.CheckboxMenuItem.processEvent(java.awt.AWTEvent)
java.awt.Choice.processEvent(java.awt.AWTEvent)
java.awt.Component.processEvent(java.awt.AWTEvent)
java.awt.Container.processEvent(java.awt.AWTEvent)
java.awt.List.processEvent(java.awt.AWTEvent)
java.awt.MenuComponent.processEvent(java.awt.AWTEvent)
java.awt.MenuItem.processEvent(java.awt.AWTEvent)
java.awt.Scrollbar.processEvent(java.awt.AWTEvent)
java.awt.TextComponent.processEvent(java.awt.AWTEvent)
java.awt.TextField.processEvent(java.awt.AWTEvent)
java.awt.Window.processEvent(java.awt.AWTEvent)


Occurences of processFocusEvent

processFocusEvent occurences:
java.awt.Component.processFocusEvent(java.awt.event.FocusEvent)
javax.swing.JFormattedTextField.processFocusEvent(java.awt.event.FocusEvent)
javax.swing.JPopupMenu.processFocusEvent(java.awt.event.FocusEvent)


Occurences of processImageComplete

processImageComplete occurences:
javax.imageio.ImageReader.processImageComplete()
javax.imageio.ImageWriter.processImageComplete()


Occurences of processImageProgress

processImageProgress occurences:
javax.imageio.ImageReader.processImageProgress(float)
javax.imageio.ImageWriter.processImageProgress(float)


Occurences of processImageStarted

processImageStarted occurences:
javax.imageio.ImageReader.processImageStarted(int)
javax.imageio.ImageWriter.processImageStarted(int)


Occurences of PROCESSING

PROCESSING occurences:
javax.print.attribute.standard.PROCESSING
javax.print.attribute.standard.PROCESSING


Occurences of ProcessingInstruction

ProcessingInstruction occurences:
javax.xml.stream.events.ProcessingInstruction
org.w3c.dom.ProcessingInstruction


Occurences of processingInstruction

processingInstruction occurences:
org.xml.sax.ContentHandler.processingInstruction(java.lang.String, java.lang.String)
org.xml.sax.DocumentHandler.processingInstruction(java.lang.String, java.lang.String)
org.xml.sax.HandlerBase.processingInstruction(java.lang.String, java.lang.String)
org.xml.sax.helpers.DefaultHandler.processingInstruction(java.lang.String, java.lang.String)
org.xml.sax.helpers.ParserAdapter.processingInstruction(java.lang.String, java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.processingInstruction(java.lang.String, java.lang.String)
org.xml.sax.helpers.XMLReaderAdapter.processingInstruction(java.lang.String, java.lang.String)


Occurences of processInputMethodEvent

processInputMethodEvent occurences:
java.awt.Component.processInputMethodEvent(java.awt.event.InputMethodEvent)
javax.swing.JFormattedTextField.processInputMethodEvent(java.awt.event.InputMethodEvent)
javax.swing.text.JTextComponent.processInputMethodEvent(java.awt.event.InputMethodEvent)


Occurences of processItemEvent

processItemEvent occurences:
java.awt.Checkbox.processItemEvent(java.awt.event.ItemEvent)
java.awt.CheckboxMenuItem.processItemEvent(java.awt.event.ItemEvent)
java.awt.Choice.processItemEvent(java.awt.event.ItemEvent)
java.awt.List.processItemEvent(java.awt.event.ItemEvent)


Occurences of processKeyBinding

processKeyBinding occurences:
javax.swing.JComponent.processKeyBinding(javax.swing.KeyStroke, java.awt.event.KeyEvent, int, boolean)
javax.swing.JMenuBar.processKeyBinding(javax.swing.KeyStroke, java.awt.event.KeyEvent, int, boolean)
javax.swing.JTable.processKeyBinding(javax.swing.KeyStroke, java.awt.event.KeyEvent, int, boolean)


Occurences of processKeyEvent

processKeyEvent occurences:
java.awt.Component.processKeyEvent(java.awt.event.KeyEvent)
java.awt.DefaultKeyboardFocusManager.processKeyEvent(java.awt.Component, java.awt.event.KeyEvent)
java.awt.KeyboardFocusManager.processKeyEvent(java.awt.Component, java.awt.event.KeyEvent)
javax.swing.JComboBox.processKeyEvent(java.awt.event.KeyEvent)
javax.swing.JComponent.processKeyEvent(java.awt.event.KeyEvent)
javax.swing.JMenu.processKeyEvent(java.awt.event.KeyEvent)
javax.swing.JMenuBar.processKeyEvent(java.awt.event.KeyEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.JMenuItem.processKeyEvent(java.awt.event.KeyEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.JPopupMenu.processKeyEvent(java.awt.event.KeyEvent)
javax.swing.JPopupMenu.processKeyEvent(java.awt.event.KeyEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.MenuElement.processKeyEvent(java.awt.event.KeyEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.MenuSelectionManager.processKeyEvent(java.awt.event.KeyEvent)


Occurences of processMouseEvent

processMouseEvent occurences:
java.awt.Component.processMouseEvent(java.awt.event.MouseEvent)
javax.swing.JComponent.processMouseEvent(java.awt.event.MouseEvent)
javax.swing.JMenuBar.processMouseEvent(java.awt.event.MouseEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.JMenuItem.processMouseEvent(java.awt.event.MouseEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.JPopupMenu.processMouseEvent(java.awt.event.MouseEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.MenuElement.processMouseEvent(java.awt.event.MouseEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.MenuSelectionManager.processMouseEvent(java.awt.event.MouseEvent)
javax.swing.plaf.basic.BasicCheckBoxMenuItemUI.processMouseEvent(javax.swing.JMenuItem, java.awt.event.MouseEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
javax.swing.plaf.basic.BasicRadioButtonMenuItemUI.processMouseEvent(javax.swing.JMenuItem, java.awt.event.MouseEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)


Occurences of processMouseMotionEvent

processMouseMotionEvent occurences:
java.awt.Component.processMouseMotionEvent(java.awt.event.MouseEvent)
javax.swing.JComponent.processMouseMotionEvent(java.awt.event.MouseEvent)


Occurences of processMouseWheelEvent

processMouseWheelEvent occurences:
java.awt.Component.processMouseWheelEvent(java.awt.event.MouseWheelEvent)
java.awt.ScrollPane.processMouseWheelEvent(java.awt.event.MouseWheelEvent)


Occurences of processThumbnailComplete

processThumbnailComplete occurences:
javax.imageio.ImageReader.processThumbnailComplete()
javax.imageio.ImageWriter.processThumbnailComplete()


Occurences of processThumbnailProgress

processThumbnailProgress occurences:
javax.imageio.ImageReader.processThumbnailProgress(float)
javax.imageio.ImageWriter.processThumbnailProgress(float)


Occurences of processThumbnailStarted

processThumbnailStarted occurences:
javax.imageio.ImageReader.processThumbnailStarted(int, int)
javax.imageio.ImageWriter.processThumbnailStarted(int, int)


Occurences of processWarningOccurred

processWarningOccurred occurences:
javax.imageio.ImageReader.processWarningOccurred(java.lang.String)
javax.imageio.ImageReader.processWarningOccurred(java.lang.String, java.lang.String)
javax.imageio.ImageWriter.processWarningOccurred(int, java.lang.String)
javax.imageio.ImageWriter.processWarningOccurred(int, java.lang.String, java.lang.String)


Occurences of processWindowEvent

processWindowEvent occurences:
java.awt.Window.processWindowEvent(java.awt.event.WindowEvent)
javax.swing.JDialog.processWindowEvent(java.awt.event.WindowEvent)
javax.swing.JFrame.processWindowEvent(java.awt.event.WindowEvent)


Occurences of programChange

programChange occurences:
javax.sound.midi.MidiChannel.programChange(int)
javax.sound.midi.MidiChannel.programChange(int, int)


Occurences of Programmer's Guide to the Java 2D API

Programmer's Guide to the Java 2D API occurences:
Programmer's Guide to the Java 2D API
Programmer's Guide to the Java 2D API


Occurences of PROGRESS

PROGRESS occurences:
java.util.jar.PROGRESS
java.util.jar.PROGRESS


Occurences of progressListeners

progressListeners occurences:
javax.imageio.progressListeners
javax.imageio.progressListeners


Occurences of PROGRESS_BAR

PROGRESS_BAR occurences:
javax.accessibility.PROGRESS_BAR
javax.swing.plaf.synth.PROGRESS_BAR


Occurences of properties

properties occurences:
java.util.jar.Pack200.Packer.properties()
java.util.jar.Pack200.Unpacker.properties()
javax.sound.midi.MidiFileFormat.properties()
javax.sound.sampled.AudioFileFormat.properties()
javax.sound.sampled.AudioFormat.properties()


Occurences of Properties (constructors)

Properties (constructors) occurences:
java.util.Properties()
java.util.Properties(java.util.Properties)


Occurences of PROPERTY

PROPERTY occurences:
javax.xml.bind.annotation.PROPERTY
org.w3c.dom.bootstrap.PROPERTY


Occurences of propertyChange

propertyChange occurences:
java.beans.beancontext.BeanContextSupport.propertyChange(java.beans.PropertyChangeEvent)
java.beans.PropertyChangeListener.propertyChange(java.beans.PropertyChangeEvent)
java.beans.PropertyChangeListenerProxy.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.JList.AccessibleJList.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.JPopupMenu.AccessibleJPopupMenu.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.JScrollPane.AccessibleJScrollPane.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.JSpinner.DefaultEditor.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.JTable.AccessibleJTable.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicButtonListener.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicColorChooserUI.PropertyHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicComboBoxUI.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicComboPopup.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicDirectoryModel.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicEditorPaneUI.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicInternalFrameUI.InternalFramePropertyChangeListener.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicLabelUI.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicListUI.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicOptionPaneUI.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicRootPaneUI.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicScrollBarUI.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicScrollPaneUI.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicSliderUI.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicSplitPaneDivider.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicSplitPaneUI.PropertyHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicTabbedPaneUI.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicTextAreaUI.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicTextPaneUI.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicTextUI.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicToolBarUI.PropertyListener.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicTreeUI.PropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.basic.BasicTreeUI.SelectionModelPropertyChangeHandler.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.metal.MetalComboBoxUI.MetalPropertyChangeListener.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.metal.MetalFileChooserUI.FilterComboBoxModel.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.metal.MetalRootPaneUI.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.metal.MetalSliderUI.MetalPropertyListener.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.plaf.metal.MetalTextFieldUI.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.propertyChange(java.beans.PropertyChangeEvent)
javax.swing.table.DefaultTableColumnModel.propertyChange(java.beans.PropertyChangeEvent)


Occurences of propertyChangeListener

propertyChangeListener occurences:
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener
javax.swing.plaf.basic.propertyChangeListener


Occurences of PropertyDescriptor (constructors)

PropertyDescriptor (constructors) occurences:
java.beans.PropertyDescriptor(java.lang.String, java.lang.Class)
java.beans.PropertyDescriptor(java.lang.String, java.lang.Class, java.lang.String, java.lang.String)
java.beans.PropertyDescriptor(java.lang.String, java.lang.reflect.Method, java.lang.reflect.Method)


Occurences of PropertyEditorSupport (constructors)

PropertyEditorSupport (constructors) occurences:
java.beans.PropertyEditorSupport()
java.beans.PropertyEditorSupport(java.lang.Object)


Occurences of PropertyException (constructors)

PropertyException (constructors) occurences:
javax.xml.bind.PropertyException(java.lang.String)
javax.xml.bind.PropertyException(java.lang.String, java.lang.Object)
javax.xml.bind.PropertyException(java.lang.String, java.lang.String)
javax.xml.bind.PropertyException(java.lang.String, java.lang.String, java.lang.Throwable)
javax.xml.bind.PropertyException(java.lang.String, java.lang.Throwable)
javax.xml.bind.PropertyException(java.lang.Throwable)


Occurences of PropertyResourceBundle (constructors)

PropertyResourceBundle (constructors) occurences:
java.util.PropertyResourceBundle(java.io.InputStream)
java.util.PropertyResourceBundle(java.io.Reader)


Occurences of PROTECTED

PROTECTED occurences:
com.sun.mirror.declaration.PROTECTED
java.lang.reflect.PROTECTED
javax.lang.model.element.PROTECTED


Occurences of ProtectionDomain (constructors)

ProtectionDomain (constructors) occurences:
java.security.ProtectionDomain(java.security.CodeSource, java.security.PermissionCollection)
java.security.ProtectionDomain(java.security.CodeSource, java.security.PermissionCollection, java.lang.ClassLoader, java.security.Principal[])


Occurences of ProtocolException

ProtocolException occurences:
java.net.ProtocolException
javax.xml.ws.ProtocolException


Occurences of ProtocolException (constructors)

ProtocolException (constructors) occurences:
java.net.ProtocolException()
java.net.ProtocolException(java.lang.String)
javax.xml.ws.ProtocolException()
javax.xml.ws.ProtocolException(java.lang.String)
javax.xml.ws.ProtocolException(java.lang.String, java.lang.Throwable)
javax.xml.ws.ProtocolException(java.lang.Throwable)


Occurences of PROTOCOL_PROVIDER_CLASS_LOADER

PROTOCOL_PROVIDER_CLASS_LOADER occurences:
javax.management.remote.PROTOCOL_PROVIDER_CLASS_LOADER
javax.management.remote.PROTOCOL_PROVIDER_CLASS_LOADER


Occurences of PROTOCOL_PROVIDER_PACKAGES

PROTOCOL_PROVIDER_PACKAGES occurences:
javax.management.remote.PROTOCOL_PROVIDER_PACKAGES
javax.management.remote.PROTOCOL_PROVIDER_PACKAGES


Occurences of provideErrorFeedback

provideErrorFeedback occurences:
javax.swing.LookAndFeel.provideErrorFeedback(java.awt.Component)
javax.swing.plaf.metal.MetalLookAndFeel.provideErrorFeedback(java.awt.Component)


Occurences of Provider

Provider occurences:
java.security.Provider
javax.xml.ws.Provider
javax.xml.ws.spi.Provider


Occurences of provider

provider occurences:
com.sun.tools.attach.VirtualMachine.provider()
com.sun.tools.attach.VirtualMachineDescriptor.provider()
java.nio.channels.SelectableChannel.provider()
java.nio.channels.Selector.provider()
java.nio.channels.spi.AbstractSelectableChannel.provider()
java.nio.channels.spi.AbstractSelector.provider()
java.nio.channels.spi.SelectorProvider.provider()
javax.xml.ws.spi.Provider.provider()


Occurences of Provider (constructors)

Provider (constructors) occurences:
java.security.Provider(java.lang.String, double, java.lang.String)
javax.xml.ws.spi.Provider()


Occurences of ProviderException (constructors)

ProviderException (constructors) occurences:
java.security.ProviderException()
java.security.ProviderException(java.lang.String)
java.security.ProviderException(java.lang.String, java.lang.Throwable)
java.security.ProviderException(java.lang.Throwable)


Occurences of Proxy

Proxy occurences:
java.lang.reflect.Proxy
java.net.Proxy


Occurences of Proxy (constructors)

Proxy (constructors) occurences:
java.lang.reflect.Proxy(java.lang.reflect.InvocationHandler)
java.net.Proxy(java.net.Proxy.Type, java.net.SocketAddress)


Occurences of Proxy Configuration

Proxy Configuration occurences:
Proxy Configuration
Proxy Configuration


Occurences of PSSParameterSpec (constructors)

PSSParameterSpec (constructors) occurences:
java.security.spec.PSSParameterSpec(int)
java.security.spec.PSSParameterSpec(java.lang.String, java.lang.String, java.security.spec.AlgorithmParameterSpec, int, int)


Occurences of ptLineDist

ptLineDist occurences:
java.awt.geom.Line2D.ptLineDist(double, double)
java.awt.geom.Line2D.ptLineDist(double, double, double, double, double, double)
java.awt.geom.Line2D.ptLineDist(java.awt.geom.Point2D)


Occurences of ptLineDistSq

ptLineDistSq occurences:
java.awt.geom.Line2D.ptLineDistSq(double, double)
java.awt.geom.Line2D.ptLineDistSq(double, double, double, double, double, double)
java.awt.geom.Line2D.ptLineDistSq(java.awt.geom.Point2D)


Occurences of ptSegDist

ptSegDist occurences:
java.awt.geom.Line2D.ptSegDist(double, double)
java.awt.geom.Line2D.ptSegDist(double, double, double, double, double, double)
java.awt.geom.Line2D.ptSegDist(java.awt.geom.Point2D)


Occurences of ptSegDistSq

ptSegDistSq occurences:
java.awt.geom.Line2D.ptSegDistSq(double, double)
java.awt.geom.Line2D.ptSegDistSq(double, double, double, double, double, double)
java.awt.geom.Line2D.ptSegDistSq(java.awt.geom.Point2D)


Occurences of PUBLIC

PUBLIC occurences:
com.sun.mirror.declaration.PUBLIC
java.lang.reflect.PUBLIC
java.lang.reflect.PUBLIC
java.security.PUBLIC
javax.lang.model.element.PUBLIC
javax.swing.text.html.parser.PUBLIC


Occurences of PUBLIC_MEMBER

PUBLIC_MEMBER occurences:
javax.xml.bind.annotation.PUBLIC_MEMBER
org.omg.CORBA.PUBLIC_MEMBER


Occurences of publish

publish occurences:
java.util.logging.ConsoleHandler.publish(java.util.logging.LogRecord)
java.util.logging.FileHandler.publish(java.util.logging.LogRecord)
java.util.logging.Handler.publish(java.util.logging.LogRecord)
java.util.logging.MemoryHandler.publish(java.util.logging.LogRecord)
java.util.logging.SocketHandler.publish(java.util.logging.LogRecord)
java.util.logging.StreamHandler.publish(java.util.logging.LogRecord)
javax.swing.SwingWorker.publish(java.lang.Object[])
javax.swing.SwingWorker.publish(V...)
javax.xml.ws.Endpoint.publish(java.lang.Object)
javax.xml.ws.Endpoint.publish(java.lang.String)
javax.xml.ws.Endpoint.publish(java.lang.String, java.lang.Object)


Occurences of purge

purge occurences:
java.util.concurrent.ThreadPoolExecutor.purge()
java.util.Timer.purge()


Occurences of purgeRelations

purgeRelations occurences:
javax.management.relation.RelationService.purgeRelations()
javax.management.relation.RelationServiceMBean.purgeRelations()


Occurences of push

push occurences:
java.awt.EventQueue.push(java.awt.EventQueue)
java.util.ArrayDeque.push(E)
java.util.ArrayDeque.push(java.lang.Object)
java.util.concurrent.BlockingDeque.push(E)
java.util.concurrent.BlockingDeque.push(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.push(E)
java.util.concurrent.LinkedBlockingDeque.push(java.lang.Object)
java.util.Deque.push(E)
java.util.Deque.push(java.lang.Object)
java.util.LinkedList.push(E)
java.util.LinkedList.push(java.lang.Object)
java.util.logging.MemoryHandler.push()
java.util.Stack.push(E)
java.util.Stack.push(java.lang.Object)


Occurences of PushbackInputStream (constructors)

PushbackInputStream (constructors) occurences:
java.io.PushbackInputStream(java.io.InputStream)
java.io.PushbackInputStream(java.io.InputStream, int)


Occurences of PushbackReader (constructors)

PushbackReader (constructors) occurences:
java.io.PushbackReader(java.io.Reader)
java.io.PushbackReader(java.io.Reader, int)


Occurences of put

put occurences:
java.awt.RenderingHints.put(java.lang.Object, java.lang.Object)
java.io.ObjectOutputStream.PutField.put(java.lang.String, boolean)
java.io.ObjectOutputStream.PutField.put(java.lang.String, byte)
java.io.ObjectOutputStream.PutField.put(java.lang.String, char)
java.io.ObjectOutputStream.PutField.put(java.lang.String, double)
java.io.ObjectOutputStream.PutField.put(java.lang.String, float)
java.io.ObjectOutputStream.PutField.put(java.lang.String, int)
java.io.ObjectOutputStream.PutField.put(java.lang.String, java.lang.Object)
java.io.ObjectOutputStream.PutField.put(java.lang.String, long)
java.io.ObjectOutputStream.PutField.put(java.lang.String, short)
java.net.CookieHandler.put(java.net.URI, java.util.Map)
java.net.CookieManager.put(java.net.URI, java.util.Map)
java.net.ResponseCache.put(java.net.URI, java.net.URLConnection)
java.nio.ByteBuffer.put(byte)
java.nio.ByteBuffer.put(byte[])
java.nio.ByteBuffer.put(byte[], int, int)
java.nio.ByteBuffer.put(int, byte)
java.nio.ByteBuffer.put(java.nio.ByteBuffer)
java.nio.CharBuffer.put(char)
java.nio.CharBuffer.put(char[])
java.nio.CharBuffer.put(char[], int, int)
java.nio.CharBuffer.put(int, char)
java.nio.CharBuffer.put(java.lang.String)
java.nio.CharBuffer.put(java.lang.String, int, int)
java.nio.CharBuffer.put(java.nio.CharBuffer)
java.nio.DoubleBuffer.put(double)
java.nio.DoubleBuffer.put(double[])
java.nio.DoubleBuffer.put(double[], int, int)
java.nio.DoubleBuffer.put(int, double)
java.nio.DoubleBuffer.put(java.nio.DoubleBuffer)
java.nio.FloatBuffer.put(float)
java.nio.FloatBuffer.put(float[])
java.nio.FloatBuffer.put(float[], int, int)
java.nio.FloatBuffer.put(int, float)
java.nio.FloatBuffer.put(java.nio.FloatBuffer)
java.nio.IntBuffer.put(int)
java.nio.IntBuffer.put(int, int)
java.nio.IntBuffer.put(int[])
java.nio.IntBuffer.put(int[], int, int)
java.nio.IntBuffer.put(java.nio.IntBuffer)
java.nio.LongBuffer.put(int, long)
java.nio.LongBuffer.put(java.nio.LongBuffer)
java.nio.LongBuffer.put(long)
java.nio.LongBuffer.put(long[])
java.nio.LongBuffer.put(long[], int, int)
java.nio.ShortBuffer.put(int, short)
java.nio.ShortBuffer.put(java.nio.ShortBuffer)
java.nio.ShortBuffer.put(short)
java.nio.ShortBuffer.put(short[])
java.nio.ShortBuffer.put(short[], int, int)
java.security.Provider.put(java.lang.Object, java.lang.Object)
java.util.AbstractMap.put(java.lang.Object,java.lang.Object)
java.util.AbstractMap.put(K, V)
java.util.concurrent.ArrayBlockingQueue.put(E)
java.util.concurrent.ArrayBlockingQueue.put(java.lang.Object)
java.util.concurrent.BlockingDeque.put(E)
java.util.concurrent.BlockingDeque.put(java.lang.Object)
java.util.concurrent.BlockingQueue.put(E)
java.util.concurrent.BlockingQueue.put(java.lang.Object)
java.util.concurrent.ConcurrentHashMap.put(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentHashMap.put(K, V)
java.util.concurrent.ConcurrentSkipListMap.put(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.put(K, V)
java.util.concurrent.DelayQueue.put(E)
java.util.concurrent.DelayQueue.put(java.util.concurrent.Delayed)
java.util.concurrent.LinkedBlockingDeque.put(E)
java.util.concurrent.LinkedBlockingDeque.put(java.lang.Object)
java.util.concurrent.LinkedBlockingQueue.put(E)
java.util.concurrent.LinkedBlockingQueue.put(java.lang.Object)
java.util.concurrent.PriorityBlockingQueue.put(E)
java.util.concurrent.PriorityBlockingQueue.put(java.lang.Object)
java.util.concurrent.SynchronousQueue.put(E)
java.util.concurrent.SynchronousQueue.put(java.lang.Object)
java.util.Dictionary.put(java.lang.Object,java.lang.Object)
java.util.Dictionary.put(K, V)
java.util.EnumMap.put(java.lang.Enum,java.lang.Object)
java.util.EnumMap.put(K, V)
java.util.HashMap.put(java.lang.Object,java.lang.Object)
java.util.HashMap.put(K, V)
java.util.Hashtable.put(java.lang.Object,java.lang.Object)
java.util.Hashtable.put(K, V)
java.util.IdentityHashMap.put(java.lang.Object,java.lang.Object)
java.util.IdentityHashMap.put(K, V)
java.util.jar.Attributes.put(java.lang.Object, java.lang.Object)
java.util.Map.put(java.lang.Object,java.lang.Object)
java.util.Map.put(K, V)
java.util.prefs.AbstractPreferences.put(java.lang.String, java.lang.String)
java.util.prefs.Preferences.put(java.lang.String, java.lang.String)
java.util.TreeMap.put(java.lang.Object,java.lang.Object)
java.util.TreeMap.put(K, V)
java.util.WeakHashMap.put(java.lang.Object,java.lang.Object)
java.util.WeakHashMap.put(K, V)
javax.management.openmbean.TabularData.put(javax.management.openmbean.CompositeData)
javax.management.openmbean.TabularDataSupport.put(java.lang.Object, java.lang.Object)
javax.management.openmbean.TabularDataSupport.put(javax.management.openmbean.CompositeData)
javax.naming.directory.Attributes.put(java.lang.String, java.lang.Object)
javax.naming.directory.Attributes.put(javax.naming.directory.Attribute)
javax.naming.directory.BasicAttributes.put(java.lang.String, java.lang.Object)
javax.naming.directory.BasicAttributes.put(javax.naming.directory.Attribute)
javax.print.attribute.standard.PrinterStateReasons.put(javax.print.attribute.standard.PrinterStateReason, javax.print.attribute.standard.Severity)
javax.script.AbstractScriptEngine.put(java.lang.String, java.lang.Object)
javax.script.Bindings.put(java.lang.String, java.lang.Object)
javax.script.ScriptEngine.put(java.lang.String, java.lang.Object)
javax.script.ScriptEngineManager.put(java.lang.String, java.lang.Object)
javax.script.SimpleBindings.put(java.lang.String, java.lang.Object)
javax.swing.ActionMap.put(java.lang.Object, javax.swing.Action)
javax.swing.ComponentInputMap.put(javax.swing.KeyStroke, java.lang.Object)
javax.swing.InputMap.put(javax.swing.KeyStroke, java.lang.Object)
javax.swing.UIDefaults.put(java.lang.Object, java.lang.Object)
javax.swing.UIManager.put(java.lang.Object, java.lang.Object)
javax.xml.crypto.dom.DOMCryptoContext.put(java.lang.Object, java.lang.Object)
javax.xml.crypto.XMLCryptoContext.put(java.lang.Object, java.lang.Object)


Occurences of putAll

putAll occurences:
java.awt.RenderingHints.putAll(java.util.Map)
java.security.Provider.putAll(java.util.Map)
java.util.AbstractMap.putAll(java.util.Map)
java.util.concurrent.ConcurrentHashMap.putAll(java.util.Map)
java.util.EnumMap.putAll(java.util.Map)
java.util.HashMap.putAll(java.util.Map)
java.util.Hashtable.putAll(java.util.Map)
java.util.IdentityHashMap.putAll(java.util.Map)
java.util.jar.Attributes.putAll(java.util.Map)
java.util.Map.putAll(java.util.Map)
java.util.TreeMap.putAll(java.util.Map)
java.util.WeakHashMap.putAll(java.util.Map)
javax.management.openmbean.TabularData.putAll(javax.management.openmbean.CompositeData[])
javax.management.openmbean.TabularDataSupport.putAll(java.util.Map)
javax.management.openmbean.TabularDataSupport.putAll(javax.management.openmbean.CompositeData[])
javax.script.Bindings.putAll(java.util.Map)
javax.script.SimpleBindings.putAll(java.util.Map)


Occurences of putBoolean

putBoolean occurences:
java.util.prefs.AbstractPreferences.putBoolean(java.lang.String, boolean)
java.util.prefs.Preferences.putBoolean(java.lang.String, boolean)


Occurences of putByteArray

putByteArray occurences:
java.util.prefs.AbstractPreferences.putByteArray(java.lang.String, byte[])
java.util.prefs.Preferences.putByteArray(java.lang.String, byte[])


Occurences of putChar

putChar occurences:
java.nio.ByteBuffer.putChar(char)
java.nio.ByteBuffer.putChar(int, char)


Occurences of putConstraint

putConstraint occurences:
javax.swing.SpringLayout.putConstraint(java.lang.String, java.awt.Component, int, java.lang.String, java.awt.Component)
javax.swing.SpringLayout.putConstraint(java.lang.String, java.awt.Component, javax.swing.Spring, java.lang.String, java.awt.Component)


Occurences of putDouble

putDouble occurences:
java.nio.ByteBuffer.putDouble(double)
java.nio.ByteBuffer.putDouble(int, double)
java.util.prefs.AbstractPreferences.putDouble(java.lang.String, double)
java.util.prefs.Preferences.putDouble(java.lang.String, double)


Occurences of putFirst

putFirst occurences:
java.util.concurrent.BlockingDeque.putFirst(E)
java.util.concurrent.BlockingDeque.putFirst(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.putFirst(E)
java.util.concurrent.LinkedBlockingDeque.putFirst(java.lang.Object)


Occurences of putFloat

putFloat occurences:
java.nio.ByteBuffer.putFloat(float)
java.nio.ByteBuffer.putFloat(int, float)
java.util.prefs.AbstractPreferences.putFloat(java.lang.String, float)
java.util.prefs.Preferences.putFloat(java.lang.String, float)


Occurences of putIfAbsent

putIfAbsent occurences:
java.util.concurrent.ConcurrentHashMap.putIfAbsent(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentHashMap.putIfAbsent(K, V)
java.util.concurrent.ConcurrentMap.putIfAbsent(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentMap.putIfAbsent(K, V)
java.util.concurrent.ConcurrentSkipListMap.putIfAbsent(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.putIfAbsent(K, V)


Occurences of putInt

putInt occurences:
java.nio.ByteBuffer.putInt(int)
java.nio.ByteBuffer.putInt(int, int)
java.util.prefs.AbstractPreferences.putInt(java.lang.String, int)
java.util.prefs.Preferences.putInt(java.lang.String, int)


Occurences of putLast

putLast occurences:
java.util.concurrent.BlockingDeque.putLast(E)
java.util.concurrent.BlockingDeque.putLast(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.putLast(E)
java.util.concurrent.LinkedBlockingDeque.putLast(java.lang.Object)


Occurences of putLong

putLong occurences:
java.nio.ByteBuffer.putLong(int, long)
java.nio.ByteBuffer.putLong(long)
java.util.prefs.AbstractPreferences.putLong(java.lang.String, long)
java.util.prefs.Preferences.putLong(java.lang.String, long)


Occurences of putNamespacePrefix

putNamespacePrefix occurences:
javax.xml.crypto.dom.DOMCryptoContext.putNamespacePrefix(java.lang.String, java.lang.String)
javax.xml.crypto.XMLCryptoContext.putNamespacePrefix(java.lang.String, java.lang.String)


Occurences of putNextEntry

putNextEntry occurences:
java.util.jar.JarOutputStream.putNextEntry(java.util.zip.ZipEntry)
java.util.zip.ZipOutputStream.putNextEntry(java.util.zip.ZipEntry)


Occurences of putProperty

putProperty occurences:
com.sun.jdi.request.EventRequest.putProperty(java.lang.Object, java.lang.Object)
javax.swing.text.AbstractDocument.putProperty(java.lang.Object, java.lang.Object)
javax.swing.text.Document.putProperty(java.lang.Object, java.lang.Object)


Occurences of putShort

putShort occurences:
java.nio.ByteBuffer.putShort(int, short)
java.nio.ByteBuffer.putShort(short)


Occurences of putValue

putValue occurences:
java.util.jar.Attributes.putValue(java.lang.String, java.lang.String)
javax.net.ssl.SSLSession.putValue(java.lang.String, java.lang.Object)
javax.swing.AbstractAction.putValue(java.lang.String, java.lang.Object)
javax.swing.Action.putValue(java.lang.String, java.lang.Object)


Occurences of QName (constructors)

QName (constructors) occurences:
javax.xml.namespace.QName(java.lang.String)
javax.xml.namespace.QName(java.lang.String, java.lang.String)
javax.xml.namespace.QName(java.lang.String, java.lang.String, java.lang.String)


Occurences of QuadCurve2D.Double (constructors)

QuadCurve2D.Double (constructors) occurences:
java.awt.geom.QuadCurve2D.Double()
java.awt.geom.QuadCurve2D.Double(double, double, double, double, double, double)


Occurences of QuadCurve2D.Float (constructors)

QuadCurve2D.Float (constructors) occurences:
java.awt.geom.QuadCurve2D.Float()
java.awt.geom.QuadCurve2D.Float(float, float, float, float, float, float)


Occurences of quadrantRotate

quadrantRotate occurences:
java.awt.geom.AffineTransform.quadrantRotate(int)
java.awt.geom.AffineTransform.quadrantRotate(int, double, double)


Occurences of quadTo

quadTo occurences:
java.awt.geom.Path2D.quadTo(double, double, double, double)
java.awt.geom.Path2D.Double.quadTo(double, double, double, double)
java.awt.geom.Path2D.Float.quadTo(double, double, double, double)
java.awt.geom.Path2D.Float.quadTo(float, float, float, float)


Occurences of QUARTO

QUARTO occurences:
java.awt.QUARTO
javax.print.attribute.standard.QUARTO
javax.print.attribute.standard.QUARTO


Occurences of queryMBeans

queryMBeans occurences:
javax.management.MBeanServer.queryMBeans(javax.management.ObjectName, javax.management.QueryExp)
javax.management.MBeanServerConnection.queryMBeans(javax.management.ObjectName, javax.management.QueryExp)
javax.management.remote.rmi.RMIConnection.queryMBeans(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.queryMBeans(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.queryMBeans(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)


Occurences of queryNames

queryNames occurences:
javax.management.MBeanServer.queryNames(javax.management.ObjectName, javax.management.QueryExp)
javax.management.MBeanServerConnection.queryNames(javax.management.ObjectName, javax.management.QueryExp)
javax.management.remote.rmi.RMIConnection.queryNames(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.queryNames(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.queryNames(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)


Occurences of quote

quote occurences:
java.net.quote
java.util.regex.Pattern.quote(java.lang.String)
javax.management.ObjectName.quote(java.lang.String)


Occurences of RadialGradientPaint (constructors)

RadialGradientPaint (constructors) occurences:
java.awt.RadialGradientPaint(float, float, float, float, float, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod)
java.awt.RadialGradientPaint(float, float, float, float[], java.awt.Color[])
java.awt.RadialGradientPaint(float, float, float, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod)
java.awt.RadialGradientPaint(java.awt.geom.Point2D, float, float[], java.awt.Color[])
java.awt.RadialGradientPaint(java.awt.geom.Point2D, float, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod)
java.awt.RadialGradientPaint(java.awt.geom.Point2D, float, java.awt.geom.Point2D, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod)
java.awt.RadialGradientPaint(java.awt.geom.Point2D, float, java.awt.geom.Point2D, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod, java.awt.MultipleGradientPaint.ColorSpaceType, java.awt.geom.AffineTransform)
java.awt.RadialGradientPaint(java.awt.geom.Rectangle2D, float[], java.awt.Color[], java.awt.MultipleGradientPaint.CycleMethod)


Occurences of RADIO_BUTTON

RADIO_BUTTON occurences:
javax.accessibility.RADIO_BUTTON
javax.swing.plaf.synth.RADIO_BUTTON


Occurences of RAISED

RAISED occurences:
javax.swing.border.RAISED
javax.swing.border.RAISED


Occurences of random

random occurences:
java.lang.Math.random()
java.lang.StrictMath.random()


Occurences of Random (constructors)

Random (constructors) occurences:
java.util.Random()
java.util.Random(long)


Occurences of RandomAccessFile (constructors)

RandomAccessFile (constructors) occurences:
java.io.RandomAccessFile(java.io.File, java.lang.String)
java.io.RandomAccessFile(java.lang.String, java.lang.String)


Occurences of range

range occurences:
java.util.EnumSet.range(E, E)
java.util.EnumSet.range(java.lang.Enum,java.lang.Enum)


Occurences of Raster (constructors)

Raster (constructors) occurences:
java.awt.image.Raster(java.awt.image.SampleModel, java.awt.image.DataBuffer, java.awt.Point)
java.awt.image.Raster(java.awt.image.SampleModel, java.awt.image.DataBuffer, java.awt.Rectangle, java.awt.Point, java.awt.image.Raster)
java.awt.image.Raster(java.awt.image.SampleModel, java.awt.Point)


Occurences of RC2ParameterSpec (constructors)

RC2ParameterSpec (constructors) occurences:
javax.crypto.spec.RC2ParameterSpec(int)
javax.crypto.spec.RC2ParameterSpec(int, byte[])
javax.crypto.spec.RC2ParameterSpec(int, byte[], int)


Occurences of RC5ParameterSpec (constructors)

RC5ParameterSpec (constructors) occurences:
javax.crypto.spec.RC5ParameterSpec(int, int, int)
javax.crypto.spec.RC5ParameterSpec(int, int, int, byte[])
javax.crypto.spec.RC5ParameterSpec(int, int, int, byte[], int)


Occurences of RCSID

RCSID occurences:
javax.swing.undo.RCSID
javax.swing.undo.RCSID


Occurences of Rdn (constructors)

Rdn (constructors) occurences:
javax.naming.ldap.Rdn(java.lang.String)
javax.naming.ldap.Rdn(java.lang.String, java.lang.Object)
javax.naming.ldap.Rdn(javax.naming.directory.Attributes)
javax.naming.ldap.Rdn(javax.naming.ldap.Rdn)


Occurences of read

read occurences:
Class GLOBALS.read
java.io.BufferedInputStream.read()
java.io.BufferedInputStream.read(byte[], int, int)
java.io.BufferedReader.read()
java.io.BufferedReader.read(char[], int, int)
java.io.ByteArrayInputStream.read()
java.io.ByteArrayInputStream.read(byte[], int, int)
java.io.CharArrayReader.read()
java.io.CharArrayReader.read(char[], int, int)
java.io.DataInputStream.read(byte[])
java.io.DataInputStream.read(byte[], int, int)
java.io.FileInputStream.read()
java.io.FileInputStream.read(byte[])
java.io.FileInputStream.read(byte[], int, int)
java.io.FilterInputStream.read()
java.io.FilterInputStream.read(byte[])
java.io.FilterInputStream.read(byte[], int, int)
java.io.FilterReader.read()
java.io.FilterReader.read(char[], int, int)
java.io.InputStream.read()
java.io.InputStream.read(byte[])
java.io.InputStream.read(byte[], int, int)
java.io.InputStreamReader.read()
java.io.InputStreamReader.read(char[], int, int)
java.io.LineNumberInputStream.read()
java.io.LineNumberInputStream.read(byte[], int, int)
java.io.LineNumberReader.read()
java.io.LineNumberReader.read(char[], int, int)
java.io.ObjectInput.read()
java.io.ObjectInput.read(byte[])
java.io.ObjectInput.read(byte[], int, int)
java.io.ObjectInputStream.read()
java.io.ObjectInputStream.read(byte[], int, int)
java.io.PipedInputStream.read()
java.io.PipedInputStream.read(byte[], int, int)
java.io.PipedReader.read()
java.io.PipedReader.read(char[], int, int)
java.io.PushbackInputStream.read()
java.io.PushbackInputStream.read(byte[], int, int)
java.io.PushbackReader.read()
java.io.PushbackReader.read(char[], int, int)
java.io.RandomAccessFile.read()
java.io.RandomAccessFile.read(byte[])
java.io.RandomAccessFile.read(byte[], int, int)
java.io.Reader.read()
java.io.Reader.read(char[])
java.io.Reader.read(char[], int, int)
java.io.Reader.read(java.nio.CharBuffer)
java.io.SequenceInputStream.read()
java.io.SequenceInputStream.read(byte[], int, int)
java.io.StringBufferInputStream.read()
java.io.StringBufferInputStream.read(byte[], int, int)
java.io.StringReader.read()
java.io.StringReader.read(char[], int, int)
java.lang.Readable.read(java.nio.CharBuffer)
java.nio.channels.DatagramChannel.read(java.nio.ByteBuffer)
java.nio.channels.DatagramChannel.read(java.nio.ByteBuffer[])
java.nio.channels.DatagramChannel.read(java.nio.ByteBuffer[], int, int)
java.nio.channels.FileChannel.read(java.nio.ByteBuffer)
java.nio.channels.FileChannel.read(java.nio.ByteBuffer, long)
java.nio.channels.FileChannel.read(java.nio.ByteBuffer[])
java.nio.channels.FileChannel.read(java.nio.ByteBuffer[], int, int)
java.nio.channels.ReadableByteChannel.read(java.nio.ByteBuffer)
java.nio.channels.ScatteringByteChannel.read(java.nio.ByteBuffer[])
java.nio.channels.ScatteringByteChannel.read(java.nio.ByteBuffer[], int, int)
java.nio.channels.SocketChannel.read(java.nio.ByteBuffer)
java.nio.channels.SocketChannel.read(java.nio.ByteBuffer[])
java.nio.channels.SocketChannel.read(java.nio.ByteBuffer[], int, int)
java.nio.CharBuffer.read(java.nio.CharBuffer)
java.rmi.server.ObjID.read(java.io.ObjectInput)
java.rmi.server.UID.read(java.io.DataInput)
java.security.DigestInputStream.read()
java.security.DigestInputStream.read(byte[], int, int)
java.util.jar.JarInputStream.read(byte[], int, int)
java.util.jar.Manifest.read(java.io.InputStream)
java.util.zip.CheckedInputStream.read()
java.util.zip.CheckedInputStream.read(byte[], int, int)
java.util.zip.DeflaterInputStream.read()
java.util.zip.DeflaterInputStream.read(byte[], int, int)
java.util.zip.GZIPInputStream.read(byte[], int, int)
java.util.zip.InflaterInputStream.read()
java.util.zip.InflaterInputStream.read(byte[], int, int)
java.util.zip.ZipInputStream.read(byte[], int, int)
javax.crypto.CipherInputStream.read()
javax.crypto.CipherInputStream.read(byte[])
javax.crypto.CipherInputStream.read(byte[], int, int)
javax.imageio.ImageIO.read(java.io.File)
javax.imageio.ImageIO.read(java.io.InputStream)
javax.imageio.ImageIO.read(java.net.URL)
javax.imageio.ImageIO.read(javax.imageio.stream.ImageInputStream)
javax.imageio.ImageReader.read(int)
javax.imageio.ImageReader.read(int, javax.imageio.ImageReadParam)
javax.imageio.stream.FileCacheImageInputStream.read()
javax.imageio.stream.FileCacheImageInputStream.read(byte[], int, int)
javax.imageio.stream.FileCacheImageOutputStream.read()
javax.imageio.stream.FileCacheImageOutputStream.read(byte[], int, int)
javax.imageio.stream.FileImageInputStream.read()
javax.imageio.stream.FileImageInputStream.read(byte[], int, int)
javax.imageio.stream.FileImageOutputStream.read()
javax.imageio.stream.FileImageOutputStream.read(byte[], int, int)
javax.imageio.stream.ImageInputStream.read()
javax.imageio.stream.ImageInputStream.read(byte[])
javax.imageio.stream.ImageInputStream.read(byte[], int, int)
javax.imageio.stream.ImageInputStreamImpl.read()
javax.imageio.stream.ImageInputStreamImpl.read(byte[])
javax.imageio.stream.ImageInputStreamImpl.read(byte[], int, int)
javax.imageio.stream.MemoryCacheImageInputStream.read()
javax.imageio.stream.MemoryCacheImageInputStream.read(byte[], int, int)
javax.imageio.stream.MemoryCacheImageOutputStream.read()
javax.imageio.stream.MemoryCacheImageOutputStream.read(byte[], int, int)
javax.sound.sampled.AudioInputStream.read()
javax.sound.sampled.AudioInputStream.read(byte[])
javax.sound.sampled.AudioInputStream.read(byte[], int, int)
javax.sound.sampled.TargetDataLine.read(byte[], int, int)
javax.swing.JEditorPane.read(java.io.InputStream, java.lang.Object)
javax.swing.ProgressMonitorInputStream.read()
javax.swing.ProgressMonitorInputStream.read(byte[])
javax.swing.ProgressMonitorInputStream.read(byte[], int, int)
javax.swing.text.DefaultEditorKit.read(java.io.InputStream, javax.swing.text.Document, int)
javax.swing.text.DefaultEditorKit.read(java.io.Reader, javax.swing.text.Document, int)
javax.swing.text.EditorKit.read(java.io.InputStream, javax.swing.text.Document, int)
javax.swing.text.EditorKit.read(java.io.Reader, javax.swing.text.Document, int)
javax.swing.text.html.HTMLEditorKit.read(java.io.Reader, javax.swing.text.Document, int)
javax.swing.text.html.parser.DTD.read(java.io.DataInputStream)
javax.swing.text.JTextComponent.read(java.io.Reader, java.lang.Object)
javax.swing.text.rtf.RTFEditorKit.read(java.io.InputStream, javax.swing.text.Document, int)
javax.swing.text.rtf.RTFEditorKit.read(java.io.Reader, javax.swing.text.Document, int)
org.omg.CORBA.AnySeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.BooleanSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.CharSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.CompletionStatusHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.CurrentHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.DefinitionKindHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.DoubleSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.FieldNameHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.FloatSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.IdentifierHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.IDLTypeHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.LongLongSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.LongSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.NameValuePairHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ObjectHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.OctetSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ParameterModeHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.PolicyErrorCodeHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.PolicyErrorHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.PolicyHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.PolicyListHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.PolicyTypeHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.portable.InputStream.read()
org.omg.CORBA.RepositoryIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ServiceDetailHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ServiceInformationHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.SetOverrideTypeHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ShortSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.StringSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.StringValueHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.StructMemberHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ULongLongSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ULongSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.UnionMemberHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.UnknownUserExceptionHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.UShortSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ValueBaseHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.ValueMemberHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.VersionSpecHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.VisibilityHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.WCharSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.WrongTransactionHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.WStringSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.WStringValueHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.BindingHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.BindingIteratorHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.BindingListHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.BindingTypeHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.IstringHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NameComponentHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NameHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextExtHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextExtPackage.AddressHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextExtPackage.StringNameHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextExtPackage.URLStringHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextPackage.NotEmptyHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextPackage.NotFoundHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.CosNaming.NamingContextPackage.NotFoundReasonHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.AnySeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynAnyFactoryHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCodeHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynAnyHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynAnyPackage.InvalidValueHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynAnyPackage.TypeMismatchHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynAnySeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynArrayHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynEnumHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynFixedHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynSequenceHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynStructHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynUnionHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.DynValueHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.FieldNameHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.NameDynAnyPairHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.NameDynAnyPairSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.NameValuePairHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.DynamicAny.NameValuePairSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.CodecFactoryHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.CodecFactoryPackage.UnknownEncodingHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.CodecPackage.FormatMismatchHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.CodecPackage.InvalidTypeForEncodingHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.CodecPackage.TypeMismatchHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.ComponentIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.IORHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.MultipleComponentProfileHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.ProfileIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.ServiceContextHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.ServiceContextListHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.ServiceIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.TaggedComponentHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.IOP.TaggedProfileHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.Messaging.SyncScopeHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.AdapterManagerIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.AdapterNameHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.AdapterStateHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.CurrentHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ForwardRequestHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.InvalidSlotHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.IORInterceptor_3_0Helper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ObjectIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ObjectReferenceFactoryHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ObjectReferenceTemplateHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ORBIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateNameHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidNameHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ORBInitInfoPackage.ObjectIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableInterceptor.ServerIdHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.CurrentHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.CurrentPackage.NoContextHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.ForwardRequestHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAManagerPackage.AdapterInactiveHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.AdapterAlreadyExistsHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.AdapterNonExistentHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.InvalidPolicyHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.NoServantHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.ObjectAlreadyActiveHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.ObjectNotActiveHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.ServantAlreadyActiveHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.ServantNotActiveHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.WrongAdapterHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.POAPackage.WrongPolicyHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.ServantActivatorHelper.read(org.omg.CORBA.portable.InputStream)
org.omg.PortableServer.ServantLocatorHelper.read(org.omg.CORBA.portable.InputStream)


Occurences of readAll

readAll occurences:
javax.imageio.ImageReader.readAll(int, javax.imageio.ImageReadParam)
javax.imageio.ImageReader.readAll(java.util.Iterator)


Occurences of readAny

readAny occurences:
javax.rmi.CORBA.Util.readAny(org.omg.CORBA.portable.InputStream)
javax.rmi.CORBA.UtilDelegate.readAny(org.omg.CORBA.portable.InputStream)


Occurences of readArray

readArray occurences:
java.sql.SQLInput.readArray()
javax.sql.rowset.serial.SQLInputImpl.readArray()


Occurences of readAsciiStream

readAsciiStream occurences:
java.sql.SQLInput.readAsciiStream()
javax.sql.rowset.serial.SQLInputImpl.readAsciiStream()


Occurences of readBigDecimal

readBigDecimal occurences:
java.sql.SQLInput.readBigDecimal()
javax.sql.rowset.serial.SQLInputImpl.readBigDecimal()


Occurences of readBinaryStream

readBinaryStream occurences:
java.sql.SQLInput.readBinaryStream()
javax.sql.rowset.serial.SQLInputImpl.readBinaryStream()


Occurences of readBit

readBit occurences:
javax.imageio.stream.ImageInputStream.readBit()
javax.imageio.stream.ImageInputStreamImpl.readBit()


Occurences of readBits

readBits occurences:
javax.imageio.stream.ImageInputStream.readBits(int)
javax.imageio.stream.ImageInputStreamImpl.readBits(int)


Occurences of readBlob

readBlob occurences:
java.sql.SQLInput.readBlob()
javax.sql.rowset.serial.SQLInputImpl.readBlob()


Occurences of readBoolean

readBoolean occurences:
java.io.DataInput.readBoolean()
java.io.DataInputStream.readBoolean()
java.io.ObjectInputStream.readBoolean()
java.io.RandomAccessFile.readBoolean()
java.sql.SQLInput.readBoolean()
javax.imageio.stream.ImageInputStream.readBoolean()
javax.imageio.stream.ImageInputStreamImpl.readBoolean()
javax.sql.rowset.serial.SQLInputImpl.readBoolean()


Occurences of readByte

readByte occurences:
java.io.DataInput.readByte()
java.io.DataInputStream.readByte()
java.io.ObjectInputStream.readByte()
java.io.RandomAccessFile.readByte()
java.sql.SQLInput.readByte()
javax.imageio.stream.ImageInputStream.readByte()
javax.imageio.stream.ImageInputStreamImpl.readByte()
javax.sql.rowset.serial.SQLInputImpl.readByte()


Occurences of readBytes

readBytes occurences:
java.sql.SQLInput.readBytes()
javax.imageio.stream.ImageInputStream.readBytes(javax.imageio.stream.IIOByteBuffer, int)
javax.imageio.stream.ImageInputStreamImpl.readBytes(javax.imageio.stream.IIOByteBuffer, int)
javax.sql.rowset.serial.SQLInputImpl.readBytes()


Occurences of readChar

readChar occurences:
java.io.DataInput.readChar()
java.io.DataInputStream.readChar()
java.io.ObjectInputStream.readChar()
java.io.RandomAccessFile.readChar()
javax.imageio.stream.ImageInputStream.readChar()
javax.imageio.stream.ImageInputStreamImpl.readChar()


Occurences of readCharacterStream

readCharacterStream occurences:
java.sql.SQLInput.readCharacterStream()
javax.sql.rowset.serial.SQLInputImpl.readCharacterStream()


Occurences of readClob

readClob occurences:
java.sql.SQLInput.readClob()
javax.sql.rowset.serial.SQLInputImpl.readClob()


Occurences of readConfiguration

readConfiguration occurences:
java.util.logging.LogManager.readConfiguration()
java.util.logging.LogManager.readConfiguration(java.io.InputStream)


Occurences of readDate

readDate occurences:
java.sql.SQLInput.readDate()
javax.sql.rowset.serial.SQLInputImpl.readDate()


Occurences of readDouble

readDouble occurences:
java.io.DataInput.readDouble()
java.io.DataInputStream.readDouble()
java.io.ObjectInputStream.readDouble()
java.io.RandomAccessFile.readDouble()
java.sql.SQLInput.readDouble()
javax.imageio.stream.ImageInputStream.readDouble()
javax.imageio.stream.ImageInputStreamImpl.readDouble()
javax.sql.rowset.serial.SQLInputImpl.readDouble()


Occurences of reader

reader occurences:
java.io.Console.reader()
javax.script.reader


Occurences of Reader (constructors)

Reader (constructors) occurences:
java.io.Reader()
java.io.Reader(java.lang.Object)


Occurences of readExternal

readExternal occurences:
java.awt.datatransfer.DataFlavor.readExternal(java.io.ObjectInput)
java.io.Externalizable.readExternal(java.io.ObjectInput)
javax.activation.MimeType.readExternal(java.io.ObjectInput)
javax.management.loading.MLet.readExternal(java.io.ObjectInput)


Occurences of readFloat

readFloat occurences:
java.io.DataInput.readFloat()
java.io.DataInputStream.readFloat()
java.io.ObjectInputStream.readFloat()
java.io.RandomAccessFile.readFloat()
java.sql.SQLInput.readFloat()
javax.imageio.stream.ImageInputStream.readFloat()
javax.imageio.stream.ImageInputStreamImpl.readFloat()
javax.sql.rowset.serial.SQLInputImpl.readFloat()


Occurences of readFully

readFully occurences:
java.io.DataInput.readFully(byte[])
java.io.DataInput.readFully(byte[], int, int)
java.io.DataInputStream.readFully(byte[])
java.io.DataInputStream.readFully(byte[], int, int)
java.io.ObjectInputStream.readFully(byte[])
java.io.ObjectInputStream.readFully(byte[], int, int)
java.io.RandomAccessFile.readFully(byte[])
java.io.RandomAccessFile.readFully(byte[], int, int)
javax.imageio.stream.ImageInputStream.readFully(byte[])
javax.imageio.stream.ImageInputStream.readFully(byte[], int, int)
javax.imageio.stream.ImageInputStream.readFully(char[], int, int)
javax.imageio.stream.ImageInputStream.readFully(double[], int, int)
javax.imageio.stream.ImageInputStream.readFully(float[], int, int)
javax.imageio.stream.ImageInputStream.readFully(int[], int, int)
javax.imageio.stream.ImageInputStream.readFully(long[], int, int)
javax.imageio.stream.ImageInputStream.readFully(short[], int, int)
javax.imageio.stream.ImageInputStreamImpl.readFully(byte[])
javax.imageio.stream.ImageInputStreamImpl.readFully(byte[], int, int)
javax.imageio.stream.ImageInputStreamImpl.readFully(char[], int, int)
javax.imageio.stream.ImageInputStreamImpl.readFully(double[], int, int)
javax.imageio.stream.ImageInputStreamImpl.readFully(float[], int, int)
javax.imageio.stream.ImageInputStreamImpl.readFully(int[], int, int)
javax.imageio.stream.ImageInputStreamImpl.readFully(long[], int, int)
javax.imageio.stream.ImageInputStreamImpl.readFully(short[], int, int)


Occurences of readInt

readInt occurences:
java.io.DataInput.readInt()
java.io.DataInputStream.readInt()
java.io.ObjectInputStream.readInt()
java.io.RandomAccessFile.readInt()
java.sql.SQLInput.readInt()
javax.imageio.stream.ImageInputStream.readInt()
javax.imageio.stream.ImageInputStreamImpl.readInt()
javax.sql.rowset.serial.SQLInputImpl.readInt()


Occurences of readLine

readLine occurences:
java.io.BufferedReader.readLine()
java.io.Console.readLine()
java.io.Console.readLine(java.lang.String, java.lang.Object...)
java.io.DataInput.readLine()
java.io.DataInputStream.readLine()
java.io.LineNumberReader.readLine()
java.io.ObjectInputStream.readLine()
java.io.RandomAccessFile.readLine()
javax.imageio.stream.ImageInputStream.readLine()
javax.imageio.stream.ImageInputStreamImpl.readLine()


Occurences of readLock

readLock occurences:
java.util.concurrent.locks.ReadWriteLock.readLock()
java.util.concurrent.locks.ReentrantReadWriteLock.readLock()
javax.swing.text.AbstractDocument.readLock()


Occurences of readLong

readLong occurences:
java.io.DataInput.readLong()
java.io.DataInputStream.readLong()
java.io.ObjectInputStream.readLong()
java.io.RandomAccessFile.readLong()
java.sql.SQLInput.readLong()
javax.imageio.stream.ImageInputStream.readLong()
javax.imageio.stream.ImageInputStreamImpl.readLong()
javax.sql.rowset.serial.SQLInputImpl.readLong()


Occurences of readNClob

readNClob occurences:
java.sql.SQLInput.readNClob()
javax.sql.rowset.serial.SQLInputImpl.readNClob()


Occurences of readNString

readNString occurences:
java.sql.SQLInput.readNString()
javax.sql.rowset.serial.SQLInputImpl.readNString()


Occurences of readObject

readObject occurences:
java.beans.XMLDecoder.readObject()
java.io.ObjectInput.readObject()
java.io.ObjectInputStream.readObject()
java.sql.SQLInput.readObject()
javax.rmi.CORBA.StubDelegate.readObject(javax.rmi.CORBA.Stub, java.io.ObjectInputStream)
javax.sql.rowset.serial.SQLInputImpl.readObject()


Occurences of readPassword

readPassword occurences:
java.io.Console.readPassword()
java.io.Console.readPassword(java.lang.String, java.lang.Object...)


Occurences of readRef

readRef occurences:
java.sql.SQLInput.readRef()
javax.sql.rowset.serial.SQLInputImpl.readRef()


Occurences of readResolve

readResolve occurences:
java.awt.AWTKeyStroke.readResolve()
java.awt.color.ICC_Profile.readResolve()
java.awt.font.TextAttribute.readResolve()
java.security.cert.Certificate.CertificateRep.readResolve()
java.security.cert.CertPath.CertPathRep.readResolve()
java.security.KeyRep.readResolve()
java.text.AttributedCharacterIterator.Attribute.readResolve()
java.text.DateFormat.Field.readResolve()
java.text.MessageFormat.Field.readResolve()
java.text.NumberFormat.Field.readResolve()
javax.management.openmbean.SimpleType.readResolve()
javax.print.attribute.EnumSyntax.readResolve()


Occurences of readRowId

readRowId occurences:
java.sql.SQLInput.readRowId()
javax.sql.rowset.serial.SQLInputImpl.readRowId()


Occurences of readShort

readShort occurences:
java.io.DataInput.readShort()
java.io.DataInputStream.readShort()
java.io.ObjectInputStream.readShort()
java.io.RandomAccessFile.readShort()
java.sql.SQLInput.readShort()
javax.imageio.stream.ImageInputStream.readShort()
javax.imageio.stream.ImageInputStreamImpl.readShort()
javax.sql.rowset.serial.SQLInputImpl.readShort()


Occurences of readSQLXML

readSQLXML occurences:
java.sql.SQLInput.readSQLXML()
javax.sql.rowset.serial.SQLInputImpl.readSQLXML()


Occurences of readString

readString occurences:
java.sql.SQLInput.readString()
javax.sql.rowset.serial.SQLInputImpl.readString()


Occurences of readTime

readTime occurences:
java.sql.SQLInput.readTime()
javax.sql.rowset.serial.SQLInputImpl.readTime()


Occurences of readTimestamp

readTimestamp occurences:
java.sql.SQLInput.readTimestamp()
javax.sql.rowset.serial.SQLInputImpl.readTimestamp()


Occurences of readUnsignedByte

readUnsignedByte occurences:
java.io.DataInput.readUnsignedByte()
java.io.DataInputStream.readUnsignedByte()
java.io.ObjectInputStream.readUnsignedByte()
java.io.RandomAccessFile.readUnsignedByte()
javax.imageio.stream.ImageInputStream.readUnsignedByte()
javax.imageio.stream.ImageInputStreamImpl.readUnsignedByte()


Occurences of readUnsignedInt

readUnsignedInt occurences:
javax.imageio.stream.ImageInputStream.readUnsignedInt()
javax.imageio.stream.ImageInputStreamImpl.readUnsignedInt()


Occurences of readUnsignedShort

readUnsignedShort occurences:
java.io.DataInput.readUnsignedShort()
java.io.DataInputStream.readUnsignedShort()
java.io.ObjectInputStream.readUnsignedShort()
java.io.RandomAccessFile.readUnsignedShort()
javax.imageio.stream.ImageInputStream.readUnsignedShort()
javax.imageio.stream.ImageInputStreamImpl.readUnsignedShort()


Occurences of readURL

readURL occurences:
java.sql.SQLInput.readURL()
javax.sql.rowset.serial.SQLInputImpl.readURL()


Occurences of readUTF

readUTF occurences:
java.io.DataInput.readUTF()
java.io.DataInputStream.readUTF()
java.io.DataInputStream.readUTF(java.io.DataInput)
java.io.ObjectInputStream.readUTF()
java.io.RandomAccessFile.readUTF()
javax.imageio.stream.ImageInputStream.readUTF()
javax.imageio.stream.ImageInputStreamImpl.readUTF()


Occurences of readXml

readXml occurences:
javax.sql.rowset.WebRowSet.readXml(java.io.InputStream)
javax.sql.rowset.WebRowSet.readXml(java.io.Reader)


Occurences of ready

ready occurences:
java.io.BufferedReader.ready()
java.io.CharArrayReader.ready()
java.io.FilterReader.ready()
java.io.InputStreamReader.ready()
java.io.PipedReader.ready()
java.io.PushbackReader.ready()
java.io.Reader.ready()
java.io.StringReader.ready()


Occurences of read_abstract_interface

read_abstract_interface occurences:
org.omg.CORBA_2_3.portable.InputStream.read_abstract_interface()
org.omg.CORBA_2_3.portable.InputStream.read_abstract_interface(java.lang.Class)


Occurences of read_any

read_any occurences:
org.omg.CORBA.DataInputStream.read_any()
org.omg.CORBA.portable.InputStream.read_any()


Occurences of read_boolean

read_boolean occurences:
org.omg.CORBA.DataInputStream.read_boolean()
org.omg.CORBA.portable.InputStream.read_boolean()


Occurences of read_boolean_array

read_boolean_array occurences:
org.omg.CORBA.DataInputStream.read_boolean_array(org.omg.CORBA.BooleanSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_boolean_array(boolean[], int, int)


Occurences of read_char

read_char occurences:
org.omg.CORBA.DataInputStream.read_char()
org.omg.CORBA.portable.InputStream.read_char()


Occurences of read_char_array

read_char_array occurences:
org.omg.CORBA.DataInputStream.read_char_array(org.omg.CORBA.CharSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_char_array(char[], int, int)


Occurences of read_double

read_double occurences:
org.omg.CORBA.DataInputStream.read_double()
org.omg.CORBA.portable.InputStream.read_double()


Occurences of read_double_array

read_double_array occurences:
org.omg.CORBA.DataInputStream.read_double_array(org.omg.CORBA.DoubleSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_double_array(double[], int, int)


Occurences of read_float

read_float occurences:
org.omg.CORBA.DataInputStream.read_float()
org.omg.CORBA.portable.InputStream.read_float()


Occurences of read_float_array

read_float_array occurences:
org.omg.CORBA.DataInputStream.read_float_array(org.omg.CORBA.FloatSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_float_array(float[], int, int)


Occurences of read_long

read_long occurences:
org.omg.CORBA.DataInputStream.read_long()
org.omg.CORBA.portable.InputStream.read_long()


Occurences of read_longlong

read_longlong occurences:
org.omg.CORBA.DataInputStream.read_longlong()
org.omg.CORBA.portable.InputStream.read_longlong()


Occurences of read_longlong_array

read_longlong_array occurences:
org.omg.CORBA.DataInputStream.read_longlong_array(org.omg.CORBA.LongLongSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_longlong_array(long[], int, int)


Occurences of read_long_array

read_long_array occurences:
org.omg.CORBA.DataInputStream.read_long_array(org.omg.CORBA.LongSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_long_array(int[], int, int)


Occurences of read_Object

read_Object occurences:
org.omg.CORBA.DataInputStream.read_Object()
org.omg.CORBA.portable.InputStream.read_Object()
org.omg.CORBA.portable.InputStream.read_Object(java.lang.Class)


Occurences of read_octet

read_octet occurences:
org.omg.CORBA.DataInputStream.read_octet()
org.omg.CORBA.portable.InputStream.read_octet()


Occurences of read_octet_array

read_octet_array occurences:
org.omg.CORBA.DataInputStream.read_octet_array(org.omg.CORBA.OctetSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_octet_array(byte[], int, int)


Occurences of read_short

read_short occurences:
org.omg.CORBA.DataInputStream.read_short()
org.omg.CORBA.portable.InputStream.read_short()


Occurences of read_short_array

read_short_array occurences:
org.omg.CORBA.DataInputStream.read_short_array(org.omg.CORBA.ShortSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_short_array(short[], int, int)


Occurences of read_string

read_string occurences:
org.omg.CORBA.DataInputStream.read_string()
org.omg.CORBA.portable.InputStream.read_string()


Occurences of read_TypeCode

read_TypeCode occurences:
org.omg.CORBA.DataInputStream.read_TypeCode()
org.omg.CORBA.portable.InputStream.read_TypeCode()


Occurences of read_ulong

read_ulong occurences:
org.omg.CORBA.DataInputStream.read_ulong()
org.omg.CORBA.portable.InputStream.read_ulong()


Occurences of read_ulonglong

read_ulonglong occurences:
org.omg.CORBA.DataInputStream.read_ulonglong()
org.omg.CORBA.portable.InputStream.read_ulonglong()


Occurences of read_ulonglong_array

read_ulonglong_array occurences:
org.omg.CORBA.DataInputStream.read_ulonglong_array(org.omg.CORBA.ULongLongSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_ulonglong_array(long[], int, int)


Occurences of read_ulong_array

read_ulong_array occurences:
org.omg.CORBA.DataInputStream.read_ulong_array(org.omg.CORBA.ULongSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_ulong_array(int[], int, int)


Occurences of read_ushort

read_ushort occurences:
org.omg.CORBA.DataInputStream.read_ushort()
org.omg.CORBA.portable.InputStream.read_ushort()


Occurences of read_ushort_array

read_ushort_array occurences:
org.omg.CORBA.DataInputStream.read_ushort_array(org.omg.CORBA.UShortSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_ushort_array(short[], int, int)


Occurences of read_value

read_value occurences:
org.omg.CORBA.Any.read_value(org.omg.CORBA.portable.InputStream, org.omg.CORBA.TypeCode)
org.omg.CORBA.portable.BoxedValueHelper.read_value(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.portable.ValueFactory.read_value(org.omg.CORBA_2_3.portable.InputStream)
org.omg.CORBA.StringValueHelper.read_value(org.omg.CORBA.portable.InputStream)
org.omg.CORBA.WStringValueHelper.read_value(org.omg.CORBA.portable.InputStream)
org.omg.CORBA_2_3.portable.InputStream.read_value()
org.omg.CORBA_2_3.portable.InputStream.read_value(java.io.Serializable)
org.omg.CORBA_2_3.portable.InputStream.read_value(java.lang.Class)
org.omg.CORBA_2_3.portable.InputStream.read_value(java.lang.String)
org.omg.CORBA_2_3.portable.InputStream.read_value(org.omg.CORBA.portable.BoxedValueHelper)


Occurences of read_wchar

read_wchar occurences:
org.omg.CORBA.DataInputStream.read_wchar()
org.omg.CORBA.portable.InputStream.read_wchar()


Occurences of read_wchar_array

read_wchar_array occurences:
org.omg.CORBA.DataInputStream.read_wchar_array(org.omg.CORBA.WCharSeqHolder, int, int)
org.omg.CORBA.portable.InputStream.read_wchar_array(char[], int, int)


Occurences of read_wstring

read_wstring occurences:
org.omg.CORBA.DataInputStream.read_wstring()
org.omg.CORBA.portable.InputStream.read_wstring()


Occurences of RealmCallback (constructors)

RealmCallback (constructors) occurences:
javax.security.sasl.RealmCallback(java.lang.String)
javax.security.sasl.RealmCallback(java.lang.String, java.lang.String)


Occurences of rebind

rebind occurences:
java.rmi.Naming.rebind(java.lang.String, java.rmi.Remote)
java.rmi.registry.Registry.rebind(java.lang.String, java.rmi.Remote)
javax.naming.Context.rebind(java.lang.String, java.lang.Object)
javax.naming.Context.rebind(javax.naming.Name, java.lang.Object)
javax.naming.directory.DirContext.rebind(java.lang.String, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.directory.DirContext.rebind(javax.naming.Name, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.rebind(java.lang.String, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.rebind(javax.naming.Name, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.InitialContext.rebind(java.lang.String, java.lang.Object)
javax.naming.InitialContext.rebind(javax.naming.Name, java.lang.Object)
org.omg.CosNaming.NamingContextOperations.rebind(org.omg.CosNaming.NameComponent[], org.omg.CORBA.Object)
org.omg.CosNaming._NamingContextExtStub.rebind(org.omg.CosNaming.NameComponent[], org.omg.CORBA.Object)
org.omg.CosNaming._NamingContextStub.rebind(org.omg.CosNaming.NameComponent[], org.omg.CORBA.Object)


Occurences of REBIND (constructors)

REBIND (constructors) occurences:
org.omg.CORBA.REBIND()
org.omg.CORBA.REBIND(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.REBIND(java.lang.String)
org.omg.CORBA.REBIND(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of rebind_context

rebind_context occurences:
org.omg.CosNaming.NamingContextOperations.rebind_context(org.omg.CosNaming.NameComponent[], org.omg.CosNaming.NamingContext)
org.omg.CosNaming._NamingContextExtStub.rebind_context(org.omg.CosNaming.NameComponent[], org.omg.CosNaming.NamingContext)
org.omg.CosNaming._NamingContextStub.rebind_context(org.omg.CosNaming.NameComponent[], org.omg.CosNaming.NamingContext)


Occurences of receive

receive occurences:
java.io.PipedInputStream.receive(int)
java.net.DatagramSocket.receive(java.net.DatagramPacket)
java.net.DatagramSocketImpl.receive(java.net.DatagramPacket)
java.nio.channels.DatagramChannel.receive(java.nio.ByteBuffer)


Occurences of reclaim

reclaim occurences:
javax.swing.text.AbstractDocument.AttributeContext.reclaim(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.reclaim(javax.swing.text.AttributeSet)


Occurences of reconnect

reconnect occurences:
javax.naming.ldap.InitialLdapContext.reconnect(javax.naming.ldap.Control[])
javax.naming.ldap.LdapContext.reconnect(javax.naming.ldap.Control[])


Occurences of reconvert

reconvert occurences:
java.awt.im.InputContext.reconvert()
java.awt.im.spi.InputMethod.reconvert()


Occurences of Rectangle (constructors)

Rectangle (constructors) occurences:
java.awt.Rectangle()
java.awt.Rectangle(int, int)
java.awt.Rectangle(int, int, int, int)
java.awt.Rectangle(java.awt.Dimension)
java.awt.Rectangle(java.awt.Point)
java.awt.Rectangle(java.awt.Point, java.awt.Dimension)
java.awt.Rectangle(java.awt.Rectangle)


Occurences of Rectangle2D.Double (constructors)

Rectangle2D.Double (constructors) occurences:
java.awt.geom.Rectangle2D.Double()
java.awt.geom.Rectangle2D.Double(double, double, double, double)


Occurences of Rectangle2D.Float (constructors)

Rectangle2D.Float (constructors) occurences:
java.awt.geom.Rectangle2D.Float()
java.awt.geom.Rectangle2D.Float(float, float, float, float)


Occurences of redefineClasses

redefineClasses occurences:
com.sun.jdi.VirtualMachine.redefineClasses(java.util.Map)
java.lang.instrument.Instrumentation.redefineClasses(java.lang.instrument.ClassDefinition...)


Occurences of redirectErrorStream

redirectErrorStream occurences:
java.lang.ProcessBuilder.redirectErrorStream()
java.lang.ProcessBuilder.redirectErrorStream(boolean)


Occurences of Redirection between HTTP URL and HTTPS URL is not followed.

Redirection between HTTP URL and HTTPS URL is not followed. occurences:
Redirection between HTTP URL and HTTPS URL is not followed.
Redirection between HTTP URL and HTTPS URL is not followed.


Occurences of redo

redo occurences:
javax.swing.text.AbstractDocument.DefaultDocumentEvent.redo()
javax.swing.text.AbstractDocument.ElementEdit.redo()
javax.swing.text.DefaultStyledDocument.AttributeUndoableEdit.redo()
javax.swing.undo.AbstractUndoableEdit.redo()
javax.swing.undo.CompoundEdit.redo()
javax.swing.undo.StateEdit.redo()
javax.swing.undo.UndoableEdit.redo()
javax.swing.undo.UndoManager.redo()


Occurences of reduce

reduce occurences:
com.sun.source.util.TreeScanner.reduce(java.lang.Object,java.lang.Object)
com.sun.source.util.TreeScanner.reduce(R, R)


Occurences of ReentrantLock (constructors)

ReentrantLock (constructors) occurences:
java.util.concurrent.locks.ReentrantLock()
java.util.concurrent.locks.ReentrantLock(boolean)


Occurences of ReentrantReadWriteLock (constructors)

ReentrantReadWriteLock (constructors) occurences:
java.util.concurrent.locks.ReentrantReadWriteLock()
java.util.concurrent.locks.ReentrantReadWriteLock(boolean)


Occurences of ref

ref occurences:
java.lang.ref
java.rmi.server.ref


Occurences of Reference

Reference occurences:
java.lang.ref.Reference
javax.naming.Reference
javax.xml.crypto.dsig.Reference
Reference


Occurences of Reference (constructors)

Reference (constructors) occurences:
javax.naming.Reference(java.lang.String)
javax.naming.Reference(java.lang.String, java.lang.String, java.lang.String)
javax.naming.Reference(java.lang.String, javax.naming.RefAddr)
javax.naming.Reference(java.lang.String, javax.naming.RefAddr, java.lang.String, java.lang.String)


Occurences of referenceType

referenceType occurences:
com.sun.jdi.event.ClassPrepareEvent.referenceType()
com.sun.jdi.ObjectReference.referenceType()


Occurences of ReferenceType

ReferenceType occurences:
com.sun.jdi.ReferenceType
com.sun.mirror.type.ReferenceType
javax.lang.model.type.ReferenceType


Occurences of ReferralException (constructors)

ReferralException (constructors) occurences:
javax.naming.ReferralException()
javax.naming.ReferralException(java.lang.String)


Occurences of ReflectionException (constructors)

ReflectionException (constructors) occurences:
javax.management.ReflectionException(java.lang.Exception)
javax.management.ReflectionException(java.lang.Exception, java.lang.String)


Occurences of ReflectPermission (constructors)

ReflectPermission (constructors) occurences:
java.lang.reflect.ReflectPermission(java.lang.String)
java.lang.reflect.ReflectPermission(java.lang.String, java.lang.String)


Occurences of refresh

refresh occurences:
java.security.Policy.refresh()
javax.security.auth.kerberos.KerberosTicket.refresh()
javax.security.auth.login.Configuration.refresh()
javax.security.auth.Policy.refresh()
javax.security.auth.Refreshable.refresh()


Occurences of RefreshFailedException (constructors)

RefreshFailedException (constructors) occurences:
javax.security.auth.RefreshFailedException()
javax.security.auth.RefreshFailedException(java.lang.String)


Occurences of regionMatches

regionMatches occurences:
java.lang.String.regionMatches(boolean, int, java.lang.String, int, int)
java.lang.String.regionMatches(int, java.lang.String, int, int)


Occurences of register

register occurences:
java.nio.channels.SelectableChannel.register(java.nio.channels.Selector, int)
java.nio.channels.SelectableChannel.register(java.nio.channels.Selector, int, java.lang.Object)
java.nio.channels.spi.AbstractSelectableChannel.register(java.nio.channels.Selector, int, java.lang.Object)
java.nio.channels.spi.AbstractSelector.register(java.nio.channels.spi.AbstractSelectableChannel, int, java.lang.Object)
java.rmi.activation.Activatable.register(java.rmi.activation.ActivationDesc)


Occurences of registerEditorKitForContentType

registerEditorKitForContentType occurences:
javax.swing.JEditorPane.registerEditorKitForContentType(java.lang.String, java.lang.String)
javax.swing.JEditorPane.registerEditorKitForContentType(java.lang.String, java.lang.String, java.lang.ClassLoader)


Occurences of registerKeyboardAction

registerKeyboardAction occurences:
javax.swing.JComponent.registerKeyboardAction(java.awt.event.ActionListener, java.lang.String, javax.swing.KeyStroke, int)
javax.swing.JComponent.registerKeyboardAction(java.awt.event.ActionListener, javax.swing.KeyStroke, int)


Occurences of registerListeners

registerListeners occurences:
java.awt.dnd.DragGestureRecognizer.registerListeners()
java.awt.dnd.MouseDragGestureRecognizer.registerListeners()


Occurences of registerOutParameter

registerOutParameter occurences:
java.sql.CallableStatement.registerOutParameter(int, int)
java.sql.CallableStatement.registerOutParameter(int, int, int)
java.sql.CallableStatement.registerOutParameter(int, int, java.lang.String)
java.sql.CallableStatement.registerOutParameter(java.lang.String, int)
java.sql.CallableStatement.registerOutParameter(java.lang.String, int, int)
java.sql.CallableStatement.registerOutParameter(java.lang.String, int, java.lang.String)


Occurences of registerServiceProvider

registerServiceProvider occurences:
javax.imageio.spi.ServiceRegistry.registerServiceProvider(java.lang.Object)
javax.imageio.spi.ServiceRegistry.registerServiceProvider(java.lang.Object,java.lang.Class)
javax.imageio.spi.ServiceRegistry.registerServiceProvider(T, java.lang.Class)
javax.print.PrintServiceLookup.registerServiceProvider(javax.print.PrintServiceLookup)


Occurences of registerTarget

registerTarget occurences:
javax.rmi.CORBA.Util.registerTarget(javax.rmi.CORBA.Tie, java.rmi.Remote)
javax.rmi.CORBA.UtilDelegate.registerTarget(javax.rmi.CORBA.Tie, java.rmi.Remote)


Occurences of rejectDrag

rejectDrag occurences:
java.awt.dnd.DropTargetContext.rejectDrag()
java.awt.dnd.DropTargetDragEvent.rejectDrag()


Occurences of rejectDrop

rejectDrop occurences:
java.awt.dnd.DropTargetContext.rejectDrop()
java.awt.dnd.DropTargetDropEvent.rejectDrop()


Occurences of rejectedExecution

rejectedExecution occurences:
java.util.concurrent.RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor)
java.util.concurrent.ThreadPoolExecutor.AbortPolicy.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor)
java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor)
java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor)
java.util.concurrent.ThreadPoolExecutor.DiscardPolicy.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor)


Occurences of RejectedExecutionException (constructors)

RejectedExecutionException (constructors) occurences:
java.util.concurrent.RejectedExecutionException()
java.util.concurrent.RejectedExecutionException(java.lang.String)
java.util.concurrent.RejectedExecutionException(java.lang.String, java.lang.Throwable)
java.util.concurrent.RejectedExecutionException(java.lang.Throwable)


Occurences of RelationException (constructors)

RelationException (constructors) occurences:
javax.management.relation.RelationException()
javax.management.relation.RelationException(java.lang.String)


Occurences of RelationNotFoundException (constructors)

RelationNotFoundException (constructors) occurences:
javax.management.relation.RelationNotFoundException()
javax.management.relation.RelationNotFoundException(java.lang.String)


Occurences of RelationNotification (constructors)

RelationNotification (constructors) occurences:
javax.management.relation.RelationNotification(java.lang.String, java.lang.Object, long, long, java.lang.String, java.lang.String, java.lang.String, javax.management.ObjectName, java.lang.String, java.util.List, java.util.List)
javax.management.relation.RelationNotification(java.lang.String, java.lang.Object, long, long, java.lang.String, java.lang.String, java.lang.String, javax.management.ObjectName, java.util.List)


Occurences of RelationServiceNotRegisteredException (constructors)

RelationServiceNotRegisteredException (constructors) occurences:
javax.management.relation.RelationServiceNotRegisteredException()
javax.management.relation.RelationServiceNotRegisteredException(java.lang.String)


Occurences of RelationSupport (constructors)

RelationSupport (constructors) occurences:
javax.management.relation.RelationSupport(java.lang.String, javax.management.ObjectName, java.lang.String, javax.management.relation.RoleList)
javax.management.relation.RelationSupport(java.lang.String, javax.management.ObjectName, javax.management.MBeanServer, java.lang.String, javax.management.relation.RoleList)


Occurences of RelationTypeNotFoundException (constructors)

RelationTypeNotFoundException (constructors) occurences:
javax.management.relation.RelationTypeNotFoundException()
javax.management.relation.RelationTypeNotFoundException(java.lang.String)


Occurences of RelationTypeSupport (constructors)

RelationTypeSupport (constructors) occurences:
javax.management.relation.RelationTypeSupport(java.lang.String)
javax.management.relation.RelationTypeSupport(java.lang.String, javax.management.relation.RoleInfo[])


Occurences of relativeCCW

relativeCCW occurences:
java.awt.geom.Line2D.relativeCCW(double, double)
java.awt.geom.Line2D.relativeCCW(double, double, double, double, double, double)
java.awt.geom.Line2D.relativeCCW(java.awt.geom.Point2D)


Occurences of release

release occurences:
java.nio.channels.FileLock.release()
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.release(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.release(int)
java.util.concurrent.Semaphore.release()
java.util.concurrent.Semaphore.release(int)
javax.sql.rowset.CachedRowSet.release()
org.omg.CORBA.portable.Delegate.release(org.omg.CORBA.Object)


Occurences of releaseBeanContextResources

releaseBeanContextResources occurences:
java.beans.beancontext.BeanContextChildSupport.releaseBeanContextResources()
java.beans.beancontext.BeanContextServicesSupport.releaseBeanContextResources()


Occurences of releaseService

releaseService occurences:
java.beans.beancontext.BeanContextServiceProvider.releaseService(java.beans.beancontext.BeanContextServices, java.lang.Object, java.lang.Object)
java.beans.beancontext.BeanContextServices.releaseService(java.beans.beancontext.BeanContextChild, java.lang.Object, java.lang.Object)
java.beans.beancontext.BeanContextServicesSupport.releaseService(java.beans.beancontext.BeanContextChild, java.lang.Object, java.lang.Object)
java.beans.beancontext.BeanContextServicesSupport.BCSSProxyServiceProvider.releaseService(java.beans.beancontext.BeanContextServices, java.lang.Object, java.lang.Object)


Occurences of releaseShared

releaseShared occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.releaseShared(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.releaseShared(int)


Occurences of releaseWritableTile

releaseWritableTile occurences:
java.awt.image.BufferedImage.releaseWritableTile(int, int)
java.awt.image.WritableRenderedImage.releaseWritableTile(int, int)


Occurences of reload

reload occurences:
java.util.ServiceLoader.reload()
javax.swing.tree.DefaultTreeModel.reload()
javax.swing.tree.DefaultTreeModel.reload(javax.swing.tree.TreeNode)


Occurences of remainder

remainder occurences:
java.math.BigDecimal.remainder(java.math.BigDecimal)
java.math.BigDecimal.remainder(java.math.BigDecimal, java.math.MathContext)
java.math.BigInteger.remainder(java.math.BigInteger)


Occurences of REMAINDER

REMAINDER occurences:
com.sun.source.tree.REMAINDER
java.awt.REMAINDER


Occurences of remainingCapacity

remainingCapacity occurences:
java.util.concurrent.ArrayBlockingQueue.remainingCapacity()
java.util.concurrent.BlockingQueue.remainingCapacity()
java.util.concurrent.DelayQueue.remainingCapacity()
java.util.concurrent.LinkedBlockingDeque.remainingCapacity()
java.util.concurrent.LinkedBlockingQueue.remainingCapacity()
java.util.concurrent.PriorityBlockingQueue.remainingCapacity()
java.util.concurrent.SynchronousQueue.remainingCapacity()


Occurences of remainingName

remainingName occurences:
javax.naming.remainingName
javax.naming.spi.remainingName


Occurences of RemoteException (constructors)

RemoteException (constructors) occurences:
java.rmi.RemoteException()
java.rmi.RemoteException(java.lang.String)
java.rmi.RemoteException(java.lang.String, java.lang.Throwable)


Occurences of RemoteObject (constructors)

RemoteObject (constructors) occurences:
java.rmi.server.RemoteObject()
java.rmi.server.RemoteObject(java.rmi.server.RemoteRef)


Occurences of RemoteServer (constructors)

RemoteServer (constructors) occurences:
java.rmi.server.RemoteServer()
java.rmi.server.RemoteServer(java.rmi.server.RemoteRef)


Occurences of RemoteStub (constructors)

RemoteStub (constructors) occurences:
java.rmi.server.RemoteStub()
java.rmi.server.RemoteStub(java.rmi.server.RemoteRef)


Occurences of remove

remove occurences:
com.sun.jdi.event.EventQueue.remove()
com.sun.jdi.event.EventQueue.remove(long)
java.awt.AWTEventMulticaster.remove(java.awt.event.ActionListener, java.awt.event.ActionListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.AdjustmentListener, java.awt.event.AdjustmentListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.ComponentListener, java.awt.event.ComponentListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.ContainerListener, java.awt.event.ContainerListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.FocusListener, java.awt.event.FocusListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.HierarchyBoundsListener, java.awt.event.HierarchyBoundsListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.HierarchyListener, java.awt.event.HierarchyListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.InputMethodListener, java.awt.event.InputMethodListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.ItemListener, java.awt.event.ItemListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.KeyListener, java.awt.event.KeyListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.MouseListener, java.awt.event.MouseListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.MouseMotionListener, java.awt.event.MouseMotionListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.MouseWheelListener, java.awt.event.MouseWheelListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.TextListener, java.awt.event.TextListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.WindowFocusListener, java.awt.event.WindowFocusListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.WindowListener, java.awt.event.WindowListener)
java.awt.AWTEventMulticaster.remove(java.awt.event.WindowStateListener, java.awt.event.WindowStateListener)
java.awt.AWTEventMulticaster.remove(java.util.EventListener)
java.awt.Choice.remove(int)
java.awt.Choice.remove(java.lang.String)
java.awt.Component.remove(java.awt.MenuComponent)
java.awt.Container.remove(int)
java.awt.Container.remove(java.awt.Component)
java.awt.Frame.remove(java.awt.MenuComponent)
java.awt.List.remove(int)
java.awt.List.remove(java.lang.String)
java.awt.Menu.remove(int)
java.awt.Menu.remove(java.awt.MenuComponent)
java.awt.MenuBar.remove(int)
java.awt.MenuBar.remove(java.awt.MenuComponent)
java.awt.MenuContainer.remove(java.awt.MenuComponent)
java.awt.RenderingHints.remove(java.lang.Object)
java.awt.SystemTray.remove(java.awt.TrayIcon)
java.beans.beancontext.BeanContextSupport.remove(java.lang.Object)
java.beans.beancontext.BeanContextSupport.remove(java.lang.Object, boolean)
java.beans.beancontext.BeanContextSupport.BCSIterator.remove()
java.beans.Encoder.remove(java.lang.Object)
java.lang.ref.ReferenceQueue.remove()
java.lang.ref.ReferenceQueue.remove(long)
java.lang.ThreadLocal.remove()
java.net.CookieStore.remove(java.net.URI, java.net.HttpCookie)
java.security.Provider.remove(java.lang.Object)
java.util.AbstractCollection.remove(java.lang.Object)
java.util.AbstractList.remove(int)
java.util.AbstractMap.remove(java.lang.Object)
java.util.AbstractQueue.remove()
java.util.AbstractSequentialList.remove(int)
java.util.ArrayDeque.remove()
java.util.ArrayDeque.remove(java.lang.Object)
java.util.ArrayList.remove(int)
java.util.ArrayList.remove(java.lang.Object)
java.util.Collection.remove(java.lang.Object)
java.util.concurrent.ArrayBlockingQueue.remove(java.lang.Object)
java.util.concurrent.BlockingDeque.remove()
java.util.concurrent.BlockingDeque.remove(java.lang.Object)
java.util.concurrent.BlockingQueue.remove(java.lang.Object)
java.util.concurrent.ConcurrentHashMap.remove(java.lang.Object)
java.util.concurrent.ConcurrentHashMap.remove(java.lang.Object, java.lang.Object)
java.util.concurrent.ConcurrentLinkedQueue.remove(java.lang.Object)
java.util.concurrent.ConcurrentMap.remove(java.lang.Object, java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.remove(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.remove(java.lang.Object, java.lang.Object)
java.util.concurrent.ConcurrentSkipListSet.remove(java.lang.Object)
java.util.concurrent.CopyOnWriteArrayList.remove(int)
java.util.concurrent.CopyOnWriteArrayList.remove(java.lang.Object)
java.util.concurrent.CopyOnWriteArraySet.remove(java.lang.Object)
java.util.concurrent.DelayQueue.remove(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.remove()
java.util.concurrent.LinkedBlockingDeque.remove(java.lang.Object)
java.util.concurrent.LinkedBlockingQueue.remove(java.lang.Object)
java.util.concurrent.PriorityBlockingQueue.remove(java.lang.Object)
java.util.concurrent.ScheduledThreadPoolExecutor.remove(java.lang.Runnable)
java.util.concurrent.SynchronousQueue.remove(java.lang.Object)
java.util.concurrent.ThreadPoolExecutor.remove(java.lang.Runnable)
java.util.Deque.remove()
java.util.Deque.remove(java.lang.Object)
java.util.Dictionary.remove(java.lang.Object)
java.util.EnumMap.remove(java.lang.Object)
java.util.HashMap.remove(java.lang.Object)
java.util.HashSet.remove(java.lang.Object)
java.util.Hashtable.remove(java.lang.Object)
java.util.IdentityHashMap.remove(java.lang.Object)
java.util.Iterator.remove()
java.util.jar.Attributes.remove(java.lang.Object)
java.util.LinkedList.remove()
java.util.LinkedList.remove(int)
java.util.LinkedList.remove(java.lang.Object)
java.util.List.remove(int)
java.util.List.remove(java.lang.Object)
java.util.ListIterator.remove()
java.util.Map.remove(java.lang.Object)
java.util.prefs.AbstractPreferences.remove(java.lang.String)
java.util.prefs.Preferences.remove(java.lang.String)
java.util.PriorityQueue.remove(java.lang.Object)
java.util.Queue.remove()
java.util.Scanner.remove()
java.util.Set.remove(java.lang.Object)
java.util.TreeMap.remove(java.lang.Object)
java.util.TreeSet.remove(java.lang.Object)
java.util.Vector.remove(int)
java.util.Vector.remove(java.lang.Object)
java.util.WeakHashMap.remove(java.lang.Object)
javax.accessibility.AccessibleRelationSet.remove(javax.accessibility.AccessibleRelation)
javax.accessibility.AccessibleStateSet.remove(javax.accessibility.AccessibleState)
javax.activation.MimeTypeParameterList.remove(java.lang.String)
javax.management.openmbean.TabularData.remove(java.lang.Object[])
javax.management.openmbean.TabularDataSupport.remove(java.lang.Object)
javax.management.openmbean.TabularDataSupport.remove(java.lang.Object[])
javax.naming.CompositeName.remove(int)
javax.naming.CompoundName.remove(int)
javax.naming.directory.Attribute.remove(int)
javax.naming.directory.Attribute.remove(java.lang.Object)
javax.naming.directory.Attributes.remove(java.lang.String)
javax.naming.directory.BasicAttribute.remove(int)
javax.naming.directory.BasicAttribute.remove(java.lang.Object)
javax.naming.directory.BasicAttributes.remove(java.lang.String)
javax.naming.ldap.LdapName.remove(int)
javax.naming.Name.remove(int)
javax.naming.Reference.remove(int)
javax.print.attribute.AttributeSet.remove(java.lang.Class)
javax.print.attribute.AttributeSet.remove(javax.print.attribute.Attribute)
javax.print.attribute.HashAttributeSet.remove(java.lang.Class)
javax.print.attribute.HashAttributeSet.remove(javax.print.attribute.Attribute)
javax.script.Bindings.remove(java.lang.Object)
javax.script.SimpleBindings.remove(java.lang.Object)
javax.sound.midi.Track.remove(javax.sound.midi.MidiEvent)
javax.swing.ActionMap.remove(java.lang.Object)
javax.swing.ButtonGroup.remove(javax.swing.AbstractButton)
javax.swing.ComponentInputMap.remove(javax.swing.KeyStroke)
javax.swing.DefaultListModel.remove(int)
javax.swing.event.EventListenerList.remove(java.lang.Class, T)
javax.swing.event.EventListenerList.remove(java.lang.Class,java.util.EventListener)
javax.swing.InputMap.remove(javax.swing.KeyStroke)
javax.swing.JApplet.remove(java.awt.Component)
javax.swing.JDesktopPane.remove(int)
javax.swing.JDialog.remove(java.awt.Component)
javax.swing.JFrame.remove(java.awt.Component)
javax.swing.JInternalFrame.remove(java.awt.Component)
javax.swing.JLayeredPane.remove(int)
javax.swing.JMenu.remove(int)
javax.swing.JMenu.remove(java.awt.Component)
javax.swing.JMenu.remove(javax.swing.JMenuItem)
javax.swing.JPopupMenu.remove(int)
javax.swing.JSplitPane.remove(int)
javax.swing.JSplitPane.remove(java.awt.Component)
javax.swing.JTabbedPane.remove(int)
javax.swing.JTabbedPane.remove(java.awt.Component)
javax.swing.JViewport.remove(java.awt.Component)
javax.swing.JWindow.remove(java.awt.Component)
javax.swing.text.AbstractDocument.remove(int, int)
javax.swing.text.AbstractDocument.Content.remove(int, int)
javax.swing.text.DefaultStyledDocument.ElementBuffer.remove(int, int, javax.swing.text.AbstractDocument.DefaultDocumentEvent)
javax.swing.text.Document.remove(int, int)
javax.swing.text.DocumentFilter.remove(javax.swing.text.DocumentFilter.FilterBypass, int, int)
javax.swing.text.DocumentFilter.FilterBypass.remove(int, int)
javax.swing.text.GapContent.remove(int, int)
javax.swing.text.StringContent.remove(int, int)
javax.swing.text.View.remove(int)
javax.swing.tree.DefaultMutableTreeNode.remove(int)
javax.swing.tree.DefaultMutableTreeNode.remove(javax.swing.tree.MutableTreeNode)
javax.swing.tree.MutableTreeNode.remove(int)
javax.swing.tree.MutableTreeNode.remove(javax.swing.tree.MutableTreeNode)
javax.xml.stream.util.EventReaderDelegate.remove()
org.omg.CORBA.ContextList.remove(int)
org.omg.CORBA.ExceptionList.remove(int)
org.omg.CORBA.NVList.remove(int)


Occurences of removeAccessibleSelection

removeAccessibleSelection occurences:
java.awt.List.AccessibleAWTList.removeAccessibleSelection(int)
java.awt.MenuComponent.AccessibleAWTMenuComponent.removeAccessibleSelection(int)
javax.accessibility.AccessibleSelection.removeAccessibleSelection(int)
javax.swing.JComboBox.AccessibleJComboBox.removeAccessibleSelection(int)
javax.swing.JList.AccessibleJList.removeAccessibleSelection(int)
javax.swing.JMenu.AccessibleJMenu.removeAccessibleSelection(int)
javax.swing.JMenuBar.AccessibleJMenuBar.removeAccessibleSelection(int)
javax.swing.JTabbedPane.AccessibleJTabbedPane.removeAccessibleSelection(int)
javax.swing.JTable.AccessibleJTable.removeAccessibleSelection(int)
javax.swing.JTree.AccessibleJTree.removeAccessibleSelection(int)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.removeAccessibleSelection(int)


Occurences of removeActionListener

removeActionListener occurences:
java.awt.Button.removeActionListener(java.awt.event.ActionListener)
java.awt.List.removeActionListener(java.awt.event.ActionListener)
java.awt.MenuItem.removeActionListener(java.awt.event.ActionListener)
java.awt.TextField.removeActionListener(java.awt.event.ActionListener)
java.awt.TrayIcon.removeActionListener(java.awt.event.ActionListener)
javax.swing.AbstractButton.removeActionListener(java.awt.event.ActionListener)
javax.swing.ButtonModel.removeActionListener(java.awt.event.ActionListener)
javax.swing.ComboBoxEditor.removeActionListener(java.awt.event.ActionListener)
javax.swing.DefaultButtonModel.removeActionListener(java.awt.event.ActionListener)
javax.swing.JComboBox.removeActionListener(java.awt.event.ActionListener)
javax.swing.JFileChooser.removeActionListener(java.awt.event.ActionListener)
javax.swing.JTextField.removeActionListener(java.awt.event.ActionListener)
javax.swing.plaf.basic.BasicComboBoxEditor.removeActionListener(java.awt.event.ActionListener)
javax.swing.Timer.removeActionListener(java.awt.event.ActionListener)


Occurences of removeAdjustmentListener

removeAdjustmentListener occurences:
java.awt.Adjustable.removeAdjustmentListener(java.awt.event.AdjustmentListener)
java.awt.Scrollbar.removeAdjustmentListener(java.awt.event.AdjustmentListener)
java.awt.ScrollPaneAdjustable.removeAdjustmentListener(java.awt.event.AdjustmentListener)
javax.swing.JScrollBar.removeAdjustmentListener(java.awt.event.AdjustmentListener)


Occurences of removeAll

removeAll occurences:
java.awt.Choice.removeAll()
java.awt.Container.removeAll()
java.awt.List.removeAll()
java.awt.Menu.removeAll()
java.beans.beancontext.BeanContextSupport.removeAll(java.util.Collection)
java.net.CookieStore.removeAll()
java.util.AbstractCollection.removeAll(java.util.Collection)
java.util.AbstractSet.removeAll(java.util.Collection)
java.util.Collection.removeAll(java.util.Collection)
java.util.concurrent.ConcurrentSkipListSet.removeAll(java.util.Collection)
java.util.concurrent.CopyOnWriteArrayList.removeAll(java.util.Collection)
java.util.concurrent.CopyOnWriteArraySet.removeAll(java.util.Collection)
java.util.concurrent.SynchronousQueue.removeAll(java.util.Collection)
java.util.List.removeAll(java.util.Collection)
java.util.Set.removeAll(java.util.Collection)
java.util.Vector.removeAll(java.util.Collection)
javax.swing.JDesktopPane.removeAll()
javax.swing.JLayeredPane.removeAll()
javax.swing.JMenu.removeAll()
javax.swing.JSplitPane.removeAll()
javax.swing.JTabbedPane.removeAll()
javax.swing.text.View.removeAll()


Occurences of removeAllElements

removeAllElements occurences:
java.util.Vector.removeAllElements()
javax.swing.DefaultComboBoxModel.removeAllElements()
javax.swing.DefaultListModel.removeAllElements()


Occurences of removeAllHighlights

removeAllHighlights occurences:
javax.swing.text.DefaultHighlighter.removeAllHighlights()
javax.swing.text.Highlighter.removeAllHighlights()


Occurences of removeAllMimeHeaders

removeAllMimeHeaders occurences:
javax.xml.soap.AttachmentPart.removeAllMimeHeaders()
javax.xml.soap.SOAPPart.removeAllMimeHeaders()


Occurences of removeAllNotifications

removeAllNotifications occurences:
javax.management.timer.Timer.removeAllNotifications()
javax.management.timer.TimerMBean.removeAllNotifications()


Occurences of removeAttribute

removeAttribute occurences:
javax.imageio.metadata.IIOMetadataFormatImpl.removeAttribute(java.lang.String, java.lang.String)
javax.imageio.metadata.IIOMetadataNode.removeAttribute(java.lang.String)
javax.script.ScriptContext.removeAttribute(java.lang.String, int)
javax.script.SimpleScriptContext.removeAttribute(java.lang.String, int)
javax.swing.text.AbstractDocument.AbstractElement.removeAttribute(java.lang.Object)
javax.swing.text.AbstractDocument.AttributeContext.removeAttribute(javax.swing.text.AttributeSet, java.lang.Object)
javax.swing.text.html.StyleSheet.removeAttribute(javax.swing.text.AttributeSet, java.lang.Object)
javax.swing.text.MutableAttributeSet.removeAttribute(java.lang.Object)
javax.swing.text.SimpleAttributeSet.removeAttribute(java.lang.Object)
javax.swing.text.StyleContext.removeAttribute(javax.swing.text.AttributeSet, java.lang.Object)
javax.swing.text.StyleContext.NamedStyle.removeAttribute(java.lang.Object)
javax.xml.soap.SOAPElement.removeAttribute(javax.xml.namespace.QName)
javax.xml.soap.SOAPElement.removeAttribute(javax.xml.soap.Name)
org.w3c.dom.Element.removeAttribute(java.lang.String)
org.xml.sax.ext.Attributes2Impl.removeAttribute(int)
org.xml.sax.helpers.AttributeListImpl.removeAttribute(java.lang.String)
org.xml.sax.helpers.AttributesImpl.removeAttribute(int)


Occurences of removeAttributeChangeNotificationListener

removeAttributeChangeNotificationListener occurences:
javax.management.modelmbean.ModelMBeanNotificationBroadcaster.removeAttributeChangeNotificationListener(javax.management.NotificationListener, java.lang.String)
javax.management.modelmbean.RequiredModelMBean.removeAttributeChangeNotificationListener(javax.management.NotificationListener, java.lang.String)


Occurences of removeAttributeNode

removeAttributeNode occurences:
javax.imageio.metadata.IIOMetadataNode.removeAttributeNode(org.w3c.dom.Attr)
org.w3c.dom.Element.removeAttributeNode(org.w3c.dom.Attr)


Occurences of removeAttributeNS

removeAttributeNS occurences:
javax.imageio.metadata.IIOMetadataNode.removeAttributeNS(java.lang.String, java.lang.String)
org.w3c.dom.Element.removeAttributeNS(java.lang.String, java.lang.String)


Occurences of removeAttributes

removeAttributes occurences:
javax.swing.text.AbstractDocument.AbstractElement.removeAttributes(java.util.Enumeration)
javax.swing.text.AbstractDocument.AbstractElement.removeAttributes(javax.swing.text.AttributeSet)
javax.swing.text.AbstractDocument.AttributeContext.removeAttributes(javax.swing.text.AttributeSet, java.util.Enumeration)
javax.swing.text.AbstractDocument.AttributeContext.removeAttributes(javax.swing.text.AttributeSet, javax.swing.text.AttributeSet)
javax.swing.text.html.StyleSheet.removeAttributes(javax.swing.text.AttributeSet, java.util.Enumeration)
javax.swing.text.html.StyleSheet.removeAttributes(javax.swing.text.AttributeSet, javax.swing.text.AttributeSet)
javax.swing.text.MutableAttributeSet.removeAttributes(java.util.Enumeration)
javax.swing.text.MutableAttributeSet.removeAttributes(javax.swing.text.AttributeSet)
javax.swing.text.SimpleAttributeSet.removeAttributes(java.util.Enumeration)
javax.swing.text.SimpleAttributeSet.removeAttributes(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.removeAttributes(javax.swing.text.AttributeSet, java.util.Enumeration)
javax.swing.text.StyleContext.removeAttributes(javax.swing.text.AttributeSet, javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.NamedStyle.removeAttributes(java.util.Enumeration)
javax.swing.text.StyleContext.NamedStyle.removeAttributes(javax.swing.text.AttributeSet)


Occurences of removeBeanContextMembershipListener

removeBeanContextMembershipListener occurences:
java.beans.beancontext.BeanContext.removeBeanContextMembershipListener(java.beans.beancontext.BeanContextMembershipListener)
java.beans.beancontext.BeanContextSupport.removeBeanContextMembershipListener(java.beans.beancontext.BeanContextMembershipListener)


Occurences of removeBeanContextServicesListener

removeBeanContextServicesListener occurences:
java.beans.beancontext.BeanContextServices.removeBeanContextServicesListener(java.beans.beancontext.BeanContextServicesListener)
java.beans.beancontext.BeanContextServicesSupport.removeBeanContextServicesListener(java.beans.beancontext.BeanContextServicesListener)


Occurences of removeCellEditorListener

removeCellEditorListener occurences:
javax.swing.AbstractCellEditor.removeCellEditorListener(javax.swing.event.CellEditorListener)
javax.swing.CellEditor.removeCellEditorListener(javax.swing.event.CellEditorListener)
javax.swing.tree.DefaultTreeCellEditor.removeCellEditorListener(javax.swing.event.CellEditorListener)


Occurences of removeChangeListener

removeChangeListener occurences:
javax.swing.AbstractButton.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.AbstractSpinnerModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.BoundedRangeModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.ButtonModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.colorchooser.ColorSelectionModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.colorchooser.DefaultColorSelectionModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.DefaultBoundedRangeModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.DefaultButtonModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.DefaultSingleSelectionModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.JProgressBar.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.JSlider.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.JSpinner.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.JTabbedPane.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.JViewport.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.MenuSelectionManager.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.SingleSelectionModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.SpinnerModel.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.Caret.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.DefaultCaret.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.Style.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.StyleContext.removeChangeListener(javax.swing.event.ChangeListener)
javax.swing.text.StyleContext.NamedStyle.removeChangeListener(javax.swing.event.ChangeListener)


Occurences of removeChild

removeChild occurences:
javax.imageio.metadata.IIOMetadataNode.removeChild(org.w3c.dom.Node)
org.w3c.dom.Node.removeChild(org.w3c.dom.Node)


Occurences of removeColumn

removeColumn occurences:
javax.swing.JTable.removeColumn(javax.swing.table.TableColumn)
javax.swing.table.DefaultTableColumnModel.removeColumn(javax.swing.table.TableColumn)
javax.swing.table.TableColumnModel.removeColumn(javax.swing.table.TableColumn)


Occurences of removeColumnModelListener

removeColumnModelListener occurences:
javax.swing.table.DefaultTableColumnModel.removeColumnModelListener(javax.swing.event.TableColumnModelListener)
javax.swing.table.TableColumnModel.removeColumnModelListener(javax.swing.event.TableColumnModelListener)


Occurences of removeConnectionNotificationListener

removeConnectionNotificationListener occurences:
javax.management.remote.JMXConnector.removeConnectionNotificationListener(javax.management.NotificationListener)
javax.management.remote.JMXConnector.removeConnectionNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.remote.rmi.RMIConnector.removeConnectionNotificationListener(javax.management.NotificationListener)
javax.management.remote.rmi.RMIConnector.removeConnectionNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)


Occurences of removeConsumer

removeConsumer occurences:
java.awt.image.FilteredImageSource.removeConsumer(java.awt.image.ImageConsumer)
java.awt.image.ImageProducer.removeConsumer(java.awt.image.ImageConsumer)
java.awt.image.MemoryImageSource.removeConsumer(java.awt.image.ImageConsumer)
java.awt.image.renderable.RenderableImageProducer.removeConsumer(java.awt.image.ImageConsumer)


Occurences of removeDocumentListener

removeDocumentListener occurences:
javax.swing.text.AbstractDocument.removeDocumentListener(javax.swing.event.DocumentListener)
javax.swing.text.DefaultStyledDocument.removeDocumentListener(javax.swing.event.DocumentListener)
javax.swing.text.Document.removeDocumentListener(javax.swing.event.DocumentListener)


Occurences of removeDragSourceListener

removeDragSourceListener occurences:
java.awt.dnd.DragSource.removeDragSourceListener(java.awt.dnd.DragSourceListener)
java.awt.dnd.DragSourceContext.removeDragSourceListener(java.awt.dnd.DragSourceListener)


Occurences of removeEditor

removeEditor occurences:
javax.swing.JTable.removeEditor()
javax.swing.plaf.basic.BasicComboBoxUI.removeEditor()


Occurences of removeElement

removeElement occurences:
java.util.Vector.removeElement(java.lang.Object)
javax.imageio.metadata.IIOMetadataFormatImpl.removeElement(java.lang.String)
javax.swing.DefaultComboBoxModel.removeElement(java.lang.Object)
javax.swing.DefaultListModel.removeElement(java.lang.Object)
javax.swing.MutableComboBoxModel.removeElement(java.lang.Object)


Occurences of removeElementAt

removeElementAt occurences:
java.util.Vector.removeElementAt(int)
javax.swing.DefaultComboBoxModel.removeElementAt(int)
javax.swing.DefaultListModel.removeElementAt(int)
javax.swing.MutableComboBoxModel.removeElementAt(int)


Occurences of removeField

removeField occurences:
javax.management.Descriptor.removeField(java.lang.String)
javax.management.ImmutableDescriptor.removeField(java.lang.String)
javax.management.modelmbean.DescriptorSupport.removeField(java.lang.String)


Occurences of removeFirst

removeFirst occurences:
java.util.ArrayDeque.removeFirst()
java.util.concurrent.LinkedBlockingDeque.removeFirst()
java.util.Deque.removeFirst()
java.util.LinkedList.removeFirst()


Occurences of removeFirstOccurrence

removeFirstOccurrence occurences:
java.util.ArrayDeque.removeFirstOccurrence(java.lang.Object)
java.util.concurrent.BlockingDeque.removeFirstOccurrence(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.removeFirstOccurrence(java.lang.Object)
java.util.Deque.removeFirstOccurrence(java.lang.Object)
java.util.LinkedList.removeFirstOccurrence(java.lang.Object)


Occurences of removeFocusListener

removeFocusListener occurences:
java.awt.Component.removeFocusListener(java.awt.event.FocusListener)
java.awt.Component.AccessibleAWTComponent.removeFocusListener(java.awt.event.FocusListener)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.removeFocusListener(java.awt.event.FocusListener)
java.awt.MenuComponent.AccessibleAWTMenuComponent.removeFocusListener(java.awt.event.FocusListener)
javax.accessibility.AccessibleComponent.removeFocusListener(java.awt.event.FocusListener)
javax.swing.JList.AccessibleJList.AccessibleJListChild.removeFocusListener(java.awt.event.FocusListener)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.removeFocusListener(java.awt.event.FocusListener)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.removeFocusListener(java.awt.event.FocusListener)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.removeFocusListener(java.awt.event.FocusListener)


Occurences of removeFromEnvironment

removeFromEnvironment occurences:
javax.naming.Context.removeFromEnvironment(java.lang.String)
javax.naming.InitialContext.removeFromEnvironment(java.lang.String)


Occurences of removeFromParent

removeFromParent occurences:
javax.swing.tree.DefaultMutableTreeNode.removeFromParent()
javax.swing.tree.MutableTreeNode.removeFromParent()


Occurences of removeHighlight

removeHighlight occurences:
javax.swing.text.DefaultHighlighter.removeHighlight(java.lang.Object)
javax.swing.text.Highlighter.removeHighlight(java.lang.Object)


Occurences of removeImage

removeImage occurences:
java.awt.MediaTracker.removeImage(java.awt.Image)
java.awt.MediaTracker.removeImage(java.awt.Image, int)
java.awt.MediaTracker.removeImage(java.awt.Image, int, int, int)
javax.imageio.ImageWriter.removeImage(int)


Occurences of removeIndexInterval

removeIndexInterval occurences:
javax.swing.DefaultListSelectionModel.removeIndexInterval(int, int)
javax.swing.ListSelectionModel.removeIndexInterval(int, int)


Occurences of removeItemListener

removeItemListener occurences:
java.awt.Checkbox.removeItemListener(java.awt.event.ItemListener)
java.awt.CheckboxMenuItem.removeItemListener(java.awt.event.ItemListener)
java.awt.Choice.removeItemListener(java.awt.event.ItemListener)
java.awt.ItemSelectable.removeItemListener(java.awt.event.ItemListener)
java.awt.List.removeItemListener(java.awt.event.ItemListener)
javax.swing.AbstractButton.removeItemListener(java.awt.event.ItemListener)
javax.swing.ButtonModel.removeItemListener(java.awt.event.ItemListener)
javax.swing.DefaultButtonModel.removeItemListener(java.awt.event.ItemListener)
javax.swing.JComboBox.removeItemListener(java.awt.event.ItemListener)


Occurences of removeLast

removeLast occurences:
java.util.ArrayDeque.removeLast()
java.util.concurrent.LinkedBlockingDeque.removeLast()
java.util.Deque.removeLast()
java.util.LinkedList.removeLast()


Occurences of removeLastOccurrence

removeLastOccurrence occurences:
java.util.ArrayDeque.removeLastOccurrence(java.lang.Object)
java.util.concurrent.BlockingDeque.removeLastOccurrence(java.lang.Object)
java.util.concurrent.LinkedBlockingDeque.removeLastOccurrence(java.lang.Object)
java.util.Deque.removeLastOccurrence(java.lang.Object)
java.util.LinkedList.removeLastOccurrence(java.lang.Object)


Occurences of removeLayoutComponent

removeLayoutComponent occurences:
java.awt.BorderLayout.removeLayoutComponent(java.awt.Component)
java.awt.CardLayout.removeLayoutComponent(java.awt.Component)
java.awt.FlowLayout.removeLayoutComponent(java.awt.Component)
java.awt.GridBagLayout.removeLayoutComponent(java.awt.Component)
java.awt.GridLayout.removeLayoutComponent(java.awt.Component)
java.awt.LayoutManager.removeLayoutComponent(java.awt.Component)
javax.swing.BoxLayout.removeLayoutComponent(java.awt.Component)
javax.swing.GroupLayout.removeLayoutComponent(java.awt.Component)
javax.swing.JRootPane.RootLayout.removeLayoutComponent(java.awt.Component)
javax.swing.JSpinner.DefaultEditor.removeLayoutComponent(java.awt.Component)
javax.swing.OverlayLayout.removeLayoutComponent(java.awt.Component)
javax.swing.plaf.basic.BasicComboBoxUI.ComboBoxLayoutManager.removeLayoutComponent(java.awt.Component)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.TitlePaneLayout.removeLayoutComponent(java.awt.Component)
javax.swing.plaf.basic.BasicInternalFrameUI.InternalFrameLayout.removeLayoutComponent(java.awt.Component)
javax.swing.plaf.basic.BasicOptionPaneUI.ButtonAreaLayout.removeLayoutComponent(java.awt.Component)
javax.swing.plaf.basic.BasicScrollBarUI.removeLayoutComponent(java.awt.Component)
javax.swing.plaf.basic.BasicSplitPaneDivider.DividerLayout.removeLayoutComponent(java.awt.Component)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.removeLayoutComponent(java.awt.Component)
javax.swing.plaf.basic.BasicTabbedPaneUI.TabbedPaneLayout.removeLayoutComponent(java.awt.Component)
javax.swing.ScrollPaneLayout.removeLayoutComponent(java.awt.Component)
javax.swing.SpringLayout.removeLayoutComponent(java.awt.Component)
javax.swing.ViewportLayout.removeLayoutComponent(java.awt.Component)


Occurences of removeListDataListener

removeListDataListener occurences:
javax.swing.AbstractListModel.removeListDataListener(javax.swing.event.ListDataListener)
javax.swing.ListModel.removeListDataListener(javax.swing.event.ListDataListener)


Occurences of removeListSelectionListener

removeListSelectionListener occurences:
javax.swing.DefaultListSelectionModel.removeListSelectionListener(javax.swing.event.ListSelectionListener)
javax.swing.JList.removeListSelectionListener(javax.swing.event.ListSelectionListener)
javax.swing.ListSelectionModel.removeListSelectionListener(javax.swing.event.ListSelectionListener)


Occurences of removeMenuKeyListener

removeMenuKeyListener occurences:
javax.swing.JMenuItem.removeMenuKeyListener(javax.swing.event.MenuKeyListener)
javax.swing.JPopupMenu.removeMenuKeyListener(javax.swing.event.MenuKeyListener)


Occurences of removeMimeHeader

removeMimeHeader occurences:
javax.xml.soap.AttachmentPart.removeMimeHeader(java.lang.String)
javax.xml.soap.SOAPPart.removeMimeHeader(java.lang.String)


Occurences of removeMouseListener

removeMouseListener occurences:
java.awt.Component.removeMouseListener(java.awt.event.MouseListener)
java.awt.TrayIcon.removeMouseListener(java.awt.event.MouseListener)


Occurences of removeMouseMotionListener

removeMouseMotionListener occurences:
java.awt.Component.removeMouseMotionListener(java.awt.event.MouseMotionListener)
java.awt.TrayIcon.removeMouseMotionListener(java.awt.event.MouseMotionListener)


Occurences of removeNode

removeNode occurences:
java.util.prefs.AbstractPreferences.removeNode()
java.util.prefs.Preferences.removeNode()


Occurences of removeNodeChangeListener

removeNodeChangeListener occurences:
java.util.prefs.AbstractPreferences.removeNodeChangeListener(java.util.prefs.NodeChangeListener)
java.util.prefs.Preferences.removeNodeChangeListener(java.util.prefs.NodeChangeListener)


Occurences of removeNotification

removeNotification occurences:
javax.management.timer.Timer.removeNotification(java.lang.Integer)
javax.management.timer.TimerMBean.removeNotification(java.lang.Integer)


Occurences of removeNotificationListener

removeNotificationListener occurences:
javax.management.MBeanServer.removeNotificationListener(javax.management.ObjectName, javax.management.NotificationListener)
javax.management.MBeanServer.removeNotificationListener(javax.management.ObjectName, javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.MBeanServer.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName)
javax.management.MBeanServer.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName, javax.management.NotificationFilter, java.lang.Object)
javax.management.MBeanServerConnection.removeNotificationListener(javax.management.ObjectName, javax.management.NotificationListener)
javax.management.MBeanServerConnection.removeNotificationListener(javax.management.ObjectName, javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.MBeanServerConnection.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName)
javax.management.MBeanServerConnection.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName, javax.management.NotificationFilter, java.lang.Object)
javax.management.MBeanServerDelegate.removeNotificationListener(javax.management.NotificationListener)
javax.management.MBeanServerDelegate.removeNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.modelmbean.RequiredModelMBean.removeNotificationListener(javax.management.NotificationListener)
javax.management.modelmbean.RequiredModelMBean.removeNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.NotificationBroadcaster.removeNotificationListener(javax.management.NotificationListener)
javax.management.NotificationBroadcasterSupport.removeNotificationListener(javax.management.NotificationListener)
javax.management.NotificationBroadcasterSupport.removeNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.NotificationEmitter.removeNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)
javax.management.remote.rmi.RMIConnection.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnection.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName, java.rmi.MarshalledObject, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.removeNotificationListener(javax.management.ObjectName, javax.management.ObjectName, javax.security.auth.Subject)
javax.management.StandardEmitterMBean.removeNotificationListener(javax.management.NotificationListener)
javax.management.StandardEmitterMBean.removeNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)


Occurences of removeNotificationListeners

removeNotificationListeners occurences:
javax.management.remote.rmi.RMIConnection.removeNotificationListeners(javax.management.ObjectName, java.lang.Integer[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.removeNotificationListeners(javax.management.ObjectName, java.lang.Integer[], javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.removeNotificationListeners(javax.management.ObjectName, java.lang.Integer[], javax.security.auth.Subject)


Occurences of removeNotifications

removeNotifications occurences:
javax.management.timer.Timer.removeNotifications(java.lang.String)
javax.management.timer.TimerMBean.removeNotifications(java.lang.String)


Occurences of removeNotify

removeNotify occurences:
java.awt.Component.removeNotify()
java.awt.Container.removeNotify()
java.awt.dnd.DropTarget.removeNotify(java.awt.peer.ComponentPeer)
java.awt.dnd.DropTargetContext.removeNotify()
java.awt.Frame.removeNotify()
java.awt.im.InputContext.removeNotify(java.awt.Component)
java.awt.im.spi.InputMethod.removeNotify()
java.awt.List.removeNotify()
java.awt.Menu.removeNotify()
java.awt.MenuBar.removeNotify()
java.awt.MenuComponent.removeNotify()
java.awt.TextComponent.removeNotify()
java.awt.Window.removeNotify()
javax.swing.AbstractButton.removeNotify()
javax.swing.JButton.removeNotify()
javax.swing.JComponent.removeNotify()
javax.swing.JMenuBar.removeNotify()
javax.swing.JRootPane.removeNotify()
javax.swing.JTable.removeNotify()
javax.swing.text.JTextComponent.removeNotify()


Occurences of removeObservedObject

removeObservedObject occurences:
javax.management.monitor.Monitor.removeObservedObject(javax.management.ObjectName)
javax.management.monitor.MonitorMBean.removeObservedObject(javax.management.ObjectName)


Occurences of removePopupMenuListener

removePopupMenuListener occurences:
javax.swing.JComboBox.removePopupMenuListener(javax.swing.event.PopupMenuListener)
javax.swing.JPopupMenu.removePopupMenuListener(javax.swing.event.PopupMenuListener)


Occurences of removePreferenceChangeListener

removePreferenceChangeListener occurences:
java.util.prefs.AbstractPreferences.removePreferenceChangeListener(java.util.prefs.PreferenceChangeListener)
java.util.prefs.Preferences.removePreferenceChangeListener(java.util.prefs.PreferenceChangeListener)


Occurences of removePropertyChangeListener

removePropertyChangeListener occurences:
com.sun.tools.jconsole.JConsoleContext.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.Component.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.Component.removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.awt.Component.AccessibleAWTComponent.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.KeyboardFocusManager.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.awt.KeyboardFocusManager.removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.awt.SystemTray.removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.awt.Toolkit.removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.beans.beancontext.BeanContextChild.removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.beans.beancontext.BeanContextChildSupport.removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.beans.Customizer.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.beans.PropertyChangeSupport.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.beans.PropertyChangeSupport.removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
java.beans.PropertyEditor.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.beans.PropertyEditorSupport.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.util.jar.Pack200.Packer.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.util.jar.Pack200.Unpacker.removePropertyChangeListener(java.beans.PropertyChangeListener)
java.util.logging.LogManager.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.accessibility.AccessibleContext.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.AbstractAction.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.Action.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.JComponent.AccessibleJComponent.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.JList.AccessibleJList.AccessibleJListChild.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.plaf.basic.BasicDirectoryModel.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.SwingWorker.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.table.TableColumn.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.tree.DefaultTreeSelectionModel.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.tree.TreeSelectionModel.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.UIDefaults.removePropertyChangeListener(java.beans.PropertyChangeListener)
javax.swing.UIManager.removePropertyChangeListener(java.beans.PropertyChangeListener)


Occurences of removeRange

removeRange occurences:
java.util.AbstractList.removeRange(int, int)
java.util.ArrayList.removeRange(int, int)
java.util.Vector.removeRange(int, int)
javax.swing.DefaultListModel.removeRange(int, int)


Occurences of removeRelation

removeRelation occurences:
javax.management.relation.RelationService.removeRelation(java.lang.String)
javax.management.relation.RelationServiceMBean.removeRelation(java.lang.String)


Occurences of removeRelationType

removeRelationType occurences:
javax.management.relation.RelationService.removeRelationType(java.lang.String)
javax.management.relation.RelationServiceMBean.removeRelationType(java.lang.String)


Occurences of removeRowSetListener

removeRowSetListener occurences:
javax.sql.RowSet.removeRowSetListener(javax.sql.RowSetListener)
javax.sql.rowset.BaseRowSet.removeRowSetListener(javax.sql.RowSetListener)


Occurences of removeSelectionInterval

removeSelectionInterval occurences:
javax.swing.DefaultListSelectionModel.removeSelectionInterval(int, int)
javax.swing.JList.removeSelectionInterval(int, int)
javax.swing.JTree.removeSelectionInterval(int, int)
javax.swing.ListSelectionModel.removeSelectionInterval(int, int)


Occurences of removeSelectionPath

removeSelectionPath occurences:
javax.swing.JTree.removeSelectionPath(javax.swing.tree.TreePath)
javax.swing.tree.DefaultTreeSelectionModel.removeSelectionPath(javax.swing.tree.TreePath)
javax.swing.tree.TreeSelectionModel.removeSelectionPath(javax.swing.tree.TreePath)


Occurences of removeSelectionPaths

removeSelectionPaths occurences:
javax.swing.JTree.removeSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.JTree.EmptySelectionModel.removeSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.tree.DefaultTreeSelectionModel.removeSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.tree.TreeSelectionModel.removeSelectionPaths(javax.swing.tree.TreePath[])


Occurences of removeStyle

removeStyle occurences:
javax.swing.JTextPane.removeStyle(java.lang.String)
javax.swing.text.DefaultStyledDocument.removeStyle(java.lang.String)
javax.swing.text.html.StyleSheet.removeStyle(java.lang.String)
javax.swing.text.StyleContext.removeStyle(java.lang.String)
javax.swing.text.StyledDocument.removeStyle(java.lang.String)


Occurences of removeTableModelListener

removeTableModelListener occurences:
javax.swing.table.AbstractTableModel.removeTableModelListener(javax.swing.event.TableModelListener)
javax.swing.table.TableModel.removeTableModelListener(javax.swing.event.TableModelListener)


Occurences of removeTileObserver

removeTileObserver occurences:
java.awt.image.BufferedImage.removeTileObserver(java.awt.image.TileObserver)
java.awt.image.WritableRenderedImage.removeTileObserver(java.awt.image.TileObserver)


Occurences of removeTreeModelListener

removeTreeModelListener occurences:
javax.swing.tree.DefaultTreeModel.removeTreeModelListener(javax.swing.event.TreeModelListener)
javax.swing.tree.TreeModel.removeTreeModelListener(javax.swing.event.TreeModelListener)


Occurences of removeTreeSelectionListener

removeTreeSelectionListener occurences:
javax.swing.JTree.removeTreeSelectionListener(javax.swing.event.TreeSelectionListener)
javax.swing.tree.DefaultTreeSelectionModel.removeTreeSelectionListener(javax.swing.event.TreeSelectionListener)
javax.swing.tree.TreeSelectionModel.removeTreeSelectionListener(javax.swing.event.TreeSelectionListener)


Occurences of removeUndoableEditListener

removeUndoableEditListener occurences:
javax.swing.text.AbstractDocument.removeUndoableEditListener(javax.swing.event.UndoableEditListener)
javax.swing.text.Document.removeUndoableEditListener(javax.swing.event.UndoableEditListener)
javax.swing.undo.UndoableEditSupport.removeUndoableEditListener(javax.swing.event.UndoableEditListener)


Occurences of removeUpdate

removeUpdate occurences:
javax.swing.event.DocumentListener.removeUpdate(javax.swing.event.DocumentEvent)
javax.swing.text.AbstractDocument.removeUpdate(javax.swing.text.AbstractDocument.DefaultDocumentEvent)
javax.swing.text.DefaultStyledDocument.removeUpdate(javax.swing.text.AbstractDocument.DefaultDocumentEvent)
javax.swing.text.DefaultStyledDocument.ElementBuffer.removeUpdate()
javax.swing.text.FieldView.removeUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.FlowView.removeUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.FlowView.FlowStrategy.removeUpdate(javax.swing.text.FlowView, javax.swing.event.DocumentEvent, java.awt.Rectangle)
javax.swing.text.GlyphView.removeUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.html.InlineView.removeUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.JTextComponent.AccessibleJTextComponent.removeUpdate(javax.swing.event.DocumentEvent)
javax.swing.text.PlainDocument.removeUpdate(javax.swing.text.AbstractDocument.DefaultDocumentEvent)
javax.swing.text.PlainView.removeUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.View.removeUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.WrappedPlainView.removeUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)
javax.swing.text.ZoneView.removeUpdate(javax.swing.event.DocumentEvent, java.awt.Shape, javax.swing.text.ViewFactory)


Occurences of removeVetoableChangeListener

removeVetoableChangeListener occurences:
java.awt.KeyboardFocusManager.removeVetoableChangeListener(java.beans.VetoableChangeListener)
java.awt.KeyboardFocusManager.removeVetoableChangeListener(java.lang.String, java.beans.VetoableChangeListener)
java.beans.beancontext.BeanContextChild.removeVetoableChangeListener(java.lang.String, java.beans.VetoableChangeListener)
java.beans.beancontext.BeanContextChildSupport.removeVetoableChangeListener(java.lang.String, java.beans.VetoableChangeListener)
java.beans.VetoableChangeSupport.removeVetoableChangeListener(java.beans.VetoableChangeListener)
java.beans.VetoableChangeSupport.removeVetoableChangeListener(java.lang.String, java.beans.VetoableChangeListener)
javax.swing.JComponent.removeVetoableChangeListener(java.beans.VetoableChangeListener)


Occurences of rename

rename occurences:
javax.naming.Context.rename(java.lang.String, java.lang.String)
javax.naming.Context.rename(javax.naming.Name, javax.naming.Name)
javax.naming.InitialContext.rename(java.lang.String, java.lang.String)
javax.naming.InitialContext.rename(javax.naming.Name, javax.naming.Name)


Occurences of render

render occurences:
javax.swing.text.AbstractDocument.render(java.lang.Runnable)
javax.swing.text.Document.render(java.lang.Runnable)


Occurences of RenderContext (constructors)

RenderContext (constructors) occurences:
java.awt.image.renderable.RenderContext(java.awt.geom.AffineTransform)
java.awt.image.renderable.RenderContext(java.awt.geom.AffineTransform, java.awt.RenderingHints)
java.awt.image.renderable.RenderContext(java.awt.geom.AffineTransform, java.awt.Shape)
java.awt.image.renderable.RenderContext(java.awt.geom.AffineTransform, java.awt.Shape, java.awt.RenderingHints)


Occurences of renderer

renderer occurences:
javax.swing.renderer
javax.swing.renderer
javax.swing.tree.renderer


Occurences of rendererPane

rendererPane occurences:
javax.swing.plaf.basic.rendererPane
javax.swing.plaf.basic.rendererPane
javax.swing.plaf.basic.rendererPane
javax.swing.plaf.basic.rendererPane
javax.swing.plaf.metal.rendererPane


Occurences of RenderingHints (constructors)

RenderingHints (constructors) occurences:
java.awt.RenderingHints(java.awt.RenderingHints.Key, java.lang.Object)
java.awt.RenderingHints(java.util.Map)


Occurences of repaint

repaint occurences:
java.awt.Component.repaint()
java.awt.Component.repaint(int, int, int, int)
java.awt.Component.repaint(long)
java.awt.Component.repaint(long, int, int, int, int)
javax.swing.DefaultListCellRenderer.repaint()
javax.swing.DefaultListCellRenderer.repaint(java.awt.Rectangle)
javax.swing.DefaultListCellRenderer.repaint(long, int, int, int, int)
javax.swing.JApplet.repaint(long, int, int, int, int)
javax.swing.JComponent.repaint(java.awt.Rectangle)
javax.swing.JComponent.repaint(long, int, int, int, int)
javax.swing.JDialog.repaint(long, int, int, int, int)
javax.swing.JFrame.repaint(long, int, int, int, int)
javax.swing.JViewport.repaint(long, int, int, int, int)
javax.swing.JWindow.repaint(long, int, int, int, int)
javax.swing.table.DefaultTableCellRenderer.repaint()
javax.swing.table.DefaultTableCellRenderer.repaint(java.awt.Rectangle)
javax.swing.table.DefaultTableCellRenderer.repaint(long, int, int, int, int)
javax.swing.text.DefaultCaret.repaint()
javax.swing.tree.DefaultTreeCellRenderer.repaint()
javax.swing.tree.DefaultTreeCellRenderer.repaint(java.awt.Rectangle)
javax.swing.tree.DefaultTreeCellRenderer.repaint(long, int, int, int, int)


Occurences of replace

replace occurences:
java.lang.String.replace(char, char)
java.lang.String.replace(java.lang.CharSequence, java.lang.CharSequence)
java.lang.StringBuffer.replace(int, int, java.lang.String)
java.lang.StringBuilder.replace(int, int, java.lang.String)
java.util.concurrent.ConcurrentHashMap.replace(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentHashMap.replace(java.lang.Object,java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentHashMap.replace(K, V)
java.util.concurrent.ConcurrentHashMap.replace(K, V, V)
java.util.concurrent.ConcurrentMap.replace(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentMap.replace(java.lang.Object,java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentMap.replace(K, V)
java.util.concurrent.ConcurrentMap.replace(K, V, V)
java.util.concurrent.ConcurrentSkipListMap.replace(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.replace(java.lang.Object,java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.replace(K, V)
java.util.concurrent.ConcurrentSkipListMap.replace(K, V, V)
javax.swing.GroupLayout.replace(java.awt.Component, java.awt.Component)
javax.swing.text.AbstractDocument.replace(int, int, java.lang.String, javax.swing.text.AttributeSet)
javax.swing.text.AbstractDocument.BranchElement.replace(int, int, javax.swing.text.Element[])
javax.swing.text.AsyncBoxView.replace(int, int, javax.swing.text.View[])
javax.swing.text.BoxView.replace(int, int, javax.swing.text.View[])
javax.swing.text.CompositeView.replace(int, int, javax.swing.text.View[])
javax.swing.text.DocumentFilter.replace(javax.swing.text.DocumentFilter.FilterBypass, int, int, java.lang.String, javax.swing.text.AttributeSet)
javax.swing.text.DocumentFilter.FilterBypass.replace(int, int, java.lang.String, javax.swing.text.AttributeSet)
javax.swing.text.GapContent.replace(int, int, java.lang.Object, int)
javax.swing.text.TableView.replace(int, int, javax.swing.text.View[])
javax.swing.text.TableView.TableRow.replace(int, int, javax.swing.text.View[])
javax.swing.text.View.replace(int, int, javax.swing.text.View[])


Occurences of replaceAll

replaceAll occurences:
java.lang.String.replaceAll(java.lang.String, java.lang.String)
java.util.Collections.replaceAll(java.util.List, T, T)
java.util.Collections.replaceAll(java.util.List,java.lang.Object,java.lang.Object)
java.util.regex.Matcher.replaceAll(java.lang.String)


Occurences of replaceChild

replaceChild occurences:
javax.imageio.metadata.IIOMetadataNode.replaceChild(org.w3c.dom.Node, org.w3c.dom.Node)
org.w3c.dom.Node.replaceChild(org.w3c.dom.Node, org.w3c.dom.Node)


Occurences of replaceEdit

replaceEdit occurences:
javax.swing.undo.AbstractUndoableEdit.replaceEdit(javax.swing.undo.UndoableEdit)
javax.swing.undo.UndoableEdit.replaceEdit(javax.swing.undo.UndoableEdit)


Occurences of replaceFirst

replaceFirst occurences:
java.lang.String.replaceFirst(java.lang.String, java.lang.String)
java.util.regex.Matcher.replaceFirst(java.lang.String)


Occurences of replacement

replacement occurences:
java.nio.charset.CharsetDecoder.replacement()
java.nio.charset.CharsetEncoder.replacement()


Occurences of replacePixels

replacePixels occurences:
javax.imageio.ImageWriter.replacePixels(java.awt.image.Raster, javax.imageio.ImageWriteParam)
javax.imageio.ImageWriter.replacePixels(java.awt.image.RenderedImage, javax.imageio.ImageWriteParam)


Occurences of replaceRange

replaceRange occurences:
java.awt.TextArea.replaceRange(java.lang.String, int, int)
javax.swing.JTextArea.replaceRange(java.lang.String, int, int)


Occurences of replaceSelection

replaceSelection occurences:
javax.swing.JEditorPane.replaceSelection(java.lang.String)
javax.swing.JTextPane.replaceSelection(java.lang.String)
javax.swing.text.JTextComponent.replaceSelection(java.lang.String)


Occurences of replaceText

replaceText occurences:
java.awt.TextArea.replaceText(java.lang.String, int, int)
javax.accessibility.AccessibleEditableText.replaceText(int, int, java.lang.String)
javax.swing.JSpinner.AccessibleJSpinner.replaceText(int, int, java.lang.String)
javax.swing.text.JTextComponent.AccessibleJTextComponent.replaceText(int, int, java.lang.String)


Occurences of replaceWith

replaceWith occurences:
java.nio.charset.CharsetDecoder.replaceWith(java.lang.String)
java.nio.charset.CharsetEncoder.replaceWith(byte[])


Occurences of REPORT

REPORT occurences:
java.nio.charset.REPORT
javax.print.attribute.standard.REPORT


Occurences of report

report occurences:
javax.tools.DiagnosticCollector.report(javax.tools.Diagnostic)
javax.tools.DiagnosticListener.report(javax.tools.Diagnostic)
javax.xml.stream.XMLReporter.report(java.lang.String, java.lang.String, java.lang.Object, javax.xml.stream.Location)


Occurences of request

request occurences:
com.sun.jdi.event.Event.request()
com.sun.jdi.request
org.omg.CORBA.portable.Delegate.request(org.omg.CORBA.Object, java.lang.String)
org.omg.CORBA.portable.Delegate.request(org.omg.CORBA.Object, java.lang.String, boolean)


Occurences of requestFocus

requestFocus occurences:
java.awt.Component.requestFocus()
java.awt.Component.requestFocus(boolean)
java.awt.Component.AccessibleAWTComponent.requestFocus()
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.requestFocus()
java.awt.MenuComponent.AccessibleAWTMenuComponent.requestFocus()
javax.accessibility.AccessibleComponent.requestFocus()
javax.swing.JComponent.requestFocus()
javax.swing.JComponent.requestFocus(boolean)
javax.swing.JList.AccessibleJList.AccessibleJListChild.requestFocus()
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.requestFocus()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.requestFocus()
javax.swing.plaf.basic.BasicInternalFrameTitlePane.SystemMenuBar.requestFocus()
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.requestFocus()


Occurences of requestFocusInWindow

requestFocusInWindow occurences:
java.awt.Component.requestFocusInWindow()
java.awt.Component.requestFocusInWindow(boolean)
javax.swing.JComponent.requestFocusInWindow()
javax.swing.JComponent.requestFocusInWindow(boolean)


Occurences of requestPasswordAuthentication

requestPasswordAuthentication occurences:
java.net.Authenticator.requestPasswordAuthentication(java.lang.String, java.net.InetAddress, int, java.lang.String, java.lang.String, java.lang.String)
java.net.Authenticator.requestPasswordAuthentication(java.lang.String, java.net.InetAddress, int, java.lang.String, java.lang.String, java.lang.String, java.net.URL, java.net.Authenticator.RequestorType)
java.net.Authenticator.requestPasswordAuthentication(java.net.InetAddress, int, java.lang.String, java.lang.String, java.lang.String)


Occurences of requestTopDownLeftRightResend

requestTopDownLeftRightResend occurences:
java.awt.image.FilteredImageSource.requestTopDownLeftRightResend(java.awt.image.ImageConsumer)
java.awt.image.ImageProducer.requestTopDownLeftRightResend(java.awt.image.ImageConsumer)
java.awt.image.MemoryImageSource.requestTopDownLeftRightResend(java.awt.image.ImageConsumer)
java.awt.image.renderable.RenderableImageProducer.requestTopDownLeftRightResend(java.awt.image.ImageConsumer)


Occurences of require

require occurences:
javax.xml.stream.util.StreamReaderDelegate.require(int, java.lang.String, java.lang.String)
javax.xml.stream.XMLStreamReader.require(int, java.lang.String, java.lang.String)


Occurences of REQUIRED

REQUIRED occurences:
java.awt.REQUIRED
javax.security.auth.login.REQUIRED
javax.swing.text.html.parser.REQUIRED


Occurences of required

required occurences:
java.sql.required
javax.xml.bind.annotation.XmlAttribute.required()
javax.xml.bind.annotation.XmlElement.required()


Occurences of RequiredModelMBean (constructors)

RequiredModelMBean (constructors) occurences:
javax.management.modelmbean.RequiredModelMBean()
javax.management.modelmbean.RequiredModelMBean(javax.management.modelmbean.ModelMBeanInfo)


Occurences of RescaleOp (constructors)

RescaleOp (constructors) occurences:
java.awt.image.RescaleOp(float, float, java.awt.RenderingHints)
java.awt.image.RescaleOp(float[], float[], java.awt.RenderingHints)


Occurences of rescanCurrentDirectory

rescanCurrentDirectory occurences:
javax.swing.JFileChooser.rescanCurrentDirectory()
javax.swing.plaf.basic.BasicFileChooserUI.rescanCurrentDirectory(javax.swing.JFileChooser)
javax.swing.plaf.FileChooserUI.rescanCurrentDirectory(javax.swing.JFileChooser)
javax.swing.plaf.metal.MetalFileChooserUI.rescanCurrentDirectory(javax.swing.JFileChooser)
javax.swing.plaf.multi.MultiFileChooserUI.rescanCurrentDirectory(javax.swing.JFileChooser)


Occurences of reset

reset occurences:
java.awt.geom.Area.reset()
java.awt.geom.Path2D.reset()
java.awt.Polygon.reset()
java.io.BufferedInputStream.reset()
java.io.BufferedReader.reset()
java.io.ByteArrayInputStream.reset()
java.io.ByteArrayOutputStream.reset()
java.io.CharArrayReader.reset()
java.io.CharArrayWriter.reset()
java.io.FilterInputStream.reset()
java.io.FilterReader.reset()
java.io.InputStream.reset()
java.io.LineNumberInputStream.reset()
java.io.LineNumberReader.reset()
java.io.ObjectOutputStream.reset()
java.io.PushbackInputStream.reset()
java.io.PushbackReader.reset()
java.io.Reader.reset()
java.io.StringBufferInputStream.reset()
java.io.StringReader.reset()
java.nio.Buffer.reset()
java.nio.charset.CharsetDecoder.reset()
java.nio.charset.CharsetEncoder.reset()
java.security.MessageDigest.reset()
java.text.CollationElementIterator.reset()
java.util.concurrent.CyclicBarrier.reset()
java.util.logging.LogManager.reset()
java.util.regex.Matcher.reset()
java.util.regex.Matcher.reset(java.lang.CharSequence)
java.util.Scanner.reset()
java.util.zip.Adler32.reset()
java.util.zip.Checksum.reset()
java.util.zip.CRC32.reset()
java.util.zip.Deflater.reset()
java.util.zip.DeflaterInputStream.reset()
java.util.zip.Inflater.reset()
java.util.zip.InflaterInputStream.reset()
javax.crypto.Mac.reset()
javax.imageio.ImageReader.reset()
javax.imageio.ImageWriter.reset()
javax.imageio.metadata.IIOMetadata.reset()
javax.imageio.stream.ImageInputStream.reset()
javax.imageio.stream.ImageInputStreamImpl.reset()
javax.sound.sampled.AudioInputStream.reset()
javax.swing.ProgressMonitorInputStream.reset()
javax.xml.bind.util.ValidationEventCollector.reset()
javax.xml.datatype.XMLGregorianCalendar.reset()
javax.xml.parsers.DocumentBuilder.reset()
javax.xml.parsers.SAXParser.reset()
javax.xml.transform.Transformer.reset()
javax.xml.validation.Validator.reset()
javax.xml.xpath.XPath.reset()
org.xml.sax.helpers.NamespaceSupport.reset()


Occurences of resetRowSelection

resetRowSelection occurences:
javax.swing.tree.DefaultTreeSelectionModel.resetRowSelection()
javax.swing.tree.TreeSelectionModel.resetRowSelection()


Occurences of resetToPreferredSizes

resetToPreferredSizes occurences:
javax.swing.JSplitPane.resetToPreferredSizes()
javax.swing.plaf.basic.BasicSplitPaneUI.resetToPreferredSizes(javax.swing.JSplitPane)
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.resetToPreferredSizes()
javax.swing.plaf.multi.MultiSplitPaneUI.resetToPreferredSizes(javax.swing.JSplitPane)
javax.swing.plaf.SplitPaneUI.resetToPreferredSizes(javax.swing.JSplitPane)


Occurences of reshape

reshape occurences:
java.awt.Component.reshape(int, int, int, int)
java.awt.Rectangle.reshape(int, int, int, int)
java.awt.Window.reshape(int, int, int, int)
javax.swing.JComponent.reshape(int, int, int, int)
javax.swing.JInternalFrame.reshape(int, int, int, int)
javax.swing.JViewport.reshape(int, int, int, int)


Occurences of resize

resize occurences:
java.applet.Applet.resize(int, int)
java.applet.Applet.resize(java.awt.Dimension)
java.awt.Component.resize(int, int)
java.awt.Component.resize(java.awt.Dimension)
java.awt.Rectangle.resize(int, int)


Occurences of resizeAndRepaint

resizeAndRepaint occurences:
javax.swing.JTable.resizeAndRepaint()
javax.swing.table.JTableHeader.resizeAndRepaint()


Occurences of resizeFrame

resizeFrame occurences:
javax.swing.DefaultDesktopManager.resizeFrame(javax.swing.JComponent, int, int, int, int)
javax.swing.DesktopManager.resizeFrame(javax.swing.JComponent, int, int, int, int)


Occurences of resolution

resolution occurences:
javax.sound.midi.resolution
javax.sound.midi.resolution


Occurences of resolve

resolve occurences:
java.net.URI.resolve(java.lang.String)
java.net.URI.resolve(java.net.URI)
javax.xml.transform.URIResolver.resolve(java.lang.String, java.lang.String)
org.omg.CosNaming.NamingContextOperations.resolve(org.omg.CosNaming.NameComponent[])
org.omg.CosNaming._NamingContextExtStub.resolve(org.omg.CosNaming.NameComponent[])
org.omg.CosNaming._NamingContextStub.resolve(org.omg.CosNaming.NameComponent[])


Occurences of ResolveAttribute

ResolveAttribute occurences:
javax.swing.text.ResolveAttribute
javax.swing.text.ResolveAttribute


Occurences of resolveClass

resolveClass occurences:
java.io.ObjectInputStream.resolveClass(java.io.ObjectStreamClass)
java.lang.ClassLoader.resolveClass(java.lang.Class)


Occurences of resolvedObj

resolvedObj occurences:
javax.naming.resolvedObj
javax.naming.spi.resolvedObj


Occurences of resolveEntity

resolveEntity occurences:
javax.xml.stream.XMLResolver.resolveEntity(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.EntityResolver.resolveEntity(java.lang.String, java.lang.String)
org.xml.sax.ext.DefaultHandler2.resolveEntity(java.lang.String, java.lang.String)
org.xml.sax.ext.DefaultHandler2.resolveEntity(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.ext.EntityResolver2.resolveEntity(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.HandlerBase.resolveEntity(java.lang.String, java.lang.String)
org.xml.sax.helpers.DefaultHandler.resolveEntity(java.lang.String, java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.resolveEntity(java.lang.String, java.lang.String)


Occurences of ResolveResult (constructors)

ResolveResult (constructors) occurences:
javax.naming.spi.ResolveResult()
javax.naming.spi.ResolveResult(java.lang.Object, java.lang.String)
javax.naming.spi.ResolveResult(java.lang.Object, javax.naming.Name)


Occurences of resolveToClass

resolveToClass occurences:
javax.naming.spi.Resolver.resolveToClass(java.lang.String, java.lang.Class)
javax.naming.spi.Resolver.resolveToClass(javax.naming.Name, java.lang.Class)


Occurences of resolve_initial_references

resolve_initial_references occurences:
org.omg.CORBA.ORB.resolve_initial_references(java.lang.String)
org.omg.PortableInterceptor.ORBInitInfoOperations.resolve_initial_references(java.lang.String)


Occurences of resolve_str

resolve_str occurences:
org.omg.CosNaming.NamingContextExtOperations.resolve_str(java.lang.String)
org.omg.CosNaming._NamingContextExtStub.resolve_str(java.lang.String)


Occurences of responseCode

responseCode occurences:
java.net.HttpRetryException.responseCode()
java.net.responseCode


Occurences of rest_of_name

rest_of_name occurences:
org.omg.CosNaming.NamingContextPackage.rest_of_name
org.omg.CosNaming.NamingContextPackage.rest_of_name


Occurences of result

result occurences:
org.omg.CORBA.Request.result()
org.omg.CORBA.ServerRequest.result(org.omg.CORBA.Any)
org.omg.PortableInterceptor.RequestInfoOperations.result()


Occurences of ResultSet

ResultSet occurences:
java.sql.ResultSet
ResultSet


Occurences of resume

resume occurences:
com.sun.jdi.event.EventSet.resume()
com.sun.jdi.ThreadGroupReference.resume()
com.sun.jdi.ThreadReference.resume()
com.sun.jdi.VirtualMachine.resume()
java.lang.Thread.resume()
java.lang.ThreadGroup.resume()


Occurences of retainAll

retainAll occurences:
java.beans.beancontext.BeanContextSupport.retainAll(java.util.Collection)
java.util.AbstractCollection.retainAll(java.util.Collection)
java.util.Collection.retainAll(java.util.Collection)
java.util.concurrent.CopyOnWriteArrayList.retainAll(java.util.Collection)
java.util.concurrent.CopyOnWriteArraySet.retainAll(java.util.Collection)
java.util.concurrent.SynchronousQueue.retainAll(java.util.Collection)
java.util.List.retainAll(java.util.Collection)
java.util.Set.retainAll(java.util.Collection)
java.util.Vector.retainAll(java.util.Collection)


Occurences of retrieveAllRoles

retrieveAllRoles occurences:
javax.management.relation.Relation.retrieveAllRoles()
javax.management.relation.RelationSupport.retrieveAllRoles()


Occurences of returnType

returnType occurences:
com.sun.javadoc.MethodDoc.returnType()
com.sun.jdi.Method.returnType()


Occurences of returnValue

returnValue occurences:
com.sun.jdi.event.MethodExitEvent.returnValue()
com.sun.tools.attach.AgentInitializationException.returnValue()


Occurences of revalidate

revalidate occurences:
java.awt.Component.BltBufferStrategy.revalidate()
java.awt.Component.FlipBufferStrategy.revalidate()
javax.swing.DefaultListCellRenderer.revalidate()
javax.swing.JComponent.revalidate()
javax.swing.table.DefaultTableCellRenderer.revalidate()
javax.swing.tree.DefaultTreeCellRenderer.revalidate()


Occurences of reverse

reverse occurences:
java.lang.Integer.reverse(int)
java.lang.Long.reverse(long)
java.lang.StringBuffer.reverse()
java.lang.StringBuilder.reverse()
java.util.Collections.reverse(java.util.List)


Occurences of reverseBytes

reverseBytes occurences:
java.lang.Character.reverseBytes(char)
java.lang.Integer.reverseBytes(int)
java.lang.Long.reverseBytes(long)
java.lang.Short.reverseBytes(short)


Occurences of reverseOrder

reverseOrder occurences:
java.util.Collections.reverseOrder()
java.util.Collections.reverseOrder(java.util.Comparator)


Occurences of REVERSE_LANDSCAPE

REVERSE_LANDSCAPE occurences:
java.awt.print.REVERSE_LANDSCAPE
javax.print.attribute.standard.REVERSE_LANDSCAPE


Occurences of revokeService

revokeService occurences:
java.beans.beancontext.BeanContextServices.revokeService(java.lang.Class, java.beans.beancontext.BeanContextServiceProvider, boolean)
java.beans.beancontext.BeanContextServicesSupport.revokeService(java.lang.Class, java.beans.beancontext.BeanContextServiceProvider, boolean)


Occurences of rewind

rewind occurences:
java.nio.Buffer.rewind()
org.omg.CORBA.DynAny.rewind()
org.omg.DynamicAny.DynAnyOperations.rewind()
org.omg.DynamicAny._DynAnyStub.rewind()
org.omg.DynamicAny._DynArrayStub.rewind()
org.omg.DynamicAny._DynEnumStub.rewind()
org.omg.DynamicAny._DynFixedStub.rewind()
org.omg.DynamicAny._DynSequenceStub.rewind()
org.omg.DynamicAny._DynStructStub.rewind()
org.omg.DynamicAny._DynUnionStub.rewind()
org.omg.DynamicAny._DynValueStub.rewind()


Occurences of right

right occurences:
java.awt.right
javax.swing.border.right


Occurences of RIGHT

RIGHT occurences:
java.awt.RIGHT
java.awt.RIGHT
java.awt.RIGHT
javax.swing.border.RIGHT
javax.swing.RIGHT
javax.swing.RIGHT


Occurences of rightKey

rightKey occurences:
javax.swing.plaf.basic.rightKey
javax.swing.plaf.basic.rightKey
javax.swing.plaf.basic.rightKey


Occurences of rint

rint occurences:
java.lang.Math.rint(double)
java.lang.StrictMath.rint(double)


Occurences of rmi

rmi occurences:
java.rmi
javax.management.remote.rmi
javax.rmi
org.omg.stub.java.rmi


Occurences of rmic - The Java RMI Compiler

rmic - The Java RMI Compiler occurences:
rmic - The Java RMI Compiler
rmic - The Java RMI Compiler


Occurences of RMIConnector (constructors)

RMIConnector (constructors) occurences:
javax.management.remote.rmi.RMIConnector(javax.management.remote.JMXServiceURL, java.util.Map)
javax.management.remote.rmi.RMIConnector(javax.management.remote.rmi.RMIServer, java.util.Map)


Occurences of RMIConnectorServer (constructors)

RMIConnectorServer (constructors) occurences:
javax.management.remote.rmi.RMIConnectorServer(javax.management.remote.JMXServiceURL, java.util.Map)
javax.management.remote.rmi.RMIConnectorServer(javax.management.remote.JMXServiceURL, java.util.Map, javax.management.MBeanServer)
javax.management.remote.rmi.RMIConnectorServer(javax.management.remote.JMXServiceURL, java.util.Map, javax.management.remote.rmi.RMIServerImpl, javax.management.MBeanServer)


Occurences of rmid - The Java RMI Activation System Daemon

rmid - The Java RMI Activation System Daemon occurences:
rmid - The Java RMI Activation System Daemon
rmid - The Java RMI Activation System Daemon


Occurences of rmiregistry - The Java Remote Object Registry

rmiregistry - The Java Remote Object Registry occurences:
rmiregistry - The Java Remote Object Registry
rmiregistry - The Java Remote Object Registry


Occurences of RMISecurityException (constructors)

RMISecurityException (constructors) occurences:
java.rmi.RMISecurityException(java.lang.String)
java.rmi.RMISecurityException(java.lang.String, java.lang.String)


Occurences of Robot (constructors)

Robot (constructors) occurences:
java.awt.Robot()
java.awt.Robot(java.awt.GraphicsDevice)


Occurences of RoleInfo (constructors)

RoleInfo (constructors) occurences:
javax.management.relation.RoleInfo(java.lang.String, java.lang.String)
javax.management.relation.RoleInfo(java.lang.String, java.lang.String, boolean, boolean)
javax.management.relation.RoleInfo(java.lang.String, java.lang.String, boolean, boolean, int, int, java.lang.String)
javax.management.relation.RoleInfo(javax.management.relation.RoleInfo)


Occurences of RoleInfoNotFoundException (constructors)

RoleInfoNotFoundException (constructors) occurences:
javax.management.relation.RoleInfoNotFoundException()
javax.management.relation.RoleInfoNotFoundException(java.lang.String)


Occurences of RoleList (constructors)

RoleList (constructors) occurences:
javax.management.relation.RoleList()
javax.management.relation.RoleList(int)
javax.management.relation.RoleList(java.util.List)


Occurences of RoleNotFoundException (constructors)

RoleNotFoundException (constructors) occurences:
javax.management.relation.RoleNotFoundException()
javax.management.relation.RoleNotFoundException(java.lang.String)


Occurences of RoleUnresolvedList (constructors)

RoleUnresolvedList (constructors) occurences:
javax.management.relation.RoleUnresolvedList()
javax.management.relation.RoleUnresolvedList(int)
javax.management.relation.RoleUnresolvedList(java.util.List)


Occurences of roll

roll occurences:
java.util.Calendar.roll(int, boolean)
java.util.Calendar.roll(int, int)
java.util.GregorianCalendar.roll(int, boolean)
java.util.GregorianCalendar.roll(int, int)


Occurences of rollback

rollback occurences:
java.sql.Connection.rollback()
java.sql.Connection.rollback(java.sql.Savepoint)
javax.sql.rowset.CachedRowSet.rollback()
javax.sql.rowset.CachedRowSet.rollback(java.sql.Savepoint)
javax.sql.rowset.JdbcRowSet.rollback()
javax.sql.rowset.JdbcRowSet.rollback(java.sql.Savepoint)
javax.sql.rowset.spi.TransactionalWriter.rollback()
javax.sql.rowset.spi.TransactionalWriter.rollback(java.sql.Savepoint)
javax.transaction.xa.XAResource.rollback(javax.transaction.xa.Xid)


Occurences of ROMAN_BASELINE

ROMAN_BASELINE occurences:
java.awt.font.ROMAN_BASELINE
java.awt.ROMAN_BASELINE


Occurences of rootPane

rootPane occurences:
javax.swing.rootPane
javax.swing.rootPane
javax.swing.rootPane
javax.swing.rootPane
javax.swing.rootPane


Occurences of rootPaneCheckingEnabled

rootPaneCheckingEnabled occurences:
javax.swing.rootPaneCheckingEnabled
javax.swing.rootPaneCheckingEnabled
javax.swing.rootPaneCheckingEnabled
javax.swing.rootPaneCheckingEnabled
javax.swing.rootPaneCheckingEnabled


Occurences of rootVisible

rootVisible occurences:
javax.swing.rootVisible
javax.swing.tree.rootVisible


Occurences of ROOT_PANE

ROOT_PANE occurences:
javax.accessibility.ROOT_PANE
javax.swing.plaf.synth.ROOT_PANE


Occurences of rotate

rotate occurences:
java.awt.geom.AffineTransform.rotate(double)
java.awt.geom.AffineTransform.rotate(double, double)
java.awt.geom.AffineTransform.rotate(double, double, double)
java.awt.geom.AffineTransform.rotate(double, double, double, double)
java.awt.Graphics2D.rotate(double)
java.awt.Graphics2D.rotate(double, double, double)
java.util.Collections.rotate(java.util.List, int)


Occurences of rotateLeft

rotateLeft occurences:
java.lang.Integer.rotateLeft(int, int)
java.lang.Long.rotateLeft(long, int)


Occurences of rotateRight

rotateRight occurences:
java.lang.Integer.rotateRight(int, int)
java.lang.Long.rotateRight(long, int)


Occurences of rotateTabRuns

rotateTabRuns occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.TabbedPaneLayout.rotateTabRuns(int, int)
javax.swing.plaf.metal.MetalTabbedPaneUI.TabbedPaneLayout.rotateTabRuns(int, int)


Occurences of round

round occurences:
java.lang.Math.round(double)
java.lang.Math.round(float)
java.lang.StrictMath.round(double)
java.lang.StrictMath.round(float)
java.math.BigDecimal.round(java.math.MathContext)


Occurences of RoundRectangle2D.Double (constructors)

RoundRectangle2D.Double (constructors) occurences:
java.awt.geom.RoundRectangle2D.Double()
java.awt.geom.RoundRectangle2D.Double(double, double, double, double, double, double)


Occurences of RoundRectangle2D.Float (constructors)

RoundRectangle2D.Float (constructors) occurences:
java.awt.geom.RoundRectangle2D.Float()
java.awt.geom.RoundRectangle2D.Float(float, float, float, float, float, float)


Occurences of rowHeight

rowHeight occurences:
javax.swing.rowHeight
javax.swing.rowHeight
javax.swing.tree.rowHeight


Occurences of rowsDeleted

rowsDeleted occurences:
javax.swing.DefaultRowSorter.rowsDeleted(int, int)
javax.swing.RowSorter.rowsDeleted(int, int)


Occurences of RowSet

RowSet occurences:
javax.sql.RowSet
RowSet


Occurences of RowSetWarning (constructors)

RowSetWarning (constructors) occurences:
javax.sql.rowset.RowSetWarning()
javax.sql.rowset.RowSetWarning(java.lang.String)
javax.sql.rowset.RowSetWarning(java.lang.String, java.lang.String)
javax.sql.rowset.RowSetWarning(java.lang.String, java.lang.String, int)


Occurences of rowsInserted

rowsInserted occurences:
javax.swing.DefaultRowSorter.rowsInserted(int, int)
javax.swing.RowSorter.rowsInserted(int, int)


Occurences of RowSorterEvent (constructors)

RowSorterEvent (constructors) occurences:
javax.swing.event.RowSorterEvent(javax.swing.RowSorter)
javax.swing.event.RowSorterEvent(javax.swing.RowSorter, javax.swing.event.RowSorterEvent.Type, int[])


Occurences of rowsUpdated

rowsUpdated occurences:
javax.swing.DefaultRowSorter.rowsUpdated(int, int)
javax.swing.DefaultRowSorter.rowsUpdated(int, int, int)
javax.swing.RowSorter.rowsUpdated(int, int)
javax.swing.RowSorter.rowsUpdated(int, int, int)


Occurences of ROW_HEADER

ROW_HEADER occurences:
javax.accessibility.ROW_HEADER
javax.swing.ROW_HEADER


Occurences of run

run occurences:
java.awt.image.renderable.RenderableImageProducer.run()
java.lang.Runnable.run()
java.lang.Thread.run()
java.security.PrivilegedAction.run()
java.security.PrivilegedExceptionAction.run()
java.util.concurrent.FutureTask.run()
java.util.concurrent.RunnableFuture.run()
java.util.TimerTask.run()
javax.swing.SwingWorker.run()
javax.swing.text.AsyncBoxView.ChildState.run()
javax.tools.Tool.run(java.io.InputStream, java.io.OutputStream, java.io.OutputStream, java.lang.String...)
org.omg.CORBA.ORB.run()


Occurences of runFinalization

runFinalization occurences:
java.lang.Runtime.runFinalization()
java.lang.System.runFinalization()


Occurences of runFinalizersOnExit

runFinalizersOnExit occurences:
java.lang.Runtime.runFinalizersOnExit(boolean)
java.lang.System.runFinalizersOnExit(boolean)


Occurences of RuntimeErrorException (constructors)

RuntimeErrorException (constructors) occurences:
javax.management.RuntimeErrorException(java.lang.Error)
javax.management.RuntimeErrorException(java.lang.Error, java.lang.String)


Occurences of RuntimeException (constructors)

RuntimeException (constructors) occurences:
java.lang.RuntimeException()
java.lang.RuntimeException(java.lang.String)
java.lang.RuntimeException(java.lang.String, java.lang.Throwable)
java.lang.RuntimeException(java.lang.Throwable)


Occurences of RuntimeMBeanException (constructors)

RuntimeMBeanException (constructors) occurences:
javax.management.RuntimeMBeanException(java.lang.RuntimeException)
javax.management.RuntimeMBeanException(java.lang.RuntimeException, java.lang.String)


Occurences of RuntimeOperationsException (constructors)

RuntimeOperationsException (constructors) occurences:
javax.management.RuntimeOperationsException(java.lang.RuntimeException)
javax.management.RuntimeOperationsException(java.lang.RuntimeException, java.lang.String)


Occurences of RuntimePermission (constructors)

RuntimePermission (constructors) occurences:
java.lang.RuntimePermission(java.lang.String)
java.lang.RuntimePermission(java.lang.String, java.lang.String)


Occurences of SAAJResult (constructors)

SAAJResult (constructors) occurences:
javax.xml.soap.SAAJResult()
javax.xml.soap.SAAJResult(java.lang.String)
javax.xml.soap.SAAJResult(javax.xml.soap.SOAPElement)
javax.xml.soap.SAAJResult(javax.xml.soap.SOAPMessage)


Occurences of sameFile

sameFile occurences:
java.net.URL.sameFile(java.net.URL)
java.net.URLStreamHandler.sameFile(java.net.URL, java.net.URL)


Occurences of sample

sample occurences:
java.util.sample
java.util.sample


Occurences of sampleModel

sampleModel occurences:
java.awt.image.sampleModel
javax.imageio.sampleModel


Occurences of SaslException (constructors)

SaslException (constructors) occurences:
javax.security.sasl.SaslException()
javax.security.sasl.SaslException(java.lang.String)
javax.security.sasl.SaslException(java.lang.String, java.lang.Throwable)


Occurences of save

save occurences:
java.awt.AWTEventMulticaster.save(java.io.ObjectOutputStream, java.lang.String, java.util.EventListener)
java.util.Properties.save(java.io.OutputStream, java.lang.String)


Occurences of sax

sax occurences:
javax.xml.transform.sax
org.xml.sax


Occurences of SAXException (constructors)

SAXException (constructors) occurences:
org.xml.sax.SAXException()
org.xml.sax.SAXException(java.lang.Exception)
org.xml.sax.SAXException(java.lang.String)
org.xml.sax.SAXException(java.lang.String, java.lang.Exception)


Occurences of SAXNotRecognizedException (constructors)

SAXNotRecognizedException (constructors) occurences:
org.xml.sax.SAXNotRecognizedException()
org.xml.sax.SAXNotRecognizedException(java.lang.String)


Occurences of SAXNotSupportedException (constructors)

SAXNotSupportedException (constructors) occurences:
org.xml.sax.SAXNotSupportedException()
org.xml.sax.SAXNotSupportedException(java.lang.String)


Occurences of SAXParseException (constructors)

SAXParseException (constructors) occurences:
org.xml.sax.SAXParseException(java.lang.String, java.lang.String, java.lang.String, int, int)
org.xml.sax.SAXParseException(java.lang.String, java.lang.String, java.lang.String, int, int, java.lang.Exception)
org.xml.sax.SAXParseException(java.lang.String, org.xml.sax.Locator)
org.xml.sax.SAXParseException(java.lang.String, org.xml.sax.Locator, java.lang.Exception)


Occurences of saxParserPlugable

saxParserPlugable occurences:
javax.xml.bind.helpers.saxParserPlugable
javax.xml.bind.saxParserPlugable


Occurences of SAXResult (constructors)

SAXResult (constructors) occurences:
javax.xml.transform.sax.SAXResult()
javax.xml.transform.sax.SAXResult(org.xml.sax.ContentHandler)


Occurences of SAXSource (constructors)

SAXSource (constructors) occurences:
javax.xml.transform.sax.SAXSource()
javax.xml.transform.sax.SAXSource(org.xml.sax.InputSource)
javax.xml.transform.sax.SAXSource(org.xml.sax.XMLReader, org.xml.sax.InputSource)


Occurences of scalb

scalb occurences:
java.lang.Math.scalb(double, int)
java.lang.Math.scalb(float, int)
java.lang.StrictMath.scalb(double, int)
java.lang.StrictMath.scalb(float, int)


Occurences of scale

scale occurences:
java.awt.geom.AffineTransform.scale(double, double)
java.awt.Graphics2D.scale(double, double)
java.math.BigDecimal.scale()
javax.swing.Spring.scale(javax.swing.Spring, float)


Occurences of scan

scan occurences:
com.sun.source.util.TreePathScanner.scan(com.sun.source.tree.Tree, P)
com.sun.source.util.TreePathScanner.scan(com.sun.source.tree.Tree,java.lang.Object)
com.sun.source.util.TreePathScanner.scan(com.sun.source.util.TreePath, P)
com.sun.source.util.TreePathScanner.scan(com.sun.source.util.TreePath,java.lang.Object)
com.sun.source.util.TreeScanner.scan(com.sun.source.tree.Tree, P)
com.sun.source.util.TreeScanner.scan(com.sun.source.tree.Tree,java.lang.Object)
com.sun.source.util.TreeScanner.scan(java.lang.Iterable, P)
com.sun.source.util.TreeScanner.scan(java.lang.Iterable,java.lang.Object)
javax.lang.model.util.ElementScanner6.scan(java.lang.Iterable, P)
javax.lang.model.util.ElementScanner6.scan(java.lang.Iterable,java.lang.Object)
javax.lang.model.util.ElementScanner6.scan(javax.lang.model.element.Element)
javax.lang.model.util.ElementScanner6.scan(javax.lang.model.element.Element, P)
javax.lang.model.util.ElementScanner6.scan(javax.lang.model.element.Element,java.lang.Object)


Occurences of Scanner (constructors)

Scanner (constructors) occurences:
java.util.Scanner(java.io.File)
java.util.Scanner(java.io.File, java.lang.String)
java.util.Scanner(java.io.InputStream)
java.util.Scanner(java.io.InputStream, java.lang.String)
java.util.Scanner(java.lang.Readable)
java.util.Scanner(java.lang.String)
java.util.Scanner(java.nio.channels.ReadableByteChannel)
java.util.Scanner(java.nio.channels.ReadableByteChannel, java.lang.String)


Occurences of schedule

schedule occurences:
java.util.concurrent.ScheduledExecutorService.schedule(java.lang.Runnable, long, java.util.concurrent.TimeUnit)
java.util.concurrent.ScheduledExecutorService.schedule(java.util.concurrent.Callable, long, java.util.concurrent.TimeUnit)
java.util.concurrent.ScheduledThreadPoolExecutor.schedule(java.lang.Runnable, long, java.util.concurrent.TimeUnit)
java.util.concurrent.ScheduledThreadPoolExecutor.schedule(java.util.concurrent.Callable, long, java.util.concurrent.TimeUnit)
java.util.Timer.schedule(java.util.TimerTask, java.util.Date)
java.util.Timer.schedule(java.util.TimerTask, java.util.Date, long)
java.util.Timer.schedule(java.util.TimerTask, long)
java.util.Timer.schedule(java.util.TimerTask, long, long)


Occurences of scheduleAtFixedRate

scheduleAtFixedRate occurences:
java.util.concurrent.ScheduledExecutorService.scheduleAtFixedRate(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit)
java.util.concurrent.ScheduledThreadPoolExecutor.scheduleAtFixedRate(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit)
java.util.Timer.scheduleAtFixedRate(java.util.TimerTask, java.util.Date, long)
java.util.Timer.scheduleAtFixedRate(java.util.TimerTask, long, long)


Occurences of ScheduledThreadPoolExecutor (constructors)

ScheduledThreadPoolExecutor (constructors) occurences:
java.util.concurrent.ScheduledThreadPoolExecutor(int)
java.util.concurrent.ScheduledThreadPoolExecutor(int, java.util.concurrent.RejectedExecutionHandler)
java.util.concurrent.ScheduledThreadPoolExecutor(int, java.util.concurrent.ThreadFactory)
java.util.concurrent.ScheduledThreadPoolExecutor(int, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler)


Occurences of scheduleWithFixedDelay

scheduleWithFixedDelay occurences:
java.util.concurrent.ScheduledExecutorService.scheduleWithFixedDelay(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit)
java.util.concurrent.ScheduledThreadPoolExecutor.scheduleWithFixedDelay(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit)


Occurences of SchemaViolationException (constructors)

SchemaViolationException (constructors) occurences:
javax.naming.directory.SchemaViolationException()
javax.naming.directory.SchemaViolationException(java.lang.String)


Occurences of scientific

scientific occurences:
java.util.scientific
java.util.scientific


Occurences of scope

scope occurences:
javax.xml.bind.annotation.XmlElementDecl.scope()
javax.xml.bind.scope


Occurences of ScriptEngineManager (constructors)

ScriptEngineManager (constructors) occurences:
javax.script.ScriptEngineManager()
javax.script.ScriptEngineManager(java.lang.ClassLoader)


Occurences of ScriptException (constructors)

ScriptException (constructors) occurences:
javax.script.ScriptException(java.lang.Exception)
javax.script.ScriptException(java.lang.String)
javax.script.ScriptException(java.lang.String, java.lang.String, int)
javax.script.ScriptException(java.lang.String, java.lang.String, int, int)


Occurences of scrollbar

scrollbar occurences:
java.awt.scrollbar
javax.swing.plaf.basic.scrollbar


Occurences of Scrollbar (constructors)

Scrollbar (constructors) occurences:
java.awt.Scrollbar()
java.awt.Scrollbar(int)
java.awt.Scrollbar(int, int, int, int, int)


Occurences of scrollByBlock

scrollByBlock occurences:
javax.swing.plaf.basic.BasicScrollBarUI.scrollByBlock(int)
javax.swing.plaf.basic.BasicSliderUI.scrollByBlock(int)


Occurences of scrollByUnit

scrollByUnit occurences:
javax.swing.plaf.basic.BasicScrollBarUI.scrollByUnit(int)
javax.swing.plaf.basic.BasicSliderUI.scrollByUnit(int)


Occurences of scrollDueToClickInTrack

scrollDueToClickInTrack occurences:
javax.swing.plaf.basic.BasicSliderUI.scrollDueToClickInTrack(int)
javax.swing.plaf.metal.MetalSliderUI.scrollDueToClickInTrack(int)


Occurences of scrollListener

scrollListener occurences:
javax.swing.plaf.basic.scrollListener
javax.swing.plaf.basic.scrollListener


Occurences of ScrollPane (constructors)

ScrollPane (constructors) occurences:
java.awt.ScrollPane()
java.awt.ScrollPane(int)


Occurences of scrollRectToVisible

scrollRectToVisible occurences:
javax.swing.JComponent.scrollRectToVisible(java.awt.Rectangle)
javax.swing.JTextField.scrollRectToVisible(java.awt.Rectangle)
javax.swing.JViewport.scrollRectToVisible(java.awt.Rectangle)


Occurences of scrollTimer

scrollTimer occurences:
javax.swing.plaf.basic.scrollTimer
javax.swing.plaf.basic.scrollTimer


Occurences of SCROLL_BAR

SCROLL_BAR occurences:
javax.accessibility.SCROLL_BAR
javax.swing.plaf.synth.SCROLL_BAR


Occurences of SCROLL_PANE

SCROLL_PANE occurences:
javax.accessibility.SCROLL_PANE
javax.swing.plaf.synth.SCROLL_PANE


Occurences of SealedObject (constructors)

SealedObject (constructors) occurences:
javax.crypto.SealedObject(java.io.Serializable, javax.crypto.Cipher)
javax.crypto.SealedObject(javax.crypto.SealedObject)


Occurences of search

search occurences:
java.util.Stack.search(java.lang.Object)
javax.naming.directory.DirContext.search(java.lang.String, java.lang.String, java.lang.Object[], javax.naming.directory.SearchControls)
javax.naming.directory.DirContext.search(java.lang.String, java.lang.String, javax.naming.directory.SearchControls)
javax.naming.directory.DirContext.search(java.lang.String, javax.naming.directory.Attributes)
javax.naming.directory.DirContext.search(java.lang.String, javax.naming.directory.Attributes, java.lang.String[])
javax.naming.directory.DirContext.search(javax.naming.Name, java.lang.String, java.lang.Object[], javax.naming.directory.SearchControls)
javax.naming.directory.DirContext.search(javax.naming.Name, java.lang.String, javax.naming.directory.SearchControls)
javax.naming.directory.DirContext.search(javax.naming.Name, javax.naming.directory.Attributes)
javax.naming.directory.DirContext.search(javax.naming.Name, javax.naming.directory.Attributes, java.lang.String[])
javax.naming.directory.InitialDirContext.search(java.lang.String, java.lang.String, java.lang.Object[], javax.naming.directory.SearchControls)
javax.naming.directory.InitialDirContext.search(java.lang.String, java.lang.String, javax.naming.directory.SearchControls)
javax.naming.directory.InitialDirContext.search(java.lang.String, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.search(java.lang.String, javax.naming.directory.Attributes, java.lang.String[])
javax.naming.directory.InitialDirContext.search(javax.naming.Name, java.lang.String, java.lang.Object[], javax.naming.directory.SearchControls)
javax.naming.directory.InitialDirContext.search(javax.naming.Name, java.lang.String, javax.naming.directory.SearchControls)
javax.naming.directory.InitialDirContext.search(javax.naming.Name, javax.naming.directory.Attributes)
javax.naming.directory.InitialDirContext.search(javax.naming.Name, javax.naming.directory.Attributes, java.lang.String[])


Occurences of Search Java Upgrade Guide

Search Java Upgrade Guide occurences:
Search Java Upgrade Guide
Search Java Upgrade Guide
Search Java Upgrade Guide
Search Java Upgrade Guide


Occurences of SearchControls (constructors)

SearchControls (constructors) occurences:
javax.naming.directory.SearchControls()
javax.naming.directory.SearchControls(int, long, int, java.lang.String[], boolean, boolean)


Occurences of SearchResult (constructors)

SearchResult (constructors) occurences:
javax.naming.directory.SearchResult(java.lang.String, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.directory.SearchResult(java.lang.String, java.lang.Object, javax.naming.directory.Attributes, boolean)
javax.naming.directory.SearchResult(java.lang.String, java.lang.String, java.lang.Object, javax.naming.directory.Attributes)
javax.naming.directory.SearchResult(java.lang.String, java.lang.String, java.lang.Object, javax.naming.directory.Attributes, boolean)


Occurences of SECOND

SECOND occurences:
java.text.SECOND
java.util.SECOND


Occurences of SECONDS

SECONDS occurences:
java.util.concurrent.SECONDS
javax.xml.datatype.SECONDS


Occurences of SecretKeySpec (constructors)

SecretKeySpec (constructors) occurences:
javax.crypto.spec.SecretKeySpec(byte[], int, int, java.lang.String)
javax.crypto.spec.SecretKeySpec(byte[], java.lang.String)


Occurences of SecureClassLoader (constructors)

SecureClassLoader (constructors) occurences:
java.security.SecureClassLoader()
java.security.SecureClassLoader(java.lang.ClassLoader)


Occurences of SecureRandom (constructors)

SecureRandom (constructors) occurences:
java.security.SecureRandom()
java.security.SecureRandom(byte[])
java.security.SecureRandom(java.security.SecureRandomSpi, java.security.Provider)


Occurences of Security

Security occurences:
java.security.Security
Security
Security
Security


Occurences of SecurityException (constructors)

SecurityException (constructors) occurences:
java.lang.SecurityException()
java.lang.SecurityException(java.lang.String)
java.lang.SecurityException(java.lang.String, java.lang.Throwable)
java.lang.SecurityException(java.lang.Throwable)


Occurences of SecurityPermission (constructors)

SecurityPermission (constructors) occurences:
java.security.SecurityPermission(java.lang.String)
java.security.SecurityPermission(java.lang.String, java.lang.String)


Occurences of seek

seek occurences:
java.io.RandomAccessFile.seek(long)
javax.imageio.stream.FileCacheImageOutputStream.seek(long)
javax.imageio.stream.FileImageInputStream.seek(long)
javax.imageio.stream.FileImageOutputStream.seek(long)
javax.imageio.stream.ImageInputStream.seek(long)
javax.imageio.stream.ImageInputStreamImpl.seek(long)
org.omg.CORBA.DynAny.seek(int)
org.omg.DynamicAny.DynAnyOperations.seek(int)
org.omg.DynamicAny._DynAnyStub.seek(int)
org.omg.DynamicAny._DynArrayStub.seek(int)
org.omg.DynamicAny._DynEnumStub.seek(int)
org.omg.DynamicAny._DynFixedStub.seek(int)
org.omg.DynamicAny._DynSequenceStub.seek(int)
org.omg.DynamicAny._DynStructStub.seek(int)
org.omg.DynamicAny._DynUnionStub.seek(int)
org.omg.DynamicAny._DynValueStub.seek(int)


Occurences of Segment (constructors)

Segment (constructors) occurences:
javax.swing.text.Segment()
javax.swing.text.Segment(char[], int, int)


Occurences of select

select occurences:
java.awt.Choice.select(int)
java.awt.Choice.select(java.lang.String)
java.awt.List.select(int)
java.awt.TextComponent.select(int, int)
java.net.ProxySelector.select(java.net.URI)
java.nio.channels.Selector.select()
java.nio.channels.Selector.select(long)
javax.swing.text.JTextComponent.select(int, int)
javax.xml.crypto.KeySelector.select(javax.xml.crypto.dsig.keyinfo.KeyInfo, javax.xml.crypto.KeySelector.Purpose, javax.xml.crypto.AlgorithmMethod, javax.xml.crypto.XMLCryptoContext)


Occurences of selectAll

selectAll occurences:
java.awt.TextComponent.selectAll()
javax.swing.ComboBoxEditor.selectAll()
javax.swing.JTable.selectAll()
javax.swing.plaf.basic.BasicComboBoxEditor.selectAll()
javax.swing.text.JTextComponent.selectAll()


Occurences of selectAllAccessibleSelection

selectAllAccessibleSelection occurences:
java.awt.List.AccessibleAWTList.selectAllAccessibleSelection()
java.awt.MenuComponent.AccessibleAWTMenuComponent.selectAllAccessibleSelection()
javax.accessibility.AccessibleSelection.selectAllAccessibleSelection()
javax.swing.JComboBox.AccessibleJComboBox.selectAllAccessibleSelection()
javax.swing.JList.AccessibleJList.selectAllAccessibleSelection()
javax.swing.JMenu.AccessibleJMenu.selectAllAccessibleSelection()
javax.swing.JMenuBar.AccessibleJMenuBar.selectAllAccessibleSelection()
javax.swing.JTabbedPane.AccessibleJTabbedPane.selectAllAccessibleSelection()
javax.swing.JTable.AccessibleJTable.selectAllAccessibleSelection()
javax.swing.JTree.AccessibleJTree.selectAllAccessibleSelection()
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.selectAllAccessibleSelection()


Occurences of selectColor

selectColor occurences:
javax.swing.plaf.metal.selectColor
javax.swing.plaf.metal.selectColor
javax.swing.plaf.metal.selectColor
javax.swing.plaf.metal.selectColor


Occurences of SELECTED

SELECTED occurences:
java.awt.event.SELECTED
javax.accessibility.SELECTED
javax.swing.plaf.synth.SELECTED
javax.swing.SELECTED
javax.swing.text.html.SELECTED


Occurences of selectInitialValue

selectInitialValue occurences:
javax.swing.JOptionPane.selectInitialValue()
javax.swing.plaf.basic.BasicOptionPaneUI.selectInitialValue(javax.swing.JOptionPane)
javax.swing.plaf.multi.MultiOptionPaneUI.selectInitialValue(javax.swing.JOptionPane)
javax.swing.plaf.OptionPaneUI.selectInitialValue(javax.swing.JOptionPane)


Occurences of selectionBackground

selectionBackground occurences:
javax.swing.plaf.basic.selectionBackground
javax.swing.selectionBackground


Occurences of selectionForeground

selectionForeground occurences:
javax.swing.plaf.basic.selectionForeground
javax.swing.selectionForeground


Occurences of selectionModel

selectionModel occurences:
javax.swing.selectionModel
javax.swing.selectionModel
javax.swing.table.selectionModel


Occurences of SELECTION_MODEL_PROPERTY

SELECTION_MODEL_PROPERTY occurences:
javax.swing.SELECTION_MODEL_PROPERTY
javax.swing.SELECTION_MODEL_PROPERTY


Occurences of selectText

selectText occurences:
javax.accessibility.AccessibleEditableText.selectText(int, int)
javax.swing.JSpinner.AccessibleJSpinner.selectText(int, int)
javax.swing.text.JTextComponent.AccessibleJTextComponent.selectText(int, int)


Occurences of Semaphore (constructors)

Semaphore (constructors) occurences:
java.util.concurrent.Semaphore(int)
java.util.concurrent.Semaphore(int, boolean)


Occurences of send

send occurences:
java.net.DatagramSocket.send(java.net.DatagramPacket)
java.net.DatagramSocketImpl.send(java.net.DatagramPacket)
java.net.MulticastSocket.send(java.net.DatagramPacket, byte)
java.nio.channels.DatagramChannel.send(java.nio.ByteBuffer, java.net.SocketAddress)
javax.sound.midi.Receiver.send(javax.sound.midi.MidiMessage, long)


Occurences of sendAttributeChangeNotification

sendAttributeChangeNotification occurences:
javax.management.modelmbean.ModelMBeanNotificationBroadcaster.sendAttributeChangeNotification(javax.management.Attribute, javax.management.Attribute)
javax.management.modelmbean.ModelMBeanNotificationBroadcaster.sendAttributeChangeNotification(javax.management.AttributeChangeNotification)
javax.management.modelmbean.RequiredModelMBean.sendAttributeChangeNotification(javax.management.Attribute, javax.management.Attribute)
javax.management.modelmbean.RequiredModelMBean.sendAttributeChangeNotification(javax.management.AttributeChangeNotification)


Occurences of sendNotification

sendNotification occurences:
javax.management.MBeanServerDelegate.sendNotification(javax.management.Notification)
javax.management.modelmbean.ModelMBeanNotificationBroadcaster.sendNotification(java.lang.String)
javax.management.modelmbean.ModelMBeanNotificationBroadcaster.sendNotification(javax.management.Notification)
javax.management.modelmbean.RequiredModelMBean.sendNotification(java.lang.String)
javax.management.modelmbean.RequiredModelMBean.sendNotification(javax.management.Notification)
javax.management.NotificationBroadcasterSupport.sendNotification(javax.management.Notification)
javax.management.StandardEmitterMBean.sendNotification(javax.management.Notification)


Occurences of sendRelationCreationNotification

sendRelationCreationNotification occurences:
javax.management.relation.RelationService.sendRelationCreationNotification(java.lang.String)
javax.management.relation.RelationServiceMBean.sendRelationCreationNotification(java.lang.String)


Occurences of sendRelationRemovalNotification

sendRelationRemovalNotification occurences:
javax.management.relation.RelationService.sendRelationRemovalNotification(java.lang.String, java.util.List)
javax.management.relation.RelationServiceMBean.sendRelationRemovalNotification(java.lang.String, java.util.List)


Occurences of sendRoleUpdateNotification

sendRoleUpdateNotification occurences:
javax.management.relation.RelationService.sendRoleUpdateNotification(java.lang.String, javax.management.relation.Role, java.util.List)
javax.management.relation.RelationServiceMBean.sendRoleUpdateNotification(java.lang.String, javax.management.relation.Role, java.util.List)


Occurences of sendUrgentData

sendUrgentData occurences:
java.net.Socket.sendUrgentData(int)
java.net.SocketImpl.sendUrgentData(int)


Occurences of SEPARATE_DOCUMENTS_COLLATED_COPIES

SEPARATE_DOCUMENTS_COLLATED_COPIES occurences:
java.awt.SEPARATE_DOCUMENTS_COLLATED_COPIES
javax.print.attribute.standard.SEPARATE_DOCUMENTS_COLLATED_COPIES


Occurences of SEPARATE_DOCUMENTS_UNCOLLATED_COPIES

SEPARATE_DOCUMENTS_UNCOLLATED_COPIES occurences:
java.awt.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES
javax.print.attribute.standard.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES


Occurences of SEPARATOR

SEPARATOR occurences:
javax.accessibility.SEPARATOR
javax.swing.plaf.synth.SEPARATOR


Occurences of SEPTEMBER

SEPTEMBER occurences:
java.util.SEPTEMBER
javax.xml.datatype.SEPTEMBER


Occurences of Sequence (constructors)

Sequence (constructors) occurences:
javax.sound.midi.Sequence(float, int)
javax.sound.midi.Sequence(float, int, int)


Occurences of SequenceInputStream (constructors)

SequenceInputStream (constructors) occurences:
java.io.SequenceInputStream(java.io.InputStream, java.io.InputStream)
java.io.SequenceInputStream(java.util.Enumeration)


Occurences of SerialArray (constructors)

SerialArray (constructors) occurences:
javax.sql.rowset.serial.SerialArray(java.sql.Array)
javax.sql.rowset.serial.SerialArray(java.sql.Array, java.util.Map)


Occurences of SerialBlob (constructors)

SerialBlob (constructors) occurences:
javax.sql.rowset.serial.SerialBlob(byte[])
javax.sql.rowset.serial.SerialBlob(java.sql.Blob)


Occurences of SerialClob (constructors)

SerialClob (constructors) occurences:
javax.sql.rowset.serial.SerialClob(char[])
javax.sql.rowset.serial.SerialClob(java.sql.Clob)


Occurences of SerialException (constructors)

SerialException (constructors) occurences:
javax.sql.rowset.serial.SerialException()
javax.sql.rowset.serial.SerialException(java.lang.String)


Occurences of SerializablePermission (constructors)

SerializablePermission (constructors) occurences:
java.io.SerializablePermission(java.lang.String)
java.io.SerializablePermission(java.lang.String, java.lang.String)


Occurences of Serialization, Evolution, and the Addition of a New SuperClass

Serialization, Evolution, and the Addition of a New SuperClass occurences:
Serialization, Evolution, and the Addition of a New SuperClass
Serialization, Evolution, and the Addition of a New SuperClass
Serialization, Evolution, and the Addition of a New SuperClass


Occurences of SerialStruct (constructors)

SerialStruct (constructors) occurences:
javax.sql.rowset.serial.SerialStruct(java.sql.SQLData, java.util.Map)
javax.sql.rowset.serial.SerialStruct(java.sql.Struct, java.util.Map)


Occurences of serialver - The Serial Version Command

serialver - The Serial Version Command occurences:
serialver - The Serial Version Command
serialver - The Serial Version Command
serialver - The Serial Version Command


Occurences of serialVersionUID

serialVersionUID occurences:
java.rmi.server.serialVersionUID
java.rmi.server.serialVersionUID
java.security.interfaces.serialVersionUID
java.security.interfaces.serialVersionUID
java.security.interfaces.serialVersionUID
java.security.interfaces.serialVersionUID
java.security.interfaces.serialVersionUID
java.security.interfaces.serialVersionUID
java.security.interfaces.serialVersionUID
java.security.interfaces.serialVersionUID
java.security.serialVersionUID
java.security.serialVersionUID
java.security.serialVersionUID
javax.crypto.interfaces.serialVersionUID
javax.crypto.interfaces.serialVersionUID
javax.crypto.interfaces.serialVersionUID
javax.crypto.serialVersionUID
javax.naming.directory.serialVersionUID
javax.naming.serialVersionUID


Occurences of ServantAlreadyActive (constructors)

ServantAlreadyActive (constructors) occurences:
org.omg.PortableServer.POAPackage.ServantAlreadyActive()
org.omg.PortableServer.POAPackage.ServantAlreadyActive(java.lang.String)


Occurences of ServantNotActive (constructors)

ServantNotActive (constructors) occurences:
org.omg.PortableServer.POAPackage.ServantNotActive()
org.omg.PortableServer.POAPackage.ServantNotActive(java.lang.String)


Occurences of server

server occurences:
java.rmi.server
javax.management.monitor.server


Occurences of ServerCloneException (constructors)

ServerCloneException (constructors) occurences:
java.rmi.server.ServerCloneException(java.lang.String)
java.rmi.server.ServerCloneException(java.lang.String, java.lang.Exception)


Occurences of ServerException (constructors)

ServerException (constructors) occurences:
java.rmi.ServerException(java.lang.String)
java.rmi.ServerException(java.lang.String, java.lang.Exception)


Occurences of ServerNotActiveException (constructors)

ServerNotActiveException (constructors) occurences:
java.rmi.server.ServerNotActiveException()
java.rmi.server.ServerNotActiveException(java.lang.String)


Occurences of ServerSocket (constructors)

ServerSocket (constructors) occurences:
java.net.ServerSocket()
java.net.ServerSocket(int)
java.net.ServerSocket(int, int)
java.net.ServerSocket(int, int, java.net.InetAddress)


Occurences of server_id

server_id occurences:
org.omg.PortableInterceptor.ObjectReferenceTemplate.server_id()
org.omg.PortableInterceptor.ServerRequestInfoOperations.server_id()


Occurences of serviceAvailable

serviceAvailable occurences:
java.beans.beancontext.BeanContextChildSupport.serviceAvailable(java.beans.beancontext.BeanContextServiceAvailableEvent)
java.beans.beancontext.BeanContextServicesListener.serviceAvailable(java.beans.beancontext.BeanContextServiceAvailableEvent)
java.beans.beancontext.BeanContextServicesSupport.serviceAvailable(java.beans.beancontext.BeanContextServiceAvailableEvent)


Occurences of serviceClass

serviceClass occurences:
java.beans.beancontext.serviceClass
java.beans.beancontext.serviceClass


Occurences of ServiceConfigurationError (constructors)

ServiceConfigurationError (constructors) occurences:
java.util.ServiceConfigurationError(java.lang.String)
java.util.ServiceConfigurationError(java.lang.String, java.lang.Throwable)


Occurences of ServiceContext (constructors)

ServiceContext (constructors) occurences:
org.omg.IOP.ServiceContext()
org.omg.IOP.ServiceContext(int, byte[])


Occurences of ServiceContextHolder (constructors)

ServiceContextHolder (constructors) occurences:
org.omg.IOP.ServiceContextHolder()
org.omg.IOP.ServiceContextHolder(org.omg.IOP.ServiceContext)


Occurences of ServiceContextListHolder (constructors)

ServiceContextListHolder (constructors) occurences:
org.omg.IOP.ServiceContextListHolder()
org.omg.IOP.ServiceContextListHolder(org.omg.IOP.ServiceContext[])


Occurences of ServiceDetail (constructors)

ServiceDetail (constructors) occurences:
org.omg.CORBA.ServiceDetail()
org.omg.CORBA.ServiceDetail(int, byte[])


Occurences of ServiceInformation (constructors)

ServiceInformation (constructors) occurences:
org.omg.CORBA.ServiceInformation()
org.omg.CORBA.ServiceInformation(int[], org.omg.CORBA.ServiceDetail[])


Occurences of ServiceInformationHolder (constructors)

ServiceInformationHolder (constructors) occurences:
org.omg.CORBA.ServiceInformationHolder()
org.omg.CORBA.ServiceInformationHolder(org.omg.CORBA.ServiceInformation)


Occurences of serviceName

serviceName occurences:
javax.jws.WebService.serviceName()
javax.xml.ws.WebServiceProvider.serviceName()


Occurences of ServiceNotFoundException (constructors)

ServiceNotFoundException (constructors) occurences:
javax.management.ServiceNotFoundException()
javax.management.ServiceNotFoundException(java.lang.String)


Occurences of serviceRevoked

serviceRevoked occurences:
java.beans.beancontext.BeanContextChildSupport.serviceRevoked(java.beans.beancontext.BeanContextServiceRevokedEvent)
java.beans.beancontext.BeanContextServiceRevokedListener.serviceRevoked(java.beans.beancontext.BeanContextServiceRevokedEvent)
java.beans.beancontext.BeanContextServicesSupport.serviceRevoked(java.beans.beancontext.BeanContextServiceRevokedEvent)
java.beans.beancontext.BeanContextServicesSupport.BCSSProxyServiceProvider.serviceRevoked(java.beans.beancontext.BeanContextServiceRevokedEvent)


Occurences of ServiceUnavailableException (constructors)

ServiceUnavailableException (constructors) occurences:
javax.naming.ServiceUnavailableException()
javax.naming.ServiceUnavailableException(java.lang.String)


Occurences of set

set occurences:
java.awt.image.renderable.ParameterBlock.set(byte, int)
java.awt.image.renderable.ParameterBlock.set(char, int)
java.awt.image.renderable.ParameterBlock.set(double, int)
java.awt.image.renderable.ParameterBlock.set(float, int)
java.awt.image.renderable.ParameterBlock.set(int, int)
java.awt.image.renderable.ParameterBlock.set(java.lang.Object, int)
java.awt.image.renderable.ParameterBlock.set(long, int)
java.awt.image.renderable.ParameterBlock.set(short, int)
java.awt.Insets.set(int, int, int, int)
java.awt.JobAttributes.set(java.awt.JobAttributes)
java.awt.PageAttributes.set(java.awt.PageAttributes)
java.lang.reflect.Array.set(java.lang.Object, int, java.lang.Object)
java.lang.reflect.Field.set(java.lang.Object, java.lang.Object)
java.lang.ThreadLocal.set(java.lang.Object)
java.lang.ThreadLocal.set(T)
java.net.URL.set(java.lang.String, java.lang.String, int, java.lang.String, java.lang.String)
java.net.URL.set(java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
java.util.AbstractList.set(int, E)
java.util.AbstractList.set(int,java.lang.Object)
java.util.AbstractSequentialList.set(int, E)
java.util.AbstractSequentialList.set(int,java.lang.Object)
java.util.ArrayList.set(int, E)
java.util.ArrayList.set(int,java.lang.Object)
java.util.BitSet.set(int)
java.util.BitSet.set(int, boolean)
java.util.BitSet.set(int, int)
java.util.BitSet.set(int, int, boolean)
java.util.Calendar.set(int, int)
java.util.Calendar.set(int, int, int)
java.util.Calendar.set(int, int, int, int, int)
java.util.Calendar.set(int, int, int, int, int, int)
java.util.concurrent.atomic.AtomicBoolean.set(boolean)
java.util.concurrent.atomic.AtomicInteger.set(int)
java.util.concurrent.atomic.AtomicIntegerArray.set(int, int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.set(java.lang.Object,int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.set(T, int)
java.util.concurrent.atomic.AtomicLong.set(long)
java.util.concurrent.atomic.AtomicLongArray.set(int, long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.set(java.lang.Object,long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.set(T, long)
java.util.concurrent.atomic.AtomicMarkableReference.set(java.lang.Object,boolean)
java.util.concurrent.atomic.AtomicMarkableReference.set(V, boolean)
java.util.concurrent.atomic.AtomicReference.set(java.lang.Object)
java.util.concurrent.atomic.AtomicReference.set(V)
java.util.concurrent.atomic.AtomicReferenceArray.set(int, E)
java.util.concurrent.atomic.AtomicReferenceArray.set(int,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.set(java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.set(T, V)
java.util.concurrent.atomic.AtomicStampedReference.set(java.lang.Object,int)
java.util.concurrent.atomic.AtomicStampedReference.set(V, int)
java.util.concurrent.CopyOnWriteArrayList.set(int, E)
java.util.concurrent.CopyOnWriteArrayList.set(int,java.lang.Object)
java.util.concurrent.FutureTask.set(java.lang.Object)
java.util.concurrent.FutureTask.set(V)
java.util.LinkedList.set(int, E)
java.util.LinkedList.set(int,java.lang.Object)
java.util.List.set(int, E)
java.util.List.set(int,java.lang.Object)
java.util.ListIterator.set(E)
java.util.ListIterator.set(java.lang.Object)
java.util.Vector.set(int, E)
java.util.Vector.set(int,java.lang.Object)
javax.activation.MimeTypeParameterList.set(java.lang.String, java.lang.String)
javax.management.AttributeList.set(int, java.lang.Object)
javax.management.AttributeList.set(int, javax.management.Attribute)
javax.management.relation.RoleList.set(int, java.lang.Object)
javax.management.relation.RoleList.set(int, javax.management.relation.Role)
javax.management.relation.RoleUnresolvedList.set(int, java.lang.Object)
javax.management.relation.RoleUnresolvedList.set(int, javax.management.relation.RoleUnresolved)
javax.naming.directory.Attribute.set(int, java.lang.Object)
javax.naming.directory.BasicAttribute.set(int, java.lang.Object)
javax.swing.DefaultListModel.set(int, java.lang.Object)


Occurences of setAccelerator

setAccelerator occurences:
javax.swing.JMenu.setAccelerator(javax.swing.KeyStroke)
javax.swing.JMenuItem.setAccelerator(javax.swing.KeyStroke)


Occurences of setAccessible

setAccessible occurences:
java.lang.reflect.AccessibleObject.setAccessible(boolean)
java.lang.reflect.AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean)


Occurences of setAccessibleCaption

setAccessibleCaption occurences:
javax.accessibility.AccessibleTable.setAccessibleCaption(javax.accessibility.Accessible)
javax.swing.JTable.AccessibleJTable.setAccessibleCaption(javax.accessibility.Accessible)


Occurences of setAccessibleColumnDescription

setAccessibleColumnDescription occurences:
javax.accessibility.AccessibleTable.setAccessibleColumnDescription(int, javax.accessibility.Accessible)
javax.swing.JTable.AccessibleJTable.setAccessibleColumnDescription(int, javax.accessibility.Accessible)


Occurences of setAccessibleColumnHeader

setAccessibleColumnHeader occurences:
javax.accessibility.AccessibleTable.setAccessibleColumnHeader(javax.accessibility.AccessibleTable)
javax.swing.JTable.AccessibleJTable.setAccessibleColumnHeader(javax.accessibility.AccessibleTable)


Occurences of setAccessibleDescription

setAccessibleDescription occurences:
javax.accessibility.AccessibleContext.setAccessibleDescription(java.lang.String)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setAccessibleDescription(java.lang.String)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setAccessibleDescription(java.lang.String)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setAccessibleDescription(java.lang.String)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setAccessibleDescription(java.lang.String)


Occurences of setAccessibleIconDescription

setAccessibleIconDescription occurences:
javax.accessibility.AccessibleIcon.setAccessibleIconDescription(java.lang.String)
javax.swing.ImageIcon.AccessibleImageIcon.setAccessibleIconDescription(java.lang.String)


Occurences of setAccessibleName

setAccessibleName occurences:
javax.accessibility.AccessibleContext.setAccessibleName(java.lang.String)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setAccessibleName(java.lang.String)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setAccessibleName(java.lang.String)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setAccessibleName(java.lang.String)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setAccessibleName(java.lang.String)


Occurences of setAccessibleRowDescription

setAccessibleRowDescription occurences:
javax.accessibility.AccessibleTable.setAccessibleRowDescription(int, javax.accessibility.Accessible)
javax.swing.JTable.AccessibleJTable.setAccessibleRowDescription(int, javax.accessibility.Accessible)


Occurences of setAccessibleRowHeader

setAccessibleRowHeader occurences:
javax.accessibility.AccessibleTable.setAccessibleRowHeader(javax.accessibility.AccessibleTable)
javax.swing.JTable.AccessibleJTable.setAccessibleRowHeader(javax.accessibility.AccessibleTable)


Occurences of setAccessibleSummary

setAccessibleSummary occurences:
javax.accessibility.AccessibleTable.setAccessibleSummary(javax.accessibility.Accessible)
javax.swing.JTable.AccessibleJTable.setAccessibleSummary(javax.accessibility.Accessible)


Occurences of setAction

setAction occurences:
javax.swing.AbstractButton.setAction(javax.swing.Action)
javax.swing.JComboBox.setAction(javax.swing.Action)
javax.swing.JTextField.setAction(javax.swing.Action)


Occurences of setActionCommand

setActionCommand occurences:
java.awt.Button.setActionCommand(java.lang.String)
java.awt.MenuItem.setActionCommand(java.lang.String)
java.awt.TrayIcon.setActionCommand(java.lang.String)
javax.swing.AbstractButton.setActionCommand(java.lang.String)
javax.swing.ButtonModel.setActionCommand(java.lang.String)
javax.swing.DefaultButtonModel.setActionCommand(java.lang.String)
javax.swing.JComboBox.setActionCommand(java.lang.String)
javax.swing.JTextField.setActionCommand(java.lang.String)
javax.swing.Timer.setActionCommand(java.lang.String)


Occurences of setAdapter

setAdapter occurences:
javax.xml.bind.helpers.AbstractMarshallerImpl.setAdapter(java.lang.Class, A)
javax.xml.bind.helpers.AbstractMarshallerImpl.setAdapter(java.lang.Class,javax.xml.bind.annotation.adapters.XmlAdapter)
javax.xml.bind.helpers.AbstractMarshallerImpl.setAdapter(javax.xml.bind.annotation.adapters.XmlAdapter)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setAdapter(java.lang.Class, A)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setAdapter(java.lang.Class,javax.xml.bind.annotation.adapters.XmlAdapter)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setAdapter(javax.xml.bind.annotation.adapters.XmlAdapter)
javax.xml.bind.Marshaller.setAdapter(java.lang.Class, A)
javax.xml.bind.Marshaller.setAdapter(java.lang.Class,javax.xml.bind.annotation.adapters.XmlAdapter)
javax.xml.bind.Marshaller.setAdapter(javax.xml.bind.annotation.adapters.XmlAdapter)
javax.xml.bind.Unmarshaller.setAdapter(java.lang.Class, A)
javax.xml.bind.Unmarshaller.setAdapter(java.lang.Class,javax.xml.bind.annotation.adapters.XmlAdapter)
javax.xml.bind.Unmarshaller.setAdapter(javax.xml.bind.annotation.adapters.XmlAdapter)


Occurences of setAlignment

setAlignment occurences:
java.awt.FlowLayout.setAlignment(int)
java.awt.Label.setAlignment(int)
javax.swing.text.StyleConstants.setAlignment(javax.swing.text.MutableAttributeSet, int)


Occurences of setAnchorSelectionIndex

setAnchorSelectionIndex occurences:
javax.swing.DefaultListSelectionModel.setAnchorSelectionIndex(int)
javax.swing.ListSelectionModel.setAnchorSelectionIndex(int)


Occurences of setAngleExtent

setAngleExtent occurences:
java.awt.geom.Arc2D.setAngleExtent(double)
java.awt.geom.Arc2D.Double.setAngleExtent(double)
java.awt.geom.Arc2D.Float.setAngleExtent(double)


Occurences of setAngles

setAngles occurences:
java.awt.geom.Arc2D.setAngles(double, double, double, double)
java.awt.geom.Arc2D.setAngles(java.awt.geom.Point2D, java.awt.geom.Point2D)


Occurences of setAngleStart

setAngleStart occurences:
java.awt.geom.Arc2D.setAngleStart(double)
java.awt.geom.Arc2D.setAngleStart(java.awt.geom.Point2D)
java.awt.geom.Arc2D.Double.setAngleStart(double)
java.awt.geom.Arc2D.Float.setAngleStart(double)


Occurences of setApproveButtonMnemonic

setApproveButtonMnemonic occurences:
javax.swing.JFileChooser.setApproveButtonMnemonic(char)
javax.swing.JFileChooser.setApproveButtonMnemonic(int)


Occurences of setArc

setArc occurences:
java.awt.geom.Arc2D.setArc(double, double, double, double, double, double, int)
java.awt.geom.Arc2D.setArc(java.awt.geom.Arc2D)
java.awt.geom.Arc2D.setArc(java.awt.geom.Point2D, java.awt.geom.Dimension2D, double, double, int)
java.awt.geom.Arc2D.setArc(java.awt.geom.Rectangle2D, double, double, int)
java.awt.geom.Arc2D.Double.setArc(double, double, double, double, double, double, int)
java.awt.geom.Arc2D.Float.setArc(double, double, double, double, double, double, int)


Occurences of setArmed

setArmed occurences:
javax.swing.ButtonModel.setArmed(boolean)
javax.swing.DefaultButtonModel.setArmed(boolean)
javax.swing.JMenuItem.setArmed(boolean)


Occurences of setArray

setArray occurences:
java.sql.PreparedStatement.setArray(int, java.sql.Array)
javax.sql.RowSet.setArray(int, java.sql.Array)
javax.sql.rowset.BaseRowSet.setArray(int, java.sql.Array)


Occurences of setAsciiStream

setAsciiStream occurences:
java.sql.CallableStatement.setAsciiStream(java.lang.String, java.io.InputStream)
java.sql.CallableStatement.setAsciiStream(java.lang.String, java.io.InputStream, int)
java.sql.CallableStatement.setAsciiStream(java.lang.String, java.io.InputStream, long)
java.sql.Clob.setAsciiStream(long)
java.sql.PreparedStatement.setAsciiStream(int, java.io.InputStream)
java.sql.PreparedStatement.setAsciiStream(int, java.io.InputStream, int)
java.sql.PreparedStatement.setAsciiStream(int, java.io.InputStream, long)
javax.sql.RowSet.setAsciiStream(int, java.io.InputStream)
javax.sql.RowSet.setAsciiStream(int, java.io.InputStream, int)
javax.sql.RowSet.setAsciiStream(java.lang.String, java.io.InputStream)
javax.sql.RowSet.setAsciiStream(java.lang.String, java.io.InputStream, int)
javax.sql.rowset.BaseRowSet.setAsciiStream(int, java.io.InputStream)
javax.sql.rowset.BaseRowSet.setAsciiStream(int, java.io.InputStream, int)
javax.sql.rowset.BaseRowSet.setAsciiStream(java.lang.String, java.io.InputStream)
javax.sql.rowset.BaseRowSet.setAsciiStream(java.lang.String, java.io.InputStream, int)
javax.sql.rowset.serial.SerialClob.setAsciiStream(long)


Occurences of setAsText

setAsText occurences:
java.beans.PropertyEditor.setAsText(java.lang.String)
java.beans.PropertyEditorSupport.setAsText(java.lang.String)


Occurences of setAttachmentMarshaller

setAttachmentMarshaller occurences:
javax.xml.bind.helpers.AbstractMarshallerImpl.setAttachmentMarshaller(javax.xml.bind.attachment.AttachmentMarshaller)
javax.xml.bind.Marshaller.setAttachmentMarshaller(javax.xml.bind.attachment.AttachmentMarshaller)


Occurences of setAttachmentUnmarshaller

setAttachmentUnmarshaller occurences:
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setAttachmentUnmarshaller(javax.xml.bind.attachment.AttachmentUnmarshaller)
javax.xml.bind.Unmarshaller.setAttachmentUnmarshaller(javax.xml.bind.attachment.AttachmentUnmarshaller)


Occurences of setAttribute

setAttribute occurences:
javax.imageio.metadata.IIOMetadataNode.setAttribute(java.lang.String, java.lang.String)
javax.management.DynamicMBean.setAttribute(javax.management.Attribute)
javax.management.MBeanServer.setAttribute(javax.management.ObjectName, javax.management.Attribute)
javax.management.MBeanServerConnection.setAttribute(javax.management.ObjectName, javax.management.Attribute)
javax.management.modelmbean.RequiredModelMBean.setAttribute(javax.management.Attribute)
javax.management.remote.rmi.RMIConnection.setAttribute(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.setAttribute(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.setAttribute(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.StandardMBean.setAttribute(javax.management.Attribute)
javax.script.ScriptContext.setAttribute(java.lang.String, java.lang.Object, int)
javax.script.SimpleScriptContext.setAttribute(java.lang.String, java.lang.Object, int)
javax.xml.parsers.DocumentBuilderFactory.setAttribute(java.lang.String, java.lang.Object)
javax.xml.transform.TransformerFactory.setAttribute(java.lang.String, java.lang.Object)
org.w3c.dom.Element.setAttribute(java.lang.String, java.lang.String)
org.xml.sax.helpers.AttributesImpl.setAttribute(int, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)


Occurences of setAttributeNode

setAttributeNode occurences:
javax.imageio.metadata.IIOMetadataNode.setAttributeNode(org.w3c.dom.Attr)
org.w3c.dom.Element.setAttributeNode(org.w3c.dom.Attr)


Occurences of setAttributeNodeNS

setAttributeNodeNS occurences:
javax.imageio.metadata.IIOMetadataNode.setAttributeNodeNS(org.w3c.dom.Attr)
org.w3c.dom.Element.setAttributeNodeNS(org.w3c.dom.Attr)


Occurences of setAttributeNS

setAttributeNS occurences:
javax.imageio.metadata.IIOMetadataNode.setAttributeNS(java.lang.String, java.lang.String, java.lang.String)
org.w3c.dom.Element.setAttributeNS(java.lang.String, java.lang.String, java.lang.String)


Occurences of setAttributes

setAttributes occurences:
javax.accessibility.AccessibleEditableText.setAttributes(int, int, javax.swing.text.AttributeSet)
javax.management.DynamicMBean.setAttributes(javax.management.AttributeList)
javax.management.MBeanServer.setAttributes(javax.management.ObjectName, javax.management.AttributeList)
javax.management.MBeanServerConnection.setAttributes(javax.management.ObjectName, javax.management.AttributeList)
javax.management.modelmbean.RequiredModelMBean.setAttributes(javax.management.AttributeList)
javax.management.remote.rmi.RMIConnection.setAttributes(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.setAttributes(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.setAttributes(javax.management.ObjectName, java.rmi.MarshalledObject, javax.security.auth.Subject)
javax.management.StandardMBean.setAttributes(javax.management.AttributeList)
javax.naming.directory.SearchResult.setAttributes(javax.naming.directory.Attributes)
javax.swing.JSpinner.AccessibleJSpinner.setAttributes(int, int, javax.swing.text.AttributeSet)
javax.swing.text.JTextComponent.AccessibleJTextComponent.setAttributes(int, int, javax.swing.text.AttributeSet)
org.xml.sax.ext.Attributes2Impl.setAttributes(org.xml.sax.Attributes)
org.xml.sax.helpers.AttributesImpl.setAttributes(org.xml.sax.Attributes)


Occurences of setAutoCommit

setAutoCommit occurences:
java.sql.Connection.setAutoCommit(boolean)
javax.sql.rowset.JdbcRowSet.setAutoCommit(boolean)


Occurences of setAutoIncrement

setAutoIncrement occurences:
javax.sql.rowset.RowSetMetaDataImpl.setAutoIncrement(int, boolean)
javax.sql.RowSetMetaData.setAutoIncrement(int, boolean)


Occurences of setBackground

setBackground occurences:
java.awt.Component.setBackground(java.awt.Color)
java.awt.Component.AccessibleAWTComponent.setBackground(java.awt.Color)
java.awt.Graphics2D.setBackground(java.awt.Color)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setBackground(java.awt.Color)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setBackground(java.awt.Color)
java.awt.TextComponent.setBackground(java.awt.Color)
javax.accessibility.AccessibleComponent.setBackground(java.awt.Color)
javax.swing.JComponent.setBackground(java.awt.Color)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setBackground(java.awt.Color)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setBackground(java.awt.Color)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setBackground(java.awt.Color)
javax.swing.table.DefaultTableCellRenderer.setBackground(java.awt.Color)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setBackground(java.awt.Color)
javax.swing.text.LabelView.setBackground(java.awt.Color)
javax.swing.text.StyleConstants.setBackground(javax.swing.text.MutableAttributeSet, java.awt.Color)
javax.swing.tree.DefaultTreeCellRenderer.setBackground(java.awt.Color)


Occurences of setBase

setBase occurences:
javax.swing.text.html.HTMLDocument.setBase(java.net.URL)
javax.swing.text.html.StyleSheet.setBase(java.net.URL)


Occurences of setBaseFontSize

setBaseFontSize occurences:
javax.swing.text.html.StyleSheet.setBaseFontSize(int)
javax.swing.text.html.StyleSheet.setBaseFontSize(java.lang.String)


Occurences of setBaseURI

setBaseURI occurences:
javax.xml.crypto.dom.DOMCryptoContext.setBaseURI(java.lang.String)
javax.xml.crypto.XMLCryptoContext.setBaseURI(java.lang.String)
org.w3c.dom.ls.LSInput.setBaseURI(java.lang.String)


Occurences of setBeanContext

setBeanContext occurences:
java.beans.beancontext.BeanContextChild.setBeanContext(java.beans.beancontext.BeanContext)
java.beans.beancontext.BeanContextChildSupport.setBeanContext(java.beans.beancontext.BeanContext)


Occurences of setBigDecimal

setBigDecimal occurences:
java.sql.CallableStatement.setBigDecimal(java.lang.String, java.math.BigDecimal)
java.sql.PreparedStatement.setBigDecimal(int, java.math.BigDecimal)
javax.sql.RowSet.setBigDecimal(int, java.math.BigDecimal)
javax.sql.RowSet.setBigDecimal(java.lang.String, java.math.BigDecimal)
javax.sql.rowset.BaseRowSet.setBigDecimal(int, java.math.BigDecimal)
javax.sql.rowset.BaseRowSet.setBigDecimal(java.lang.String, java.math.BigDecimal)


Occurences of setBinaryStream

setBinaryStream occurences:
java.sql.Blob.setBinaryStream(long)
java.sql.CallableStatement.setBinaryStream(java.lang.String, java.io.InputStream)
java.sql.CallableStatement.setBinaryStream(java.lang.String, java.io.InputStream, int)
java.sql.CallableStatement.setBinaryStream(java.lang.String, java.io.InputStream, long)
java.sql.PreparedStatement.setBinaryStream(int, java.io.InputStream)
java.sql.PreparedStatement.setBinaryStream(int, java.io.InputStream, int)
java.sql.PreparedStatement.setBinaryStream(int, java.io.InputStream, long)
java.sql.SQLXML.setBinaryStream()
javax.sql.RowSet.setBinaryStream(int, java.io.InputStream)
javax.sql.RowSet.setBinaryStream(int, java.io.InputStream, int)
javax.sql.RowSet.setBinaryStream(java.lang.String, java.io.InputStream)
javax.sql.RowSet.setBinaryStream(java.lang.String, java.io.InputStream, int)
javax.sql.rowset.BaseRowSet.setBinaryStream(int, java.io.InputStream)
javax.sql.rowset.BaseRowSet.setBinaryStream(int, java.io.InputStream, int)
javax.sql.rowset.BaseRowSet.setBinaryStream(java.lang.String, java.io.InputStream)
javax.sql.rowset.BaseRowSet.setBinaryStream(java.lang.String, java.io.InputStream, int)
javax.sql.rowset.serial.SerialBlob.setBinaryStream(long)


Occurences of setBindings

setBindings occurences:
javax.script.AbstractScriptEngine.setBindings(javax.script.Bindings, int)
javax.script.ScriptContext.setBindings(javax.script.Bindings, int)
javax.script.ScriptEngine.setBindings(javax.script.Bindings, int)
javax.script.ScriptEngineManager.setBindings(javax.script.Bindings)
javax.script.SimpleScriptContext.setBindings(javax.script.Bindings, int)


Occurences of setBitOffset

setBitOffset occurences:
javax.imageio.stream.ImageInputStream.setBitOffset(int)
javax.imageio.stream.ImageInputStreamImpl.setBitOffset(int)


Occurences of setBlinkRate

setBlinkRate occurences:
javax.swing.text.Caret.setBlinkRate(int)
javax.swing.text.DefaultCaret.setBlinkRate(int)


Occurences of setBlob

setBlob occurences:
java.sql.CallableStatement.setBlob(java.lang.String, java.io.InputStream)
java.sql.CallableStatement.setBlob(java.lang.String, java.io.InputStream, long)
java.sql.CallableStatement.setBlob(java.lang.String, java.sql.Blob)
java.sql.PreparedStatement.setBlob(int, java.io.InputStream)
java.sql.PreparedStatement.setBlob(int, java.io.InputStream, long)
java.sql.PreparedStatement.setBlob(int, java.sql.Blob)
javax.sql.RowSet.setBlob(int, java.io.InputStream)
javax.sql.RowSet.setBlob(int, java.io.InputStream, long)
javax.sql.RowSet.setBlob(int, java.sql.Blob)
javax.sql.RowSet.setBlob(java.lang.String, java.io.InputStream)
javax.sql.RowSet.setBlob(java.lang.String, java.io.InputStream, long)
javax.sql.RowSet.setBlob(java.lang.String, java.sql.Blob)
javax.sql.rowset.BaseRowSet.setBlob(int, java.io.InputStream)
javax.sql.rowset.BaseRowSet.setBlob(int, java.io.InputStream, long)
javax.sql.rowset.BaseRowSet.setBlob(int, java.sql.Blob)
javax.sql.rowset.BaseRowSet.setBlob(java.lang.String, java.io.InputStream)
javax.sql.rowset.BaseRowSet.setBlob(java.lang.String, java.io.InputStream, long)
javax.sql.rowset.BaseRowSet.setBlob(java.lang.String, java.sql.Blob)


Occurences of setBlockIncrement

setBlockIncrement occurences:
java.awt.Adjustable.setBlockIncrement(int)
java.awt.Scrollbar.setBlockIncrement(int)
java.awt.ScrollPaneAdjustable.setBlockIncrement(int)
javax.swing.JScrollBar.setBlockIncrement(int)
javax.swing.JScrollPane.ScrollBar.setBlockIncrement(int)


Occurences of setBoolean

setBoolean occurences:
java.lang.reflect.Array.setBoolean(java.lang.Object, int, boolean)
java.lang.reflect.Field.setBoolean(java.lang.Object, boolean)
java.sql.CallableStatement.setBoolean(java.lang.String, boolean)
java.sql.PreparedStatement.setBoolean(int, boolean)
javax.sql.RowSet.setBoolean(int, boolean)
javax.sql.RowSet.setBoolean(java.lang.String, boolean)
javax.sql.rowset.BaseRowSet.setBoolean(int, boolean)
javax.sql.rowset.BaseRowSet.setBoolean(java.lang.String, boolean)


Occurences of setBorder

setBorder occurences:
javax.swing.border.TitledBorder.setBorder(javax.swing.border.Border)
javax.swing.JComponent.setBorder(javax.swing.border.Border)
javax.swing.JViewport.setBorder(javax.swing.border.Border)
javax.swing.plaf.basic.BasicSplitPaneDivider.setBorder(javax.swing.border.Border)
javax.swing.tree.DefaultTreeCellEditor.DefaultTextField.setBorder(javax.swing.border.Border)


Occurences of setBorderPainted

setBorderPainted occurences:
javax.swing.AbstractButton.setBorderPainted(boolean)
javax.swing.JMenuBar.setBorderPainted(boolean)
javax.swing.JPopupMenu.setBorderPainted(boolean)
javax.swing.JProgressBar.setBorderPainted(boolean)
javax.swing.JToolBar.setBorderPainted(boolean)


Occurences of setBorderSelectionColor

setBorderSelectionColor occurences:
javax.swing.tree.DefaultTreeCellEditor.setBorderSelectionColor(java.awt.Color)
javax.swing.tree.DefaultTreeCellRenderer.setBorderSelectionColor(java.awt.Color)


Occurences of setBorderToNonRollover

setBorderToNonRollover occurences:
javax.swing.plaf.basic.BasicToolBarUI.setBorderToNonRollover(java.awt.Component)
javax.swing.plaf.metal.MetalToolBarUI.setBorderToNonRollover(java.awt.Component)


Occurences of setBounds

setBounds occurences:
java.awt.Component.setBounds(int, int, int, int)
java.awt.Component.setBounds(java.awt.Rectangle)
java.awt.Component.AccessibleAWTComponent.setBounds(java.awt.Rectangle)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setBounds(java.awt.Rectangle)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setBounds(java.awt.Rectangle)
java.awt.Rectangle.setBounds(int, int, int, int)
java.awt.Rectangle.setBounds(java.awt.Rectangle)
java.awt.Window.setBounds(int, int, int, int)
java.awt.Window.setBounds(java.awt.Rectangle)
javax.accessibility.AccessibleComponent.setBounds(java.awt.Rectangle)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setBounds(java.awt.Rectangle)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setBounds(java.awt.Rectangle)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setBounds(java.awt.Rectangle)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setBounds(java.awt.Rectangle)


Occurences of setBoundsForFrame

setBoundsForFrame occurences:
javax.swing.DefaultDesktopManager.setBoundsForFrame(javax.swing.JComponent, int, int, int, int)
javax.swing.DesktopManager.setBoundsForFrame(javax.swing.JComponent, int, int, int, int)


Occurences of setByte

setByte occurences:
java.lang.reflect.Array.setByte(java.lang.Object, int, byte)
java.lang.reflect.Field.setByte(java.lang.Object, byte)
java.sql.CallableStatement.setByte(java.lang.String, byte)
java.sql.PreparedStatement.setByte(int, byte)
javax.sql.RowSet.setByte(int, byte)
javax.sql.RowSet.setByte(java.lang.String, byte)
javax.sql.rowset.BaseRowSet.setByte(int, byte)
javax.sql.rowset.BaseRowSet.setByte(java.lang.String, byte)


Occurences of setByteOrder

setByteOrder occurences:
javax.imageio.stream.ImageInputStream.setByteOrder(java.nio.ByteOrder)
javax.imageio.stream.ImageInputStreamImpl.setByteOrder(java.nio.ByteOrder)


Occurences of setBytes

setBytes occurences:
java.sql.Blob.setBytes(long, byte[])
java.sql.Blob.setBytes(long, byte[], int, int)
java.sql.CallableStatement.setBytes(java.lang.String, byte[])
java.sql.PreparedStatement.setBytes(int, byte[])
javax.sql.RowSet.setBytes(int, byte[])
javax.sql.RowSet.setBytes(java.lang.String, byte[])
javax.sql.rowset.BaseRowSet.setBytes(int, byte[])
javax.sql.rowset.BaseRowSet.setBytes(java.lang.String, byte[])
javax.sql.rowset.serial.SerialBlob.setBytes(long, byte[])
javax.sql.rowset.serial.SerialBlob.setBytes(long, byte[], int, int)


Occurences of setByteStream

setByteStream occurences:
org.w3c.dom.ls.LSInput.setByteStream(java.io.InputStream)
org.w3c.dom.ls.LSOutput.setByteStream(java.io.OutputStream)
org.xml.sax.InputSource.setByteStream(java.io.InputStream)


Occurences of setCaretPosition

setCaretPosition occurences:
java.awt.TextComponent.setCaretPosition(int)
javax.swing.text.JTextComponent.setCaretPosition(int)


Occurences of setCaseSensitive

setCaseSensitive occurences:
javax.sql.rowset.RowSetMetaDataImpl.setCaseSensitive(int, boolean)
javax.sql.RowSetMetaData.setCaseSensitive(int, boolean)


Occurences of setCatalogName

setCatalogName occurences:
javax.sql.rowset.RowSetMetaDataImpl.setCatalogName(int, java.lang.String)
javax.sql.RowSetMetaData.setCatalogName(int, java.lang.String)


Occurences of setCellEditor

setCellEditor occurences:
javax.swing.JTable.setCellEditor(javax.swing.table.TableCellEditor)
javax.swing.JTree.setCellEditor(javax.swing.tree.TreeCellEditor)
javax.swing.plaf.basic.BasicTreeUI.setCellEditor(javax.swing.tree.TreeCellEditor)
javax.swing.table.TableColumn.setCellEditor(javax.swing.table.TableCellEditor)


Occurences of setCellRenderer

setCellRenderer occurences:
javax.swing.JList.setCellRenderer(javax.swing.ListCellRenderer)
javax.swing.JTree.setCellRenderer(javax.swing.tree.TreeCellRenderer)
javax.swing.plaf.basic.BasicTreeUI.setCellRenderer(javax.swing.tree.TreeCellRenderer)
javax.swing.table.TableColumn.setCellRenderer(javax.swing.table.TableCellRenderer)


Occurences of setChar

setChar occurences:
java.lang.reflect.Array.setChar(java.lang.Object, int, char)
java.lang.reflect.Field.setChar(java.lang.Object, char)


Occurences of setCharacterAttributes

setCharacterAttributes occurences:
javax.swing.JTextPane.setCharacterAttributes(javax.swing.text.AttributeSet, boolean)
javax.swing.text.DefaultStyledDocument.setCharacterAttributes(int, int, javax.swing.text.AttributeSet, boolean)
javax.swing.text.StyledDocument.setCharacterAttributes(int, int, javax.swing.text.AttributeSet, boolean)
javax.swing.text.StyledEditorKit.StyledTextAction.setCharacterAttributes(javax.swing.JEditorPane, javax.swing.text.AttributeSet, boolean)


Occurences of setCharacterStream

setCharacterStream occurences:
java.sql.CallableStatement.setCharacterStream(java.lang.String, java.io.Reader)
java.sql.CallableStatement.setCharacterStream(java.lang.String, java.io.Reader, int)
java.sql.CallableStatement.setCharacterStream(java.lang.String, java.io.Reader, long)
java.sql.Clob.setCharacterStream(long)
java.sql.PreparedStatement.setCharacterStream(int, java.io.Reader)
java.sql.PreparedStatement.setCharacterStream(int, java.io.Reader, int)
java.sql.PreparedStatement.setCharacterStream(int, java.io.Reader, long)
java.sql.SQLXML.setCharacterStream()
javax.sql.RowSet.setCharacterStream(int, java.io.Reader)
javax.sql.RowSet.setCharacterStream(int, java.io.Reader, int)
javax.sql.RowSet.setCharacterStream(java.lang.String, java.io.Reader)
javax.sql.RowSet.setCharacterStream(java.lang.String, java.io.Reader, int)
javax.sql.rowset.BaseRowSet.setCharacterStream(int, java.io.Reader)
javax.sql.rowset.BaseRowSet.setCharacterStream(int, java.io.Reader, int)
javax.sql.rowset.BaseRowSet.setCharacterStream(java.lang.String, java.io.Reader)
javax.sql.rowset.BaseRowSet.setCharacterStream(java.lang.String, java.io.Reader, int)
javax.sql.rowset.serial.SerialClob.setCharacterStream(long)
org.w3c.dom.ls.LSInput.setCharacterStream(java.io.Reader)
org.w3c.dom.ls.LSOutput.setCharacterStream(java.io.Writer)
org.xml.sax.InputSource.setCharacterStream(java.io.Reader)


Occurences of setCharacterSubsets

setCharacterSubsets occurences:
java.awt.im.InputContext.setCharacterSubsets(java.lang.Character.Subset[])
java.awt.im.spi.InputMethod.setCharacterSubsets(java.lang.Character.Subset[])


Occurences of setCharAt

setCharAt occurences:
java.lang.StringBuffer.setCharAt(int, char)
java.lang.StringBuilder.setCharAt(int, char)


Occurences of setClientInfo

setClientInfo occurences:
java.sql.Connection.setClientInfo(java.lang.String, java.lang.String)
java.sql.Connection.setClientInfo(java.util.Properties)


Occurences of setClip

setClip occurences:
java.awt.Graphics.setClip(int, int, int, int)
java.awt.Graphics.setClip(java.awt.Shape)
javax.swing.DebugGraphics.setClip(int, int, int, int)
javax.swing.DebugGraphics.setClip(java.awt.Shape)


Occurences of setClob

setClob occurences:
java.sql.CallableStatement.setClob(java.lang.String, java.io.Reader)
java.sql.CallableStatement.setClob(java.lang.String, java.io.Reader, long)
java.sql.CallableStatement.setClob(java.lang.String, java.sql.Clob)
java.sql.PreparedStatement.setClob(int, java.io.Reader)
java.sql.PreparedStatement.setClob(int, java.io.Reader, long)
java.sql.PreparedStatement.setClob(int, java.sql.Clob)
javax.sql.RowSet.setClob(int, java.io.Reader)
javax.sql.RowSet.setClob(int, java.io.Reader, long)
javax.sql.RowSet.setClob(int, java.sql.Clob)
javax.sql.RowSet.setClob(java.lang.String, java.io.Reader)
javax.sql.RowSet.setClob(java.lang.String, java.io.Reader, long)
javax.sql.RowSet.setClob(java.lang.String, java.sql.Clob)
javax.sql.rowset.BaseRowSet.setClob(int, java.io.Reader)
javax.sql.rowset.BaseRowSet.setClob(int, java.io.Reader, long)
javax.sql.rowset.BaseRowSet.setClob(int, java.sql.Clob)
javax.sql.rowset.BaseRowSet.setClob(java.lang.String, java.io.Reader)
javax.sql.rowset.BaseRowSet.setClob(java.lang.String, java.io.Reader, long)
javax.sql.rowset.BaseRowSet.setClob(java.lang.String, java.sql.Clob)


Occurences of setColor

setColor occurences:
java.awt.Graphics.setColor(java.awt.Color)
java.awt.PageAttributes.setColor(java.awt.PageAttributes.ColorType)
javax.swing.DebugGraphics.setColor(java.awt.Color)
javax.swing.JColorChooser.setColor(int)
javax.swing.JColorChooser.setColor(int, int, int)
javax.swing.JColorChooser.setColor(java.awt.Color)


Occurences of setColorModel

setColorModel occurences:
java.awt.image.BufferedImageFilter.setColorModel(java.awt.image.ColorModel)
java.awt.image.ImageConsumer.setColorModel(java.awt.image.ColorModel)
java.awt.image.ImageFilter.setColorModel(java.awt.image.ColorModel)
java.awt.image.PixelGrabber.setColorModel(java.awt.image.ColorModel)
java.awt.image.RGBImageFilter.setColorModel(java.awt.image.ColorModel)


Occurences of setColumnCount

setColumnCount occurences:
javax.sql.rowset.RowSetMetaDataImpl.setColumnCount(int)
javax.sql.RowSetMetaData.setColumnCount(int)
javax.swing.table.DefaultTableModel.setColumnCount(int)


Occurences of setColumnDisplaySize

setColumnDisplaySize occurences:
javax.sql.rowset.RowSetMetaDataImpl.setColumnDisplaySize(int, int)
javax.sql.RowSetMetaData.setColumnDisplaySize(int, int)


Occurences of setColumnIdentifiers

setColumnIdentifiers occurences:
javax.swing.table.DefaultTableModel.setColumnIdentifiers(java.lang.Object[])
javax.swing.table.DefaultTableModel.setColumnIdentifiers(java.util.Vector)


Occurences of setColumnLabel

setColumnLabel occurences:
javax.sql.rowset.RowSetMetaDataImpl.setColumnLabel(int, java.lang.String)
javax.sql.RowSetMetaData.setColumnLabel(int, java.lang.String)


Occurences of setColumnMargin

setColumnMargin occurences:
javax.swing.table.DefaultTableColumnModel.setColumnMargin(int)
javax.swing.table.TableColumnModel.setColumnMargin(int)


Occurences of setColumnModel

setColumnModel occurences:
javax.swing.JTable.setColumnModel(javax.swing.table.TableColumnModel)
javax.swing.table.JTableHeader.setColumnModel(javax.swing.table.TableColumnModel)


Occurences of setColumnName

setColumnName occurences:
javax.sql.rowset.RowSetMetaDataImpl.setColumnName(int, java.lang.String)
javax.sql.RowSetMetaData.setColumnName(int, java.lang.String)


Occurences of setColumnNumber

setColumnNumber occurences:
javax.xml.bind.helpers.ValidationEventLocatorImpl.setColumnNumber(int)
org.xml.sax.helpers.LocatorImpl.setColumnNumber(int)


Occurences of setColumns

setColumns occurences:
java.awt.GridLayout.setColumns(int)
java.awt.TextArea.setColumns(int)
java.awt.TextField.setColumns(int)
javax.swing.JTextArea.setColumns(int)
javax.swing.JTextField.setColumns(int)


Occurences of setColumnSelectionAllowed

setColumnSelectionAllowed occurences:
javax.swing.JTable.setColumnSelectionAllowed(boolean)
javax.swing.table.DefaultTableColumnModel.setColumnSelectionAllowed(boolean)
javax.swing.table.TableColumnModel.setColumnSelectionAllowed(boolean)


Occurences of setColumnType

setColumnType occurences:
javax.sql.rowset.RowSetMetaDataImpl.setColumnType(int, int)
javax.sql.RowSetMetaData.setColumnType(int, int)


Occurences of setColumnTypeName

setColumnTypeName occurences:
javax.sql.rowset.RowSetMetaDataImpl.setColumnTypeName(int, java.lang.String)
javax.sql.RowSetMetaData.setColumnTypeName(int, java.lang.String)


Occurences of setCommand

setCommand occurences:
javax.sql.RowSet.setCommand(java.lang.String)
javax.sql.rowset.BaseRowSet.setCommand(java.lang.String)


Occurences of setComment

setComment occurences:
java.net.HttpCookie.setComment(java.lang.String)
java.util.zip.ZipEntry.setComment(java.lang.String)
java.util.zip.ZipOutputStream.setComment(java.lang.String)


Occurences of setComparator

setComparator occurences:
javax.swing.DefaultRowSorter.setComparator(int, java.util.Comparator)
javax.swing.SortingFocusTraversalPolicy.setComparator(java.util.Comparator)


Occurences of setComponent

setComponent occurences:
java.awt.dnd.DragGestureRecognizer.setComponent(java.awt.Component)
java.awt.dnd.DropTarget.setComponent(java.awt.Component)
javax.swing.JToolTip.setComponent(javax.swing.JComponent)
javax.swing.text.StyleConstants.setComponent(javax.swing.text.MutableAttributeSet, java.awt.Component)


Occurences of setComponentOrientation

setComponentOrientation occurences:
java.awt.Component.setComponentOrientation(java.awt.ComponentOrientation)
javax.swing.JMenu.setComponentOrientation(java.awt.ComponentOrientation)
javax.swing.JScrollPane.setComponentOrientation(java.awt.ComponentOrientation)
javax.swing.text.JTextComponent.setComponentOrientation(java.awt.ComponentOrientation)


Occurences of setComponentZOrder

setComponentZOrder occurences:
java.awt.Container.setComponentZOrder(java.awt.Component, int)
javax.swing.JDesktopPane.setComponentZOrder(java.awt.Component, int)


Occurences of setCompositionEnabled

setCompositionEnabled occurences:
java.awt.im.InputContext.setCompositionEnabled(boolean)
java.awt.im.spi.InputMethod.setCompositionEnabled(boolean)


Occurences of setConcurrency

setConcurrency occurences:
javax.sql.RowSet.setConcurrency(int)
javax.sql.rowset.BaseRowSet.setConcurrency(int)


Occurences of setContent

setContent occurences:
javax.xml.soap.AttachmentPart.setContent(java.lang.Object, java.lang.String)
javax.xml.soap.SOAPPart.setContent(javax.xml.transform.Source)


Occurences of setContentHandler

setContentHandler occurences:
javax.xml.validation.ValidatorHandler.setContentHandler(org.xml.sax.ContentHandler)
org.xml.sax.helpers.ParserAdapter.setContentHandler(org.xml.sax.ContentHandler)
org.xml.sax.helpers.XMLFilterImpl.setContentHandler(org.xml.sax.ContentHandler)
org.xml.sax.XMLReader.setContentHandler(org.xml.sax.ContentHandler)


Occurences of setContentId

setContentId occurences:
javax.xml.soap.AttachmentPart.setContentId(java.lang.String)
javax.xml.soap.SOAPPart.setContentId(java.lang.String)


Occurences of setContentLocation

setContentLocation occurences:
javax.xml.soap.AttachmentPart.setContentLocation(java.lang.String)
javax.xml.soap.SOAPPart.setContentLocation(java.lang.String)


Occurences of setContentPane

setContentPane occurences:
javax.swing.JApplet.setContentPane(java.awt.Container)
javax.swing.JDialog.setContentPane(java.awt.Container)
javax.swing.JFrame.setContentPane(java.awt.Container)
javax.swing.JInternalFrame.setContentPane(java.awt.Container)
javax.swing.JRootPane.setContentPane(java.awt.Container)
javax.swing.JWindow.setContentPane(java.awt.Container)
javax.swing.RootPaneContainer.setContentPane(java.awt.Container)


Occurences of setContentType

setContentType occurences:
javax.swing.JEditorPane.setContentType(java.lang.String)
javax.xml.soap.AttachmentPart.setContentType(java.lang.String)


Occurences of setContext

setContext occurences:
com.sun.tools.jconsole.JConsolePlugin.setContext(com.sun.tools.jconsole.JConsoleContext)
javax.script.AbstractScriptEngine.setContext(javax.script.ScriptContext)
javax.script.ScriptEngine.setContext(javax.script.ScriptContext)


Occurences of setContinuousLayout

setContinuousLayout occurences:
javax.swing.JSplitPane.setContinuousLayout(boolean)
javax.swing.plaf.basic.BasicSplitPaneUI.setContinuousLayout(boolean)


Occurences of setController

setController occurences:
javax.imageio.IIOParam.setController(javax.imageio.IIOParamController)
javax.imageio.metadata.IIOMetadata.setController(javax.imageio.metadata.IIOMetadataController)


Occurences of setCopies

setCopies occurences:
java.awt.JobAttributes.setCopies(int)
java.awt.print.PrinterJob.setCopies(int)


Occurences of setCurrency

setCurrency occurences:
java.text.DecimalFormat.setCurrency(java.util.Currency)
java.text.DecimalFormatSymbols.setCurrency(java.util.Currency)
java.text.NumberFormat.setCurrency(java.util.Currency)
javax.sql.rowset.RowSetMetaDataImpl.setCurrency(int, boolean)
javax.sql.RowSetMetaData.setCurrency(int, boolean)


Occurences of setCurrentAccessibleValue

setCurrentAccessibleValue occurences:
java.awt.Button.AccessibleAWTButton.setCurrentAccessibleValue(java.lang.Number)
java.awt.Checkbox.AccessibleAWTCheckbox.setCurrentAccessibleValue(java.lang.Number)
java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem.setCurrentAccessibleValue(java.lang.Number)
java.awt.MenuItem.AccessibleAWTMenuItem.setCurrentAccessibleValue(java.lang.Number)
java.awt.Scrollbar.AccessibleAWTScrollBar.setCurrentAccessibleValue(java.lang.Number)
javax.accessibility.AccessibleValue.setCurrentAccessibleValue(java.lang.Number)
javax.swing.AbstractButton.AccessibleAbstractButton.setCurrentAccessibleValue(java.lang.Number)
javax.swing.JInternalFrame.AccessibleJInternalFrame.setCurrentAccessibleValue(java.lang.Number)
javax.swing.JInternalFrame.JDesktopIcon.AccessibleJDesktopIcon.setCurrentAccessibleValue(java.lang.Number)
javax.swing.JProgressBar.AccessibleJProgressBar.setCurrentAccessibleValue(java.lang.Number)
javax.swing.JScrollBar.AccessibleJScrollBar.setCurrentAccessibleValue(java.lang.Number)
javax.swing.JSlider.AccessibleJSlider.setCurrentAccessibleValue(java.lang.Number)
javax.swing.JSpinner.AccessibleJSpinner.setCurrentAccessibleValue(java.lang.Number)
javax.swing.JSplitPane.AccessibleJSplitPane.setCurrentAccessibleValue(java.lang.Number)


Occurences of setCurrentManager

setCurrentManager occurences:
javax.swing.FocusManager.setCurrentManager(javax.swing.FocusManager)
javax.swing.RepaintManager.setCurrentManager(javax.swing.RepaintManager)


Occurences of setCursor

setCursor occurences:
java.awt.Component.setCursor(java.awt.Cursor)
java.awt.Component.AccessibleAWTComponent.setCursor(java.awt.Cursor)
java.awt.dnd.DragSourceContext.setCursor(java.awt.Cursor)
java.awt.Frame.setCursor(int)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setCursor(java.awt.Cursor)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setCursor(java.awt.Cursor)
java.awt.Window.setCursor(java.awt.Cursor)
javax.accessibility.AccessibleComponent.setCursor(java.awt.Cursor)
javax.swing.JInternalFrame.setCursor(java.awt.Cursor)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setCursor(java.awt.Cursor)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setCursor(java.awt.Cursor)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setCursor(java.awt.Cursor)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setCursor(java.awt.Cursor)


Occurences of setCurve

setCurve occurences:
java.awt.geom.CubicCurve2D.setCurve(double, double, double, double, double, double, double, double)
java.awt.geom.CubicCurve2D.setCurve(double[], int)
java.awt.geom.CubicCurve2D.setCurve(java.awt.geom.CubicCurve2D)
java.awt.geom.CubicCurve2D.setCurve(java.awt.geom.Point2D, java.awt.geom.Point2D, java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.geom.CubicCurve2D.setCurve(java.awt.geom.Point2D[], int)
java.awt.geom.CubicCurve2D.Double.setCurve(double, double, double, double, double, double, double, double)
java.awt.geom.CubicCurve2D.Float.setCurve(double, double, double, double, double, double, double, double)
java.awt.geom.CubicCurve2D.Float.setCurve(float, float, float, float, float, float, float, float)
java.awt.geom.QuadCurve2D.setCurve(double, double, double, double, double, double)
java.awt.geom.QuadCurve2D.setCurve(double[], int)
java.awt.geom.QuadCurve2D.setCurve(java.awt.geom.Point2D, java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.geom.QuadCurve2D.setCurve(java.awt.geom.Point2D[], int)
java.awt.geom.QuadCurve2D.setCurve(java.awt.geom.QuadCurve2D)
java.awt.geom.QuadCurve2D.Double.setCurve(double, double, double, double, double, double)
java.awt.geom.QuadCurve2D.Float.setCurve(double, double, double, double, double, double)
java.awt.geom.QuadCurve2D.Float.setCurve(float, float, float, float, float, float)


Occurences of setDaemon

setDaemon occurences:
java.lang.Thread.setDaemon(boolean)
java.lang.ThreadGroup.setDaemon(boolean)


Occurences of setData

setData occurences:
java.awt.color.ICC_Profile.setData(int, byte[])
java.awt.image.BufferedImage.setData(java.awt.image.Raster)
java.awt.image.WritableRenderedImage.setData(java.awt.image.Raster)
java.net.DatagramPacket.setData(byte[])
java.net.DatagramPacket.setData(byte[], int, int)
javax.imageio.stream.IIOByteBuffer.setData(byte[])
org.w3c.dom.CharacterData.setData(java.lang.String)
org.w3c.dom.ProcessingInstruction.setData(java.lang.String)


Occurences of setDataElements

setDataElements occurences:
java.awt.image.BandedSampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.MultiPixelPackedSampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.SampleModel.setDataElements(int, int, int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.SampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.setDataElements(int, int, java.lang.Object, java.awt.image.DataBuffer)
java.awt.image.WritableRaster.setDataElements(int, int, int, int, java.lang.Object)
java.awt.image.WritableRaster.setDataElements(int, int, java.awt.image.Raster)
java.awt.image.WritableRaster.setDataElements(int, int, java.lang.Object)


Occurences of setDataSourceName

setDataSourceName occurences:
javax.sql.RowSet.setDataSourceName(java.lang.String)
javax.sql.rowset.BaseRowSet.setDataSourceName(java.lang.String)


Occurences of setDataVector

setDataVector occurences:
javax.swing.table.DefaultTableModel.setDataVector(java.lang.Object[][], java.lang.Object[])
javax.swing.table.DefaultTableModel.setDataVector(java.util.Vector, java.util.Vector)


Occurences of setDate

setDate occurences:
java.security.cert.PKIXParameters.setDate(java.util.Date)
java.sql.CallableStatement.setDate(java.lang.String, java.sql.Date)
java.sql.CallableStatement.setDate(java.lang.String, java.sql.Date, java.util.Calendar)
java.sql.PreparedStatement.setDate(int, java.sql.Date)
java.sql.PreparedStatement.setDate(int, java.sql.Date, java.util.Calendar)
java.sql.Time.setDate(int)
java.util.Date.setDate(int)
javax.sql.RowSet.setDate(int, java.sql.Date)
javax.sql.RowSet.setDate(int, java.sql.Date, java.util.Calendar)
javax.sql.RowSet.setDate(java.lang.String, java.sql.Date)
javax.sql.RowSet.setDate(java.lang.String, java.sql.Date, java.util.Calendar)
javax.sql.rowset.BaseRowSet.setDate(int, java.sql.Date)
javax.sql.rowset.BaseRowSet.setDate(int, java.sql.Date, java.util.Calendar)
javax.sql.rowset.BaseRowSet.setDate(java.lang.String, java.sql.Date)
javax.sql.rowset.BaseRowSet.setDate(java.lang.String, java.sql.Date, java.util.Calendar)


Occurences of setDefault

setDefault occurences:
java.net.Authenticator.setDefault(java.net.Authenticator)
java.net.CookieHandler.setDefault(java.net.CookieHandler)
java.net.ProxySelector.setDefault(java.net.ProxySelector)
java.net.ResponseCache.setDefault(java.net.ResponseCache)
java.util.Locale.setDefault(java.util.Locale)
java.util.TimeZone.setDefault(java.util.TimeZone)
javax.net.ssl.SSLContext.setDefault(javax.net.ssl.SSLContext)


Occurences of setDefaultCloseOperation

setDefaultCloseOperation occurences:
javax.swing.JDialog.setDefaultCloseOperation(int)
javax.swing.JFrame.setDefaultCloseOperation(int)
javax.swing.JInternalFrame.setDefaultCloseOperation(int)


Occurences of setDefaultLocale

setDefaultLocale occurences:
javax.swing.JComponent.setDefaultLocale(java.util.Locale)
javax.swing.UIDefaults.setDefaultLocale(java.util.Locale)


Occurences of setDefaultLookAndFeelDecorated

setDefaultLookAndFeelDecorated occurences:
javax.swing.JDialog.setDefaultLookAndFeelDecorated(boolean)
javax.swing.JFrame.setDefaultLookAndFeelDecorated(boolean)


Occurences of setDefaultNamespace

setDefaultNamespace occurences:
javax.xml.stream.XMLEventWriter.setDefaultNamespace(java.lang.String)
javax.xml.stream.XMLStreamWriter.setDefaultNamespace(java.lang.String)


Occurences of setDefaultNamespacePrefix

setDefaultNamespacePrefix occurences:
javax.xml.crypto.dom.DOMCryptoContext.setDefaultNamespacePrefix(java.lang.String)
javax.xml.crypto.XMLCryptoContext.setDefaultNamespacePrefix(java.lang.String)


Occurences of setDefaultRenderer

setDefaultRenderer occurences:
javax.swing.JTable.setDefaultRenderer(java.lang.Class, javax.swing.table.TableCellRenderer)
javax.swing.table.JTableHeader.setDefaultRenderer(javax.swing.table.TableCellRenderer)


Occurences of setDelay

setDelay occurences:
javax.swing.JMenu.setDelay(int)
javax.swing.Timer.setDelay(int)


Occurences of setDescriptor

setDescriptor occurences:
javax.management.DescriptorAccess.setDescriptor(javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanAttributeInfo.setDescriptor(javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanConstructorInfo.setDescriptor(javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanInfo.setDescriptor(javax.management.Descriptor, java.lang.String)
javax.management.modelmbean.ModelMBeanInfoSupport.setDescriptor(javax.management.Descriptor, java.lang.String)
javax.management.modelmbean.ModelMBeanNotificationInfo.setDescriptor(javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanOperationInfo.setDescriptor(javax.management.Descriptor)


Occurences of setDescriptors

setDescriptors occurences:
javax.management.modelmbean.ModelMBeanInfo.setDescriptors(javax.management.Descriptor[])
javax.management.modelmbean.ModelMBeanInfoSupport.setDescriptors(javax.management.Descriptor[])


Occurences of setDesignTime

setDesignTime occurences:
java.beans.beancontext.BeanContextSupport.setDesignTime(boolean)
java.beans.Beans.setDesignTime(boolean)
java.beans.DesignMode.setDesignTime(boolean)


Occurences of setDestination

setDestination occurences:
java.awt.JobAttributes.setDestination(java.awt.JobAttributes.DestinationType)
javax.imageio.ImageReadParam.setDestination(java.awt.image.BufferedImage)


Occurences of setDestinationType

setDestinationType occurences:
javax.imageio.IIOParam.setDestinationType(javax.imageio.ImageTypeSpecifier)
javax.imageio.ImageReadParam.setDestinationType(javax.imageio.ImageTypeSpecifier)


Occurences of setDictionary

setDictionary occurences:
java.util.zip.Deflater.setDictionary(byte[])
java.util.zip.Deflater.setDictionary(byte[], int, int)
java.util.zip.Inflater.setDictionary(byte[])
java.util.zip.Inflater.setDictionary(byte[], int, int)


Occurences of setDifferenceMode

setDifferenceMode occurences:
javax.management.monitor.CounterMonitor.setDifferenceMode(boolean)
javax.management.monitor.CounterMonitorMBean.setDifferenceMode(boolean)
javax.management.monitor.GaugeMonitor.setDifferenceMode(boolean)
javax.management.monitor.GaugeMonitorMBean.setDifferenceMode(boolean)


Occurences of setDimensions

setDimensions occurences:
java.awt.image.BufferedImageFilter.setDimensions(int, int)
java.awt.image.CropImageFilter.setDimensions(int, int)
java.awt.image.ImageConsumer.setDimensions(int, int)
java.awt.image.ImageFilter.setDimensions(int, int)
java.awt.image.PixelGrabber.setDimensions(int, int)
java.awt.image.ReplicateScaleFilter.setDimensions(int, int)


Occurences of setDirection

setDirection occurences:
javax.swing.plaf.basic.BasicArrowButton.setDirection(int)
javax.swing.plaf.basic.BasicScrollBarUI.ScrollListener.setDirection(int)
javax.swing.plaf.basic.BasicSliderUI.ScrollListener.setDirection(int)
javax.swing.text.DefaultStyledDocument.ElementSpec.setDirection(short)


Occurences of setDirectory

setDirectory occurences:
java.awt.FileDialog.setDirectory(java.lang.String)
javax.swing.plaf.basic.BasicFileChooserUI.setDirectory(java.io.File)


Occurences of setDirectoryName

setDirectoryName occurences:
javax.swing.plaf.basic.BasicFileChooserUI.setDirectoryName(java.lang.String)
javax.swing.plaf.metal.MetalFileChooserUI.setDirectoryName(java.lang.String)


Occurences of setDirectorySelected

setDirectorySelected occurences:
javax.swing.plaf.basic.BasicFileChooserUI.setDirectorySelected(boolean)
javax.swing.plaf.metal.MetalFileChooserUI.setDirectorySelected(boolean)


Occurences of setDisabledIcon

setDisabledIcon occurences:
javax.swing.AbstractButton.setDisabledIcon(javax.swing.Icon)
javax.swing.JLabel.setDisabledIcon(javax.swing.Icon)


Occurences of setDisplayedMnemonic

setDisplayedMnemonic occurences:
javax.swing.JLabel.setDisplayedMnemonic(char)
javax.swing.JLabel.setDisplayedMnemonic(int)


Occurences of setDisplayedMnemonicIndex

setDisplayedMnemonicIndex occurences:
javax.swing.AbstractButton.setDisplayedMnemonicIndex(int)
javax.swing.JLabel.setDisplayedMnemonicIndex(int)


Occurences of setDividerLocation

setDividerLocation occurences:
javax.swing.JSplitPane.setDividerLocation(double)
javax.swing.JSplitPane.setDividerLocation(int)
javax.swing.plaf.basic.BasicSplitPaneUI.setDividerLocation(javax.swing.JSplitPane, int)
javax.swing.plaf.multi.MultiSplitPaneUI.setDividerLocation(javax.swing.JSplitPane, int)
javax.swing.plaf.SplitPaneUI.setDividerLocation(javax.swing.JSplitPane, int)


Occurences of setDividerSize

setDividerSize occurences:
javax.swing.JSplitPane.setDividerSize(int)
javax.swing.plaf.basic.BasicSplitPaneDivider.setDividerSize(int)


Occurences of setDocument

setDocument occurences:
javax.swing.JFormattedTextField.setDocument(javax.swing.text.Document)
javax.swing.JTextField.setDocument(javax.swing.text.Document)
javax.swing.JTextPane.setDocument(javax.swing.text.Document)
javax.swing.text.JTextComponent.setDocument(javax.swing.text.Document)


Occurences of setDocumentHandler

setDocumentHandler occurences:
org.xml.sax.helpers.XMLReaderAdapter.setDocumentHandler(org.xml.sax.DocumentHandler)
org.xml.sax.Parser.setDocumentHandler(org.xml.sax.DocumentHandler)


Occurences of setDocumentLocator

setDocumentLocator occurences:
org.xml.sax.ContentHandler.setDocumentLocator(org.xml.sax.Locator)
org.xml.sax.DocumentHandler.setDocumentLocator(org.xml.sax.Locator)
org.xml.sax.HandlerBase.setDocumentLocator(org.xml.sax.Locator)
org.xml.sax.helpers.DefaultHandler.setDocumentLocator(org.xml.sax.Locator)
org.xml.sax.helpers.ParserAdapter.setDocumentLocator(org.xml.sax.Locator)
org.xml.sax.helpers.XMLFilterImpl.setDocumentLocator(org.xml.sax.Locator)
org.xml.sax.helpers.XMLReaderAdapter.setDocumentLocator(org.xml.sax.Locator)


Occurences of setDot

setDot occurences:
javax.swing.text.Caret.setDot(int)
javax.swing.text.DefaultCaret.setDot(int)
javax.swing.text.DefaultCaret.setDot(int, javax.swing.text.Position.Bias)
javax.swing.text.NavigationFilter.setDot(javax.swing.text.NavigationFilter.FilterBypass, int, javax.swing.text.Position.Bias)
javax.swing.text.NavigationFilter.FilterBypass.setDot(int, javax.swing.text.Position.Bias)


Occurences of setDouble

setDouble occurences:
java.lang.reflect.Array.setDouble(java.lang.Object, int, double)
java.lang.reflect.Field.setDouble(java.lang.Object, double)
java.sql.CallableStatement.setDouble(java.lang.String, double)
java.sql.PreparedStatement.setDouble(int, double)
javax.sql.RowSet.setDouble(int, double)
javax.sql.RowSet.setDouble(java.lang.String, double)
javax.sql.rowset.BaseRowSet.setDouble(int, double)
javax.sql.rowset.BaseRowSet.setDouble(java.lang.String, double)


Occurences of setDoubleBuffered

setDoubleBuffered occurences:
javax.swing.JComponent.setDoubleBuffered(boolean)
javax.swing.JRootPane.setDoubleBuffered(boolean)


Occurences of setDragEnabled

setDragEnabled occurences:
javax.swing.JColorChooser.setDragEnabled(boolean)
javax.swing.JFileChooser.setDragEnabled(boolean)
javax.swing.JList.setDragEnabled(boolean)
javax.swing.JTable.setDragEnabled(boolean)
javax.swing.JTree.setDragEnabled(boolean)
javax.swing.text.JTextComponent.setDragEnabled(boolean)


Occurences of setDropMode

setDropMode occurences:
javax.swing.JList.setDropMode(javax.swing.DropMode)
javax.swing.JTable.setDropMode(javax.swing.DropMode)
javax.swing.JTree.setDropMode(javax.swing.DropMode)
javax.swing.text.JTextComponent.setDropMode(javax.swing.DropMode)


Occurences of setDTDHandler

setDTDHandler occurences:
org.xml.sax.helpers.ParserAdapter.setDTDHandler(org.xml.sax.DTDHandler)
org.xml.sax.helpers.XMLFilterImpl.setDTDHandler(org.xml.sax.DTDHandler)
org.xml.sax.helpers.XMLReaderAdapter.setDTDHandler(org.xml.sax.DTDHandler)
org.xml.sax.Parser.setDTDHandler(org.xml.sax.DTDHandler)
org.xml.sax.XMLReader.setDTDHandler(org.xml.sax.DTDHandler)


Occurences of setEchoChar

setEchoChar occurences:
java.awt.TextField.setEchoChar(char)
javax.swing.JPasswordField.setEchoChar(char)


Occurences of setEditable

setEditable occurences:
java.awt.TextComponent.setEditable(boolean)
javax.swing.JComboBox.setEditable(boolean)
javax.swing.JTree.setEditable(boolean)
javax.swing.plaf.basic.BasicTreeUI.setEditable(boolean)
javax.swing.text.JTextComponent.setEditable(boolean)


Occurences of setEditor

setEditor occurences:
javax.swing.JComboBox.setEditor(javax.swing.ComboBoxEditor)
javax.swing.JSpinner.setEditor(javax.swing.JComponent)


Occurences of setEditorKit

setEditorKit occurences:
javax.swing.JEditorPane.setEditorKit(javax.swing.text.EditorKit)
javax.swing.JTextPane.setEditorKit(javax.swing.text.EditorKit)


Occurences of setElem

setElem occurences:
java.awt.image.DataBuffer.setElem(int, int)
java.awt.image.DataBuffer.setElem(int, int, int)
java.awt.image.DataBufferByte.setElem(int, int)
java.awt.image.DataBufferByte.setElem(int, int, int)
java.awt.image.DataBufferDouble.setElem(int, int)
java.awt.image.DataBufferDouble.setElem(int, int, int)
java.awt.image.DataBufferFloat.setElem(int, int)
java.awt.image.DataBufferFloat.setElem(int, int, int)
java.awt.image.DataBufferInt.setElem(int, int)
java.awt.image.DataBufferInt.setElem(int, int, int)
java.awt.image.DataBufferShort.setElem(int, int)
java.awt.image.DataBufferShort.setElem(int, int, int)
java.awt.image.DataBufferUShort.setElem(int, int)
java.awt.image.DataBufferUShort.setElem(int, int, int)


Occurences of setElemDouble

setElemDouble occurences:
java.awt.image.DataBuffer.setElemDouble(int, double)
java.awt.image.DataBuffer.setElemDouble(int, int, double)
java.awt.image.DataBufferDouble.setElemDouble(int, double)
java.awt.image.DataBufferDouble.setElemDouble(int, int, double)
java.awt.image.DataBufferFloat.setElemDouble(int, double)
java.awt.image.DataBufferFloat.setElemDouble(int, int, double)


Occurences of setElementAt

setElementAt occurences:
java.util.Vector.setElementAt(E, int)
java.util.Vector.setElementAt(java.lang.Object,int)
javax.swing.DefaultListModel.setElementAt(java.lang.Object, int)


Occurences of setElemFloat

setElemFloat occurences:
java.awt.image.DataBuffer.setElemFloat(int, float)
java.awt.image.DataBuffer.setElemFloat(int, int, float)
java.awt.image.DataBufferDouble.setElemFloat(int, float)
java.awt.image.DataBufferDouble.setElemFloat(int, int, float)
java.awt.image.DataBufferFloat.setElemFloat(int, float)
java.awt.image.DataBufferFloat.setElemFloat(int, int, float)


Occurences of setEnabled

setEnabled occurences:
com.sun.jdi.request.EventRequest.setEnabled(boolean)
java.awt.Component.setEnabled(boolean)
java.awt.Component.AccessibleAWTComponent.setEnabled(boolean)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setEnabled(boolean)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setEnabled(boolean)
java.awt.MenuItem.setEnabled(boolean)
javax.accessibility.AccessibleComponent.setEnabled(boolean)
javax.swing.AbstractAction.setEnabled(boolean)
javax.swing.AbstractButton.setEnabled(boolean)
javax.swing.Action.setEnabled(boolean)
javax.swing.ButtonModel.setEnabled(boolean)
javax.swing.DefaultButtonModel.setEnabled(boolean)
javax.swing.JComboBox.setEnabled(boolean)
javax.swing.JComponent.setEnabled(boolean)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setEnabled(boolean)
javax.swing.JMenuItem.setEnabled(boolean)
javax.swing.JScrollBar.setEnabled(boolean)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setEnabled(boolean)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setEnabled(boolean)
javax.swing.plaf.metal.MetalComboBoxButton.setEnabled(boolean)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setEnabled(boolean)
javax.swing.ToolTipManager.setEnabled(boolean)


Occurences of setEnabledCipherSuites

setEnabledCipherSuites occurences:
javax.naming.ldap.StartTlsResponse.setEnabledCipherSuites(java.lang.String[])
javax.net.ssl.SSLEngine.setEnabledCipherSuites(java.lang.String[])
javax.net.ssl.SSLServerSocket.setEnabledCipherSuites(java.lang.String[])
javax.net.ssl.SSLSocket.setEnabledCipherSuites(java.lang.String[])


Occurences of setEnabledProtocols

setEnabledProtocols occurences:
javax.net.ssl.SSLEngine.setEnabledProtocols(java.lang.String[])
javax.net.ssl.SSLServerSocket.setEnabledProtocols(java.lang.String[])
javax.net.ssl.SSLSocket.setEnabledProtocols(java.lang.String[])


Occurences of setEnableSessionCreation

setEnableSessionCreation occurences:
javax.net.ssl.SSLEngine.setEnableSessionCreation(boolean)
javax.net.ssl.SSLServerSocket.setEnableSessionCreation(boolean)
javax.net.ssl.SSLSocket.setEnableSessionCreation(boolean)


Occurences of setEncoding

setEncoding occurences:
java.util.logging.Handler.setEncoding(java.lang.String)
java.util.logging.StreamHandler.setEncoding(java.lang.String)
javax.xml.bind.helpers.AbstractMarshallerImpl.setEncoding(java.lang.String)
org.w3c.dom.ls.LSInput.setEncoding(java.lang.String)
org.w3c.dom.ls.LSOutput.setEncoding(java.lang.String)
org.xml.sax.ext.Locator2Impl.setEncoding(java.lang.String)
org.xml.sax.InputSource.setEncoding(java.lang.String)


Occurences of setEndRule

setEndRule occurences:
java.util.SimpleTimeZone.setEndRule(int, int, int)
java.util.SimpleTimeZone.setEndRule(int, int, int, int)
java.util.SimpleTimeZone.setEndRule(int, int, int, int, boolean)


Occurences of setEntityResolver

setEntityResolver occurences:
javax.xml.parsers.DocumentBuilder.setEntityResolver(org.xml.sax.EntityResolver)
org.xml.sax.helpers.ParserAdapter.setEntityResolver(org.xml.sax.EntityResolver)
org.xml.sax.helpers.XMLFilterImpl.setEntityResolver(org.xml.sax.EntityResolver)
org.xml.sax.helpers.XMLReaderAdapter.setEntityResolver(org.xml.sax.EntityResolver)
org.xml.sax.Parser.setEntityResolver(org.xml.sax.EntityResolver)
org.xml.sax.XMLReader.setEntityResolver(org.xml.sax.EntityResolver)


Occurences of setError

setError occurences:
java.io.PrintStream.setError()
java.io.PrintWriter.setError()


Occurences of setErrorHandler

setErrorHandler occurences:
javax.xml.parsers.DocumentBuilder.setErrorHandler(org.xml.sax.ErrorHandler)
javax.xml.validation.SchemaFactory.setErrorHandler(org.xml.sax.ErrorHandler)
javax.xml.validation.Validator.setErrorHandler(org.xml.sax.ErrorHandler)
javax.xml.validation.ValidatorHandler.setErrorHandler(org.xml.sax.ErrorHandler)
org.xml.sax.helpers.ParserAdapter.setErrorHandler(org.xml.sax.ErrorHandler)
org.xml.sax.helpers.XMLFilterImpl.setErrorHandler(org.xml.sax.ErrorHandler)
org.xml.sax.helpers.XMLReaderAdapter.setErrorHandler(org.xml.sax.ErrorHandler)
org.xml.sax.Parser.setErrorHandler(org.xml.sax.ErrorHandler)
org.xml.sax.XMLReader.setErrorHandler(org.xml.sax.ErrorHandler)


Occurences of setErrorListener

setErrorListener occurences:
javax.xml.transform.Transformer.setErrorListener(javax.xml.transform.ErrorListener)
javax.xml.transform.TransformerFactory.setErrorListener(javax.xml.transform.ErrorListener)


Occurences of setErrorWriter

setErrorWriter occurences:
javax.script.ScriptContext.setErrorWriter(java.io.Writer)
javax.script.SimpleScriptContext.setErrorWriter(java.io.Writer)


Occurences of setEscapeProcessing

setEscapeProcessing occurences:
java.sql.Statement.setEscapeProcessing(boolean)
javax.sql.RowSet.setEscapeProcessing(boolean)
javax.sql.rowset.BaseRowSet.setEscapeProcessing(boolean)


Occurences of setEventHandler

setEventHandler occurences:
javax.xml.bind.Binder.setEventHandler(javax.xml.bind.ValidationEventHandler)
javax.xml.bind.helpers.AbstractMarshallerImpl.setEventHandler(javax.xml.bind.ValidationEventHandler)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setEventHandler(javax.xml.bind.ValidationEventHandler)
javax.xml.bind.Marshaller.setEventHandler(javax.xml.bind.ValidationEventHandler)
javax.xml.bind.Unmarshaller.setEventHandler(javax.xml.bind.ValidationEventHandler)
javax.xml.bind.Validator.setEventHandler(javax.xml.bind.ValidationEventHandler)


Occurences of setExceptionListener

setExceptionListener occurences:
java.beans.Encoder.setExceptionListener(java.beans.ExceptionListener)
java.beans.XMLDecoder.setExceptionListener(java.beans.ExceptionListener)


Occurences of setExecutable

setExecutable occurences:
java.io.File.setExecutable(boolean)
java.io.File.setExecutable(boolean, boolean)


Occurences of setExecutor

setExecutor occurences:
javax.xml.ws.Endpoint.setExecutor(java.util.concurrent.Executor)
javax.xml.ws.Service.setExecutor(java.util.concurrent.Executor)
javax.xml.ws.spi.ServiceDelegate.setExecutor(java.util.concurrent.Executor)


Occurences of setExpandedState

setExpandedState occurences:
javax.swing.JTree.setExpandedState(javax.swing.tree.TreePath, boolean)
javax.swing.tree.AbstractLayoutCache.setExpandedState(javax.swing.tree.TreePath, boolean)
javax.swing.tree.FixedHeightLayoutCache.setExpandedState(javax.swing.tree.TreePath, boolean)
javax.swing.tree.VariableHeightLayoutCache.setExpandedState(javax.swing.tree.TreePath, boolean)


Occurences of setExtent

setExtent occurences:
javax.swing.BoundedRangeModel.setExtent(int)
javax.swing.DefaultBoundedRangeModel.setExtent(int)
javax.swing.JSlider.setExtent(int)


Occurences of setFaultCode

setFaultCode occurences:
javax.xml.soap.SOAPFault.setFaultCode(java.lang.String)
javax.xml.soap.SOAPFault.setFaultCode(javax.xml.namespace.QName)
javax.xml.soap.SOAPFault.setFaultCode(javax.xml.soap.Name)


Occurences of setFaultString

setFaultString occurences:
javax.xml.soap.SOAPFault.setFaultString(java.lang.String)
javax.xml.soap.SOAPFault.setFaultString(java.lang.String, java.util.Locale)


Occurences of setFeature

setFeature occurences:
javax.xml.parsers.DocumentBuilderFactory.setFeature(java.lang.String, boolean)
javax.xml.parsers.SAXParserFactory.setFeature(java.lang.String, boolean)
javax.xml.transform.TransformerFactory.setFeature(java.lang.String, boolean)
javax.xml.validation.SchemaFactory.setFeature(java.lang.String, boolean)
javax.xml.validation.Validator.setFeature(java.lang.String, boolean)
javax.xml.validation.ValidatorHandler.setFeature(java.lang.String, boolean)
javax.xml.xpath.XPathFactory.setFeature(java.lang.String, boolean)
org.xml.sax.helpers.ParserAdapter.setFeature(java.lang.String, boolean)
org.xml.sax.helpers.XMLFilterImpl.setFeature(java.lang.String, boolean)
org.xml.sax.XMLReader.setFeature(java.lang.String, boolean)


Occurences of setFetchDirection

setFetchDirection occurences:
java.sql.ResultSet.setFetchDirection(int)
java.sql.Statement.setFetchDirection(int)
javax.sql.rowset.BaseRowSet.setFetchDirection(int)


Occurences of setFetchSize

setFetchSize occurences:
java.sql.ResultSet.setFetchSize(int)
java.sql.Statement.setFetchSize(int)
javax.sql.rowset.BaseRowSet.setFetchSize(int)


Occurences of setField

setField occurences:
javax.management.Descriptor.setField(java.lang.String, java.lang.Object)
javax.management.ImmutableDescriptor.setField(java.lang.String, java.lang.Object)
javax.management.modelmbean.DescriptorSupport.setField(java.lang.String, java.lang.Object)


Occurences of setFields

setFields occurences:
javax.management.Descriptor.setFields(java.lang.String[], java.lang.Object[])
javax.management.ImmutableDescriptor.setFields(java.lang.String[], java.lang.Object[])
javax.management.modelmbean.DescriptorSupport.setFields(java.lang.String[], java.lang.Object[])


Occurences of setFileName

setFileName occurences:
java.awt.JobAttributes.setFileName(java.lang.String)
javax.swing.plaf.basic.BasicFileChooserUI.setFileName(java.lang.String)
javax.swing.plaf.metal.MetalFileChooserUI.setFileName(java.lang.String)


Occurences of setFilter

setFilter occurences:
java.util.logging.Handler.setFilter(java.util.logging.Filter)
java.util.logging.Logger.setFilter(java.util.logging.Filter)
javax.sql.rowset.FilteredRowSet.setFilter(javax.sql.rowset.Predicate)
org.w3c.dom.ls.LSParser.setFilter(org.w3c.dom.ls.LSParserFilter)
org.w3c.dom.ls.LSSerializer.setFilter(org.w3c.dom.ls.LSSerializerFilter)


Occurences of setFirstLineIndent

setFirstLineIndent occurences:
javax.swing.text.ParagraphView.setFirstLineIndent(float)
javax.swing.text.StyleConstants.setFirstLineIndent(javax.swing.text.MutableAttributeSet, float)


Occurences of setFloat

setFloat occurences:
java.lang.reflect.Array.setFloat(java.lang.Object, int, float)
java.lang.reflect.Field.setFloat(java.lang.Object, float)
java.sql.CallableStatement.setFloat(java.lang.String, float)
java.sql.PreparedStatement.setFloat(int, float)
javax.sql.RowSet.setFloat(int, float)
javax.sql.RowSet.setFloat(java.lang.String, float)
javax.sql.rowset.BaseRowSet.setFloat(int, float)
javax.sql.rowset.BaseRowSet.setFloat(java.lang.String, float)


Occurences of setFocusCycleRoot

setFocusCycleRoot occurences:
java.awt.Container.setFocusCycleRoot(boolean)
java.awt.Window.setFocusCycleRoot(boolean)
javax.swing.JInternalFrame.setFocusCycleRoot(boolean)


Occurences of setFocusTraversalKeys

setFocusTraversalKeys occurences:
java.awt.Component.setFocusTraversalKeys(int, java.util.Set)
java.awt.Container.setFocusTraversalKeys(int, java.util.Set)
javax.swing.JComponent.setFocusTraversalKeys(int, java.util.Set)


Occurences of setFont

setFont occurences:
java.awt.Component.setFont(java.awt.Font)
java.awt.Component.AccessibleAWTComponent.setFont(java.awt.Font)
java.awt.Container.setFont(java.awt.Font)
java.awt.Graphics.setFont(java.awt.Font)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setFont(java.awt.Font)
java.awt.MenuComponent.setFont(java.awt.Font)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setFont(java.awt.Font)
javax.accessibility.AccessibleComponent.setFont(java.awt.Font)
javax.swing.DebugGraphics.setFont(java.awt.Font)
javax.swing.JComponent.setFont(java.awt.Font)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setFont(java.awt.Font)
javax.swing.JSlider.setFont(java.awt.Font)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setFont(java.awt.Font)
javax.swing.JTextArea.setFont(java.awt.Font)
javax.swing.JTextField.setFont(java.awt.Font)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setFont(java.awt.Font)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setFont(java.awt.Font)
javax.swing.tree.DefaultTreeCellEditor.setFont(java.awt.Font)
javax.swing.tree.DefaultTreeCellRenderer.setFont(java.awt.Font)


Occurences of setFontSize

setFontSize occurences:
Class ActiveClient.ActiveClient.setFontSize(int)
Class LWTextComponent.LWTextComponent.setFontSize(int)
javax.swing.text.StyleConstants.setFontSize(javax.swing.text.MutableAttributeSet, int)


Occurences of setForeground

setForeground occurences:
java.awt.Component.setForeground(java.awt.Color)
java.awt.Component.AccessibleAWTComponent.setForeground(java.awt.Color)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setForeground(java.awt.Color)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setForeground(java.awt.Color)
javax.accessibility.AccessibleComponent.setForeground(java.awt.Color)
javax.swing.JComponent.setForeground(java.awt.Color)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setForeground(java.awt.Color)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setForeground(java.awt.Color)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setForeground(java.awt.Color)
javax.swing.table.DefaultTableCellRenderer.setForeground(java.awt.Color)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setForeground(java.awt.Color)
javax.swing.text.StyleConstants.setForeground(javax.swing.text.MutableAttributeSet, java.awt.Color)


Occurences of setFormat

setFormat occurences:
java.text.MessageFormat.setFormat(int, java.text.Format)
javax.swing.text.DateFormatter.setFormat(java.text.DateFormat)
javax.swing.text.InternationalFormatter.setFormat(java.text.Format)
javax.swing.text.NumberFormatter.setFormat(java.text.Format)


Occurences of setFormatter

setFormatter occurences:
java.util.logging.Handler.setFormatter(java.util.logging.Formatter)
javax.swing.JFormattedTextField.setFormatter(javax.swing.JFormattedTextField.AbstractFormatter)


Occurences of setFrame

setFrame occurences:
java.awt.geom.Arc2D.setFrame(double, double, double, double)
java.awt.geom.Ellipse2D.Double.setFrame(double, double, double, double)
java.awt.geom.Ellipse2D.Float.setFrame(double, double, double, double)
java.awt.geom.Ellipse2D.Float.setFrame(float, float, float, float)
java.awt.geom.Rectangle2D.setFrame(double, double, double, double)
java.awt.geom.RectangularShape.setFrame(double, double, double, double)
java.awt.geom.RectangularShape.setFrame(java.awt.geom.Point2D, java.awt.geom.Dimension2D)
java.awt.geom.RectangularShape.setFrame(java.awt.geom.Rectangle2D)
java.awt.geom.RoundRectangle2D.setFrame(double, double, double, double)


Occurences of setFrameFromCenter

setFrameFromCenter occurences:
java.awt.geom.RectangularShape.setFrameFromCenter(double, double, double, double)
java.awt.geom.RectangularShape.setFrameFromCenter(java.awt.geom.Point2D, java.awt.geom.Point2D)


Occurences of setFrameFromDiagonal

setFrameFromDiagonal occurences:
java.awt.geom.RectangularShape.setFrameFromDiagonal(double, double, double, double)
java.awt.geom.RectangularShape.setFrameFromDiagonal(java.awt.geom.Point2D, java.awt.geom.Point2D)


Occurences of setGlassPane

setGlassPane occurences:
javax.swing.JApplet.setGlassPane(java.awt.Component)
javax.swing.JDialog.setGlassPane(java.awt.Component)
javax.swing.JFrame.setGlassPane(java.awt.Component)
javax.swing.JInternalFrame.setGlassPane(java.awt.Component)
javax.swing.JRootPane.setGlassPane(java.awt.Component)
javax.swing.JWindow.setGlassPane(java.awt.Component)
javax.swing.RootPaneContainer.setGlassPane(java.awt.Component)


Occurences of setGranularityPeriod

setGranularityPeriod occurences:
javax.management.monitor.Monitor.setGranularityPeriod(long)
javax.management.monitor.MonitorMBean.setGranularityPeriod(long)


Occurences of setGroup

setGroup occurences:
javax.swing.ButtonModel.setGroup(javax.swing.ButtonGroup)
javax.swing.DefaultButtonModel.setGroup(javax.swing.ButtonGroup)


Occurences of setHandlerResolver

setHandlerResolver occurences:
javax.xml.ws.Service.setHandlerResolver(javax.xml.ws.handler.HandlerResolver)
javax.xml.ws.spi.ServiceDelegate.setHandlerResolver(javax.xml.ws.handler.HandlerResolver)


Occurences of setHelpMenu

setHelpMenu occurences:
java.awt.MenuBar.setHelpMenu(java.awt.Menu)
javax.swing.JMenuBar.setHelpMenu(javax.swing.JMenu)


Occurences of setHgap

setHgap occurences:
java.awt.BorderLayout.setHgap(int)
java.awt.CardLayout.setHgap(int)
java.awt.FlowLayout.setHgap(int)
java.awt.GridLayout.setHgap(int)


Occurences of setHints

setHints occurences:
java.awt.image.AreaAveragingScaleFilter.setHints(int)
java.awt.image.ImageConsumer.setHints(int)
java.awt.image.ImageFilter.setHints(int)
java.awt.image.PixelGrabber.setHints(int)


Occurences of setHonorsVisibility

setHonorsVisibility occurences:
javax.swing.GroupLayout.setHonorsVisibility(boolean)
javax.swing.GroupLayout.setHonorsVisibility(java.awt.Component, java.lang.Boolean)


Occurences of setHorizontalAlignment

setHorizontalAlignment occurences:
javax.swing.AbstractButton.setHorizontalAlignment(int)
javax.swing.JLabel.setHorizontalAlignment(int)
javax.swing.JTextField.setHorizontalAlignment(int)


Occurences of setHorizontalScrollBarPolicy

setHorizontalScrollBarPolicy occurences:
javax.swing.JScrollPane.setHorizontalScrollBarPolicy(int)
javax.swing.ScrollPaneLayout.setHorizontalScrollBarPolicy(int)


Occurences of setHorizontalTextPosition

setHorizontalTextPosition occurences:
javax.swing.AbstractButton.setHorizontalTextPosition(int)
javax.swing.JLabel.setHorizontalTextPosition(int)


Occurences of setHostnameVerifier

setHostnameVerifier occurences:
javax.naming.ldap.StartTlsResponse.setHostnameVerifier(javax.net.ssl.HostnameVerifier)
javax.net.ssl.HttpsURLConnection.setHostnameVerifier(javax.net.ssl.HostnameVerifier)


Occurences of setHours

setHours occurences:
java.sql.Date.setHours(int)
java.util.Date.setHours(int)


Occurences of setHumanPresentableName

setHumanPresentableName occurences:
java.awt.datatransfer.DataFlavor.setHumanPresentableName(java.lang.String)
javax.activation.ActivationDataFlavor.setHumanPresentableName(java.lang.String)


Occurences of setIcon

setIcon occurences:
javax.swing.AbstractButton.setIcon(javax.swing.Icon)
javax.swing.JInternalFrame.setIcon(boolean)
javax.swing.JLabel.setIcon(javax.swing.Icon)
javax.swing.JOptionPane.setIcon(javax.swing.Icon)
javax.swing.text.StyleConstants.setIcon(javax.swing.text.MutableAttributeSet, javax.swing.Icon)


Occurences of setIconImage

setIconImage occurences:
java.awt.Frame.setIconImage(java.awt.Image)
java.awt.Window.setIconImage(java.awt.Image)
javax.swing.JFrame.setIconImage(java.awt.Image)


Occurences of setIconTextGap

setIconTextGap occurences:
javax.swing.AbstractButton.setIconTextGap(int)
javax.swing.JLabel.setIconTextGap(int)


Occurences of setIdAttribute

setIdAttribute occurences:
javax.imageio.metadata.IIOMetadataNode.setIdAttribute(java.lang.String, boolean)
org.w3c.dom.Element.setIdAttribute(java.lang.String, boolean)


Occurences of setIdAttributeNode

setIdAttributeNode occurences:
javax.imageio.metadata.IIOMetadataNode.setIdAttributeNode(org.w3c.dom.Attr, boolean)
org.w3c.dom.Element.setIdAttributeNode(org.w3c.dom.Attr, boolean)


Occurences of setIdAttributeNS

setIdAttributeNS occurences:
javax.imageio.metadata.IIOMetadataNode.setIdAttributeNS(java.lang.String, java.lang.String, boolean)
javax.xml.crypto.dom.DOMCryptoContext.setIdAttributeNS(org.w3c.dom.Element, java.lang.String, java.lang.String)
org.w3c.dom.Element.setIdAttributeNS(java.lang.String, java.lang.String, boolean)


Occurences of setImage

setImage occurences:
java.awt.TrayIcon.setImage(java.awt.Image)
javax.swing.ImageIcon.setImage(java.awt.Image)


Occurences of setImplicitDownCycleTraversal

setImplicitDownCycleTraversal occurences:
java.awt.ContainerOrderFocusTraversalPolicy.setImplicitDownCycleTraversal(boolean)
javax.swing.SortingFocusTraversalPolicy.setImplicitDownCycleTraversal(boolean)


Occurences of setIndex

setIndex occurences:
java.text.CharacterIterator.setIndex(int)
java.text.ParsePosition.setIndex(int)
java.text.StringCharacterIterator.setIndex(int)
javax.swing.text.Segment.setIndex(int)


Occurences of setInitialDelay

setInitialDelay occurences:
javax.swing.Timer.setInitialDelay(int)
javax.swing.ToolTipManager.setInitialDelay(int)


Occurences of setInitThreshold

setInitThreshold occurences:
javax.management.monitor.CounterMonitor.setInitThreshold(java.lang.Number)
javax.management.monitor.CounterMonitorMBean.setInitThreshold(java.lang.Number)


Occurences of setInput

setInput occurences:
java.util.zip.Deflater.setInput(byte[])
java.util.zip.Deflater.setInput(byte[], int, int)
java.util.zip.Inflater.setInput(byte[])
java.util.zip.Inflater.setInput(byte[], int, int)
javax.imageio.ImageReader.setInput(java.lang.Object)
javax.imageio.ImageReader.setInput(java.lang.Object, boolean)
javax.imageio.ImageReader.setInput(java.lang.Object, boolean, boolean)


Occurences of setInt

setInt occurences:
java.lang.reflect.Array.setInt(java.lang.Object, int, int)
java.lang.reflect.Field.setInt(java.lang.Object, int)
java.sql.CallableStatement.setInt(java.lang.String, int)
java.sql.PreparedStatement.setInt(int, int)
javax.sql.RowSet.setInt(int, int)
javax.sql.RowSet.setInt(java.lang.String, int)
javax.sql.rowset.BaseRowSet.setInt(int, int)
javax.sql.rowset.BaseRowSet.setInt(java.lang.String, int)


Occurences of setIssuer

setIssuer occurences:
java.security.cert.X509CertSelector.setIssuer(byte[])
java.security.cert.X509CertSelector.setIssuer(java.lang.String)
java.security.cert.X509CertSelector.setIssuer(javax.security.auth.x500.X500Principal)


Occurences of setItem

setItem occurences:
javax.swing.ComboBoxEditor.setItem(java.lang.Object)
javax.swing.plaf.basic.BasicComboBoxEditor.setItem(java.lang.Object)


Occurences of setJMenuBar

setJMenuBar occurences:
javax.swing.JApplet.setJMenuBar(javax.swing.JMenuBar)
javax.swing.JDialog.setJMenuBar(javax.swing.JMenuBar)
javax.swing.JFrame.setJMenuBar(javax.swing.JMenuBar)
javax.swing.JInternalFrame.setJMenuBar(javax.swing.JMenuBar)
javax.swing.JRootPane.setJMenuBar(javax.swing.JMenuBar)


Occurences of setKeyEntry

setKeyEntry occurences:
java.security.KeyStore.setKeyEntry(java.lang.String, byte[], java.security.cert.Certificate[])
java.security.KeyStore.setKeyEntry(java.lang.String, java.security.Key, char[], java.security.cert.Certificate[])


Occurences of setKeySelector

setKeySelector occurences:
javax.xml.crypto.dom.DOMCryptoContext.setKeySelector(javax.xml.crypto.KeySelector)
javax.xml.crypto.XMLCryptoContext.setKeySelector(javax.xml.crypto.KeySelector)


Occurences of setLabel

setLabel occurences:
java.awt.Button.setLabel(java.lang.String)
java.awt.Checkbox.setLabel(java.lang.String)
java.awt.MenuItem.setLabel(java.lang.String)
javax.swing.AbstractButton.setLabel(java.lang.String)
javax.swing.JPopupMenu.setLabel(java.lang.String)
javax.swing.text.html.Option.setLabel(java.lang.String)


Occurences of setLargeModel

setLargeModel occurences:
javax.swing.JTree.setLargeModel(boolean)
javax.swing.plaf.basic.BasicTreeUI.setLargeModel(boolean)


Occurences of setLayer

setLayer occurences:
javax.swing.JInternalFrame.setLayer(int)
javax.swing.JInternalFrame.setLayer(java.lang.Integer)
javax.swing.JLayeredPane.setLayer(java.awt.Component, int)
javax.swing.JLayeredPane.setLayer(java.awt.Component, int, int)


Occurences of setLayeredPane

setLayeredPane occurences:
javax.swing.JApplet.setLayeredPane(javax.swing.JLayeredPane)
javax.swing.JDialog.setLayeredPane(javax.swing.JLayeredPane)
javax.swing.JFrame.setLayeredPane(javax.swing.JLayeredPane)
javax.swing.JInternalFrame.setLayeredPane(javax.swing.JLayeredPane)
javax.swing.JRootPane.setLayeredPane(javax.swing.JLayeredPane)
javax.swing.JWindow.setLayeredPane(javax.swing.JLayeredPane)
javax.swing.RootPaneContainer.setLayeredPane(javax.swing.JLayeredPane)


Occurences of setLayout

setLayout occurences:
java.awt.Container.setLayout(java.awt.LayoutManager)
java.awt.ScrollPane.setLayout(java.awt.LayoutManager)
javax.swing.AbstractButton.setLayout(java.awt.LayoutManager)
javax.swing.Box.setLayout(java.awt.LayoutManager)
javax.swing.JApplet.setLayout(java.awt.LayoutManager)
javax.swing.JDialog.setLayout(java.awt.LayoutManager)
javax.swing.JFrame.setLayout(java.awt.LayoutManager)
javax.swing.JInternalFrame.setLayout(java.awt.LayoutManager)
javax.swing.JScrollPane.setLayout(java.awt.LayoutManager)
javax.swing.JToolBar.setLayout(java.awt.LayoutManager)
javax.swing.JWindow.setLayout(java.awt.LayoutManager)


Occurences of setLeadSelectionIndex

setLeadSelectionIndex occurences:
javax.swing.DefaultListSelectionModel.setLeadSelectionIndex(int)
javax.swing.ListSelectionModel.setLeadSelectionIndex(int)


Occurences of setLength

setLength occurences:
java.io.RandomAccessFile.setLength(long)
java.lang.StringBuffer.setLength(int)
java.lang.StringBuilder.setLength(int)
java.net.DatagramPacket.setLength(int)
javax.imageio.stream.IIOByteBuffer.setLength(int)


Occurences of setLenient

setLenient occurences:
java.text.DateFormat.setLenient(boolean)
java.util.Calendar.setLenient(boolean)


Occurences of setLevel

setLevel occurences:
java.util.logging.Handler.setLevel(java.util.logging.Level)
java.util.logging.Logger.setLevel(java.util.logging.Level)
java.util.logging.LogRecord.setLevel(java.util.logging.Level)
java.util.zip.Deflater.setLevel(int)
java.util.zip.ZipOutputStream.setLevel(int)


Occurences of setLibraryDirectory

setLibraryDirectory occurences:
javax.management.loading.MLet.setLibraryDirectory(java.lang.String)
javax.management.loading.MLetMBean.setLibraryDirectory(java.lang.String)


Occurences of setLightWeightPopupEnabled

setLightWeightPopupEnabled occurences:
javax.swing.JComboBox.setLightWeightPopupEnabled(boolean)
javax.swing.JPopupMenu.setLightWeightPopupEnabled(boolean)
javax.swing.ToolTipManager.setLightWeightPopupEnabled(boolean)


Occurences of setLine

setLine occurences:
java.awt.geom.Line2D.setLine(double, double, double, double)
java.awt.geom.Line2D.setLine(java.awt.geom.Line2D)
java.awt.geom.Line2D.setLine(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.geom.Line2D.Double.setLine(double, double, double, double)
java.awt.geom.Line2D.Float.setLine(double, double, double, double)
java.awt.geom.Line2D.Float.setLine(float, float, float, float)


Occurences of setLineNumber

setLineNumber occurences:
java.io.LineNumberInputStream.setLineNumber(int)
java.io.LineNumberReader.setLineNumber(int)
javax.xml.bind.helpers.ValidationEventLocatorImpl.setLineNumber(int)
org.xml.sax.helpers.LocatorImpl.setLineNumber(int)


Occurences of setLineSpacing

setLineSpacing occurences:
javax.swing.text.ParagraphView.setLineSpacing(float)
javax.swing.text.StyleConstants.setLineSpacing(javax.swing.text.MutableAttributeSet, float)


Occurences of setLinkedException

setLinkedException occurences:
javax.xml.bind.helpers.ValidationEventImpl.setLinkedException(java.lang.Throwable)
javax.xml.bind.JAXBException.setLinkedException(java.lang.Throwable)
javax.xml.bind.TypeConstraintException.setLinkedException(java.lang.Throwable)


Occurences of setListData

setListData occurences:
javax.swing.JList.setListData(java.lang.Object[])
javax.swing.JList.setListData(java.util.Vector)


Occurences of setListener

setListener occurences:
javax.xml.bind.helpers.AbstractMarshallerImpl.setListener(javax.xml.bind.Marshaller.Listener)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setListener(javax.xml.bind.Unmarshaller.Listener)
javax.xml.bind.Marshaller.setListener(javax.xml.bind.Marshaller.Listener)
javax.xml.bind.Unmarshaller.setListener(javax.xml.bind.Unmarshaller.Listener)


Occurences of setLocale

setLocale occurences:
java.awt.Component.setLocale(java.util.Locale)
java.awt.im.spi.InputMethod.setLocale(java.util.Locale)
java.beans.beancontext.BeanContextSupport.setLocale(java.util.Locale)
java.text.MessageFormat.setLocale(java.util.Locale)
javax.imageio.ImageReader.setLocale(java.util.Locale)
javax.imageio.ImageWriter.setLocale(java.util.Locale)
javax.security.auth.callback.LanguageCallback.setLocale(java.util.Locale)
javax.tools.JavaCompiler.CompilationTask.setLocale(java.util.Locale)
org.xml.sax.helpers.XMLReaderAdapter.setLocale(java.util.Locale)
org.xml.sax.Parser.setLocale(java.util.Locale)


Occurences of setLocation

setLocation occurences:
java.awt.Component.setLocation(int, int)
java.awt.Component.setLocation(java.awt.Point)
java.awt.Component.AccessibleAWTComponent.setLocation(java.awt.Point)
java.awt.geom.Point2D.setLocation(double, double)
java.awt.geom.Point2D.setLocation(java.awt.geom.Point2D)
java.awt.geom.Point2D.Double.setLocation(double, double)
java.awt.geom.Point2D.Float.setLocation(double, double)
java.awt.geom.Point2D.Float.setLocation(float, float)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setLocation(java.awt.Point)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setLocation(java.awt.Point)
java.awt.Point.setLocation(double, double)
java.awt.Point.setLocation(int, int)
java.awt.Point.setLocation(java.awt.Point)
java.awt.Rectangle.setLocation(int, int)
java.awt.Rectangle.setLocation(java.awt.Point)
javax.accessibility.AccessibleComponent.setLocation(java.awt.Point)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setLocation(java.awt.Point)
javax.swing.JPopupMenu.setLocation(int, int)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setLocation(java.awt.Point)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setLocation(java.awt.Point)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setLocation(java.awt.Point)
javax.tools.StandardJavaFileManager.setLocation(javax.tools.JavaFileManager.Location, java.lang.Iterable)
javax.xml.stream.XMLEventFactory.setLocation(javax.xml.stream.Location)


Occurences of setLocator

setLocator occurences:
javax.xml.bind.helpers.ValidationEventImpl.setLocator(javax.xml.bind.ValidationEventLocator)
javax.xml.transform.TransformerException.setLocator(javax.xml.transform.SourceLocator)


Occurences of setLogger

setLogger occurences:
javax.sql.rowset.spi.SyncFactory.setLogger(java.util.logging.Logger)
javax.sql.rowset.spi.SyncFactory.setLogger(java.util.logging.Logger, java.util.logging.Level)


Occurences of setLogicalStyle

setLogicalStyle occurences:
javax.swing.JTextPane.setLogicalStyle(javax.swing.text.Style)
javax.swing.text.DefaultStyledDocument.setLogicalStyle(int, javax.swing.text.Style)
javax.swing.text.StyledDocument.setLogicalStyle(int, javax.swing.text.Style)


Occurences of setLoginTimeout

setLoginTimeout occurences:
java.sql.DriverManager.setLoginTimeout(int)
javax.sql.CommonDataSource.setLoginTimeout(int)


Occurences of setLogStream

setLogStream occurences:
java.sql.DriverManager.setLogStream(java.io.PrintStream)
javax.swing.DebugGraphics.setLogStream(java.io.PrintStream)


Occurences of setLogWriter

setLogWriter occurences:
java.sql.DriverManager.setLogWriter(java.io.PrintWriter)
javax.sql.CommonDataSource.setLogWriter(java.io.PrintWriter)


Occurences of setLong

setLong occurences:
java.lang.reflect.Array.setLong(java.lang.Object, int, long)
java.lang.reflect.Field.setLong(java.lang.Object, long)
java.sql.CallableStatement.setLong(java.lang.String, long)
java.sql.PreparedStatement.setLong(int, long)
javax.sql.RowSet.setLong(int, long)
javax.sql.RowSet.setLong(java.lang.String, long)
javax.sql.rowset.BaseRowSet.setLong(int, long)
javax.sql.rowset.BaseRowSet.setLong(java.lang.String, long)


Occurences of setLookAndFeel

setLookAndFeel occurences:
javax.swing.UIManager.setLookAndFeel(java.lang.String)
javax.swing.UIManager.setLookAndFeel(javax.swing.LookAndFeel)


Occurences of setMagicCaretPosition

setMagicCaretPosition occurences:
javax.swing.text.Caret.setMagicCaretPosition(java.awt.Point)
javax.swing.text.DefaultCaret.setMagicCaretPosition(java.awt.Point)


Occurences of setManagedResource

setManagedResource occurences:
javax.management.modelmbean.ModelMBean.setManagedResource(java.lang.Object, java.lang.String)
javax.management.modelmbean.RequiredModelMBean.setManagedResource(java.lang.Object, java.lang.String)


Occurences of setMargin

setMargin occurences:
javax.swing.AbstractButton.setMargin(java.awt.Insets)
javax.swing.JMenuBar.setMargin(java.awt.Insets)
javax.swing.JToolBar.setMargin(java.awt.Insets)
javax.swing.text.JTextComponent.setMargin(java.awt.Insets)


Occurences of setMatchColumn

setMatchColumn occurences:
javax.sql.rowset.Joinable.setMatchColumn(int)
javax.sql.rowset.Joinable.setMatchColumn(int[])
javax.sql.rowset.Joinable.setMatchColumn(java.lang.String)
javax.sql.rowset.Joinable.setMatchColumn(java.lang.String[])


Occurences of setMaxFieldSize

setMaxFieldSize occurences:
java.sql.Statement.setMaxFieldSize(int)
javax.sql.RowSet.setMaxFieldSize(int)
javax.sql.rowset.BaseRowSet.setMaxFieldSize(int)


Occurences of setMaximum

setMaximum occurences:
java.awt.Adjustable.setMaximum(int)
java.awt.Scrollbar.setMaximum(int)
java.awt.ScrollPaneAdjustable.setMaximum(int)
javax.swing.BoundedRangeModel.setMaximum(int)
javax.swing.DefaultBoundedRangeModel.setMaximum(int)
javax.swing.JInternalFrame.setMaximum(boolean)
javax.swing.JProgressBar.setMaximum(int)
javax.swing.JScrollBar.setMaximum(int)
javax.swing.JSlider.setMaximum(int)
javax.swing.ProgressMonitor.setMaximum(int)
javax.swing.SpinnerNumberModel.setMaximum(java.lang.Comparable)
javax.swing.text.InternationalFormatter.setMaximum(java.lang.Comparable)


Occurences of setMaximumFractionDigits

setMaximumFractionDigits occurences:
java.text.DecimalFormat.setMaximumFractionDigits(int)
java.text.NumberFormat.setMaximumFractionDigits(int)


Occurences of setMaximumIntegerDigits

setMaximumIntegerDigits occurences:
java.text.DecimalFormat.setMaximumIntegerDigits(int)
java.text.NumberFormat.setMaximumIntegerDigits(int)


Occurences of setMaximumSize

setMaximumSize occurences:
java.awt.Component.setMaximumSize(java.awt.Dimension)
javax.swing.JComponent.setMaximumSize(java.awt.Dimension)


Occurences of setMaxRows

setMaxRows occurences:
java.sql.Statement.setMaxRows(int)
javax.sql.RowSet.setMaxRows(int)
javax.sql.rowset.BaseRowSet.setMaxRows(int)


Occurences of setMBeanDescriptor

setMBeanDescriptor occurences:
javax.management.modelmbean.ModelMBeanInfo.setMBeanDescriptor(javax.management.Descriptor)
javax.management.modelmbean.ModelMBeanInfoSupport.setMBeanDescriptor(javax.management.Descriptor)


Occurences of setMBeanServer

setMBeanServer occurences:
javax.management.AttributeValueExp.setMBeanServer(javax.management.MBeanServer)
javax.management.ObjectName.setMBeanServer(javax.management.MBeanServer)
javax.management.QueryEval.setMBeanServer(javax.management.MBeanServer)
javax.management.QueryExp.setMBeanServer(javax.management.MBeanServer)
javax.management.remote.MBeanServerForwarder.setMBeanServer(javax.management.MBeanServer)
javax.management.remote.rmi.RMIServerImpl.setMBeanServer(javax.management.MBeanServer)
javax.management.StringValueExp.setMBeanServer(javax.management.MBeanServer)
javax.management.ValueExp.setMBeanServer(javax.management.MBeanServer)


Occurences of setMBeanServerForwarder

setMBeanServerForwarder occurences:
javax.management.remote.JMXConnectorServer.setMBeanServerForwarder(javax.management.remote.MBeanServerForwarder)
javax.management.remote.JMXConnectorServerMBean.setMBeanServerForwarder(javax.management.remote.MBeanServerForwarder)
javax.management.remote.rmi.RMIConnectorServer.setMBeanServerForwarder(javax.management.remote.MBeanServerForwarder)


Occurences of setMenuBar

setMenuBar occurences:
java.awt.Frame.setMenuBar(java.awt.MenuBar)
javax.swing.JInternalFrame.setMenuBar(javax.swing.JMenuBar)
javax.swing.JRootPane.setMenuBar(javax.swing.JMenuBar)


Occurences of setMessage

setMessage occurences:
java.util.logging.LogRecord.setMessage(java.lang.String)
javax.sound.midi.MetaMessage.setMessage(int, byte[], int)
javax.sound.midi.MidiMessage.setMessage(byte[], int)
javax.sound.midi.ShortMessage.setMessage(int)
javax.sound.midi.ShortMessage.setMessage(int, int, int)
javax.sound.midi.ShortMessage.setMessage(int, int, int, int)
javax.sound.midi.SysexMessage.setMessage(byte[], int)
javax.sound.midi.SysexMessage.setMessage(int, byte[], int)
javax.swing.JOptionPane.setMessage(java.lang.Object)
javax.xml.bind.helpers.ValidationEventImpl.setMessage(java.lang.String)
javax.xml.ws.handler.soap.SOAPMessageContext.setMessage(javax.xml.soap.SOAPMessage)


Occurences of setMessageDigest

setMessageDigest occurences:
java.security.DigestInputStream.setMessageDigest(java.security.MessageDigest)
java.security.DigestOutputStream.setMessageDigest(java.security.MessageDigest)


Occurences of setMetaData

setMetaData occurences:
javax.sql.rowset.CachedRowSet.setMetaData(javax.sql.RowSetMetaData)
javax.sql.RowSetInternal.setMetaData(javax.sql.RowSetMetaData)


Occurences of setMetadata

setMetadata occurences:
javax.imageio.IIOImage.setMetadata(javax.imageio.metadata.IIOMetadata)
javax.xml.ws.Endpoint.setMetadata(java.util.List)


Occurences of setMethod

setMethod occurences:
java.util.zip.ZipEntry.setMethod(int)
java.util.zip.ZipOutputStream.setMethod(int)


Occurences of setMicrosecondPosition

setMicrosecondPosition occurences:
javax.sound.midi.Sequencer.setMicrosecondPosition(long)
javax.sound.sampled.Clip.setMicrosecondPosition(long)


Occurences of setMimeHeader

setMimeHeader occurences:
javax.xml.soap.AttachmentPart.setMimeHeader(java.lang.String, java.lang.String)
javax.xml.soap.SOAPPart.setMimeHeader(java.lang.String, java.lang.String)


Occurences of setMinimum

setMinimum occurences:
java.awt.Adjustable.setMinimum(int)
java.awt.Scrollbar.setMinimum(int)
java.awt.ScrollPaneAdjustable.setMinimum(int)
javax.swing.BoundedRangeModel.setMinimum(int)
javax.swing.DefaultBoundedRangeModel.setMinimum(int)
javax.swing.JProgressBar.setMinimum(int)
javax.swing.JScrollBar.setMinimum(int)
javax.swing.JSlider.setMinimum(int)
javax.swing.ProgressMonitor.setMinimum(int)
javax.swing.SpinnerNumberModel.setMinimum(java.lang.Comparable)
javax.swing.text.InternationalFormatter.setMinimum(java.lang.Comparable)


Occurences of setMinimumFractionDigits

setMinimumFractionDigits occurences:
java.text.DecimalFormat.setMinimumFractionDigits(int)
java.text.NumberFormat.setMinimumFractionDigits(int)


Occurences of setMinimumIntegerDigits

setMinimumIntegerDigits occurences:
java.text.DecimalFormat.setMinimumIntegerDigits(int)
java.text.NumberFormat.setMinimumIntegerDigits(int)


Occurences of setMinimumSize

setMinimumSize occurences:
java.awt.Component.setMinimumSize(java.awt.Dimension)
java.awt.Window.setMinimumSize(java.awt.Dimension)
javax.swing.JComponent.setMinimumSize(java.awt.Dimension)


Occurences of setMinutes

setMinutes occurences:
java.sql.Date.setMinutes(int)
java.util.Date.setMinutes(int)


Occurences of setMnemonic

setMnemonic occurences:
javax.swing.AbstractButton.setMnemonic(char)
javax.swing.AbstractButton.setMnemonic(int)
javax.swing.ButtonModel.setMnemonic(int)
javax.swing.DefaultButtonModel.setMnemonic(int)


Occurences of setModel

setModel occurences:
javax.swing.AbstractButton.setModel(javax.swing.ButtonModel)
javax.swing.JComboBox.setModel(javax.swing.ComboBoxModel)
javax.swing.JList.setModel(javax.swing.ListModel)
javax.swing.JMenu.setModel(javax.swing.ButtonModel)
javax.swing.JMenuItem.setModel(javax.swing.ButtonModel)
javax.swing.JProgressBar.setModel(javax.swing.BoundedRangeModel)
javax.swing.JScrollBar.setModel(javax.swing.BoundedRangeModel)
javax.swing.JSlider.setModel(javax.swing.BoundedRangeModel)
javax.swing.JSpinner.setModel(javax.swing.SpinnerModel)
javax.swing.JTabbedPane.setModel(javax.swing.SingleSelectionModel)
javax.swing.JTable.setModel(javax.swing.table.TableModel)
javax.swing.JTree.setModel(javax.swing.tree.TreeModel)
javax.swing.plaf.basic.BasicTreeUI.setModel(javax.swing.tree.TreeModel)
javax.swing.table.TableRowSorter.setModel(javax.swing.table.TableModel)
javax.swing.table.TableRowSorter.setModel(M)
javax.swing.tree.AbstractLayoutCache.setModel(javax.swing.tree.TreeModel)
javax.swing.tree.FixedHeightLayoutCache.setModel(javax.swing.tree.TreeModel)
javax.swing.tree.VariableHeightLayoutCache.setModel(javax.swing.tree.TreeModel)


Occurences of setModelMBeanInfo

setModelMBeanInfo occurences:
javax.management.modelmbean.ModelMBean.setModelMBeanInfo(javax.management.modelmbean.ModelMBeanInfo)
javax.management.modelmbean.RequiredModelMBean.setModelMBeanInfo(javax.management.modelmbean.ModelMBeanInfo)


Occurences of setModulus

setModulus occurences:
javax.management.monitor.CounterMonitor.setModulus(java.lang.Number)
javax.management.monitor.CounterMonitorMBean.setModulus(java.lang.Number)


Occurences of setMonth

setMonth occurences:
java.sql.Time.setMonth(int)
java.util.Date.setMonth(int)
javax.xml.datatype.XMLGregorianCalendar.setMonth(int)


Occurences of setName

setName occurences:
java.awt.Component.setName(java.lang.String)
java.awt.MenuComponent.setName(java.lang.String)
java.beans.FeatureDescriptor.setName(java.lang.String)
java.lang.Thread.setName(java.lang.String)
java.security.acl.Acl.setName(java.security.Principal, java.lang.String)
javax.naming.NameClassPair.setName(java.lang.String)
javax.security.auth.callback.NameCallback.setName(java.lang.String)
javax.swing.text.StyleContext.NamedStyle.setName(java.lang.String)


Occurences of setNamespaceAware

setNamespaceAware occurences:
javax.xml.parsers.DocumentBuilderFactory.setNamespaceAware(boolean)
javax.xml.parsers.SAXParserFactory.setNamespaceAware(boolean)


Occurences of setNamespaceContext

setNamespaceContext occurences:
javax.xml.stream.XMLEventWriter.setNamespaceContext(javax.xml.namespace.NamespaceContext)
javax.xml.stream.XMLStreamWriter.setNamespaceContext(javax.xml.namespace.NamespaceContext)
javax.xml.xpath.XPath.setNamespaceContext(javax.xml.namespace.NamespaceContext)


Occurences of setNCharacterStream

setNCharacterStream occurences:
java.sql.CallableStatement.setNCharacterStream(java.lang.String, java.io.Reader)
java.sql.CallableStatement.setNCharacterStream(java.lang.String, java.io.Reader, long)
java.sql.PreparedStatement.setNCharacterStream(int, java.io.Reader)
java.sql.PreparedStatement.setNCharacterStream(int, java.io.Reader, long)
javax.sql.RowSet.setNCharacterStream(int, java.io.Reader)
javax.sql.RowSet.setNCharacterStream(int, java.io.Reader, long)
javax.sql.RowSet.setNCharacterStream(java.lang.String, java.io.Reader)
javax.sql.RowSet.setNCharacterStream(java.lang.String, java.io.Reader, long)
javax.sql.rowset.BaseRowSet.setNCharacterStream(int, java.io.Reader)
javax.sql.rowset.BaseRowSet.setNCharacterStream(int, java.io.Reader, long)
javax.sql.rowset.BaseRowSet.setNCharacterStream(java.lang.String, java.io.Reader)
javax.sql.rowset.BaseRowSet.setNCharacterStream(java.lang.String, java.io.Reader, long)


Occurences of setNClob

setNClob occurences:
java.sql.CallableStatement.setNClob(java.lang.String, java.io.Reader)
java.sql.CallableStatement.setNClob(java.lang.String, java.io.Reader, long)
java.sql.CallableStatement.setNClob(java.lang.String, java.sql.NClob)
java.sql.PreparedStatement.setNClob(int, java.io.Reader)
java.sql.PreparedStatement.setNClob(int, java.io.Reader, long)
java.sql.PreparedStatement.setNClob(int, java.sql.NClob)
javax.sql.RowSet.setNClob(int, java.io.Reader)
javax.sql.RowSet.setNClob(int, java.io.Reader, long)
javax.sql.RowSet.setNClob(int, java.sql.NClob)
javax.sql.RowSet.setNClob(java.lang.String, java.io.Reader)
javax.sql.RowSet.setNClob(java.lang.String, java.io.Reader, long)
javax.sql.RowSet.setNClob(java.lang.String, java.sql.NClob)
javax.sql.rowset.BaseRowSet.setNClob(int, java.io.Reader)
javax.sql.rowset.BaseRowSet.setNClob(int, java.io.Reader, long)
javax.sql.rowset.BaseRowSet.setNClob(int, java.sql.NClob)
javax.sql.rowset.BaseRowSet.setNClob(java.lang.String, java.io.Reader)
javax.sql.rowset.BaseRowSet.setNClob(java.lang.String, java.io.Reader, long)
javax.sql.rowset.BaseRowSet.setNClob(java.lang.String, java.sql.NClob)


Occurences of setNeedClientAuth

setNeedClientAuth occurences:
javax.net.ssl.SSLEngine.setNeedClientAuth(boolean)
javax.net.ssl.SSLParameters.setNeedClientAuth(boolean)
javax.net.ssl.SSLServerSocket.setNeedClientAuth(boolean)
javax.net.ssl.SSLSocket.setNeedClientAuth(boolean)


Occurences of setNextSibling

setNextSibling occurences:
javax.xml.crypto.dsig.dom.DOMSignContext.setNextSibling(org.w3c.dom.Node)
javax.xml.transform.dom.DOMResult.setNextSibling(org.w3c.dom.Node)


Occurences of setNextWarning

setNextWarning occurences:
java.sql.SQLWarning.setNextWarning(java.sql.SQLWarning)
javax.sql.rowset.RowSetWarning.setNextWarning(javax.sql.rowset.RowSetWarning)


Occurences of setNode

setNode occurences:
javax.xml.bind.helpers.ValidationEventLocatorImpl.setNode(org.w3c.dom.Node)
javax.xml.crypto.dsig.dom.DOMValidateContext.setNode(org.w3c.dom.Node)
javax.xml.transform.dom.DOMResult.setNode(org.w3c.dom.Node)
javax.xml.transform.dom.DOMSource.setNode(org.w3c.dom.Node)


Occurences of setNodeDimensions

setNodeDimensions occurences:
javax.swing.tree.AbstractLayoutCache.setNodeDimensions(javax.swing.tree.AbstractLayoutCache.NodeDimensions)
javax.swing.tree.VariableHeightLayoutCache.setNodeDimensions(javax.swing.tree.AbstractLayoutCache.NodeDimensions)


Occurences of setNodeValue

setNodeValue occurences:
javax.imageio.metadata.IIOMetadataNode.setNodeValue(java.lang.String)
org.w3c.dom.Node.setNodeValue(java.lang.String)


Occurences of setNonContinuousLayoutDivider

setNonContinuousLayoutDivider occurences:
javax.swing.plaf.basic.BasicSplitPaneUI.setNonContinuousLayoutDivider(java.awt.Component)
javax.swing.plaf.basic.BasicSplitPaneUI.setNonContinuousLayoutDivider(java.awt.Component, boolean)


Occurences of setNotify

setNotify occurences:
javax.management.monitor.CounterMonitor.setNotify(boolean)
javax.management.monitor.CounterMonitorMBean.setNotify(boolean)


Occurences of setNotifyDiffer

setNotifyDiffer occurences:
javax.management.monitor.StringMonitor.setNotifyDiffer(boolean)
javax.management.monitor.StringMonitorMBean.setNotifyDiffer(boolean)


Occurences of setNotifyHigh

setNotifyHigh occurences:
javax.management.monitor.GaugeMonitor.setNotifyHigh(boolean)
javax.management.monitor.GaugeMonitorMBean.setNotifyHigh(boolean)


Occurences of setNotifyLow

setNotifyLow occurences:
javax.management.monitor.GaugeMonitor.setNotifyLow(boolean)
javax.management.monitor.GaugeMonitorMBean.setNotifyLow(boolean)


Occurences of setNotifyMatch

setNotifyMatch occurences:
javax.management.monitor.StringMonitor.setNotifyMatch(boolean)
javax.management.monitor.StringMonitorMBean.setNotifyMatch(boolean)


Occurences of setNString

setNString occurences:
java.sql.CallableStatement.setNString(java.lang.String, java.lang.String)
java.sql.PreparedStatement.setNString(int, java.lang.String)
javax.sql.RowSet.setNString(int, java.lang.String)
javax.sql.RowSet.setNString(java.lang.String, java.lang.String)
javax.sql.rowset.BaseRowSet.setNString(int, java.lang.String)
javax.sql.rowset.BaseRowSet.setNString(java.lang.String, java.lang.String)


Occurences of setNull

setNull occurences:
java.sql.CallableStatement.setNull(java.lang.String, int)
java.sql.CallableStatement.setNull(java.lang.String, int, java.lang.String)
java.sql.PreparedStatement.setNull(int, int)
java.sql.PreparedStatement.setNull(int, int, java.lang.String)
javax.sql.RowSet.setNull(int, int)
javax.sql.RowSet.setNull(int, int, java.lang.String)
javax.sql.RowSet.setNull(java.lang.String, int)
javax.sql.RowSet.setNull(java.lang.String, int, java.lang.String)
javax.sql.rowset.BaseRowSet.setNull(int, int)
javax.sql.rowset.BaseRowSet.setNull(int, int, java.lang.String)
javax.sql.rowset.BaseRowSet.setNull(java.lang.String, int)
javax.sql.rowset.BaseRowSet.setNull(java.lang.String, int, java.lang.String)


Occurences of setNullable

setNullable occurences:
javax.sql.rowset.RowSetMetaDataImpl.setNullable(int, int)
javax.sql.RowSetMetaData.setNullable(int, int)


Occurences of setObject

setObject occurences:
java.beans.Customizer.setObject(java.lang.Object)
java.sql.CallableStatement.setObject(java.lang.String, java.lang.Object)
java.sql.CallableStatement.setObject(java.lang.String, java.lang.Object, int)
java.sql.CallableStatement.setObject(java.lang.String, java.lang.Object, int, int)
java.sql.PreparedStatement.setObject(int, java.lang.Object)
java.sql.PreparedStatement.setObject(int, java.lang.Object, int)
java.sql.PreparedStatement.setObject(int, java.lang.Object, int, int)
java.sql.Ref.setObject(java.lang.Object)
javax.naming.Binding.setObject(java.lang.Object)
javax.sql.RowSet.setObject(int, java.lang.Object)
javax.sql.RowSet.setObject(int, java.lang.Object, int)
javax.sql.RowSet.setObject(int, java.lang.Object, int, int)
javax.sql.RowSet.setObject(java.lang.String, java.lang.Object)
javax.sql.RowSet.setObject(java.lang.String, java.lang.Object, int)
javax.sql.RowSet.setObject(java.lang.String, java.lang.Object, int, int)
javax.sql.rowset.BaseRowSet.setObject(int, java.lang.Object)
javax.sql.rowset.BaseRowSet.setObject(int, java.lang.Object, int)
javax.sql.rowset.BaseRowSet.setObject(int, java.lang.Object, int, int)
javax.sql.rowset.BaseRowSet.setObject(java.lang.String, java.lang.Object)
javax.sql.rowset.BaseRowSet.setObject(java.lang.String, java.lang.Object, int)
javax.sql.rowset.BaseRowSet.setObject(java.lang.String, java.lang.Object, int, int)
javax.sql.rowset.serial.SerialRef.setObject(java.lang.Object)
javax.xml.bind.helpers.ValidationEventLocatorImpl.setObject(java.lang.Object)


Occurences of setObservedAttribute

setObservedAttribute occurences:
javax.management.monitor.Monitor.setObservedAttribute(java.lang.String)
javax.management.monitor.MonitorMBean.setObservedAttribute(java.lang.String)


Occurences of setObservedObject

setObservedObject occurences:
javax.management.monitor.Monitor.setObservedObject(javax.management.ObjectName)
javax.management.monitor.MonitorMBean.setObservedObject(javax.management.ObjectName)


Occurences of setOffset

setOffset occurences:
java.io.ObjectStreamField.setOffset(int)
java.text.CollationElementIterator.setOffset(int)
javax.imageio.stream.IIOByteBuffer.setOffset(int)
javax.management.monitor.CounterMonitor.setOffset(java.lang.Number)
javax.management.monitor.CounterMonitorMBean.setOffset(java.lang.Number)
javax.swing.plaf.basic.BasicToolBarUI.DragWindow.setOffset(java.awt.Point)
javax.xml.bind.helpers.ValidationEventLocatorImpl.setOffset(int)


Occurences of SetOfIntegerSyntax (constructors)

SetOfIntegerSyntax (constructors) occurences:
javax.print.attribute.SetOfIntegerSyntax(int)
javax.print.attribute.SetOfIntegerSyntax(int, int)
javax.print.attribute.SetOfIntegerSyntax(int[][])
javax.print.attribute.SetOfIntegerSyntax(java.lang.String)


Occurences of setOrdering

setOrdering occurences:
javax.imageio.spi.ServiceRegistry.setOrdering(java.lang.Class, T, T)
javax.imageio.spi.ServiceRegistry.setOrdering(java.lang.Class,java.lang.Object,java.lang.Object)


Occurences of setOrientation

setOrientation occurences:
java.awt.print.PageFormat.setOrientation(int)
java.awt.Scrollbar.setOrientation(int)
javax.swing.JProgressBar.setOrientation(int)
javax.swing.JScrollBar.setOrientation(int)
javax.swing.JSeparator.setOrientation(int)
javax.swing.JSlider.setOrientation(int)
javax.swing.JSplitPane.setOrientation(int)
javax.swing.JToolBar.setOrientation(int)
javax.swing.plaf.basic.BasicSplitPaneUI.setOrientation(int)
javax.swing.plaf.basic.BasicToolBarUI.setOrientation(int)
javax.swing.plaf.basic.BasicToolBarUI.DragWindow.setOrientation(int)


Occurences of setOrientationRequested

setOrientationRequested occurences:
java.awt.PageAttributes.setOrientationRequested(int)
java.awt.PageAttributes.setOrientationRequested(java.awt.PageAttributes.OrientationRequestedType)


Occurences of setOutputStream

setOutputStream occurences:
java.rmi.server.LogStream.setOutputStream(java.io.OutputStream)
java.util.logging.StreamHandler.setOutputStream(java.io.OutputStream)
javax.xml.transform.stream.StreamResult.setOutputStream(java.io.OutputStream)


Occurences of setOwner

setOwner occurences:
java.beans.XMLDecoder.setOwner(java.lang.Object)
java.beans.XMLEncoder.setOwner(java.lang.Object)


Occurences of setPage

setPage occurences:
java.awt.print.Book.setPage(int, java.awt.print.Printable, java.awt.print.PageFormat)
javax.swing.JEditorPane.setPage(java.lang.String)
javax.swing.JEditorPane.setPage(java.net.URL)


Occurences of setPaintMode

setPaintMode occurences:
java.awt.Graphics.setPaintMode()
javax.swing.DebugGraphics.setPaintMode()


Occurences of setPalette

setPalette occurences:
javax.swing.plaf.metal.MetalInternalFrameTitlePane.setPalette(boolean)
javax.swing.plaf.metal.MetalInternalFrameUI.setPalette(boolean)


Occurences of setParagraphAttributes

setParagraphAttributes occurences:
javax.swing.JTextPane.setParagraphAttributes(javax.swing.text.AttributeSet, boolean)
javax.swing.text.DefaultStyledDocument.setParagraphAttributes(int, int, javax.swing.text.AttributeSet, boolean)
javax.swing.text.html.HTMLDocument.setParagraphAttributes(int, int, javax.swing.text.AttributeSet, boolean)
javax.swing.text.StyledDocument.setParagraphAttributes(int, int, javax.swing.text.AttributeSet, boolean)
javax.swing.text.StyledEditorKit.StyledTextAction.setParagraphAttributes(javax.swing.JEditorPane, javax.swing.text.AttributeSet, boolean)


Occurences of setParameter

setParameter occurences:
java.security.Signature.setParameter(java.lang.String, java.lang.Object)
java.security.Signature.setParameter(java.security.spec.AlgorithmParameterSpec)
javax.activation.MimeType.setParameter(java.lang.String, java.lang.String)
javax.xml.transform.Transformer.setParameter(java.lang.String, java.lang.Object)
org.w3c.dom.DOMConfiguration.setParameter(java.lang.String, java.lang.Object)


Occurences of setParameters

setParameters occurences:
java.awt.image.renderable.ParameterBlock.setParameters(java.util.Vector)
java.util.logging.LogRecord.setParameters(java.lang.Object[])


Occurences of setParent

setParent occurences:
java.util.logging.Logger.setParent(java.util.logging.Logger)
java.util.ResourceBundle.setParent(java.util.ResourceBundle)
javax.swing.ActionMap.setParent(javax.swing.ActionMap)
javax.swing.ComponentInputMap.setParent(javax.swing.InputMap)
javax.swing.InputMap.setParent(javax.swing.InputMap)
javax.swing.text.AsyncBoxView.setParent(javax.swing.text.View)
javax.swing.text.ComponentView.setParent(javax.swing.text.View)
javax.swing.text.CompositeView.setParent(javax.swing.text.View)
javax.swing.text.FlowView.setParent(javax.swing.text.View)
javax.swing.text.html.BlockView.setParent(javax.swing.text.View)
javax.swing.text.html.ImageView.setParent(javax.swing.text.View)
javax.swing.text.html.ParagraphView.setParent(javax.swing.text.View)
javax.swing.text.View.setParent(javax.swing.text.View)
javax.swing.tree.DefaultMutableTreeNode.setParent(javax.swing.tree.MutableTreeNode)
javax.swing.tree.MutableTreeNode.setParent(javax.swing.tree.MutableTreeNode)
javax.xml.crypto.dsig.dom.DOMSignContext.setParent(org.w3c.dom.Node)
javax.xml.stream.util.EventReaderDelegate.setParent(javax.xml.stream.XMLEventReader)
javax.xml.stream.util.StreamReaderDelegate.setParent(javax.xml.stream.XMLStreamReader)
org.xml.sax.helpers.XMLFilterImpl.setParent(org.xml.sax.XMLReader)
org.xml.sax.XMLFilter.setParent(org.xml.sax.XMLReader)


Occurences of setPassword

setPassword occurences:
javax.security.auth.callback.PasswordCallback.setPassword(char[])
javax.sql.RowSet.setPassword(java.lang.String)
javax.sql.rowset.BaseRowSet.setPassword(java.lang.String)


Occurences of setPayload

setPayload occurences:
javax.xml.ws.LogicalMessage.setPayload(java.lang.Object, javax.xml.bind.JAXBContext)
javax.xml.ws.LogicalMessage.setPayload(javax.xml.transform.Source)


Occurences of setPerformancePreferences

setPerformancePreferences occurences:
java.net.ServerSocket.setPerformancePreferences(int, int, int)
java.net.Socket.setPerformancePreferences(int, int, int)
java.net.SocketImpl.setPerformancePreferences(int, int, int)


Occurences of setPixel

setPixel occurences:
java.awt.image.BandedSampleModel.setPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.setPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.MultiPixelPackedSampleModel.setPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.setPixel(int, int, double[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.setPixel(int, int, float[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.setPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.setPixel(int, int, int[], java.awt.image.DataBuffer)
java.awt.image.WritableRaster.setPixel(int, int, double[])
java.awt.image.WritableRaster.setPixel(int, int, float[])
java.awt.image.WritableRaster.setPixel(int, int, int[])


Occurences of setPixels

setPixels occurences:
java.awt.image.AreaAveragingScaleFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.AreaAveragingScaleFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.BandedSampleModel.setPixels(int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.BufferedImageFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.BufferedImageFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.ComponentSampleModel.setPixels(int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.CropImageFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.CropImageFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.ImageConsumer.setPixels(int, int, int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.ImageConsumer.setPixels(int, int, int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.ImageFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.ImageFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.PixelGrabber.setPixels(int, int, int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.PixelGrabber.setPixels(int, int, int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.ReplicateScaleFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.ReplicateScaleFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.RGBImageFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, byte[], int, int)
java.awt.image.RGBImageFilter.setPixels(int, int, int, int, java.awt.image.ColorModel, int[], int, int)
java.awt.image.SampleModel.setPixels(int, int, int, int, double[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.setPixels(int, int, int, int, float[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.setPixels(int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.setPixels(int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.WritableRaster.setPixels(int, int, int, int, double[])
java.awt.image.WritableRaster.setPixels(int, int, int, int, float[])
java.awt.image.WritableRaster.setPixels(int, int, int, int, int[])


Occurences of setPolicy

setPolicy occurences:
java.security.cert.X509CertSelector.setPolicy(java.util.Set)
java.security.Policy.setPolicy(java.security.Policy)
javax.security.auth.Policy.setPolicy(javax.security.auth.Policy)


Occurences of setPopupSize

setPopupSize occurences:
javax.swing.JPopupMenu.setPopupSize(int, int)
javax.swing.JPopupMenu.setPopupSize(java.awt.Dimension)


Occurences of setPopupVisible

setPopupVisible occurences:
javax.swing.JComboBox.setPopupVisible(boolean)
javax.swing.plaf.basic.BasicComboBoxUI.setPopupVisible(javax.swing.JComboBox, boolean)
javax.swing.plaf.ComboBoxUI.setPopupVisible(javax.swing.JComboBox, boolean)
javax.swing.plaf.multi.MultiComboBoxUI.setPopupVisible(javax.swing.JComboBox, boolean)


Occurences of setPosition

setPosition occurences:
java.awt.font.LineBreakMeasurer.setPosition(int)
javax.swing.JLayeredPane.setPosition(java.awt.Component, int)


Occurences of setPrecision

setPrecision occurences:
javax.sql.rowset.RowSetMetaDataImpl.setPrecision(int, int)
javax.sql.RowSetMetaData.setPrecision(int, int)


Occurences of setPreferredSize

setPreferredSize occurences:
java.awt.Component.setPreferredSize(java.awt.Dimension)
javax.swing.JComponent.setPreferredSize(java.awt.Dimension)


Occurences of setPrefix

setPrefix occurences:
javax.imageio.metadata.IIOMetadataNode.setPrefix(java.lang.String)
javax.xml.stream.XMLEventWriter.setPrefix(java.lang.String, java.lang.String)
javax.xml.stream.XMLStreamWriter.setPrefix(java.lang.String, java.lang.String)
org.w3c.dom.Node.setPrefix(java.lang.String)


Occurences of setPressed

setPressed occurences:
javax.swing.ButtonModel.setPressed(boolean)
javax.swing.DefaultButtonModel.setPressed(boolean)
javax.swing.JToggleButton.ToggleButtonModel.setPressed(boolean)


Occurences of setPrintable

setPrintable occurences:
java.awt.print.PrinterJob.setPrintable(java.awt.print.Printable)
java.awt.print.PrinterJob.setPrintable(java.awt.print.Printable, java.awt.print.PageFormat)


Occurences of setPrinterResolution

setPrinterResolution occurences:
java.awt.PageAttributes.setPrinterResolution(int)
java.awt.PageAttributes.setPrinterResolution(int[])


Occurences of setPrintQuality

setPrintQuality occurences:
java.awt.PageAttributes.setPrintQuality(int)
java.awt.PageAttributes.setPrintQuality(java.awt.PageAttributes.PrintQualityType)


Occurences of setProgress

setProgress occurences:
javax.swing.ProgressMonitor.setProgress(int)
javax.swing.SwingWorker.setProgress(int)


Occurences of setProperties

setProperties occurences:
java.awt.image.CropImageFilter.setProperties(java.util.Hashtable)
java.awt.image.ImageConsumer.setProperties(java.util.Hashtable)
java.awt.image.ImageFilter.setProperties(java.util.Hashtable)
java.awt.image.PixelGrabber.setProperties(java.util.Hashtable)
java.awt.image.ReplicateScaleFilter.setProperties(java.util.Hashtable)
java.lang.System.setProperties(java.util.Properties)
javax.xml.ws.Endpoint.setProperties(java.util.Map)


Occurences of setPropertiesFromAttributes

setPropertiesFromAttributes occurences:
javax.swing.text.html.BlockView.setPropertiesFromAttributes()
javax.swing.text.html.ImageView.setPropertiesFromAttributes()
javax.swing.text.html.InlineView.setPropertiesFromAttributes()
javax.swing.text.html.ListView.setPropertiesFromAttributes()
javax.swing.text.html.ParagraphView.setPropertiesFromAttributes()
javax.swing.text.LabelView.setPropertiesFromAttributes()
javax.swing.text.ParagraphView.setPropertiesFromAttributes()


Occurences of setProperty

setProperty occurences:
java.lang.System.setProperty(java.lang.String, java.lang.String)
java.security.Security.setProperty(java.lang.String, java.lang.String)
java.util.Properties.setProperty(java.lang.String, java.lang.String)
javax.xml.bind.Binder.setProperty(java.lang.String, java.lang.Object)
javax.xml.bind.helpers.AbstractMarshallerImpl.setProperty(java.lang.String, java.lang.Object)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setProperty(java.lang.String, java.lang.Object)
javax.xml.bind.Marshaller.setProperty(java.lang.String, java.lang.Object)
javax.xml.bind.Unmarshaller.setProperty(java.lang.String, java.lang.Object)
javax.xml.bind.Validator.setProperty(java.lang.String, java.lang.Object)
javax.xml.crypto.dom.DOMCryptoContext.setProperty(java.lang.String, java.lang.Object)
javax.xml.crypto.XMLCryptoContext.setProperty(java.lang.String, java.lang.Object)
javax.xml.parsers.SAXParser.setProperty(java.lang.String, java.lang.Object)
javax.xml.soap.SOAPMessage.setProperty(java.lang.String, java.lang.Object)
javax.xml.stream.XMLInputFactory.setProperty(java.lang.String, java.lang.Object)
javax.xml.stream.XMLOutputFactory.setProperty(java.lang.String, java.lang.Object)
javax.xml.validation.SchemaFactory.setProperty(java.lang.String, java.lang.Object)
javax.xml.validation.Validator.setProperty(java.lang.String, java.lang.Object)
javax.xml.validation.ValidatorHandler.setProperty(java.lang.String, java.lang.Object)
org.xml.sax.helpers.ParserAdapter.setProperty(java.lang.String, java.lang.Object)
org.xml.sax.helpers.XMLFilterImpl.setProperty(java.lang.String, java.lang.Object)
org.xml.sax.XMLReader.setProperty(java.lang.String, java.lang.Object)


Occurences of setPublicId

setPublicId occurences:
javax.xml.transform.stream.StreamSource.setPublicId(java.lang.String)
org.w3c.dom.ls.LSInput.setPublicId(java.lang.String)
org.xml.sax.helpers.LocatorImpl.setPublicId(java.lang.String)
org.xml.sax.InputSource.setPublicId(java.lang.String)


Occurences of setPurgeFlag

setPurgeFlag occurences:
javax.management.relation.RelationService.setPurgeFlag(boolean)
javax.management.relation.RelationServiceMBean.setPurgeFlag(boolean)


Occurences of setQueryTimeout

setQueryTimeout occurences:
java.sql.Statement.setQueryTimeout(int)
javax.sql.RowSet.setQueryTimeout(int)
javax.sql.rowset.BaseRowSet.setQueryTimeout(int)


Occurences of setRangeProperties

setRangeProperties occurences:
javax.swing.BoundedRangeModel.setRangeProperties(int, int, int, int, boolean)
javax.swing.DefaultBoundedRangeModel.setRangeProperties(int, int, int, int, boolean)


Occurences of setRawOffset

setRawOffset occurences:
java.util.SimpleTimeZone.setRawOffset(int)
java.util.TimeZone.setRawOffset(int)


Occurences of setReadable

setReadable occurences:
java.io.File.setReadable(boolean)
java.io.File.setReadable(boolean, boolean)


Occurences of setReader

setReader occurences:
javax.script.ScriptContext.setReader(java.io.Reader)
javax.script.SimpleScriptContext.setReader(java.io.Reader)
javax.xml.transform.stream.StreamSource.setReader(java.io.Reader)


Occurences of setReadOnly

setReadOnly occurences:
java.io.File.setReadOnly()
java.security.PermissionCollection.setReadOnly()
java.sql.Connection.setReadOnly(boolean)
javax.security.auth.Subject.setReadOnly()
javax.sql.RowSet.setReadOnly(boolean)
javax.sql.rowset.BaseRowSet.setReadOnly(boolean)


Occurences of setReceiveBufferSize

setReceiveBufferSize occurences:
java.net.DatagramSocket.setReceiveBufferSize(int)
java.net.ServerSocket.setReceiveBufferSize(int)
java.net.Socket.setReceiveBufferSize(int)


Occurences of setRect

setRect occurences:
java.awt.geom.Rectangle2D.setRect(double, double, double, double)
java.awt.geom.Rectangle2D.setRect(java.awt.geom.Rectangle2D)
java.awt.geom.Rectangle2D.Double.setRect(double, double, double, double)
java.awt.geom.Rectangle2D.Double.setRect(java.awt.geom.Rectangle2D)
java.awt.geom.Rectangle2D.Float.setRect(double, double, double, double)
java.awt.geom.Rectangle2D.Float.setRect(float, float, float, float)
java.awt.geom.Rectangle2D.Float.setRect(java.awt.geom.Rectangle2D)
java.awt.image.WritableRaster.setRect(int, int, java.awt.image.Raster)
java.awt.image.WritableRaster.setRect(java.awt.image.Raster)
java.awt.Rectangle.setRect(double, double, double, double)


Occurences of setRef

setRef occurences:
java.rmi.server.RemoteStub.setRef(java.rmi.server.RemoteStub, java.rmi.server.RemoteRef)
java.sql.PreparedStatement.setRef(int, java.sql.Ref)
javax.sql.RowSet.setRef(int, java.sql.Ref)
javax.sql.rowset.BaseRowSet.setRef(int, java.sql.Ref)


Occurences of setRelationServiceManagementFlag

setRelationServiceManagementFlag occurences:
javax.management.relation.RelationSupport.setRelationServiceManagementFlag(java.lang.Boolean)
javax.management.relation.RelationSupportMBean.setRelationServiceManagementFlag(java.lang.Boolean)


Occurences of setRemainingName

setRemainingName occurences:
javax.naming.NamingException.setRemainingName(javax.naming.Name)
javax.naming.spi.ResolveResult.setRemainingName(javax.naming.Name)


Occurences of setRenderingHints

setRenderingHints occurences:
java.awt.Graphics2D.setRenderingHints(java.util.Map)
java.awt.image.renderable.RenderContext.setRenderingHints(java.awt.RenderingHints)


Occurences of setRequestControls

setRequestControls occurences:
javax.naming.ldap.InitialLdapContext.setRequestControls(javax.naming.ldap.Control[])
javax.naming.ldap.LdapContext.setRequestControls(javax.naming.ldap.Control[])


Occurences of setResizable

setResizable occurences:
java.awt.Dialog.setResizable(boolean)
java.awt.Frame.setResizable(boolean)
javax.swing.JInternalFrame.setResizable(boolean)
javax.swing.table.TableColumn.setResizable(boolean)


Occurences of setResolvedObj

setResolvedObj occurences:
javax.naming.NamingException.setResolvedObj(java.lang.Object)
javax.naming.spi.ResolveResult.setResolvedObj(java.lang.Object)


Occurences of setResolvedValue

setResolvedValue occurences:
javax.sql.rowset.spi.SyncResolver.setResolvedValue(int, java.lang.Object)
javax.sql.rowset.spi.SyncResolver.setResolvedValue(java.lang.String, java.lang.Object)


Occurences of setResolveParent

setResolveParent occurences:
javax.swing.text.AbstractDocument.AbstractElement.setResolveParent(javax.swing.text.AttributeSet)
javax.swing.text.Keymap.setResolveParent(javax.swing.text.Keymap)
javax.swing.text.MutableAttributeSet.setResolveParent(javax.swing.text.AttributeSet)
javax.swing.text.SimpleAttributeSet.setResolveParent(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.NamedStyle.setResolveParent(javax.swing.text.AttributeSet)


Occurences of setResourceResolver

setResourceResolver occurences:
javax.xml.validation.SchemaFactory.setResourceResolver(org.w3c.dom.ls.LSResourceResolver)
javax.xml.validation.Validator.setResourceResolver(org.w3c.dom.ls.LSResourceResolver)
javax.xml.validation.ValidatorHandler.setResourceResolver(org.w3c.dom.ls.LSResourceResolver)


Occurences of setResult

setResult occurences:
java.sql.SQLXML.setResult(java.lang.Class)
javax.xml.transform.sax.TransformerHandler.setResult(javax.xml.transform.Result)


Occurences of setReuseAddress

setReuseAddress occurences:
java.net.DatagramSocket.setReuseAddress(boolean)
java.net.ServerSocket.setReuseAddress(boolean)
java.net.Socket.setReuseAddress(boolean)


Occurences of setRGB

setRGB occurences:
java.awt.image.BufferedImage.setRGB(int, int, int)
java.awt.image.BufferedImage.setRGB(int, int, int, int, int[], int, int)


Occurences of setRole

setRole occurences:
javax.management.relation.Relation.setRole(javax.management.relation.Role)
javax.management.relation.RelationService.setRole(java.lang.String, javax.management.relation.Role)
javax.management.relation.RelationServiceMBean.setRole(java.lang.String, javax.management.relation.Role)
javax.management.relation.RelationSupport.setRole(javax.management.relation.Role)
javax.xml.soap.SOAPHeaderElement.setRole(java.lang.String)


Occurences of setRoleName

setRoleName occurences:
javax.management.relation.Role.setRoleName(java.lang.String)
javax.management.relation.RoleUnresolved.setRoleName(java.lang.String)


Occurences of setRoles

setRoles occurences:
javax.management.relation.Relation.setRoles(javax.management.relation.RoleList)
javax.management.relation.RelationService.setRoles(java.lang.String, javax.management.relation.RoleList)
javax.management.relation.RelationServiceMBean.setRoles(java.lang.String, javax.management.relation.RoleList)
javax.management.relation.RelationSupport.setRoles(javax.management.relation.RoleList)
javax.management.relation.RoleResult.setRoles(javax.management.relation.RoleList)
javax.xml.ws.soap.SOAPBinding.setRoles(java.util.Set)


Occurences of setRoleValue

setRoleValue occurences:
javax.management.relation.Role.setRoleValue(java.util.List)
javax.management.relation.RoleUnresolved.setRoleValue(java.util.List)


Occurences of setRollover

setRollover occurences:
javax.swing.ButtonModel.setRollover(boolean)
javax.swing.DefaultButtonModel.setRollover(boolean)
javax.swing.JToolBar.setRollover(boolean)


Occurences of setRootPane

setRootPane occurences:
javax.swing.JApplet.setRootPane(javax.swing.JRootPane)
javax.swing.JDialog.setRootPane(javax.swing.JRootPane)
javax.swing.JFrame.setRootPane(javax.swing.JRootPane)
javax.swing.JInternalFrame.setRootPane(javax.swing.JRootPane)
javax.swing.JWindow.setRootPane(javax.swing.JRootPane)


Occurences of setRootPaneCheckingEnabled

setRootPaneCheckingEnabled occurences:
javax.swing.JApplet.setRootPaneCheckingEnabled(boolean)
javax.swing.JDialog.setRootPaneCheckingEnabled(boolean)
javax.swing.JFrame.setRootPaneCheckingEnabled(boolean)
javax.swing.JInternalFrame.setRootPaneCheckingEnabled(boolean)
javax.swing.JWindow.setRootPaneCheckingEnabled(boolean)


Occurences of setRootVisible

setRootVisible occurences:
javax.swing.JTree.setRootVisible(boolean)
javax.swing.plaf.basic.BasicTreeUI.setRootVisible(boolean)
javax.swing.tree.AbstractLayoutCache.setRootVisible(boolean)
javax.swing.tree.FixedHeightLayoutCache.setRootVisible(boolean)
javax.swing.tree.VariableHeightLayoutCache.setRootVisible(boolean)


Occurences of setRoundingMode

setRoundingMode occurences:
java.text.DecimalFormat.setRoundingMode(java.math.RoundingMode)
java.text.NumberFormat.setRoundingMode(java.math.RoundingMode)


Occurences of setRoundRect

setRoundRect occurences:
java.awt.geom.RoundRectangle2D.setRoundRect(double, double, double, double, double, double)
java.awt.geom.RoundRectangle2D.setRoundRect(java.awt.geom.RoundRectangle2D)
java.awt.geom.RoundRectangle2D.Double.setRoundRect(double, double, double, double, double, double)
java.awt.geom.RoundRectangle2D.Double.setRoundRect(java.awt.geom.RoundRectangle2D)
java.awt.geom.RoundRectangle2D.Float.setRoundRect(double, double, double, double, double, double)
java.awt.geom.RoundRectangle2D.Float.setRoundRect(float, float, float, float, float, float)
java.awt.geom.RoundRectangle2D.Float.setRoundRect(java.awt.geom.RoundRectangle2D)


Occurences of setRowHeight

setRowHeight occurences:
javax.swing.JTable.setRowHeight(int)
javax.swing.JTable.setRowHeight(int, int)
javax.swing.JTree.setRowHeight(int)
javax.swing.plaf.basic.BasicTreeUI.setRowHeight(int)
javax.swing.tree.AbstractLayoutCache.setRowHeight(int)
javax.swing.tree.FixedHeightLayoutCache.setRowHeight(int)
javax.swing.tree.VariableHeightLayoutCache.setRowHeight(int)


Occurences of setRowId

setRowId occurences:
java.sql.CallableStatement.setRowId(java.lang.String, java.sql.RowId)
java.sql.PreparedStatement.setRowId(int, java.sql.RowId)
javax.sql.RowSet.setRowId(int, java.sql.RowId)
javax.sql.RowSet.setRowId(java.lang.String, java.sql.RowId)
javax.sql.rowset.BaseRowSet.setRowId(int, java.sql.RowId)
javax.sql.rowset.BaseRowSet.setRowId(java.lang.String, java.sql.RowId)


Occurences of setRowMapper

setRowMapper occurences:
javax.swing.tree.DefaultTreeSelectionModel.setRowMapper(javax.swing.tree.RowMapper)
javax.swing.tree.TreeSelectionModel.setRowMapper(javax.swing.tree.RowMapper)


Occurences of setRows

setRows occurences:
java.awt.GridLayout.setRows(int)
java.awt.TextArea.setRows(int)
javax.swing.JTextArea.setRows(int)


Occurences of setSample

setSample occurences:
java.awt.image.BandedSampleModel.setSample(int, int, int, double, java.awt.image.DataBuffer)
java.awt.image.BandedSampleModel.setSample(int, int, int, float, java.awt.image.DataBuffer)
java.awt.image.BandedSampleModel.setSample(int, int, int, int, java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.setSample(int, int, int, double, java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.setSample(int, int, int, float, java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.setSample(int, int, int, int, java.awt.image.DataBuffer)
java.awt.image.MultiPixelPackedSampleModel.setSample(int, int, int, int, java.awt.image.DataBuffer)
java.awt.image.SampleModel.setSample(int, int, int, double, java.awt.image.DataBuffer)
java.awt.image.SampleModel.setSample(int, int, int, float, java.awt.image.DataBuffer)
java.awt.image.SampleModel.setSample(int, int, int, int, java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.setSample(int, int, int, int, java.awt.image.DataBuffer)
java.awt.image.WritableRaster.setSample(int, int, int, double)
java.awt.image.WritableRaster.setSample(int, int, int, float)
java.awt.image.WritableRaster.setSample(int, int, int, int)


Occurences of setSamples

setSamples occurences:
java.awt.image.BandedSampleModel.setSamples(int, int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.ComponentSampleModel.setSamples(int, int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.setSamples(int, int, int, int, int, double[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.setSamples(int, int, int, int, int, float[], java.awt.image.DataBuffer)
java.awt.image.SampleModel.setSamples(int, int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.SinglePixelPackedSampleModel.setSamples(int, int, int, int, int, int[], java.awt.image.DataBuffer)
java.awt.image.WritableRaster.setSamples(int, int, int, int, int, double[])
java.awt.image.WritableRaster.setSamples(int, int, int, int, int, float[])
java.awt.image.WritableRaster.setSamples(int, int, int, int, int, int[])


Occurences of setSavepoint

setSavepoint occurences:
java.sql.Connection.setSavepoint()
java.sql.Connection.setSavepoint(java.lang.String)


Occurences of setScale

setScale occurences:
java.math.BigDecimal.setScale(int)
java.math.BigDecimal.setScale(int, int)
java.math.BigDecimal.setScale(int, java.math.RoundingMode)
javax.sql.rowset.RowSetMetaDataImpl.setScale(int, int)
javax.sql.RowSetMetaData.setScale(int, int)


Occurences of setSchema

setSchema occurences:
javax.xml.bind.Binder.setSchema(javax.xml.validation.Schema)
javax.xml.bind.helpers.AbstractMarshallerImpl.setSchema(javax.xml.validation.Schema)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setSchema(javax.xml.validation.Schema)
javax.xml.bind.Marshaller.setSchema(javax.xml.validation.Schema)
javax.xml.bind.Unmarshaller.setSchema(javax.xml.validation.Schema)
javax.xml.parsers.DocumentBuilderFactory.setSchema(javax.xml.validation.Schema)
javax.xml.parsers.SAXParserFactory.setSchema(javax.xml.validation.Schema)


Occurences of setSchemaName

setSchemaName occurences:
javax.sql.rowset.RowSetMetaDataImpl.setSchemaName(int, java.lang.String)
javax.sql.RowSetMetaData.setSchemaName(int, java.lang.String)


Occurences of setScrollByBlock

setScrollByBlock occurences:
javax.swing.plaf.basic.BasicScrollBarUI.ScrollListener.setScrollByBlock(boolean)
javax.swing.plaf.basic.BasicSliderUI.ScrollListener.setScrollByBlock(boolean)


Occurences of setScrollPosition

setScrollPosition occurences:
java.awt.ScrollPane.setScrollPosition(int, int)
java.awt.ScrollPane.setScrollPosition(java.awt.Point)


Occurences of setSearchable

setSearchable occurences:
javax.sql.rowset.RowSetMetaDataImpl.setSearchable(int, boolean)
javax.sql.RowSetMetaData.setSearchable(int, boolean)


Occurences of setSeconds

setSeconds occurences:
java.sql.Date.setSeconds(int)
java.util.Date.setSeconds(int)


Occurences of setSeed

setSeed occurences:
java.security.SecureRandom.setSeed(byte[])
java.security.SecureRandom.setSeed(long)
java.util.Random.setSeed(long)


Occurences of setSelected

setSelected occurences:
javax.swing.AbstractButton.setSelected(boolean)
javax.swing.ButtonGroup.setSelected(javax.swing.ButtonModel, boolean)
javax.swing.ButtonModel.setSelected(boolean)
javax.swing.DefaultButtonModel.setSelected(boolean)
javax.swing.JInternalFrame.setSelected(boolean)
javax.swing.JMenu.setSelected(boolean)
javax.swing.JMenuBar.setSelected(java.awt.Component)
javax.swing.JPopupMenu.setSelected(java.awt.Component)
javax.swing.JToggleButton.ToggleButtonModel.setSelected(boolean)


Occurences of setSelectedColor

setSelectedColor occurences:
javax.swing.colorchooser.ColorSelectionModel.setSelectedColor(java.awt.Color)
javax.swing.colorchooser.DefaultColorSelectionModel.setSelectedColor(java.awt.Color)


Occurences of setSelectedIndex

setSelectedIndex occurences:
javax.security.auth.callback.ChoiceCallback.setSelectedIndex(int)
javax.security.auth.callback.ConfirmationCallback.setSelectedIndex(int)
javax.swing.DefaultSingleSelectionModel.setSelectedIndex(int)
javax.swing.JComboBox.setSelectedIndex(int)
javax.swing.JList.setSelectedIndex(int)
javax.swing.JTabbedPane.setSelectedIndex(int)
javax.swing.SingleSelectionModel.setSelectedIndex(int)


Occurences of setSelectedItem

setSelectedItem occurences:
javax.swing.ComboBoxModel.setSelectedItem(java.lang.Object)
javax.swing.DefaultComboBoxModel.setSelectedItem(java.lang.Object)
javax.swing.JComboBox.setSelectedItem(java.lang.Object)
javax.swing.plaf.metal.MetalFileChooserUI.DirectoryComboBoxModel.setSelectedItem(java.lang.Object)
javax.swing.plaf.metal.MetalFileChooserUI.FilterComboBoxModel.setSelectedItem(java.lang.Object)


Occurences of setSelectionBackground

setSelectionBackground occurences:
javax.swing.JList.setSelectionBackground(java.awt.Color)
javax.swing.JTable.setSelectionBackground(java.awt.Color)


Occurences of setSelectionEnd

setSelectionEnd occurences:
java.awt.TextComponent.setSelectionEnd(int)
javax.swing.text.JTextComponent.setSelectionEnd(int)


Occurences of setSelectionForeground

setSelectionForeground occurences:
javax.swing.JList.setSelectionForeground(java.awt.Color)
javax.swing.JTable.setSelectionForeground(java.awt.Color)


Occurences of setSelectionInterval

setSelectionInterval occurences:
javax.swing.DefaultListSelectionModel.setSelectionInterval(int, int)
javax.swing.JList.setSelectionInterval(int, int)
javax.swing.JTree.setSelectionInterval(int, int)
javax.swing.ListSelectionModel.setSelectionInterval(int, int)


Occurences of setSelectionMode

setSelectionMode occurences:
javax.swing.DefaultListSelectionModel.setSelectionMode(int)
javax.swing.JList.setSelectionMode(int)
javax.swing.JTable.setSelectionMode(int)
javax.swing.ListSelectionModel.setSelectionMode(int)
javax.swing.tree.DefaultTreeSelectionModel.setSelectionMode(int)
javax.swing.tree.TreeSelectionModel.setSelectionMode(int)


Occurences of setSelectionModel

setSelectionModel occurences:
javax.swing.JColorChooser.setSelectionModel(javax.swing.colorchooser.ColorSelectionModel)
javax.swing.JList.setSelectionModel(javax.swing.ListSelectionModel)
javax.swing.JMenuBar.setSelectionModel(javax.swing.SingleSelectionModel)
javax.swing.JPopupMenu.setSelectionModel(javax.swing.SingleSelectionModel)
javax.swing.JTable.setSelectionModel(javax.swing.ListSelectionModel)
javax.swing.JTree.setSelectionModel(javax.swing.tree.TreeSelectionModel)
javax.swing.plaf.basic.BasicTreeUI.setSelectionModel(javax.swing.tree.TreeSelectionModel)
javax.swing.table.DefaultTableColumnModel.setSelectionModel(javax.swing.ListSelectionModel)
javax.swing.table.TableColumnModel.setSelectionModel(javax.swing.ListSelectionModel)
javax.swing.tree.AbstractLayoutCache.setSelectionModel(javax.swing.tree.TreeSelectionModel)


Occurences of setSelectionPath

setSelectionPath occurences:
javax.swing.JTree.setSelectionPath(javax.swing.tree.TreePath)
javax.swing.tree.DefaultTreeSelectionModel.setSelectionPath(javax.swing.tree.TreePath)
javax.swing.tree.TreeSelectionModel.setSelectionPath(javax.swing.tree.TreePath)


Occurences of setSelectionPaths

setSelectionPaths occurences:
javax.swing.JTree.setSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.JTree.EmptySelectionModel.setSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.tree.DefaultTreeSelectionModel.setSelectionPaths(javax.swing.tree.TreePath[])
javax.swing.tree.TreeSelectionModel.setSelectionPaths(javax.swing.tree.TreePath[])


Occurences of setSelectionStart

setSelectionStart occurences:
java.awt.TextComponent.setSelectionStart(int)
javax.swing.text.JTextComponent.setSelectionStart(int)


Occurences of setSelectionVisible

setSelectionVisible occurences:
javax.swing.text.Caret.setSelectionVisible(boolean)
javax.swing.text.DefaultCaret.setSelectionVisible(boolean)


Occurences of setSendBufferSize

setSendBufferSize occurences:
java.net.DatagramSocket.setSendBufferSize(int)
java.net.Socket.setSendBufferSize(int)


Occurences of setSendPastNotifications

setSendPastNotifications occurences:
javax.management.timer.Timer.setSendPastNotifications(boolean)
javax.management.timer.TimerMBean.setSendPastNotifications(boolean)


Occurences of setSequence

setSequence occurences:
javax.sound.midi.Sequencer.setSequence(java.io.InputStream)
javax.sound.midi.Sequencer.setSequence(javax.sound.midi.Sequence)


Occurences of setSequenceNumber

setSequenceNumber occurences:
java.util.logging.LogRecord.setSequenceNumber(long)
javax.management.Notification.setSequenceNumber(long)


Occurences of setShort

setShort occurences:
java.lang.reflect.Array.setShort(java.lang.Object, int, short)
java.lang.reflect.Field.setShort(java.lang.Object, short)
java.sql.CallableStatement.setShort(java.lang.String, short)
java.sql.PreparedStatement.setShort(int, short)
javax.sql.RowSet.setShort(int, short)
javax.sql.RowSet.setShort(java.lang.String, short)
javax.sql.rowset.BaseRowSet.setShort(int, short)
javax.sql.rowset.BaseRowSet.setShort(java.lang.String, short)


Occurences of setShowDeleted

setShowDeleted occurences:
javax.sql.rowset.BaseRowSet.setShowDeleted(boolean)
javax.sql.rowset.CachedRowSet.setShowDeleted(boolean)
javax.sql.rowset.JdbcRowSet.setShowDeleted(boolean)


Occurences of setShowsRootHandles

setShowsRootHandles occurences:
javax.swing.JTree.setShowsRootHandles(boolean)
javax.swing.plaf.basic.BasicTreeUI.setShowsRootHandles(boolean)


Occurences of setSigned

setSigned occurences:
javax.sql.rowset.RowSetMetaDataImpl.setSigned(int, boolean)
javax.sql.RowSetMetaData.setSigned(int, boolean)


Occurences of setSize

setSize occurences:
java.awt.Component.setSize(int, int)
java.awt.Component.setSize(java.awt.Dimension)
java.awt.Component.AccessibleAWTComponent.setSize(java.awt.Dimension)
java.awt.Dimension.setSize(double, double)
java.awt.Dimension.setSize(int, int)
java.awt.Dimension.setSize(java.awt.Dimension)
java.awt.geom.Dimension2D.setSize(double, double)
java.awt.geom.Dimension2D.setSize(java.awt.geom.Dimension2D)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setSize(java.awt.Dimension)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setSize(java.awt.Dimension)
java.awt.print.Paper.setSize(double, double)
java.awt.Rectangle.setSize(int, int)
java.awt.Rectangle.setSize(java.awt.Dimension)
java.awt.Window.setSize(int, int)
java.awt.Window.setSize(java.awt.Dimension)
java.util.Vector.setSize(int)
java.util.zip.ZipEntry.setSize(long)
javax.accessibility.AccessibleComponent.setSize(java.awt.Dimension)
javax.swing.DefaultListModel.setSize(int)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setSize(java.awt.Dimension)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setSize(java.awt.Dimension)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setSize(java.awt.Dimension)
javax.swing.SizeSequence.setSize(int, int)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setSize(java.awt.Dimension)
javax.swing.text.AsyncBoxView.setSize(float, float)
javax.swing.text.BoxView.setSize(float, float)
javax.swing.text.html.ImageView.setSize(float, float)
javax.swing.text.PlainView.setSize(float, float)
javax.swing.text.View.setSize(float, float)
javax.swing.text.WrappedPlainView.setSize(float, float)


Occurences of setSizes

setSizes occurences:
javax.swing.plaf.basic.BasicSplitPaneUI.BasicHorizontalLayoutManager.setSizes(int[])
javax.swing.SizeSequence.setSizes(int[])


Occurences of setSocketFactory

setSocketFactory occurences:
java.net.ServerSocket.setSocketFactory(java.net.SocketImplFactory)
java.rmi.server.RMISocketFactory.setSocketFactory(java.rmi.server.RMISocketFactory)


Occurences of setSortKeys

setSortKeys occurences:
javax.swing.DefaultRowSorter.setSortKeys(java.util.List)
javax.swing.RowSorter.setSortKeys(java.util.List)


Occurences of setSoTimeout

setSoTimeout occurences:
java.net.DatagramSocket.setSoTimeout(int)
java.net.ServerSocket.setSoTimeout(int)
java.net.Socket.setSoTimeout(int)


Occurences of setSource

setSource occurences:
java.awt.AWTEvent.setSource(java.lang.Object)
java.awt.image.renderable.ParameterBlock.setSource(java.lang.Object, int)
java.beans.PropertyEditorSupport.setSource(java.lang.Object)
javax.management.Notification.setSource(java.lang.Object)


Occurences of setSQLXML

setSQLXML occurences:
java.sql.CallableStatement.setSQLXML(java.lang.String, java.sql.SQLXML)
java.sql.PreparedStatement.setSQLXML(int, java.sql.SQLXML)
javax.sql.RowSet.setSQLXML(int, java.sql.SQLXML)
javax.sql.RowSet.setSQLXML(java.lang.String, java.sql.SQLXML)
javax.sql.rowset.BaseRowSet.setSQLXML(int, java.sql.SQLXML)
javax.sql.rowset.BaseRowSet.setSQLXML(java.lang.String, java.sql.SQLXML)


Occurences of setSSLParameters

setSSLParameters occurences:
javax.net.ssl.SSLEngine.setSSLParameters(javax.net.ssl.SSLParameters)
javax.net.ssl.SSLSocket.setSSLParameters(javax.net.ssl.SSLParameters)


Occurences of setStartRule

setStartRule occurences:
java.util.SimpleTimeZone.setStartRule(int, int, int)
java.util.SimpleTimeZone.setStartRule(int, int, int, int)
java.util.SimpleTimeZone.setStartRule(int, int, int, int, boolean)


Occurences of setState

setState occurences:
java.awt.Checkbox.setState(boolean)
java.awt.CheckboxMenuItem.setState(boolean)
java.awt.Frame.setState(int)
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.setState(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.setState(int)
javax.swing.JCheckBoxMenuItem.setState(boolean)


Occurences of setStrikeThrough

setStrikeThrough occurences:
javax.swing.text.LabelView.setStrikeThrough(boolean)
javax.swing.text.StyleConstants.setStrikeThrough(javax.swing.text.MutableAttributeSet, boolean)


Occurences of setString

setString occurences:
java.sql.CallableStatement.setString(java.lang.String, java.lang.String)
java.sql.Clob.setString(long, java.lang.String)
java.sql.Clob.setString(long, java.lang.String, int, int)
java.sql.PreparedStatement.setString(int, java.lang.String)
java.sql.SQLXML.setString(java.lang.String)
javax.sql.RowSet.setString(int, java.lang.String)
javax.sql.RowSet.setString(java.lang.String, java.lang.String)
javax.sql.rowset.BaseRowSet.setString(int, java.lang.String)
javax.sql.rowset.BaseRowSet.setString(java.lang.String, java.lang.String)
javax.sql.rowset.serial.SerialClob.setString(long, java.lang.String)
javax.sql.rowset.serial.SerialClob.setString(long, java.lang.String, int, int)
javax.swing.JProgressBar.setString(java.lang.String)


Occurences of setStringToCompare

setStringToCompare occurences:
javax.management.monitor.StringMonitor.setStringToCompare(java.lang.String)
javax.management.monitor.StringMonitorMBean.setStringToCompare(java.lang.String)


Occurences of setSubject

setSubject occurences:
java.security.cert.X509CertSelector.setSubject(byte[])
java.security.cert.X509CertSelector.setSubject(java.lang.String)
java.security.cert.X509CertSelector.setSubject(javax.security.auth.x500.X500Principal)


Occurences of setSubjectPublicKey

setSubjectPublicKey occurences:
java.security.cert.X509CertSelector.setSubjectPublicKey(byte[])
java.security.cert.X509CertSelector.setSubjectPublicKey(java.security.PublicKey)


Occurences of setSubscript

setSubscript occurences:
javax.swing.text.LabelView.setSubscript(boolean)
javax.swing.text.StyleConstants.setSubscript(javax.swing.text.MutableAttributeSet, boolean)


Occurences of setSuperscript

setSuperscript occurences:
javax.swing.text.LabelView.setSuperscript(boolean)
javax.swing.text.StyleConstants.setSuperscript(javax.swing.text.MutableAttributeSet, boolean)


Occurences of setSystemId

setSystemId occurences:
javax.xml.transform.dom.DOMResult.setSystemId(java.lang.String)
javax.xml.transform.dom.DOMSource.setSystemId(java.lang.String)
javax.xml.transform.Result.setSystemId(java.lang.String)
javax.xml.transform.sax.SAXResult.setSystemId(java.lang.String)
javax.xml.transform.sax.SAXSource.setSystemId(java.lang.String)
javax.xml.transform.sax.TemplatesHandler.setSystemId(java.lang.String)
javax.xml.transform.sax.TransformerHandler.setSystemId(java.lang.String)
javax.xml.transform.Source.setSystemId(java.lang.String)
javax.xml.transform.stax.StAXResult.setSystemId(java.lang.String)
javax.xml.transform.stax.StAXSource.setSystemId(java.lang.String)
javax.xml.transform.stream.StreamResult.setSystemId(java.io.File)
javax.xml.transform.stream.StreamResult.setSystemId(java.lang.String)
javax.xml.transform.stream.StreamSource.setSystemId(java.io.File)
javax.xml.transform.stream.StreamSource.setSystemId(java.lang.String)
org.w3c.dom.ls.LSInput.setSystemId(java.lang.String)
org.w3c.dom.ls.LSOutput.setSystemId(java.lang.String)
org.xml.sax.helpers.LocatorImpl.setSystemId(java.lang.String)
org.xml.sax.InputSource.setSystemId(java.lang.String)


Occurences of setTableName

setTableName occurences:
javax.sql.rowset.CachedRowSet.setTableName(java.lang.String)
javax.sql.rowset.RowSetMetaDataImpl.setTableName(int, java.lang.String)
javax.sql.RowSetMetaData.setTableName(int, java.lang.String)


Occurences of setTarget

setTarget occurences:
javax.accessibility.AccessibleRelation.setTarget(java.lang.Object)
javax.accessibility.AccessibleRelation.setTarget(java.lang.Object[])
javax.rmi.CORBA.Tie.setTarget(java.rmi.Remote)


Occurences of setText

setText occurences:
java.awt.Label.setText(java.lang.String)
java.awt.TextComponent.setText(java.lang.String)
java.awt.TextField.setText(java.lang.String)
java.text.BreakIterator.setText(java.lang.String)
java.text.BreakIterator.setText(java.text.CharacterIterator)
java.text.CollationElementIterator.setText(java.lang.String)
java.text.CollationElementIterator.setText(java.text.CharacterIterator)
java.text.StringCharacterIterator.setText(java.lang.String)
javax.security.auth.callback.TextInputCallback.setText(java.lang.String)
javax.swing.AbstractButton.setText(java.lang.String)
javax.swing.JEditorPane.setText(java.lang.String)
javax.swing.JLabel.setText(java.lang.String)
javax.swing.text.JTextComponent.setText(java.lang.String)


Occurences of setTextContent

setTextContent occurences:
javax.imageio.metadata.IIOMetadataNode.setTextContent(java.lang.String)
org.w3c.dom.Node.setTextContent(java.lang.String)


Occurences of setTextContents

setTextContents occurences:
javax.accessibility.AccessibleEditableText.setTextContents(java.lang.String)
javax.swing.JSpinner.AccessibleJSpinner.setTextContents(java.lang.String)
javax.swing.text.JTextComponent.AccessibleJTextComponent.setTextContents(java.lang.String)


Occurences of setThreshold

setThreshold occurences:
javax.management.monitor.CounterMonitor.setThreshold(java.lang.Number)
javax.management.monitor.CounterMonitorMBean.setThreshold(java.lang.Number)


Occurences of setThresholds

setThresholds occurences:
javax.management.monitor.GaugeMonitor.setThresholds(java.lang.Number, java.lang.Number)
javax.management.monitor.GaugeMonitorMBean.setThresholds(java.lang.Number, java.lang.Number)


Occurences of setThumbBounds

setThumbBounds occurences:
javax.swing.plaf.basic.BasicScrollBarUI.setThumbBounds(int, int, int, int)
javax.swing.plaf.metal.MetalScrollBarUI.setThumbBounds(int, int, int, int)


Occurences of setTime

setTime occurences:
java.sql.CallableStatement.setTime(java.lang.String, java.sql.Time)
java.sql.CallableStatement.setTime(java.lang.String, java.sql.Time, java.util.Calendar)
java.sql.Date.setTime(long)
java.sql.PreparedStatement.setTime(int, java.sql.Time)
java.sql.PreparedStatement.setTime(int, java.sql.Time, java.util.Calendar)
java.sql.Time.setTime(long)
java.sql.Timestamp.setTime(long)
java.util.Calendar.setTime(java.util.Date)
java.util.Date.setTime(long)
java.util.zip.ZipEntry.setTime(long)
javax.sql.RowSet.setTime(int, java.sql.Time)
javax.sql.RowSet.setTime(int, java.sql.Time, java.util.Calendar)
javax.sql.RowSet.setTime(java.lang.String, java.sql.Time)
javax.sql.RowSet.setTime(java.lang.String, java.sql.Time, java.util.Calendar)
javax.sql.rowset.BaseRowSet.setTime(int, java.sql.Time)
javax.sql.rowset.BaseRowSet.setTime(int, java.sql.Time, java.util.Calendar)
javax.sql.rowset.BaseRowSet.setTime(java.lang.String, java.sql.Time)
javax.sql.rowset.BaseRowSet.setTime(java.lang.String, java.sql.Time, java.util.Calendar)
javax.xml.datatype.XMLGregorianCalendar.setTime(int, int, int)
javax.xml.datatype.XMLGregorianCalendar.setTime(int, int, int, int)
javax.xml.datatype.XMLGregorianCalendar.setTime(int, int, int, java.math.BigDecimal)


Occurences of setTimestamp

setTimestamp occurences:
java.sql.CallableStatement.setTimestamp(java.lang.String, java.sql.Timestamp)
java.sql.CallableStatement.setTimestamp(java.lang.String, java.sql.Timestamp, java.util.Calendar)
java.sql.PreparedStatement.setTimestamp(int, java.sql.Timestamp)
java.sql.PreparedStatement.setTimestamp(int, java.sql.Timestamp, java.util.Calendar)
javax.sql.RowSet.setTimestamp(int, java.sql.Timestamp)
javax.sql.RowSet.setTimestamp(int, java.sql.Timestamp, java.util.Calendar)
javax.sql.RowSet.setTimestamp(java.lang.String, java.sql.Timestamp)
javax.sql.RowSet.setTimestamp(java.lang.String, java.sql.Timestamp, java.util.Calendar)
javax.sql.rowset.BaseRowSet.setTimestamp(int, java.sql.Timestamp)
javax.sql.rowset.BaseRowSet.setTimestamp(int, java.sql.Timestamp, java.util.Calendar)
javax.sql.rowset.BaseRowSet.setTimestamp(java.lang.String, java.sql.Timestamp)
javax.sql.rowset.BaseRowSet.setTimestamp(java.lang.String, java.sql.Timestamp, java.util.Calendar)


Occurences of setTimeToLive

setTimeToLive occurences:
java.net.DatagramSocketImpl.setTimeToLive(int)
java.net.MulticastSocket.setTimeToLive(int)


Occurences of setTimeZone

setTimeZone occurences:
java.text.DateFormat.setTimeZone(java.util.TimeZone)
java.util.Calendar.setTimeZone(java.util.TimeZone)
java.util.GregorianCalendar.setTimeZone(java.util.TimeZone)


Occurences of Setting the class path

Setting the class path occurences:
Setting the class path
Setting the class path


Occurences of setTitle

setTitle occurences:
java.awt.Dialog.setTitle(java.lang.String)
java.awt.Frame.setTitle(java.lang.String)
javax.swing.border.TitledBorder.setTitle(java.lang.String)
javax.swing.JInternalFrame.setTitle(java.lang.String)


Occurences of setToQuadrantRotation

setToQuadrantRotation occurences:
java.awt.geom.AffineTransform.setToQuadrantRotation(int)
java.awt.geom.AffineTransform.setToQuadrantRotation(int, double, double)


Occurences of setToRotation

setToRotation occurences:
java.awt.geom.AffineTransform.setToRotation(double)
java.awt.geom.AffineTransform.setToRotation(double, double)
java.awt.geom.AffineTransform.setToRotation(double, double, double)
java.awt.geom.AffineTransform.setToRotation(double, double, double, double)


Occurences of setTrafficClass

setTrafficClass occurences:
java.net.DatagramSocket.setTrafficClass(int)
java.net.Socket.setTrafficClass(int)


Occurences of setTransactionIsolation

setTransactionIsolation occurences:
java.sql.Connection.setTransactionIsolation(int)
javax.sql.RowSet.setTransactionIsolation(int)
javax.sql.rowset.BaseRowSet.setTransactionIsolation(int)


Occurences of setTransferHandler

setTransferHandler occurences:
javax.swing.JApplet.setTransferHandler(javax.swing.TransferHandler)
javax.swing.JComponent.setTransferHandler(javax.swing.TransferHandler)
javax.swing.JDialog.setTransferHandler(javax.swing.TransferHandler)
javax.swing.JFrame.setTransferHandler(javax.swing.TransferHandler)
javax.swing.JWindow.setTransferHandler(javax.swing.TransferHandler)


Occurences of setTransform

setTransform occurences:
java.awt.geom.AffineTransform.setTransform(double, double, double, double, double, double)
java.awt.geom.AffineTransform.setTransform(java.awt.geom.AffineTransform)
java.awt.Graphics2D.setTransform(java.awt.geom.AffineTransform)
java.awt.image.renderable.RenderContext.setTransform(java.awt.geom.AffineTransform)


Occurences of setTTL

setTTL occurences:
java.net.DatagramSocketImpl.setTTL(byte)
java.net.MulticastSocket.setTTL(byte)


Occurences of setType

setType occurences:
javax.sql.RowSet.setType(int)
javax.sql.rowset.BaseRowSet.setType(int)
javax.swing.text.DefaultStyledDocument.ElementSpec.setType(short)
org.xml.sax.helpers.AttributesImpl.setType(int, java.lang.String)


Occurences of setTypeMap

setTypeMap occurences:
java.sql.Connection.setTypeMap(java.util.Map)
javax.sql.RowSet.setTypeMap(java.util.Map)
javax.sql.rowset.BaseRowSet.setTypeMap(java.util.Map)


Occurences of setUI

setUI occurences:
javax.swing.AbstractButton.setUI(javax.swing.plaf.ButtonUI)
javax.swing.JColorChooser.setUI(javax.swing.plaf.ColorChooserUI)
javax.swing.JComboBox.setUI(javax.swing.plaf.ComboBoxUI)
javax.swing.JComponent.setUI(javax.swing.plaf.ComponentUI)
javax.swing.JDesktopPane.setUI(javax.swing.plaf.DesktopPaneUI)
javax.swing.JInternalFrame.setUI(javax.swing.plaf.InternalFrameUI)
javax.swing.JInternalFrame.JDesktopIcon.setUI(javax.swing.plaf.DesktopIconUI)
javax.swing.JLabel.setUI(javax.swing.plaf.LabelUI)
javax.swing.JList.setUI(javax.swing.plaf.ListUI)
javax.swing.JMenuBar.setUI(javax.swing.plaf.MenuBarUI)
javax.swing.JMenuItem.setUI(javax.swing.plaf.MenuItemUI)
javax.swing.JOptionPane.setUI(javax.swing.plaf.OptionPaneUI)
javax.swing.JPanel.setUI(javax.swing.plaf.PanelUI)
javax.swing.JPopupMenu.setUI(javax.swing.plaf.PopupMenuUI)
javax.swing.JProgressBar.setUI(javax.swing.plaf.ProgressBarUI)
javax.swing.JRootPane.setUI(javax.swing.plaf.RootPaneUI)
javax.swing.JScrollBar.setUI(javax.swing.plaf.ScrollBarUI)
javax.swing.JScrollPane.setUI(javax.swing.plaf.ScrollPaneUI)
javax.swing.JSeparator.setUI(javax.swing.plaf.SeparatorUI)
javax.swing.JSlider.setUI(javax.swing.plaf.SliderUI)
javax.swing.JSpinner.setUI(javax.swing.plaf.SpinnerUI)
javax.swing.JSplitPane.setUI(javax.swing.plaf.SplitPaneUI)
javax.swing.JTabbedPane.setUI(javax.swing.plaf.TabbedPaneUI)
javax.swing.JTable.setUI(javax.swing.plaf.TableUI)
javax.swing.JToolBar.setUI(javax.swing.plaf.ToolBarUI)
javax.swing.JTree.setUI(javax.swing.plaf.TreeUI)
javax.swing.JViewport.setUI(javax.swing.plaf.ViewportUI)
javax.swing.table.JTableHeader.setUI(javax.swing.plaf.TableHeaderUI)
javax.swing.text.JTextComponent.setUI(javax.swing.plaf.TextUI)


Occurences of setUndecorated

setUndecorated occurences:
java.awt.Dialog.setUndecorated(boolean)
java.awt.Frame.setUndecorated(boolean)


Occurences of setUnderline

setUnderline occurences:
javax.swing.text.LabelView.setUnderline(boolean)
javax.swing.text.StyleConstants.setUnderline(javax.swing.text.MutableAttributeSet, boolean)


Occurences of setUnicodeStream

setUnicodeStream occurences:
java.sql.PreparedStatement.setUnicodeStream(int, java.io.InputStream, int)
javax.sql.rowset.BaseRowSet.setUnicodeStream(int, java.io.InputStream, int)


Occurences of setUnitIncrement

setUnitIncrement occurences:
java.awt.Adjustable.setUnitIncrement(int)
java.awt.Scrollbar.setUnitIncrement(int)
java.awt.ScrollPaneAdjustable.setUnitIncrement(int)
javax.swing.JScrollBar.setUnitIncrement(int)
javax.swing.JScrollPane.ScrollBar.setUnitIncrement(int)


Occurences of setURIDereferencer

setURIDereferencer occurences:
javax.xml.crypto.dom.DOMCryptoContext.setURIDereferencer(javax.xml.crypto.URIDereferencer)
javax.xml.crypto.XMLCryptoContext.setURIDereferencer(javax.xml.crypto.URIDereferencer)


Occurences of setURIResolver

setURIResolver occurences:
javax.xml.transform.Transformer.setURIResolver(javax.xml.transform.URIResolver)
javax.xml.transform.TransformerFactory.setURIResolver(javax.xml.transform.URIResolver)


Occurences of setURL

setURL occurences:
java.net.URLStreamHandler.setURL(java.net.URL, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String)
java.net.URLStreamHandler.setURL(java.net.URL, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
java.sql.CallableStatement.setURL(java.lang.String, java.net.URL)
java.sql.PreparedStatement.setURL(int, java.net.URL)
javax.sql.RowSet.setURL(int, java.net.URL)
javax.sql.rowset.BaseRowSet.setURL(int, java.net.URL)
javax.xml.bind.helpers.ValidationEventLocatorImpl.setURL(java.net.URL)


Occurences of setUrl

setUrl occurences:
javax.sql.RowSet.setUrl(java.lang.String)
javax.sql.rowset.BaseRowSet.setUrl(java.lang.String)


Occurences of setUseClientMode

setUseClientMode occurences:
javax.net.ssl.SSLEngine.setUseClientMode(boolean)
javax.net.ssl.SSLServerSocket.setUseClientMode(boolean)
javax.net.ssl.SSLSocket.setUseClientMode(boolean)


Occurences of setUserData

setUserData occurences:
javax.imageio.metadata.IIOMetadataNode.setUserData(java.lang.String, java.lang.Object, org.w3c.dom.UserDataHandler)
javax.management.Notification.setUserData(java.lang.Object)
org.w3c.dom.Node.setUserData(java.lang.String, java.lang.Object, org.w3c.dom.UserDataHandler)


Occurences of setUsername

setUsername occurences:
javax.sql.RowSet.setUsername(java.lang.String)
javax.sql.rowset.BaseRowSet.setUsername(java.lang.String)


Occurences of setUserObject

setUserObject occurences:
javax.imageio.metadata.IIOMetadataNode.setUserObject(java.lang.Object)
javax.swing.tree.DefaultMutableTreeNode.setUserObject(java.lang.Object)
javax.swing.tree.MutableTreeNode.setUserObject(java.lang.Object)


Occurences of setValidating

setValidating occurences:
javax.xml.bind.helpers.AbstractUnmarshallerImpl.setValidating(boolean)
javax.xml.bind.Unmarshaller.setValidating(boolean)
javax.xml.parsers.DocumentBuilderFactory.setValidating(boolean)
javax.xml.parsers.SAXParserFactory.setValidating(boolean)


Occurences of setValue

setValue occurences:
com.sun.jdi.ArrayReference.setValue(int, com.sun.jdi.Value)
com.sun.jdi.ClassType.setValue(com.sun.jdi.Field, com.sun.jdi.Value)
com.sun.jdi.connect.Connector.Argument.setValue(java.lang.String)
com.sun.jdi.connect.Connector.BooleanArgument.setValue(boolean)
com.sun.jdi.connect.Connector.IntegerArgument.setValue(int)
com.sun.jdi.ObjectReference.setValue(com.sun.jdi.Field, com.sun.jdi.Value)
com.sun.jdi.StackFrame.setValue(com.sun.jdi.LocalVariable, com.sun.jdi.Value)
java.awt.Adjustable.setValue(int)
java.awt.Scrollbar.setValue(int)
java.awt.ScrollPaneAdjustable.setValue(int)
java.beans.Expression.setValue(java.lang.Object)
java.beans.FeatureDescriptor.setValue(java.lang.String, java.lang.Object)
java.beans.PropertyEditor.setValue(java.lang.Object)
java.beans.PropertyEditorSupport.setValue(java.lang.Object)
java.net.HttpCookie.setValue(java.lang.String)
java.util.AbstractMap.SimpleEntry.setValue(java.lang.Object)
java.util.AbstractMap.SimpleEntry.setValue(V)
java.util.AbstractMap.SimpleImmutableEntry.setValue(java.lang.Object)
java.util.AbstractMap.SimpleImmutableEntry.setValue(V)
java.util.Map.Entry.setValue(java.lang.Object)
java.util.Map.Entry.setValue(V)
javax.sound.sampled.BooleanControl.setValue(boolean)
javax.sound.sampled.EnumControl.setValue(java.lang.Object)
javax.sound.sampled.FloatControl.setValue(float)
javax.swing.BoundedRangeModel.setValue(int)
javax.swing.DefaultBoundedRangeModel.setValue(int)
javax.swing.DefaultCellEditor.EditorDelegate.setValue(java.lang.Object)
javax.swing.JFormattedTextField.setValue(java.lang.Object)
javax.swing.JOptionPane.setValue(java.lang.Object)
javax.swing.JProgressBar.setValue(int)
javax.swing.JScrollBar.setValue(int)
javax.swing.JSlider.setValue(int)
javax.swing.JSpinner.setValue(java.lang.Object)
javax.swing.Renderer.setValue(java.lang.Object, boolean)
javax.swing.SpinnerDateModel.setValue(java.lang.Object)
javax.swing.SpinnerListModel.setValue(java.lang.Object)
javax.swing.SpinnerModel.setValue(java.lang.Object)
javax.swing.SpinnerNumberModel.setValue(java.lang.Object)
javax.swing.Spring.setValue(int)
javax.swing.table.DefaultTableCellRenderer.setValue(java.lang.Object)
javax.xml.bind.JAXBElement.setValue(java.lang.Object)
javax.xml.bind.JAXBElement.setValue(T)
javax.xml.soap.Node.setValue(java.lang.String)
org.w3c.dom.Attr.setValue(java.lang.String)
org.xml.sax.helpers.AttributesImpl.setValue(int, java.lang.String)


Occurences of setValueAt

setValueAt occurences:
javax.swing.JTable.setValueAt(java.lang.Object, int, int)
javax.swing.table.AbstractTableModel.setValueAt(java.lang.Object, int, int)
javax.swing.table.DefaultTableModel.setValueAt(java.lang.Object, int, int)
javax.swing.table.TableModel.setValueAt(java.lang.Object, int, int)


Occurences of setValueIsAdjusting

setValueIsAdjusting occurences:
java.awt.Scrollbar.setValueIsAdjusting(boolean)
java.awt.ScrollPaneAdjustable.setValueIsAdjusting(boolean)
javax.swing.BoundedRangeModel.setValueIsAdjusting(boolean)
javax.swing.DefaultBoundedRangeModel.setValueIsAdjusting(boolean)
javax.swing.DefaultListSelectionModel.setValueIsAdjusting(boolean)
javax.swing.JList.setValueIsAdjusting(boolean)
javax.swing.JScrollBar.setValueIsAdjusting(boolean)
javax.swing.JSlider.setValueIsAdjusting(boolean)
javax.swing.ListSelectionModel.setValueIsAdjusting(boolean)


Occurences of setValues

setValues occurences:
com.sun.jdi.ArrayReference.setValues(int, java.util.List, int, int)
com.sun.jdi.ArrayReference.setValues(java.util.List)
java.awt.Scrollbar.setValues(int, int, int, int)
javax.swing.JScrollBar.setValues(int, int, int, int)


Occurences of setVerbose

setVerbose occurences:
java.lang.management.ClassLoadingMXBean.setVerbose(boolean)
java.lang.management.MemoryMXBean.setVerbose(boolean)


Occurences of setVerticalAlignment

setVerticalAlignment occurences:
javax.swing.AbstractButton.setVerticalAlignment(int)
javax.swing.JLabel.setVerticalAlignment(int)


Occurences of setVerticalScrollBarPolicy

setVerticalScrollBarPolicy occurences:
javax.swing.JScrollPane.setVerticalScrollBarPolicy(int)
javax.swing.ScrollPaneLayout.setVerticalScrollBarPolicy(int)


Occurences of setVerticalTextPosition

setVerticalTextPosition occurences:
javax.swing.AbstractButton.setVerticalTextPosition(int)
javax.swing.JLabel.setVerticalTextPosition(int)


Occurences of setVgap

setVgap occurences:
java.awt.BorderLayout.setVgap(int)
java.awt.CardLayout.setVgap(int)
java.awt.FlowLayout.setVgap(int)
java.awt.GridLayout.setVgap(int)


Occurences of setView

setView occurences:
javax.swing.JViewport.setView(java.awt.Component)
javax.swing.plaf.basic.BasicTextUI.setView(javax.swing.text.View)


Occurences of setVisible

setVisible occurences:
java.awt.Component.setVisible(boolean)
java.awt.Component.AccessibleAWTComponent.setVisible(boolean)
java.awt.Dialog.setVisible(boolean)
java.awt.List.AccessibleAWTList.AccessibleAWTListChild.setVisible(boolean)
java.awt.MenuComponent.AccessibleAWTMenuComponent.setVisible(boolean)
java.awt.Window.setVisible(boolean)
javax.accessibility.AccessibleComponent.setVisible(boolean)
javax.swing.JComponent.setVisible(boolean)
javax.swing.JList.AccessibleJList.AccessibleJListChild.setVisible(boolean)
javax.swing.JPopupMenu.setVisible(boolean)
javax.swing.JTable.AccessibleJTable.AccessibleJTableCell.setVisible(boolean)
javax.swing.JTree.AccessibleJTree.AccessibleJTreeNode.setVisible(boolean)
javax.swing.table.JTableHeader.AccessibleJTableHeader.AccessibleJTableHeaderEntry.setVisible(boolean)
javax.swing.text.Caret.setVisible(boolean)
javax.swing.text.DefaultCaret.setVisible(boolean)


Occurences of setVisibleAmount

setVisibleAmount occurences:
java.awt.Adjustable.setVisibleAmount(int)
java.awt.Scrollbar.setVisibleAmount(int)
java.awt.ScrollPaneAdjustable.setVisibleAmount(int)
javax.swing.JScrollBar.setVisibleAmount(int)


Occurences of setVisibleRowCount

setVisibleRowCount occurences:
javax.swing.JList.setVisibleRowCount(int)
javax.swing.JTree.setVisibleRowCount(int)


Occurences of setWantClientAuth

setWantClientAuth occurences:
javax.net.ssl.SSLEngine.setWantClientAuth(boolean)
javax.net.ssl.SSLParameters.setWantClientAuth(boolean)
javax.net.ssl.SSLServerSocket.setWantClientAuth(boolean)
javax.net.ssl.SSLSocket.setWantClientAuth(boolean)


Occurences of setWheelScrollingEnabled

setWheelScrollingEnabled occurences:
java.awt.ScrollPane.setWheelScrollingEnabled(boolean)
javax.swing.JScrollPane.setWheelScrollingEnabled(boolean)


Occurences of setWidth

setWidth occurences:
javax.swing.SpringLayout.Constraints.setWidth(javax.swing.Spring)
javax.swing.table.TableColumn.setWidth(int)


Occurences of setWritable

setWritable occurences:
java.io.File.setWritable(boolean)
java.io.File.setWritable(boolean, boolean)


Occurences of setWriter

setWriter occurences:
javax.script.ScriptContext.setWriter(java.io.Writer)
javax.script.SimpleScriptContext.setWriter(java.io.Writer)
javax.xml.transform.stream.StreamResult.setWriter(java.io.Writer)


Occurences of setXIncludeAware

setXIncludeAware occurences:
javax.xml.parsers.DocumentBuilderFactory.setXIncludeAware(boolean)
javax.xml.parsers.SAXParserFactory.setXIncludeAware(boolean)


Occurences of setXORMode

setXORMode occurences:
java.awt.Graphics.setXORMode(java.awt.Color)
javax.swing.DebugGraphics.setXORMode(java.awt.Color)


Occurences of setXPathFunctionResolver

setXPathFunctionResolver occurences:
javax.xml.xpath.XPath.setXPathFunctionResolver(javax.xml.xpath.XPathFunctionResolver)
javax.xml.xpath.XPathFactory.setXPathFunctionResolver(javax.xml.xpath.XPathFunctionResolver)


Occurences of setXPathVariableResolver

setXPathVariableResolver occurences:
javax.xml.xpath.XPath.setXPathVariableResolver(javax.xml.xpath.XPathVariableResolver)
javax.xml.xpath.XPathFactory.setXPathVariableResolver(javax.xml.xpath.XPathVariableResolver)


Occurences of setYear

setYear occurences:
java.sql.Time.setYear(int)
java.util.Date.setYear(int)
javax.xml.datatype.XMLGregorianCalendar.setYear(int)
javax.xml.datatype.XMLGregorianCalendar.setYear(java.math.BigInteger)


Occurences of set_as_default

set_as_default occurences:
org.omg.CORBA.DynUnion.set_as_default()
org.omg.CORBA.DynUnion.set_as_default(boolean)


Occurences of set_as_string

set_as_string occurences:
org.omg.DynamicAny.DynEnumOperations.set_as_string(java.lang.String)
org.omg.DynamicAny._DynEnumStub.set_as_string(java.lang.String)


Occurences of set_as_ulong

set_as_ulong occurences:
org.omg.DynamicAny.DynEnumOperations.set_as_ulong(int)
org.omg.DynamicAny._DynEnumStub.set_as_ulong(int)


Occurences of set_discriminator

set_discriminator occurences:
org.omg.DynamicAny.DynUnionOperations.set_discriminator(org.omg.DynamicAny.DynAny)
org.omg.DynamicAny._DynUnionStub.set_discriminator(org.omg.DynamicAny.DynAny)


Occurences of set_elements

set_elements occurences:
org.omg.CORBA.DynArray.set_elements(org.omg.CORBA.Any[])
org.omg.CORBA.DynSequence.set_elements(org.omg.CORBA.Any[])
org.omg.DynamicAny.DynArrayOperations.set_elements(org.omg.CORBA.Any[])
org.omg.DynamicAny.DynSequenceOperations.set_elements(org.omg.CORBA.Any[])
org.omg.DynamicAny._DynArrayStub.set_elements(org.omg.CORBA.Any[])
org.omg.DynamicAny._DynSequenceStub.set_elements(org.omg.CORBA.Any[])


Occurences of set_elements_as_dyn_any

set_elements_as_dyn_any occurences:
org.omg.DynamicAny.DynArrayOperations.set_elements_as_dyn_any(org.omg.DynamicAny.DynAny[])
org.omg.DynamicAny.DynSequenceOperations.set_elements_as_dyn_any(org.omg.DynamicAny.DynAny[])
org.omg.DynamicAny._DynArrayStub.set_elements_as_dyn_any(org.omg.DynamicAny.DynAny[])
org.omg.DynamicAny._DynSequenceStub.set_elements_as_dyn_any(org.omg.DynamicAny.DynAny[])


Occurences of set_length

set_length occurences:
org.omg.DynamicAny.DynSequenceOperations.set_length(int)
org.omg.DynamicAny._DynSequenceStub.set_length(int)


Occurences of set_members

set_members occurences:
org.omg.CORBA.DynStruct.set_members(org.omg.CORBA.NameValuePair[])
org.omg.CORBA.DynValue.set_members(org.omg.CORBA.NameValuePair[])
org.omg.DynamicAny.DynStructOperations.set_members(org.omg.DynamicAny.NameValuePair[])
org.omg.DynamicAny.DynValueOperations.set_members(org.omg.DynamicAny.NameValuePair[])
org.omg.DynamicAny._DynStructStub.set_members(org.omg.DynamicAny.NameValuePair[])
org.omg.DynamicAny._DynValueStub.set_members(org.omg.DynamicAny.NameValuePair[])


Occurences of set_members_as_dyn_any

set_members_as_dyn_any occurences:
org.omg.DynamicAny.DynStructOperations.set_members_as_dyn_any(org.omg.DynamicAny.NameDynAnyPair[])
org.omg.DynamicAny.DynValueOperations.set_members_as_dyn_any(org.omg.DynamicAny.NameDynAnyPair[])
org.omg.DynamicAny._DynStructStub.set_members_as_dyn_any(org.omg.DynamicAny.NameDynAnyPair[])
org.omg.DynamicAny._DynValueStub.set_members_as_dyn_any(org.omg.DynamicAny.NameDynAnyPair[])


Occurences of set_parameters

set_parameters occurences:
org.omg.CORBA.ORB.set_parameters(java.applet.Applet, java.util.Properties)
org.omg.CORBA.ORB.set_parameters(java.lang.String[], java.util.Properties)


Occurences of set_slot

set_slot occurences:
org.omg.PortableInterceptor.CurrentOperations.set_slot(int, org.omg.CORBA.Any)
org.omg.PortableInterceptor.ServerRequestInfoOperations.set_slot(int, org.omg.CORBA.Any)


Occurences of set_to_default_member

set_to_default_member occurences:
org.omg.DynamicAny.DynUnionOperations.set_to_default_member()
org.omg.DynamicAny._DynUnionStub.set_to_default_member()


Occurences of set_to_no_active_member

set_to_no_active_member occurences:
org.omg.DynamicAny.DynUnionOperations.set_to_no_active_member()
org.omg.DynamicAny._DynUnionStub.set_to_no_active_member()


Occurences of set_to_null

set_to_null occurences:
org.omg.DynamicAny.DynValueCommonOperations.set_to_null()
org.omg.DynamicAny._DynValueStub.set_to_null()


Occurences of set_to_value

set_to_value occurences:
org.omg.DynamicAny.DynValueCommonOperations.set_to_value()
org.omg.DynamicAny._DynValueStub.set_to_value()


Occurences of set_value

set_value occurences:
org.omg.CORBA.DynFixed.set_value(byte[])
org.omg.DynamicAny.DynFixedOperations.set_value(java.lang.String)
org.omg.DynamicAny._DynFixedStub.set_value(java.lang.String)


Occurences of SE_RESIZE_CURSOR

SE_RESIZE_CURSOR occurences:
java.awt.SE_RESIZE_CURSOR
java.awt.SE_RESIZE_CURSOR


Occurences of SHA1

SHA1 occurences:
java.security.spec.SHA1
javax.xml.crypto.dsig.SHA1


Occurences of SHA256

SHA256 occurences:
java.security.spec.SHA256
javax.xml.crypto.dsig.SHA256


Occurences of SHA512

SHA512 occurences:
java.security.spec.SHA512
javax.xml.crypto.dsig.SHA512


Occurences of shadow

shadow occurences:
javax.swing.border.shadow
javax.swing.plaf.basic.shadow
javax.swing.plaf.basic.shadow
javax.swing.plaf.basic.shadow
javax.swing.plaf.basic.shadow
javax.swing.plaf.basic.shadow


Occurences of shape

shape occurences:
java.awt.font.NumericShaper.shape(char[], int, int)
java.awt.font.NumericShaper.shape(char[], int, int, int)


Occurences of sharedInstance

sharedInstance occurences:
javax.swing.JTree.EmptySelectionModel.sharedInstance()
javax.swing.sharedInstance
javax.swing.ToolTipManager.sharedInstance()


Occurences of shear

shear occurences:
java.awt.geom.AffineTransform.shear(double, double)
java.awt.Graphics2D.shear(double, double)


Occurences of SHIFT_MASK

SHIFT_MASK occurences:
java.awt.event.SHIFT_MASK
java.awt.event.SHIFT_MASK
java.awt.SHIFT_MASK


Occurences of SHORT

SHORT occurences:
com.sun.mirror.type.SHORT
java.text.SHORT
java.util.SHORT
java.util.SHORT
javax.lang.model.type.SHORT
javax.management.openmbean.SHORT


Occurences of Short (constructors)

Short (constructors) occurences:
java.lang.Short(java.lang.String)
java.lang.Short(short)


Occurences of ShortBufferException (constructors)

ShortBufferException (constructors) occurences:
javax.crypto.ShortBufferException()
javax.crypto.ShortBufferException(java.lang.String)


Occurences of ShortHolder (constructors)

ShortHolder (constructors) occurences:
org.omg.CORBA.ShortHolder()
org.omg.CORBA.ShortHolder(short)


Occurences of ShortLookupTable (constructors)

ShortLookupTable (constructors) occurences:
java.awt.image.ShortLookupTable(int, short[])
java.awt.image.ShortLookupTable(int, short[][])


Occurences of ShortMessage (constructors)

ShortMessage (constructors) occurences:
javax.sound.midi.ShortMessage()
javax.sound.midi.ShortMessage(byte[])


Occurences of ShortSeqHolder (constructors)

ShortSeqHolder (constructors) occurences:
org.omg.CORBA.ShortSeqHolder()
org.omg.CORBA.ShortSeqHolder(short[])


Occurences of shortValue

shortValue occurences:
com.sun.jdi.PrimitiveValue.shortValue()
java.lang.Byte.shortValue()
java.lang.Double.shortValue()
java.lang.Float.shortValue()
java.lang.Integer.shortValue()
java.lang.Long.shortValue()
java.lang.Number.shortValue()
java.lang.Short.shortValue()


Occurences of shouldPadTabRun

shouldPadTabRun occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.shouldPadTabRun(int, int)
javax.swing.plaf.metal.MetalTabbedPaneUI.shouldPadTabRun(int, int)


Occurences of shouldRotateTabRuns

shouldRotateTabRuns occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.shouldRotateTabRuns(int)
javax.swing.plaf.metal.MetalTabbedPaneUI.shouldRotateTabRuns(int, int)


Occurences of shouldSelectCell

shouldSelectCell occurences:
javax.swing.AbstractCellEditor.shouldSelectCell(java.util.EventObject)
javax.swing.CellEditor.shouldSelectCell(java.util.EventObject)
javax.swing.DefaultCellEditor.shouldSelectCell(java.util.EventObject)
javax.swing.DefaultCellEditor.EditorDelegate.shouldSelectCell(java.util.EventObject)
javax.swing.tree.DefaultTreeCellEditor.shouldSelectCell(java.util.EventObject)


Occurences of show

show occurences:
java.awt.CardLayout.show(java.awt.Container, java.lang.String)
java.awt.Component.show()
java.awt.Component.show(boolean)
java.awt.Component.BltBufferStrategy.show()
java.awt.Component.FlipBufferStrategy.show()
java.awt.Dialog.show()
java.awt.image.BufferStrategy.show()
java.awt.PopupMenu.show(java.awt.Component, int, int)
java.awt.Window.show()
javax.swing.JInternalFrame.show()
javax.swing.JPopupMenu.show(java.awt.Component, int, int)
javax.swing.plaf.basic.BasicComboPopup.show()
javax.swing.plaf.basic.ComboPopup.show()
javax.swing.Popup.show()


Occurences of showConfirmDialog

showConfirmDialog occurences:
javax.swing.JOptionPane.showConfirmDialog(java.awt.Component, java.lang.Object)
javax.swing.JOptionPane.showConfirmDialog(java.awt.Component, java.lang.Object, java.lang.String, int)
javax.swing.JOptionPane.showConfirmDialog(java.awt.Component, java.lang.Object, java.lang.String, int, int)
javax.swing.JOptionPane.showConfirmDialog(java.awt.Component, java.lang.Object, java.lang.String, int, int, javax.swing.Icon)


Occurences of showDialog

showDialog occurences:
javax.swing.JColorChooser.showDialog(java.awt.Component, java.lang.String, java.awt.Color)
javax.swing.JFileChooser.showDialog(java.awt.Component, java.lang.String)


Occurences of showDocument

showDocument occurences:
java.applet.AppletContext.showDocument(java.net.URL)
java.applet.AppletContext.showDocument(java.net.URL, java.lang.String)


Occurences of showInputDialog

showInputDialog occurences:
javax.swing.JOptionPane.showInputDialog(java.awt.Component, java.lang.Object)
javax.swing.JOptionPane.showInputDialog(java.awt.Component, java.lang.Object, java.lang.Object)
javax.swing.JOptionPane.showInputDialog(java.awt.Component, java.lang.Object, java.lang.String, int)
javax.swing.JOptionPane.showInputDialog(java.awt.Component, java.lang.Object, java.lang.String, int, javax.swing.Icon, java.lang.Object[], java.lang.Object)
javax.swing.JOptionPane.showInputDialog(java.lang.Object)
javax.swing.JOptionPane.showInputDialog(java.lang.Object, java.lang.Object)


Occurences of showInternalConfirmDialog

showInternalConfirmDialog occurences:
javax.swing.JOptionPane.showInternalConfirmDialog(java.awt.Component, java.lang.Object)
javax.swing.JOptionPane.showInternalConfirmDialog(java.awt.Component, java.lang.Object, java.lang.String, int)
javax.swing.JOptionPane.showInternalConfirmDialog(java.awt.Component, java.lang.Object, java.lang.String, int, int)
javax.swing.JOptionPane.showInternalConfirmDialog(java.awt.Component, java.lang.Object, java.lang.String, int, int, javax.swing.Icon)


Occurences of showInternalInputDialog

showInternalInputDialog occurences:
javax.swing.JOptionPane.showInternalInputDialog(java.awt.Component, java.lang.Object)
javax.swing.JOptionPane.showInternalInputDialog(java.awt.Component, java.lang.Object, java.lang.String, int)
javax.swing.JOptionPane.showInternalInputDialog(java.awt.Component, java.lang.Object, java.lang.String, int, javax.swing.Icon, java.lang.Object[], java.lang.Object)


Occurences of showInternalMessageDialog

showInternalMessageDialog occurences:
javax.swing.JOptionPane.showInternalMessageDialog(java.awt.Component, java.lang.Object)
javax.swing.JOptionPane.showInternalMessageDialog(java.awt.Component, java.lang.Object, java.lang.String, int)
javax.swing.JOptionPane.showInternalMessageDialog(java.awt.Component, java.lang.Object, java.lang.String, int, javax.swing.Icon)


Occurences of showMessageDialog

showMessageDialog occurences:
javax.swing.JOptionPane.showMessageDialog(java.awt.Component, java.lang.Object)
javax.swing.JOptionPane.showMessageDialog(java.awt.Component, java.lang.Object, java.lang.String, int)
javax.swing.JOptionPane.showMessageDialog(java.awt.Component, java.lang.Object, java.lang.String, int, javax.swing.Icon)


Occurences of showStatus

showStatus occurences:
java.applet.Applet.showStatus(java.lang.String)
java.applet.AppletContext.showStatus(java.lang.String)


Occurences of showSystemMenu

showSystemMenu occurences:
javax.swing.plaf.basic.BasicInternalFrameTitlePane.showSystemMenu()
javax.swing.plaf.metal.MetalInternalFrameTitlePane.showSystemMenu()


Occurences of shuffle

shuffle occurences:
java.util.Collections.shuffle(java.util.List)
java.util.Collections.shuffle(java.util.List, java.util.Random)


Occurences of shutdown

shutdown occurences:
java.rmi.activation.ActivationSystem.shutdown()
java.util.concurrent.ExecutorService.shutdown()
java.util.concurrent.ScheduledThreadPoolExecutor.shutdown()
java.util.concurrent.ThreadPoolExecutor.shutdown()
org.omg.CORBA.ORB.shutdown(boolean)


Occurences of shutdownInput

shutdownInput occurences:
java.net.Socket.shutdownInput()
java.net.SocketImpl.shutdownInput()


Occurences of shutdownNow

shutdownNow occurences:
java.util.concurrent.ExecutorService.shutdownNow()
java.util.concurrent.ScheduledThreadPoolExecutor.shutdownNow()
java.util.concurrent.ThreadPoolExecutor.shutdownNow()


Occurences of shutdownOutput

shutdownOutput occurences:
java.net.Socket.shutdownOutput()
java.net.SocketImpl.shutdownOutput()


Occurences of SIGN

SIGN occurences:
java.security.SIGN
java.text.SIGN
javax.xml.crypto.SIGN


Occurences of sign

sign occurences:
java.security.Signature.sign()
java.security.Signature.sign(byte[], int, int)
javax.xml.crypto.dsig.XMLSignature.sign(javax.xml.crypto.dsig.XMLSignContext)


Occurences of signal

signal occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.signal()
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.signal()
java.util.concurrent.locks.Condition.signal()


Occurences of signalAll

signalAll occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject.signalAll()
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.signalAll()
java.util.concurrent.locks.Condition.signalAll()


Occurences of signature

signature occurences:
com.sun.javadoc.ExecutableMemberDoc.signature()
com.sun.jdi.LocalVariable.signature()
com.sun.jdi.Type.signature()
com.sun.jdi.TypeComponent.signature()


Occurences of SignatureException (constructors)

SignatureException (constructors) occurences:
java.security.SignatureException()
java.security.SignatureException(java.lang.String)
java.security.SignatureException(java.lang.String, java.lang.Throwable)
java.security.SignatureException(java.lang.Throwable)


Occurences of Signer (constructors)

Signer (constructors) occurences:
java.security.Signer()
java.security.Signer(java.lang.String)
java.security.Signer(java.lang.String, java.security.IdentityScope)


Occurences of signum

signum occurences:
java.lang.Integer.signum(int)
java.lang.Long.signum(long)
java.lang.Math.signum(double)
java.lang.Math.signum(float)
java.lang.StrictMath.signum(double)
java.lang.StrictMath.signum(float)
java.math.BigDecimal.signum()
java.math.BigInteger.signum()


Occurences of Silent Installation

Silent Installation occurences:
Silent Installation
Silent Installation


Occurences of SimpleAnnotationValueVisitor6 (constructors)

SimpleAnnotationValueVisitor6 (constructors) occurences:
javax.lang.model.util.SimpleAnnotationValueVisitor6()
javax.lang.model.util.SimpleAnnotationValueVisitor6(java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6(R)


Occurences of SimpleAttributeSet (constructors)

SimpleAttributeSet (constructors) occurences:
javax.swing.text.SimpleAttributeSet()
javax.swing.text.SimpleAttributeSet(javax.swing.text.AttributeSet)


Occurences of SimpleBindings (constructors)

SimpleBindings (constructors) occurences:
javax.script.SimpleBindings()
javax.script.SimpleBindings(java.util.Map)


Occurences of SimpleDateFormat (constructors)

SimpleDateFormat (constructors) occurences:
java.text.SimpleDateFormat()
java.text.SimpleDateFormat(java.lang.String)
java.text.SimpleDateFormat(java.lang.String, java.text.DateFormatSymbols)
java.text.SimpleDateFormat(java.lang.String, java.util.Locale)


Occurences of SimpleElementVisitor6 (constructors)

SimpleElementVisitor6 (constructors) occurences:
javax.lang.model.util.SimpleElementVisitor6()
javax.lang.model.util.SimpleElementVisitor6(java.lang.Object)
javax.lang.model.util.SimpleElementVisitor6(R)


Occurences of SimpleTimeZone (constructors)

SimpleTimeZone (constructors) occurences:
java.util.SimpleTimeZone(int, java.lang.String)
java.util.SimpleTimeZone(int, java.lang.String, int, int, int, int, int, int, int, int)
java.util.SimpleTimeZone(int, java.lang.String, int, int, int, int, int, int, int, int, int)
java.util.SimpleTimeZone(int, java.lang.String, int, int, int, int, int, int, int, int, int, int, int)


Occurences of SimpleTreeVisitor (constructors)

SimpleTreeVisitor (constructors) occurences:
com.sun.source.util.SimpleTreeVisitor()
com.sun.source.util.SimpleTreeVisitor(java.lang.Object)
com.sun.source.util.SimpleTreeVisitor(R)


Occurences of SimpleTypeVisitor6 (constructors)

SimpleTypeVisitor6 (constructors) occurences:
javax.lang.model.util.SimpleTypeVisitor6()
javax.lang.model.util.SimpleTypeVisitor6(java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6(R)


Occurences of sin

sin occurences:
java.lang.Math.sin(double)
java.lang.StrictMath.sin(double)


Occurences of SinglePixelPackedSampleModel (constructors)

SinglePixelPackedSampleModel (constructors) occurences:
java.awt.image.SinglePixelPackedSampleModel(int, int, int, int, int[])
java.awt.image.SinglePixelPackedSampleModel(int, int, int, int[])


Occurences of singleton

singleton occurences:
java.util.Collections.singleton(java.lang.Object)
java.util.Collections.singleton(T)


Occurences of singletonList

singletonList occurences:
java.util.Collections.singletonList(java.lang.Object)
java.util.Collections.singletonList(T)


Occurences of singletonMap

singletonMap occurences:
java.util.Collections.singletonMap(java.lang.Object,java.lang.Object)
java.util.Collections.singletonMap(K, V)


Occurences of sinh

sinh occurences:
java.lang.Math.sinh(double)
java.lang.StrictMath.sinh(double)


Occurences of SIZE

SIZE occurences:
java.awt.font.SIZE
java.lang.SIZE
java.lang.SIZE
java.lang.SIZE
java.lang.SIZE
java.lang.SIZE
java.lang.SIZE
java.lang.SIZE
javax.swing.text.html.SIZE


Occurences of size

size occurences:
com.sun.jdi.request.StepRequest.size()
java.awt.Component.size()
java.awt.image.size
java.awt.RenderingHints.size()
java.awt.size
java.beans.beancontext.BeanContextMembershipEvent.size()
java.beans.beancontext.BeanContextSupport.size()
java.io.ByteArrayOutputStream.size()
java.io.CharArrayWriter.size()
java.io.DataOutputStream.size()
java.nio.channels.FileChannel.size()
java.nio.channels.FileLock.size()
java.security.IdentityScope.size()
java.security.KeyStore.size()
java.util.AbstractCollection.size()
java.util.AbstractMap.size()
java.util.ArrayDeque.size()
java.util.ArrayList.size()
java.util.BitSet.size()
java.util.Collection.size()
java.util.concurrent.ArrayBlockingQueue.size()
java.util.concurrent.BlockingDeque.size()
java.util.concurrent.ConcurrentHashMap.size()
java.util.concurrent.ConcurrentLinkedQueue.size()
java.util.concurrent.ConcurrentSkipListMap.size()
java.util.concurrent.ConcurrentSkipListSet.size()
java.util.concurrent.CopyOnWriteArrayList.size()
java.util.concurrent.CopyOnWriteArraySet.size()
java.util.concurrent.DelayQueue.size()
java.util.concurrent.LinkedBlockingDeque.size()
java.util.concurrent.LinkedBlockingQueue.size()
java.util.concurrent.PriorityBlockingQueue.size()
java.util.concurrent.SynchronousQueue.size()
java.util.Deque.size()
java.util.Dictionary.size()
java.util.EnumMap.size()
java.util.HashMap.size()
java.util.HashSet.size()
java.util.Hashtable.size()
java.util.IdentityHashMap.size()
java.util.jar.Attributes.size()
java.util.LinkedList.size()
java.util.List.size()
java.util.Map.size()
java.util.PriorityQueue.size()
java.util.Set.size()
java.util.TreeMap.size()
java.util.TreeSet.size()
java.util.Vector.size()
java.util.WeakHashMap.size()
java.util.zip.ZipFile.size()
javax.accessibility.AccessibleRelationSet.size()
javax.activation.MimeTypeParameterList.size()
javax.management.openmbean.TabularData.size()
javax.management.openmbean.TabularDataSupport.size()
javax.naming.CompositeName.size()
javax.naming.CompoundName.size()
javax.naming.directory.Attribute.size()
javax.naming.directory.Attributes.size()
javax.naming.directory.BasicAttribute.size()
javax.naming.directory.BasicAttributes.size()
javax.naming.ldap.LdapName.size()
javax.naming.ldap.Rdn.size()
javax.naming.Name.size()
javax.naming.Reference.size()
javax.print.attribute.AttributeSet.size()
javax.print.attribute.HashAttributeSet.size()
javax.script.SimpleBindings.size()
javax.sound.midi.Track.size()
javax.sql.rowset.CachedRowSet.size()
javax.swing.ActionMap.size()
javax.swing.DefaultListModel.size()
javax.swing.InputMap.size()


Occurences of Size2DSyntax (constructors)

Size2DSyntax (constructors) occurences:
javax.print.attribute.Size2DSyntax(float, float, int)
javax.print.attribute.Size2DSyntax(int, int, int)


Occurences of sizeColumnsToFit

sizeColumnsToFit occurences:
javax.swing.JTable.sizeColumnsToFit(boolean)
javax.swing.JTable.sizeColumnsToFit(int)


Occurences of SizeLimitExceededException (constructors)

SizeLimitExceededException (constructors) occurences:
javax.naming.SizeLimitExceededException()
javax.naming.SizeLimitExceededException(java.lang.String)


Occurences of SizeRequirements (constructors)

SizeRequirements (constructors) occurences:
javax.swing.SizeRequirements()
javax.swing.SizeRequirements(int, int, int, float)


Occurences of SizeSequence (constructors)

SizeSequence (constructors) occurences:
javax.swing.SizeSequence()
javax.swing.SizeSequence(int)
javax.swing.SizeSequence(int, int)
javax.swing.SizeSequence(int[])


Occurences of SkeletonNotFoundException (constructors)

SkeletonNotFoundException (constructors) occurences:
java.rmi.server.SkeletonNotFoundException(java.lang.String)
java.rmi.server.SkeletonNotFoundException(java.lang.String, java.lang.Exception)


Occurences of skip

skip occurences:
java.io.BufferedInputStream.skip(long)
java.io.BufferedReader.skip(long)
java.io.ByteArrayInputStream.skip(long)
java.io.CharArrayReader.skip(long)
java.io.FileInputStream.skip(long)
java.io.FilterInputStream.skip(long)
java.io.FilterReader.skip(long)
java.io.InputStream.skip(long)
java.io.LineNumberInputStream.skip(long)
java.io.LineNumberReader.skip(long)
java.io.ObjectInput.skip(long)
java.io.PushbackInputStream.skip(long)
java.io.PushbackReader.skip(long)
java.io.Reader.skip(long)
java.io.StringBufferInputStream.skip(long)
java.io.StringReader.skip(long)
java.util.Scanner.skip(java.lang.String)
java.util.Scanner.skip(java.util.regex.Pattern)
java.util.zip.CheckedInputStream.skip(long)
java.util.zip.DeflaterInputStream.skip(long)
java.util.zip.InflaterInputStream.skip(long)
java.util.zip.ZipInputStream.skip(long)
javax.crypto.CipherInputStream.skip(long)
javax.sound.sampled.AudioInputStream.skip(long)
javax.swing.ProgressMonitorInputStream.skip(long)


Occurences of skipBytes

skipBytes occurences:
java.io.DataInput.skipBytes(int)
java.io.DataInputStream.skipBytes(int)
java.io.ObjectInputStream.skipBytes(int)
java.io.RandomAccessFile.skipBytes(int)
javax.imageio.stream.ImageInputStream.skipBytes(int)
javax.imageio.stream.ImageInputStream.skipBytes(long)
javax.imageio.stream.ImageInputStreamImpl.skipBytes(int)
javax.imageio.stream.ImageInputStreamImpl.skipBytes(long)


Occurences of skippedEntity

skippedEntity occurences:
org.xml.sax.ContentHandler.skippedEntity(java.lang.String)
org.xml.sax.helpers.DefaultHandler.skippedEntity(java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.skippedEntity(java.lang.String)
org.xml.sax.helpers.XMLReaderAdapter.skippedEntity(java.lang.String)


Occurences of sleep

sleep occurences:
java.lang.Thread.sleep(long)
java.lang.Thread.sleep(long, int)
java.util.concurrent.TimeUnit.sleep(long)


Occurences of slice

slice occurences:
java.nio.ByteBuffer.slice()
java.nio.CharBuffer.slice()
java.nio.DoubleBuffer.slice()
java.nio.FloatBuffer.slice()
java.nio.IntBuffer.slice()
java.nio.LongBuffer.slice()
java.nio.ShortBuffer.slice()


Occurences of SLIDER

SLIDER occurences:
javax.accessibility.SLIDER
javax.swing.plaf.synth.SLIDER


Occurences of soap

soap occurences:
javax.jws.soap
javax.xml.soap
javax.xml.ws.handler.soap
javax.xml.ws.soap


Occurences of SOAPBinding

SOAPBinding occurences:
javax.jws.soap.SOAPBinding
javax.xml.ws.soap.SOAPBinding


Occurences of SOAPException (constructors)

SOAPException (constructors) occurences:
javax.xml.soap.SOAPException()
javax.xml.soap.SOAPException(java.lang.String)
javax.xml.soap.SOAPException(java.lang.String, java.lang.Throwable)
javax.xml.soap.SOAPException(java.lang.Throwable)


Occurences of socket

socket occurences:
java.nio.channels.DatagramChannel.socket()
java.nio.channels.ServerSocketChannel.socket()
java.nio.channels.SocketChannel.socket()


Occurences of Socket (constructors)

Socket (constructors) occurences:
java.net.Socket()
java.net.Socket(java.lang.String, int)
java.net.Socket(java.lang.String, int, boolean)
java.net.Socket(java.lang.String, int, java.net.InetAddress, int)
java.net.Socket(java.net.InetAddress, int)
java.net.Socket(java.net.InetAddress, int, boolean)
java.net.Socket(java.net.InetAddress, int, java.net.InetAddress, int)
java.net.Socket(java.net.Proxy)
java.net.Socket(java.net.SocketImpl)


Occurences of SocketException (constructors)

SocketException (constructors) occurences:
java.net.SocketException()
java.net.SocketException(java.lang.String)


Occurences of SocketHandler (constructors)

SocketHandler (constructors) occurences:
java.util.logging.SocketHandler()
java.util.logging.SocketHandler(java.lang.String, int)


Occurences of SocketSecurityException (constructors)

SocketSecurityException (constructors) occurences:
java.rmi.server.SocketSecurityException(java.lang.String)
java.rmi.server.SocketSecurityException(java.lang.String, java.lang.Exception)


Occurences of SocketTimeoutException (constructors)

SocketTimeoutException (constructors) occurences:
java.net.SocketTimeoutException()
java.net.SocketTimeoutException(java.lang.String)


Occurences of SoftBevelBorder (constructors)

SoftBevelBorder (constructors) occurences:
javax.swing.border.SoftBevelBorder(int)
javax.swing.border.SoftBevelBorder(int, java.awt.Color, java.awt.Color)
javax.swing.border.SoftBevelBorder(int, java.awt.Color, java.awt.Color, java.awt.Color, java.awt.Color)


Occurences of SoftReference (constructors)

SoftReference (constructors) occurences:
java.lang.ref.SoftReference(java.lang.Object)
java.lang.ref.SoftReference(java.lang.Object,java.lang.ref.ReferenceQueue)
java.lang.ref.SoftReference(T)
java.lang.ref.SoftReference(T, java.lang.ref.ReferenceQueue)


Occurences of solveCubic

solveCubic occurences:
java.awt.geom.CubicCurve2D.solveCubic(double[])
java.awt.geom.CubicCurve2D.solveCubic(double[], double[])


Occurences of solveQuadratic

solveQuadratic occurences:
java.awt.geom.QuadCurve2D.solveQuadratic(double[])
java.awt.geom.QuadCurve2D.solveQuadratic(double[], double[])


Occurences of sort

sort occurences:
java.util.Arrays.sort(byte[])
java.util.Arrays.sort(byte[], int, int)
java.util.Arrays.sort(char[])
java.util.Arrays.sort(char[], int, int)
java.util.Arrays.sort(double[])
java.util.Arrays.sort(double[], int, int)
java.util.Arrays.sort(float[])
java.util.Arrays.sort(float[], int, int)
java.util.Arrays.sort(int[])
java.util.Arrays.sort(int[], int, int)
java.util.Arrays.sort(java.lang.Object[])
java.util.Arrays.sort(java.lang.Object[], int, int)
java.util.Arrays.sort(java.lang.Object[],int,int,java.util.Comparator)
java.util.Arrays.sort(java.lang.Object[],java.util.Comparator)
java.util.Arrays.sort(long[])
java.util.Arrays.sort(long[], int, int)
java.util.Arrays.sort(short[])
java.util.Arrays.sort(short[], int, int)
java.util.Arrays.sort(T[], int, int, java.util.Comparator)
java.util.Arrays.sort(T[], java.util.Comparator)
java.util.Collections.sort(java.util.List)
java.util.Collections.sort(java.util.List, java.util.Comparator)
javax.swing.DefaultRowSorter.sort()
javax.swing.plaf.basic.BasicDirectoryModel.sort(java.util.Vector)


Occurences of SortControl (constructors)

SortControl (constructors) occurences:
javax.naming.ldap.SortControl(java.lang.String, boolean)
javax.naming.ldap.SortControl(java.lang.String[], boolean)
javax.naming.ldap.SortControl(javax.naming.ldap.SortKey[], boolean)


Occurences of sorterChanged

sorterChanged occurences:
javax.swing.event.RowSorterListener.sorterChanged(javax.swing.event.RowSorterEvent)
javax.swing.JTable.sorterChanged(javax.swing.event.RowSorterEvent)


Occurences of SortingFocusTraversalPolicy (constructors)

SortingFocusTraversalPolicy (constructors) occurences:
javax.swing.SortingFocusTraversalPolicy()
javax.swing.SortingFocusTraversalPolicy(java.util.Comparator)


Occurences of SortKey (constructors)

SortKey (constructors) occurences:
javax.naming.ldap.SortKey(java.lang.String)
javax.naming.ldap.SortKey(java.lang.String, boolean, java.lang.String)


Occurences of source

source occurences:
java.nio.channels.Pipe.source()
java.util.source
javax.management.source
javax.swing.plaf.basic.source


Occurences of SOURCE

SOURCE occurences:
java.lang.annotation.SOURCE
javax.tools.SOURCE


Occurences of sourceName

sourceName occurences:
com.sun.jdi.Location.sourceName()
com.sun.jdi.Location.sourceName(java.lang.String)
com.sun.jdi.ReferenceType.sourceName()


Occurences of sourcePath

sourcePath occurences:
com.sun.jdi.Location.sourcePath()
com.sun.jdi.Location.sourcePath(java.lang.String)


Occurences of SourcePosition

SourcePosition occurences:
com.sun.javadoc.SourcePosition
com.sun.mirror.util.SourcePosition


Occurences of SOUTH

SOUTH occurences:
java.awt.SOUTH
java.awt.SOUTH
javax.swing.SOUTH
javax.swing.SOUTH


Occurences of spec

spec occurences:
java.security.spec
javax.crypto.spec
javax.xml.crypto.dsig.spec
Overview


Occurences of spi

spi occurences:
com.sun.jdi.connect.spi
com.sun.tools.attach.spi
java.awt.im.spi
java.nio.channels.spi
java.nio.charset.spi
java.text.spi
java.util.spi
javax.imageio.spi
javax.naming.spi
javax.security.auth.spi
javax.sound.midi.spi
javax.sound.sampled.spi
javax.sql.rowset.spi
javax.xml.ws.spi


Occurences of SpinnerDateModel (constructors)

SpinnerDateModel (constructors) occurences:
javax.swing.SpinnerDateModel()
javax.swing.SpinnerDateModel(java.util.Date, java.lang.Comparable, java.lang.Comparable, int)


Occurences of SpinnerListModel (constructors)

SpinnerListModel (constructors) occurences:
javax.swing.SpinnerListModel()
javax.swing.SpinnerListModel(java.lang.Object[])
javax.swing.SpinnerListModel(java.util.List)


Occurences of SpinnerNumberModel (constructors)

SpinnerNumberModel (constructors) occurences:
javax.swing.SpinnerNumberModel()
javax.swing.SpinnerNumberModel(double, double, double, double)
javax.swing.SpinnerNumberModel(int, int, int, int)
javax.swing.SpinnerNumberModel(java.lang.Number, java.lang.Comparable, java.lang.Comparable, java.lang.Number)


Occurences of split

split occurences:
java.lang.String.split(java.lang.String)
java.lang.String.split(java.lang.String, int)
java.util.regex.Pattern.split(java.lang.CharSequence)
java.util.regex.Pattern.split(java.lang.CharSequence, int)


Occurences of splitPane

splitPane occurences:
javax.swing.plaf.basic.splitPane
javax.swing.plaf.basic.splitPane


Occurences of SPLIT_PANE

SPLIT_PANE occurences:
javax.accessibility.SPLIT_PANE
javax.swing.plaf.synth.SPLIT_PANE


Occurences of SpringLayout.Constraints (constructors)

SpringLayout.Constraints (constructors) occurences:
javax.swing.SpringLayout.Constraints()
javax.swing.SpringLayout.Constraints(java.awt.Component)
javax.swing.SpringLayout.Constraints(javax.swing.Spring, javax.swing.Spring)
javax.swing.SpringLayout.Constraints(javax.swing.Spring, javax.swing.Spring, javax.swing.Spring, javax.swing.Spring)


Occurences of sql

sql occurences:
java.sql
javax.sql


Occurences of SQLClientInfoException (constructors)

SQLClientInfoException (constructors) occurences:
java.sql.SQLClientInfoException()
java.sql.SQLClientInfoException(java.lang.String, java.lang.String, int, java.util.Map)
java.sql.SQLClientInfoException(java.lang.String, java.lang.String, int, java.util.Map, java.lang.Throwable)
java.sql.SQLClientInfoException(java.lang.String, java.lang.String, java.util.Map)
java.sql.SQLClientInfoException(java.lang.String, java.lang.String, java.util.Map, java.lang.Throwable)
java.sql.SQLClientInfoException(java.lang.String, java.util.Map)
java.sql.SQLClientInfoException(java.lang.String, java.util.Map, java.lang.Throwable)
java.sql.SQLClientInfoException(java.util.Map)
java.sql.SQLClientInfoException(java.util.Map, java.lang.Throwable)


Occurences of SQLDataException (constructors)

SQLDataException (constructors) occurences:
java.sql.SQLDataException()
java.sql.SQLDataException(java.lang.String)
java.sql.SQLDataException(java.lang.String, java.lang.String)
java.sql.SQLDataException(java.lang.String, java.lang.String, int)
java.sql.SQLDataException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLDataException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLDataException(java.lang.String, java.lang.Throwable)
java.sql.SQLDataException(java.lang.Throwable)


Occurences of SQLException (constructors)

SQLException (constructors) occurences:
java.sql.SQLException()
java.sql.SQLException(java.lang.String)
java.sql.SQLException(java.lang.String, java.lang.String)
java.sql.SQLException(java.lang.String, java.lang.String, int)
java.sql.SQLException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLException(java.lang.String, java.lang.Throwable)
java.sql.SQLException(java.lang.Throwable)


Occurences of SQLFeatureNotSupportedException (constructors)

SQLFeatureNotSupportedException (constructors) occurences:
java.sql.SQLFeatureNotSupportedException()
java.sql.SQLFeatureNotSupportedException(java.lang.String)
java.sql.SQLFeatureNotSupportedException(java.lang.String, java.lang.String)
java.sql.SQLFeatureNotSupportedException(java.lang.String, java.lang.String, int)
java.sql.SQLFeatureNotSupportedException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLFeatureNotSupportedException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLFeatureNotSupportedException(java.lang.String, java.lang.Throwable)
java.sql.SQLFeatureNotSupportedException(java.lang.Throwable)


Occurences of SQLIntegrityConstraintViolationException (constructors)

SQLIntegrityConstraintViolationException (constructors) occurences:
java.sql.SQLIntegrityConstraintViolationException()
java.sql.SQLIntegrityConstraintViolationException(java.lang.String)
java.sql.SQLIntegrityConstraintViolationException(java.lang.String, java.lang.String)
java.sql.SQLIntegrityConstraintViolationException(java.lang.String, java.lang.String, int)
java.sql.SQLIntegrityConstraintViolationException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLIntegrityConstraintViolationException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLIntegrityConstraintViolationException(java.lang.String, java.lang.Throwable)
java.sql.SQLIntegrityConstraintViolationException(java.lang.Throwable)


Occurences of SQLInvalidAuthorizationSpecException (constructors)

SQLInvalidAuthorizationSpecException (constructors) occurences:
java.sql.SQLInvalidAuthorizationSpecException()
java.sql.SQLInvalidAuthorizationSpecException(java.lang.String)
java.sql.SQLInvalidAuthorizationSpecException(java.lang.String, java.lang.String)
java.sql.SQLInvalidAuthorizationSpecException(java.lang.String, java.lang.String, int)
java.sql.SQLInvalidAuthorizationSpecException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLInvalidAuthorizationSpecException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLInvalidAuthorizationSpecException(java.lang.String, java.lang.Throwable)
java.sql.SQLInvalidAuthorizationSpecException(java.lang.Throwable)


Occurences of SQLNonTransientConnectionException (constructors)

SQLNonTransientConnectionException (constructors) occurences:
java.sql.SQLNonTransientConnectionException()
java.sql.SQLNonTransientConnectionException(java.lang.String)
java.sql.SQLNonTransientConnectionException(java.lang.String, java.lang.String)
java.sql.SQLNonTransientConnectionException(java.lang.String, java.lang.String, int)
java.sql.SQLNonTransientConnectionException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLNonTransientConnectionException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLNonTransientConnectionException(java.lang.String, java.lang.Throwable)
java.sql.SQLNonTransientConnectionException(java.lang.Throwable)


Occurences of SQLNonTransientException (constructors)

SQLNonTransientException (constructors) occurences:
java.sql.SQLNonTransientException()
java.sql.SQLNonTransientException(java.lang.String)
java.sql.SQLNonTransientException(java.lang.String, java.lang.String)
java.sql.SQLNonTransientException(java.lang.String, java.lang.String, int)
java.sql.SQLNonTransientException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLNonTransientException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLNonTransientException(java.lang.String, java.lang.Throwable)
java.sql.SQLNonTransientException(java.lang.Throwable)


Occurences of SQLPermission (constructors)

SQLPermission (constructors) occurences:
java.sql.SQLPermission(java.lang.String)
java.sql.SQLPermission(java.lang.String, java.lang.String)


Occurences of SQLRecoverableException (constructors)

SQLRecoverableException (constructors) occurences:
java.sql.SQLRecoverableException()
java.sql.SQLRecoverableException(java.lang.String)
java.sql.SQLRecoverableException(java.lang.String, java.lang.String)
java.sql.SQLRecoverableException(java.lang.String, java.lang.String, int)
java.sql.SQLRecoverableException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLRecoverableException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLRecoverableException(java.lang.String, java.lang.Throwable)
java.sql.SQLRecoverableException(java.lang.Throwable)


Occurences of SQLSyntaxErrorException (constructors)

SQLSyntaxErrorException (constructors) occurences:
java.sql.SQLSyntaxErrorException()
java.sql.SQLSyntaxErrorException(java.lang.String)
java.sql.SQLSyntaxErrorException(java.lang.String, java.lang.String)
java.sql.SQLSyntaxErrorException(java.lang.String, java.lang.String, int)
java.sql.SQLSyntaxErrorException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLSyntaxErrorException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLSyntaxErrorException(java.lang.String, java.lang.Throwable)
java.sql.SQLSyntaxErrorException(java.lang.Throwable)


Occurences of SQLTimeoutException (constructors)

SQLTimeoutException (constructors) occurences:
java.sql.SQLTimeoutException()
java.sql.SQLTimeoutException(java.lang.String)
java.sql.SQLTimeoutException(java.lang.String, java.lang.String)
java.sql.SQLTimeoutException(java.lang.String, java.lang.String, int)
java.sql.SQLTimeoutException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLTimeoutException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLTimeoutException(java.lang.String, java.lang.Throwable)
java.sql.SQLTimeoutException(java.lang.Throwable)


Occurences of SQLTransactionRollbackException (constructors)

SQLTransactionRollbackException (constructors) occurences:
java.sql.SQLTransactionRollbackException()
java.sql.SQLTransactionRollbackException(java.lang.String)
java.sql.SQLTransactionRollbackException(java.lang.String, java.lang.String)
java.sql.SQLTransactionRollbackException(java.lang.String, java.lang.String, int)
java.sql.SQLTransactionRollbackException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLTransactionRollbackException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLTransactionRollbackException(java.lang.String, java.lang.Throwable)
java.sql.SQLTransactionRollbackException(java.lang.Throwable)


Occurences of SQLTransientConnectionException (constructors)

SQLTransientConnectionException (constructors) occurences:
java.sql.SQLTransientConnectionException()
java.sql.SQLTransientConnectionException(java.lang.String)
java.sql.SQLTransientConnectionException(java.lang.String, java.lang.String)
java.sql.SQLTransientConnectionException(java.lang.String, java.lang.String, int)
java.sql.SQLTransientConnectionException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLTransientConnectionException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLTransientConnectionException(java.lang.String, java.lang.Throwable)
java.sql.SQLTransientConnectionException(java.lang.Throwable)


Occurences of SQLTransientException (constructors)

SQLTransientException (constructors) occurences:
java.sql.SQLTransientException()
java.sql.SQLTransientException(java.lang.String)
java.sql.SQLTransientException(java.lang.String, java.lang.String)
java.sql.SQLTransientException(java.lang.String, java.lang.String, int)
java.sql.SQLTransientException(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLTransientException(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLTransientException(java.lang.String, java.lang.Throwable)
java.sql.SQLTransientException(java.lang.Throwable)


Occurences of SQLWarning (constructors)

SQLWarning (constructors) occurences:
java.sql.SQLWarning()
java.sql.SQLWarning(java.lang.String)
java.sql.SQLWarning(java.lang.String, java.lang.String)
java.sql.SQLWarning(java.lang.String, java.lang.String, int)
java.sql.SQLWarning(java.lang.String, java.lang.String, int, java.lang.Throwable)
java.sql.SQLWarning(java.lang.String, java.lang.String, java.lang.Throwable)
java.sql.SQLWarning(java.lang.String, java.lang.Throwable)
java.sql.SQLWarning(java.lang.Throwable)


Occurences of SQLXML

SQLXML occurences:
java.sql.SQLXML
java.sql.SQLXML


Occurences of sqrt

sqrt occurences:
java.lang.Math.sqrt(double)
java.lang.StrictMath.sqrt(double)


Occurences of SRC

SRC occurences:
java.awt.SRC
javax.swing.text.html.SRC


Occurences of ssl

ssl occurences:
javax.net.ssl
javax.rmi.ssl


Occurences of SSLEngine (constructors)

SSLEngine (constructors) occurences:
javax.net.ssl.SSLEngine()
javax.net.ssl.SSLEngine(java.lang.String, int)


Occurences of SSLException (constructors)

SSLException (constructors) occurences:
javax.net.ssl.SSLException(java.lang.String)
javax.net.ssl.SSLException(java.lang.String, java.lang.Throwable)
javax.net.ssl.SSLException(java.lang.Throwable)


Occurences of SSLParameters (constructors)

SSLParameters (constructors) occurences:
javax.net.ssl.SSLParameters()
javax.net.ssl.SSLParameters(java.lang.String[])
javax.net.ssl.SSLParameters(java.lang.String[], java.lang.String[])


Occurences of SSLPermission (constructors)

SSLPermission (constructors) occurences:
javax.net.ssl.SSLPermission(java.lang.String)
javax.net.ssl.SSLPermission(java.lang.String, java.lang.String)


Occurences of SslRMIServerSocketFactory (constructors)

SslRMIServerSocketFactory (constructors) occurences:
javax.rmi.ssl.SslRMIServerSocketFactory()
javax.rmi.ssl.SslRMIServerSocketFactory(java.lang.String[], java.lang.String[], boolean)


Occurences of SSLServerSocket (constructors)

SSLServerSocket (constructors) occurences:
javax.net.ssl.SSLServerSocket()
javax.net.ssl.SSLServerSocket(int)
javax.net.ssl.SSLServerSocket(int, int)
javax.net.ssl.SSLServerSocket(int, int, java.net.InetAddress)


Occurences of SSLSocket (constructors)

SSLSocket (constructors) occurences:
javax.net.ssl.SSLSocket()
javax.net.ssl.SSLSocket(java.lang.String, int)
javax.net.ssl.SSLSocket(java.lang.String, int, java.net.InetAddress, int)
javax.net.ssl.SSLSocket(java.net.InetAddress, int)
javax.net.ssl.SSLSocket(java.net.InetAddress, int, java.net.InetAddress, int)


Occurences of StackOverflowError (constructors)

StackOverflowError (constructors) occurences:
java.lang.StackOverflowError()
java.lang.StackOverflowError(java.lang.String)


Occurences of standaloneSet

standaloneSet occurences:
javax.xml.stream.events.StartDocument.standaloneSet()
javax.xml.stream.util.StreamReaderDelegate.standaloneSet()
javax.xml.stream.XMLStreamReader.standaloneSet()


Occurences of STANDARD

STANDARD occurences:
java.awt.font.STANDARD
javax.print.attribute.standard.STANDARD


Occurences of StandardEmitterMBean (constructors)

StandardEmitterMBean (constructors) occurences:
javax.management.StandardEmitterMBean(java.lang.Class, boolean, javax.management.NotificationEmitter)
javax.management.StandardEmitterMBean(java.lang.Class, javax.management.NotificationEmitter)
javax.management.StandardEmitterMBean(java.lang.Object,java.lang.Class,boolean,javax.management.NotificationEmitter)
javax.management.StandardEmitterMBean(java.lang.Object,java.lang.Class,javax.management.NotificationEmitter)
javax.management.StandardEmitterMBean(T, java.lang.Class, boolean, javax.management.NotificationEmitter)
javax.management.StandardEmitterMBean(T, java.lang.Class, javax.management.NotificationEmitter)


Occurences of StandardMBean (constructors)

StandardMBean (constructors) occurences:
javax.management.StandardMBean(java.lang.Class)
javax.management.StandardMBean(java.lang.Class, boolean)
javax.management.StandardMBean(java.lang.Object,java.lang.Class)
javax.management.StandardMBean(java.lang.Object,java.lang.Class,boolean)
javax.management.StandardMBean(T, java.lang.Class)
javax.management.StandardMBean(T, java.lang.Class, boolean)


Occurences of start

start occurences:
com.sun.javadoc.Doclet.start(com.sun.javadoc.RootDoc)
java.applet.Applet.start()
java.awt.geom.start
java.awt.geom.start
java.lang.ProcessBuilder.start()
java.lang.Thread.start()
java.util.regex.Matcher.start()
java.util.regex.Matcher.start(int)
java.util.regex.MatchResult.start()
java.util.regex.MatchResult.start(int)
javax.management.monitor.CounterMonitor.start()
javax.management.monitor.GaugeMonitor.start()
javax.management.monitor.Monitor.start()
javax.management.monitor.MonitorMBean.start()
javax.management.monitor.StringMonitor.start()
javax.management.remote.JMXConnectorServerMBean.start()
javax.management.remote.rmi.RMIConnectorServer.start()
javax.management.timer.Timer.start()
javax.management.timer.TimerMBean.start()
javax.sound.midi.Sequencer.start()
javax.sound.sampled.DataLine.start()
javax.swing.text.html.HTMLDocument.HTMLReader.BlockAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.text.html.HTMLDocument.HTMLReader.CharacterAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.text.html.HTMLDocument.HTMLReader.FormAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.text.html.HTMLDocument.HTMLReader.HiddenAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.text.html.HTMLDocument.HTMLReader.ParagraphAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.text.html.HTMLDocument.HTMLReader.PreAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.text.html.HTMLDocument.HTMLReader.SpecialAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.text.html.HTMLDocument.HTMLReader.TagAction.start(javax.swing.text.html.HTML.Tag, javax.swing.text.MutableAttributeSet)
javax.swing.Timer.start()
javax.transaction.xa.XAResource.start(javax.transaction.xa.Xid, int)


Occurences of START

START occurences:
javax.sound.midi.START
javax.sound.sampled.START
javax.swing.text.html.START


Occurences of startCDATA

startCDATA occurences:
org.xml.sax.ext.DefaultHandler2.startCDATA()
org.xml.sax.ext.LexicalHandler.startCDATA()


Occurences of startDocument

startDocument occurences:
org.xml.sax.ContentHandler.startDocument()
org.xml.sax.DocumentHandler.startDocument()
org.xml.sax.HandlerBase.startDocument()
org.xml.sax.helpers.DefaultHandler.startDocument()
org.xml.sax.helpers.ParserAdapter.startDocument()
org.xml.sax.helpers.XMLFilterImpl.startDocument()
org.xml.sax.helpers.XMLReaderAdapter.startDocument()


Occurences of startDrag

startDrag occurences:
java.awt.dnd.DragGestureEvent.startDrag(java.awt.Cursor, java.awt.datatransfer.Transferable)
java.awt.dnd.DragGestureEvent.startDrag(java.awt.Cursor, java.awt.datatransfer.Transferable, java.awt.dnd.DragSourceListener)
java.awt.dnd.DragGestureEvent.startDrag(java.awt.Cursor, java.awt.Image, java.awt.Point, java.awt.datatransfer.Transferable, java.awt.dnd.DragSourceListener)
java.awt.dnd.DragSource.startDrag(java.awt.dnd.DragGestureEvent, java.awt.Cursor, java.awt.datatransfer.Transferable, java.awt.dnd.DragSourceListener)
java.awt.dnd.DragSource.startDrag(java.awt.dnd.DragGestureEvent, java.awt.Cursor, java.awt.datatransfer.Transferable, java.awt.dnd.DragSourceListener, java.awt.datatransfer.FlavorMap)
java.awt.dnd.DragSource.startDrag(java.awt.dnd.DragGestureEvent, java.awt.Cursor, java.awt.Image, java.awt.Point, java.awt.datatransfer.Transferable, java.awt.dnd.DragSourceListener)
java.awt.dnd.DragSource.startDrag(java.awt.dnd.DragGestureEvent, java.awt.Cursor, java.awt.Image, java.awt.Point, java.awt.datatransfer.Transferable, java.awt.dnd.DragSourceListener, java.awt.datatransfer.FlavorMap)


Occurences of startDTD

startDTD occurences:
org.xml.sax.ext.DefaultHandler2.startDTD(java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.ext.LexicalHandler.startDTD(java.lang.String, java.lang.String, java.lang.String)


Occurences of startEditingAtPath

startEditingAtPath occurences:
javax.swing.JTree.startEditingAtPath(javax.swing.tree.TreePath)
javax.swing.plaf.basic.BasicTreeUI.startEditingAtPath(javax.swing.JTree, javax.swing.tree.TreePath)
javax.swing.plaf.multi.MultiTreeUI.startEditingAtPath(javax.swing.JTree, javax.swing.tree.TreePath)
javax.swing.plaf.TreeUI.startEditingAtPath(javax.swing.JTree, javax.swing.tree.TreePath)


Occurences of startElement

startElement occurences:
org.w3c.dom.ls.LSParserFilter.startElement(org.w3c.dom.Element)
org.xml.sax.ContentHandler.startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
org.xml.sax.DocumentHandler.startElement(java.lang.String, org.xml.sax.AttributeList)
org.xml.sax.HandlerBase.startElement(java.lang.String, org.xml.sax.AttributeList)
org.xml.sax.helpers.DefaultHandler.startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
org.xml.sax.helpers.ParserAdapter.startElement(java.lang.String, org.xml.sax.AttributeList)
org.xml.sax.helpers.XMLFilterImpl.startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
org.xml.sax.helpers.XMLReaderAdapter.startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)


Occurences of startEntity

startEntity occurences:
org.xml.sax.ext.DefaultHandler2.startEntity(java.lang.String)
org.xml.sax.ext.LexicalHandler.startEntity(java.lang.String)


Occurences of startIndex

startIndex occurences:
javax.accessibility.startIndex
javax.accessibility.startIndex


Occurences of startListening

startListening occurences:
com.sun.jdi.connect.ListeningConnector.startListening(java.util.Map)
com.sun.jdi.connect.spi.TransportService.startListening()
com.sun.jdi.connect.spi.TransportService.startListening(java.lang.String)


Occurences of startPrefixMapping

startPrefixMapping occurences:
org.xml.sax.ContentHandler.startPrefixMapping(java.lang.String, java.lang.String)
org.xml.sax.helpers.DefaultHandler.startPrefixMapping(java.lang.String, java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.startPrefixMapping(java.lang.String, java.lang.String)
org.xml.sax.helpers.XMLReaderAdapter.startPrefixMapping(java.lang.String, java.lang.String)


Occurences of startProduction

startProduction occurences:
java.awt.image.FilteredImageSource.startProduction(java.awt.image.ImageConsumer)
java.awt.image.ImageProducer.startProduction(java.awt.image.ImageConsumer)
java.awt.image.MemoryImageSource.startProduction(java.awt.image.ImageConsumer)
java.awt.image.renderable.RenderableImageProducer.startProduction(java.awt.image.ImageConsumer)


Occurences of startsWith

startsWith occurences:
java.lang.String.startsWith(java.lang.String)
java.lang.String.startsWith(java.lang.String, int)
javax.naming.CompositeName.startsWith(javax.naming.Name)
javax.naming.CompoundName.startsWith(javax.naming.Name)
javax.naming.ldap.LdapName.startsWith(java.util.List)
javax.naming.ldap.LdapName.startsWith(javax.naming.Name)
javax.naming.Name.startsWith(javax.naming.Name)


Occurences of startTag

startTag occurences:
javax.swing.text.html.HTMLWriter.startTag(javax.swing.text.Element)
javax.swing.text.html.parser.Parser.startTag(javax.swing.text.html.parser.TagElement)


Occurences of start_value

start_value occurences:
org.omg.CORBA.portable.ValueInputStream.start_value()
org.omg.CORBA.portable.ValueOutputStream.start_value(java.lang.String)


Occurences of state

state occurences:
java.security.state
org.omg.PortableInterceptor.IORInfoOperations.state()


Occurences of stateChanged

stateChanged occurences:
javax.swing.AbstractButton.ButtonChangeListener.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.event.ChangeListener.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.JMenuItem.AccessibleJMenuItem.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.JScrollPane.AccessibleJScrollPane.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.JSpinner.AccessibleJSpinner.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.JSpinner.DefaultEditor.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.JTabbedPane.AccessibleJTabbedPane.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.JTabbedPane.ModelListener.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicButtonListener.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicMenuUI.ChangeHandler.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicProgressBarUI.ChangeHandler.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicScrollBarUI.ModelListener.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicScrollPaneUI.HSBChangeListener.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicScrollPaneUI.ViewportChangeHandler.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicScrollPaneUI.VSBChangeListener.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicSliderUI.ChangeHandler.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.plaf.basic.BasicTabbedPaneUI.TabSelectionHandler.stateChanged(javax.swing.event.ChangeEvent)
javax.swing.ProgressMonitor.AccessibleProgressMonitor.stateChanged(javax.swing.event.ChangeEvent)


Occurences of StateEdit (constructors)

StateEdit (constructors) occurences:
javax.swing.undo.StateEdit(javax.swing.undo.StateEditable)
javax.swing.undo.StateEdit(javax.swing.undo.StateEditable, java.lang.String)


Occurences of Statement

Statement occurences:
java.beans.Statement
java.sql.Statement
Statement


Occurences of StatementEvent (constructors)

StatementEvent (constructors) occurences:
javax.sql.StatementEvent(javax.sql.PooledConnection, java.sql.PreparedStatement)
javax.sql.StatementEvent(javax.sql.PooledConnection, java.sql.PreparedStatement, java.sql.SQLException)


Occurences of STATIC

STATIC occurences:
com.sun.mirror.declaration.STATIC
java.lang.reflect.STATIC
javax.lang.model.element.STATIC


Occurences of status

status occurences:
com.sun.jdi.ThreadReference.status()
java.awt.image.PixelGrabber.status()


Occurences of StAXResult (constructors)

StAXResult (constructors) occurences:
javax.xml.transform.stax.StAXResult(javax.xml.stream.XMLEventWriter)
javax.xml.transform.stax.StAXResult(javax.xml.stream.XMLStreamWriter)


Occurences of StAXSource (constructors)

StAXSource (constructors) occurences:
javax.xml.transform.stax.StAXSource(javax.xml.stream.XMLEventReader)
javax.xml.transform.stax.StAXSource(javax.xml.stream.XMLStreamReader)


Occurences of steps

steps occurences:
java.nio.charset.steps
java.nio.charset.steps


Occurences of stop

stop occurences:
com.sun.jdi.ThreadReference.stop(com.sun.jdi.ObjectReference)
java.applet.Applet.stop()
java.applet.AudioClip.stop()
java.awt.dnd.DropTarget.DropTargetAutoScroller.stop()
java.lang.Thread.stop()
java.lang.Thread.stop(java.lang.Throwable)
java.lang.ThreadGroup.stop()
javax.management.monitor.CounterMonitor.stop()
javax.management.monitor.GaugeMonitor.stop()
javax.management.monitor.Monitor.stop()
javax.management.monitor.MonitorMBean.stop()
javax.management.monitor.StringMonitor.stop()
javax.management.remote.JMXConnectorServerMBean.stop()
javax.management.remote.rmi.RMIConnectorServer.stop()
javax.management.timer.Timer.stop()
javax.management.timer.TimerMBean.stop()
javax.sound.midi.Sequencer.stop()
javax.sound.sampled.DataLine.stop()
javax.swing.Timer.stop()
javax.xml.ws.Endpoint.stop()


Occurences of STOP

STOP occurences:
javax.sound.midi.STOP
javax.sound.sampled.STOP


Occurences of stopCellEditing

stopCellEditing occurences:
javax.swing.AbstractCellEditor.stopCellEditing()
javax.swing.CellEditor.stopCellEditing()
javax.swing.DefaultCellEditor.stopCellEditing()
javax.swing.DefaultCellEditor.EditorDelegate.stopCellEditing()
javax.swing.tree.DefaultTreeCellEditor.stopCellEditing()


Occurences of stopEditing

stopEditing occurences:
javax.swing.JTree.stopEditing()
javax.swing.plaf.basic.BasicTreeUI.stopEditing(javax.swing.JTree)
javax.swing.plaf.multi.MultiTreeUI.stopEditing(javax.swing.JTree)
javax.swing.plaf.TreeUI.stopEditing(javax.swing.JTree)


Occurences of stopListening

stopListening occurences:
com.sun.jdi.connect.ListeningConnector.stopListening(java.util.Map)
com.sun.jdi.connect.spi.TransportService.stopListening(com.sun.jdi.connect.spi.TransportService.ListenKey)


Occurences of store

store occurences:
java.security.KeyStore.store(java.io.OutputStream, char[])
java.security.KeyStore.store(java.security.KeyStore.LoadStoreParameter)
java.util.Properties.store(java.io.OutputStream, java.lang.String)
java.util.Properties.store(java.io.Writer, java.lang.String)
javax.management.modelmbean.RequiredModelMBean.store()
javax.management.PersistentMBean.store()


Occurences of STORED

STORED occurences:
java.util.zip.STORED
java.util.zip.STORED


Occurences of storeToXML

storeToXML occurences:
java.util.Properties.storeToXML(java.io.OutputStream, java.lang.String)
java.util.Properties.storeToXML(java.io.OutputStream, java.lang.String, java.lang.String)


Occurences of stream

stream occurences:
javax.imageio.stream
javax.xml.stream
javax.xml.transform.stream


Occurences of StreamCorruptedException (constructors)

StreamCorruptedException (constructors) occurences:
java.io.StreamCorruptedException()
java.io.StreamCorruptedException(java.lang.String)


Occurences of StreamHandler (constructors)

StreamHandler (constructors) occurences:
java.util.logging.StreamHandler()
java.util.logging.StreamHandler(java.io.OutputStream, java.util.logging.Formatter)


Occurences of StreamReaderDelegate (constructors)

StreamReaderDelegate (constructors) occurences:
javax.xml.stream.util.StreamReaderDelegate()
javax.xml.stream.util.StreamReaderDelegate(javax.xml.stream.XMLStreamReader)


Occurences of StreamResult (constructors)

StreamResult (constructors) occurences:
javax.xml.transform.stream.StreamResult()
javax.xml.transform.stream.StreamResult(java.io.File)
javax.xml.transform.stream.StreamResult(java.io.OutputStream)
javax.xml.transform.stream.StreamResult(java.io.Writer)
javax.xml.transform.stream.StreamResult(java.lang.String)


Occurences of StreamSource (constructors)

StreamSource (constructors) occurences:
javax.xml.transform.stream.StreamSource()
javax.xml.transform.stream.StreamSource(java.io.File)
javax.xml.transform.stream.StreamSource(java.io.InputStream)
javax.xml.transform.stream.StreamSource(java.io.InputStream, java.lang.String)
javax.xml.transform.stream.StreamSource(java.io.Reader)
javax.xml.transform.stream.StreamSource(java.io.Reader, java.lang.String)
javax.xml.transform.stream.StreamSource(java.lang.String)


Occurences of StreamTokenizer (constructors)

StreamTokenizer (constructors) occurences:
java.io.StreamTokenizer(java.io.InputStream)
java.io.StreamTokenizer(java.io.Reader)


Occurences of STRICTFP

STRICTFP occurences:
com.sun.mirror.declaration.STRICTFP
javax.lang.model.element.STRICTFP


Occurences of STRING

STRING occurences:
javax.management.openmbean.STRING
javax.xml.xpath.STRING


Occurences of String (constructors)

String (constructors) occurences:
java.lang.String()
java.lang.String(byte[])
java.lang.String(byte[], int)
java.lang.String(byte[], int, int)
java.lang.String(byte[], int, int, int)
java.lang.String(byte[], int, int, java.lang.String)
java.lang.String(byte[], int, int, java.nio.charset.Charset)
java.lang.String(byte[], java.lang.String)
java.lang.String(byte[], java.nio.charset.Charset)
java.lang.String(char[])
java.lang.String(char[], int, int)
java.lang.String(int[], int, int)
java.lang.String(java.lang.String)
java.lang.String(java.lang.StringBuffer)
java.lang.String(java.lang.StringBuilder)


Occurences of StringBuffer (constructors)

StringBuffer (constructors) occurences:
java.lang.StringBuffer()
java.lang.StringBuffer(int)
java.lang.StringBuffer(java.lang.CharSequence)
java.lang.StringBuffer(java.lang.String)


Occurences of StringBuilder (constructors)

StringBuilder (constructors) occurences:
java.lang.StringBuilder()
java.lang.StringBuilder(int)
java.lang.StringBuilder(java.lang.CharSequence)
java.lang.StringBuilder(java.lang.String)


Occurences of StringCharacterIterator (constructors)

StringCharacterIterator (constructors) occurences:
java.text.StringCharacterIterator(java.lang.String)
java.text.StringCharacterIterator(java.lang.String, int)
java.text.StringCharacterIterator(java.lang.String, int, int, int)


Occurences of StringContent (constructors)

StringContent (constructors) occurences:
javax.swing.text.StringContent()
javax.swing.text.StringContent(int)


Occurences of StringHolder (constructors)

StringHolder (constructors) occurences:
org.omg.CORBA.StringHolder()
org.omg.CORBA.StringHolder(java.lang.String)


Occurences of StringIndexOutOfBoundsException (constructors)

StringIndexOutOfBoundsException (constructors) occurences:
java.lang.StringIndexOutOfBoundsException()
java.lang.StringIndexOutOfBoundsException(int)
java.lang.StringIndexOutOfBoundsException(java.lang.String)


Occurences of StringSeqHolder (constructors)

StringSeqHolder (constructors) occurences:
org.omg.CORBA.StringSeqHolder()
org.omg.CORBA.StringSeqHolder(java.lang.String[])


Occurences of StringTokenizer (constructors)

StringTokenizer (constructors) occurences:
java.util.StringTokenizer(java.lang.String)
java.util.StringTokenizer(java.lang.String, java.lang.String)
java.util.StringTokenizer(java.lang.String, java.lang.String, boolean)


Occurences of stringToValue

stringToValue occurences:
javax.swing.JFormattedTextField.AbstractFormatter.stringToValue(java.lang.String)
javax.swing.text.DefaultFormatter.stringToValue(java.lang.String)
javax.swing.text.InternationalFormatter.stringToValue(java.lang.String)
javax.swing.text.MaskFormatter.stringToValue(java.lang.String)


Occurences of StringValueExp (constructors)

StringValueExp (constructors) occurences:
javax.management.StringValueExp()
javax.management.StringValueExp(java.lang.String)


Occurences of stringValueOf

stringValueOf occurences:
com.sun.jdi.connect.Connector.BooleanArgument.stringValueOf(boolean)
com.sun.jdi.connect.Connector.IntegerArgument.stringValueOf(int)


Occurences of StringWriter (constructors)

StringWriter (constructors) occurences:
java.io.StringWriter()
java.io.StringWriter(int)


Occurences of StructMember (constructors)

StructMember (constructors) occurences:
org.omg.CORBA.StructMember()
org.omg.CORBA.StructMember(java.lang.String, org.omg.CORBA.TypeCode, org.omg.CORBA.IDLType)


Occurences of StubNotFoundException (constructors)

StubNotFoundException (constructors) occurences:
java.rmi.StubNotFoundException(java.lang.String)
java.rmi.StubNotFoundException(java.lang.String, java.lang.Exception)


Occurences of style

style occurences:
java.awt.style
javax.jws.soap.SOAPBinding.style()


Occurences of STYLE

STYLE occurences:
javax.swing.text.html.STYLE
javax.swing.text.html.STYLE


Occurences of StyleContext.NamedStyle (constructors)

StyleContext.NamedStyle (constructors) occurences:
javax.swing.text.StyleContext.NamedStyle()
javax.swing.text.StyleContext.NamedStyle(java.lang.String, javax.swing.text.Style)
javax.swing.text.StyleContext.NamedStyle(javax.swing.text.Style)


Occurences of StyleContext.SmallAttributeSet (constructors)

StyleContext.SmallAttributeSet (constructors) occurences:
javax.swing.text.StyleContext.SmallAttributeSet(java.lang.Object[])
javax.swing.text.StyleContext.SmallAttributeSet(javax.swing.text.AttributeSet)


Occurences of subdivide

subdivide occurences:
java.awt.geom.CubicCurve2D.subdivide(double[], int, double[], int, double[], int)
java.awt.geom.CubicCurve2D.subdivide(java.awt.geom.CubicCurve2D, java.awt.geom.CubicCurve2D)
java.awt.geom.CubicCurve2D.subdivide(java.awt.geom.CubicCurve2D, java.awt.geom.CubicCurve2D, java.awt.geom.CubicCurve2D)
java.awt.geom.QuadCurve2D.subdivide(double[], int, double[], int, double[], int)
java.awt.geom.QuadCurve2D.subdivide(java.awt.geom.QuadCurve2D, java.awt.geom.QuadCurve2D)
java.awt.geom.QuadCurve2D.subdivide(java.awt.geom.QuadCurve2D, java.awt.geom.QuadCurve2D, java.awt.geom.QuadCurve2D)


Occurences of Subject (constructors)

Subject (constructors) occurences:
javax.security.auth.Subject()
javax.security.auth.Subject(boolean, java.util.Set, java.util.Set, java.util.Set)


Occurences of SubjectDelegationPermission (constructors)

SubjectDelegationPermission (constructors) occurences:
javax.management.remote.SubjectDelegationPermission(java.lang.String)
javax.management.remote.SubjectDelegationPermission(java.lang.String, java.lang.String)


Occurences of Subjects, Principals, Authentication, and Credentials

Subjects, Principals, Authentication, and Credentials occurences:
Subjects, Principals, Authentication, and Credentials
Subjects, Principals, Authentication, and Credentials


Occurences of subList

subList occurences:
java.util.AbstractList.subList(int, int)
java.util.concurrent.CopyOnWriteArrayList.subList(int, int)
java.util.List.subList(int, int)
java.util.Vector.subList(int, int)


Occurences of subMap

subMap occurences:
java.util.concurrent.ConcurrentNavigableMap.subMap(java.lang.Object,boolean,java.lang.Object,boolean)
java.util.concurrent.ConcurrentNavigableMap.subMap(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentNavigableMap.subMap(K, boolean, K, boolean)
java.util.concurrent.ConcurrentNavigableMap.subMap(K, K)
java.util.concurrent.ConcurrentSkipListMap.subMap(java.lang.Object,boolean,java.lang.Object,boolean)
java.util.concurrent.ConcurrentSkipListMap.subMap(java.lang.Object,java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.subMap(K, boolean, K, boolean)
java.util.concurrent.ConcurrentSkipListMap.subMap(K, K)
java.util.NavigableMap.subMap(java.lang.Object,boolean,java.lang.Object,boolean)
java.util.NavigableMap.subMap(java.lang.Object,java.lang.Object)
java.util.NavigableMap.subMap(K, boolean, K, boolean)
java.util.NavigableMap.subMap(K, K)
java.util.SortedMap.subMap(java.lang.Object,java.lang.Object)
java.util.SortedMap.subMap(K, K)
java.util.TreeMap.subMap(java.lang.Object,boolean,java.lang.Object,boolean)
java.util.TreeMap.subMap(java.lang.Object,java.lang.Object)
java.util.TreeMap.subMap(K, boolean, K, boolean)
java.util.TreeMap.subMap(K, K)


Occurences of submit

submit occurences:
java.util.concurrent.AbstractExecutorService.submit(java.lang.Runnable)
java.util.concurrent.AbstractExecutorService.submit(java.lang.Runnable, T)
java.util.concurrent.AbstractExecutorService.submit(java.lang.Runnable,java.lang.Object)
java.util.concurrent.AbstractExecutorService.submit(java.util.concurrent.Callable)
java.util.concurrent.CompletionService.submit(java.lang.Runnable, V)
java.util.concurrent.CompletionService.submit(java.lang.Runnable,java.lang.Object)
java.util.concurrent.CompletionService.submit(java.util.concurrent.Callable)
java.util.concurrent.ExecutorCompletionService.submit(java.lang.Runnable, V)
java.util.concurrent.ExecutorCompletionService.submit(java.lang.Runnable,java.lang.Object)
java.util.concurrent.ExecutorCompletionService.submit(java.util.concurrent.Callable)
java.util.concurrent.ExecutorService.submit(java.lang.Runnable)
java.util.concurrent.ExecutorService.submit(java.lang.Runnable, T)
java.util.concurrent.ExecutorService.submit(java.lang.Runnable,java.lang.Object)
java.util.concurrent.ExecutorService.submit(java.util.concurrent.Callable)
java.util.concurrent.ScheduledThreadPoolExecutor.submit(java.lang.Runnable)
java.util.concurrent.ScheduledThreadPoolExecutor.submit(java.lang.Runnable, T)
java.util.concurrent.ScheduledThreadPoolExecutor.submit(java.lang.Runnable,java.lang.Object)
java.util.concurrent.ScheduledThreadPoolExecutor.submit(java.util.concurrent.Callable)


Occurences of subSequence

subSequence occurences:
java.lang.CharSequence.subSequence(int, int)
java.lang.String.subSequence(int, int)
java.lang.StringBuffer.subSequence(int, int)
java.lang.StringBuilder.subSequence(int, int)
java.nio.CharBuffer.subSequence(int, int)
javax.swing.text.Segment.subSequence(int, int)


Occurences of subSet

subSet occurences:
java.util.concurrent.ConcurrentSkipListSet.subSet(E, boolean, E, boolean)
java.util.concurrent.ConcurrentSkipListSet.subSet(E, E)
java.util.concurrent.ConcurrentSkipListSet.subSet(java.lang.Object,boolean,java.lang.Object,boolean)
java.util.concurrent.ConcurrentSkipListSet.subSet(java.lang.Object,java.lang.Object)
java.util.NavigableSet.subSet(E, boolean, E, boolean)
java.util.NavigableSet.subSet(E, E)
java.util.NavigableSet.subSet(java.lang.Object,boolean,java.lang.Object,boolean)
java.util.NavigableSet.subSet(java.lang.Object,java.lang.Object)
java.util.SortedSet.subSet(E, E)
java.util.SortedSet.subSet(java.lang.Object,java.lang.Object)
java.util.TreeSet.subSet(E, boolean, E, boolean)
java.util.TreeSet.subSet(E, E)
java.util.TreeSet.subSet(java.lang.Object,boolean,java.lang.Object,boolean)
java.util.TreeSet.subSet(java.lang.Object,java.lang.Object)


Occurences of Substitution by Serializable Classes

Substitution by Serializable Classes occurences:
Substitution by Serializable Classes
Substitution by Serializable Classes
Substitution by Serializable Classes


Occurences of substring

substring occurences:
java.lang.String.substring(int)
java.lang.String.substring(int, int)
java.lang.StringBuffer.substring(int)
java.lang.StringBuffer.substring(int, int)
java.lang.StringBuilder.substring(int)
java.lang.StringBuilder.substring(int, int)


Occurences of subtract

subtract occurences:
java.awt.geom.Area.subtract(java.awt.geom.Area)
java.math.BigDecimal.subtract(java.math.BigDecimal)
java.math.BigDecimal.subtract(java.math.BigDecimal, java.math.MathContext)
java.math.BigInteger.subtract(java.math.BigInteger)
javax.xml.datatype.Duration.subtract(javax.xml.datatype.Duration)


Occurences of SUBTREE_SCOPE

SUBTREE_SCOPE occurences:
javax.naming.directory.SUBTREE_SCOPE
javax.naming.event.SUBTREE_SCOPE


Occurences of sum

sum occurences:
java.util.regex.sum
javax.swing.Spring.sum(javax.swing.Spring, javax.swing.Spring)


Occurences of Summary of New Features

Summary of New Features occurences:
Summary of New Features
Summary of New Features


Occurences of superclass

superclass occurences:
com.sun.javadoc.ClassDoc.superclass()
com.sun.jdi.ClassType.superclass()


Occurences of superclassType

superclassType occurences:
com.sun.javadoc.ClassDoc.superclassType()
com.sun.javadoc.ParameterizedType.superclassType()


Occurences of Supported Properties

Supported Properties occurences:
javax.xml.crypto.dsig.Supported Properties
javax.xml.crypto.dsig.Supported Properties


Occurences of supportedProps

supportedProps occurences:
javax.xml.bind.supportedProps
javax.xml.bind.supportedProps
javax.xml.bind.supportedProps


Occurences of supportsConvert

supportsConvert occurences:
java.sql.DatabaseMetaData.supportsConvert()
java.sql.DatabaseMetaData.supportsConvert(int, int)


Occurences of supportsCustomEditor

supportsCustomEditor occurences:
java.beans.PropertyEditor.supportsCustomEditor()
java.beans.PropertyEditorSupport.supportsCustomEditor()


Occurences of supportsMultipleConnections

supportsMultipleConnections occurences:
com.sun.jdi.connect.ListeningConnector.supportsMultipleConnections()
com.sun.jdi.connect.spi.TransportService.Capabilities.supportsMultipleConnections()


Occurences of suspend

suspend occurences:
com.sun.jdi.ThreadGroupReference.suspend()
com.sun.jdi.ThreadReference.suspend()
com.sun.jdi.VirtualMachine.suspend()
java.lang.Thread.suspend()
java.lang.ThreadGroup.suspend()


Occurences of suspendPolicy

suspendPolicy occurences:
com.sun.jdi.event.EventSet.suspendPolicy()
com.sun.jdi.request.EventRequest.suspendPolicy()


Occurences of SwingPropertyChangeSupport (constructors)

SwingPropertyChangeSupport (constructors) occurences:
javax.swing.event.SwingPropertyChangeSupport(java.lang.Object)
javax.swing.event.SwingPropertyChangeSupport(java.lang.Object, boolean)


Occurences of SW_RESIZE_CURSOR

SW_RESIZE_CURSOR occurences:
java.awt.SW_RESIZE_CURSOR
java.awt.SW_RESIZE_CURSOR


Occurences of sync

sync occurences:
java.awt.Toolkit.sync()
java.io.FileDescriptor.sync()
java.util.prefs.AbstractPreferences.sync()
java.util.prefs.Preferences.sync()


Occurences of SyncFactoryException (constructors)

SyncFactoryException (constructors) occurences:
javax.sql.rowset.spi.SyncFactoryException()
javax.sql.rowset.spi.SyncFactoryException(java.lang.String)


Occurences of synchronization

synchronization occurences:
java.text.synchronization
java.text.synchronization
java.text.synchronization
java.text.synchronization
java.text.synchronization
java.text.synchronization
java.text.synchronization


Occurences of SYNCHRONIZED

SYNCHRONIZED occurences:
com.sun.mirror.declaration.SYNCHRONIZED
com.sun.source.tree.SYNCHRONIZED
java.lang.reflect.SYNCHRONIZED
javax.lang.model.element.SYNCHRONIZED


Occurences of synchronizedView

synchronizedView occurences:
javax.print.attribute.AttributeSetUtilities.synchronizedView(javax.print.attribute.AttributeSet)
javax.print.attribute.AttributeSetUtilities.synchronizedView(javax.print.attribute.DocAttributeSet)
javax.print.attribute.AttributeSetUtilities.synchronizedView(javax.print.attribute.PrintJobAttributeSet)
javax.print.attribute.AttributeSetUtilities.synchronizedView(javax.print.attribute.PrintRequestAttributeSet)
javax.print.attribute.AttributeSetUtilities.synchronizedView(javax.print.attribute.PrintServiceAttributeSet)


Occurences of SynchronousQueue (constructors)

SynchronousQueue (constructors) occurences:
java.util.concurrent.SynchronousQueue()
java.util.concurrent.SynchronousQueue(boolean)


Occurences of SyncProviderException (constructors)

SyncProviderException (constructors) occurences:
javax.sql.rowset.spi.SyncProviderException()
javax.sql.rowset.spi.SyncProviderException(java.lang.String)
javax.sql.rowset.spi.SyncProviderException(javax.sql.rowset.spi.SyncResolver)


Occurences of SysexMessage (constructors)

SysexMessage (constructors) occurences:
javax.sound.midi.SysexMessage()
javax.sound.midi.SysexMessage(byte[])


Occurences of systemRoot

systemRoot occurences:
java.util.prefs.Preferences.systemRoot()
java.util.prefs.PreferencesFactory.systemRoot()


Occurences of S_RESIZE_CURSOR

S_RESIZE_CURSOR occurences:
java.awt.S_RESIZE_CURSOR
java.awt.S_RESIZE_CURSOR


Occurences of tabForCoordinate

tabForCoordinate occurences:
javax.swing.plaf.basic.BasicTabbedPaneUI.tabForCoordinate(javax.swing.JTabbedPane, int, int)
javax.swing.plaf.multi.MultiTabbedPaneUI.tabForCoordinate(javax.swing.JTabbedPane, int, int)
javax.swing.plaf.TabbedPaneUI.tabForCoordinate(javax.swing.JTabbedPane, int, int)


Occurences of table

table occurences:
javax.swing.plaf.basic.table
javax.swing.table
javax.swing.table.table


Occurences of TABLE

TABLE occurences:
javax.accessibility.TABLE
javax.swing.plaf.synth.TABLE
javax.swing.text.html.TABLE


Occurences of tableChanged

tableChanged occurences:
javax.swing.event.TableModelListener.tableChanged(javax.swing.event.TableModelEvent)
javax.swing.JTable.tableChanged(javax.swing.event.TableModelEvent)
javax.swing.JTable.AccessibleJTable.tableChanged(javax.swing.event.TableModelEvent)


Occurences of TableColumn (constructors)

TableColumn (constructors) occurences:
javax.swing.table.TableColumn()
javax.swing.table.TableColumn(int)
javax.swing.table.TableColumn(int, int)
javax.swing.table.TableColumn(int, int, javax.swing.table.TableCellRenderer, javax.swing.table.TableCellEditor)


Occurences of TableModelEvent (constructors)

TableModelEvent (constructors) occurences:
javax.swing.event.TableModelEvent(javax.swing.table.TableModel)
javax.swing.event.TableModelEvent(javax.swing.table.TableModel, int)
javax.swing.event.TableModelEvent(javax.swing.table.TableModel, int, int)
javax.swing.event.TableModelEvent(javax.swing.table.TableModel, int, int, int)
javax.swing.event.TableModelEvent(javax.swing.table.TableModel, int, int, int, int)


Occurences of TableRowSorter (constructors)

TableRowSorter (constructors) occurences:
javax.swing.table.TableRowSorter()
javax.swing.table.TableRowSorter(javax.swing.table.TableModel)
javax.swing.table.TableRowSorter(M)


Occurences of TABLOID

TABLOID occurences:
java.awt.TABLOID
javax.print.attribute.standard.TABLOID
javax.print.attribute.standard.TABLOID


Occurences of TabSet

TabSet occurences:
javax.swing.text.TabSet
javax.swing.text.TabSet


Occurences of TabStop (constructors)

TabStop (constructors) occurences:
javax.swing.text.TabStop(float)
javax.swing.text.TabStop(float, int, int)


Occurences of TabularDataSupport (constructors)

TabularDataSupport (constructors) occurences:
javax.management.openmbean.TabularDataSupport(javax.management.openmbean.TabularType)
javax.management.openmbean.TabularDataSupport(javax.management.openmbean.TabularType, int, float)


Occurences of tag

tag occurences:
org.omg.IOP.tag
org.omg.IOP.tag


Occurences of TagElement (constructors)

TagElement (constructors) occurences:
javax.swing.text.html.parser.TagElement(javax.swing.text.html.parser.Element)
javax.swing.text.html.parser.TagElement(javax.swing.text.html.parser.Element, boolean)


Occurences of TaggedComponent (constructors)

TaggedComponent (constructors) occurences:
org.omg.IOP.TaggedComponent()
org.omg.IOP.TaggedComponent(int, byte[])


Occurences of TaggedComponentHolder (constructors)

TaggedComponentHolder (constructors) occurences:
org.omg.IOP.TaggedComponentHolder()
org.omg.IOP.TaggedComponentHolder(org.omg.IOP.TaggedComponent)


Occurences of TaggedProfile (constructors)

TaggedProfile (constructors) occurences:
org.omg.IOP.TaggedProfile()
org.omg.IOP.TaggedProfile(int, byte[])


Occurences of TaggedProfileHolder (constructors)

TaggedProfileHolder (constructors) occurences:
org.omg.IOP.TaggedProfileHolder()
org.omg.IOP.TaggedProfileHolder(org.omg.IOP.TaggedProfile)


Occurences of Taglet Overview

Taglet Overview occurences:
Taglet Overview
Taglet Overview


Occurences of tags

tags occurences:
com.sun.javadoc.Doc.tags()
com.sun.javadoc.Doc.tags(java.lang.String)


Occurences of tailMap

tailMap occurences:
java.util.concurrent.ConcurrentNavigableMap.tailMap(java.lang.Object)
java.util.concurrent.ConcurrentNavigableMap.tailMap(java.lang.Object,boolean)
java.util.concurrent.ConcurrentNavigableMap.tailMap(K)
java.util.concurrent.ConcurrentNavigableMap.tailMap(K, boolean)
java.util.concurrent.ConcurrentSkipListMap.tailMap(java.lang.Object)
java.util.concurrent.ConcurrentSkipListMap.tailMap(java.lang.Object,boolean)
java.util.concurrent.ConcurrentSkipListMap.tailMap(K)
java.util.concurrent.ConcurrentSkipListMap.tailMap(K, boolean)
java.util.NavigableMap.tailMap(java.lang.Object)
java.util.NavigableMap.tailMap(java.lang.Object,boolean)
java.util.NavigableMap.tailMap(K)
java.util.NavigableMap.tailMap(K, boolean)
java.util.SortedMap.tailMap(java.lang.Object)
java.util.SortedMap.tailMap(K)
java.util.TreeMap.tailMap(java.lang.Object)
java.util.TreeMap.tailMap(java.lang.Object,boolean)
java.util.TreeMap.tailMap(K)
java.util.TreeMap.tailMap(K, boolean)


Occurences of tailSet

tailSet occurences:
java.util.concurrent.ConcurrentSkipListSet.tailSet(E)
java.util.concurrent.ConcurrentSkipListSet.tailSet(E, boolean)
java.util.concurrent.ConcurrentSkipListSet.tailSet(java.lang.Object)
java.util.concurrent.ConcurrentSkipListSet.tailSet(java.lang.Object,boolean)
java.util.NavigableSet.tailSet(E)
java.util.NavigableSet.tailSet(E, boolean)
java.util.NavigableSet.tailSet(java.lang.Object)
java.util.NavigableSet.tailSet(java.lang.Object,boolean)
java.util.SortedSet.tailSet(E)
java.util.SortedSet.tailSet(java.lang.Object)
java.util.TreeSet.tailSet(E)
java.util.TreeSet.tailSet(E, boolean)
java.util.TreeSet.tailSet(java.lang.Object)
java.util.TreeSet.tailSet(java.lang.Object,boolean)


Occurences of take

take occurences:
java.util.concurrent.ArrayBlockingQueue.take()
java.util.concurrent.BlockingDeque.take()
java.util.concurrent.BlockingQueue.take()
java.util.concurrent.CompletionService.take()
java.util.concurrent.DelayQueue.take()
java.util.concurrent.ExecutorCompletionService.take()
java.util.concurrent.LinkedBlockingDeque.take()
java.util.concurrent.LinkedBlockingQueue.take()
java.util.concurrent.PriorityBlockingQueue.take()
java.util.concurrent.SynchronousQueue.take()


Occurences of takeFirst

takeFirst occurences:
java.util.concurrent.BlockingDeque.takeFirst()
java.util.concurrent.LinkedBlockingDeque.takeFirst()


Occurences of takeLast

takeLast occurences:
java.util.concurrent.BlockingDeque.takeLast()
java.util.concurrent.LinkedBlockingDeque.takeLast()


Occurences of TAMIL

TAMIL occurences:
java.awt.font.TAMIL
java.lang.TAMIL


Occurences of tan

tan occurences:
java.lang.Math.tan(double)
java.lang.StrictMath.tan(double)


Occurences of tanh

tanh occurences:
java.lang.Math.tanh(double)
java.lang.StrictMath.tanh(double)


Occurences of target

target occurences:
java.awt.target
org.omg.CORBA.Request.target()
org.omg.PortableInterceptor.ClientRequestInfoOperations.target()


Occurences of targetNamespace

targetNamespace occurences:
javax.jws.WebParam.targetNamespace()
javax.jws.WebResult.targetNamespace()
javax.jws.WebService.targetNamespace()
javax.xml.ws.RequestWrapper.targetNamespace()
javax.xml.ws.ResponseWrapper.targetNamespace()
javax.xml.ws.WebFault.targetNamespace()
javax.xml.ws.WebServiceClient.targetNamespace()
javax.xml.ws.WebServiceProvider.targetNamespace()


Occurences of TaskEvent (constructors)

TaskEvent (constructors) occurences:
com.sun.source.util.TaskEvent(com.sun.source.util.TaskEvent.Kind)
com.sun.source.util.TaskEvent(com.sun.source.util.TaskEvent.Kind, com.sun.source.tree.CompilationUnitTree)
com.sun.source.util.TaskEvent(com.sun.source.util.TaskEvent.Kind, com.sun.source.tree.CompilationUnitTree, javax.lang.model.element.TypeElement)
com.sun.source.util.TaskEvent(com.sun.source.util.TaskEvent.Kind, javax.tools.JavaFileObject)


Occurences of TELUGU

TELUGU occurences:
java.awt.font.TELUGU
java.lang.TELUGU


Occurences of TEN

TEN occurences:
java.math.TEN
java.math.TEN


Occurences of TEXT

TEXT occurences:
java.awt.TEXT
javax.accessibility.TEXT
javax.swing.text.html.TEXT


Occurences of text

text occurences:
com.sun.javadoc.Tag.text()
java.awt.text
java.text
java.text.text
javax.accessibility.text
javax.swing.text
javax.swing.text.AbstractWriter.text(javax.swing.text.Element)
javax.swing.text.html.HTMLWriter.text(javax.swing.text.Element)
javax.swing.text.html.MinimalHTMLWriter.text(javax.swing.text.Element)


Occurences of Text

Text occurences:
javax.xml.soap.Text
org.w3c.dom.Text


Occurences of TextArea (constructors)

TextArea (constructors) occurences:
java.awt.TextArea()
java.awt.TextArea(int, int)
java.awt.TextArea(java.lang.String)
java.awt.TextArea(java.lang.String, int, int)
java.awt.TextArea(java.lang.String, int, int, int)


Occurences of textAreaContent

textAreaContent occurences:
javax.swing.text.html.HTMLDocument.HTMLReader.textAreaContent(char[])
javax.swing.text.html.HTMLWriter.textAreaContent(javax.swing.text.AttributeSet)


Occurences of TextField (constructors)

TextField (constructors) occurences:
java.awt.TextField()
java.awt.TextField(int)
java.awt.TextField(java.lang.String)
java.awt.TextField(java.lang.String, int)


Occurences of TextInputCallback (constructors)

TextInputCallback (constructors) occurences:
javax.security.auth.callback.TextInputCallback(java.lang.String)
javax.security.auth.callback.TextInputCallback(java.lang.String, java.lang.String)


Occurences of TextLayout (constructors)

TextLayout (constructors) occurences:
java.awt.font.TextLayout(java.lang.String, java.awt.Font, java.awt.font.FontRenderContext)
java.awt.font.TextLayout(java.lang.String, java.util.Map, java.awt.font.FontRenderContext)
java.awt.font.TextLayout(java.text.AttributedCharacterIterator, java.awt.font.FontRenderContext)


Occurences of textValueChanged

textValueChanged occurences:
java.awt.AWTEventMulticaster.textValueChanged(java.awt.event.TextEvent)
java.awt.event.TextListener.textValueChanged(java.awt.event.TextEvent)
java.awt.TextComponent.AccessibleAWTTextComponent.textValueChanged(java.awt.event.TextEvent)


Occurences of TEXT_CURSOR

TEXT_CURSOR occurences:
java.awt.TEXT_CURSOR
java.awt.TEXT_CURSOR


Occurences of TEXT_HTML

TEXT_HTML occurences:
javax.print.TEXT_HTML
javax.print.TEXT_HTML
javax.print.TEXT_HTML


Occurences of TEXT_HTML_HOST

TEXT_HTML_HOST occurences:
javax.print.TEXT_HTML_HOST
javax.print.TEXT_HTML_HOST
javax.print.TEXT_HTML_HOST


Occurences of TEXT_HTML_US_ASCII

TEXT_HTML_US_ASCII occurences:
javax.print.TEXT_HTML_US_ASCII
javax.print.TEXT_HTML_US_ASCII
javax.print.TEXT_HTML_US_ASCII


Occurences of TEXT_HTML_UTF_16

TEXT_HTML_UTF_16 occurences:
javax.print.TEXT_HTML_UTF_16
javax.print.TEXT_HTML_UTF_16
javax.print.TEXT_HTML_UTF_16


Occurences of TEXT_HTML_UTF_16BE

TEXT_HTML_UTF_16BE occurences:
javax.print.TEXT_HTML_UTF_16BE
javax.print.TEXT_HTML_UTF_16BE
javax.print.TEXT_HTML_UTF_16BE


Occurences of TEXT_HTML_UTF_16LE

TEXT_HTML_UTF_16LE occurences:
javax.print.TEXT_HTML_UTF_16LE
javax.print.TEXT_HTML_UTF_16LE
javax.print.TEXT_HTML_UTF_16LE


Occurences of TEXT_HTML_UTF_8

TEXT_HTML_UTF_8 occurences:
javax.print.TEXT_HTML_UTF_8
javax.print.TEXT_HTML_UTF_8
javax.print.TEXT_HTML_UTF_8


Occurences of TEXT_PLAIN

TEXT_PLAIN occurences:
javax.print.TEXT_PLAIN
javax.print.TEXT_PLAIN
javax.print.TEXT_PLAIN


Occurences of TEXT_PLAIN_HOST

TEXT_PLAIN_HOST occurences:
javax.print.TEXT_PLAIN_HOST
javax.print.TEXT_PLAIN_HOST
javax.print.TEXT_PLAIN_HOST


Occurences of TEXT_PLAIN_US_ASCII

TEXT_PLAIN_US_ASCII occurences:
javax.print.TEXT_PLAIN_US_ASCII
javax.print.TEXT_PLAIN_US_ASCII
javax.print.TEXT_PLAIN_US_ASCII


Occurences of TEXT_PLAIN_UTF_16

TEXT_PLAIN_UTF_16 occurences:
javax.print.TEXT_PLAIN_UTF_16
javax.print.TEXT_PLAIN_UTF_16
javax.print.TEXT_PLAIN_UTF_16


Occurences of TEXT_PLAIN_UTF_16BE

TEXT_PLAIN_UTF_16BE occurences:
javax.print.TEXT_PLAIN_UTF_16BE
javax.print.TEXT_PLAIN_UTF_16BE
javax.print.TEXT_PLAIN_UTF_16BE


Occurences of TEXT_PLAIN_UTF_16LE

TEXT_PLAIN_UTF_16LE occurences:
javax.print.TEXT_PLAIN_UTF_16LE
javax.print.TEXT_PLAIN_UTF_16LE
javax.print.TEXT_PLAIN_UTF_16LE


Occurences of TEXT_PLAIN_UTF_8

TEXT_PLAIN_UTF_8 occurences:
javax.print.TEXT_PLAIN_UTF_8
javax.print.TEXT_PLAIN_UTF_8
javax.print.TEXT_PLAIN_UTF_8


Occurences of THAI

THAI occurences:
java.awt.font.THAI
java.lang.THAI


Occurences of The "Hello World" Example

The "Hello World" Example occurences:
The "Hello World" Example
The "Hello World" Example


Occurences of The Extension Mechanism

The Extension Mechanism occurences:
The Extension Mechanism
The Extension Mechanism


Occurences of The Invocation API

The Invocation API occurences:
The Invocation API
The Invocation API


Occurences of the_activator

the_activator occurences:
org.omg.PortableServer.POAOperations.the_activator()
org.omg.PortableServer.POAOperations.the_activator(org.omg.PortableServer.AdapterActivator)


Occurences of thisObject

thisObject occurences:
com.sun.jdi.StackFrame.thisObject()
javax.rmi.CORBA.Tie.thisObject()


Occurences of thread

thread occurences:
com.sun.jdi.event.ClassPrepareEvent.thread()
com.sun.jdi.event.LocatableEvent.thread()
com.sun.jdi.event.MonitorContendedEnteredEvent.thread()
com.sun.jdi.event.MonitorContendedEnterEvent.thread()
com.sun.jdi.event.MonitorWaitedEvent.thread()
com.sun.jdi.event.MonitorWaitEvent.thread()
com.sun.jdi.event.ThreadDeathEvent.thread()
com.sun.jdi.event.ThreadStartEvent.thread()
com.sun.jdi.event.VMStartEvent.thread()
com.sun.jdi.MonitorInfo.thread()
com.sun.jdi.request.StepRequest.thread()
com.sun.jdi.StackFrame.thread()


Occurences of Thread (constructors)

Thread (constructors) occurences:
java.lang.Thread()
java.lang.Thread(java.lang.Runnable)
java.lang.Thread(java.lang.Runnable, java.lang.String)
java.lang.Thread(java.lang.String)
java.lang.Thread(java.lang.ThreadGroup, java.lang.Runnable)
java.lang.Thread(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String)
java.lang.Thread(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String, long)
java.lang.Thread(java.lang.ThreadGroup, java.lang.String)


Occurences of ThreadGroup (constructors)

ThreadGroup (constructors) occurences:
java.lang.ThreadGroup(java.lang.String)
java.lang.ThreadGroup(java.lang.ThreadGroup, java.lang.String)


Occurences of ThreadPoolExecutor (constructors)

ThreadPoolExecutor (constructors) occurences:
java.util.concurrent.ThreadPoolExecutor(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue)
java.util.concurrent.ThreadPoolExecutor(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue, java.util.concurrent.RejectedExecutionHandler)
java.util.concurrent.ThreadPoolExecutor(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue, java.util.concurrent.ThreadFactory)
java.util.concurrent.ThreadPoolExecutor(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler)


Occurences of Throwable (constructors)

Throwable (constructors) occurences:
java.lang.Throwable()
java.lang.Throwable(java.lang.String)
java.lang.Throwable(java.lang.String, java.lang.Throwable)
java.lang.Throwable(java.lang.Throwable)


Occurences of thumbColor

thumbColor occurences:
javax.swing.plaf.basic.thumbColor
javax.swing.plaf.metal.thumbColor


Occurences of thumbnailComplete

thumbnailComplete occurences:
javax.imageio.event.IIOReadProgressListener.thumbnailComplete(javax.imageio.ImageReader)
javax.imageio.event.IIOWriteProgressListener.thumbnailComplete(javax.imageio.ImageWriter)


Occurences of thumbnailProgress

thumbnailProgress occurences:
javax.imageio.event.IIOReadProgressListener.thumbnailProgress(javax.imageio.ImageReader, float)
javax.imageio.event.IIOWriteProgressListener.thumbnailProgress(javax.imageio.ImageWriter, float)


Occurences of thumbnailStarted

thumbnailStarted occurences:
javax.imageio.event.IIOReadProgressListener.thumbnailStarted(javax.imageio.ImageReader, int, int)
javax.imageio.event.IIOWriteProgressListener.thumbnailStarted(javax.imageio.ImageWriter, int, int)


Occurences of thumbRect

thumbRect occurences:
javax.swing.plaf.basic.thumbRect
javax.swing.plaf.basic.thumbRect


Occurences of TIBETAN

TIBETAN occurences:
java.awt.font.TIBETAN
java.lang.TIBETAN


Occurences of TIME

TIME occurences:
java.sql.TIME
javax.xml.datatype.TIME


Occurences of Time (constructors)

Time (constructors) occurences:
java.sql.Time(int, int, int)
java.sql.Time(long)


Occurences of TimeLimitExceededException (constructors)

TimeLimitExceededException (constructors) occurences:
javax.naming.TimeLimitExceededException()
javax.naming.TimeLimitExceededException(java.lang.String)


Occurences of TIMEOUT (constructors)

TIMEOUT (constructors) occurences:
org.omg.CORBA.TIMEOUT()
org.omg.CORBA.TIMEOUT(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.TIMEOUT(java.lang.String)
org.omg.CORBA.TIMEOUT(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of TimeoutException (constructors)

TimeoutException (constructors) occurences:
java.util.concurrent.TimeoutException()
java.util.concurrent.TimeoutException(java.lang.String)


Occurences of timer

timer occurences:
javax.management.timer
javax.swing.plaf.basic.timer
javax.swing.tree.timer


Occurences of Timer

Timer occurences:
java.util.Timer
javax.management.timer.Timer
javax.swing.Timer


Occurences of Timer (constructors)

Timer (constructors) occurences:
java.util.Timer()
java.util.Timer(boolean)
java.util.Timer(java.lang.String)
java.util.Timer(java.lang.String, boolean)
javax.management.timer.Timer()
javax.swing.Timer(int, java.awt.event.ActionListener)


Occurences of Timestamp

Timestamp occurences:
java.security.Timestamp
java.sql.Timestamp


Occurences of Timestamp (constructors)

Timestamp (constructors) occurences:
java.security.Timestamp(java.util.Date, java.security.cert.CertPath)
java.sql.Timestamp(int, int, int, int, int, int, int)
java.sql.Timestamp(long)


Occurences of title

title occurences:
javax.swing.border.title
javax.swing.text.html.parser.title
javax.swing.title


Occurences of TITLE

TITLE occurences:
javax.swing.text.html.TITLE
javax.swing.text.html.TITLE


Occurences of TitledBorder (constructors)

TitledBorder (constructors) occurences:
javax.swing.border.TitledBorder(java.lang.String)
javax.swing.border.TitledBorder(javax.swing.border.Border)
javax.swing.border.TitledBorder(javax.swing.border.Border, java.lang.String)
javax.swing.border.TitledBorder(javax.swing.border.Border, java.lang.String, int, int)
javax.swing.border.TitledBorder(javax.swing.border.Border, java.lang.String, int, int, java.awt.Font)
javax.swing.border.TitledBorder(javax.swing.border.Border, java.lang.String, int, int, java.awt.Font, java.awt.Color)


Occurences of toArray

toArray occurences:
java.awt.dnd.DragGestureEvent.toArray()
java.awt.dnd.DragGestureEvent.toArray(java.lang.Object[])
java.beans.beancontext.BeanContextMembershipEvent.toArray()
java.beans.beancontext.BeanContextSupport.toArray()
java.beans.beancontext.BeanContextSupport.toArray(java.lang.Object[])
java.util.AbstractCollection.toArray()
java.util.AbstractCollection.toArray(java.lang.Object[])
java.util.AbstractCollection.toArray(T[])
java.util.ArrayDeque.toArray()
java.util.ArrayDeque.toArray(java.lang.Object[])
java.util.ArrayDeque.toArray(T[])
java.util.ArrayList.toArray()
java.util.ArrayList.toArray(java.lang.Object[])
java.util.ArrayList.toArray(T[])
java.util.Collection.toArray()
java.util.Collection.toArray(java.lang.Object[])
java.util.Collection.toArray(T[])
java.util.concurrent.ArrayBlockingQueue.toArray()
java.util.concurrent.ArrayBlockingQueue.toArray(java.lang.Object[])
java.util.concurrent.ArrayBlockingQueue.toArray(T[])
java.util.concurrent.ConcurrentLinkedQueue.toArray()
java.util.concurrent.ConcurrentLinkedQueue.toArray(java.lang.Object[])
java.util.concurrent.ConcurrentLinkedQueue.toArray(T[])
java.util.concurrent.CopyOnWriteArrayList.toArray()
java.util.concurrent.CopyOnWriteArrayList.toArray(java.lang.Object[])
java.util.concurrent.CopyOnWriteArrayList.toArray(T[])
java.util.concurrent.CopyOnWriteArraySet.toArray()
java.util.concurrent.CopyOnWriteArraySet.toArray(java.lang.Object[])
java.util.concurrent.CopyOnWriteArraySet.toArray(T[])
java.util.concurrent.DelayQueue.toArray()
java.util.concurrent.DelayQueue.toArray(java.lang.Object[])
java.util.concurrent.DelayQueue.toArray(T[])
java.util.concurrent.LinkedBlockingDeque.toArray()
java.util.concurrent.LinkedBlockingDeque.toArray(java.lang.Object[])
java.util.concurrent.LinkedBlockingDeque.toArray(T[])
java.util.concurrent.LinkedBlockingQueue.toArray()
java.util.concurrent.LinkedBlockingQueue.toArray(java.lang.Object[])
java.util.concurrent.LinkedBlockingQueue.toArray(T[])
java.util.concurrent.PriorityBlockingQueue.toArray()
java.util.concurrent.PriorityBlockingQueue.toArray(java.lang.Object[])
java.util.concurrent.PriorityBlockingQueue.toArray(T[])
java.util.concurrent.SynchronousQueue.toArray()
java.util.concurrent.SynchronousQueue.toArray(java.lang.Object[])
java.util.concurrent.SynchronousQueue.toArray(T[])
java.util.LinkedList.toArray()
java.util.LinkedList.toArray(java.lang.Object[])
java.util.LinkedList.toArray(T[])
java.util.List.toArray()
java.util.List.toArray(java.lang.Object[])
java.util.List.toArray(T[])
java.util.PriorityQueue.toArray()
java.util.PriorityQueue.toArray(java.lang.Object[])
java.util.PriorityQueue.toArray(T[])
java.util.Set.toArray()
java.util.Set.toArray(java.lang.Object[])
java.util.Set.toArray(T[])
java.util.Vector.toArray()
java.util.Vector.toArray(java.lang.Object[])
java.util.Vector.toArray(T[])
javax.accessibility.AccessibleRelationSet.toArray()
javax.accessibility.AccessibleStateSet.toArray()
javax.print.attribute.AttributeSet.toArray()
javax.print.attribute.HashAttributeSet.toArray()
javax.swing.DefaultListModel.toArray()


Occurences of toASCII

toASCII occurences:
java.net.IDN.toASCII(java.lang.String)
java.net.IDN.toASCII(java.lang.String, int)


Occurences of toBack

toBack occurences:
java.awt.Dialog.toBack()
java.awt.Window.toBack()
javax.swing.JInternalFrame.toBack()


Occurences of toBinaryString

toBinaryString occurences:
java.lang.Integer.toBinaryString(int)
java.lang.Long.toBinaryString(long)


Occurences of toByteArray

toByteArray occurences:
java.io.ByteArrayOutputStream.toByteArray()
java.math.BigInteger.toByteArray()
java.text.CollationKey.toByteArray()


Occurences of toCharArray

toCharArray occurences:
java.io.CharArrayWriter.toCharArray()
java.lang.String.toCharArray()


Occurences of toChars

toChars occurences:
java.lang.Character.toChars(int)
java.lang.Character.toChars(int, char[], int)


Occurences of toCIEXYZ

toCIEXYZ occurences:
java.awt.color.ColorSpace.toCIEXYZ(float[])
java.awt.color.ICC_ColorSpace.toCIEXYZ(float[])


Occurences of toCollection

toCollection occurences:
javax.sql.rowset.CachedRowSet.toCollection()
javax.sql.rowset.CachedRowSet.toCollection(int)
javax.sql.rowset.CachedRowSet.toCollection(java.lang.String)


Occurences of toDegrees

toDegrees occurences:
java.lang.Math.toDegrees(double)
java.lang.StrictMath.toDegrees(double)


Occurences of toDisplayString

toDisplayString occurences:
javax.accessibility.AccessibleBundle.toDisplayString()
javax.accessibility.AccessibleBundle.toDisplayString(java.lang.String, java.util.Locale)
javax.accessibility.AccessibleBundle.toDisplayString(java.util.Locale)


Occurences of toExternalForm

toExternalForm occurences:
java.net.URL.toExternalForm()
java.net.URLStreamHandler.toExternalForm(java.net.URL)


Occurences of toFront

toFront occurences:
java.awt.Window.toFront()
javax.swing.JInternalFrame.toFront()


Occurences of toGenericString

toGenericString occurences:
java.lang.reflect.Constructor.toGenericString()
java.lang.reflect.Field.toGenericString()
java.lang.reflect.Method.toGenericString()


Occurences of toggleSortOrder

toggleSortOrder occurences:
javax.swing.DefaultRowSorter.toggleSortOrder(int)
javax.swing.RowSorter.toggleSortOrder(int)


Occurences of TOGGLE_BUTTON

TOGGLE_BUTTON occurences:
javax.accessibility.TOGGLE_BUTTON
javax.swing.plaf.synth.TOGGLE_BUTTON


Occurences of toGregorianCalendar

toGregorianCalendar occurences:
javax.xml.datatype.XMLGregorianCalendar.toGregorianCalendar()
javax.xml.datatype.XMLGregorianCalendar.toGregorianCalendar(java.util.TimeZone, java.util.Locale, javax.xml.datatype.XMLGregorianCalendar)


Occurences of toHexString

toHexString occurences:
java.lang.Double.toHexString(double)
java.lang.Float.toHexString(float)
java.lang.Integer.toHexString(int)
java.lang.Long.toHexString(long)


Occurences of toJMXConnector

toJMXConnector occurences:
javax.management.remote.JMXConnectorServer.toJMXConnector(java.util.Map)
javax.management.remote.JMXConnectorServerMBean.toJMXConnector(java.util.Map)
javax.management.remote.rmi.RMIConnectorServer.toJMXConnector(java.util.Map)


Occurences of toLocalizedPattern

toLocalizedPattern occurences:
java.text.DecimalFormat.toLocalizedPattern()
java.text.SimpleDateFormat.toLocalizedPattern()


Occurences of toLowerCase

toLowerCase occurences:
java.lang.Character.toLowerCase(char)
java.lang.Character.toLowerCase(int)
java.lang.String.toLowerCase()
java.lang.String.toLowerCase(java.util.Locale)


Occurences of toOctalString

toOctalString occurences:
java.lang.Integer.toOctalString(int)
java.lang.Long.toOctalString(long)


Occurences of toolBar

toolBar occurences:
javax.swing.plaf.basic.toolBar
javax.swing.plaf.basic.toolBar


Occurences of TOOL_BAR

TOOL_BAR occurences:
javax.accessibility.TOOL_BAR
javax.swing.plaf.synth.TOOL_BAR


Occurences of TOOL_TIP

TOOL_TIP occurences:
javax.accessibility.TOOL_TIP
javax.swing.plaf.synth.TOOL_TIP


Occurences of TooManyListenersException (constructors)

TooManyListenersException (constructors) occurences:
java.util.TooManyListenersException()
java.util.TooManyListenersException(java.lang.String)


Occurences of TOP

TOP occurences:
javax.print.attribute.standard.TOP
javax.swing.border.TOP
javax.swing.TOP
javax.swing.TOP


Occurences of top

top occurences:
java.awt.top
javax.swing.border.top


Occurences of toPattern

toPattern occurences:
java.text.ChoiceFormat.toPattern()
java.text.DecimalFormat.toPattern()
java.text.MessageFormat.toPattern()
java.text.SimpleDateFormat.toPattern()


Occurences of TOP_ALIGNMENT

TOP_ALIGNMENT occurences:
java.awt.font.TOP_ALIGNMENT
java.awt.TOP_ALIGNMENT


Occurences of toRadians

toRadians occurences:
java.lang.Math.toRadians(double)
java.lang.StrictMath.toRadians(double)


Occurences of toRGB

toRGB occurences:
java.awt.color.ColorSpace.toRGB(float[])
java.awt.color.ICC_ColorSpace.toRGB(float[])


Occurences of toString

toString occurences:
com.sun.javadoc.AnnotationValue.toString()
com.sun.javadoc.Parameter.toString()
com.sun.javadoc.SourcePosition.toString()
com.sun.javadoc.Tag.toString()
com.sun.javadoc.Type.toString()
com.sun.jdi.Mirror.toString()
com.sun.mirror.declaration.AnnotationValue.toString()
com.sun.mirror.declaration.Modifier.toString()
com.sun.mirror.type.TypeMirror.toString()
com.sun.source.util.TaskEvent.toString()
com.sun.tools.attach.VirtualMachine.toString()
com.sun.tools.attach.VirtualMachineDescriptor.toString()
com.sun.tools.doclets.Taglet.toString(com.sun.javadoc.Tag)
com.sun.tools.doclets.Taglet.toString(com.sun.javadoc.Tag[])
java.awt.AWTEvent.toString()
java.awt.AWTKeyStroke.toString()
java.awt.BorderLayout.toString()
java.awt.BufferCapabilities.FlipContents.toString()
java.awt.CardLayout.toString()
java.awt.CheckboxGroup.toString()
java.awt.Color.toString()
java.awt.Component.toString()
java.awt.Cursor.toString()
java.awt.datatransfer.DataFlavor.toString()
java.awt.Dimension.toString()
java.awt.Event.toString()
java.awt.FlowLayout.toString()
java.awt.Font.toString()
java.awt.font.NumericShaper.toString()
java.awt.font.TextHitInfo.toString()
java.awt.font.TextLayout.toString()
java.awt.FontMetrics.toString()
java.awt.geom.AffineTransform.toString()
java.awt.geom.Point2D.Double.toString()
java.awt.geom.Point2D.Float.toString()
java.awt.geom.Rectangle2D.Double.toString()
java.awt.geom.Rectangle2D.Float.toString()
java.awt.Graphics.toString()
java.awt.GridBagLayout.toString()
java.awt.GridLayout.toString()
java.awt.image.BufferedImage.toString()
java.awt.image.ColorModel.toString()
java.awt.image.DirectColorModel.toString()
java.awt.image.IndexColorModel.toString()
java.awt.Insets.toString()
java.awt.JobAttributes.toString()
java.awt.JobAttributes.DefaultSelectionType.toString()
java.awt.JobAttributes.DestinationType.toString()
java.awt.JobAttributes.DialogType.toString()
java.awt.JobAttributes.MultipleDocumentHandlingType.toString()
java.awt.JobAttributes.SidesType.toString()
java.awt.MenuComponent.toString()
java.awt.MenuShortcut.toString()
java.awt.PageAttributes.toString()
java.awt.PageAttributes.ColorType.toString()
java.awt.PageAttributes.MediaType.toString()
java.awt.PageAttributes.OrientationRequestedType.toString()
java.awt.PageAttributes.OriginType.toString()
java.awt.PageAttributes.PrintQualityType.toString()
java.awt.Point.toString()
java.awt.Rectangle.toString()
java.awt.RenderingHints.toString()
java.awt.Robot.toString()
java.awt.ScrollPaneAdjustable.toString()
java.awt.SystemColor.toString()
java.beans.Expression.toString()
java.beans.Statement.toString()
java.io.ByteArrayOutputStream.toString()
java.io.ByteArrayOutputStream.toString(int)
java.io.ByteArrayOutputStream.toString(java.lang.String)
java.io.CharArrayWriter.toString()
java.io.File.toString()
java.io.ObjectStreamClass.toString()
java.io.ObjectStreamField.toString()
java.io.StreamTokenizer.toString()
java.io.StringWriter.toString()
java.lang.annotation.Annotation.toString()
java.lang.Boolean.toString()
java.lang.Boolean.toString(boolean)
java.lang.Byte.toString()
java.lang.Byte.toString(byte)
java.lang.Character.toString()
java.lang.Character.toString(char)
java.lang.Character.Subset.toString()
java.lang.CharSequence.toString()
java.lang.Class.toString()
java.lang.Double.toString()
java.lang.Double.toString(double)
java.lang.Enum.toString()
java.lang.Float.toString()
java.lang.Float.toString(float)
java.lang.Integer.toString()
java.lang.Integer.toString(int)
java.lang.Integer.toString(int, int)
java.lang.Long.toString()
java.lang.Long.toString(long)
java.lang.Long.toString(long, int)
java.lang.management.LockInfo.toString()
java.lang.management.MemoryType.toString()
java.lang.management.MemoryUsage.toString()
java.lang.management.ThreadInfo.toString()
java.lang.Object.toString()
java.lang.Package.toString()
java.lang.reflect.Constructor.toString()
java.lang.reflect.Field.toString()
java.lang.reflect.Method.toString()
java.lang.reflect.Modifier.toString(int)
java.lang.Short.toString()
java.lang.Short.toString(short)
java.lang.StackTraceElement.toString()
java.lang.String.toString()
java.lang.StringBuffer.toString()
java.lang.StringBuilder.toString()
java.lang.Thread.toString()
java.lang.ThreadGroup.toString()
java.lang.Throwable.toString()
java.math.BigDecimal.toString()
java.math.BigInteger.toString()
java.math.BigInteger.toString(int)
java.math.MathContext.toString()
java.net.HttpCookie.toString()
java.net.InetAddress.toString()
java.net.InetSocketAddress.toString()
java.net.InterfaceAddress.toString()
java.net.NetworkInterface.toString()
java.net.Proxy.toString()
java.net.ServerSocket.toString()
java.net.Socket.toString()
java.net.SocketImpl.toString()
java.net.URI.toString()
java.net.URL.toString()
java.net.URLConnection.toString()
java.nio.ByteBuffer.toString()
java.nio.ByteOrder.toString()
java.nio.channels.FileChannel.MapMode.toString()
java.nio.channels.FileLock.toString()
java.nio.CharBuffer.toString()
java.nio.charset.Charset.toString()
java.nio.charset.CoderResult.toString()
java.nio.charset.CodingErrorAction.toString()
java.nio.DoubleBuffer.toString()
java.nio.FloatBuffer.toString()
java.nio.IntBuffer.toString()
java.nio.LongBuffer.toString()
java.nio.ShortBuffer.toString()
java.rmi.dgc.VMID.toString()
java.rmi.server.LogStream.toString()
java.rmi.server.ObjID.toString()
java.rmi.server.Operation.toString()
java.rmi.server.RemoteObject.toString()
java.rmi.server.UID.toString()
java.security.acl.Acl.toString()
java.security.acl.AclEntry.toString()
java.security.acl.Permission.toString()
java.security.AlgorithmParameters.toString()
java.security.cert.Certificate.toString()
java.security.cert.CertPath.toString()
java.security.cert.CollectionCertStoreParameters.toString()
java.security.cert.CRL.toString()
java.security.cert.LDAPCertStoreParameters.toString()
java.security.cert.PKIXBuilderParameters.toString()
java.security.cert.PKIXCertPathBuilderResult.toString()
java.security.cert.PKIXCertPathValidatorResult.toString()
java.security.cert.PKIXParameters.toString()
java.security.cert.PolicyQualifierInfo.toString()
java.security.cert.TrustAnchor.toString()
java.security.cert.X509CertSelector.toString()
java.security.cert.X509CRLEntry.toString()
java.security.cert.X509CRLSelector.toString()
java.security.Certificate.toString(boolean)
java.security.CodeSigner.toString()
java.security.CodeSource.toString()
java.security.DigestInputStream.toString()
java.security.DigestOutputStream.toString()
java.security.Identity.toString()
java.security.Identity.toString(boolean)
java.security.IdentityScope.toString()
java.security.KeyStore.PrivateKeyEntry.toString()
java.security.KeyStore.SecretKeyEntry.toString()
java.security.KeyStore.TrustedCertificateEntry.toString()
java.security.MessageDigest.toString()
java.security.Permission.toString()
java.security.PermissionCollection.toString()
java.security.Principal.toString()
java.security.PrivilegedActionException.toString()
java.security.ProtectionDomain.toString()
java.security.Provider.toString()
java.security.Provider.Service.toString()
java.security.Signature.toString()
java.security.Signer.toString()
java.security.Timestamp.toString()
java.security.UnresolvedPermission.toString()
java.sql.Date.toString()
java.sql.RowId.toString()
java.sql.Time.toString()
java.sql.Timestamp.toString()
java.text.Annotation.toString()
java.text.AttributedCharacterIterator.Attribute.toString()
java.text.Bidi.toString()
java.text.FieldPosition.toString()
java.text.ParsePosition.toString()
java.util.AbstractCollection.toString()
java.util.AbstractMap.toString()
java.util.AbstractMap.SimpleEntry.toString()
java.util.AbstractMap.SimpleImmutableEntry.toString()
java.util.Arrays.toString(boolean[])
java.util.Arrays.toString(byte[])
java.util.Arrays.toString(char[])
java.util.Arrays.toString(double[])
java.util.Arrays.toString(float[])
java.util.Arrays.toString(int[])
java.util.Arrays.toString(java.lang.Object[])
java.util.Arrays.toString(long[])
java.util.Arrays.toString(short[])
java.util.BitSet.toString()
java.util.Calendar.toString()
java.util.concurrent.ArrayBlockingQueue.toString()
java.util.concurrent.atomic.AtomicBoolean.toString()
java.util.concurrent.atomic.AtomicInteger.toString()
java.util.concurrent.atomic.AtomicIntegerArray.toString()
java.util.concurrent.atomic.AtomicLong.toString()
java.util.concurrent.atomic.AtomicLongArray.toString()
java.util.concurrent.atomic.AtomicReference.toString()
java.util.concurrent.atomic.AtomicReferenceArray.toString()
java.util.concurrent.CopyOnWriteArrayList.toString()
java.util.concurrent.CountDownLatch.toString()
java.util.concurrent.LinkedBlockingDeque.toString()
java.util.concurrent.LinkedBlockingQueue.toString()
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.toString()
java.util.concurrent.locks.AbstractQueuedSynchronizer.toString()
java.util.concurrent.locks.ReentrantLock.toString()
java.util.concurrent.locks.ReentrantReadWriteLock.toString()
java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.toString()
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.toString()
java.util.concurrent.PriorityBlockingQueue.toString()
java.util.concurrent.Semaphore.toString()
java.util.Currency.toString()
java.util.Date.toString()
java.util.EventObject.toString()
java.util.Formatter.toString()
java.util.Hashtable.toString()
java.util.jar.Attributes.Name.toString()
java.util.Locale.toString()
java.util.logging.Level.toString()
java.util.prefs.AbstractPreferences.toString()
java.util.prefs.Preferences.toString()
java.util.regex.Matcher.toString()
java.util.regex.Pattern.toString()
java.util.Scanner.toString()
java.util.ServiceLoader.toString()
java.util.SimpleTimeZone.toString()
java.util.UUID.toString()
java.util.Vector.toString()
java.util.zip.ZipEntry.toString()
javax.accessibility.AccessibleBundle.toString()
javax.accessibility.AccessibleRelationSet.toString()
javax.accessibility.AccessibleStateSet.toString()
javax.activation.MimeType.toString()
javax.activation.MimeTypeParameterList.toString()
javax.imageio.plugins.jpeg.JPEGHuffmanTable.toString()
javax.imageio.plugins.jpeg.JPEGQTable.toString()
javax.lang.model.element.AnnotationValue.toString()
javax.lang.model.element.Modifier.toString()
javax.lang.model.type.TypeMirror.toString()
javax.management.Attribute.toString()
javax.management.AttributeValueExp.toString()
javax.management.BadAttributeValueExpException.toString()
javax.management.BadBinaryOpValueExpException.toString()
javax.management.BadStringOperationException.toString()
javax.management.ImmutableDescriptor.toString()
javax.management.MBeanAttributeInfo.toString()
javax.management.MBeanConstructorInfo.toString()
javax.management.MBeanInfo.toString()
javax.management.MBeanNotificationInfo.toString()
javax.management.MBeanOperationInfo.toString()
javax.management.MBeanParameterInfo.toString()
javax.management.modelmbean.DescriptorSupport.toString()
javax.management.modelmbean.ModelMBeanAttributeInfo.toString()
javax.management.modelmbean.ModelMBeanConstructorInfo.toString()
javax.management.modelmbean.ModelMBeanNotificationInfo.toString()
javax.management.modelmbean.ModelMBeanOperationInfo.toString()
javax.management.Notification.toString()
javax.management.ObjectInstance.toString()
javax.management.ObjectName.toString()
javax.management.openmbean.ArrayType.toString()
javax.management.openmbean.CompositeData.toString()
javax.management.openmbean.CompositeDataSupport.toString()
javax.management.openmbean.CompositeType.toString()
javax.management.openmbean.OpenMBeanAttributeInfo.toString()
javax.management.openmbean.OpenMBeanAttributeInfoSupport.toString()
javax.management.openmbean.OpenMBeanConstructorInfo.toString()
javax.management.openmbean.OpenMBeanConstructorInfoSupport.toString()
javax.management.openmbean.OpenMBeanInfo.toString()
javax.management.openmbean.OpenMBeanInfoSupport.toString()
javax.management.openmbean.OpenMBeanOperationInfo.toString()
javax.management.openmbean.OpenMBeanOperationInfoSupport.toString()
javax.management.openmbean.OpenMBeanParameterInfo.toString()
javax.management.openmbean.OpenMBeanParameterInfoSupport.toString()
javax.management.openmbean.OpenType.toString()
javax.management.openmbean.SimpleType.toString()
javax.management.openmbean.TabularData.toString()
javax.management.openmbean.TabularDataSupport.toString()
javax.management.openmbean.TabularType.toString()
javax.management.relation.Role.toString()
javax.management.relation.RoleInfo.toString()
javax.management.relation.RoleUnresolved.toString()
javax.management.remote.JMXPrincipal.toString()
javax.management.remote.JMXServiceURL.toString()
javax.management.remote.NotificationResult.toString()
javax.management.remote.rmi.RMIConnectionImpl.toString()
javax.management.remote.rmi.RMIConnector.toString()
javax.management.remote.TargetedNotification.toString()
javax.management.StringValueExp.toString()
javax.naming.BinaryRefAddr.toString()
javax.naming.Binding.toString()
javax.naming.CompositeName.toString()
javax.naming.CompoundName.toString()
javax.naming.directory.AttributeModificationException.toString()
javax.naming.directory.BasicAttribute.toString()
javax.naming.directory.BasicAttributes.toString()
javax.naming.directory.ModificationItem.toString()
javax.naming.directory.SearchResult.toString()
javax.naming.ldap.LdapName.toString()
javax.naming.ldap.Rdn.toString()
javax.naming.LinkException.toString()
javax.naming.LinkException.toString(boolean)
javax.naming.NameClassPair.toString()
javax.naming.NamingException.toString()
javax.naming.NamingException.toString(boolean)
javax.naming.RefAddr.toString()
javax.naming.Reference.toString()
javax.net.ssl.SSLEngineResult.toString()
javax.print.attribute.DateTimeSyntax.toString()
javax.print.attribute.EnumSyntax.toString()
javax.print.attribute.IntegerSyntax.toString()
javax.print.attribute.ResolutionSyntax.toString()
javax.print.attribute.ResolutionSyntax.toString(int, java.lang.String)
javax.print.attribute.SetOfIntegerSyntax.toString()
javax.print.attribute.Size2DSyntax.toString()
javax.print.attribute.Size2DSyntax.toString(int, java.lang.String)
javax.print.attribute.standard.MediaPrintableArea.toString()
javax.print.attribute.standard.MediaPrintableArea.toString(int, java.lang.String)
javax.print.attribute.TextSyntax.toString()
javax.print.attribute.URISyntax.toString()
javax.print.DocFlavor.toString()
javax.print.event.PrintEvent.toString()
javax.rmi.CORBA.Stub.toString()
javax.rmi.CORBA.StubDelegate.toString(javax.rmi.CORBA.Stub)
javax.security.auth.kerberos.KerberosKey.toString()
javax.security.auth.kerberos.KerberosPrincipal.toString()
javax.security.auth.kerberos.KerberosTicket.toString()
javax.security.auth.login.AppConfigurationEntry.LoginModuleControlFlag.toString()
javax.security.auth.Subject.toString()
javax.security.auth.x500.X500Principal.toString()
javax.security.cert.Certificate.toString()
javax.security.sasl.SaslException.toString()
javax.sound.midi.MidiDevice.Info.toString()
javax.sound.midi.Sequencer.SyncMode.toString()
javax.sound.sampled.AudioFileFormat.toString()
javax.sound.sampled.AudioFileFormat.Type.toString()
javax.sound.sampled.AudioFormat.toString()
javax.sound.sampled.AudioFormat.Encoding.toString()
javax.sound.sampled.BooleanControl.toString()
javax.sound.sampled.CompoundControl.toString()
javax.sound.sampled.Control.toString()
javax.sound.sampled.Control.Type.toString()
javax.sound.sampled.DataLine.Info.toString()
javax.sound.sampled.EnumControl.toString()
javax.sound.sampled.FloatControl.toString()
javax.sound.sampled.Line.Info.toString()
javax.sound.sampled.LineEvent.toString()
javax.sound.sampled.LineEvent.Type.toString()
javax.sound.sampled.Mixer.Info.toString()
javax.sound.sampled.Port.Info.toString()
javax.sound.sampled.ReverbType.toString()
javax.swing.DefaultBoundedRangeModel.toString()
javax.swing.DefaultListModel.toString()
javax.swing.DefaultListSelectionModel.toString()
javax.swing.event.DocumentEvent.EventType.toString()
javax.swing.event.EventListenerList.toString()
javax.swing.event.HyperlinkEvent.EventType.toString()
javax.swing.event.ListDataEvent.toString()
javax.swing.event.ListSelectionEvent.toString()
javax.swing.event.TreeModelEvent.toString()
javax.swing.filechooser.FileNameExtensionFilter.toString()
javax.swing.GroupLayout.toString()
javax.swing.ImageIcon.toString()
javax.swing.JList.DropLocation.toString()
javax.swing.JTable.DropLocation.toString()
javax.swing.JTree.DropLocation.toString()
javax.swing.LookAndFeel.toString()
javax.swing.plaf.synth.ColorType.toString()
javax.swing.plaf.synth.Region.toString()
javax.swing.RepaintManager.toString()
javax.swing.SizeRequirements.toString()
javax.swing.table.TableStringConverter.toString(javax.swing.table.TableModel, int, int)
javax.swing.text.AbstractDocument.BranchElement.toString()
javax.swing.text.AbstractDocument.DefaultDocumentEvent.toString()
javax.swing.text.AbstractDocument.LeafElement.toString()
javax.swing.text.DefaultCaret.toString()
javax.swing.text.DefaultStyledDocument.ElementSpec.toString()
javax.swing.text.html.CSS.Attribute.toString()
javax.swing.text.html.HTML.Attribute.toString()
javax.swing.text.html.HTML.Tag.toString()
javax.swing.text.html.Option.toString()
javax.swing.text.html.parser.AttributeList.toString()
javax.swing.text.html.parser.ContentModel.toString()
javax.swing.text.html.parser.DTD.toString()
javax.swing.text.html.parser.Element.toString()
javax.swing.text.JTextComponent.DropLocation.toString()
javax.swing.text.Position.Bias.toString()
javax.swing.text.Segment.toString()
javax.swing.text.SimpleAttributeSet.toString()
javax.swing.text.StyleConstants.toString()
javax.swing.text.StyleContext.toString()
javax.swing.text.StyleContext.NamedStyle.toString()
javax.swing.text.StyleContext.SmallAttributeSet.toString()
javax.swing.text.TabSet.toString()
javax.swing.text.TabStop.toString()
javax.swing.TransferHandler.DropLocation.toString()
javax.swing.tree.DefaultMutableTreeNode.toString()
javax.swing.tree.DefaultTreeSelectionModel.toString()
javax.swing.tree.TreePath.toString()
javax.swing.UIManager.LookAndFeelInfo.toString()
javax.swing.undo.AbstractUndoableEdit.toString()
javax.swing.undo.CompoundEdit.toString()
javax.swing.undo.UndoableEditSupport.toString()
javax.swing.undo.UndoManager.toString()
javax.tools.SimpleJavaFileObject.toString()
javax.xml.bind.helpers.ValidationEventImpl.toString()
javax.xml.bind.helpers.ValidationEventLocatorImpl.toString()
javax.xml.bind.JAXBException.toString()
javax.xml.bind.TypeConstraintException.toString()
javax.xml.crypto.dsig.spec.XPathType.Filter.toString()
javax.xml.crypto.KeySelector.Purpose.toString()
javax.xml.datatype.DatatypeConstants.Field.toString()
javax.xml.datatype.Duration.toString()
javax.xml.datatype.XMLGregorianCalendar.toString()
javax.xml.namespace.QName.toString()
org.ietf.jgss.GSSException.toString()
org.ietf.jgss.GSSName.toString()
org.ietf.jgss.Oid.toString()
org.omg.CORBA.portable.Delegate.toString(org.omg.CORBA.Object)
org.omg.CORBA.portable.ObjectImpl.toString()
org.omg.CORBA.SystemException.toString()
org.xml.sax.SAXException.toString()


Occurences of toStub

toStub occurences:
java.rmi.server.RemoteObject.toStub(java.rmi.Remote)
javax.management.remote.rmi.RMIIIOPServerImpl.toStub()
javax.management.remote.rmi.RMIJRMPServerImpl.toStub()
javax.management.remote.rmi.RMIServerImpl.toStub()
javax.rmi.CORBA.PortableRemoteObjectDelegate.toStub(java.rmi.Remote)
javax.rmi.PortableRemoteObject.toStub(java.rmi.Remote)


Occurences of toTitleCase

toTitleCase occurences:
java.lang.Character.toTitleCase(char)
java.lang.Character.toTitleCase(int)


Occurences of toUnicode

toUnicode occurences:
java.net.IDN.toUnicode(java.lang.String)
java.net.IDN.toUnicode(java.lang.String, int)


Occurences of toUpperCase

toUpperCase occurences:
java.lang.Character.toUpperCase(char)
java.lang.Character.toUpperCase(int)
java.lang.String.toUpperCase()
java.lang.String.toUpperCase(java.util.Locale)


Occurences of toUri

toUri occurences:
javax.tools.FileObject.toUri()
javax.tools.ForwardingFileObject.toUri()
javax.tools.SimpleJavaFileObject.toUri()


Occurences of toURI

toURI occurences:
java.io.File.toURI()
java.net.URL.toURI()


Occurences of toURL

toURL occurences:
java.io.File.toURL()
java.net.URI.toURL()


Occurences of toViewCoordinates

toViewCoordinates occurences:
javax.swing.JViewport.toViewCoordinates(java.awt.Dimension)
javax.swing.JViewport.toViewCoordinates(java.awt.Point)


Occurences of to_any

to_any occurences:
org.omg.CORBA.DynAny.to_any()
org.omg.DynamicAny.DynAnyOperations.to_any()
org.omg.DynamicAny._DynAnyStub.to_any()
org.omg.DynamicAny._DynArrayStub.to_any()
org.omg.DynamicAny._DynEnumStub.to_any()
org.omg.DynamicAny._DynFixedStub.to_any()
org.omg.DynamicAny._DynSequenceStub.to_any()
org.omg.DynamicAny._DynStructStub.to_any()
org.omg.DynamicAny._DynUnionStub.to_any()
org.omg.DynamicAny._DynValueStub.to_any()


Occurences of to_name

to_name occurences:
org.omg.CosNaming.NamingContextExtOperations.to_name(java.lang.String)
org.omg.CosNaming._NamingContextExtStub.to_name(java.lang.String)


Occurences of to_string

to_string occurences:
org.omg.CosNaming.NamingContextExtOperations.to_string(org.omg.CosNaming.NameComponent[])
org.omg.CosNaming._NamingContextExtStub.to_string(org.omg.CosNaming.NameComponent[])


Occurences of to_url

to_url occurences:
org.omg.CosNaming.NamingContextExtOperations.to_url(java.lang.String, java.lang.String)
org.omg.CosNaming._NamingContextExtStub.to_url(java.lang.String, java.lang.String)


Occurences of Tracing and Logging

Tracing and Logging occurences:
Tracing and Logging
Tracing and Logging


Occurences of trackListener

trackListener occurences:
javax.swing.plaf.basic.trackListener
javax.swing.plaf.basic.trackListener


Occurences of trackRect

trackRect occurences:
javax.swing.plaf.basic.trackRect
javax.swing.plaf.basic.trackRect


Occurences of TRAILING

TRAILING occurences:
java.awt.TRAILING
javax.swing.border.TRAILING
javax.swing.TRAILING
javax.swing.TRAILING


Occurences of TransactionRequiredException (constructors)

TransactionRequiredException (constructors) occurences:
javax.transaction.TransactionRequiredException()
javax.transaction.TransactionRequiredException(java.lang.String)


Occurences of TransactionRolledbackException (constructors)

TransactionRolledbackException (constructors) occurences:
javax.transaction.TransactionRolledbackException()
javax.transaction.TransactionRolledbackException(java.lang.String)


Occurences of TRANSACTION_MODE (constructors)

TRANSACTION_MODE (constructors) occurences:
org.omg.CORBA.TRANSACTION_MODE()
org.omg.CORBA.TRANSACTION_MODE(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.TRANSACTION_MODE(java.lang.String)
org.omg.CORBA.TRANSACTION_MODE(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of TRANSACTION_REQUIRED (constructors)

TRANSACTION_REQUIRED (constructors) occurences:
org.omg.CORBA.TRANSACTION_REQUIRED()
org.omg.CORBA.TRANSACTION_REQUIRED(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.TRANSACTION_REQUIRED(java.lang.String)
org.omg.CORBA.TRANSACTION_REQUIRED(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of TRANSACTION_ROLLEDBACK (constructors)

TRANSACTION_ROLLEDBACK (constructors) occurences:
org.omg.CORBA.TRANSACTION_ROLLEDBACK()
org.omg.CORBA.TRANSACTION_ROLLEDBACK(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.TRANSACTION_ROLLEDBACK(java.lang.String)
org.omg.CORBA.TRANSACTION_ROLLEDBACK(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of TRANSACTION_UNAVAILABLE (constructors)

TRANSACTION_UNAVAILABLE (constructors) occurences:
org.omg.CORBA.TRANSACTION_UNAVAILABLE()
org.omg.CORBA.TRANSACTION_UNAVAILABLE(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.TRANSACTION_UNAVAILABLE(java.lang.String)
org.omg.CORBA.TRANSACTION_UNAVAILABLE(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of transferFocusBackward

transferFocusBackward occurences:
java.awt.Component.transferFocusBackward()
java.awt.Container.transferFocusBackward()


Occurences of TransferHandler (constructors)

TransferHandler (constructors) occurences:
javax.swing.TransferHandler()
javax.swing.TransferHandler(java.lang.String)


Occurences of transform

transform occurences:
java.awt.geom.AffineTransform.transform(double[], int, double[], int, int)
java.awt.geom.AffineTransform.transform(double[], int, float[], int, int)
java.awt.geom.AffineTransform.transform(float[], int, double[], int, int)
java.awt.geom.AffineTransform.transform(float[], int, float[], int, int)
java.awt.geom.AffineTransform.transform(java.awt.geom.Point2D, java.awt.geom.Point2D)
java.awt.geom.AffineTransform.transform(java.awt.geom.Point2D[], int, java.awt.geom.Point2D[], int, int)
java.awt.geom.Area.transform(java.awt.geom.AffineTransform)
java.awt.geom.Path2D.transform(java.awt.geom.AffineTransform)
java.awt.geom.Path2D.Double.transform(java.awt.geom.AffineTransform)
java.awt.geom.Path2D.Float.transform(java.awt.geom.AffineTransform)
java.awt.Graphics2D.transform(java.awt.geom.AffineTransform)
java.lang.instrument.ClassFileTransformer.transform(java.lang.ClassLoader, java.lang.String, java.lang.Class, java.security.ProtectionDomain, byte[])
javax.xml.crypto.dsig.Transform.transform(javax.xml.crypto.Data, javax.xml.crypto.XMLCryptoContext)
javax.xml.crypto.dsig.Transform.transform(javax.xml.crypto.Data, javax.xml.crypto.XMLCryptoContext, java.io.OutputStream)
javax.xml.transform
javax.xml.transform.Transformer.transform(javax.xml.transform.Source, javax.xml.transform.Result)


Occurences of TransformerConfigurationException (constructors)

TransformerConfigurationException (constructors) occurences:
javax.xml.transform.TransformerConfigurationException()
javax.xml.transform.TransformerConfigurationException(java.lang.String)
javax.xml.transform.TransformerConfigurationException(java.lang.String, java.lang.Throwable)
javax.xml.transform.TransformerConfigurationException(java.lang.String, javax.xml.transform.SourceLocator)
javax.xml.transform.TransformerConfigurationException(java.lang.String, javax.xml.transform.SourceLocator, java.lang.Throwable)
javax.xml.transform.TransformerConfigurationException(java.lang.Throwable)


Occurences of TransformerException (constructors)

TransformerException (constructors) occurences:
javax.xml.transform.TransformerException(java.lang.String)
javax.xml.transform.TransformerException(java.lang.String, java.lang.Throwable)
javax.xml.transform.TransformerException(java.lang.String, javax.xml.transform.SourceLocator)
javax.xml.transform.TransformerException(java.lang.String, javax.xml.transform.SourceLocator, java.lang.Throwable)
javax.xml.transform.TransformerException(java.lang.Throwable)


Occurences of TransformerFactoryConfigurationError (constructors)

TransformerFactoryConfigurationError (constructors) occurences:
javax.xml.transform.TransformerFactoryConfigurationError()
javax.xml.transform.TransformerFactoryConfigurationError(java.lang.Exception)
javax.xml.transform.TransformerFactoryConfigurationError(java.lang.Exception, java.lang.String)
javax.xml.transform.TransformerFactoryConfigurationError(java.lang.String)


Occurences of TransformException (constructors)

TransformException (constructors) occurences:
javax.xml.crypto.dsig.TransformException()
javax.xml.crypto.dsig.TransformException(java.lang.String)
javax.xml.crypto.dsig.TransformException(java.lang.String, java.lang.Throwable)
javax.xml.crypto.dsig.TransformException(java.lang.Throwable)


Occurences of TRANSIENT

TRANSIENT occurences:
com.sun.mirror.declaration.TRANSIENT
java.lang.reflect.TRANSIENT
javax.accessibility.TRANSIENT
javax.lang.model.element.TRANSIENT
org.omg.CORBA.TRANSIENT
org.omg.PortableServer.TRANSIENT


Occurences of TRANSIENT (constructors)

TRANSIENT (constructors) occurences:
org.omg.CORBA.TRANSIENT()
org.omg.CORBA.TRANSIENT(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.TRANSIENT(java.lang.String)
org.omg.CORBA.TRANSIENT(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of translate

translate occurences:
java.awt.Event.translate(int, int)
java.awt.geom.AffineTransform.translate(double, double)
java.awt.Graphics.translate(int, int)
java.awt.Graphics2D.translate(double, double)
java.awt.Graphics2D.translate(int, int)
java.awt.Point.translate(int, int)
java.awt.Polygon.translate(int, int)
java.awt.Rectangle.translate(int, int)
javax.swing.DebugGraphics.translate(int, int)


Occurences of translateKey

translateKey occurences:
java.security.KeyFactory.translateKey(java.security.Key)
javax.crypto.SecretKeyFactory.translateKey(javax.crypto.SecretKey)


Occurences of transparency

transparency occurences:
java.awt.image.transparency
java.awt.image.transparency


Occurences of TransportTimeoutException (constructors)

TransportTimeoutException (constructors) occurences:
com.sun.jdi.connect.TransportTimeoutException()
com.sun.jdi.connect.TransportTimeoutException(java.lang.String)


Occurences of TrayIcon (constructors)

TrayIcon (constructors) occurences:
java.awt.TrayIcon(java.awt.Image)
java.awt.TrayIcon(java.awt.Image, java.lang.String)
java.awt.TrayIcon(java.awt.Image, java.lang.String, java.awt.PopupMenu)


Occurences of tree

tree occurences:
com.sun.source.tree
javax.swing.plaf.basic.tree
javax.swing.tree
javax.swing.tree.tree
Overview


Occurences of TREE

TREE occurences:
javax.accessibility.TREE
javax.swing.plaf.synth.TREE


Occurences of treeCollapsed

treeCollapsed occurences:
javax.swing.event.TreeExpansionListener.treeCollapsed(javax.swing.event.TreeExpansionEvent)
javax.swing.JTree.AccessibleJTree.treeCollapsed(javax.swing.event.TreeExpansionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeExpansionHandler.treeCollapsed(javax.swing.event.TreeExpansionEvent)


Occurences of treeExpanded

treeExpanded occurences:
javax.swing.event.TreeExpansionListener.treeExpanded(javax.swing.event.TreeExpansionEvent)
javax.swing.JTree.AccessibleJTree.treeExpanded(javax.swing.event.TreeExpansionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeExpansionHandler.treeExpanded(javax.swing.event.TreeExpansionEvent)


Occurences of TreeMap (constructors)

TreeMap (constructors) occurences:
java.util.TreeMap()
java.util.TreeMap(java.util.Comparator)
java.util.TreeMap(java.util.Map)
java.util.TreeMap(java.util.SortedMap)


Occurences of treeModel

treeModel occurences:
javax.swing.plaf.basic.treeModel
javax.swing.tree.treeModel
javax.swing.treeModel


Occurences of TreeModelEvent (constructors)

TreeModelEvent (constructors) occurences:
javax.swing.event.TreeModelEvent(java.lang.Object, java.lang.Object[])
javax.swing.event.TreeModelEvent(java.lang.Object, java.lang.Object[], int[], java.lang.Object[])
javax.swing.event.TreeModelEvent(java.lang.Object, javax.swing.tree.TreePath)
javax.swing.event.TreeModelEvent(java.lang.Object, javax.swing.tree.TreePath, int[], java.lang.Object[])


Occurences of treeNodesChanged

treeNodesChanged occurences:
javax.swing.event.TreeModelListener.treeNodesChanged(javax.swing.event.TreeModelEvent)
javax.swing.JTree.AccessibleJTree.treeNodesChanged(javax.swing.event.TreeModelEvent)
javax.swing.JTree.TreeModelHandler.treeNodesChanged(javax.swing.event.TreeModelEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeModelHandler.treeNodesChanged(javax.swing.event.TreeModelEvent)
javax.swing.tree.AbstractLayoutCache.treeNodesChanged(javax.swing.event.TreeModelEvent)
javax.swing.tree.FixedHeightLayoutCache.treeNodesChanged(javax.swing.event.TreeModelEvent)
javax.swing.tree.VariableHeightLayoutCache.treeNodesChanged(javax.swing.event.TreeModelEvent)


Occurences of treeNodesInserted

treeNodesInserted occurences:
javax.swing.event.TreeModelListener.treeNodesInserted(javax.swing.event.TreeModelEvent)
javax.swing.JTree.AccessibleJTree.treeNodesInserted(javax.swing.event.TreeModelEvent)
javax.swing.JTree.TreeModelHandler.treeNodesInserted(javax.swing.event.TreeModelEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeModelHandler.treeNodesInserted(javax.swing.event.TreeModelEvent)
javax.swing.tree.AbstractLayoutCache.treeNodesInserted(javax.swing.event.TreeModelEvent)
javax.swing.tree.FixedHeightLayoutCache.treeNodesInserted(javax.swing.event.TreeModelEvent)
javax.swing.tree.VariableHeightLayoutCache.treeNodesInserted(javax.swing.event.TreeModelEvent)


Occurences of treeNodesRemoved

treeNodesRemoved occurences:
javax.swing.event.TreeModelListener.treeNodesRemoved(javax.swing.event.TreeModelEvent)
javax.swing.JTree.AccessibleJTree.treeNodesRemoved(javax.swing.event.TreeModelEvent)
javax.swing.JTree.TreeModelHandler.treeNodesRemoved(javax.swing.event.TreeModelEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeModelHandler.treeNodesRemoved(javax.swing.event.TreeModelEvent)
javax.swing.tree.AbstractLayoutCache.treeNodesRemoved(javax.swing.event.TreeModelEvent)
javax.swing.tree.FixedHeightLayoutCache.treeNodesRemoved(javax.swing.event.TreeModelEvent)
javax.swing.tree.VariableHeightLayoutCache.treeNodesRemoved(javax.swing.event.TreeModelEvent)


Occurences of TreePath

TreePath occurences:
com.sun.source.util.TreePath
javax.swing.tree.TreePath


Occurences of TreePath (constructors)

TreePath (constructors) occurences:
com.sun.source.util.TreePath(com.sun.source.tree.CompilationUnitTree)
com.sun.source.util.TreePath(com.sun.source.util.TreePath, com.sun.source.tree.Tree)
javax.swing.tree.TreePath()
javax.swing.tree.TreePath(java.lang.Object)
javax.swing.tree.TreePath(java.lang.Object[])
javax.swing.tree.TreePath(java.lang.Object[], int)
javax.swing.tree.TreePath(javax.swing.tree.TreePath, java.lang.Object)


Occurences of TreeSelectionEvent (constructors)

TreeSelectionEvent (constructors) occurences:
javax.swing.event.TreeSelectionEvent(java.lang.Object, javax.swing.tree.TreePath, boolean, javax.swing.tree.TreePath, javax.swing.tree.TreePath)
javax.swing.event.TreeSelectionEvent(java.lang.Object, javax.swing.tree.TreePath[], boolean[], javax.swing.tree.TreePath, javax.swing.tree.TreePath)


Occurences of treeSelectionModel

treeSelectionModel occurences:
javax.swing.plaf.basic.treeSelectionModel
javax.swing.tree.treeSelectionModel


Occurences of TreeSet (constructors)

TreeSet (constructors) occurences:
java.util.TreeSet()
java.util.TreeSet(java.util.Collection)
java.util.TreeSet(java.util.Comparator)
java.util.TreeSet(java.util.SortedSet)


Occurences of treeStructureChanged

treeStructureChanged occurences:
javax.swing.event.TreeModelListener.treeStructureChanged(javax.swing.event.TreeModelEvent)
javax.swing.JTree.AccessibleJTree.treeStructureChanged(javax.swing.event.TreeModelEvent)
javax.swing.JTree.TreeModelHandler.treeStructureChanged(javax.swing.event.TreeModelEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeModelHandler.treeStructureChanged(javax.swing.event.TreeModelEvent)
javax.swing.tree.AbstractLayoutCache.treeStructureChanged(javax.swing.event.TreeModelEvent)
javax.swing.tree.FixedHeightLayoutCache.treeStructureChanged(javax.swing.event.TreeModelEvent)
javax.swing.tree.VariableHeightLayoutCache.treeStructureChanged(javax.swing.event.TreeModelEvent)


Occurences of trimToSize

trimToSize occurences:
java.lang.StringBuffer.trimToSize()
java.lang.StringBuilder.trimToSize()
java.util.ArrayList.trimToSize()
java.util.Vector.trimToSize()
javax.swing.DefaultListModel.trimToSize()


Occurences of Troubleshooting

Troubleshooting occurences:
Troubleshooting
Troubleshooting
Troubleshooting


Occurences of TRUE

TRUE occurences:
java.lang.TRUE
java.util.jar.TRUE
java.util.jar.TRUE


Occurences of truncate

truncate occurences:
java.nio.channels.FileChannel.truncate(long)
java.sql.Blob.truncate(long)
java.sql.Clob.truncate(long)
javax.sql.rowset.serial.SerialBlob.truncate(long)
javax.sql.rowset.serial.SerialClob.truncate(long)


Occurences of TrustAnchor (constructors)

TrustAnchor (constructors) occurences:
java.security.cert.TrustAnchor(java.lang.String, java.security.PublicKey, byte[])
java.security.cert.TrustAnchor(java.security.cert.X509Certificate, byte[])
java.security.cert.TrustAnchor(javax.security.auth.x500.X500Principal, java.security.PublicKey, byte[])


Occurences of tryAcquire

tryAcquire occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.tryAcquire(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquire(int)
java.util.concurrent.Semaphore.tryAcquire()
java.util.concurrent.Semaphore.tryAcquire(int)
java.util.concurrent.Semaphore.tryAcquire(int, long, java.util.concurrent.TimeUnit)
java.util.concurrent.Semaphore.tryAcquire(long, java.util.concurrent.TimeUnit)


Occurences of tryAcquireNanos

tryAcquireNanos occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.tryAcquireNanos(long, long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireNanos(int, long)


Occurences of tryAcquireShared

tryAcquireShared occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.tryAcquireShared(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireShared(int)


Occurences of tryAcquireSharedNanos

tryAcquireSharedNanos occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.tryAcquireSharedNanos(long, long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireSharedNanos(int, long)


Occurences of tryLock

tryLock occurences:
java.nio.channels.FileChannel.tryLock()
java.nio.channels.FileChannel.tryLock(long, long, boolean)
java.util.concurrent.locks.Lock.tryLock()
java.util.concurrent.locks.Lock.tryLock(long, java.util.concurrent.TimeUnit)
java.util.concurrent.locks.ReentrantLock.tryLock()
java.util.concurrent.locks.ReentrantLock.tryLock(long, java.util.concurrent.TimeUnit)
java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.tryLock()
java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.tryLock(long, java.util.concurrent.TimeUnit)
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.tryLock()
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.tryLock(long, java.util.concurrent.TimeUnit)


Occurences of tryRelease

tryRelease occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.tryRelease(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.tryRelease(int)


Occurences of tryReleaseShared

tryReleaseShared occurences:
java.util.concurrent.locks.AbstractQueuedLongSynchronizer.tryReleaseShared(long)
java.util.concurrent.locks.AbstractQueuedSynchronizer.tryReleaseShared(int)


Occurences of TWO_SIDED_LONG_EDGE

TWO_SIDED_LONG_EDGE occurences:
java.awt.TWO_SIDED_LONG_EDGE
javax.print.attribute.standard.TWO_SIDED_LONG_EDGE


Occurences of TWO_SIDED_SHORT_EDGE

TWO_SIDED_SHORT_EDGE occurences:
java.awt.TWO_SIDED_SHORT_EDGE
javax.print.attribute.standard.TWO_SIDED_SHORT_EDGE


Occurences of type

type occurences:
com.sun.javadoc.FieldDoc.type()
com.sun.javadoc.Parameter.type()
com.sun.jdi.Field.type()
com.sun.jdi.LocalVariable.type()
com.sun.jdi.Value.type()
com.sun.mirror.type
com.sun.tools.attach.spi.AttachProvider.type()
java.net.Proxy.type()
javax.annotation.Resource.type()
javax.lang.model.type
javax.naming.event.type
javax.sound.midi.type
javax.swing.event.type
javax.swing.text.html.parser.type
javax.swing.text.html.parser.type
javax.swing.text.html.parser.type
javax.swing.text.html.parser.type
javax.swing.type
javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter.type()
javax.xml.bind.annotation.XmlElement.type()
javax.xml.bind.annotation.XmlElementRef.type()
javax.xml.bind.annotation.XmlSchemaType.type()
javax.xml.ws.WebServiceRef.type()
org.omg.CORBA.Any.type()
org.omg.CORBA.Any.type(org.omg.CORBA.TypeCode)
org.omg.CORBA.AnySeqHelper.type()
org.omg.CORBA.BooleanSeqHelper.type()
org.omg.CORBA.CharSeqHelper.type()
org.omg.CORBA.CompletionStatusHelper.type()
org.omg.CORBA.CurrentHelper.type()
org.omg.CORBA.DefinitionKindHelper.type()
org.omg.CORBA.DoubleSeqHelper.type()
org.omg.CORBA.DynAny.type()
org.omg.CORBA.FieldNameHelper.type()
org.omg.CORBA.FloatSeqHelper.type()
org.omg.CORBA.IdentifierHelper.type()
org.omg.CORBA.IDLTypeHelper.type()
org.omg.CORBA.IDLTypeOperations.type()
org.omg.CORBA.LongLongSeqHelper.type()
org.omg.CORBA.LongSeqHelper.type()
org.omg.CORBA.NameValuePairHelper.type()
org.omg.CORBA.ObjectHelper.type()
org.omg.CORBA.OctetSeqHelper.type()
org.omg.CORBA.ParameterModeHelper.type()
org.omg.CORBA.PolicyErrorCodeHelper.type()
org.omg.CORBA.PolicyErrorHelper.type()
org.omg.CORBA.PolicyHelper.type()
org.omg.CORBA.PolicyListHelper.type()
org.omg.CORBA.PolicyTypeHelper.type()
org.omg.CORBA.RepositoryIdHelper.type()
org.omg.CORBA.ServiceDetailHelper.type()
org.omg.CORBA.ServiceInformationHelper.type()
org.omg.CORBA.SetOverrideTypeHelper.type()
org.omg.CORBA.ShortSeqHelper.type()
org.omg.CORBA.StringSeqHelper.type()
org.omg.CORBA.StringValueHelper.type()
org.omg.CORBA.StructMemberHelper.type()
org.omg.CORBA.type
org.omg.CORBA.type
org.omg.CORBA.type
org.omg.CORBA.ULongLongSeqHelper.type()
org.omg.CORBA.ULongSeqHelper.type()
org.omg.CORBA.UnionMemberHelper.type()
org.omg.CORBA.UnknownUserExceptionHelper.type()
org.omg.CORBA.UShortSeqHelper.type()
org.omg.CORBA.ValueBaseHelper.type()
org.omg.CORBA.ValueMemberHelper.type()
org.omg.CORBA.VersionSpecHelper.type()
org.omg.CORBA.VisibilityHelper.type()
org.omg.CORBA.WCharSeqHelper.type()
org.omg.CORBA.WrongTransactionHelper.type()
org.omg.CORBA.WStringSeqHelper.type()
org.omg.CORBA.WStringValueHelper.type()
org.omg.CORBA._IDLTypeStub.type()
org.omg.CosNaming.BindingHelper.type()
org.omg.CosNaming.BindingIteratorHelper.type()
org.omg.CosNaming.BindingListHelper.type()
org.omg.CosNaming.BindingTypeHelper.type()
org.omg.CosNaming.IstringHelper.type()
org.omg.CosNaming.NameComponentHelper.type()
org.omg.CosNaming.NameHelper.type()
org.omg.CosNaming.NamingContextExtHelper.type()
org.omg.CosNaming.NamingContextExtPackage.AddressHelper.type()
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHelper.type()
org.omg.CosNaming.NamingContextExtPackage.StringNameHelper.type()
org.omg.CosNaming.NamingContextExtPackage.URLStringHelper.type()
org.omg.CosNaming.NamingContextHelper.type()
org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.type()
org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.type()
org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.type()
org.omg.CosNaming.NamingContextPackage.NotEmptyHelper.type()
org.omg.CosNaming.NamingContextPackage.NotFoundHelper.type()
org.omg.CosNaming.NamingContextPackage.NotFoundReasonHelper.type()
org.omg.DynamicAny.AnySeqHelper.type()
org.omg.DynamicAny.DynAnyFactoryHelper.type()
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCodeHelper.type()
org.omg.DynamicAny.DynAnyHelper.type()
org.omg.DynamicAny.DynAnyOperations.type()
org.omg.DynamicAny.DynAnyPackage.InvalidValueHelper.type()
org.omg.DynamicAny.DynAnyPackage.TypeMismatchHelper.type()
org.omg.DynamicAny.DynAnySeqHelper.type()
org.omg.DynamicAny.DynArrayHelper.type()
org.omg.DynamicAny.DynEnumHelper.type()
org.omg.DynamicAny.DynFixedHelper.type()
org.omg.DynamicAny.DynSequenceHelper.type()
org.omg.DynamicAny.DynStructHelper.type()
org.omg.DynamicAny.DynUnionHelper.type()
org.omg.DynamicAny.DynValueHelper.type()
org.omg.DynamicAny.FieldNameHelper.type()
org.omg.DynamicAny.NameDynAnyPairHelper.type()
org.omg.DynamicAny.NameDynAnyPairSeqHelper.type()
org.omg.DynamicAny.NameValuePairHelper.type()
org.omg.DynamicAny.NameValuePairSeqHelper.type()
org.omg.DynamicAny._DynAnyStub.type()
org.omg.DynamicAny._DynArrayStub.type()
org.omg.DynamicAny._DynEnumStub.type()
org.omg.DynamicAny._DynFixedStub.type()
org.omg.DynamicAny._DynSequenceStub.type()
org.omg.DynamicAny._DynStructStub.type()
org.omg.DynamicAny._DynUnionStub.type()
org.omg.DynamicAny._DynValueStub.type()
org.omg.IOP.CodecFactoryHelper.type()
org.omg.IOP.CodecFactoryPackage.UnknownEncodingHelper.type()
org.omg.IOP.CodecPackage.FormatMismatchHelper.type()
org.omg.IOP.CodecPackage.InvalidTypeForEncodingHelper.type()
org.omg.IOP.CodecPackage.TypeMismatchHelper.type()
org.omg.IOP.ComponentIdHelper.type()
org.omg.IOP.IORHelper.type()
org.omg.IOP.MultipleComponentProfileHelper.type()
org.omg.IOP.ProfileIdHelper.type()
org.omg.IOP.ServiceContextHelper.type()
org.omg.IOP.ServiceContextListHelper.type()
org.omg.IOP.ServiceIdHelper.type()
org.omg.IOP.TaggedComponentHelper.type()
org.omg.IOP.TaggedProfileHelper.type()
org.omg.Messaging.SyncScopeHelper.type()
org.omg.PortableInterceptor.AdapterManagerIdHelper.type()
org.omg.PortableInterceptor.AdapterNameHelper.type()
org.omg.PortableInterceptor.AdapterStateHelper.type()
org.omg.PortableInterceptor.CurrentHelper.type()
org.omg.PortableInterceptor.ForwardRequestHelper.type()
org.omg.PortableInterceptor.InvalidSlotHelper.type()
org.omg.PortableInterceptor.IORInterceptor_3_0Helper.type()
org.omg.PortableInterceptor.ObjectIdHelper.type()
org.omg.PortableInterceptor.ObjectReferenceFactoryHelper.type()
org.omg.PortableInterceptor.ObjectReferenceTemplateHelper.type()
org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHelper.type()
org.omg.PortableInterceptor.ORBIdHelper.type()
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateNameHelper.type()
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidNameHelper.type()
org.omg.PortableInterceptor.ORBInitInfoPackage.ObjectIdHelper.type()
org.omg.PortableInterceptor.ServerIdHelper.type()
org.omg.PortableServer.CurrentHelper.type()
org.omg.PortableServer.CurrentPackage.NoContextHelper.type()
org.omg.PortableServer.ForwardRequestHelper.type()
org.omg.PortableServer.POAHelper.type()
org.omg.PortableServer.POAManagerPackage.AdapterInactiveHelper.type()
org.omg.PortableServer.POAPackage.AdapterAlreadyExistsHelper.type()
org.omg.PortableServer.POAPackage.AdapterNonExistentHelper.type()
org.omg.PortableServer.POAPackage.InvalidPolicyHelper.type()
org.omg.PortableServer.POAPackage.NoServantHelper.type()
org.omg.PortableServer.POAPackage.ObjectAlreadyActiveHelper.type()
org.omg.PortableServer.POAPackage.ObjectNotActiveHelper.type()
org.omg.PortableServer.POAPackage.ServantAlreadyActiveHelper.type()
org.omg.PortableServer.POAPackage.ServantNotActiveHelper.type()
org.omg.PortableServer.POAPackage.WrongAdapterHelper.type()
org.omg.PortableServer.POAPackage.WrongPolicyHelper.type()
org.omg.PortableServer.ServantActivatorHelper.type()
org.omg.PortableServer.ServantLocatorHelper.type()


Occurences of TYPE

TYPE occurences:
java.lang.annotation.TYPE
java.lang.TYPE
java.lang.TYPE
java.lang.TYPE
java.lang.TYPE
java.lang.TYPE
java.lang.TYPE
java.lang.TYPE
java.lang.TYPE
java.lang.TYPE
javax.swing.text.html.TYPE
javax.xml.crypto.dsig.keyinfo.TYPE
javax.xml.crypto.dsig.keyinfo.TYPE
javax.xml.crypto.dsig.TYPE
javax.xml.crypto.dsig.TYPE
javax.xml.crypto.dsig.TYPE


Occurences of Type

Type occurences:
com.sun.javadoc.Type
com.sun.jdi.Type
java.lang.reflect.Type


Occurences of TypeCodeHolder (constructors)

TypeCodeHolder (constructors) occurences:
org.omg.CORBA.TypeCodeHolder()
org.omg.CORBA.TypeCodeHolder(org.omg.CORBA.TypeCode)


Occurences of TypeConstraintException (constructors)

TypeConstraintException (constructors) occurences:
javax.xml.bind.TypeConstraintException(java.lang.String)
javax.xml.bind.TypeConstraintException(java.lang.String, java.lang.String)
javax.xml.bind.TypeConstraintException(java.lang.String, java.lang.String, java.lang.Throwable)
javax.xml.bind.TypeConstraintException(java.lang.String, java.lang.Throwable)
javax.xml.bind.TypeConstraintException(java.lang.Throwable)


Occurences of TypeKindVisitor6 (constructors)

TypeKindVisitor6 (constructors) occurences:
javax.lang.model.util.TypeKindVisitor6()
javax.lang.model.util.TypeKindVisitor6(java.lang.Object)
javax.lang.model.util.TypeKindVisitor6(R)


Occurences of TypeMirror

TypeMirror occurences:
com.sun.mirror.type.TypeMirror
javax.lang.model.type.TypeMirror


Occurences of TypeMismatch

TypeMismatch occurences:
org.omg.CORBA.DynAnyPackage.TypeMismatch
org.omg.DynamicAny.DynAnyPackage.TypeMismatch
org.omg.IOP.CodecPackage.TypeMismatch


Occurences of TypeMismatch (constructors)

TypeMismatch (constructors) occurences:
org.omg.CORBA.DynAnyPackage.TypeMismatch()
org.omg.CORBA.DynAnyPackage.TypeMismatch(java.lang.String)
org.omg.DynamicAny.DynAnyPackage.TypeMismatch()
org.omg.DynamicAny.DynAnyPackage.TypeMismatch(java.lang.String)
org.omg.IOP.CodecPackage.TypeMismatch()
org.omg.IOP.CodecPackage.TypeMismatch(java.lang.String)


Occurences of TypeMismatchHelper

TypeMismatchHelper occurences:
org.omg.DynamicAny.DynAnyPackage.TypeMismatchHelper
org.omg.IOP.CodecPackage.TypeMismatchHelper


Occurences of TypeMismatchHelper (constructors)

TypeMismatchHelper (constructors) occurences:
org.omg.DynamicAny.DynAnyPackage.TypeMismatchHelper()
org.omg.IOP.CodecPackage.TypeMismatchHelper()


Occurences of typeName

typeName occurences:
com.sun.javadoc.Parameter.typeName()
com.sun.javadoc.Type.typeName()
com.sun.jdi.Field.typeName()
com.sun.jdi.LocalVariable.typeName()
java.lang.TypeNotPresentException.typeName()


Occurences of typeParameters

typeParameters occurences:
com.sun.javadoc.ClassDoc.typeParameters()
com.sun.javadoc.ExecutableMemberDoc.typeParameters()


Occurences of typeParamTags

typeParamTags occurences:
com.sun.javadoc.ClassDoc.typeParamTags()
com.sun.javadoc.ExecutableMemberDoc.typeParamTags()


Occurences of Types

Types occurences:
com.sun.mirror.util.Types
java.sql.Types
javax.lang.model.util.Types


Occurences of typesIn

typesIn occurences:
javax.lang.model.util.ElementFilter.typesIn(java.lang.Iterable)
javax.lang.model.util.ElementFilter.typesIn(java.util.Set)


Occurences of TypeVariable

TypeVariable occurences:
com.sun.javadoc.TypeVariable
com.sun.mirror.type.TypeVariable
java.lang.reflect.TypeVariable
javax.lang.model.type.TypeVariable


Occurences of TypeVisitor

TypeVisitor occurences:
com.sun.mirror.util.TypeVisitor
javax.lang.model.type.TypeVisitor


Occurences of type_def

type_def occurences:
org.omg.CORBA.type_def
org.omg.CORBA.type_def
org.omg.CORBA.type_def


Occurences of TYPE_PARAMETER

TYPE_PARAMETER occurences:
com.sun.source.tree.TYPE_PARAMETER
javax.lang.model.element.TYPE_PARAMETER


Occurences of ui

ui occurences:
javax.swing.plaf.basic.ui
javax.swing.ui


Occurences of UID (constructors)

UID (constructors) occurences:
java.rmi.server.UID()
java.rmi.server.UID(short)


Occurences of UIDefaults (constructors)

UIDefaults (constructors) occurences:
javax.swing.UIDefaults()
javax.swing.UIDefaults(int, float)
javax.swing.UIDefaults(java.lang.Object[])


Occurences of UIDefaults.ProxyLazyValue (constructors)

UIDefaults.ProxyLazyValue (constructors) occurences:
javax.swing.UIDefaults.ProxyLazyValue(java.lang.String)
javax.swing.UIDefaults.ProxyLazyValue(java.lang.String, java.lang.Object[])
javax.swing.UIDefaults.ProxyLazyValue(java.lang.String, java.lang.String)
javax.swing.UIDefaults.ProxyLazyValue(java.lang.String, java.lang.String, java.lang.Object[])


Occurences of uis

uis occurences:
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis
javax.swing.plaf.multi.uis


Occurences of ULongLongSeqHolder (constructors)

ULongLongSeqHolder (constructors) occurences:
org.omg.CORBA.ULongLongSeqHolder()
org.omg.CORBA.ULongLongSeqHolder(long[])


Occurences of ULongSeqHolder (constructors)

ULongSeqHolder (constructors) occurences:
org.omg.CORBA.ULongSeqHolder()
org.omg.CORBA.ULongSeqHolder(int[])


Occurences of ulp

ulp occurences:
java.lang.Math.ulp(double)
java.lang.Math.ulp(float)
java.lang.StrictMath.ulp(double)
java.lang.StrictMath.ulp(float)
java.math.BigDecimal.ulp()


Occurences of unbind

unbind occurences:
java.rmi.Naming.unbind(java.lang.String)
java.rmi.registry.Registry.unbind(java.lang.String)
javax.naming.Context.unbind(java.lang.String)
javax.naming.Context.unbind(javax.naming.Name)
javax.naming.InitialContext.unbind(java.lang.String)
javax.naming.InitialContext.unbind(javax.naming.Name)
org.omg.CosNaming.NamingContextOperations.unbind(org.omg.CosNaming.NameComponent[])
org.omg.CosNaming._NamingContextExtStub.unbind(org.omg.CosNaming.NameComponent[])
org.omg.CosNaming._NamingContextStub.unbind(org.omg.CosNaming.NameComponent[])


Occurences of uncaughtException

uncaughtException occurences:
java.lang.Thread.UncaughtExceptionHandler.uncaughtException(java.lang.Thread, java.lang.Throwable)
java.lang.ThreadGroup.uncaughtException(java.lang.Thread, java.lang.Throwable)


Occurences of unchecked_narrow

unchecked_narrow occurences:
org.omg.CosNaming.BindingIteratorHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.CosNaming.NamingContextExtHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.CosNaming.NamingContextHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynAnyFactoryHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynAnyHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynArrayHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynEnumHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynFixedHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynSequenceHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynStructHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynUnionHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.DynamicAny.DynValueHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.IOP.CodecFactoryHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.PortableInterceptor.CurrentHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.PortableInterceptor.IORInterceptor_3_0Helper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.PortableServer.ServantActivatorHelper.unchecked_narrow(org.omg.CORBA.Object)
org.omg.PortableServer.ServantLocatorHelper.unchecked_narrow(org.omg.CORBA.Object)


Occurences of unconfigureEditor

unconfigureEditor occurences:
javax.swing.plaf.basic.BasicComboBoxUI.unconfigureEditor()
javax.swing.plaf.metal.MetalComboBoxUI.unconfigureEditor()


Occurences of UndeclaredThrowableException (constructors)

UndeclaredThrowableException (constructors) occurences:
java.lang.reflect.UndeclaredThrowableException(java.lang.Throwable)
java.lang.reflect.UndeclaredThrowableException(java.lang.Throwable, java.lang.String)


Occurences of UNDEFINED

UNDEFINED occurences:
java.awt.UNDEFINED
javax.xml.bind.annotation.UNDEFINED


Occurences of undo

undo occurences:
javax.swing.text.AbstractDocument.DefaultDocumentEvent.undo()
javax.swing.text.AbstractDocument.ElementEdit.undo()
javax.swing.text.DefaultStyledDocument.AttributeUndoableEdit.undo()
javax.swing.undo
javax.swing.undo.AbstractUndoableEdit.undo()
javax.swing.undo.CompoundEdit.undo()
javax.swing.undo.StateEdit.undo()
javax.swing.undo.UndoableEdit.undo()
javax.swing.undo.UndoManager.undo()


Occurences of undoableEditHappened

undoableEditHappened occurences:
javax.swing.event.UndoableEditListener.undoableEditHappened(javax.swing.event.UndoableEditEvent)
javax.swing.undo.UndoManager.undoableEditHappened(javax.swing.event.UndoableEditEvent)


Occurences of UndoableEditSupport (constructors)

UndoableEditSupport (constructors) occurences:
javax.swing.undo.UndoableEditSupport()
javax.swing.undo.UndoableEditSupport(java.lang.Object)


Occurences of UnexpectedException (constructors)

UnexpectedException (constructors) occurences:
java.rmi.UnexpectedException(java.lang.String)
java.rmi.UnexpectedException(java.lang.String, java.lang.Exception)


Occurences of unexportObject

unexportObject occurences:
java.rmi.activation.Activatable.unexportObject(java.rmi.Remote, boolean)
java.rmi.server.UnicastRemoteObject.unexportObject(java.rmi.Remote, boolean)
javax.rmi.CORBA.PortableRemoteObjectDelegate.unexportObject(java.rmi.Remote)
javax.rmi.CORBA.Util.unexportObject(java.rmi.Remote)
javax.rmi.CORBA.UtilDelegate.unexportObject(java.rmi.Remote)
javax.rmi.PortableRemoteObject.unexportObject(java.rmi.Remote)


Occurences of UnicastRemoteObject (constructors)

UnicastRemoteObject (constructors) occurences:
java.rmi.server.UnicastRemoteObject()
java.rmi.server.UnicastRemoteObject(int)
java.rmi.server.UnicastRemoteObject(int, java.rmi.server.RMIClientSocketFactory, java.rmi.server.RMIServerSocketFactory)


Occurences of uninitialize

uninitialize occurences:
javax.swing.LookAndFeel.uninitialize()
javax.swing.plaf.basic.BasicLookAndFeel.uninitialize()
javax.swing.plaf.synth.SynthLookAndFeel.uninitialize()


Occurences of uninstallComponents

uninstallComponents occurences:
javax.swing.plaf.basic.BasicComboBoxUI.uninstallComponents()
javax.swing.plaf.basic.BasicDesktopIconUI.uninstallComponents()
javax.swing.plaf.basic.BasicFileChooserUI.uninstallComponents(javax.swing.JFileChooser)
javax.swing.plaf.basic.BasicInternalFrameUI.uninstallComponents()
javax.swing.plaf.basic.BasicLabelUI.uninstallComponents(javax.swing.JLabel)
javax.swing.plaf.basic.BasicMenuItemUI.uninstallComponents(javax.swing.JMenuItem)
javax.swing.plaf.basic.BasicOptionPaneUI.uninstallComponents()
javax.swing.plaf.basic.BasicRootPaneUI.uninstallComponents(javax.swing.JRootPane)
javax.swing.plaf.basic.BasicScrollBarUI.uninstallComponents()
javax.swing.plaf.basic.BasicTabbedPaneUI.uninstallComponents()
javax.swing.plaf.basic.BasicToolBarUI.uninstallComponents()
javax.swing.plaf.basic.BasicTreeUI.uninstallComponents()
javax.swing.plaf.metal.MetalDesktopIconUI.uninstallComponents()
javax.swing.plaf.metal.MetalFileChooserUI.uninstallComponents(javax.swing.JFileChooser)
javax.swing.plaf.metal.MetalInternalFrameUI.uninstallComponents()


Occurences of uninstallDefaults

uninstallDefaults occurences:
javax.swing.plaf.basic.BasicButtonUI.uninstallDefaults(javax.swing.AbstractButton)
javax.swing.plaf.basic.BasicColorChooserUI.uninstallDefaults()
javax.swing.plaf.basic.BasicComboBoxUI.uninstallDefaults()
javax.swing.plaf.basic.BasicDesktopIconUI.uninstallDefaults()
javax.swing.plaf.basic.BasicDesktopPaneUI.uninstallDefaults()
javax.swing.plaf.basic.BasicFileChooserUI.uninstallDefaults(javax.swing.JFileChooser)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.uninstallDefaults()
javax.swing.plaf.basic.BasicInternalFrameUI.uninstallDefaults()
javax.swing.plaf.basic.BasicLabelUI.uninstallDefaults(javax.swing.JLabel)
javax.swing.plaf.basic.BasicListUI.uninstallDefaults()
javax.swing.plaf.basic.BasicMenuBarUI.uninstallDefaults()
javax.swing.plaf.basic.BasicMenuItemUI.uninstallDefaults()
javax.swing.plaf.basic.BasicMenuUI.uninstallDefaults()
javax.swing.plaf.basic.BasicOptionPaneUI.uninstallDefaults()
javax.swing.plaf.basic.BasicPanelUI.uninstallDefaults(javax.swing.JPanel)
javax.swing.plaf.basic.BasicPopupMenuUI.uninstallDefaults()
javax.swing.plaf.basic.BasicProgressBarUI.uninstallDefaults()
javax.swing.plaf.basic.BasicRadioButtonUI.uninstallDefaults(javax.swing.AbstractButton)
javax.swing.plaf.basic.BasicRootPaneUI.uninstallDefaults(javax.swing.JRootPane)
javax.swing.plaf.basic.BasicScrollBarUI.uninstallDefaults()
javax.swing.plaf.basic.BasicScrollPaneUI.uninstallDefaults(javax.swing.JScrollPane)
javax.swing.plaf.basic.BasicSeparatorUI.uninstallDefaults(javax.swing.JSeparator)
javax.swing.plaf.basic.BasicSpinnerUI.uninstallDefaults()
javax.swing.plaf.basic.BasicSplitPaneUI.uninstallDefaults()
javax.swing.plaf.basic.BasicTabbedPaneUI.uninstallDefaults()
javax.swing.plaf.basic.BasicTableHeaderUI.uninstallDefaults()
javax.swing.plaf.basic.BasicTableUI.uninstallDefaults()
javax.swing.plaf.basic.BasicTextUI.uninstallDefaults()
javax.swing.plaf.basic.BasicToolBarUI.uninstallDefaults()
javax.swing.plaf.basic.BasicToolTipUI.uninstallDefaults(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.uninstallDefaults()
javax.swing.plaf.basic.BasicViewportUI.uninstallDefaults(javax.swing.JComponent)
javax.swing.plaf.metal.MetalButtonUI.uninstallDefaults(javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalCheckBoxUI.uninstallDefaults(javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalInternalFrameTitlePane.uninstallDefaults()
javax.swing.plaf.metal.MetalRadioButtonUI.uninstallDefaults(javax.swing.AbstractButton)
javax.swing.plaf.metal.MetalToggleButtonUI.uninstallDefaults(javax.swing.AbstractButton)
javax.swing.plaf.synth.SynthStyle.uninstallDefaults(javax.swing.plaf.synth.SynthContext)


Occurences of uninstallingUI

uninstallingUI occurences:
javax.swing.plaf.basic.BasicComboPopup.uninstallingUI()
javax.swing.plaf.basic.ComboPopup.uninstallingUI()


Occurences of uninstallKeyboardActions

uninstallKeyboardActions occurences:
javax.swing.plaf.basic.BasicButtonListener.uninstallKeyboardActions(javax.swing.JComponent)
javax.swing.plaf.basic.BasicButtonUI.uninstallKeyboardActions(javax.swing.AbstractButton)
javax.swing.plaf.basic.BasicComboBoxUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicComboPopup.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicDesktopPaneUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicInternalFrameUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicLabelUI.uninstallKeyboardActions(javax.swing.JLabel)
javax.swing.plaf.basic.BasicListUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicMenuBarUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicMenuItemUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicMenuUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicOptionPaneUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicPopupMenuUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicRootPaneUI.uninstallKeyboardActions(javax.swing.JRootPane)
javax.swing.plaf.basic.BasicScrollBarUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicScrollPaneUI.uninstallKeyboardActions(javax.swing.JScrollPane)
javax.swing.plaf.basic.BasicSliderUI.uninstallKeyboardActions(javax.swing.JSlider)
javax.swing.plaf.basic.BasicSplitPaneUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicTabbedPaneUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicTableHeaderUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicTableUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicTextUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicToolBarUI.uninstallKeyboardActions()
javax.swing.plaf.basic.BasicTreeUI.uninstallKeyboardActions()
javax.swing.plaf.metal.MetalInternalFrameUI.uninstallKeyboardActions()


Occurences of uninstallListeners

uninstallListeners occurences:
javax.swing.plaf.basic.BasicButtonUI.uninstallListeners(javax.swing.AbstractButton)
javax.swing.plaf.basic.BasicColorChooserUI.uninstallListeners()
javax.swing.plaf.basic.BasicComboBoxUI.uninstallListeners()
javax.swing.plaf.basic.BasicDesktopIconUI.uninstallListeners()
javax.swing.plaf.basic.BasicDesktopPaneUI.uninstallListeners()
javax.swing.plaf.basic.BasicFileChooserUI.uninstallListeners(javax.swing.JFileChooser)
javax.swing.plaf.basic.BasicInternalFrameTitlePane.uninstallListeners()
javax.swing.plaf.basic.BasicInternalFrameUI.uninstallListeners()
javax.swing.plaf.basic.BasicLabelUI.uninstallListeners(javax.swing.JLabel)
javax.swing.plaf.basic.BasicListUI.uninstallListeners()
javax.swing.plaf.basic.BasicMenuBarUI.uninstallListeners()
javax.swing.plaf.basic.BasicMenuItemUI.uninstallListeners()
javax.swing.plaf.basic.BasicMenuUI.uninstallListeners()
javax.swing.plaf.basic.BasicOptionPaneUI.uninstallListeners()
javax.swing.plaf.basic.BasicPopupMenuUI.uninstallListeners()
javax.swing.plaf.basic.BasicProgressBarUI.uninstallListeners()
javax.swing.plaf.basic.BasicRootPaneUI.uninstallListeners(javax.swing.JRootPane)
javax.swing.plaf.basic.BasicScrollBarUI.uninstallListeners()
javax.swing.plaf.basic.BasicScrollPaneUI.uninstallListeners(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSeparatorUI.uninstallListeners(javax.swing.JSeparator)
javax.swing.plaf.basic.BasicSliderUI.uninstallListeners(javax.swing.JSlider)
javax.swing.plaf.basic.BasicSpinnerUI.uninstallListeners()
javax.swing.plaf.basic.BasicSplitPaneUI.uninstallListeners()
javax.swing.plaf.basic.BasicTabbedPaneUI.uninstallListeners()
javax.swing.plaf.basic.BasicTableHeaderUI.uninstallListeners()
javax.swing.plaf.basic.BasicTableUI.uninstallListeners()
javax.swing.plaf.basic.BasicTextUI.uninstallListeners()
javax.swing.plaf.basic.BasicToolBarUI.uninstallListeners()
javax.swing.plaf.basic.BasicToolTipUI.uninstallListeners(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.uninstallListeners()
javax.swing.plaf.metal.MetalDesktopIconUI.uninstallListeners()
javax.swing.plaf.metal.MetalInternalFrameUI.uninstallListeners()
javax.swing.plaf.metal.MetalScrollPaneUI.uninstallListeners(javax.swing.JScrollPane)
javax.swing.plaf.metal.MetalToolBarUI.uninstallListeners()


Occurences of uninstallUI

uninstallUI occurences:
javax.swing.plaf.basic.BasicButtonUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicColorChooserUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicComboBoxUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopIconUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicDesktopPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicEditorPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicFileChooserUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicInternalFrameUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicLabelUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicListUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicMenuItemUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicOptionPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPanelUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicPopupMenuUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicProgressBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicRootPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicScrollPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSeparatorUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSliderUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSpinnerUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicSplitPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTabbedPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableHeaderUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTableUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicToolTipUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicTreeUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.basic.BasicViewportUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.ComponentUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalFileChooserUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalInternalFrameUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalMenuBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalRootPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalScrollPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolTipUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.metal.MetalTreeUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiButtonUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.uninstallUI(javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.uninstallUI(javax.swing.JComponent)


Occurences of union

union occurences:
java.awt.geom.Rectangle2D.union(java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D, java.awt.geom.Rectangle2D)
java.awt.Rectangle.union(java.awt.Rectangle)
javax.management.ImmutableDescriptor.union(javax.management.Descriptor...)


Occurences of UnionMember (constructors)

UnionMember (constructors) occurences:
org.omg.CORBA.UnionMember()
org.omg.CORBA.UnionMember(java.lang.String, org.omg.CORBA.Any, org.omg.CORBA.TypeCode, org.omg.CORBA.IDLType)


Occurences of UNKNOWN

UNKNOWN occurences:
java.awt.UNKNOWN
javax.accessibility.UNKNOWN
javax.management.UNKNOWN
javax.print.attribute.standard.UNKNOWN
javax.print.attribute.standard.UNKNOWN
org.omg.CORBA.UNKNOWN
org.omg.PortableInterceptor.UNKNOWN


Occurences of UNKNOWN (constructors)

UNKNOWN (constructors) occurences:
org.omg.CORBA.UNKNOWN()
org.omg.CORBA.UNKNOWN(int, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.UNKNOWN(java.lang.String)
org.omg.CORBA.UNKNOWN(java.lang.String, int, org.omg.CORBA.CompletionStatus)


Occurences of UnknownEncoding (constructors)

UnknownEncoding (constructors) occurences:
org.omg.IOP.CodecFactoryPackage.UnknownEncoding()
org.omg.IOP.CodecFactoryPackage.UnknownEncoding(java.lang.String)


Occurences of UnknownError (constructors)

UnknownError (constructors) occurences:
java.lang.UnknownError()
java.lang.UnknownError(java.lang.String)


Occurences of UnknownHostException

UnknownHostException occurences:
java.net.UnknownHostException
java.rmi.UnknownHostException


Occurences of UnknownHostException (constructors)

UnknownHostException (constructors) occurences:
java.net.UnknownHostException()
java.net.UnknownHostException(java.lang.String)
java.rmi.UnknownHostException(java.lang.String)
java.rmi.UnknownHostException(java.lang.String, java.lang.Exception)


Occurences of UnknownServiceException (constructors)

UnknownServiceException (constructors) occurences:
java.net.UnknownServiceException()
java.net.UnknownServiceException(java.lang.String)


Occurences of UnknownUserException (constructors)

UnknownUserException (constructors) occurences:
org.omg.CORBA.UnknownUserException()
org.omg.CORBA.UnknownUserException(org.omg.CORBA.Any)


Occurences of UnknownUserExceptionHolder (constructors)

UnknownUserExceptionHolder (constructors) occurences:
org.omg.CORBA.UnknownUserExceptionHolder()
org.omg.CORBA.UnknownUserExceptionHolder(org.omg.CORBA.UnknownUserException)


Occurences of unlock

unlock occurences:
java.util.concurrent.locks.Lock.unlock()
java.util.concurrent.locks.ReentrantLock.unlock()
java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.unlock()
java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.unlock()


Occurences of unmappableCharacterAction

unmappableCharacterAction occurences:
java.nio.charset.CharsetDecoder.unmappableCharacterAction()
java.nio.charset.CharsetEncoder.unmappableCharacterAction()


Occurences of unmarshal

unmarshal occurences:
javax.xml.bind.annotation.adapters.CollapsedStringAdapter.unmarshal(java.lang.String)
javax.xml.bind.annotation.adapters.HexBinaryAdapter.unmarshal(java.lang.String)
javax.xml.bind.annotation.adapters.NormalizedStringAdapter.unmarshal(java.lang.String)
javax.xml.bind.annotation.adapters.XmlAdapter.unmarshal(java.lang.Object)
javax.xml.bind.annotation.adapters.XmlAdapter.unmarshal(ValueType)
javax.xml.bind.Binder.unmarshal(java.lang.Object)
javax.xml.bind.Binder.unmarshal(java.lang.Object,java.lang.Class)
javax.xml.bind.Binder.unmarshal(XmlNode)
javax.xml.bind.Binder.unmarshal(XmlNode, java.lang.Class)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(java.io.File)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(java.io.InputStream)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(java.io.Reader)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(java.net.URL)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(javax.xml.stream.XMLEventReader)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(javax.xml.stream.XMLEventReader, java.lang.Class)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(javax.xml.stream.XMLStreamReader)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(javax.xml.stream.XMLStreamReader, java.lang.Class)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(javax.xml.transform.Source)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(javax.xml.transform.Source, java.lang.Class)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(org.w3c.dom.Node, java.lang.Class)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(org.xml.sax.InputSource)
javax.xml.bind.helpers.AbstractUnmarshallerImpl.unmarshal(org.xml.sax.XMLReader, org.xml.sax.InputSource)
javax.xml.bind.Unmarshaller.unmarshal(java.io.File)
javax.xml.bind.Unmarshaller.unmarshal(java.io.InputStream)
javax.xml.bind.Unmarshaller.unmarshal(java.io.Reader)
javax.xml.bind.Unmarshaller.unmarshal(java.net.URL)
javax.xml.bind.Unmarshaller.unmarshal(javax.xml.stream.XMLEventReader)
javax.xml.bind.Unmarshaller.unmarshal(javax.xml.stream.XMLEventReader, java.lang.Class)
javax.xml.bind.Unmarshaller.unmarshal(javax.xml.stream.XMLStreamReader)
javax.xml.bind.Unmarshaller.unmarshal(javax.xml.stream.XMLStreamReader, java.lang.Class)
javax.xml.bind.Unmarshaller.unmarshal(javax.xml.transform.Source)
javax.xml.bind.Unmarshaller.unmarshal(javax.xml.transform.Source, java.lang.Class)
javax.xml.bind.Unmarshaller.unmarshal(org.w3c.dom.Node)
javax.xml.bind.Unmarshaller.unmarshal(org.w3c.dom.Node, java.lang.Class)
javax.xml.bind.Unmarshaller.unmarshal(org.xml.sax.InputSource)
org.omg.CORBA.CustomMarshal.unmarshal(org.omg.CORBA.DataInputStream)


Occurences of UnmarshalException

UnmarshalException occurences:
java.rmi.UnmarshalException
javax.xml.bind.UnmarshalException


Occurences of UnmarshalException (constructors)

UnmarshalException (constructors) occurences:
java.rmi.UnmarshalException(java.lang.String)
java.rmi.UnmarshalException(java.lang.String, java.lang.Exception)
javax.xml.bind.UnmarshalException(java.lang.String)
javax.xml.bind.UnmarshalException(java.lang.String, java.lang.String)
javax.xml.bind.UnmarshalException(java.lang.String, java.lang.String, java.lang.Throwable)
javax.xml.bind.UnmarshalException(java.lang.String, java.lang.Throwable)
javax.xml.bind.UnmarshalException(java.lang.Throwable)


Occurences of unmarshalXMLSignature

unmarshalXMLSignature occurences:
javax.xml.crypto.dsig.XMLSignatureFactory.unmarshalXMLSignature(javax.xml.crypto.dsig.XMLValidateContext)
javax.xml.crypto.dsig.XMLSignatureFactory.unmarshalXMLSignature(javax.xml.crypto.XMLStructure)


Occurences of UnmodifiableClassException (constructors)

UnmodifiableClassException (constructors) occurences:
java.lang.instrument.UnmodifiableClassException()
java.lang.instrument.UnmodifiableClassException(java.lang.String)


Occurences of UnmodifiableSetException (constructors)

UnmodifiableSetException (constructors) occurences:
javax.print.attribute.UnmodifiableSetException()
javax.print.attribute.UnmodifiableSetException(java.lang.String)


Occurences of unmodifiableView

unmodifiableView occurences:
javax.print.attribute.AttributeSetUtilities.unmodifiableView(javax.print.attribute.AttributeSet)
javax.print.attribute.AttributeSetUtilities.unmodifiableView(javax.print.attribute.DocAttributeSet)
javax.print.attribute.AttributeSetUtilities.unmodifiableView(javax.print.attribute.PrintJobAttributeSet)
javax.print.attribute.AttributeSetUtilities.unmodifiableView(javax.print.attribute.PrintRequestAttributeSet)
javax.print.attribute.AttributeSetUtilities.unmodifiableView(javax.print.attribute.PrintServiceAttributeSet)


Occurences of UNNECESSARY

UNNECESSARY occurences:
java.awt.UNNECESSARY
java.math.UNNECESSARY


Occurences of unpack

unpack occurences:
java.util.jar.Pack200.Unpacker.unpack(java.io.File, java.util.jar.JarOutputStream)
java.util.jar.Pack200.Unpacker.unpack(java.io.InputStream, java.util.jar.JarOutputStream)


Occurences of unparsedEntityDecl

unparsedEntityDecl occurences:
org.xml.sax.DTDHandler.unparsedEntityDecl(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.HandlerBase.unparsedEntityDecl(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.helpers.DefaultHandler.unparsedEntityDecl(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
org.xml.sax.helpers.XMLFilterImpl.unparsedEntityDecl(java.lang.String, java.lang.String, java.lang.String, java.lang.String)


Occurences of unread

unread occurences:
java.io.PushbackInputStream.unread(byte[])
java.io.PushbackInputStream.unread(byte[], int, int)
java.io.PushbackInputStream.unread(int)
java.io.PushbackReader.unread(char[])
java.io.PushbackReader.unread(char[], int, int)
java.io.PushbackReader.unread(int)


Occurences of UnrecoverableEntryException (constructors)

UnrecoverableEntryException (constructors) occurences:
java.security.UnrecoverableEntryException()
java.security.UnrecoverableEntryException(java.lang.String)


Occurences of UnrecoverableKeyException (constructors)

UnrecoverableKeyException (constructors) occurences:
java.security.UnrecoverableKeyException()
java.security.UnrecoverableKeyException(java.lang.String)


Occurences of unreferenced

unreferenced occurences:
java.rmi.server.Unreferenced.unreferenced()
javax.management.remote.rmi.RMIConnectionImpl.unreferenced()


Occurences of unregisterListeners

unregisterListeners occurences:
java.awt.dnd.DragGestureRecognizer.unregisterListeners()
java.awt.dnd.MouseDragGestureRecognizer.unregisterListeners()


Occurences of unregisterMBean

unregisterMBean occurences:
javax.management.MBeanServer.unregisterMBean(javax.management.ObjectName)
javax.management.MBeanServerConnection.unregisterMBean(javax.management.ObjectName)
javax.management.remote.rmi.RMIConnection.unregisterMBean(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl.unregisterMBean(javax.management.ObjectName, javax.security.auth.Subject)
javax.management.remote.rmi.RMIConnectionImpl_Stub.unregisterMBean(javax.management.ObjectName, javax.security.auth.Subject)


Occurences of UnsatisfiedLinkError (constructors)

UnsatisfiedLinkError (constructors) occurences:
java.lang.UnsatisfiedLinkError()
java.lang.UnsatisfiedLinkError(java.lang.String)


Occurences of UNSET

UNSET occurences:
javax.swing.UNSET
javax.xml.bind.annotation.UNSET


Occurences of unsetCompression

unsetCompression occurences:
javax.imageio.ImageWriteParam.unsetCompression()
javax.imageio.plugins.jpeg.JPEGImageWriteParam.unsetCompression()


Occurences of unsetMatchColumn

unsetMatchColumn occurences:
javax.sql.rowset.Joinable.unsetMatchColumn(int)
javax.sql.rowset.Joinable.unsetMatchColumn(int[])
javax.sql.rowset.Joinable.unsetMatchColumn(java.lang.String)
javax.sql.rowset.Joinable.unsetMatchColumn(java.lang.String[])


Occurences of unsetOrdering

unsetOrdering occurences:
javax.imageio.spi.ServiceRegistry.unsetOrdering(java.lang.Class, T, T)
javax.imageio.spi.ServiceRegistry.unsetOrdering(java.lang.Class,java.lang.Object,java.lang.Object)


Occurences of UnsupportedAudioFileException (constructors)

UnsupportedAudioFileException (constructors) occurences:
javax.sound.sampled.UnsupportedAudioFileException()
javax.sound.sampled.UnsupportedAudioFileException(java.lang.String)


Occurences of UnsupportedCallbackException (constructors)

UnsupportedCallbackException (constructors) occurences:
javax.security.auth.callback.UnsupportedCallbackException(javax.security.auth.callback.Callback)
javax.security.auth.callback.UnsupportedCallbackException(javax.security.auth.callback.Callback, java.lang.String)


Occurences of UnsupportedClassVersionError (constructors)

UnsupportedClassVersionError (constructors) occurences:
java.lang.UnsupportedClassVersionError()
java.lang.UnsupportedClassVersionError(java.lang.String)


Occurences of UnsupportedDataTypeException (constructors)

UnsupportedDataTypeException (constructors) occurences:
javax.activation.UnsupportedDataTypeException()
javax.activation.UnsupportedDataTypeException(java.lang.String)


Occurences of UnsupportedEncodingException (constructors)

UnsupportedEncodingException (constructors) occurences:
java.io.UnsupportedEncodingException()
java.io.UnsupportedEncodingException(java.lang.String)


Occurences of UnsupportedOperationException (constructors)

UnsupportedOperationException (constructors) occurences:
java.lang.UnsupportedOperationException()
java.lang.UnsupportedOperationException(java.lang.String)
java.lang.UnsupportedOperationException(java.lang.String, java.lang.Throwable)
java.lang.UnsupportedOperationException(java.lang.Throwable)


Occurences of Untitled Document

Untitled Document occurences:
Untitled Document
Untitled Document
Untitled Document
Untitled Document


Occurences of unwrap

unwrap occurences:
java.sql.Wrapper.unwrap(java.lang.Class)
javax.crypto.Cipher.unwrap(byte[], java.lang.String, int)
javax.net.ssl.SSLEngine.unwrap(java.nio.ByteBuffer, java.nio.ByteBuffer)
javax.net.ssl.SSLEngine.unwrap(java.nio.ByteBuffer, java.nio.ByteBuffer[])
javax.net.ssl.SSLEngine.unwrap(java.nio.ByteBuffer, java.nio.ByteBuffer[], int, int)
javax.security.sasl.SaslClient.unwrap(byte[], int, int)
javax.security.sasl.SaslServer.unwrap(byte[], int, int)
javax.sql.rowset.RowSetMetaDataImpl.unwrap(java.lang.Class)
org.ietf.jgss.GSSContext.unwrap(byte[], int, int, org.ietf.jgss.MessageProp)
org.ietf.jgss.GSSContext.unwrap(java.io.InputStream, java.io.OutputStream, org.ietf.jgss.MessageProp)


Occurences of UP

UP occurences:
java.awt.UP
java.math.UP


Occurences of update

update occurences:
java.awt.Canvas.update(java.awt.Graphics)
java.awt.Component.update(java.awt.Graphics)
java.awt.Container.update(java.awt.Graphics)
java.awt.SplashScreen.update()
java.security.MessageDigest.update(byte)
java.security.MessageDigest.update(byte[])
java.security.MessageDigest.update(byte[], int, int)
java.security.MessageDigest.update(java.nio.ByteBuffer)
java.security.Signature.update(byte)
java.security.Signature.update(byte[])
java.security.Signature.update(byte[], int, int)
java.security.Signature.update(java.nio.ByteBuffer)
java.util.Observer.update(java.util.Observable, java.lang.Object)
java.util.zip.Adler32.update(byte[])
java.util.zip.Adler32.update(byte[], int, int)
java.util.zip.Adler32.update(int)
java.util.zip.Checksum.update(byte[], int, int)
java.util.zip.Checksum.update(int)
java.util.zip.CRC32.update(byte[])
java.util.zip.CRC32.update(byte[], int, int)
java.util.zip.CRC32.update(int)
javax.crypto.Cipher.update(byte[])
javax.crypto.Cipher.update(byte[], int, int)
javax.crypto.Cipher.update(byte[], int, int, byte[])
javax.crypto.Cipher.update(byte[], int, int, byte[], int)
javax.crypto.Cipher.update(java.nio.ByteBuffer, java.nio.ByteBuffer)
javax.crypto.Mac.update(byte)
javax.crypto.Mac.update(byte[])
javax.crypto.Mac.update(byte[], int, int)
javax.crypto.Mac.update(java.nio.ByteBuffer)
javax.sound.sampled.LineListener.update(javax.sound.sampled.LineEvent)
javax.swing.CellRendererPane.update(java.awt.Graphics)
javax.swing.JApplet.update(java.awt.Graphics)
javax.swing.JComponent.update(java.awt.Graphics)
javax.swing.JDialog.update(java.awt.Graphics)
javax.swing.JFrame.update(java.awt.Graphics)
javax.swing.JWindow.update(java.awt.Graphics)
javax.swing.plaf.basic.BasicMenuItemUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.basic.BasicTextUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.ComponentUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalButtonUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalMenuBarUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalTabbedPaneUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalToggleButtonUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.metal.MetalToolBarUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiButtonUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiColorChooserUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiComboBoxUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopIconUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiDesktopPaneUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiFileChooserUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiInternalFrameUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiLabelUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiListUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuBarUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiMenuItemUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiOptionPaneUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiPanelUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiPopupMenuUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiProgressBarUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiRootPaneUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollBarUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiScrollPaneUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiSeparatorUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiSliderUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiSpinnerUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiSplitPaneUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTabbedPaneUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableHeaderUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTableUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTextUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolBarUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiToolTipUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiTreeUI.update(java.awt.Graphics, javax.swing.JComponent)
javax.swing.plaf.multi.MultiViewportUI.update(java.awt.Graphics, javax.swing.JComponent)


Occurences of UPDATE

UPDATE occurences:
java.awt.event.UPDATE
javax.accessibility.UPDATE
javax.swing.event.UPDATE


Occurences of updateArray

updateArray occurences:
java.sql.ResultSet.updateArray(int, java.sql.Array)
java.sql.ResultSet.updateArray(java.lang.String, java.sql.Array)


Occurences of updateAsciiStream

updateAsciiStream occurences:
java.sql.ResultSet.updateAsciiStream(int, java.io.InputStream)
java.sql.ResultSet.updateAsciiStream(int, java.io.InputStream, int)
java.sql.ResultSet.updateAsciiStream(int, java.io.InputStream, long)
java.sql.ResultSet.updateAsciiStream(java.lang.String, java.io.InputStream)
java.sql.ResultSet.updateAsciiStream(java.lang.String, java.io.InputStream, int)
java.sql.ResultSet.updateAsciiStream(java.lang.String, java.io.InputStream, long)


Occurences of updateBigDecimal

updateBigDecimal occurences:
java.sql.ResultSet.updateBigDecimal(int, java.math.BigDecimal)
java.sql.ResultSet.updateBigDecimal(java.lang.String, java.math.BigDecimal)


Occurences of updateBinaryStream

updateBinaryStream occurences:
java.sql.ResultSet.updateBinaryStream(int, java.io.InputStream)
java.sql.ResultSet.updateBinaryStream(int, java.io.InputStream, int)
java.sql.ResultSet.updateBinaryStream(int, java.io.InputStream, long)
java.sql.ResultSet.updateBinaryStream(java.lang.String, java.io.InputStream)
java.sql.ResultSet.updateBinaryStream(java.lang.String, java.io.InputStream, int)
java.sql.ResultSet.updateBinaryStream(java.lang.String, java.io.InputStream, long)


Occurences of updateBlob

updateBlob occurences:
java.sql.ResultSet.updateBlob(int, java.io.InputStream)
java.sql.ResultSet.updateBlob(int, java.io.InputStream, long)
java.sql.ResultSet.updateBlob(int, java.sql.Blob)
java.sql.ResultSet.updateBlob(java.lang.String, java.io.InputStream)
java.sql.ResultSet.updateBlob(java.lang.String, java.io.InputStream, long)
java.sql.ResultSet.updateBlob(java.lang.String, java.sql.Blob)


Occurences of updateBoolean

updateBoolean occurences:
java.sql.ResultSet.updateBoolean(int, boolean)
java.sql.ResultSet.updateBoolean(java.lang.String, boolean)


Occurences of updateByte

updateByte occurences:
java.sql.ResultSet.updateByte(int, byte)
java.sql.ResultSet.updateByte(java.lang.String, byte)


Occurences of updateBytes

updateBytes occurences:
java.sql.ResultSet.updateBytes(int, byte[])
java.sql.ResultSet.updateBytes(java.lang.String, byte[])


Occurences of updateCharacterStream

updateCharacterStream occurences:
java.sql.ResultSet.updateCharacterStream(int, java.io.Reader)
java.sql.ResultSet.updateCharacterStream(int, java.io.Reader, int)
java.sql.ResultSet.updateCharacterStream(int, java.io.Reader, long)
java.sql.ResultSet.updateCharacterStream(java.lang.String, java.io.Reader)
java.sql.ResultSet.updateCharacterStream(java.lang.String, java.io.Reader, int)
java.sql.ResultSet.updateCharacterStream(java.lang.String, java.io.Reader, long)


Occurences of updateChildren

updateChildren occurences:
javax.swing.text.View.updateChildren(javax.swing.event.DocumentEvent.ElementChange, javax.swing.event.DocumentEvent, javax.swing.text.ViewFactory)
javax.swing.text.ZoneView.updateChildren(javax.swing.event.DocumentEvent.ElementChange, javax.swing.event.DocumentEvent, javax.swing.text.ViewFactory)


Occurences of updateClob

updateClob occurences:
java.sql.ResultSet.updateClob(int, java.io.Reader)
java.sql.ResultSet.updateClob(int, java.io.Reader, long)
java.sql.ResultSet.updateClob(int, java.sql.Clob)
java.sql.ResultSet.updateClob(java.lang.String, java.io.Reader)
java.sql.ResultSet.updateClob(java.lang.String, java.io.Reader, long)
java.sql.ResultSet.updateClob(java.lang.String, java.sql.Clob)


Occurences of updateDate

updateDate occurences:
java.sql.ResultSet.updateDate(int, java.sql.Date)
java.sql.ResultSet.updateDate(java.lang.String, java.sql.Date)


Occurences of updateDouble

updateDouble occurences:
java.sql.ResultSet.updateDouble(int, double)
java.sql.ResultSet.updateDouble(java.lang.String, double)


Occurences of updateFloat

updateFloat occurences:
java.sql.ResultSet.updateFloat(int, float)
java.sql.ResultSet.updateFloat(java.lang.String, float)


Occurences of updateInt

updateInt occurences:
java.sql.ResultSet.updateInt(int, int)
java.sql.ResultSet.updateInt(java.lang.String, int)


Occurences of updateJAXB

updateJAXB occurences:
javax.xml.bind.Binder.updateJAXB(java.lang.Object)
javax.xml.bind.Binder.updateJAXB(XmlNode)


Occurences of updateLayout

updateLayout occurences:
javax.swing.text.AsyncBoxView.updateLayout(javax.swing.event.DocumentEvent.ElementChange, javax.swing.event.DocumentEvent, java.awt.Shape)
javax.swing.text.View.updateLayout(javax.swing.event.DocumentEvent.ElementChange, javax.swing.event.DocumentEvent, java.awt.Shape)


Occurences of updateLong

updateLong occurences:
java.sql.ResultSet.updateLong(int, long)
java.sql.ResultSet.updateLong(java.lang.String, long)


Occurences of updateNCharacterStream

updateNCharacterStream occurences:
java.sql.ResultSet.updateNCharacterStream(int, java.io.Reader)
java.sql.ResultSet.updateNCharacterStream(int, java.io.Reader, long)
java.sql.ResultSet.updateNCharacterStream(java.lang.String, java.io.Reader)
java.sql.ResultSet.updateNCharacterStream(java.lang.String, java.io.Reader, long)


Occurences of updateNClob

updateNClob occurences:
java.sql.ResultSet.updateNClob(int, java.io.Reader)
java.sql.ResultSet.updateNClob(int, java.io.Reader, long)
java.sql.ResultSet.updateNClob(int, java.sql.NClob)
java.sql.ResultSet.updateNClob(java.lang.String, java.io.Reader)
java.sql.ResultSet.updateNClob(java.lang.String, java.io.Reader, long)
java.sql.ResultSet.updateNClob(java.lang.String, java.sql.NClob)


Occurences of updateNString

updateNString occurences:
java.sql.ResultSet.updateNString(int, java.lang.String)
java.sql.ResultSet.updateNString(java.lang.String, java.lang.String)


Occurences of updateNull

updateNull occurences:
java.sql.ResultSet.updateNull(int)
java.sql.ResultSet.updateNull(java.lang.String)


Occurences of updateObject

updateObject occurences:
java.sql.ResultSet.updateObject(int, java.lang.Object)
java.sql.ResultSet.updateObject(int, java.lang.Object, int)
java.sql.ResultSet.updateObject(java.lang.String, java.lang.Object)
java.sql.ResultSet.updateObject(java.lang.String, java.lang.Object, int)


Occurences of updateRef

updateRef occurences:
java.sql.ResultSet.updateRef(int, java.sql.Ref)
java.sql.ResultSet.updateRef(java.lang.String, java.sql.Ref)


Occurences of updateRenderer

updateRenderer occurences:
javax.swing.plaf.basic.BasicHTML.updateRenderer(javax.swing.JComponent, java.lang.String)
javax.swing.plaf.basic.BasicTreeUI.updateRenderer()


Occurences of updateRoleMap

updateRoleMap occurences:
javax.management.relation.RelationService.updateRoleMap(java.lang.String, javax.management.relation.Role, java.util.List)
javax.management.relation.RelationServiceMBean.updateRoleMap(java.lang.String, javax.management.relation.Role, java.util.List)


Occurences of updateRowId

updateRowId occurences:
java.sql.ResultSet.updateRowId(int, java.sql.RowId)
java.sql.ResultSet.updateRowId(java.lang.String, java.sql.RowId)


Occurences of updateShort

updateShort occurences:
java.sql.ResultSet.updateShort(int, short)
java.sql.ResultSet.updateShort(java.lang.String, short)


Occurences of updateSQLXML

updateSQLXML occurences:
java.sql.ResultSet.updateSQLXML(int, java.sql.SQLXML)
java.sql.ResultSet.updateSQLXML(java.lang.String, java.sql.SQLXML)


Occurences of updateString

updateString occurences:
java.sql.ResultSet.updateString(int, java.lang.String)
java.sql.ResultSet.updateString(java.lang.String, java.lang.String)


Occurences of updateTime

updateTime occurences:
java.sql.ResultSet.updateTime(int, java.sql.Time)
java.sql.ResultSet.updateTime(java.lang.String, java.sql.Time)


Occurences of updateTimestamp

updateTimestamp occurences:
java.sql.ResultSet.updateTimestamp(int, java.sql.Timestamp)
java.sql.ResultSet.updateTimestamp(java.lang.String, java.sql.Timestamp)


Occurences of updateUI

updateUI occurences:
javax.swing.AbstractButton.updateUI()
javax.swing.JButton.updateUI()
javax.swing.JCheckBox.updateUI()
javax.swing.JColorChooser.updateUI()
javax.swing.JComboBox.updateUI()
javax.swing.JComponent.updateUI()
javax.swing.JDesktopPane.updateUI()
javax.swing.JFileChooser.updateUI()
javax.swing.JInternalFrame.updateUI()
javax.swing.JInternalFrame.JDesktopIcon.updateUI()
javax.swing.JLabel.updateUI()
javax.swing.JList.updateUI()
javax.swing.JMenu.updateUI()
javax.swing.JMenuBar.updateUI()
javax.swing.JMenuItem.updateUI()
javax.swing.JOptionPane.updateUI()
javax.swing.JPanel.updateUI()
javax.swing.JPasswordField.updateUI()
javax.swing.JPopupMenu.updateUI()
javax.swing.JProgressBar.updateUI()
javax.swing.JRadioButton.updateUI()
javax.swing.JRootPane.updateUI()
javax.swing.JScrollBar.updateUI()
javax.swing.JScrollPane.updateUI()
javax.swing.JSeparator.updateUI()
javax.swing.JSlider.updateUI()
javax.swing.JSpinner.updateUI()
javax.swing.JSplitPane.updateUI()
javax.swing.JTabbedPane.updateUI()
javax.swing.JTable.updateUI()
javax.swing.JToggleButton.updateUI()
javax.swing.JToolBar.updateUI()
javax.swing.JToolTip.updateUI()
javax.swing.JTree.updateUI()
javax.swing.JViewport.updateUI()
javax.swing.table.DefaultTableCellRenderer.updateUI()
javax.swing.table.JTableHeader.updateUI()
javax.swing.text.JTextComponent.updateUI()


Occurences of updateUndoPositions

updateUndoPositions occurences:
javax.swing.text.GapContent.updateUndoPositions(java.util.Vector, int, int)
javax.swing.text.StringContent.updateUndoPositions(java.util.Vector)


Occurences of updateXML

updateXML occurences:
javax.xml.bind.Binder.updateXML(java.lang.Object)
javax.xml.bind.Binder.updateXML(java.lang.Object, XmlNode)
javax.xml.bind.Binder.updateXML(java.lang.Object,java.lang.Object)


Occurences of upFocusCycle

upFocusCycle occurences:
java.awt.DefaultKeyboardFocusManager.upFocusCycle(java.awt.Component)
java.awt.KeyboardFocusManager.upFocusCycle()
java.awt.KeyboardFocusManager.upFocusCycle(java.awt.Component)


Occurences of Upgrading From the Microsoft to the Sun Java Virtual Machine

Upgrading From the Microsoft to the Sun Java Virtual Machine occurences:
Upgrading From the Microsoft to the Sun Java Virtual Machine
Upgrading From the Microsoft to the Sun Java Virtual Machine


Occurences of upKey

upKey occurences:
javax.swing.plaf.basic.upKey
javax.swing.plaf.basic.upKey
javax.swing.plaf.basic.upKey


Occurences of upperLeft

upperLeft occurences:
javax.swing.upperLeft
javax.swing.upperLeft


Occurences of upperRight

upperRight occurences:
javax.swing.upperRight
javax.swing.upperRight


Occurences of URI (constructors)

URI (constructors) occurences:
java.net.URI(java.lang.String)
java.net.URI(java.lang.String, java.lang.String, java.lang.String)
java.net.URI(java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String)
java.net.URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
java.net.URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)


Occurences of URIReferenceException (constructors)

URIReferenceException (constructors) occurences:
javax.xml.crypto.URIReferenceException()
javax.xml.crypto.URIReferenceException(java.lang.String)
javax.xml.crypto.URIReferenceException(java.lang.String, java.lang.Throwable)
javax.xml.crypto.URIReferenceException(java.lang.String, java.lang.Throwable, javax.xml.crypto.URIReference)
javax.xml.crypto.URIReferenceException(java.lang.Throwable)


Occurences of URISyntaxException (constructors)

URISyntaxException (constructors) occurences:
java.net.URISyntaxException(java.lang.String, java.lang.String)
java.net.URISyntaxException(java.lang.String, java.lang.String, int)


Occurences of URL (constructors)

URL (constructors) occurences:
java.net.URL(java.lang.String)
java.net.URL(java.lang.String, java.lang.String, int, java.lang.String)
java.net.URL(java.lang.String, java.lang.String, int, java.lang.String, java.net.URLStreamHandler)
java.net.URL(java.lang.String, java.lang.String, java.lang.String)
java.net.URL(java.net.URL, java.lang.String)
java.net.URL(java.net.URL, java.lang.String, java.net.URLStreamHandler)


Occurences of URLClassLoader (constructors)

URLClassLoader (constructors) occurences:
java.net.URLClassLoader(java.net.URL[])
java.net.URLClassLoader(java.net.URL[], java.lang.ClassLoader)
java.net.URLClassLoader(java.net.URL[], java.lang.ClassLoader, java.net.URLStreamHandlerFactory)


Occurences of useDaylightTime

useDaylightTime occurences:
java.util.SimpleTimeZone.useDaylightTime()
java.util.TimeZone.useDaylightTime()


Occurences of useDelimiter

useDelimiter occurences:
java.util.Scanner.useDelimiter(java.lang.String)
java.util.Scanner.useDelimiter(java.util.regex.Pattern)


Occurences of UserException (constructors)

UserException (constructors) occurences:
org.omg.CORBA.UserException()
org.omg.CORBA.UserException(java.lang.String)


Occurences of userRoot

userRoot occurences:
java.util.prefs.Preferences.userRoot()
java.util.prefs.PreferencesFactory.userRoot()


Occurences of useToString

useToString occurences:
javax.swing.DefaultRowSorter.useToString(int)
javax.swing.table.TableRowSorter.useToString(int)


Occurences of UShortSeqHolder (constructors)

UShortSeqHolder (constructors) occurences:
org.omg.CORBA.UShortSeqHolder()
org.omg.CORBA.UShortSeqHolder(short[])


Occurences of Using Externalization and Evolution

Using Externalization and Evolution occurences:
Using Externalization and Evolution
Using Externalization and Evolution
Using Externalization and Evolution


Occurences of Using Serialization and the Serializable Fields API

Using Serialization and the Serializable Fields API occurences:
Using Serialization and the Serializable Fields API
Using Serialization and the Serializable Fields API
Using Serialization and the Serializable Fields API


Occurences of Using Serialization with a Custom Data Format

Using Serialization with a Custom Data Format occurences:
Using Serialization with a Custom Data Format
Using Serialization with a Custom Data Format
Using Serialization with a Custom Data Format


Occurences of Using Serialization with a NonSerializable Superclass

Using Serialization with a NonSerializable Superclass occurences:
Using Serialization with a NonSerializable Superclass
Using Serialization with a NonSerializable Superclass
Using Serialization with a NonSerializable Superclass


Occurences of Using Serialization with Evolution

Using Serialization with Evolution occurences:
Using Serialization with Evolution
Using Serialization with Evolution
Using Serialization with Evolution


Occurences of Using Serialization with Sockets

Using Serialization with Sockets occurences:
Using Serialization with Sockets
Using Serialization with Sockets
Using Serialization with Sockets


Occurences of UTFDataFormatException (constructors)

UTFDataFormatException (constructors) occurences:
java.io.UTFDataFormatException()
java.io.UTFDataFormatException(java.lang.String)


Occurences of util

util occurences:
com.sun.mirror.util
com.sun.source.util
java.util
javax.lang.model.util
javax.xml.bind.util
javax.xml.stream.util


Occurences of validate

validate occurences:
java.awt.Component.validate()
java.awt.Container.validate()
java.awt.image.VolatileImage.validate(java.awt.GraphicsConfiguration)
java.security.cert.CertPathValidator.validate(java.security.cert.CertPath, java.security.cert.CertPathParameters)
javax.swing.DefaultListCellRenderer.validate()
javax.swing.table.DefaultTableCellRenderer.validate()
javax.swing.tree.DefaultTreeCellRenderer.validate()
javax.xml.bind.Validator.validate(java.lang.Object)
javax.xml.crypto.dsig.Reference.validate(javax.xml.crypto.dsig.XMLValidateContext)
javax.xml.crypto.dsig.XMLSignature.validate(javax.xml.crypto.dsig.XMLValidateContext)
javax.xml.crypto.dsig.XMLSignature.SignatureValue.validate(javax.xml.crypto.dsig.XMLValidateContext)
javax.xml.validation.Validator.validate(javax.xml.transform.Source)
javax.xml.validation.Validator.validate(javax.xml.transform.Source, javax.xml.transform.Result)


Occurences of validatedContents

validatedContents occurences:
java.awt.validatedContents
java.awt.validatedContents


Occurences of ValidationEventImpl (constructors)

ValidationEventImpl (constructors) occurences:
javax.xml.bind.helpers.ValidationEventImpl(int, java.lang.String, javax.xml.bind.ValidationEventLocator)
javax.xml.bind.helpers.ValidationEventImpl(int, java.lang.String, javax.xml.bind.ValidationEventLocator, java.lang.Throwable)


Occurences of ValidationEventLocatorImpl (constructors)

ValidationEventLocatorImpl (constructors) occurences:
javax.xml.bind.helpers.ValidationEventLocatorImpl()
javax.xml.bind.helpers.ValidationEventLocatorImpl(java.lang.Object)
javax.xml.bind.helpers.ValidationEventLocatorImpl(org.w3c.dom.Node)
javax.xml.bind.helpers.ValidationEventLocatorImpl(org.xml.sax.Locator)
javax.xml.bind.helpers.ValidationEventLocatorImpl(org.xml.sax.SAXParseException)


Occurences of ValidationException (constructors)

ValidationException (constructors) occurences:
javax.xml.bind.ValidationException(java.lang.String)
javax.xml.bind.ValidationException(java.lang.String, java.lang.String)
javax.xml.bind.ValidationException(java.lang.String, java.lang.String, java.lang.Throwable)
javax.xml.bind.ValidationException(java.lang.String, java.lang.Throwable)
javax.xml.bind.ValidationException(java.lang.Throwable)


Occurences of Validator

Validator occurences:
javax.xml.bind.Validator
javax.xml.validation.Validator


Occurences of validOps

validOps occurences:
java.nio.channels.DatagramChannel.validOps()
java.nio.channels.Pipe.SinkChannel.validOps()
java.nio.channels.Pipe.SourceChannel.validOps()
java.nio.channels.SelectableChannel.validOps()
java.nio.channels.ServerSocketChannel.validOps()
java.nio.channels.SocketChannel.validOps()


Occurences of value

value occurences:
com.sun.javadoc.AnnotationDesc.ElementValuePair.value()
com.sun.javadoc.AnnotationValue.value()
com.sun.jdi.BooleanValue.value()
com.sun.jdi.ByteValue.value()
com.sun.jdi.CharValue.value()
com.sun.jdi.connect.Connector.Argument.value()
com.sun.jdi.DoubleValue.value()
com.sun.jdi.FloatValue.value()
com.sun.jdi.IntegerValue.value()
com.sun.jdi.LongValue.value()
com.sun.jdi.ShortValue.value()
com.sun.jdi.StringReference.value()
java.beans.ConstructorProperties.value()
java.lang.annotation.Retention.value()
java.lang.annotation.Target.value()
java.lang.SuppressWarnings.value()
java.sql.value
javax.annotation.Generated.value()
javax.annotation.processing.SupportedAnnotationTypes.value()
javax.annotation.processing.SupportedOptions.value()
javax.annotation.processing.SupportedSourceVersion.value()
javax.annotation.Resources.value()
javax.jws.soap.InitParam.value()
javax.jws.soap.SOAPMessageHandlers.value()
javax.management.DescriptorKey.value()
javax.management.MXBean.value()
javax.management.Query.value(boolean)
javax.management.Query.value(double)
javax.management.Query.value(float)
javax.management.Query.value(int)
javax.management.Query.value(java.lang.Number)
javax.management.Query.value(java.lang.String)
javax.management.Query.value(long)
javax.naming.ldap.value
javax.swing.text.html.parser.value
javax.swing.value
javax.swing.value
javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter.value()
javax.xml.bind.annotation.adapters.XmlJavaTypeAdapters.value()
javax.xml.bind.annotation.XmlAccessorOrder.value()
javax.xml.bind.annotation.XmlAccessorType.value()
javax.xml.bind.annotation.XmlAnyElement.value()
javax.xml.bind.annotation.XmlElementRefs.value()
javax.xml.bind.annotation.XmlElements.value()
javax.xml.bind.annotation.XmlEnum.value()
javax.xml.bind.annotation.XmlEnumValue.value()
javax.xml.bind.annotation.XmlMimeType.value()
javax.xml.bind.annotation.XmlSchemaTypes.value()
javax.xml.bind.value
javax.xml.ws.BindingType.value()
javax.xml.ws.ServiceMode.value()
javax.xml.ws.value
javax.xml.ws.WebServiceRef.value()
javax.xml.ws.WebServiceRefs.value()
org.omg.CORBA.CompletionStatus.value()
org.omg.CORBA.DefinitionKind.value()
org.omg.CORBA.NamedValue.value()
org.omg.CORBA.ParameterMode.value()
org.omg.CORBA.SetOverrideType.value()
org.omg.CORBA.TCKind.value()
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CORBA.value
org.omg.CosNaming.BindingType.value()
org.omg.CosNaming.NamingContextExtPackage.value
org.omg.CosNaming.NamingContextPackage.NotFoundReason.value()
org.omg.CosNaming.NamingContextPackage.value
org.omg.CosNaming.NamingContextPackage.value
org.omg.CosNaming.NamingContextPackage.value
org.omg.CosNaming.NamingContextPackage.value
org.omg.CosNaming.NamingContextPackage.value
org.omg.CosNaming.NamingContextPackage.value
org.omg.CosNaming.value
org.omg.CosNaming.value
org.omg.CosNaming.value
org.omg.CosNaming.value
org.omg.CosNaming.value
org.omg.CosNaming.value
org.omg.CosNaming.value
org.omg.CosNaming.value
org.omg.DynamicAny.value
org.omg.DynamicAny.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.IOP.value
org.omg.Messaging.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableInterceptor.value
org.omg.PortableServer.IdAssignmentPolicyOperations.value()
org.omg.PortableServer.IdAssignmentPolicyValue.value()
org.omg.PortableServer.IdUniquenessPolicyOperations.value()
org.omg.PortableServer.IdUniquenessPolicyValue.value()
org.omg.PortableServer.ImplicitActivationPolicyOperations.value()
org.omg.PortableServer.ImplicitActivationPolicyValue.value()
org.omg.PortableServer.LifespanPolicyOperations.value()
org.omg.PortableServer.LifespanPolicyValue.value()
org.omg.PortableServer.POAManagerPackage.State.value()
org.omg.PortableServer.RequestProcessingPolicyOperations.value()
org.omg.PortableServer.RequestProcessingPolicyValue.value()
org.omg.PortableServer.ServantLocatorPackage.value
org.omg.PortableServer.ServantRetentionPolicyOperations.value()
org.omg.PortableServer.ServantRetentionPolicyValue.value()
org.omg.PortableServer.ThreadPolicyOperations.value()
org.omg.PortableServer.ThreadPolicyValue.value()
org.omg.PortableServer.value
org.omg.PortableServer.value
org.omg.PortableServer.value
org.omg.PortableServer.value
org.omg.PortableServer.value
org.omg.PortableServer.value
org.omg.PortableServer.value


Occurences of ValueBaseHolder (constructors)

ValueBaseHolder (constructors) occurences:
org.omg.CORBA.ValueBaseHolder()
org.omg.CORBA.ValueBaseHolder(java.io.Serializable)


Occurences of valueChanged

valueChanged occurences:
javax.swing.event.ListSelectionListener.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.event.TreeSelectionListener.valueChanged(javax.swing.event.TreeSelectionEvent)
javax.swing.JList.AccessibleJList.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.JTable.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.JTable.AccessibleJTable.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.JTree.AccessibleJTree.valueChanged(javax.swing.event.TreeSelectionEvent)
javax.swing.JTree.TreeSelectionRedirector.valueChanged(javax.swing.event.TreeSelectionEvent)
javax.swing.plaf.basic.BasicComboPopup.ListSelectionHandler.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.plaf.basic.BasicFileChooserUI.SelectionListener.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.plaf.basic.BasicListUI.ListSelectionHandler.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.plaf.basic.BasicTreeUI.TreeSelectionHandler.valueChanged(javax.swing.event.TreeSelectionEvent)
javax.swing.plaf.metal.MetalFileChooserUI.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.table.DefaultTableColumnModel.valueChanged(javax.swing.event.ListSelectionEvent)
javax.swing.tree.DefaultTreeCellEditor.valueChanged(javax.swing.event.TreeSelectionEvent)


Occurences of valueForPathChanged

valueForPathChanged occurences:
javax.swing.tree.DefaultTreeModel.valueForPathChanged(javax.swing.tree.TreePath, java.lang.Object)
javax.swing.tree.TreeModel.valueForPathChanged(javax.swing.tree.TreePath, java.lang.Object)


Occurences of ValueMember (constructors)

ValueMember (constructors) occurences:
org.omg.CORBA.ValueMember()
org.omg.CORBA.ValueMember(java.lang.String, java.lang.String, java.lang.String, java.lang.String, org.omg.CORBA.TypeCode, org.omg.CORBA.IDLType, short)


Occurences of valueOf

valueOf occurences:
com.sun.javadoc.LanguageVersion.valueOf(java.lang.String)
com.sun.mirror.apt.Filer.Location.valueOf(java.lang.String)
com.sun.mirror.declaration.Modifier.valueOf(java.lang.String)
com.sun.mirror.type.PrimitiveType.Kind.valueOf(java.lang.String)
com.sun.source.tree.Tree.Kind.valueOf(java.lang.String)
com.sun.source.util.TaskEvent.Kind.valueOf(java.lang.String)
com.sun.tools.jconsole.JConsoleContext.ConnectionState.valueOf(java.lang.String)
java.awt.Component.BaselineResizeBehavior.valueOf(java.lang.String)
java.awt.Desktop.Action.valueOf(java.lang.String)
java.awt.Dialog.ModalExclusionType.valueOf(java.lang.String)
java.awt.Dialog.ModalityType.valueOf(java.lang.String)
java.awt.MultipleGradientPaint.ColorSpaceType.valueOf(java.lang.String)
java.awt.MultipleGradientPaint.CycleMethod.valueOf(java.lang.String)
java.awt.TrayIcon.MessageType.valueOf(java.lang.String)
java.lang.annotation.ElementType.valueOf(java.lang.String)
java.lang.annotation.RetentionPolicy.valueOf(java.lang.String)
java.lang.Boolean.valueOf(boolean)
java.lang.Boolean.valueOf(java.lang.String)
java.lang.Byte.valueOf(byte)
java.lang.Byte.valueOf(java.lang.String)
java.lang.Byte.valueOf(java.lang.String, int)
java.lang.Character.valueOf(char)
java.lang.Double.valueOf(double)
java.lang.Double.valueOf(java.lang.String)
java.lang.Enum.valueOf(java.lang.Class, java.lang.String)
java.lang.Float.valueOf(float)
java.lang.Float.valueOf(java.lang.String)
java.lang.Integer.valueOf(int)
java.lang.Integer.valueOf(java.lang.String)
java.lang.Integer.valueOf(java.lang.String, int)
java.lang.Long.valueOf(java.lang.String)
java.lang.Long.valueOf(java.lang.String, int)
java.lang.Long.valueOf(long)
java.lang.management.MemoryType.valueOf(java.lang.String)
java.lang.Short.valueOf(java.lang.String)
java.lang.Short.valueOf(java.lang.String, int)
java.lang.Short.valueOf(short)
java.lang.String.valueOf(boolean)
java.lang.String.valueOf(char)
java.lang.String.valueOf(char[])
java.lang.String.valueOf(char[], int, int)
java.lang.String.valueOf(double)
java.lang.String.valueOf(float)
java.lang.String.valueOf(int)
java.lang.String.valueOf(java.lang.Object)
java.lang.String.valueOf(long)
java.lang.Thread.State.valueOf(java.lang.String)
java.math.BigDecimal.valueOf(double)
java.math.BigDecimal.valueOf(long)
java.math.BigDecimal.valueOf(long, int)
java.math.BigInteger.valueOf(long)
java.math.RoundingMode.valueOf(int)
java.math.RoundingMode.valueOf(java.lang.String)
java.net.Authenticator.RequestorType.valueOf(java.lang.String)
java.net.Proxy.Type.valueOf(java.lang.String)
java.security.KeyRep.Type.valueOf(java.lang.String)
java.sql.ClientInfoStatus.valueOf(java.lang.String)
java.sql.Date.valueOf(java.lang.String)
java.sql.RowIdLifetime.valueOf(java.lang.String)
java.sql.Time.valueOf(java.lang.String)
java.sql.Timestamp.valueOf(java.lang.String)
java.text.Normalizer.Form.valueOf(java.lang.String)
java.util.concurrent.TimeUnit.valueOf(java.lang.String)
java.util.Formatter.BigDecimalLayoutForm.valueOf(java.lang.String)
javax.annotation.Resource.AuthenticationType.valueOf(java.lang.String)
javax.jws.soap.SOAPBinding.ParameterStyle.valueOf(java.lang.String)
javax.jws.soap.SOAPBinding.Style.valueOf(java.lang.String)
javax.jws.soap.SOAPBinding.Use.valueOf(java.lang.String)
javax.jws.WebParam.Mode.valueOf(java.lang.String)
javax.lang.model.element.ElementKind.valueOf(java.lang.String)
javax.lang.model.element.Modifier.valueOf(java.lang.String)
javax.lang.model.element.NestingKind.valueOf(java.lang.String)
javax.lang.model.SourceVersion.valueOf(java.lang.String)
javax.lang.model.type.TypeKind.valueOf(java.lang.String)
javax.net.ssl.SSLEngineResult.HandshakeStatus.valueOf(java.lang.String)
javax.net.ssl.SSLEngineResult.Status.valueOf(java.lang.String)
javax.swing.DropMode.valueOf(java.lang.String)
javax.swing.event.RowSorterEvent.Type.valueOf(java.lang.String)
javax.swing.GroupLayout.Alignment.valueOf(java.lang.String)
javax.swing.JTable.PrintMode.valueOf(java.lang.String)
javax.swing.LayoutStyle.ComponentPlacement.valueOf(java.lang.String)
javax.swing.RowFilter.ComparisonType.valueOf(java.lang.String)
javax.swing.SortOrder.valueOf(java.lang.String)
javax.swing.SwingWorker.StateValue.valueOf(java.lang.String)
javax.swing.text.html.FormSubmitEvent.MethodType.valueOf(java.lang.String)
javax.tools.Diagnostic.Kind.valueOf(java.lang.String)
javax.tools.JavaFileObject.Kind.valueOf(java.lang.String)
javax.tools.StandardLocation.valueOf(java.lang.String)
javax.xml.bind.annotation.XmlAccessOrder.valueOf(java.lang.String)
javax.xml.bind.annotation.XmlAccessType.valueOf(java.lang.String)
javax.xml.bind.annotation.XmlNsForm.valueOf(java.lang.String)
javax.xml.namespace.QName.valueOf(java.lang.String)
javax.xml.ws.handler.MessageContext.Scope.valueOf(java.lang.String)
javax.xml.ws.Service.Mode.valueOf(java.lang.String)


Occurences of values

values occurences:
com.sun.javadoc.LanguageVersion.values()
com.sun.mirror.apt.Filer.Location.values()
com.sun.mirror.declaration.Modifier.values()
com.sun.mirror.type.PrimitiveType.Kind.values()
com.sun.source.tree.Tree.Kind.values()
com.sun.source.util.TaskEvent.Kind.values()
com.sun.tools.jconsole.JConsoleContext.ConnectionState.values()
java.awt.Component.BaselineResizeBehavior.values()
java.awt.Desktop.Action.values()
java.awt.Dialog.ModalExclusionType.values()
java.awt.Dialog.ModalityType.values()
java.awt.MultipleGradientPaint.ColorSpaceType.values()
java.awt.MultipleGradientPaint.CycleMethod.values()
java.awt.RenderingHints.values()
java.awt.TrayIcon.MessageType.values()
java.lang.annotation.ElementType.values()
java.lang.annotation.RetentionPolicy.values()
java.lang.management.MemoryType.values()
java.lang.Thread.State.values()
java.math.RoundingMode.values()
java.net.Authenticator.RequestorType.values()
java.net.Proxy.Type.values()
java.security.KeyRep.Type.values()
java.security.Provider.values()
java.sql.ClientInfoStatus.values()
java.sql.RowIdLifetime.values()
java.text.Normalizer.Form.values()
java.util.AbstractMap.values()
java.util.concurrent.ConcurrentHashMap.values()
java.util.concurrent.ConcurrentSkipListMap.values()
java.util.concurrent.TimeUnit.values()
java.util.EnumMap.values()
java.util.Formatter.BigDecimalLayoutForm.values()
java.util.HashMap.values()
java.util.Hashtable.values()
java.util.IdentityHashMap.values()
java.util.jar.Attributes.values()
java.util.Map.values()
java.util.SortedMap.values()
java.util.TreeMap.values()
java.util.WeakHashMap.values()
javax.annotation.Resource.AuthenticationType.values()
javax.jws.soap.SOAPBinding.ParameterStyle.values()
javax.jws.soap.SOAPBinding.Style.values()
javax.jws.soap.SOAPBinding.Use.values()
javax.jws.WebParam.Mode.values()
javax.lang.model.element.ElementKind.values()
javax.lang.model.element.Modifier.values()
javax.lang.model.element.NestingKind.values()
javax.lang.model.SourceVersion.values()
javax.lang.model.type.TypeKind.values()
javax.management.openmbean.CompositeData.values()
javax.management.openmbean.CompositeDataSupport.values()
javax.management.openmbean.TabularData.values()
javax.management.openmbean.TabularDataSupport.values()
javax.naming.directory.values
javax.net.ssl.SSLEngineResult.HandshakeStatus.values()
javax.net.ssl.SSLEngineResult.Status.values()
javax.script.SimpleBindings.values()
javax.swing.DropMode.values()
javax.swing.event.RowSorterEvent.Type.values()
javax.swing.GroupLayout.Alignment.values()
javax.swing.JTable.PrintMode.values()
javax.swing.LayoutStyle.ComponentPlacement.values()
javax.swing.RowFilter.ComparisonType.values()
javax.swing.SortOrder.values()
javax.swing.SwingWorker.StateValue.values()
javax.swing.text.html.FormSubmitEvent.MethodType.values()
javax.swing.text.html.parser.values
javax.tools.Diagnostic.Kind.values()
javax.tools.JavaFileObject.Kind.values()
javax.tools.StandardLocation.values()
javax.xml.bind.annotation.XmlAccessOrder.values()
javax.xml.bind.annotation.XmlAccessType.values()
javax.xml.bind.annotation.XmlNsForm.values()
javax.xml.ws.handler.MessageContext.Scope.values()
javax.xml.ws.Service.Mode.values()


Occurences of valueToString

valueToString occurences:
javax.swing.JFormattedTextField.AbstractFormatter.valueToString(java.lang.Object)
javax.swing.text.DefaultFormatter.valueToString(java.lang.Object)
javax.swing.text.InternationalFormatter.valueToString(java.lang.Object)
javax.swing.text.MaskFormatter.valueToString(java.lang.Object)


Occurences of value_as_string

value_as_string occurences:
org.omg.CORBA.DynEnum.value_as_string()
org.omg.CORBA.DynEnum.value_as_string(java.lang.String)


Occurences of value_as_ulong

value_as_ulong occurences:
org.omg.CORBA.DynEnum.value_as_ulong()
org.omg.CORBA.DynEnum.value_as_ulong(int)


Occurences of Vector (constructors)

Vector (constructors) occurences:
java.util.Vector()
java.util.Vector(int)
java.util.Vector(int, int)
java.util.Vector(java.util.Collection)


Occurences of verify

verify occurences:
java.security.cert.Certificate.verify(java.security.PublicKey)
java.security.cert.Certificate.verify(java.security.PublicKey, java.lang.String)
java.security.cert.X509CRL.verify(java.security.PublicKey)
java.security.cert.X509CRL.verify(java.security.PublicKey, java.lang.String)
java.security.Signature.verify(byte[])
java.security.Signature.verify(byte[], int, int)
java.security.SignedObject.verify(java.security.PublicKey, java.security.Signature)
javax.net.ssl.HostnameVerifier.verify(java.lang.String, javax.net.ssl.SSLSession)
javax.security.cert.Certificate.verify(java.security.PublicKey)
javax.security.cert.Certificate.verify(java.security.PublicKey, java.lang.String)
javax.swing.InputVerifier.verify(javax.swing.JComponent)


Occurences of VERIFY

VERIFY occurences:
java.security.VERIFY
javax.xml.crypto.VERIFY


Occurences of VerifyError (constructors)

VerifyError (constructors) occurences:
java.lang.VerifyError()
java.lang.VerifyError(java.lang.String)


Occurences of verifyMIC

verifyMIC occurences:
org.ietf.jgss.GSSContext.verifyMIC(byte[], int, int, byte[], int, int, org.ietf.jgss.MessageProp)
org.ietf.jgss.GSSContext.verifyMIC(java.io.InputStream, java.io.InputStream, org.ietf.jgss.MessageProp)


Occurences of version

version occurences:
com.sun.jdi.VirtualMachine.version()
java.util.UUID.version()
javax.imageio.spi.version
org.omg.CORBA.version


Occurences of VERSION

VERSION occurences:
javax.swing.text.html.VERSION
javax.xml.transform.VERSION


Occurences of Versions Formats

Versions Formats occurences:
Versions Formats
Versions Formats


Occurences of VERTICAL

VERTICAL occurences:
java.awt.VERTICAL
java.awt.VERTICAL
java.awt.VERTICAL
javax.accessibility.VERTICAL
javax.swing.VERTICAL
javax.swing.VERTICAL


Occurences of vetoableChange

vetoableChange occurences:
java.beans.beancontext.BeanContextSupport.vetoableChange(java.beans.PropertyChangeEvent)
java.beans.VetoableChangeListener.vetoableChange(java.beans.PropertyChangeEvent)
java.beans.VetoableChangeListenerProxy.vetoableChange(java.beans.PropertyChangeEvent)


Occurences of VIEWPORT

VIEWPORT occurences:
javax.accessibility.VIEWPORT
javax.swing.plaf.synth.VIEWPORT
javax.swing.VIEWPORT


Occurences of viewport

viewport occurences:
javax.swing.viewport
javax.swing.viewport


Occurences of viewToModel

viewToModel occurences:
javax.swing.plaf.basic.BasicTextUI.viewToModel(javax.swing.text.JTextComponent, java.awt.Point)
javax.swing.plaf.basic.BasicTextUI.viewToModel(javax.swing.text.JTextComponent, java.awt.Point, javax.swing.text.Position.Bias[])
javax.swing.plaf.multi.MultiTextUI.viewToModel(javax.swing.text.JTextComponent, java.awt.Point)
javax.swing.plaf.multi.MultiTextUI.viewToModel(javax.swing.text.JTextComponent, java.awt.Point, javax.swing.text.Position.Bias[])
javax.swing.plaf.TextUI.viewToModel(javax.swing.text.JTextComponent, java.awt.Point)
javax.swing.plaf.TextUI.viewToModel(javax.swing.text.JTextComponent, java.awt.Point, javax.swing.text.Position.Bias[])
javax.swing.text.AsyncBoxView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.BoxView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.ComponentView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.CompositeView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.FieldView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.GlyphView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.GlyphView.GlyphPainter.viewToModel(javax.swing.text.GlyphView, float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.html.ImageView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.IconView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.JTextComponent.viewToModel(java.awt.Point)
javax.swing.text.PasswordView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.PlainView.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])
javax.swing.text.View.viewToModel(float, float, java.awt.Shape)
javax.swing.text.View.viewToModel(float, float, java.awt.Shape, javax.swing.text.Position.Bias[])


Occurences of VirtualMachine

VirtualMachine occurences:
com.sun.jdi.VirtualMachine
com.sun.tools.attach.VirtualMachine


Occurences of VirtualMachineDescriptor (constructors)

VirtualMachineDescriptor (constructors) occurences:
com.sun.tools.attach.VirtualMachineDescriptor(com.sun.tools.attach.spi.AttachProvider, java.lang.String)
com.sun.tools.attach.VirtualMachineDescriptor(com.sun.tools.attach.spi.AttachProvider, java.lang.String, java.lang.String)


Occurences of VirtualMachineError (constructors)

VirtualMachineError (constructors) occurences:
java.lang.VirtualMachineError()
java.lang.VirtualMachineError(java.lang.String)


Occurences of visit

visit occurences:
com.sun.source.util.SimpleTreeVisitor.visit(com.sun.source.tree.Tree, P)
com.sun.source.util.SimpleTreeVisitor.visit(com.sun.source.tree.Tree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visit(java.lang.Iterable, P)
com.sun.source.util.SimpleTreeVisitor.visit(java.lang.Iterable,java.lang.Object)
javax.lang.model.element.AnnotationValueVisitor.visit(javax.lang.model.element.AnnotationValue)
javax.lang.model.element.AnnotationValueVisitor.visit(javax.lang.model.element.AnnotationValue, P)
javax.lang.model.element.AnnotationValueVisitor.visit(javax.lang.model.element.AnnotationValue,java.lang.Object)
javax.lang.model.element.ElementVisitor.visit(javax.lang.model.element.Element)
javax.lang.model.element.ElementVisitor.visit(javax.lang.model.element.Element, P)
javax.lang.model.element.ElementVisitor.visit(javax.lang.model.element.Element,java.lang.Object)
javax.lang.model.type.TypeVisitor.visit(javax.lang.model.type.TypeMirror)
javax.lang.model.type.TypeVisitor.visit(javax.lang.model.type.TypeMirror, P)
javax.lang.model.type.TypeVisitor.visit(javax.lang.model.type.TypeMirror,java.lang.Object)
javax.lang.model.util.AbstractAnnotationValueVisitor6.visit(javax.lang.model.element.AnnotationValue)
javax.lang.model.util.AbstractAnnotationValueVisitor6.visit(javax.lang.model.element.AnnotationValue, P)
javax.lang.model.util.AbstractAnnotationValueVisitor6.visit(javax.lang.model.element.AnnotationValue,java.lang.Object)
javax.lang.model.util.AbstractElementVisitor6.visit(javax.lang.model.element.Element)
javax.lang.model.util.AbstractElementVisitor6.visit(javax.lang.model.element.Element, P)
javax.lang.model.util.AbstractElementVisitor6.visit(javax.lang.model.element.Element,java.lang.Object)
javax.lang.model.util.AbstractTypeVisitor6.visit(javax.lang.model.type.TypeMirror)
javax.lang.model.util.AbstractTypeVisitor6.visit(javax.lang.model.type.TypeMirror, P)
javax.lang.model.util.AbstractTypeVisitor6.visit(javax.lang.model.type.TypeMirror,java.lang.Object)


Occurences of visitAnnotation

visitAnnotation occurences:
com.sun.source.tree.TreeVisitor.visitAnnotation(com.sun.source.tree.AnnotationTree, P)
com.sun.source.tree.TreeVisitor.visitAnnotation(com.sun.source.tree.AnnotationTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitAnnotation(com.sun.source.tree.AnnotationTree, P)
com.sun.source.util.SimpleTreeVisitor.visitAnnotation(com.sun.source.tree.AnnotationTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitAnnotation(com.sun.source.tree.AnnotationTree, P)
com.sun.source.util.TreeScanner.visitAnnotation(com.sun.source.tree.AnnotationTree,java.lang.Object)
javax.lang.model.element.AnnotationValueVisitor.visitAnnotation(javax.lang.model.element.AnnotationMirror, P)
javax.lang.model.element.AnnotationValueVisitor.visitAnnotation(javax.lang.model.element.AnnotationMirror,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitAnnotation(javax.lang.model.element.AnnotationMirror, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitAnnotation(javax.lang.model.element.AnnotationMirror,java.lang.Object)


Occurences of visitAnnotationType

visitAnnotationType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitAnnotationType(com.sun.mirror.type.AnnotationType)
com.sun.mirror.util.TypeVisitor.visitAnnotationType(com.sun.mirror.type.AnnotationType)


Occurences of visitAnnotationTypeDeclaration

visitAnnotationTypeDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitAnnotationTypeDeclaration(com.sun.mirror.declaration.AnnotationTypeDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitAnnotationTypeDeclaration(com.sun.mirror.declaration.AnnotationTypeDeclaration)


Occurences of visitAnnotationTypeElementDeclaration

visitAnnotationTypeElementDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitAnnotationTypeElementDeclaration(com.sun.mirror.declaration.AnnotationTypeElementDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitAnnotationTypeElementDeclaration(com.sun.mirror.declaration.AnnotationTypeElementDeclaration)


Occurences of visitArray

visitArray occurences:
javax.lang.model.element.AnnotationValueVisitor.visitArray(java.util.List, P)
javax.lang.model.element.AnnotationValueVisitor.visitArray(java.util.List,java.lang.Object)
javax.lang.model.type.TypeVisitor.visitArray(javax.lang.model.type.ArrayType, P)
javax.lang.model.type.TypeVisitor.visitArray(javax.lang.model.type.ArrayType,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitArray(java.util.List, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitArray(java.util.List,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitArray(javax.lang.model.type.ArrayType, P)
javax.lang.model.util.SimpleTypeVisitor6.visitArray(javax.lang.model.type.ArrayType,java.lang.Object)


Occurences of visitArrayAccess

visitArrayAccess occurences:
com.sun.source.tree.TreeVisitor.visitArrayAccess(com.sun.source.tree.ArrayAccessTree, P)
com.sun.source.tree.TreeVisitor.visitArrayAccess(com.sun.source.tree.ArrayAccessTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitArrayAccess(com.sun.source.tree.ArrayAccessTree, P)
com.sun.source.util.SimpleTreeVisitor.visitArrayAccess(com.sun.source.tree.ArrayAccessTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitArrayAccess(com.sun.source.tree.ArrayAccessTree, P)
com.sun.source.util.TreeScanner.visitArrayAccess(com.sun.source.tree.ArrayAccessTree,java.lang.Object)


Occurences of visitArrayType

visitArrayType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitArrayType(com.sun.mirror.type.ArrayType)
com.sun.mirror.util.TypeVisitor.visitArrayType(com.sun.mirror.type.ArrayType)
com.sun.source.tree.TreeVisitor.visitArrayType(com.sun.source.tree.ArrayTypeTree, P)
com.sun.source.tree.TreeVisitor.visitArrayType(com.sun.source.tree.ArrayTypeTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitArrayType(com.sun.source.tree.ArrayTypeTree, P)
com.sun.source.util.SimpleTreeVisitor.visitArrayType(com.sun.source.tree.ArrayTypeTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitArrayType(com.sun.source.tree.ArrayTypeTree, P)
com.sun.source.util.TreeScanner.visitArrayType(com.sun.source.tree.ArrayTypeTree,java.lang.Object)


Occurences of visitAssert

visitAssert occurences:
com.sun.source.tree.TreeVisitor.visitAssert(com.sun.source.tree.AssertTree, P)
com.sun.source.tree.TreeVisitor.visitAssert(com.sun.source.tree.AssertTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitAssert(com.sun.source.tree.AssertTree, P)
com.sun.source.util.SimpleTreeVisitor.visitAssert(com.sun.source.tree.AssertTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitAssert(com.sun.source.tree.AssertTree, P)
com.sun.source.util.TreeScanner.visitAssert(com.sun.source.tree.AssertTree,java.lang.Object)


Occurences of visitAssignment

visitAssignment occurences:
com.sun.source.tree.TreeVisitor.visitAssignment(com.sun.source.tree.AssignmentTree, P)
com.sun.source.tree.TreeVisitor.visitAssignment(com.sun.source.tree.AssignmentTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitAssignment(com.sun.source.tree.AssignmentTree, P)
com.sun.source.util.SimpleTreeVisitor.visitAssignment(com.sun.source.tree.AssignmentTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitAssignment(com.sun.source.tree.AssignmentTree, P)
com.sun.source.util.TreeScanner.visitAssignment(com.sun.source.tree.AssignmentTree,java.lang.Object)


Occurences of visitBinary

visitBinary occurences:
com.sun.source.tree.TreeVisitor.visitBinary(com.sun.source.tree.BinaryTree, P)
com.sun.source.tree.TreeVisitor.visitBinary(com.sun.source.tree.BinaryTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitBinary(com.sun.source.tree.BinaryTree, P)
com.sun.source.util.SimpleTreeVisitor.visitBinary(com.sun.source.tree.BinaryTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitBinary(com.sun.source.tree.BinaryTree, P)
com.sun.source.util.TreeScanner.visitBinary(com.sun.source.tree.BinaryTree,java.lang.Object)


Occurences of visitBlock

visitBlock occurences:
com.sun.source.tree.TreeVisitor.visitBlock(com.sun.source.tree.BlockTree, P)
com.sun.source.tree.TreeVisitor.visitBlock(com.sun.source.tree.BlockTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitBlock(com.sun.source.tree.BlockTree, P)
com.sun.source.util.SimpleTreeVisitor.visitBlock(com.sun.source.tree.BlockTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitBlock(com.sun.source.tree.BlockTree, P)
com.sun.source.util.TreeScanner.visitBlock(com.sun.source.tree.BlockTree,java.lang.Object)


Occurences of visitBoolean

visitBoolean occurences:
javax.lang.model.element.AnnotationValueVisitor.visitBoolean(boolean, P)
javax.lang.model.element.AnnotationValueVisitor.visitBoolean(boolean,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitBoolean(boolean, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitBoolean(boolean,java.lang.Object)


Occurences of visitBreak

visitBreak occurences:
com.sun.source.tree.TreeVisitor.visitBreak(com.sun.source.tree.BreakTree, P)
com.sun.source.tree.TreeVisitor.visitBreak(com.sun.source.tree.BreakTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitBreak(com.sun.source.tree.BreakTree, P)
com.sun.source.util.SimpleTreeVisitor.visitBreak(com.sun.source.tree.BreakTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitBreak(com.sun.source.tree.BreakTree, P)
com.sun.source.util.TreeScanner.visitBreak(com.sun.source.tree.BreakTree,java.lang.Object)


Occurences of visitByte

visitByte occurences:
javax.lang.model.element.AnnotationValueVisitor.visitByte(byte, P)
javax.lang.model.element.AnnotationValueVisitor.visitByte(byte,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitByte(byte, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitByte(byte,java.lang.Object)


Occurences of visitCase

visitCase occurences:
com.sun.source.tree.TreeVisitor.visitCase(com.sun.source.tree.CaseTree, P)
com.sun.source.tree.TreeVisitor.visitCase(com.sun.source.tree.CaseTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitCase(com.sun.source.tree.CaseTree, P)
com.sun.source.util.SimpleTreeVisitor.visitCase(com.sun.source.tree.CaseTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitCase(com.sun.source.tree.CaseTree, P)
com.sun.source.util.TreeScanner.visitCase(com.sun.source.tree.CaseTree,java.lang.Object)


Occurences of visitCatch

visitCatch occurences:
com.sun.source.tree.TreeVisitor.visitCatch(com.sun.source.tree.CatchTree, P)
com.sun.source.tree.TreeVisitor.visitCatch(com.sun.source.tree.CatchTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitCatch(com.sun.source.tree.CatchTree, P)
com.sun.source.util.SimpleTreeVisitor.visitCatch(com.sun.source.tree.CatchTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitCatch(com.sun.source.tree.CatchTree, P)
com.sun.source.util.TreeScanner.visitCatch(com.sun.source.tree.CatchTree,java.lang.Object)


Occurences of visitChar

visitChar occurences:
javax.lang.model.element.AnnotationValueVisitor.visitChar(char, P)
javax.lang.model.element.AnnotationValueVisitor.visitChar(char,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitChar(char, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitChar(char,java.lang.Object)


Occurences of visitClass

visitClass occurences:
com.sun.source.tree.TreeVisitor.visitClass(com.sun.source.tree.ClassTree, P)
com.sun.source.tree.TreeVisitor.visitClass(com.sun.source.tree.ClassTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitClass(com.sun.source.tree.ClassTree, P)
com.sun.source.util.SimpleTreeVisitor.visitClass(com.sun.source.tree.ClassTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitClass(com.sun.source.tree.ClassTree, P)
com.sun.source.util.TreeScanner.visitClass(com.sun.source.tree.ClassTree,java.lang.Object)


Occurences of visitClassDeclaration

visitClassDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitClassDeclaration(com.sun.mirror.declaration.ClassDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitClassDeclaration(com.sun.mirror.declaration.ClassDeclaration)


Occurences of visitClassType

visitClassType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitClassType(com.sun.mirror.type.ClassType)
com.sun.mirror.util.TypeVisitor.visitClassType(com.sun.mirror.type.ClassType)


Occurences of visitCompilationUnit

visitCompilationUnit occurences:
com.sun.source.tree.TreeVisitor.visitCompilationUnit(com.sun.source.tree.CompilationUnitTree, P)
com.sun.source.tree.TreeVisitor.visitCompilationUnit(com.sun.source.tree.CompilationUnitTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitCompilationUnit(com.sun.source.tree.CompilationUnitTree, P)
com.sun.source.util.SimpleTreeVisitor.visitCompilationUnit(com.sun.source.tree.CompilationUnitTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitCompilationUnit(com.sun.source.tree.CompilationUnitTree, P)
com.sun.source.util.TreeScanner.visitCompilationUnit(com.sun.source.tree.CompilationUnitTree,java.lang.Object)


Occurences of visitCompoundAssignment

visitCompoundAssignment occurences:
com.sun.source.tree.TreeVisitor.visitCompoundAssignment(com.sun.source.tree.CompoundAssignmentTree, P)
com.sun.source.tree.TreeVisitor.visitCompoundAssignment(com.sun.source.tree.CompoundAssignmentTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitCompoundAssignment(com.sun.source.tree.CompoundAssignmentTree, P)
com.sun.source.util.SimpleTreeVisitor.visitCompoundAssignment(com.sun.source.tree.CompoundAssignmentTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitCompoundAssignment(com.sun.source.tree.CompoundAssignmentTree, P)
com.sun.source.util.TreeScanner.visitCompoundAssignment(com.sun.source.tree.CompoundAssignmentTree,java.lang.Object)


Occurences of visitConditionalExpression

visitConditionalExpression occurences:
com.sun.source.tree.TreeVisitor.visitConditionalExpression(com.sun.source.tree.ConditionalExpressionTree, P)
com.sun.source.tree.TreeVisitor.visitConditionalExpression(com.sun.source.tree.ConditionalExpressionTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitConditionalExpression(com.sun.source.tree.ConditionalExpressionTree, P)
com.sun.source.util.SimpleTreeVisitor.visitConditionalExpression(com.sun.source.tree.ConditionalExpressionTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitConditionalExpression(com.sun.source.tree.ConditionalExpressionTree, P)
com.sun.source.util.TreeScanner.visitConditionalExpression(com.sun.source.tree.ConditionalExpressionTree,java.lang.Object)


Occurences of visitConstructorDeclaration

visitConstructorDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitConstructorDeclaration(com.sun.mirror.declaration.ConstructorDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitConstructorDeclaration(com.sun.mirror.declaration.ConstructorDeclaration)


Occurences of visitContinue

visitContinue occurences:
com.sun.source.tree.TreeVisitor.visitContinue(com.sun.source.tree.ContinueTree, P)
com.sun.source.tree.TreeVisitor.visitContinue(com.sun.source.tree.ContinueTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitContinue(com.sun.source.tree.ContinueTree, P)
com.sun.source.util.SimpleTreeVisitor.visitContinue(com.sun.source.tree.ContinueTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitContinue(com.sun.source.tree.ContinueTree, P)
com.sun.source.util.TreeScanner.visitContinue(com.sun.source.tree.ContinueTree,java.lang.Object)


Occurences of visitDeclaration

visitDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitDeclaration(com.sun.mirror.declaration.Declaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitDeclaration(com.sun.mirror.declaration.Declaration)


Occurences of visitDeclared

visitDeclared occurences:
javax.lang.model.type.TypeVisitor.visitDeclared(javax.lang.model.type.DeclaredType, P)
javax.lang.model.type.TypeVisitor.visitDeclared(javax.lang.model.type.DeclaredType,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitDeclared(javax.lang.model.type.DeclaredType, P)
javax.lang.model.util.SimpleTypeVisitor6.visitDeclared(javax.lang.model.type.DeclaredType,java.lang.Object)


Occurences of visitDeclaredType

visitDeclaredType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitDeclaredType(com.sun.mirror.type.DeclaredType)
com.sun.mirror.util.TypeVisitor.visitDeclaredType(com.sun.mirror.type.DeclaredType)


Occurences of visitDouble

visitDouble occurences:
javax.lang.model.element.AnnotationValueVisitor.visitDouble(double, P)
javax.lang.model.element.AnnotationValueVisitor.visitDouble(double,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitDouble(double, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitDouble(double,java.lang.Object)


Occurences of visitDoWhileLoop

visitDoWhileLoop occurences:
com.sun.source.tree.TreeVisitor.visitDoWhileLoop(com.sun.source.tree.DoWhileLoopTree, P)
com.sun.source.tree.TreeVisitor.visitDoWhileLoop(com.sun.source.tree.DoWhileLoopTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitDoWhileLoop(com.sun.source.tree.DoWhileLoopTree, P)
com.sun.source.util.SimpleTreeVisitor.visitDoWhileLoop(com.sun.source.tree.DoWhileLoopTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitDoWhileLoop(com.sun.source.tree.DoWhileLoopTree, P)
com.sun.source.util.TreeScanner.visitDoWhileLoop(com.sun.source.tree.DoWhileLoopTree,java.lang.Object)


Occurences of visitEmptyStatement

visitEmptyStatement occurences:
com.sun.source.tree.TreeVisitor.visitEmptyStatement(com.sun.source.tree.EmptyStatementTree, P)
com.sun.source.tree.TreeVisitor.visitEmptyStatement(com.sun.source.tree.EmptyStatementTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitEmptyStatement(com.sun.source.tree.EmptyStatementTree, P)
com.sun.source.util.SimpleTreeVisitor.visitEmptyStatement(com.sun.source.tree.EmptyStatementTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitEmptyStatement(com.sun.source.tree.EmptyStatementTree, P)
com.sun.source.util.TreeScanner.visitEmptyStatement(com.sun.source.tree.EmptyStatementTree,java.lang.Object)


Occurences of visitEnhancedForLoop

visitEnhancedForLoop occurences:
com.sun.source.tree.TreeVisitor.visitEnhancedForLoop(com.sun.source.tree.EnhancedForLoopTree, P)
com.sun.source.tree.TreeVisitor.visitEnhancedForLoop(com.sun.source.tree.EnhancedForLoopTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitEnhancedForLoop(com.sun.source.tree.EnhancedForLoopTree, P)
com.sun.source.util.SimpleTreeVisitor.visitEnhancedForLoop(com.sun.source.tree.EnhancedForLoopTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitEnhancedForLoop(com.sun.source.tree.EnhancedForLoopTree, P)
com.sun.source.util.TreeScanner.visitEnhancedForLoop(com.sun.source.tree.EnhancedForLoopTree,java.lang.Object)


Occurences of visitEnumConstant

visitEnumConstant occurences:
javax.lang.model.element.AnnotationValueVisitor.visitEnumConstant(javax.lang.model.element.VariableElement, P)
javax.lang.model.element.AnnotationValueVisitor.visitEnumConstant(javax.lang.model.element.VariableElement,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitEnumConstant(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitEnumConstant(javax.lang.model.element.VariableElement,java.lang.Object)


Occurences of visitEnumConstantDeclaration

visitEnumConstantDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitEnumConstantDeclaration(com.sun.mirror.declaration.EnumConstantDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitEnumConstantDeclaration(com.sun.mirror.declaration.EnumConstantDeclaration)


Occurences of visitEnumDeclaration

visitEnumDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitEnumDeclaration(com.sun.mirror.declaration.EnumDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitEnumDeclaration(com.sun.mirror.declaration.EnumDeclaration)


Occurences of visitEnumType

visitEnumType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitEnumType(com.sun.mirror.type.EnumType)
com.sun.mirror.util.TypeVisitor.visitEnumType(com.sun.mirror.type.EnumType)


Occurences of visitErroneous

visitErroneous occurences:
com.sun.source.tree.TreeVisitor.visitErroneous(com.sun.source.tree.ErroneousTree, P)
com.sun.source.tree.TreeVisitor.visitErroneous(com.sun.source.tree.ErroneousTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitErroneous(com.sun.source.tree.ErroneousTree, P)
com.sun.source.util.SimpleTreeVisitor.visitErroneous(com.sun.source.tree.ErroneousTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitErroneous(com.sun.source.tree.ErroneousTree, P)
com.sun.source.util.TreeScanner.visitErroneous(com.sun.source.tree.ErroneousTree,java.lang.Object)


Occurences of visitError

visitError occurences:
javax.lang.model.type.TypeVisitor.visitError(javax.lang.model.type.ErrorType, P)
javax.lang.model.type.TypeVisitor.visitError(javax.lang.model.type.ErrorType,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitError(javax.lang.model.type.ErrorType, P)
javax.lang.model.util.SimpleTypeVisitor6.visitError(javax.lang.model.type.ErrorType,java.lang.Object)


Occurences of visitExecutable

visitExecutable occurences:
javax.lang.model.element.ElementVisitor.visitExecutable(javax.lang.model.element.ExecutableElement, P)
javax.lang.model.element.ElementVisitor.visitExecutable(javax.lang.model.element.ExecutableElement,java.lang.Object)
javax.lang.model.type.TypeVisitor.visitExecutable(javax.lang.model.type.ExecutableType, P)
javax.lang.model.type.TypeVisitor.visitExecutable(javax.lang.model.type.ExecutableType,java.lang.Object)
javax.lang.model.util.ElementKindVisitor6.visitExecutable(javax.lang.model.element.ExecutableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitExecutable(javax.lang.model.element.ExecutableElement,java.lang.Object)
javax.lang.model.util.ElementScanner6.visitExecutable(javax.lang.model.element.ExecutableElement, P)
javax.lang.model.util.ElementScanner6.visitExecutable(javax.lang.model.element.ExecutableElement,java.lang.Object)
javax.lang.model.util.SimpleElementVisitor6.visitExecutable(javax.lang.model.element.ExecutableElement, P)
javax.lang.model.util.SimpleElementVisitor6.visitExecutable(javax.lang.model.element.ExecutableElement,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitExecutable(javax.lang.model.type.ExecutableType, P)
javax.lang.model.util.SimpleTypeVisitor6.visitExecutable(javax.lang.model.type.ExecutableType,java.lang.Object)


Occurences of visitExecutableAsConstructor

visitExecutableAsConstructor occurences:
javax.lang.model.util.ElementKindVisitor6.visitExecutableAsConstructor(javax.lang.model.element.ExecutableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitExecutableAsConstructor(javax.lang.model.element.ExecutableElement,java.lang.Object)


Occurences of visitExecutableAsInstanceInit

visitExecutableAsInstanceInit occurences:
javax.lang.model.util.ElementKindVisitor6.visitExecutableAsInstanceInit(javax.lang.model.element.ExecutableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitExecutableAsInstanceInit(javax.lang.model.element.ExecutableElement,java.lang.Object)


Occurences of visitExecutableAsMethod

visitExecutableAsMethod occurences:
javax.lang.model.util.ElementKindVisitor6.visitExecutableAsMethod(javax.lang.model.element.ExecutableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitExecutableAsMethod(javax.lang.model.element.ExecutableElement,java.lang.Object)


Occurences of visitExecutableAsStaticInit

visitExecutableAsStaticInit occurences:
javax.lang.model.util.ElementKindVisitor6.visitExecutableAsStaticInit(javax.lang.model.element.ExecutableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitExecutableAsStaticInit(javax.lang.model.element.ExecutableElement,java.lang.Object)


Occurences of visitExecutableDeclaration

visitExecutableDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitExecutableDeclaration(com.sun.mirror.declaration.ExecutableDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitExecutableDeclaration(com.sun.mirror.declaration.ExecutableDeclaration)


Occurences of visitExpressionStatement

visitExpressionStatement occurences:
com.sun.source.tree.TreeVisitor.visitExpressionStatement(com.sun.source.tree.ExpressionStatementTree, P)
com.sun.source.tree.TreeVisitor.visitExpressionStatement(com.sun.source.tree.ExpressionStatementTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitExpressionStatement(com.sun.source.tree.ExpressionStatementTree, P)
com.sun.source.util.SimpleTreeVisitor.visitExpressionStatement(com.sun.source.tree.ExpressionStatementTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitExpressionStatement(com.sun.source.tree.ExpressionStatementTree, P)
com.sun.source.util.TreeScanner.visitExpressionStatement(com.sun.source.tree.ExpressionStatementTree,java.lang.Object)


Occurences of visitFieldDeclaration

visitFieldDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitFieldDeclaration(com.sun.mirror.declaration.FieldDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitFieldDeclaration(com.sun.mirror.declaration.FieldDeclaration)


Occurences of visitFloat

visitFloat occurences:
javax.lang.model.element.AnnotationValueVisitor.visitFloat(float, P)
javax.lang.model.element.AnnotationValueVisitor.visitFloat(float,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitFloat(float, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitFloat(float,java.lang.Object)


Occurences of visitForLoop

visitForLoop occurences:
com.sun.source.tree.TreeVisitor.visitForLoop(com.sun.source.tree.ForLoopTree, P)
com.sun.source.tree.TreeVisitor.visitForLoop(com.sun.source.tree.ForLoopTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitForLoop(com.sun.source.tree.ForLoopTree, P)
com.sun.source.util.SimpleTreeVisitor.visitForLoop(com.sun.source.tree.ForLoopTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitForLoop(com.sun.source.tree.ForLoopTree, P)
com.sun.source.util.TreeScanner.visitForLoop(com.sun.source.tree.ForLoopTree,java.lang.Object)


Occurences of visitIdentifier

visitIdentifier occurences:
com.sun.source.tree.TreeVisitor.visitIdentifier(com.sun.source.tree.IdentifierTree, P)
com.sun.source.tree.TreeVisitor.visitIdentifier(com.sun.source.tree.IdentifierTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitIdentifier(com.sun.source.tree.IdentifierTree, P)
com.sun.source.util.SimpleTreeVisitor.visitIdentifier(com.sun.source.tree.IdentifierTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitIdentifier(com.sun.source.tree.IdentifierTree, P)
com.sun.source.util.TreeScanner.visitIdentifier(com.sun.source.tree.IdentifierTree,java.lang.Object)


Occurences of visitIf

visitIf occurences:
com.sun.source.tree.TreeVisitor.visitIf(com.sun.source.tree.IfTree, P)
com.sun.source.tree.TreeVisitor.visitIf(com.sun.source.tree.IfTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitIf(com.sun.source.tree.IfTree, P)
com.sun.source.util.SimpleTreeVisitor.visitIf(com.sun.source.tree.IfTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitIf(com.sun.source.tree.IfTree, P)
com.sun.source.util.TreeScanner.visitIf(com.sun.source.tree.IfTree,java.lang.Object)


Occurences of visitImport

visitImport occurences:
com.sun.source.tree.TreeVisitor.visitImport(com.sun.source.tree.ImportTree, P)
com.sun.source.tree.TreeVisitor.visitImport(com.sun.source.tree.ImportTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitImport(com.sun.source.tree.ImportTree, P)
com.sun.source.util.SimpleTreeVisitor.visitImport(com.sun.source.tree.ImportTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitImport(com.sun.source.tree.ImportTree, P)
com.sun.source.util.TreeScanner.visitImport(com.sun.source.tree.ImportTree,java.lang.Object)


Occurences of visitInstanceOf

visitInstanceOf occurences:
com.sun.source.tree.TreeVisitor.visitInstanceOf(com.sun.source.tree.InstanceOfTree, P)
com.sun.source.tree.TreeVisitor.visitInstanceOf(com.sun.source.tree.InstanceOfTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitInstanceOf(com.sun.source.tree.InstanceOfTree, P)
com.sun.source.util.SimpleTreeVisitor.visitInstanceOf(com.sun.source.tree.InstanceOfTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitInstanceOf(com.sun.source.tree.InstanceOfTree, P)
com.sun.source.util.TreeScanner.visitInstanceOf(com.sun.source.tree.InstanceOfTree,java.lang.Object)


Occurences of visitInt

visitInt occurences:
javax.lang.model.element.AnnotationValueVisitor.visitInt(int, P)
javax.lang.model.element.AnnotationValueVisitor.visitInt(int,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitInt(int, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitInt(int,java.lang.Object)


Occurences of visitInterfaceDeclaration

visitInterfaceDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitInterfaceDeclaration(com.sun.mirror.declaration.InterfaceDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitInterfaceDeclaration(com.sun.mirror.declaration.InterfaceDeclaration)


Occurences of visitInterfaceType

visitInterfaceType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitInterfaceType(com.sun.mirror.type.InterfaceType)
com.sun.mirror.util.TypeVisitor.visitInterfaceType(com.sun.mirror.type.InterfaceType)


Occurences of visitLabeledStatement

visitLabeledStatement occurences:
com.sun.source.tree.TreeVisitor.visitLabeledStatement(com.sun.source.tree.LabeledStatementTree, P)
com.sun.source.tree.TreeVisitor.visitLabeledStatement(com.sun.source.tree.LabeledStatementTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitLabeledStatement(com.sun.source.tree.LabeledStatementTree, P)
com.sun.source.util.SimpleTreeVisitor.visitLabeledStatement(com.sun.source.tree.LabeledStatementTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitLabeledStatement(com.sun.source.tree.LabeledStatementTree, P)
com.sun.source.util.TreeScanner.visitLabeledStatement(com.sun.source.tree.LabeledStatementTree,java.lang.Object)


Occurences of visitLiteral

visitLiteral occurences:
com.sun.source.tree.TreeVisitor.visitLiteral(com.sun.source.tree.LiteralTree, P)
com.sun.source.tree.TreeVisitor.visitLiteral(com.sun.source.tree.LiteralTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitLiteral(com.sun.source.tree.LiteralTree, P)
com.sun.source.util.SimpleTreeVisitor.visitLiteral(com.sun.source.tree.LiteralTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitLiteral(com.sun.source.tree.LiteralTree, P)
com.sun.source.util.TreeScanner.visitLiteral(com.sun.source.tree.LiteralTree,java.lang.Object)


Occurences of visitLong

visitLong occurences:
javax.lang.model.element.AnnotationValueVisitor.visitLong(long, P)
javax.lang.model.element.AnnotationValueVisitor.visitLong(long,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitLong(long, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitLong(long,java.lang.Object)


Occurences of visitMemberDeclaration

visitMemberDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitMemberDeclaration(com.sun.mirror.declaration.MemberDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitMemberDeclaration(com.sun.mirror.declaration.MemberDeclaration)


Occurences of visitMemberSelect

visitMemberSelect occurences:
com.sun.source.tree.TreeVisitor.visitMemberSelect(com.sun.source.tree.MemberSelectTree, P)
com.sun.source.tree.TreeVisitor.visitMemberSelect(com.sun.source.tree.MemberSelectTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitMemberSelect(com.sun.source.tree.MemberSelectTree, P)
com.sun.source.util.SimpleTreeVisitor.visitMemberSelect(com.sun.source.tree.MemberSelectTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitMemberSelect(com.sun.source.tree.MemberSelectTree, P)
com.sun.source.util.TreeScanner.visitMemberSelect(com.sun.source.tree.MemberSelectTree,java.lang.Object)


Occurences of visitMethod

visitMethod occurences:
com.sun.source.tree.TreeVisitor.visitMethod(com.sun.source.tree.MethodTree, P)
com.sun.source.tree.TreeVisitor.visitMethod(com.sun.source.tree.MethodTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitMethod(com.sun.source.tree.MethodTree, P)
com.sun.source.util.SimpleTreeVisitor.visitMethod(com.sun.source.tree.MethodTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitMethod(com.sun.source.tree.MethodTree, P)
com.sun.source.util.TreeScanner.visitMethod(com.sun.source.tree.MethodTree,java.lang.Object)


Occurences of visitMethodDeclaration

visitMethodDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitMethodDeclaration(com.sun.mirror.declaration.MethodDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitMethodDeclaration(com.sun.mirror.declaration.MethodDeclaration)


Occurences of visitMethodInvocation

visitMethodInvocation occurences:
com.sun.source.tree.TreeVisitor.visitMethodInvocation(com.sun.source.tree.MethodInvocationTree, P)
com.sun.source.tree.TreeVisitor.visitMethodInvocation(com.sun.source.tree.MethodInvocationTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitMethodInvocation(com.sun.source.tree.MethodInvocationTree, P)
com.sun.source.util.SimpleTreeVisitor.visitMethodInvocation(com.sun.source.tree.MethodInvocationTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitMethodInvocation(com.sun.source.tree.MethodInvocationTree, P)
com.sun.source.util.TreeScanner.visitMethodInvocation(com.sun.source.tree.MethodInvocationTree,java.lang.Object)


Occurences of visitModifiers

visitModifiers occurences:
com.sun.source.tree.TreeVisitor.visitModifiers(com.sun.source.tree.ModifiersTree, P)
com.sun.source.tree.TreeVisitor.visitModifiers(com.sun.source.tree.ModifiersTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitModifiers(com.sun.source.tree.ModifiersTree, P)
com.sun.source.util.SimpleTreeVisitor.visitModifiers(com.sun.source.tree.ModifiersTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitModifiers(com.sun.source.tree.ModifiersTree, P)
com.sun.source.util.TreeScanner.visitModifiers(com.sun.source.tree.ModifiersTree,java.lang.Object)


Occurences of visitNewArray

visitNewArray occurences:
com.sun.source.tree.TreeVisitor.visitNewArray(com.sun.source.tree.NewArrayTree, P)
com.sun.source.tree.TreeVisitor.visitNewArray(com.sun.source.tree.NewArrayTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitNewArray(com.sun.source.tree.NewArrayTree, P)
com.sun.source.util.SimpleTreeVisitor.visitNewArray(com.sun.source.tree.NewArrayTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitNewArray(com.sun.source.tree.NewArrayTree, P)
com.sun.source.util.TreeScanner.visitNewArray(com.sun.source.tree.NewArrayTree,java.lang.Object)


Occurences of visitNewClass

visitNewClass occurences:
com.sun.source.tree.TreeVisitor.visitNewClass(com.sun.source.tree.NewClassTree, P)
com.sun.source.tree.TreeVisitor.visitNewClass(com.sun.source.tree.NewClassTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitNewClass(com.sun.source.tree.NewClassTree, P)
com.sun.source.util.SimpleTreeVisitor.visitNewClass(com.sun.source.tree.NewClassTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitNewClass(com.sun.source.tree.NewClassTree, P)
com.sun.source.util.TreeScanner.visitNewClass(com.sun.source.tree.NewClassTree,java.lang.Object)


Occurences of visitNoType

visitNoType occurences:
javax.lang.model.type.TypeVisitor.visitNoType(javax.lang.model.type.NoType, P)
javax.lang.model.type.TypeVisitor.visitNoType(javax.lang.model.type.NoType,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitNoType(javax.lang.model.type.NoType, P)
javax.lang.model.util.SimpleTypeVisitor6.visitNoType(javax.lang.model.type.NoType,java.lang.Object)
javax.lang.model.util.TypeKindVisitor6.visitNoType(javax.lang.model.type.NoType, P)
javax.lang.model.util.TypeKindVisitor6.visitNoType(javax.lang.model.type.NoType,java.lang.Object)


Occurences of visitNoTypeAsNone

visitNoTypeAsNone occurences:
javax.lang.model.util.TypeKindVisitor6.visitNoTypeAsNone(javax.lang.model.type.NoType, P)
javax.lang.model.util.TypeKindVisitor6.visitNoTypeAsNone(javax.lang.model.type.NoType,java.lang.Object)


Occurences of visitNoTypeAsPackage

visitNoTypeAsPackage occurences:
javax.lang.model.util.TypeKindVisitor6.visitNoTypeAsPackage(javax.lang.model.type.NoType, P)
javax.lang.model.util.TypeKindVisitor6.visitNoTypeAsPackage(javax.lang.model.type.NoType,java.lang.Object)


Occurences of visitNoTypeAsVoid

visitNoTypeAsVoid occurences:
javax.lang.model.util.TypeKindVisitor6.visitNoTypeAsVoid(javax.lang.model.type.NoType, P)
javax.lang.model.util.TypeKindVisitor6.visitNoTypeAsVoid(javax.lang.model.type.NoType,java.lang.Object)


Occurences of visitNull

visitNull occurences:
javax.lang.model.type.TypeVisitor.visitNull(javax.lang.model.type.NullType, P)
javax.lang.model.type.TypeVisitor.visitNull(javax.lang.model.type.NullType,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitNull(javax.lang.model.type.NullType, P)
javax.lang.model.util.SimpleTypeVisitor6.visitNull(javax.lang.model.type.NullType,java.lang.Object)


Occurences of visitOther

visitOther occurences:
com.sun.source.tree.TreeVisitor.visitOther(com.sun.source.tree.Tree, P)
com.sun.source.tree.TreeVisitor.visitOther(com.sun.source.tree.Tree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitOther(com.sun.source.tree.Tree, P)
com.sun.source.util.SimpleTreeVisitor.visitOther(com.sun.source.tree.Tree,java.lang.Object)
com.sun.source.util.TreeScanner.visitOther(com.sun.source.tree.Tree, P)
com.sun.source.util.TreeScanner.visitOther(com.sun.source.tree.Tree,java.lang.Object)


Occurences of visitPackage

visitPackage occurences:
javax.lang.model.element.ElementVisitor.visitPackage(javax.lang.model.element.PackageElement, P)
javax.lang.model.element.ElementVisitor.visitPackage(javax.lang.model.element.PackageElement,java.lang.Object)
javax.lang.model.util.ElementKindVisitor6.visitPackage(javax.lang.model.element.PackageElement, P)
javax.lang.model.util.ElementKindVisitor6.visitPackage(javax.lang.model.element.PackageElement,java.lang.Object)
javax.lang.model.util.ElementScanner6.visitPackage(javax.lang.model.element.PackageElement, P)
javax.lang.model.util.ElementScanner6.visitPackage(javax.lang.model.element.PackageElement,java.lang.Object)
javax.lang.model.util.SimpleElementVisitor6.visitPackage(javax.lang.model.element.PackageElement, P)
javax.lang.model.util.SimpleElementVisitor6.visitPackage(javax.lang.model.element.PackageElement,java.lang.Object)


Occurences of visitPackageDeclaration

visitPackageDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitPackageDeclaration(com.sun.mirror.declaration.PackageDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitPackageDeclaration(com.sun.mirror.declaration.PackageDeclaration)


Occurences of visitParameterDeclaration

visitParameterDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitParameterDeclaration(com.sun.mirror.declaration.ParameterDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitParameterDeclaration(com.sun.mirror.declaration.ParameterDeclaration)


Occurences of visitParameterizedType

visitParameterizedType occurences:
com.sun.source.tree.TreeVisitor.visitParameterizedType(com.sun.source.tree.ParameterizedTypeTree, P)
com.sun.source.tree.TreeVisitor.visitParameterizedType(com.sun.source.tree.ParameterizedTypeTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitParameterizedType(com.sun.source.tree.ParameterizedTypeTree, P)
com.sun.source.util.SimpleTreeVisitor.visitParameterizedType(com.sun.source.tree.ParameterizedTypeTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitParameterizedType(com.sun.source.tree.ParameterizedTypeTree, P)
com.sun.source.util.TreeScanner.visitParameterizedType(com.sun.source.tree.ParameterizedTypeTree,java.lang.Object)


Occurences of visitParenthesized

visitParenthesized occurences:
com.sun.source.tree.TreeVisitor.visitParenthesized(com.sun.source.tree.ParenthesizedTree, P)
com.sun.source.tree.TreeVisitor.visitParenthesized(com.sun.source.tree.ParenthesizedTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitParenthesized(com.sun.source.tree.ParenthesizedTree, P)
com.sun.source.util.SimpleTreeVisitor.visitParenthesized(com.sun.source.tree.ParenthesizedTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitParenthesized(com.sun.source.tree.ParenthesizedTree, P)
com.sun.source.util.TreeScanner.visitParenthesized(com.sun.source.tree.ParenthesizedTree,java.lang.Object)


Occurences of visitPrimitive

visitPrimitive occurences:
javax.lang.model.type.TypeVisitor.visitPrimitive(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.type.TypeVisitor.visitPrimitive(javax.lang.model.type.PrimitiveType,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitPrimitive(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.SimpleTypeVisitor6.visitPrimitive(javax.lang.model.type.PrimitiveType,java.lang.Object)
javax.lang.model.util.TypeKindVisitor6.visitPrimitive(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitive(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveAsBoolean

visitPrimitiveAsBoolean occurences:
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsBoolean(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsBoolean(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveAsByte

visitPrimitiveAsByte occurences:
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsByte(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsByte(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveAsChar

visitPrimitiveAsChar occurences:
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsChar(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsChar(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveAsDouble

visitPrimitiveAsDouble occurences:
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsDouble(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsDouble(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveAsFloat

visitPrimitiveAsFloat occurences:
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsFloat(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsFloat(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveAsInt

visitPrimitiveAsInt occurences:
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsInt(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsInt(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveAsLong

visitPrimitiveAsLong occurences:
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsLong(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsLong(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveAsShort

visitPrimitiveAsShort occurences:
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsShort(javax.lang.model.type.PrimitiveType, P)
javax.lang.model.util.TypeKindVisitor6.visitPrimitiveAsShort(javax.lang.model.type.PrimitiveType,java.lang.Object)


Occurences of visitPrimitiveType

visitPrimitiveType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitPrimitiveType(com.sun.mirror.type.PrimitiveType)
com.sun.mirror.util.TypeVisitor.visitPrimitiveType(com.sun.mirror.type.PrimitiveType)
com.sun.source.tree.TreeVisitor.visitPrimitiveType(com.sun.source.tree.PrimitiveTypeTree, P)
com.sun.source.tree.TreeVisitor.visitPrimitiveType(com.sun.source.tree.PrimitiveTypeTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitPrimitiveType(com.sun.source.tree.PrimitiveTypeTree, P)
com.sun.source.util.SimpleTreeVisitor.visitPrimitiveType(com.sun.source.tree.PrimitiveTypeTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitPrimitiveType(com.sun.source.tree.PrimitiveTypeTree, P)
com.sun.source.util.TreeScanner.visitPrimitiveType(com.sun.source.tree.PrimitiveTypeTree,java.lang.Object)


Occurences of visitReferenceType

visitReferenceType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitReferenceType(com.sun.mirror.type.ReferenceType)
com.sun.mirror.util.TypeVisitor.visitReferenceType(com.sun.mirror.type.ReferenceType)


Occurences of visitReturn

visitReturn occurences:
com.sun.source.tree.TreeVisitor.visitReturn(com.sun.source.tree.ReturnTree, P)
com.sun.source.tree.TreeVisitor.visitReturn(com.sun.source.tree.ReturnTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitReturn(com.sun.source.tree.ReturnTree, P)
com.sun.source.util.SimpleTreeVisitor.visitReturn(com.sun.source.tree.ReturnTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitReturn(com.sun.source.tree.ReturnTree, P)
com.sun.source.util.TreeScanner.visitReturn(com.sun.source.tree.ReturnTree,java.lang.Object)


Occurences of visitShort

visitShort occurences:
javax.lang.model.element.AnnotationValueVisitor.visitShort(short, P)
javax.lang.model.element.AnnotationValueVisitor.visitShort(short,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitShort(short, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitShort(short,java.lang.Object)


Occurences of visitString

visitString occurences:
javax.lang.model.element.AnnotationValueVisitor.visitString(java.lang.String, P)
javax.lang.model.element.AnnotationValueVisitor.visitString(java.lang.String,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitString(java.lang.String, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitString(java.lang.String,java.lang.Object)


Occurences of visitSwitch

visitSwitch occurences:
com.sun.source.tree.TreeVisitor.visitSwitch(com.sun.source.tree.SwitchTree, P)
com.sun.source.tree.TreeVisitor.visitSwitch(com.sun.source.tree.SwitchTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitSwitch(com.sun.source.tree.SwitchTree, P)
com.sun.source.util.SimpleTreeVisitor.visitSwitch(com.sun.source.tree.SwitchTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitSwitch(com.sun.source.tree.SwitchTree, P)
com.sun.source.util.TreeScanner.visitSwitch(com.sun.source.tree.SwitchTree,java.lang.Object)


Occurences of visitSynchronized

visitSynchronized occurences:
com.sun.source.tree.TreeVisitor.visitSynchronized(com.sun.source.tree.SynchronizedTree, P)
com.sun.source.tree.TreeVisitor.visitSynchronized(com.sun.source.tree.SynchronizedTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitSynchronized(com.sun.source.tree.SynchronizedTree, P)
com.sun.source.util.SimpleTreeVisitor.visitSynchronized(com.sun.source.tree.SynchronizedTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitSynchronized(com.sun.source.tree.SynchronizedTree, P)
com.sun.source.util.TreeScanner.visitSynchronized(com.sun.source.tree.SynchronizedTree,java.lang.Object)


Occurences of visitThrow

visitThrow occurences:
com.sun.source.tree.TreeVisitor.visitThrow(com.sun.source.tree.ThrowTree, P)
com.sun.source.tree.TreeVisitor.visitThrow(com.sun.source.tree.ThrowTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitThrow(com.sun.source.tree.ThrowTree, P)
com.sun.source.util.SimpleTreeVisitor.visitThrow(com.sun.source.tree.ThrowTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitThrow(com.sun.source.tree.ThrowTree, P)
com.sun.source.util.TreeScanner.visitThrow(com.sun.source.tree.ThrowTree,java.lang.Object)


Occurences of visitTry

visitTry occurences:
com.sun.source.tree.TreeVisitor.visitTry(com.sun.source.tree.TryTree, P)
com.sun.source.tree.TreeVisitor.visitTry(com.sun.source.tree.TryTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitTry(com.sun.source.tree.TryTree, P)
com.sun.source.util.SimpleTreeVisitor.visitTry(com.sun.source.tree.TryTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitTry(com.sun.source.tree.TryTree, P)
com.sun.source.util.TreeScanner.visitTry(com.sun.source.tree.TryTree,java.lang.Object)


Occurences of visitType

visitType occurences:
javax.lang.model.element.AnnotationValueVisitor.visitType(javax.lang.model.type.TypeMirror, P)
javax.lang.model.element.AnnotationValueVisitor.visitType(javax.lang.model.type.TypeMirror,java.lang.Object)
javax.lang.model.element.ElementVisitor.visitType(javax.lang.model.element.TypeElement, P)
javax.lang.model.element.ElementVisitor.visitType(javax.lang.model.element.TypeElement,java.lang.Object)
javax.lang.model.util.ElementKindVisitor6.visitType(javax.lang.model.element.TypeElement, P)
javax.lang.model.util.ElementKindVisitor6.visitType(javax.lang.model.element.TypeElement,java.lang.Object)
javax.lang.model.util.ElementScanner6.visitType(javax.lang.model.element.TypeElement, P)
javax.lang.model.util.ElementScanner6.visitType(javax.lang.model.element.TypeElement,java.lang.Object)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitType(javax.lang.model.type.TypeMirror, P)
javax.lang.model.util.SimpleAnnotationValueVisitor6.visitType(javax.lang.model.type.TypeMirror,java.lang.Object)
javax.lang.model.util.SimpleElementVisitor6.visitType(javax.lang.model.element.TypeElement, P)
javax.lang.model.util.SimpleElementVisitor6.visitType(javax.lang.model.element.TypeElement,java.lang.Object)


Occurences of visitTypeAsAnnotationType

visitTypeAsAnnotationType occurences:
javax.lang.model.util.ElementKindVisitor6.visitTypeAsAnnotationType(javax.lang.model.element.TypeElement, P)
javax.lang.model.util.ElementKindVisitor6.visitTypeAsAnnotationType(javax.lang.model.element.TypeElement,java.lang.Object)


Occurences of visitTypeAsClass

visitTypeAsClass occurences:
javax.lang.model.util.ElementKindVisitor6.visitTypeAsClass(javax.lang.model.element.TypeElement, P)
javax.lang.model.util.ElementKindVisitor6.visitTypeAsClass(javax.lang.model.element.TypeElement,java.lang.Object)


Occurences of visitTypeAsEnum

visitTypeAsEnum occurences:
javax.lang.model.util.ElementKindVisitor6.visitTypeAsEnum(javax.lang.model.element.TypeElement, P)
javax.lang.model.util.ElementKindVisitor6.visitTypeAsEnum(javax.lang.model.element.TypeElement,java.lang.Object)


Occurences of visitTypeAsInterface

visitTypeAsInterface occurences:
javax.lang.model.util.ElementKindVisitor6.visitTypeAsInterface(javax.lang.model.element.TypeElement, P)
javax.lang.model.util.ElementKindVisitor6.visitTypeAsInterface(javax.lang.model.element.TypeElement,java.lang.Object)


Occurences of visitTypeCast

visitTypeCast occurences:
com.sun.source.tree.TreeVisitor.visitTypeCast(com.sun.source.tree.TypeCastTree, P)
com.sun.source.tree.TreeVisitor.visitTypeCast(com.sun.source.tree.TypeCastTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitTypeCast(com.sun.source.tree.TypeCastTree, P)
com.sun.source.util.SimpleTreeVisitor.visitTypeCast(com.sun.source.tree.TypeCastTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitTypeCast(com.sun.source.tree.TypeCastTree, P)
com.sun.source.util.TreeScanner.visitTypeCast(com.sun.source.tree.TypeCastTree,java.lang.Object)


Occurences of visitTypeDeclaration

visitTypeDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitTypeDeclaration(com.sun.mirror.declaration.TypeDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitTypeDeclaration(com.sun.mirror.declaration.TypeDeclaration)


Occurences of visitTypeMirror

visitTypeMirror occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitTypeMirror(com.sun.mirror.type.TypeMirror)
com.sun.mirror.util.TypeVisitor.visitTypeMirror(com.sun.mirror.type.TypeMirror)


Occurences of visitTypeParameter

visitTypeParameter occurences:
com.sun.source.tree.TreeVisitor.visitTypeParameter(com.sun.source.tree.TypeParameterTree, P)
com.sun.source.tree.TreeVisitor.visitTypeParameter(com.sun.source.tree.TypeParameterTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitTypeParameter(com.sun.source.tree.TypeParameterTree, P)
com.sun.source.util.SimpleTreeVisitor.visitTypeParameter(com.sun.source.tree.TypeParameterTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitTypeParameter(com.sun.source.tree.TypeParameterTree, P)
com.sun.source.util.TreeScanner.visitTypeParameter(com.sun.source.tree.TypeParameterTree,java.lang.Object)
javax.lang.model.element.ElementVisitor.visitTypeParameter(javax.lang.model.element.TypeParameterElement, P)
javax.lang.model.element.ElementVisitor.visitTypeParameter(javax.lang.model.element.TypeParameterElement,java.lang.Object)
javax.lang.model.util.ElementKindVisitor6.visitTypeParameter(javax.lang.model.element.TypeParameterElement, P)
javax.lang.model.util.ElementKindVisitor6.visitTypeParameter(javax.lang.model.element.TypeParameterElement,java.lang.Object)
javax.lang.model.util.ElementScanner6.visitTypeParameter(javax.lang.model.element.TypeParameterElement, P)
javax.lang.model.util.ElementScanner6.visitTypeParameter(javax.lang.model.element.TypeParameterElement,java.lang.Object)
javax.lang.model.util.SimpleElementVisitor6.visitTypeParameter(javax.lang.model.element.TypeParameterElement, P)
javax.lang.model.util.SimpleElementVisitor6.visitTypeParameter(javax.lang.model.element.TypeParameterElement,java.lang.Object)


Occurences of visitTypeParameterDeclaration

visitTypeParameterDeclaration occurences:
com.sun.mirror.util.DeclarationVisitor.visitTypeParameterDeclaration(com.sun.mirror.declaration.TypeParameterDeclaration)
com.sun.mirror.util.SimpleDeclarationVisitor.visitTypeParameterDeclaration(com.sun.mirror.declaration.TypeParameterDeclaration)


Occurences of visitTypeVariable

visitTypeVariable occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitTypeVariable(com.sun.mirror.type.TypeVariable)
com.sun.mirror.util.TypeVisitor.visitTypeVariable(com.sun.mirror.type.TypeVariable)
javax.lang.model.type.TypeVisitor.visitTypeVariable(javax.lang.model.type.TypeVariable, P)
javax.lang.model.type.TypeVisitor.visitTypeVariable(javax.lang.model.type.TypeVariable,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitTypeVariable(javax.lang.model.type.TypeVariable, P)
javax.lang.model.util.SimpleTypeVisitor6.visitTypeVariable(javax.lang.model.type.TypeVariable,java.lang.Object)


Occurences of visitUnary

visitUnary occurences:
com.sun.source.tree.TreeVisitor.visitUnary(com.sun.source.tree.UnaryTree, P)
com.sun.source.tree.TreeVisitor.visitUnary(com.sun.source.tree.UnaryTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitUnary(com.sun.source.tree.UnaryTree, P)
com.sun.source.util.SimpleTreeVisitor.visitUnary(com.sun.source.tree.UnaryTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitUnary(com.sun.source.tree.UnaryTree, P)
com.sun.source.util.TreeScanner.visitUnary(com.sun.source.tree.UnaryTree,java.lang.Object)


Occurences of visitUnknown

visitUnknown occurences:
javax.lang.model.element.AnnotationValueVisitor.visitUnknown(javax.lang.model.element.AnnotationValue, P)
javax.lang.model.element.AnnotationValueVisitor.visitUnknown(javax.lang.model.element.AnnotationValue,java.lang.Object)
javax.lang.model.element.ElementVisitor.visitUnknown(javax.lang.model.element.Element, P)
javax.lang.model.element.ElementVisitor.visitUnknown(javax.lang.model.element.Element,java.lang.Object)
javax.lang.model.type.TypeVisitor.visitUnknown(javax.lang.model.type.TypeMirror, P)
javax.lang.model.type.TypeVisitor.visitUnknown(javax.lang.model.type.TypeMirror,java.lang.Object)
javax.lang.model.util.AbstractAnnotationValueVisitor6.visitUnknown(javax.lang.model.element.AnnotationValue, P)
javax.lang.model.util.AbstractAnnotationValueVisitor6.visitUnknown(javax.lang.model.element.AnnotationValue,java.lang.Object)
javax.lang.model.util.AbstractElementVisitor6.visitUnknown(javax.lang.model.element.Element, P)
javax.lang.model.util.AbstractElementVisitor6.visitUnknown(javax.lang.model.element.Element,java.lang.Object)
javax.lang.model.util.AbstractTypeVisitor6.visitUnknown(javax.lang.model.type.TypeMirror, P)
javax.lang.model.util.AbstractTypeVisitor6.visitUnknown(javax.lang.model.type.TypeMirror,java.lang.Object)


Occurences of visitVariable

visitVariable occurences:
com.sun.source.tree.TreeVisitor.visitVariable(com.sun.source.tree.VariableTree, P)
com.sun.source.tree.TreeVisitor.visitVariable(com.sun.source.tree.VariableTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitVariable(com.sun.source.tree.VariableTree, P)
com.sun.source.util.SimpleTreeVisitor.visitVariable(com.sun.source.tree.VariableTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitVariable(com.sun.source.tree.VariableTree, P)
com.sun.source.util.TreeScanner.visitVariable(com.sun.source.tree.VariableTree,java.lang.Object)
javax.lang.model.element.ElementVisitor.visitVariable(javax.lang.model.element.VariableElement, P)
javax.lang.model.element.ElementVisitor.visitVariable(javax.lang.model.element.VariableElement,java.lang.Object)
javax.lang.model.util.ElementKindVisitor6.visitVariable(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitVariable(javax.lang.model.element.VariableElement,java.lang.Object)
javax.lang.model.util.ElementScanner6.visitVariable(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.ElementScanner6.visitVariable(javax.lang.model.element.VariableElement,java.lang.Object)
javax.lang.model.util.SimpleElementVisitor6.visitVariable(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.SimpleElementVisitor6.visitVariable(javax.lang.model.element.VariableElement,java.lang.Object)


Occurences of visitVariableAsEnumConstant

visitVariableAsEnumConstant occurences:
javax.lang.model.util.ElementKindVisitor6.visitVariableAsEnumConstant(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitVariableAsEnumConstant(javax.lang.model.element.VariableElement,java.lang.Object)


Occurences of visitVariableAsExceptionParameter

visitVariableAsExceptionParameter occurences:
javax.lang.model.util.ElementKindVisitor6.visitVariableAsExceptionParameter(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitVariableAsExceptionParameter(javax.lang.model.element.VariableElement,java.lang.Object)


Occurences of visitVariableAsField

visitVariableAsField occurences:
javax.lang.model.util.ElementKindVisitor6.visitVariableAsField(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitVariableAsField(javax.lang.model.element.VariableElement,java.lang.Object)


Occurences of visitVariableAsLocalVariable

visitVariableAsLocalVariable occurences:
javax.lang.model.util.ElementKindVisitor6.visitVariableAsLocalVariable(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitVariableAsLocalVariable(javax.lang.model.element.VariableElement,java.lang.Object)


Occurences of visitVariableAsParameter

visitVariableAsParameter occurences:
javax.lang.model.util.ElementKindVisitor6.visitVariableAsParameter(javax.lang.model.element.VariableElement, P)
javax.lang.model.util.ElementKindVisitor6.visitVariableAsParameter(javax.lang.model.element.VariableElement,java.lang.Object)


Occurences of visitVoidType

visitVoidType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitVoidType(com.sun.mirror.type.VoidType)
com.sun.mirror.util.TypeVisitor.visitVoidType(com.sun.mirror.type.VoidType)


Occurences of visitWhileLoop

visitWhileLoop occurences:
com.sun.source.tree.TreeVisitor.visitWhileLoop(com.sun.source.tree.WhileLoopTree, P)
com.sun.source.tree.TreeVisitor.visitWhileLoop(com.sun.source.tree.WhileLoopTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitWhileLoop(com.sun.source.tree.WhileLoopTree, P)
com.sun.source.util.SimpleTreeVisitor.visitWhileLoop(com.sun.source.tree.WhileLoopTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitWhileLoop(com.sun.source.tree.WhileLoopTree, P)
com.sun.source.util.TreeScanner.visitWhileLoop(com.sun.source.tree.WhileLoopTree,java.lang.Object)


Occurences of visitWildcard

visitWildcard occurences:
com.sun.source.tree.TreeVisitor.visitWildcard(com.sun.source.tree.WildcardTree, P)
com.sun.source.tree.TreeVisitor.visitWildcard(com.sun.source.tree.WildcardTree,java.lang.Object)
com.sun.source.util.SimpleTreeVisitor.visitWildcard(com.sun.source.tree.WildcardTree, P)
com.sun.source.util.SimpleTreeVisitor.visitWildcard(com.sun.source.tree.WildcardTree,java.lang.Object)
com.sun.source.util.TreeScanner.visitWildcard(com.sun.source.tree.WildcardTree, P)
com.sun.source.util.TreeScanner.visitWildcard(com.sun.source.tree.WildcardTree,java.lang.Object)
javax.lang.model.type.TypeVisitor.visitWildcard(javax.lang.model.type.WildcardType, P)
javax.lang.model.type.TypeVisitor.visitWildcard(javax.lang.model.type.WildcardType,java.lang.Object)
javax.lang.model.util.SimpleTypeVisitor6.visitWildcard(javax.lang.model.type.WildcardType, P)
javax.lang.model.util.SimpleTypeVisitor6.visitWildcard(javax.lang.model.type.WildcardType,java.lang.Object)


Occurences of visitWildcardType

visitWildcardType occurences:
com.sun.mirror.util.SimpleTypeVisitor.visitWildcardType(com.sun.mirror.type.WildcardType)
com.sun.mirror.util.TypeVisitor.visitWildcardType(com.sun.mirror.type.WildcardType)


Occurences of VMCannotBeModifiedException (constructors)

VMCannotBeModifiedException (constructors) occurences:
com.sun.jdi.VMCannotBeModifiedException()
com.sun.jdi.VMCannotBeModifiedException(java.lang.String)


Occurences of VMDisconnectedException (constructors)

VMDisconnectedException (constructors) occurences:
com.sun.jdi.VMDisconnectedException()
com.sun.jdi.VMDisconnectedException(java.lang.String)


Occurences of VMMismatchException (constructors)

VMMismatchException (constructors) occurences:
com.sun.jdi.VMMismatchException()
com.sun.jdi.VMMismatchException(java.lang.String)


Occurences of VMOutOfMemoryException (constructors)

VMOutOfMemoryException (constructors) occurences:
com.sun.jdi.VMOutOfMemoryException()
com.sun.jdi.VMOutOfMemoryException(java.lang.String)


Occurences of VMStartException (constructors)

VMStartException (constructors) occurences:
com.sun.jdi.connect.VMStartException(java.lang.Process)
com.sun.jdi.connect.VMStartException(java.lang.String, java.lang.Process)


Occurences of VOID

VOID occurences:
javax.lang.model.type.VOID
javax.management.openmbean.VOID


Occurences of VoidType

VoidType occurences:
com.sun.jdi.VoidType
com.sun.mirror.type.VoidType


Occurences of VOLATILE

VOLATILE occurences:
com.sun.mirror.declaration.VOLATILE
java.lang.reflect.VOLATILE
javax.lang.model.element.VOLATILE


Occurences of W3CDomHandler (constructors)

W3CDomHandler (constructors) occurences:
javax.xml.bind.annotation.W3CDomHandler()
javax.xml.bind.annotation.W3CDomHandler(javax.xml.parsers.DocumentBuilder)


Occurences of wait

wait occurences:
java.lang.Object.wait()
java.lang.Object.wait(long)
java.lang.Object.wait(long, int)


Occurences of waitForAll

waitForAll occurences:
java.awt.MediaTracker.waitForAll()
java.awt.MediaTracker.waitForAll(long)


Occurences of waitForID

waitForID occurences:
java.awt.MediaTracker.waitForID(int)
java.awt.MediaTracker.waitForID(int, long)


Occurences of WAIT_CURSOR

WAIT_CURSOR occurences:
java.awt.WAIT_CURSOR
java.awt.WAIT_CURSOR


Occurences of warning

warning occurences:
java.util.logging.Logger.warning(java.lang.String)
javax.xml.transform.ErrorListener.warning(javax.xml.transform.TransformerException)
org.xml.sax.ErrorHandler.warning(org.xml.sax.SAXParseException)
org.xml.sax.HandlerBase.warning(org.xml.sax.SAXParseException)
org.xml.sax.helpers.DefaultHandler.warning(org.xml.sax.SAXParseException)
org.xml.sax.helpers.XMLFilterImpl.warning(org.xml.sax.SAXParseException)


Occurences of WARNING

WARNING occurences:
java.awt.WARNING
java.util.logging.WARNING
javax.print.attribute.standard.WARNING
javax.security.auth.callback.WARNING
javax.security.auth.callback.WARNING
javax.tools.WARNING
javax.xml.bind.WARNING


Occurences of warningListeners

warningListeners occurences:
javax.imageio.warningListeners
javax.imageio.warningListeners


Occurences of warningLocales

warningLocales occurences:
javax.imageio.warningLocales
javax.imageio.warningLocales


Occurences of warningOccurred

warningOccurred occurences:
javax.imageio.event.IIOReadWarningListener.warningOccurred(javax.imageio.ImageReader, java.lang.String)
javax.imageio.event.IIOWriteWarningListener.warningOccurred(javax.imageio.ImageWriter, int, java.lang.String)


Occurences of wasNull

wasNull occurences:
java.sql.CallableStatement.wasNull()
java.sql.ResultSet.wasNull()
java.sql.SQLInput.wasNull()
javax.sql.rowset.serial.SQLInputImpl.wasNull()


Occurences of WCharSeqHolder (constructors)

WCharSeqHolder (constructors) occurences:
org.omg.CORBA.WCharSeqHolder()
org.omg.CORBA.WCharSeqHolder(char[])


Occurences of weakCompareAndSet

weakCompareAndSet occurences:
java.util.concurrent.atomic.AtomicBoolean.weakCompareAndSet(boolean, boolean)
java.util.concurrent.atomic.AtomicInteger.weakCompareAndSet(int, int)
java.util.concurrent.atomic.AtomicIntegerArray.weakCompareAndSet(int, int, int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.weakCompareAndSet(java.lang.Object,int,int)
java.util.concurrent.atomic.AtomicIntegerFieldUpdater.weakCompareAndSet(T, int, int)
java.util.concurrent.atomic.AtomicLong.weakCompareAndSet(long, long)
java.util.concurrent.atomic.AtomicLongArray.weakCompareAndSet(int, long, long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.weakCompareAndSet(java.lang.Object,long,long)
java.util.concurrent.atomic.AtomicLongFieldUpdater.weakCompareAndSet(T, long, long)
java.util.concurrent.atomic.AtomicMarkableReference.weakCompareAndSet(java.lang.Object,java.lang.Object,boolean,boolean)
java.util.concurrent.atomic.AtomicMarkableReference.weakCompareAndSet(V, V, boolean, boolean)
java.util.concurrent.atomic.AtomicReference.weakCompareAndSet(java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReference.weakCompareAndSet(V, V)
java.util.concurrent.atomic.AtomicReferenceArray.weakCompareAndSet(int, E, E)
java.util.concurrent.atomic.AtomicReferenceArray.weakCompareAndSet(int,java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.weakCompareAndSet(java.lang.Object,java.lang.Object,java.lang.Object)
java.util.concurrent.atomic.AtomicReferenceFieldUpdater.weakCompareAndSet(T, V, V)
java.util.concurrent.atomic.AtomicStampedReference.weakCompareAndSet(java.lang.Object,java.lang.Object,int,int)
java.util.concurrent.atomic.AtomicStampedReference.weakCompareAndSet(V, V, int, int)


Occurences of WeakHashMap (constructors)

WeakHashMap (constructors) occurences:
java.util.WeakHashMap()
java.util.WeakHashMap(int)
java.util.WeakHashMap(int, float)
java.util.WeakHashMap(java.util.Map)


Occurences of WeakReference (constructors)

WeakReference (constructors) occurences:
java.lang.ref.WeakReference(java.lang.Object)
java.lang.ref.WeakReference(java.lang.Object,java.lang.ref.ReferenceQueue)
java.lang.ref.WeakReference(T)
java.lang.ref.WeakReference(T, java.lang.ref.ReferenceQueue)


Occurences of WebServiceException (constructors)

WebServiceException (constructors) occurences:
javax.xml.ws.WebServiceException()
javax.xml.ws.WebServiceException(java.lang.String)
javax.xml.ws.WebServiceException(java.lang.String, java.lang.Throwable)
javax.xml.ws.WebServiceException(java.lang.Throwable)


Occurences of WebServicePermission (constructors)

WebServicePermission (constructors) occurences:
javax.xml.ws.WebServicePermission(java.lang.String)
javax.xml.ws.WebServicePermission(java.lang.String, java.lang.String)


Occurences of WEEK_OF_MONTH

WEEK_OF_MONTH occurences:
java.text.WEEK_OF_MONTH
java.util.WEEK_OF_MONTH


Occurences of WEEK_OF_YEAR

WEEK_OF_YEAR occurences:
java.text.WEEK_OF_YEAR
java.util.WEEK_OF_YEAR


Occurences of WEST

WEST occurences:
java.awt.WEST
java.awt.WEST
javax.swing.WEST
javax.swing.WEST


Occurences of width

width occurences:
java.awt.geom.width
java.awt.geom.width
java.awt.geom.width
java.awt.geom.width
java.awt.geom.width
java.awt.geom.width
java.awt.geom.width
java.awt.geom.width
java.awt.image.width
java.awt.image.width
java.awt.width
java.awt.width
java.awt.width
javax.swing.Spring.width(java.awt.Component)
javax.swing.table.width


Occurences of WIDTH

WIDTH occurences:
java.awt.font.WIDTH
java.awt.image.WIDTH
javax.swing.text.html.WIDTH
javax.swing.text.html.WIDTH
javax.swing.WIDTH


Occurences of WILDCARD

WILDCARD occurences:
javax.lang.model.type.WILDCARD
javax.management.WILDCARD


Occurences of WildcardType

WildcardType occurences:
com.sun.javadoc.WildcardType
com.sun.mirror.type.WildcardType
java.lang.reflect.WildcardType
javax.lang.model.type.WildcardType


Occurences of WINDOW

WINDOW occurences:
java.awt.WINDOW
javax.accessibility.WINDOW


Occurences of Window (constructors)

Window (constructors) occurences:
java.awt.Window(java.awt.Frame)
java.awt.Window(java.awt.Window)
java.awt.Window(java.awt.Window, java.awt.GraphicsConfiguration)


Occurences of windowActivated

windowActivated occurences:
java.awt.AWTEventMulticaster.windowActivated(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowActivated(java.awt.event.WindowEvent)
java.awt.event.WindowListener.windowActivated(java.awt.event.WindowEvent)


Occurences of windowClosed

windowClosed occurences:
java.awt.AWTEventMulticaster.windowClosed(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowClosed(java.awt.event.WindowEvent)
java.awt.event.WindowListener.windowClosed(java.awt.event.WindowEvent)


Occurences of windowClosing

windowClosing occurences:
java.awt.AWTEventMulticaster.windowClosing(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowClosing(java.awt.event.WindowEvent)
java.awt.event.WindowListener.windowClosing(java.awt.event.WindowEvent)
javax.swing.JMenu.WinListener.windowClosing(java.awt.event.WindowEvent)
javax.swing.plaf.basic.BasicToolBarUI.FrameListener.windowClosing(java.awt.event.WindowEvent)


Occurences of windowDeactivated

windowDeactivated occurences:
java.awt.AWTEventMulticaster.windowDeactivated(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowDeactivated(java.awt.event.WindowEvent)
java.awt.event.WindowListener.windowDeactivated(java.awt.event.WindowEvent)


Occurences of windowDeiconified

windowDeiconified occurences:
java.awt.AWTEventMulticaster.windowDeiconified(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowDeiconified(java.awt.event.WindowEvent)
java.awt.event.WindowListener.windowDeiconified(java.awt.event.WindowEvent)


Occurences of WindowEvent (constructors)

WindowEvent (constructors) occurences:
java.awt.event.WindowEvent(java.awt.Window, int)
java.awt.event.WindowEvent(java.awt.Window, int, int, int)
java.awt.event.WindowEvent(java.awt.Window, int, java.awt.Window)
java.awt.event.WindowEvent(java.awt.Window, int, java.awt.Window, int, int)


Occurences of windowGainedFocus

windowGainedFocus occurences:
java.awt.AWTEventMulticaster.windowGainedFocus(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowGainedFocus(java.awt.event.WindowEvent)
java.awt.event.WindowFocusListener.windowGainedFocus(java.awt.event.WindowEvent)


Occurences of windowIconified

windowIconified occurences:
java.awt.AWTEventMulticaster.windowIconified(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowIconified(java.awt.event.WindowEvent)
java.awt.event.WindowListener.windowIconified(java.awt.event.WindowEvent)


Occurences of windowLostFocus

windowLostFocus occurences:
java.awt.AWTEventMulticaster.windowLostFocus(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowLostFocus(java.awt.event.WindowEvent)
java.awt.event.WindowFocusListener.windowLostFocus(java.awt.event.WindowEvent)


Occurences of windowOpened

windowOpened occurences:
java.awt.AWTEventMulticaster.windowOpened(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowOpened(java.awt.event.WindowEvent)
java.awt.event.WindowListener.windowOpened(java.awt.event.WindowEvent)


Occurences of windowStateChanged

windowStateChanged occurences:
java.awt.AWTEventMulticaster.windowStateChanged(java.awt.event.WindowEvent)
java.awt.event.WindowAdapter.windowStateChanged(java.awt.event.WindowEvent)
java.awt.event.WindowStateListener.windowStateChanged(java.awt.event.WindowEvent)


Occurences of WIND_EVEN_ODD

WIND_EVEN_ODD occurences:
java.awt.geom.WIND_EVEN_ODD
java.awt.geom.WIND_EVEN_ODD


Occurences of WIND_NON_ZERO

WIND_NON_ZERO occurences:
java.awt.geom.WIND_NON_ZERO
java.awt.geom.WIND_NON_ZERO


Occurences of wrap

wrap occurences:
java.nio.ByteBuffer.wrap(byte[])
java.nio.ByteBuffer.wrap(byte[], int, int)
java.nio.CharBuffer.wrap(char[])
java.nio.CharBuffer.wrap(char[], int, int)
java.nio.CharBuffer.wrap(java.lang.CharSequence)
java.nio.CharBuffer.wrap(java.lang.CharSequence, int, int)
java.nio.DoubleBuffer.wrap(double[])
java.nio.DoubleBuffer.wrap(double[], int, int)
java.nio.FloatBuffer.wrap(float[])
java.nio.FloatBuffer.wrap(float[], int, int)
java.nio.IntBuffer.wrap(int[])
java.nio.IntBuffer.wrap(int[], int, int)
java.nio.LongBuffer.wrap(long[])
java.nio.LongBuffer.wrap(long[], int, int)
java.nio.ShortBuffer.wrap(short[])
java.nio.ShortBuffer.wrap(short[], int, int)
javax.crypto.Cipher.wrap(java.security.Key)
javax.net.ssl.SSLEngine.wrap(java.nio.ByteBuffer, java.nio.ByteBuffer)
javax.net.ssl.SSLEngine.wrap(java.nio.ByteBuffer[], int, int, java.nio.ByteBuffer)
javax.net.ssl.SSLEngine.wrap(java.nio.ByteBuffer[], java.nio.ByteBuffer)
javax.security.sasl.SaslClient.wrap(byte[], int, int)
javax.security.sasl.SaslServer.wrap(byte[], int, int)
org.ietf.jgss.GSSContext.wrap(byte[], int, int, org.ietf.jgss.MessageProp)
org.ietf.jgss.GSSContext.wrap(java.io.InputStream, java.io.OutputStream, org.ietf.jgss.MessageProp)


Occurences of wrapException

wrapException occurences:
javax.rmi.CORBA.Util.wrapException(java.lang.Throwable)
javax.rmi.CORBA.UtilDelegate.wrapException(java.lang.Throwable)


Occurences of WrappedPlainView (constructors)

WrappedPlainView (constructors) occurences:
javax.swing.text.WrappedPlainView(javax.swing.text.Element)
javax.swing.text.WrappedPlainView(javax.swing.text.Element, boolean)


Occurences of WritableRaster (constructors)

WritableRaster (constructors) occurences:
java.awt.image.WritableRaster(java.awt.image.SampleModel, java.awt.image.DataBuffer, java.awt.Point)
java.awt.image.WritableRaster(java.awt.image.SampleModel, java.awt.image.DataBuffer, java.awt.Rectangle, java.awt.Point, java.awt.image.WritableRaster)
java.awt.image.WritableRaster(java.awt.image.SampleModel, java.awt.Point)


Occurences of write

write occurences:
java.awt.color.ICC_Profile.write(java.io.OutputStream)
java.awt.color.ICC_Profile.write(java.lang.String)
java.io.BufferedOutputStream.write(byte[], int, int)
java.io.BufferedOutputStream.write(int)
java.io.BufferedWriter.write(char[], int, int)
java.io.BufferedWriter.write(int)
java.io.BufferedWriter.write(java.lang.String, int, int)
java.io.ByteArrayOutputStream.write(byte[], int, int)
java.io.ByteArrayOutputStream.write(int)
java.io.CharArrayWriter.write(char[], int, int)
java.io.CharArrayWriter.write(int)
java.io.CharArrayWriter.write(java.lang.String, int, int)
java.io.DataOutput.write(byte[])
java.io.DataOutput.write(byte[], int, int)
java.io.DataOutput.write(int)
java.io.DataOutputStream.write(byte[], int, int)
java.io.DataOutputStream.write(int)
java.io.FileOutputStream.write(byte[])
java.io.FileOutputStream.write(byte[], int, int)
java.io.FileOutputStream.write(int)
java.io.FilterOutputStream.write(byte[])
java.io.FilterOutputStream.write(byte[], int, int)
java.io.FilterOutputStream.write(int)
java.io.FilterWriter.write(char[], int, int)
java.io.FilterWriter.write(int)
java.io.FilterWriter.write(java.lang.String, int, int)
java.io.ObjectOutput.write(byte[])
java.io.ObjectOutput.write(byte[], int, int)
java.io.ObjectOutput.write(int)
java.io.ObjectOutputStream.write(byte[])
java.io.ObjectOutputStream.write(byte[], int, int)
java.io.ObjectOutputStream.write(int)
java.io.ObjectOutputStream.PutField.write(java.io.ObjectOutput)
java.io.OutputStream.write(byte[])
java.io.OutputStream.write(byte[], int, int)
java.io.OutputStream.write(int)
java.io.OutputStreamWriter.write(char[], int, int)
java.io.OutputStreamWriter.write(int)
java.io.OutputStreamWriter.write(java.lang.String, int, int)
java.io.PipedOutputStream.write(byte[], int, int)
java.io.PipedOutputStream.write(int)
java.io.PipedWriter.write(char[], int, int)
java.io.PipedWriter.write(int)
java.io.PrintStream.write(byte[], int, int)
java.io.PrintStream.write(int)
java.io.PrintWriter.write(char[])
java.io.PrintWriter.write(char[], int, int)
java.io.PrintWriter.write(int)
java.io.PrintWriter.write(java.lang.String)
java.io.PrintWriter.write(java.lang.String, int, int)
java.io.RandomAccessFile.write(byte[])
java.io.RandomAccessFile.write(byte[], int, int)
java.io.RandomAccessFile.write(int)
java.io.StringWriter.write(char[], int, int)
java.io.StringWriter.write(int)
java.io.StringWriter.write(java.lang.String)
java.io.StringWriter.write(java.lang.String, int, int)
java.io.Writer.write(char[])
java.io.Writer.write(char[], int, int)
java.io.Writer.write(int)
java.io.Writer.write(java.lang.String)
java.io.Writer.write(java.lang.String, int, int)
java.nio.channels.DatagramChannel.write(java.nio.ByteBuffer)
java.nio.channels.DatagramChannel.write(java.nio.ByteBuffer[])
java.nio.channels.DatagramChannel.write(java.nio.ByteBuffer[], int, int)
java.nio.channels.FileChannel.write(java.nio.ByteBuffer)
java.nio.channels.FileChannel.write(java.nio.ByteBuffer, long)
java.nio.channels.FileChannel.write(java.nio.ByteBuffer[])
java.nio.channels.FileChannel.write(java.nio.ByteBuffer[], int, int)
java.nio.channels.GatheringByteChannel.write(java.nio.ByteBuffer[])
java.nio.channels.GatheringByteChannel.write(java.nio.ByteBuffer[], int, int)
java.nio.channels.SocketChannel.write(java.nio.ByteBuffer)
java.nio.channels.SocketChannel.write(java.nio.ByteBuffer[])
java.nio.channels.SocketChannel.write(java.nio.ByteBuffer[], int, int)
java.nio.channels.WritableByteChannel.write(java.nio.ByteBuffer)
java.rmi.server.LogStream.write(byte[], int, int)
java.rmi.server.LogStream.write(int)
java.rmi.server.ObjID.write(java.io.ObjectOutput)
java.rmi.server.UID.write(java.io.DataOutput)
java.security.DigestOutputStream.write(byte[], int, int)
java.security.DigestOutputStream.write(int)
java.util.jar.Manifest.write(java.io.OutputStream)
java.util.zip.CheckedOutputStream.write(byte[], int, int)
java.util.zip.CheckedOutputStream.write(int)
java.util.zip.DeflaterOutputStream.write(byte[], int, int)
java.util.zip.DeflaterOutputStream.write(int)
java.util.zip.GZIPOutputStream.write(byte[], int, int)
java.util.zip.InflaterOutputStream.write(byte[], int, int)
java.util.zip.InflaterOutputStream.write(int)
java.util.zip.ZipOutputStream.write(byte[], int, int)
javax.crypto.CipherOutputStream.write(byte[])
javax.crypto.CipherOutputStream.write(byte[], int, int)
javax.crypto.CipherOutputStream.write(int)
javax.imageio.ImageIO.write(java.awt.image.RenderedImage, java.lang.String, java.io.File)
javax.imageio.ImageIO.write(java.awt.image.RenderedImage, java.lang.String, java.io.OutputStream)
javax.imageio.ImageIO.write(java.awt.image.RenderedImage, java.lang.String, javax.imageio.stream.ImageOutputStream)
javax.imageio.ImageWriter.write(java.awt.image.RenderedImage)
javax.imageio.ImageWriter.write(javax.imageio.IIOImage)
javax.imageio.ImageWriter.write(javax.imageio.metadata.IIOMetadata, javax.imageio.IIOImage, javax.imageio.ImageWriteParam)
javax.imageio.stream.FileCacheImageOutputStream.write(byte[], int, int)
javax.imageio.stream.FileCacheImageOutputStream.write(int)
javax.imageio.stream.FileImageOutputStream.write(byte[], int, int)
javax.imageio.stream.FileImageOutputStream.write(int)
javax.imageio.stream.ImageOutputStream.write(byte[])
javax.imageio.stream.ImageOutputStream.write(byte[], int, int)
javax.imageio.stream.ImageOutputStream.write(int)
javax.imageio.stream.ImageOutputStreamImpl.write(byte[])
javax.imageio.stream.ImageOutputStreamImpl.write(byte[], int, int)
javax.imageio.stream.ImageOutputStreamImpl.write(int)
javax.imageio.stream.MemoryCacheImageOutputStream.write(byte[], int, int)
javax.imageio.stream.MemoryCacheImageOutputStream.write(int)
javax.sound.midi.MidiSystem.write(javax.sound.midi.Sequence, int, java.io.File)
javax.sound.midi.MidiSystem.write(javax.sound.midi.Sequence, int, java.io.OutputStream)
javax.sound.midi.spi.MidiFileWriter.write(javax.sound.midi.Sequence, int, java.io.File)
javax.sound.midi.spi.MidiFileWriter.write(javax.sound.midi.Sequence, int, java.io.OutputStream)
javax.sound.sampled.AudioSystem.write(javax.sound.sampled.AudioInputStream, javax.sound.sampled.AudioFileFormat.Type, java.io.File)
javax.sound.sampled.AudioSystem.write(javax.sound.sampled.AudioInputStream, javax.sound.sampled.AudioFileFormat.Type, java.io.OutputStream)
javax.sound.sampled.SourceDataLine.write(byte[], int, int)
javax.sound.sampled.spi.AudioFileWriter.write(javax.sound.sampled.AudioInputStream, javax.sound.sampled.AudioFileFormat.Type, java.io.File)
javax.sound.sampled.spi.AudioFileWriter.write(javax.sound.sampled.AudioInputStream, javax.sound.sampled.AudioFileFormat.Type, java.io.OutputStream)
javax.swing.text.AbstractWriter.write()
javax.swing.text.AbstractWriter.write(char)
javax.swing.text.AbstractWriter.write(char[], int, int)
javax.swing.text.AbstractWriter.write(java.lang.String)
javax.swing.text.DefaultEditorKit.write(java.io.OutputStream, javax.swing.text.Document, int, int)
javax.swing.text.DefaultEditorKit.write(java.io.Writer, javax.swing.text.Document, int, int)
javax.swing.text.EditorKit.write(java.io.OutputStream, javax.swing.text.Document, int, int)
javax.swing.text.EditorKit.write(java.io.Writer, javax.swing.text.Document, int, int)
javax.swing.text.html.HTMLEditorKit.write(java.io.Writer, javax.swing.text.Document, int, int)
javax.swing.text.html.HTMLWriter.write()
javax.swing.text.html.MinimalHTMLWriter.write()
javax.swing.text.JTextComponent.write(java.io.Writer)
javax.swing.text.rtf.RTFEditorKit.write(java.io.OutputStream, javax.swing.text.Document, int, int)
javax.swing.text.rtf.RTFEditorKit.write(java.io.Writer, javax.swing.text.Document, int, int)
org.omg.CORBA.AnySeqHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.Any[])
org.omg.CORBA.BooleanSeqHelper.write(org.omg.CORBA.portable.OutputStream, boolean[])
org.omg.CORBA.CharSeqHelper.write(org.omg.CORBA.portable.OutputStream, char[])
org.omg.CORBA.CompletionStatusHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.CompletionStatus)
org.omg.CORBA.CurrentHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.Current)
org.omg.CORBA.DefinitionKindHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.DefinitionKind)
org.omg.CORBA.DoubleSeqHelper.write(org.omg.CORBA.portable.OutputStream, double[])
org.omg.CORBA.FieldNameHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CORBA.FloatSeqHelper.write(org.omg.CORBA.portable.OutputStream, float[])
org.omg.CORBA.IdentifierHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CORBA.IDLTypeHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.IDLType)
org.omg.CORBA.LongLongSeqHelper.write(org.omg.CORBA.portable.OutputStream, long[])
org.omg.CORBA.LongSeqHelper.write(org.omg.CORBA.portable.OutputStream, int[])
org.omg.CORBA.NameValuePairHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.NameValuePair)
org.omg.CORBA.ObjectHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.Object)
org.omg.CORBA.OctetSeqHelper.write(org.omg.CORBA.portable.OutputStream, byte[])
org.omg.CORBA.ParameterModeHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.ParameterMode)
org.omg.CORBA.PolicyErrorCodeHelper.write(org.omg.CORBA.portable.OutputStream, short)
org.omg.CORBA.PolicyErrorHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.PolicyError)
org.omg.CORBA.PolicyHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.Policy)
org.omg.CORBA.PolicyListHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.Policy[])
org.omg.CORBA.PolicyTypeHelper.write(org.omg.CORBA.portable.OutputStream, int)
org.omg.CORBA.portable.OutputStream.write(int)
org.omg.CORBA.RepositoryIdHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CORBA.ServiceDetailHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.ServiceDetail)
org.omg.CORBA.ServiceInformationHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.ServiceInformation)
org.omg.CORBA.SetOverrideTypeHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.SetOverrideType)
org.omg.CORBA.ShortSeqHelper.write(org.omg.CORBA.portable.OutputStream, short[])
org.omg.CORBA.StringSeqHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String[])
org.omg.CORBA.StringValueHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CORBA.StructMemberHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.StructMember)
org.omg.CORBA.ULongLongSeqHelper.write(org.omg.CORBA.portable.OutputStream, long[])
org.omg.CORBA.ULongSeqHelper.write(org.omg.CORBA.portable.OutputStream, int[])
org.omg.CORBA.UnionMemberHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.UnionMember)
org.omg.CORBA.UnknownUserExceptionHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.UnknownUserException)
org.omg.CORBA.UShortSeqHelper.write(org.omg.CORBA.portable.OutputStream, short[])
org.omg.CORBA.ValueBaseHelper.write(org.omg.CORBA.portable.OutputStream, java.io.Serializable)
org.omg.CORBA.ValueMemberHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.ValueMember)
org.omg.CORBA.VersionSpecHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CORBA.VisibilityHelper.write(org.omg.CORBA.portable.OutputStream, short)
org.omg.CORBA.WCharSeqHelper.write(org.omg.CORBA.portable.OutputStream, char[])
org.omg.CORBA.WrongTransactionHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.WrongTransaction)
org.omg.CORBA.WStringSeqHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String[])
org.omg.CORBA.WStringValueHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CosNaming.BindingHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.Binding)
org.omg.CosNaming.BindingIteratorHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.BindingIterator)
org.omg.CosNaming.BindingListHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.Binding[])
org.omg.CosNaming.BindingTypeHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.BindingType)
org.omg.CosNaming.IstringHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CosNaming.NameComponentHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NameComponent)
org.omg.CosNaming.NameHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NameComponent[])
org.omg.CosNaming.NamingContextExtHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContextExt)
org.omg.CosNaming.NamingContextExtPackage.AddressHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CosNaming.NamingContextExtPackage.InvalidAddressHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContextExtPackage.InvalidAddress)
org.omg.CosNaming.NamingContextExtPackage.StringNameHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CosNaming.NamingContextExtPackage.URLStringHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.CosNaming.NamingContextHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContext)
org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContextPackage.AlreadyBound)
org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContextPackage.CannotProceed)
org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContextPackage.InvalidName)
org.omg.CosNaming.NamingContextPackage.NotEmptyHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContextPackage.NotEmpty)
org.omg.CosNaming.NamingContextPackage.NotFoundHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContextPackage.NotFound)
org.omg.CosNaming.NamingContextPackage.NotFoundReasonHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CosNaming.NamingContextPackage.NotFoundReason)
org.omg.DynamicAny.AnySeqHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.CORBA.Any[])
org.omg.DynamicAny.DynAnyFactoryHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynAnyFactory)
org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCodeHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode)
org.omg.DynamicAny.DynAnyHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynAny)
org.omg.DynamicAny.DynAnyPackage.InvalidValueHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynAnyPackage.InvalidValue)
org.omg.DynamicAny.DynAnyPackage.TypeMismatchHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynAnyPackage.TypeMismatch)
org.omg.DynamicAny.DynAnySeqHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynAny[])
org.omg.DynamicAny.DynArrayHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynArray)
org.omg.DynamicAny.DynEnumHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynEnum)
org.omg.DynamicAny.DynFixedHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynFixed)
org.omg.DynamicAny.DynSequenceHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynSequence)
org.omg.DynamicAny.DynStructHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynStruct)
org.omg.DynamicAny.DynUnionHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynUnion)
org.omg.DynamicAny.DynValueHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.DynValue)
org.omg.DynamicAny.FieldNameHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.DynamicAny.NameDynAnyPairHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.NameDynAnyPair)
org.omg.DynamicAny.NameDynAnyPairSeqHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.NameDynAnyPair[])
org.omg.DynamicAny.NameValuePairHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.NameValuePair)
org.omg.DynamicAny.NameValuePairSeqHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.DynamicAny.NameValuePair[])
org.omg.IOP.CodecFactoryHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.CodecFactory)
org.omg.IOP.CodecFactoryPackage.UnknownEncodingHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.CodecFactoryPackage.UnknownEncoding)
org.omg.IOP.CodecPackage.FormatMismatchHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.CodecPackage.FormatMismatch)
org.omg.IOP.CodecPackage.InvalidTypeForEncodingHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.CodecPackage.InvalidTypeForEncoding)
org.omg.IOP.CodecPackage.TypeMismatchHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.CodecPackage.TypeMismatch)
org.omg.IOP.ComponentIdHelper.write(org.omg.CORBA.portable.OutputStream, int)
org.omg.IOP.IORHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.IOR)
org.omg.IOP.MultipleComponentProfileHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.TaggedComponent[])
org.omg.IOP.ProfileIdHelper.write(org.omg.CORBA.portable.OutputStream, int)
org.omg.IOP.ServiceContextHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.ServiceContext)
org.omg.IOP.ServiceContextListHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.ServiceContext[])
org.omg.IOP.ServiceIdHelper.write(org.omg.CORBA.portable.OutputStream, int)
org.omg.IOP.TaggedComponentHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.TaggedComponent)
org.omg.IOP.TaggedProfileHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.IOP.TaggedProfile)
org.omg.Messaging.SyncScopeHelper.write(org.omg.CORBA.portable.OutputStream, short)
org.omg.PortableInterceptor.AdapterManagerIdHelper.write(org.omg.CORBA.portable.OutputStream, int)
org.omg.PortableInterceptor.AdapterNameHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String[])
org.omg.PortableInterceptor.AdapterStateHelper.write(org.omg.CORBA.portable.OutputStream, short)
org.omg.PortableInterceptor.CurrentHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.Current)
org.omg.PortableInterceptor.ForwardRequestHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.ForwardRequest)
org.omg.PortableInterceptor.InvalidSlotHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.InvalidSlot)
org.omg.PortableInterceptor.IORInterceptor_3_0Helper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.IORInterceptor_3_0)
org.omg.PortableInterceptor.ObjectIdHelper.write(org.omg.CORBA.portable.OutputStream, byte[])
org.omg.PortableInterceptor.ObjectReferenceFactoryHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.ObjectReferenceFactory)
org.omg.PortableInterceptor.ObjectReferenceTemplateHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.ObjectReferenceTemplate)
org.omg.PortableInterceptor.ObjectReferenceTemplateSeqHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.ObjectReferenceTemplate[])
org.omg.PortableInterceptor.ORBIdHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateNameHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName)
org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidNameHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidName)
org.omg.PortableInterceptor.ORBInitInfoPackage.ObjectIdHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.PortableInterceptor.ServerIdHelper.write(org.omg.CORBA.portable.OutputStream, java.lang.String)
org.omg.PortableServer.CurrentHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.Current)
org.omg.PortableServer.CurrentPackage.NoContextHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.CurrentPackage.NoContext)
org.omg.PortableServer.ForwardRequestHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.ForwardRequest)
org.omg.PortableServer.POAHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POA)
org.omg.PortableServer.POAManagerPackage.AdapterInactiveHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAManagerPackage.AdapterInactive)
org.omg.PortableServer.POAPackage.AdapterAlreadyExistsHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.AdapterAlreadyExists)
org.omg.PortableServer.POAPackage.AdapterNonExistentHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.AdapterNonExistent)
org.omg.PortableServer.POAPackage.InvalidPolicyHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.InvalidPolicy)
org.omg.PortableServer.POAPackage.NoServantHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.NoServant)
org.omg.PortableServer.POAPackage.ObjectAlreadyActiveHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.ObjectAlreadyActive)
org.omg.PortableServer.POAPackage.ObjectNotActiveHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.ObjectNotActive)
org.omg.PortableServer.POAPackage.ServantAlreadyActiveHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.ServantAlreadyActive)
org.omg.PortableServer.POAPackage.ServantNotActiveHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.ServantNotActive)
org.omg.PortableServer.POAPackage.WrongAdapterHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.WrongAdapter)
org.omg.PortableServer.POAPackage.WrongPolicyHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.POAPackage.WrongPolicy)
org.omg.PortableServer.ServantActivatorHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.ServantActivator)
org.omg.PortableServer.ServantLocatorHelper.write(org.omg.CORBA.portable.OutputStream, org.omg.PortableServer.ServantLocator)
org.w3c.dom.ls.LSSerializer.write(org.w3c.dom.Node, org.w3c.dom.ls.LSOutput)


Occurences of writeAbstractObject

writeAbstractObject occurences:
javax.rmi.CORBA.Util.writeAbstractObject(org.omg.CORBA.portable.OutputStream, java.lang.Object)
javax.rmi.CORBA.UtilDelegate.writeAbstractObject(org.omg.CORBA.portable.OutputStream, java.lang.Object)


Occurences of writeAny

writeAny occurences:
javax.rmi.CORBA.Util.writeAny(org.omg.CORBA.portable.OutputStream, java.lang.Object)
javax.rmi.CORBA.UtilDelegate.writeAny(org.omg.CORBA.portable.OutputStream, java.lang.Object)


Occurences of writeArray

writeArray occurences:
java.sql.SQLOutput.writeArray(java.sql.Array)
javax.sql.rowset.serial.SQLOutputImpl.writeArray(java.sql.Array)


Occurences of writeAsciiStream

writeAsciiStream occurences:
java.sql.SQLOutput.writeAsciiStream(java.io.InputStream)
javax.sql.rowset.serial.SQLOutputImpl.writeAsciiStream(java.io.InputStream)


Occurences of writeAttribute

writeAttribute occurences:
javax.xml.stream.XMLStreamWriter.writeAttribute(java.lang.String, java.lang.String)
javax.xml.stream.XMLStreamWriter.writeAttribute(java.lang.String, java.lang.String, java.lang.String)
javax.xml.stream.XMLStreamWriter.writeAttribute(java.lang.String, java.lang.String, java.lang.String, java.lang.String)


Occurences of writeAttributes

writeAttributes occurences:
javax.swing.text.AbstractWriter.writeAttributes(javax.swing.text.AttributeSet)
javax.swing.text.html.HTMLWriter.writeAttributes(javax.swing.text.AttributeSet)
javax.swing.text.html.MinimalHTMLWriter.writeAttributes(javax.swing.text.AttributeSet)
javax.swing.text.StyleContext.writeAttributes(java.io.ObjectOutputStream, javax.swing.text.AttributeSet)


Occurences of writeBigDecimal

writeBigDecimal occurences:
java.sql.SQLOutput.writeBigDecimal(java.math.BigDecimal)
javax.sql.rowset.serial.SQLOutputImpl.writeBigDecimal(java.math.BigDecimal)


Occurences of writeBinaryStream

writeBinaryStream occurences:
java.sql.SQLOutput.writeBinaryStream(java.io.InputStream)
javax.sql.rowset.serial.SQLOutputImpl.writeBinaryStream(java.io.InputStream)


Occurences of writeBit

writeBit occurences:
javax.imageio.stream.ImageOutputStream.writeBit(int)
javax.imageio.stream.ImageOutputStreamImpl.writeBit(int)


Occurences of writeBits

writeBits occurences:
javax.imageio.stream.ImageOutputStream.writeBits(long, int)
javax.imageio.stream.ImageOutputStreamImpl.writeBits(long, int)


Occurences of writeBlob

writeBlob occurences:
java.sql.SQLOutput.writeBlob(java.sql.Blob)
javax.sql.rowset.serial.SQLOutputImpl.writeBlob(java.sql.Blob)


Occurences of writeBoolean

writeBoolean occurences:
java.io.DataOutput.writeBoolean(boolean)
java.io.DataOutputStream.writeBoolean(boolean)
java.io.ObjectOutputStream.writeBoolean(boolean)
java.io.RandomAccessFile.writeBoolean(boolean)
java.sql.SQLOutput.writeBoolean(boolean)
javax.imageio.stream.ImageOutputStream.writeBoolean(boolean)
javax.imageio.stream.ImageOutputStreamImpl.writeBoolean(boolean)
javax.sql.rowset.serial.SQLOutputImpl.writeBoolean(boolean)


Occurences of writeByte

writeByte occurences:
java.io.DataOutput.writeByte(int)
java.io.DataOutputStream.writeByte(int)
java.io.ObjectOutputStream.writeByte(int)
java.io.RandomAccessFile.writeByte(int)
java.sql.SQLOutput.writeByte(byte)
javax.imageio.stream.ImageOutputStream.writeByte(int)
javax.imageio.stream.ImageOutputStreamImpl.writeByte(int)
javax.sql.rowset.serial.SQLOutputImpl.writeByte(byte)


Occurences of writeBytes

writeBytes occurences:
java.io.DataOutput.writeBytes(java.lang.String)
java.io.DataOutputStream.writeBytes(java.lang.String)
java.io.ObjectOutputStream.writeBytes(java.lang.String)
java.io.RandomAccessFile.writeBytes(java.lang.String)
java.sql.SQLOutput.writeBytes(byte[])
javax.imageio.stream.ImageOutputStream.writeBytes(java.lang.String)
javax.imageio.stream.ImageOutputStreamImpl.writeBytes(java.lang.String)
javax.sql.rowset.serial.SQLOutputImpl.writeBytes(byte[])


Occurences of writeChar

writeChar occurences:
java.io.DataOutput.writeChar(int)
java.io.DataOutputStream.writeChar(int)
java.io.ObjectOutputStream.writeChar(int)
java.io.RandomAccessFile.writeChar(int)
javax.imageio.stream.ImageOutputStream.writeChar(int)
javax.imageio.stream.ImageOutputStreamImpl.writeChar(int)


Occurences of writeCharacters

writeCharacters occurences:
javax.xml.stream.XMLStreamWriter.writeCharacters(char[], int, int)
javax.xml.stream.XMLStreamWriter.writeCharacters(java.lang.String)


Occurences of writeCharacterStream

writeCharacterStream occurences:
java.sql.SQLOutput.writeCharacterStream(java.io.Reader)
javax.sql.rowset.serial.SQLOutputImpl.writeCharacterStream(java.io.Reader)


Occurences of writeChars

writeChars occurences:
java.io.DataOutput.writeChars(java.lang.String)
java.io.DataOutputStream.writeChars(java.lang.String)
java.io.ObjectOutputStream.writeChars(java.lang.String)
java.io.RandomAccessFile.writeChars(java.lang.String)
javax.imageio.stream.ImageOutputStream.writeChars(char[], int, int)
javax.imageio.stream.ImageOutputStream.writeChars(java.lang.String)
javax.imageio.stream.ImageOutputStreamImpl.writeChars(char[], int, int)
javax.imageio.stream.ImageOutputStreamImpl.writeChars(java.lang.String)


Occurences of writeClob

writeClob occurences:
java.sql.SQLOutput.writeClob(java.sql.Clob)
javax.sql.rowset.serial.SQLOutputImpl.writeClob(java.sql.Clob)


Occurences of writeDate

writeDate occurences:
java.sql.SQLOutput.writeDate(java.sql.Date)
javax.sql.rowset.serial.SQLOutputImpl.writeDate(java.sql.Date)


Occurences of writeDouble

writeDouble occurences:
java.io.DataOutput.writeDouble(double)
java.io.DataOutputStream.writeDouble(double)
java.io.ObjectOutputStream.writeDouble(double)
java.io.RandomAccessFile.writeDouble(double)
java.sql.SQLOutput.writeDouble(double)
javax.imageio.stream.ImageOutputStream.writeDouble(double)
javax.imageio.stream.ImageOutputStreamImpl.writeDouble(double)
javax.sql.rowset.serial.SQLOutputImpl.writeDouble(double)


Occurences of writeDoubles

writeDoubles occurences:
javax.imageio.stream.ImageOutputStream.writeDoubles(double[], int, int)
javax.imageio.stream.ImageOutputStreamImpl.writeDoubles(double[], int, int)


Occurences of writeEmptyElement

writeEmptyElement occurences:
javax.xml.stream.XMLStreamWriter.writeEmptyElement(java.lang.String)
javax.xml.stream.XMLStreamWriter.writeEmptyElement(java.lang.String, java.lang.String)
javax.xml.stream.XMLStreamWriter.writeEmptyElement(java.lang.String, java.lang.String, java.lang.String)


Occurences of writeExpression

writeExpression occurences:
java.beans.Encoder.writeExpression(java.beans.Expression)
java.beans.XMLEncoder.writeExpression(java.beans.Expression)


Occurences of writeExternal

writeExternal occurences:
java.awt.datatransfer.DataFlavor.writeExternal(java.io.ObjectOutput)
java.io.Externalizable.writeExternal(java.io.ObjectOutput)
javax.activation.MimeType.writeExternal(java.io.ObjectOutput)
javax.management.loading.MLet.writeExternal(java.io.ObjectOutput)


Occurences of writeFloat

writeFloat occurences:
java.io.DataOutput.writeFloat(float)
java.io.DataOutputStream.writeFloat(float)
java.io.ObjectOutputStream.writeFloat(float)
java.io.RandomAccessFile.writeFloat(float)
java.sql.SQLOutput.writeFloat(float)
javax.imageio.stream.ImageOutputStream.writeFloat(float)
javax.imageio.stream.ImageOutputStreamImpl.writeFloat(float)
javax.sql.rowset.serial.SQLOutputImpl.writeFloat(float)


Occurences of writeFloats

writeFloats occurences:
javax.imageio.stream.ImageOutputStream.writeFloats(float[], int, int)
javax.imageio.stream.ImageOutputStreamImpl.writeFloats(float[], int, int)


Occurences of writeInt

writeInt occurences:
java.io.DataOutput.writeInt(int)
java.io.DataOutputStream.writeInt(int)
java.io.ObjectOutputStream.writeInt(int)
java.io.RandomAccessFile.writeInt(int)
java.sql.SQLOutput.writeInt(int)
javax.imageio.stream.ImageOutputStream.writeInt(int)
javax.imageio.stream.ImageOutputStreamImpl.writeInt(int)
javax.sql.rowset.serial.SQLOutputImpl.writeInt(int)


Occurences of writeInts

writeInts occurences:
javax.imageio.stream.ImageOutputStream.writeInts(int[], int, int)
javax.imageio.stream.ImageOutputStreamImpl.writeInts(int[], int, int)


Occurences of writeLineSeparator

writeLineSeparator occurences:
javax.swing.text.AbstractWriter.writeLineSeparator()
javax.swing.text.html.HTMLWriter.writeLineSeparator()


Occurences of writeLock

writeLock occurences:
java.util.concurrent.locks.ReadWriteLock.writeLock()
java.util.concurrent.locks.ReentrantReadWriteLock.writeLock()
javax.swing.text.AbstractDocument.writeLock()


Occurences of writeLong

writeLong occurences:
java.io.DataOutput.writeLong(long)
java.io.DataOutputStream.writeLong(long)
java.io.ObjectOutputStream.writeLong(long)
java.io.RandomAccessFile.writeLong(long)
java.sql.SQLOutput.writeLong(long)
javax.imageio.stream.ImageOutputStream.writeLong(long)
javax.imageio.stream.ImageOutputStreamImpl.writeLong(long)
javax.sql.rowset.serial.SQLOutputImpl.writeLong(long)


Occurences of writeLongs

writeLongs occurences:
javax.imageio.stream.ImageOutputStream.writeLongs(long[], int, int)
javax.imageio.stream.ImageOutputStreamImpl.writeLongs(long[], int, int)


Occurences of writeNClob

writeNClob occurences:
java.sql.SQLOutput.writeNClob(java.sql.NClob)
javax.sql.rowset.serial.SQLOutputImpl.writeNClob(java.sql.NClob)


Occurences of writeNString

writeNString occurences:
java.sql.SQLOutput.writeNString(java.lang.String)
javax.sql.rowset.serial.SQLOutputImpl.writeNString(java.lang.String)


Occurences of writeObject

writeObject occurences:
java.beans.Encoder.writeObject(java.lang.Object)
java.beans.PersistenceDelegate.writeObject(java.lang.Object, java.beans.Encoder)
java.beans.XMLEncoder.writeObject(java.lang.Object)
java.io.ObjectOutput.writeObject(java.lang.Object)
java.io.ObjectOutputStream.writeObject(java.lang.Object)
java.sql.SQLOutput.writeObject(java.sql.SQLData)
javax.rmi.CORBA.StubDelegate.writeObject(javax.rmi.CORBA.Stub, java.io.ObjectOutputStream)
javax.sql.rowset.serial.SQLOutputImpl.writeObject(java.sql.SQLData)


Occurences of writeProcessingInstruction

writeProcessingInstruction occurences:
javax.xml.stream.XMLStreamWriter.writeProcessingInstruction(java.lang.String)
javax.xml.stream.XMLStreamWriter.writeProcessingInstruction(java.lang.String, java.lang.String)


Occurences of writer

writer occurences:
java.io.Console.writer()
javax.script.writer


Occurences of Writer (constructors)

Writer (constructors) occurences:
java.io.Writer()
java.io.Writer(java.lang.Object)


Occurences of writeRef

writeRef occurences:
java.sql.SQLOutput.writeRef(java.sql.Ref)
javax.sql.rowset.serial.SQLOutputImpl.writeRef(java.sql.Ref)


Occurences of writeRemoteObject

writeRemoteObject occurences:
javax.rmi.CORBA.Util.writeRemoteObject(org.omg.CORBA.portable.OutputStream, java.lang.Object)
javax.rmi.CORBA.UtilDelegate.writeRemoteObject(org.omg.CORBA.portable.OutputStream, java.lang.Object)


Occurences of writeReplace

writeReplace occurences:
java.security.cert.Certificate.writeReplace()
java.security.cert.CertPath.writeReplace()
javax.rmi.CORBA.ValueHandler.writeReplace(java.io.Serializable)


Occurences of writeRowId

writeRowId occurences:
java.sql.SQLOutput.writeRowId(java.sql.RowId)
javax.sql.rowset.serial.SQLOutputImpl.writeRowId(java.sql.RowId)


Occurences of writeShort

writeShort occurences:
java.io.DataOutput.writeShort(int)
java.io.DataOutputStream.writeShort(int)
java.io.ObjectOutputStream.writeShort(int)
java.io.RandomAccessFile.writeShort(int)
java.sql.SQLOutput.writeShort(short)
javax.imageio.stream.ImageOutputStream.writeShort(int)
javax.imageio.stream.ImageOutputStreamImpl.writeShort(int)
javax.sql.rowset.serial.SQLOutputImpl.writeShort(short)


Occurences of writeShorts

writeShorts occurences:
javax.imageio.stream.ImageOutputStream.writeShorts(short[], int, int)
javax.imageio.stream.ImageOutputStreamImpl.writeShorts(short[], int, int)


Occurences of writeSQLXML

writeSQLXML occurences:
java.sql.SQLOutput.writeSQLXML(java.sql.SQLXML)
javax.sql.rowset.serial.SQLOutputImpl.writeSQLXML(java.sql.SQLXML)


Occurences of writeStartDocument

writeStartDocument occurences:
javax.xml.stream.XMLStreamWriter.writeStartDocument()
javax.xml.stream.XMLStreamWriter.writeStartDocument(java.lang.String)
javax.xml.stream.XMLStreamWriter.writeStartDocument(java.lang.String, java.lang.String)


Occurences of writeStartElement

writeStartElement occurences:
javax.xml.stream.XMLStreamWriter.writeStartElement(java.lang.String)
javax.xml.stream.XMLStreamWriter.writeStartElement(java.lang.String, java.lang.String)
javax.xml.stream.XMLStreamWriter.writeStartElement(java.lang.String, java.lang.String, java.lang.String)


Occurences of writeStatement

writeStatement occurences:
java.beans.Encoder.writeStatement(java.beans.Statement)
java.beans.XMLEncoder.writeStatement(java.beans.Statement)


Occurences of writeString

writeString occurences:
java.sql.SQLOutput.writeString(java.lang.String)
javax.sql.rowset.serial.SQLOutputImpl.writeString(java.lang.String)


Occurences of writeStruct

writeStruct occurences:
java.sql.SQLOutput.writeStruct(java.sql.Struct)
javax.sql.rowset.serial.SQLOutputImpl.writeStruct(java.sql.Struct)


Occurences of writeTime

writeTime occurences:
java.sql.SQLOutput.writeTime(java.sql.Time)
javax.sql.rowset.serial.SQLOutputImpl.writeTime(java.sql.Time)


Occurences of writeTimestamp

writeTimestamp occurences:
java.sql.SQLOutput.writeTimestamp(java.sql.Timestamp)
javax.sql.rowset.serial.SQLOutputImpl.writeTimestamp(java.sql.Timestamp)


Occurences of writeTo

writeTo occurences:
java.io.ByteArrayOutputStream.writeTo(java.io.OutputStream)
java.io.CharArrayWriter.writeTo(java.io.Writer)
javax.activation.DataContentHandler.writeTo(java.lang.Object, java.lang.String, java.io.OutputStream)
javax.activation.DataHandler.writeTo(java.io.OutputStream)
javax.xml.soap.SOAPMessage.writeTo(java.io.OutputStream)


Occurences of writeURL

writeURL occurences:
java.sql.SQLOutput.writeURL(java.net.URL)
javax.sql.rowset.serial.SQLOutputImpl.writeURL(java.net.URL)


Occurences of writeUTF

writeUTF occurences:
java.io.DataOutput.writeUTF(java.lang.String)
java.io.DataOutputStream.writeUTF(java.lang.String)
java.io.ObjectOutputStream.writeUTF(java.lang.String)
java.io.RandomAccessFile.writeUTF(java.lang.String)
javax.imageio.stream.ImageOutputStream.writeUTF(java.lang.String)
javax.imageio.stream.ImageOutputStreamImpl.writeUTF(java.lang.String)


Occurences of writeValue

writeValue occurences:
javax.rmi.CORBA.ValueHandler.writeValue(org.omg.CORBA.portable.OutputStream, java.io.Serializable)
javax.rmi.CORBA.ValueHandlerMultiFormat.writeValue(org.omg.CORBA.portable.OutputStream, java.io.Serializable, byte)


Occurences of writeXml

writeXml occurences:
javax.sql.rowset.WebRowSet.writeXml(java.io.OutputStream)
javax.sql.rowset.WebRowSet.writeXml(java.io.Writer)
javax.sql.rowset.WebRowSet.writeXml(java.sql.ResultSet, java.io.OutputStream)
javax.sql.rowset.WebRowSet.writeXml(java.sql.ResultSet, java.io.Writer)


Occurences of write_any

write_any occurences:
org.omg.CORBA.DataOutputStream.write_any(org.omg.CORBA.Any)
org.omg.CORBA.portable.OutputStream.write_any(org.omg.CORBA.Any)


Occurences of write_boolean

write_boolean occurences:
org.omg.CORBA.DataOutputStream.write_boolean(boolean)
org.omg.CORBA.portable.OutputStream.write_boolean(boolean)


Occurences of write_boolean_array

write_boolean_array occurences:
org.omg.CORBA.DataOutputStream.write_boolean_array(boolean[], int, int)
org.omg.CORBA.portable.OutputStream.write_boolean_array(boolean[], int, int)


Occurences of write_char

write_char occurences:
org.omg.CORBA.DataOutputStream.write_char(char)
org.omg.CORBA.portable.OutputStream.write_char(char)


Occurences of write_char_array

write_char_array occurences:
org.omg.CORBA.DataOutputStream.write_char_array(char[], int, int)
org.omg.CORBA.portable.OutputStream.write_char_array(char[], int, int)


Occurences of write_double

write_double occurences:
org.omg.CORBA.DataOutputStream.write_double(double)
org.omg.CORBA.portable.OutputStream.write_double(double)


Occurences of write_double_array

write_double_array occurences:
org.omg.CORBA.DataOutputStream.write_double_array(double[], int, int)
org.omg.CORBA.portable.OutputStream.write_double_array(double[], int, int)


Occurences of write_float

write_float occurences:
org.omg.CORBA.DataOutputStream.write_float(float)
org.omg.CORBA.portable.OutputStream.write_float(float)


Occurences of write_float_array

write_float_array occurences:
org.omg.CORBA.DataOutputStream.write_float_array(float[], int, int)
org.omg.CORBA.portable.OutputStream.write_float_array(float[], int, int)


Occurences of write_long

write_long occurences:
org.omg.CORBA.DataOutputStream.write_long(int)
org.omg.CORBA.portable.OutputStream.write_long(int)


Occurences of write_longlong

write_longlong occurences:
org.omg.CORBA.DataOutputStream.write_longlong(long)
org.omg.CORBA.portable.OutputStream.write_longlong(long)


Occurences of write_longlong_array

write_longlong_array occurences:
org.omg.CORBA.DataOutputStream.write_longlong_array(long[], int, int)
org.omg.CORBA.portable.OutputStream.write_longlong_array(long[], int, int)


Occurences of write_long_array

write_long_array occurences:
org.omg.CORBA.DataOutputStream.write_long_array(int[], int, int)
org.omg.CORBA.portable.OutputStream.write_long_array(int[], int, int)


Occurences of write_Object

write_Object occurences:
org.omg.CORBA.DataOutputStream.write_Object(org.omg.CORBA.Object)
org.omg.CORBA.portable.OutputStream.write_Object(org.omg.CORBA.Object)


Occurences of write_octet

write_octet occurences:
org.omg.CORBA.DataOutputStream.write_octet(byte)
org.omg.CORBA.portable.OutputStream.write_octet(byte)


Occurences of write_octet_array

write_octet_array occurences:
org.omg.CORBA.DataOutputStream.write_octet_array(byte[], int, int)
org.omg.CORBA.portable.OutputStream.write_octet_array(byte[], int, int)


Occurences of write_short

write_short occurences:
org.omg.CORBA.DataOutputStream.write_short(short)
org.omg.CORBA.portable.OutputStream.write_short(short)


Occurences of write_short_array

write_short_array occurences:
org.omg.CORBA.DataOutputStream.write_short_array(short[], int, int)
org.omg.CORBA.portable.OutputStream.write_short_array(short[], int, int)


Occurences of write_string

write_string occurences:
org.omg.CORBA.DataOutputStream.write_string(java.lang.String)
org.omg.CORBA.portable.OutputStream.write_string(java.lang.String)


Occurences of write_TypeCode

write_TypeCode occurences:
org.omg.CORBA.DataOutputStream.write_TypeCode(org.omg.CORBA.TypeCode)
org.omg.CORBA.portable.OutputStream.write_TypeCode(org.omg.CORBA.TypeCode)


Occurences of write_ulong

write_ulong occurences:
org.omg.CORBA.DataOutputStream.write_ulong(int)
org.omg.CORBA.portable.OutputStream.write_ulong(int)


Occurences of write_ulonglong

write_ulonglong occurences:
org.omg.CORBA.DataOutputStream.write_ulonglong(long)
org.omg.CORBA.portable.OutputStream.write_ulonglong(long)


Occurences of write_ulonglong_array

write_ulonglong_array occurences:
org.omg.CORBA.DataOutputStream.write_ulonglong_array(long[], int, int)
org.omg.CORBA.portable.OutputStream.write_ulonglong_array(long[], int, int)


Occurences of write_ulong_array

write_ulong_array occurences:
org.omg.CORBA.DataOutputStream.write_ulong_array(int[], int, int)
org.omg.CORBA.portable.OutputStream.write_ulong_array(int[], int, int)


Occurences of write_ushort

write_ushort occurences:
org.omg.CORBA.DataOutputStream.write_ushort(short)
org.omg.CORBA.portable.OutputStream.write_ushort(short)


Occurences of write_ushort_array

write_ushort_array occurences:
org.omg.CORBA.DataOutputStream.write_ushort_array(short[], int, int)
org.omg.CORBA.portable.OutputStream.write_ushort_array(short[], int, int)


Occurences of write_value

write_value occurences:
org.omg.CORBA.Any.write_value(org.omg.CORBA.portable.OutputStream)
org.omg.CORBA.portable.BoxedValueHelper.write_value(org.omg.CORBA.portable.OutputStream, java.io.Serializable)
org.omg.CORBA.StringValueHelper.write_value(org.omg.CORBA.portable.OutputStream, java.io.Serializable)
org.omg.CORBA.WStringValueHelper.write_value(org.omg.CORBA.portable.OutputStream, java.io.Serializable)
org.omg.CORBA_2_3.portable.OutputStream.write_value(java.io.Serializable)
org.omg.CORBA_2_3.portable.OutputStream.write_value(java.io.Serializable, java.lang.Class)
org.omg.CORBA_2_3.portable.OutputStream.write_value(java.io.Serializable, java.lang.String)
org.omg.CORBA_2_3.portable.OutputStream.write_value(java.io.Serializable, org.omg.CORBA.portable.BoxedValueHelper)


Occurences of write_wchar

write_wchar occurences:
org.omg.CORBA.DataOutputStream.write_wchar(char)
org.omg.CORBA.portable.OutputStream.write_wchar(char)


Occurences of write_wchar_array

write_wchar_array occurences:
org.omg.CORBA.DataOutputStream.write_wchar_array(char[], int, int)
org.omg.CORBA.portable.OutputStream.write_wchar_array(char[], int, int)


Occurences of write_wstring

write_wstring occurences:
org.omg.CORBA.DataOutputStream.write_wstring(java.lang.String)
org.omg.CORBA.portable.OutputStream.write_wstring(java.lang.String)


Occurences of WrongAdapter (constructors)

WrongAdapter (constructors) occurences:
org.omg.PortableServer.POAPackage.WrongAdapter()
org.omg.PortableServer.POAPackage.WrongAdapter(java.lang.String)


Occurences of WrongPolicy (constructors)

WrongPolicy (constructors) occurences:
org.omg.PortableServer.POAPackage.WrongPolicy()
org.omg.PortableServer.POAPackage.WrongPolicy(java.lang.String)


Occurences of WrongTransaction (constructors)

WrongTransaction (constructors) occurences:
org.omg.CORBA.WrongTransaction()
org.omg.CORBA.WrongTransaction(java.lang.String)


Occurences of WrongTransactionHolder (constructors)

WrongTransactionHolder (constructors) occurences:
org.omg.CORBA.WrongTransactionHolder()
org.omg.CORBA.WrongTransactionHolder(org.omg.CORBA.WrongTransaction)


Occurences of wsdlLocation

wsdlLocation occurences:
javax.jws.WebService.wsdlLocation()
javax.xml.ws.WebServiceClient.wsdlLocation()
javax.xml.ws.WebServiceProvider.wsdlLocation()
javax.xml.ws.WebServiceRef.wsdlLocation()


Occurences of WSDL_PORT

WSDL_PORT occurences:
javax.xml.ws.handler.WSDL_PORT
javax.xml.ws.WSDL_PORT


Occurences of WSDL_SERVICE

WSDL_SERVICE occurences:
javax.xml.ws.handler.WSDL_SERVICE
javax.xml.ws.WSDL_SERVICE


Occurences of WStringSeqHolder (constructors)

WStringSeqHolder (constructors) occurences:
org.omg.CORBA.WStringSeqHolder()
org.omg.CORBA.WStringSeqHolder(java.lang.String[])


Occurences of W_RESIZE_CURSOR

W_RESIZE_CURSOR occurences:
java.awt.W_RESIZE_CURSOR
java.awt.W_RESIZE_CURSOR


Occurences of x

x occurences:
java.awt.geom.x
java.awt.geom.x
java.awt.geom.x
java.awt.geom.x
java.awt.geom.x
java.awt.geom.x
java.awt.geom.x
java.awt.geom.x
java.awt.geom.x
java.awt.geom.x
java.awt.x
java.awt.x
java.awt.x


Occurences of x1

x1 occurences:
java.awt.geom.x1
java.awt.geom.x1
java.awt.geom.x1
java.awt.geom.x1
java.awt.geom.x1
java.awt.geom.x1


Occurences of x2

x2 occurences:
java.awt.geom.x2
java.awt.geom.x2
java.awt.geom.x2
java.awt.geom.x2
java.awt.geom.x2
java.awt.geom.x2


Occurences of X500Principal (constructors)

X500Principal (constructors) occurences:
javax.security.auth.x500.X500Principal(byte[])
javax.security.auth.x500.X500Principal(java.io.InputStream)
javax.security.auth.x500.X500Principal(java.lang.String)
javax.security.auth.x500.X500Principal(java.lang.String, java.util.Map)


Occurences of X500PrivateCredential (constructors)

X500PrivateCredential (constructors) occurences:
javax.security.auth.x500.X500PrivateCredential(java.security.cert.X509Certificate, java.security.PrivateKey)
javax.security.auth.x500.X500PrivateCredential(java.security.cert.X509Certificate, java.security.PrivateKey, java.lang.String)


Occurences of X509Certificate

X509Certificate occurences:
java.security.cert.X509Certificate
javax.security.cert.X509Certificate


Occurences of X509Certificate (constructors)

X509Certificate (constructors) occurences:
java.security.cert.X509Certificate()
javax.security.cert.X509Certificate()


Occurences of XAException (constructors)

XAException (constructors) occurences:
javax.transaction.xa.XAException()
javax.transaction.xa.XAException(int)
javax.transaction.xa.XAException(java.lang.String)


Occurences of XA_RDONLY

XA_RDONLY occurences:
javax.transaction.xa.XA_RDONLY
javax.transaction.xa.XA_RDONLY


Occurences of XMLDecoder (constructors)

XMLDecoder (constructors) occurences:
java.beans.XMLDecoder(java.io.InputStream)
java.beans.XMLDecoder(java.io.InputStream, java.lang.Object)
java.beans.XMLDecoder(java.io.InputStream, java.lang.Object, java.beans.ExceptionListener)
java.beans.XMLDecoder(java.io.InputStream, java.lang.Object, java.beans.ExceptionListener, java.lang.ClassLoader)


Occurences of XMLFilterImpl (constructors)

XMLFilterImpl (constructors) occurences:
org.xml.sax.helpers.XMLFilterImpl()
org.xml.sax.helpers.XMLFilterImpl(org.xml.sax.XMLReader)


Occurences of XMLNS

XMLNS occurences:
javax.xml.crypto.dsig.XMLNS
org.xml.sax.helpers.XMLNS


Occurences of XMLParseException (constructors)

XMLParseException (constructors) occurences:
javax.management.modelmbean.XMLParseException()
javax.management.modelmbean.XMLParseException(java.lang.Exception, java.lang.String)
javax.management.modelmbean.XMLParseException(java.lang.String)


Occurences of XMLReaderAdapter (constructors)

XMLReaderAdapter (constructors) occurences:
org.xml.sax.helpers.XMLReaderAdapter()
org.xml.sax.helpers.XMLReaderAdapter(org.xml.sax.XMLReader)


Occurences of XMLSignatureException (constructors)

XMLSignatureException (constructors) occurences:
javax.xml.crypto.dsig.XMLSignatureException()
javax.xml.crypto.dsig.XMLSignatureException(java.lang.String)
javax.xml.crypto.dsig.XMLSignatureException(java.lang.String, java.lang.Throwable)
javax.xml.crypto.dsig.XMLSignatureException(java.lang.Throwable)


Occurences of XMLStreamException (constructors)

XMLStreamException (constructors) occurences:
javax.xml.stream.XMLStreamException()
javax.xml.stream.XMLStreamException(java.lang.String)
javax.xml.stream.XMLStreamException(java.lang.String, java.lang.Throwable)
javax.xml.stream.XMLStreamException(java.lang.String, javax.xml.stream.Location)
javax.xml.stream.XMLStreamException(java.lang.String, javax.xml.stream.Location, java.lang.Throwable)
javax.xml.stream.XMLStreamException(java.lang.Throwable)


Occurences of xor

xor occurences:
java.math.BigInteger.xor(java.math.BigInteger)
java.util.BitSet.xor(java.util.BitSet)


Occurences of XOR

XOR occurences:
com.sun.source.tree.XOR
java.awt.XOR


Occurences of XPathException (constructors)

XPathException (constructors) occurences:
javax.xml.xpath.XPathException(java.lang.String)
javax.xml.xpath.XPathException(java.lang.Throwable)


Occurences of XPathExpressionException (constructors)

XPathExpressionException (constructors) occurences:
javax.xml.xpath.XPathExpressionException(java.lang.String)
javax.xml.xpath.XPathExpressionException(java.lang.Throwable)


Occurences of XPathFactoryConfigurationException (constructors)

XPathFactoryConfigurationException (constructors) occurences:
javax.xml.xpath.XPathFactoryConfigurationException(java.lang.String)
javax.xml.xpath.XPathFactoryConfigurationException(java.lang.Throwable)


Occurences of XPathFilterParameterSpec (constructors)

XPathFilterParameterSpec (constructors) occurences:
javax.xml.crypto.dsig.spec.XPathFilterParameterSpec(java.lang.String)
javax.xml.crypto.dsig.spec.XPathFilterParameterSpec(java.lang.String, java.util.Map)


Occurences of XPathFunctionException (constructors)

XPathFunctionException (constructors) occurences:
javax.xml.xpath.XPathFunctionException(java.lang.String)
javax.xml.xpath.XPathFunctionException(java.lang.Throwable)


Occurences of XPathType (constructors)

XPathType (constructors) occurences:
javax.xml.crypto.dsig.spec.XPathType(java.lang.String, javax.xml.crypto.dsig.spec.XPathType.Filter)
javax.xml.crypto.dsig.spec.XPathType(java.lang.String, javax.xml.crypto.dsig.spec.XPathType.Filter, java.util.Map)


Occurences of X_AXIS

X_AXIS occurences:
javax.swing.text.X_AXIS
javax.swing.X_AXIS


Occurences of y

y occurences:
java.awt.geom.y
java.awt.geom.y
java.awt.geom.y
java.awt.geom.y
java.awt.geom.y
java.awt.geom.y
java.awt.geom.y
java.awt.geom.y
java.awt.geom.y
java.awt.geom.y
java.awt.y
java.awt.y
java.awt.y


Occurences of y1

y1 occurences:
java.awt.geom.y1
java.awt.geom.y1
java.awt.geom.y1
java.awt.geom.y1
java.awt.geom.y1
java.awt.geom.y1


Occurences of y2

y2 occurences:
java.awt.geom.y2
java.awt.geom.y2
java.awt.geom.y2
java.awt.geom.y2
java.awt.geom.y2
java.awt.geom.y2


Occurences of YEAR

YEAR occurences:
java.text.YEAR
java.util.YEAR


Occurences of YES_NO_CANCEL_OPTION

YES_NO_CANCEL_OPTION occurences:
javax.security.auth.callback.YES_NO_CANCEL_OPTION
javax.swing.YES_NO_CANCEL_OPTION


Occurences of YES_NO_OPTION

YES_NO_OPTION occurences:
javax.security.auth.callback.YES_NO_OPTION
javax.swing.YES_NO_OPTION


Occurences of yPositionForValue

yPositionForValue occurences:
javax.swing.plaf.basic.BasicSliderUI.yPositionForValue(int)
javax.swing.plaf.basic.BasicSliderUI.yPositionForValue(int, int, int)


Occurences of Y_AXIS

Y_AXIS occurences:
javax.swing.text.Y_AXIS
javax.swing.Y_AXIS


Occurences of ZERO

ZERO occurences:
java.math.ZERO
java.math.ZERO


Occurences of ZipEntry (constructors)

ZipEntry (constructors) occurences:
java.util.zip.ZipEntry(java.lang.String)
java.util.zip.ZipEntry(java.util.zip.ZipEntry)


Occurences of ZipException (constructors)

ZipException (constructors) occurences:
java.util.zip.ZipException()
java.util.zip.ZipException(java.lang.String)


Occurences of ZipFile (constructors)

ZipFile (constructors) occurences:
java.util.zip.ZipFile(java.io.File)
java.util.zip.ZipFile(java.io.File, int)
java.util.zip.ZipFile(java.lang.String)


Overview List

Mirror API
All Classes

Packages
com.sun.mirror.apt
com.sun.mirror.declaration
com.sun.mirror.type
com.sun.mirror.util


 com.sun.mirror.apt
Interfaces
AnnotationProcessor
AnnotationProcessorEnvironment
AnnotationProcessorFactory
AnnotationProcessorListener
Filer
Messager
RoundCompleteListener
RoundState
Classes
AnnotationProcessors
RoundCompleteEvent
Enums
Filer.Location


 com.sun.mirror.declaration
Interfaces
AnnotationMirror
AnnotationTypeDeclaration
AnnotationTypeElementDeclaration
AnnotationValue
ClassDeclaration
ConstructorDeclaration
Declaration
EnumConstantDeclaration
EnumDeclaration
ExecutableDeclaration
FieldDeclaration
InterfaceDeclaration
MemberDeclaration
MethodDeclaration
PackageDeclaration
ParameterDeclaration
TypeDeclaration
TypeParameterDeclaration
Enums
Modifier


 com.sun.mirror.type
Interfaces
AnnotationType
ArrayType
ClassType
DeclaredType
EnumType
InterfaceType
PrimitiveType
ReferenceType
TypeMirror
TypeVariable
VoidType
WildcardType
Enums
PrimitiveType.Kind
Exceptions
MirroredTypeException
MirroredTypesException


 com.sun.mirror.util
Interfaces
Declarations
DeclarationVisitor
SourcePosition
Types
TypeVisitor
Classes
DeclarationFilter
DeclarationVisitors
SimpleDeclarationVisitor
SimpleTypeVisitor


Overview List

Attach API
All Classes

Packages
com.sun.tools.attach
com.sun.tools.attach.spi


 com.sun.tools.attach
Classes
AttachPermission
VirtualMachine
VirtualMachineDescriptor
Exceptions
AgentInitializationException
AgentLoadException
AttachNotSupportedException


 com.sun.tools.attach.spi
Classes
AttachProvider


Overview List

Compiler Tree API
All Classes

Packages
com.sun.source.tree
com.sun.source.util


 com.sun.source.tree
Interfaces
AnnotationTree
ArrayAccessTree
ArrayTypeTree
AssertTree
AssignmentTree
BinaryTree
BlockTree
BreakTree
CaseTree
CatchTree
ClassTree
CompilationUnitTree
CompoundAssignmentTree
ConditionalExpressionTree
ContinueTree
DoWhileLoopTree
EmptyStatementTree
EnhancedForLoopTree
ErroneousTree
ExpressionStatementTree
ExpressionTree
ForLoopTree
IdentifierTree
IfTree
ImportTree
InstanceOfTree
LabeledStatementTree
LineMap
LiteralTree
MemberSelectTree
MethodInvocationTree
MethodTree
ModifiersTree
NewArrayTree
NewClassTree
ParameterizedTypeTree
ParenthesizedTree
PrimitiveTypeTree
ReturnTree
Scope
StatementTree
SwitchTree
SynchronizedTree
ThrowTree
Tree
TreeVisitor
TryTree
TypeCastTree
TypeParameterTree
UnaryTree
VariableTree
WhileLoopTree
WildcardTree
Enums
Tree.Kind


 com.sun.source.util
Interfaces
SourcePositions
TaskListener
Classes
JavacTask
SimpleTreeVisitor
TaskEvent
TreePath
TreePathScanner
Trees
TreeScanner
Enums
TaskEvent.Kind


 com.sun.javadoc
Interfaces
AnnotationDesc
AnnotationDesc.ElementValuePair
AnnotationTypeDoc
AnnotationTypeElementDoc
AnnotationValue
ClassDoc
ConstructorDoc
Doc
DocErrorReporter
ExecutableMemberDoc
FieldDoc
MemberDoc
MethodDoc
PackageDoc
Parameter
ParameterizedType
ParamTag
ProgramElementDoc
RootDoc
SeeTag
SerialFieldTag
SourcePosition
Tag
ThrowsTag
Type
TypeVariable
WildcardType
Classes
Doclet
Enums
LanguageVersion


 com.sun.tools.doclets
Interfaces
Taglet


 com.sun.tools.jconsole
Interfaces
JConsoleContext
Classes
JConsolePlugin
Enums
JConsoleContext.ConnectionState


Overview List

Java Debug Interface
All Classes

Packages
com.sun.jdi
com.sun.jdi.connect
com.sun.jdi.connect.spi
com.sun.jdi.event
com.sun.jdi.request


 com.sun.jdi
Interfaces
Accessible
ArrayReference
ArrayType
BooleanType
BooleanValue
ByteType
ByteValue
CharType
CharValue
ClassLoaderReference
ClassObjectReference
ClassType
DoubleType
DoubleValue
Field
FloatType
FloatValue
IntegerType
IntegerValue
InterfaceType
LocalVariable
Locatable
Location
LongType
LongValue
Method
Mirror
MonitorInfo
ObjectReference
PathSearchingVirtualMachine
PrimitiveType
PrimitiveValue
ReferenceType
ShortType
ShortValue
StackFrame
StringReference
ThreadGroupReference
ThreadReference
Type
TypeComponent
Value
VirtualMachine
VirtualMachineManager
VoidType
VoidValue
Classes
Bootstrap
JDIPermission
Exceptions
AbsentInformationException
ClassNotLoadedException
ClassNotPreparedException
IncompatibleThreadStateException
InconsistentDebugInfoException
InternalException
InvalidCodeIndexException
InvalidLineNumberException
InvalidStackFrameException
InvalidTypeException
InvocationException
NativeMethodException
ObjectCollectedException
VMCannotBeModifiedException
VMDisconnectedException
VMMismatchException
VMOutOfMemoryException


 com.sun.jdi.connect
Interfaces
AttachingConnector
Connector
Connector.Argument
Connector.BooleanArgument
Connector.IntegerArgument
Connector.SelectedArgument
Connector.StringArgument
LaunchingConnector
ListeningConnector
Transport
Exceptions
IllegalConnectorArgumentsException
TransportTimeoutException
VMStartException


 com.sun.jdi.connect.spi
Classes
Connection
TransportService
TransportService.Capabilities
TransportService.ListenKey
Exceptions
ClosedConnectionException


 com.sun.jdi.event
Interfaces
AccessWatchpointEvent
BreakpointEvent
ClassPrepareEvent
ClassUnloadEvent
Event
EventIterator
EventQueue
EventSet
ExceptionEvent
LocatableEvent
MethodEntryEvent
MethodExitEvent
ModificationWatchpointEvent
MonitorContendedEnteredEvent
MonitorContendedEnterEvent
MonitorWaitedEvent
MonitorWaitEvent
StepEvent
ThreadDeathEvent
ThreadStartEvent
VMDeathEvent
VMDisconnectEvent
VMStartEvent
WatchpointEvent


 com.sun.jdi.request
Interfaces
AccessWatchpointRequest
BreakpointRequest
ClassPrepareRequest
ClassUnloadRequest
EventRequest
EventRequestManager
ExceptionRequest
MethodEntryRequest
MethodExitRequest
ModificationWatchpointRequest
MonitorContendedEnteredRequest
MonitorContendedEnterRequest
MonitorWaitedRequest
MonitorWaitRequest
StepRequest
ThreadDeathRequest
ThreadStartRequest
VMDeathRequest
WatchpointRequest
Exceptions
DuplicateRequestException
InvalidRequestStateException


- Exceptions In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

Exceptions In RMI

APPENDIX A

Topics:

  • Exceptions During Remote Object Export
  • Exceptions During RMI Call
  • Exceptions or Errors During Return
  • Naming Exceptions
  • Activation Exceptions
  • Other Exceptions

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Exceptions In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

A.1 Exceptions During Remote Object Export

When a remote object class is created that extends UnicastRemoteObject, the object is exported, meaning it can receive calls from external Java virtual machines and can be passed in an RMI call as either a parameter or return value. An object can either be exported on an anonymous port or on a specified port. For objects not extended from UnicastRemoteObject, the java.rmi.server.UnicastRemoteObject.exportObject method is used to explicitly export the object.

Exception
 Context

java.rmi.StubNotFoundException

Class of stub not found.

Name collision with class of same name as stub causes one of these errors:

  • Stub can't be instantiated

  • Stub not of correct class

    • Bad URL due to wrong codebase.

    Stub not of correct class.

    java.rmi.server.SkeletonNotFoundException

    note: this exception is deprecated as of Java 2 SDK, Standard Edition, v1.2

    Class of skeleton not found.

    Name collision with class of same name as skeleton causes one of these errors:

  • Skeleton can't be instantiated

  • Skeleton not of correct class

    • Bad URL due to wrong codebase.

    Skeleton not of correct class.

    java.rmi.server.ExportException

    The port is in use by another VM.

    CONTENTS | PREV | NEXT
    Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Exceptions In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

A.2 Exceptions During RMI Call

Exception
 Context

java.rmi.UnknownHostException

Unknown host.

java.rmi.ConnectException

Connection refused to host.

java.rmi.ConnectIOException

I/O error creating connection.

java.rmi.MarshalException

I/O error marshaling transport header, marshaling call header, or marshaling arguments.

java.rmi.NoSuchObjectException

Attempt to invoke a method on an object that is no longer available.

java.rmi.StubNotFoundException

Remote object not exported.

java.rmi.activation.ActivateFailedException

Thrown by RMI runtime when activation fails during a remote call to an activatable object

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Exceptions In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

A.3 Exceptions or Errors During Return

Exception
 Context

java.rmi.UnmarshalException

Corrupted stream leads to either an I/O or protocol error when:

  • Marshaling return header

  • Checking return type

  • Checking return code

  • Unmarshaling return

    • Return value class not found.

    java.rmi.UnexpectedException

    An exception not mentioned in the method signature occurred (excluding runtime exceptions). The UnexpectedException exception object contains the underlying exception that was thrown by the server.

    java.rmi.ServerError

    Any error that occurs while the server is executing a remote method. The ServerError exception object contains the underlying error that was thrown by the server,

    java.rmi.ServerException

    This exception is thrown as a result of a remote method invocation when a RemoteException is thrown while processing the invocation on the server, either while unmarshalling the arguments or executing the remote method itself. For examples, see Section A.3.1, "Possible Causes of java.rmi.ServerException".

    java.rmi.ServerRuntimeException

    note: this exception is deprecated as of Java 2 SDK, Standard Edition, v1.2

    This exception is not thrown by servers running Java 2 SDK, Standard Edition, v1.2-compatible versions. A RuntimeException is propagated to clients intact.

    CONTENTS | PREV | NEXT
    Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Exceptions In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

A.3.1 Possible Causes of java.rmi.ServerException

These are some of the underlying exceptions which can occur on the server when the server is itself executing a remote method invocation. These exceptions are wrapped in a java.rmi.ServerException; that is the java.rmi.ServerException contains the original exception for the client to extract. These exceptions are wrapped by ServerException so that the client will know that its own remote method invocation on the server did not fail, but that a secondary remote method invocation made by the server failed.

Exception
 Context

java.rmi.server.SkeletonMismatchException

note: this exception is deprecated as of the Java 2 SDK, Standard Edition, v1.2

Hash mismatch of stub and skeleton.

java.rmi.UnmarshalException

I/O error unmarshaling call header. I/O error unmarshaling arguments. Invalid method number or method hash.

java.rmi.MarshalException

Protocol error marshaling return.

java.rmi.RemoteException

A RemoteException occurring as a result of a remote invocation by the server.

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Exceptions In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

A.4 Naming Exceptions

The following table lists the exceptions specified in methods of the java.rmi.Naming class and the java.rmi.registry.Registry interface.

java.rmi.Naming class and the java.rmi.registry.Registry interface.">
Exception
 Context

java.rmi.AccessException

Operation disallowed. The registry restricts bind, rebind, and unbind to the same host. The lookup operation can originate from any host.

java.rmi.AlreadyBoundException

Attempt to bind a name that is already bound.

java.rmi.NotBoundException

Attempt to look up a name that is not bound.

java.rmi.UnknownHostException

Attempt to contact a registry on an unknown host.

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Exceptions In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

A.5 Activation Exceptions

The following table lists the exceptions that can be thrown in activities involving activatable objects. The activation API is in the package java.rmi.activation.

java.rmi.activation.">
Exception
 Context

java.rmi.activation.ActivateFailedException

Thrown by RMI runtime when activation fails during a remote call to an activatable object.

java.rmi.activation.ActivationException

General exception class used by the activation interfaces and classes.

java.rmi.activation.UnknownGroupException

Thrown by methods of the activation classes and interfaces when the ActivationGroupID parameter or ActivationGroupID in an ActivationGroupDesc parameter is invalid.

java.rmi.activation.UnknownObjectException

Thrown by methods of the activation classes and interfaces when the ActivationID parameter is invalid.

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Exceptions In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

A.6 Other Exceptions

Exception
 Context

java.rmi.RMISecurityException

note: this exception is deprecated as of the Java 2 SDK, Standard Edition, v1.2

A security exception that is thrown by the RMISecurityManager.

java.rmi.server.ServerCloneException

Clone failed.

java.rmi.server.ServerNotActiveException

Attempt to get the client host via the RemoteServer.getClientHost method when the remote server is not executing in a remote method.

java.rmi.server.SocketSecurityException

Attempt to export object on an illegal port.

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Properties In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

Properties In RMI

APPENDIX B

Topics:

  • Server Properties
  • Activation Properties
  • Other Properties

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Properties In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

B.1 Server Properties

The following table contains a list of properties typically used by servers for configuration. Note that properties are typically restricted from being set from applets.

Property
 Description

java.rmi.server.codebase

Indicates the codebase URL of classes originating from the JVM. The codebase property is used to annotate class descriptors of classes originating from a JVM so that the class for an object sent as a parameter or return value in a remote method call can be loaded at the receiver.

java.rmi.server.disableHttp

If set to true, disables the use of HTTP for RMI calls. This means that RMI will never resort to using HTTP to invoke a call via a firewall. Defaults to false (HTTP usage is enabled).

java.rmi.server.hostname

RMI uses IP addresses to indicate the location of a server (embedded in a remote reference). If the use of a hostname is desired, this property is used to specify the fully-qualified hostname for RMI to use for remote objects exported to the local JVM. The property can also be set to an IP address. Not set by default.

java.rmi.dgc.leaseValue

Sets the lease duration that the RMI runtime grants to clients referencing remote objects in the JVM. Defaults to 10 minutes.

java.rmi.server.logCalls

If set to true, server call logging is turned on and prints to stderr. Defaults to false.

java.rmi.server.useCodebaseOnly

If set to true, when RMI loads classes (if not available via CLASSPATH) they are only loaded using the URL specified by the property java.rmi.server.codebase.

java.rmi.server.useLocalHostname

If the java.rmi.server.hostname property is not set and this property is set, then RMI will not use an IP address to denote the location (embedded in remote references) of remote objects that are exported into the JVM. Instead, RMI will use the value of the call to the method java.net.InetAddress.getLocalHost.

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Properties In RMI

CONTENTS | PREV | NEXT Java Remote Method Invocation

B.2 Activation Properties

The following table contains a list of properties used in activation.

Property
 Description

java.rmi.activation.port

The port number on which the ActivationSystem is exported. This port number should be specified in a JVM if the activation daemon rmid uses a port other than the default.

java.rmi.activation.activator.class

The class that implements the interface java.rmi.activation.Activator. This property is used internally to locate the resident implementation of the Activator from which the stub class name can be found.

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Properties In RMI

CONTENTS | PREV Java Remote Method Invocation

B.3 Other Properties

These properties are used to locate specific implementation classes within implementation packages. Note: all these properties have been deprecated as of Java 2 SDK, Standard Edition, v1.2.

Property
 Description

java.rmi.loader.packagePrefix

note: this exception is deprecated as of Java 2 SDK, Standard Edition, v1.2

The package prefix for the class that implements the interface java.rmi.server.LoaderHandler. Defaults to sun.rmi.server.

java.rmi.registry.packagePrefix

note: this exception is deprecated as of Java 2 SDK, Standard Edition, v1.2

The package prefix for the class that implements the interface java.rmi.registry.RegistryHandler. Defaults to sun.rmi.registry.

java.rmi.server.packagePrefix

note: this exception is deprecated as of Java 2 SDK, Standard Edition, v1.2

The server package prefix. Assumes that the implementation of the server reference classes (such as UnicastRef and UnicastServerRef) are located in the package defined by the prefix. Defaults to sun.rmi.server.

CONTENTS | PREV
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


- Contents

CONTENTS | PREV | NEXT Java Remote Method Invocation

Table of Contents

1 Introduction

1.1 Background
1.2 System Goals

2 Java Distributed Object Model

2.1 Distributed Object Applications
2.2 Definition of Terms
2.3 The Distributed and Nondistributed Models Contrasted
2.4 Overview of RMI Interfaces and Classes
2.5 Implementing a Remote Interface
2.6 Parameter Passing in Remote Method Invocation
2.7 Locating Remote Objects

3 RMI System Overview

3.1 Stubs and Skeletons
3.2 Thread Usage in Remote Method Invocations
3.3 Garbage Collection of Remote Objects
3.4 Dynamic Class Loading
3.5 RMI Through Firewalls Via Proxies

4 Client Interfaces

4.1 The Remote Interface
4.2 The RemoteException Class
4.3 The Naming Class

5 Server Interfaces

5.1 The RemoteObject Class
5.2 The RemoteServer Class
5.3 The UnicastRemoteObject Class
5.4 The Unreferenced Interface
5.5 The RMISecurityManager Class
5.6 The RMIClassLoader Class
5.7 The LoaderHandler Interface
5.8 RMI Socket Factories
5.9 The RMIFailureHandler Interface
5.10 The LogStream Class
5.11 Stub and Skeleton Compiler

6 Registry Interfaces

6.1 The Registry Interface
6.2 The LocateRegistry Class
6.3 The RegistryHandler Interface

7 Remote Object Activation

7.1 Overview
7.2 Activation Protocol
7.3 Implementation Model for an "Activatable" Remote Object
7.4 Activation Interfaces

8 Stub/Skeleton Interfaces

8.1 The RemoteStub Class
8.2 The RemoteCall Interface
8.3 The RemoteRef Interface
8.4 The ServerRef Interface
8.5 The Skeleton Interface
8.6 The Operation Class

9 Garbage Collector Interfaces

9.1 The DGC Interface
9.2 The Lease Class
9.3 The ObjID Class
9.4 The UID Class
9.5 The VMID Class

10 RMI Wire Protocol

10.1 Overview
10.2 RMI Transport Protocol
10.3 RMI's Use of Object Serialization Protocol
10.4 RMI's Use of HTTP POST Protocol
10.5 Application-Specific Values for RMI
10.6 RMI's Multiplexing Protocol

A Exceptions In RMI

A.1 Exceptions During Remote Object Export
A.2 Exceptions During RMI Call
A.3 Exceptions or Errors During Return
A.4 Naming Exceptions
A.5 Activation Exceptions
A.6 Other Exceptions

B Properties In RMI

B.1 Server Properties
B.2 Activation Properties
B.3 Other Properties

CONTENTS | PREV | NEXT
Copyright © 1997-2006 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Object Serialization Specification
version 6.0

Change History

May 12, 2005 Updates for JavaTM SE Development Kit, v6 Beta 1

  • Added statement about how an array object returned by a readResolve invocation for an unshared read is handled.
  • Clarified the behavior in the event of an invalid serialPersistentFields value.
  • Clarified that serialVersionUID matching is waived for array classes.
  • Clarified when IllegalArgumentException is thrown by ObjectOutputStream.PutFields methods.

July 24, 2003 Updates for JavaTM 2 SDK, Standard Edition, v1.5 Beta 1

  • Added support for serializing enum constants.
  • Added specification of class modifier flags used in the computation of default serialVersionUID values to Section 4.6, "Stream Unique Identifiers".

Aug. 16, 2001 Updates for JavaTM 2 SDK, Standard Edition, v1.4 Beta 2

  • Added support for class-defined readObjectNoData methods, to be used for initializing serializable class fields in cases not covered by class-defined readObject methods. See Section 3.5, "The readObjectNoData Method", as well as Appendix A, "Security in Object Serialization".
  • New methods ObjectOutputStream.writeUnshared and ObjectInputStream.readUnshared provide a mechanism for ensuring unique references to deserialized objects. See Section 2.1, "The ObjectOutputStream Class", Section 3.1, "The ObjectInputStream Class", as well as Appendix A, "Security in Object Serialization".
  • Documented new security checks in the one-argument constructors for ObjectOutputStream and ObjectInputStream. See Section 2.1, "The ObjectOutputStream Class" and Section 3.1, "The ObjectInputStream Class".
  • Added caution against using inner classes for serialization in Section 1.10, "The Serializable Interface".
  • Clarified requirement that class-defined writeObject methods invoke ObjectOutputStream.defaultWriteObject or writeFields once before writing optional data, and that class-defined readObject methods invoke ObjectInputStream.defaultReadObject or readFields once before reading optional data. See Section 2.3, "The writeObject Method" and Section 3.4, "The readObject Method".
  • Clarified the behavior of ObjectInputStream when class-defined readObject or readExternal methods attempt read operations which exceed the bounds of available data; see Section 3.4, "The readObject Method" and Section 3.6, "The readExternal Method".
  • Clarified the description of non-proxy class descriptor field type strings to require that they be written in "field descriptor" format; see Section 6.2, "Stream Elements".

July 30, 1999 Updates for JavaTM 2 SDK, Standard Edition, v1.3 Beta

  • Added the ability to write String objects for which the UTF encoding is longer than 65535 bytes in length. See Section 6.2, "Stream Elements".
  • New methods ObjectOutputStream.writeClassDescriptor and ObjectInputStream.readClassDescriptor provide a means of customizing the serialized representation of ObjectStreamClass class descriptors. See Section 2.1, "The ObjectOutputStream Class" and Section 3.1, "The ObjectInputStream Class".
  • Expanded Appendix A, "Security in Object Serialization".

Sept. 30, 1998 Updates for JDKTM 1.2 Beta4 RC1

  • Documentation corrections only.

June 22, 1998 Updates for JDKTM 1.2 Beta4

  • Eliminated JDKTM 1.2 java.io interfaces, Replaceable and Resolvable.References to either of these classes as an interface should be replaced with java.io.Serializable. Serialization will use reflection to invoke the methods, writeReplace and readResolve, if the Serializable class defines these methods. See Section 2.5, "The writeReplace Method" and Section 3.7, "The readResolve Method."
  • New javadoc tags @serial, @serialField, and @serialData provide a way to document the Serialized Form of a Serializable class. Javadoc generates a serialization specification based on the contents of these tags. See Section 1.6, "Documenting Serializable Fields and Data for a Class."
  • Special Serializable class member, serialPersistentFields, must be declared private. See Section 1.5, "Defining Serializable Fields for a Class."
  • Clarified the steps involved in computing the serialVersionUID in Section 4.6, "Stream Unique Identifiers."

Feb. 6, 1998 Updates for JDKTM 1.2 Beta 3

  • Introduced the concept of STREAM_PROTOCOL versions. Added the STREAM_PROTOCOL_2 version to indicate a new format for Externalizable objects that enable skipping by an Externalizable object within the stream, even when the object's class is not available in the local Virtual Machine. Compatibility issues are discussed in Section 6.3, "Stream Protocol Versions."
  • The ObjectInputStream.resolveClass method can return a local class in a different package than the name of the class within the stream. This capability enables renaming of packages between releases. The serialVersionUID and the base class name must be the same in the stream and in the local version of the class. See Section 3.1, "The ObjectInputStream Class."
  • Allow substitution of String or array objects when writing them to or reading them from the stream. See Section 2.1, "The ObjectOutputStream Class" and Section 3.1, "The ObjectInputStream Class."

Sept. 4, 1997 Updates for JDKTM 1.2 Beta1

  • Separated the Replaceable interface into two interfaces: Replaceable and Resolvable. The Replaceable interface allows a class to nominate its own replacement just before serializing the object to the stream. The Resolvable interface allows a class to nominate its own replacement when reading an object from the stream.
  • Modified serialization to use the JDKTM 1.2 security model. There is a check for SerializablePermission "enableSubstitution" within the ObjectInputStream.enableReplace and ObjectOutputStream.enableResolve methods. See Section 2.1, "The ObjectOutputStream Class" and Section 3.1, "The ObjectInputStream Class."
  • Updated writeObject's exception handler to write handled IOExceptions into the stream. See Section 2.1, "The ObjectOutputStream Class."

July 3, 1997 Updates for JDKTM 1.2 Alpha

  • Documented the requirements for specifying the serialized state of classes. See Section 1.5, "Defining Serializable Fields for a Class."
  • Added the Serializable Fields API to allow classes more flexibility in accessing the serialized fields of a class. The stream protocol is unchanged. See Section 1.7, "Accessing Serializable Fields of a Class," Section 2.2, "The ObjectOutputStream.PutField Class," and Section 3.2, "The ObjectInputStream.GetField Class."
  • Clarified that field descriptors and data are written to and read from the stream in canonical order. See Section 4.1, "The ObjectStreamClass Class."

CONTENTS | PREV | NEXT
Copyright © 2005 Sun Microsystems, Inc. All Rights Reserved.


- Example of Serializable Fields

CONTENTS | PREV | NEXT Java Object Serialization Specification
version 6.0

Example of Serializable Fields

APPENDIX C

Topics:

  • Example Alternate Implementation of java.io.File

C.1 Example Alternate Implementation of java.io.File

This appendix provides a brief example of how an existing class could be specified and implemented to interoperate with the existing implementation but without requiring the same assumptions about the representation of the file name as a String.

The system class java.io.File represents a filename and has methods for parsing, manipulating files and directories by name. It has a single private field that contains the current file name. The semantics of the methods that parse paths depend on the current path separator which is held in a static field. This path separator is part of the serialized state of a file so that file name can be adjusted when read.

The serialized state of a File object is defined as the serializable fields and the sequence of data values for the file. In this case, there is one of each.

Serializable Fields:
    String path;     // path name with embedded separators
Serializable Data:
    char            // path name separator for path name
An alternate implementation might be defined as follows:
class File implements java.io.Serializable {
    ...
    private String[] pathcomponents;
    // Define serializable fields with the ObjectStreamClass

    /**

     * @serialField path String

     *              Path components separated by separator.

     */

    private static final ObjectStreamField[] serialPersistentFields
        = { new ObjectStreamField("path", String.class) };
    ...
    /**

      * @serialData  Default fields followed by separator character.

    */

    private void writeObject(ObjectOutputStream s)
        throws IOException
    {
        ObjectOutputStream.PutField fields = s.putFields();
        StringBuffer str = new StringBuffer();
        for(int i = 0; i < pathcomponents; i++) {
            str.append(separator);
            str.append(pathcomponents[i]);
        }
        fields.put("path", str.toString());
        s.writeFields();
        s.writeChar(separatorChar); // Add the separator character
    }
    ...

    private void readObject(ObjectInputStream s)
        throws IOException
    {
        ObjectInputStream.GetField fields = s.readFields();
        String path = (String)fields.get("path", null);
        ...
        char sep = s.readChar(); // read the previous separator char

        // parse path into components using the separator
        // and store into pathcomponents array.
    }
}

CONTENTS | PREV | NEXT
Copyright © 2005 Sun Microsystems, Inc. All Rights Reserved.


- Exceptions In Object Serialization

CONTENTS | PREV | NEXT Java Object Serialization Specification
version 6.0

Exceptions In Object Serialization

APPENDIX B

All exceptions thrown by serialization classes are subclasses of ObjectStreamException which is a subclass of IOException.

Exception
 Description

ObjectStreamException

Superclass of all serialization exceptions.

InvalidClassException

Thrown when a class cannot be used to restore objects for any of these reasons:

  • The class does not match the serial version of the class in the stream.

  • The class contains fields with invalid primitive data types.

  • The Externalizable class does not have a public no-arg constructor.

  • The Serializable class can not access the no-arg constructor of its closest non-Serializable superclass.

    • NotSerializableException

    Thrown by a readObject or writeObject method to terminate serialization or deserialization.

    StreamCorruptedException

    Thrown:

  • If the stream header is invalid.

  • If control information not found.

  • If control information is invalid.

  • JDKTM 1.1.5 or less attempts to call readExternal on a PROTOCOL_VERSION_2 stream.

    • NotActiveException

    Thrown if writeObject state is invalid within the following ObjectOutputStream methods:

  • defaultWriteObject

  • putFields

  • writeFields

    • Thrown if readObject state is invalid within the following ObjectInputStream methods:

  • defaultReadObject

  • readFields

  • registerValidation

    • InvalidObjectException

    Thrown when a restored object cannot be made valid.

    OptionalDataException

    Thrown by readObject when there is primitive data in the stream and an object is expected. The length field of the exception indicates the number of bytes that are available in the current block.

    WriteAbortedException

    Thrown when reading a stream terminated by an exception that occurred while the stream was being written.

    CONTENTS | PREV | NEXT
    Copyright © 2005 Sun Microsystems, Inc. All Rights Reserved.


- Security in Object Serialization

CONTENTS | PREV | NEXT Java Object Serialization Specification
version 6.0

Security in Object Serialization

APPENDIX A

Topics:

  • Overview
  • Design Goals
  • Security Issues
  • Preventing Serialization of Sensitive Data
  • Writing Class-Specific Serializing Methods
  • Guarding Unshared Deserialized Objects
  • Preventing Overwriting of Externalizable Objects
  • Encrypting a Bytestream

A.1 Overview

The object serialization system allows a bytestream to be produced from a graph of objects, sent out of the JavaTM environment (either saved to disk or transmitted over the network) and then used to recreate an equivalent set of new objects with the same state.

What happens to the state of the objects outside of the environment is outside of the control of the JavaTM system (by definition), and therefore is outside the control of the security provided by the system. The question then arises: once an object has been serialized, can the resulting byte array be examined and changed in a way that compromises the security of the Java program that deserializes it? The intent of this section is to address these security concerns.

A.2 Design Goals

The goal for object serialization is to be as simple as possible and yet still be consistent with known security restrictions; the simpler the system is, the more likely it is to be secure. The following points summarize the security measures present in object serialization:

  • Only objects implementing the java.io.Serializable or java.io.Externalizable interfaces can be serialized. Mechanisms are provided which can be used to prevent the serialization of specific fields (typically, those containing sensitive or unneeded data).
  • The serialization package cannot be used to recreate or reinitialize objects. Deserializing a byte stream may result in the creation of new objects, but will not overwrite or modify the contents of existing objects.
  • Although deserializing an object may trigger downloading of code from a remote source, the downloaded code is restricted by all of the usual JavaTM code verification and security mechanisms. Classes loaded as a side-effect of deserialization are no more or less secure than those loaded in any other fashion.

A.3 Security Issues

Naive use of object serialization may allow a malicious party with access to the serialization byte stream to read private data, create objects with illegal or dangerous state, or obtain references to the private fields of deserialized objects. Implementors concerned with security should be aware of the following implications of serialization:

  • Default serialization of an object writes the values of all fields of that object to the serialization stream, regardless of whether or not they are public. Malicious code can effectively read the values of private fields of a serializable object by serializing the object and then examining the resulting byte stream. Methods for avoiding this problem are described in Section A.4, "Preventing Serialization of Sensitive Data".
  • During deserialization, objects are created and initialized using data from the incoming serialization stream. If the stream was corrupted or tampered with prior to deserialization, the deserialized objects may have unexpected or illegal state. Methods for avoiding this problem are described in Section A.5, "Writing Class-Specific Serializing Methods".
  • By inserting extra wire handle references into a serialization byte stream, it is possible during deserialization to forge extra references to objects occurring earlier in the stream. Therefore, it is unsafe for developers to assume that references to private objects obtained via deserialization are unique. Techniques for dealing with this problem are discussed in section Section A.6, "Guarding Unshared Deserialized Objects".
  • Objects implementing the Externalizable interface are susceptible to overwriting, since the readExternal method is public. A caller can invoke the readExternal method at any time, passing it an arbitrary stream to read values from, causing the target object to be reinitialized. A means of preventing this is outlined in Section A.7, "Preventing Overwriting of Externalizable Objects".

A.4 Preventing Serialization of Sensitive Data

Fields containing sensitive data should not be serialized; doing so exposes their values to any party with access to the serialization stream. There are several methods for preventing a field from being serialized:

  • Declare the field as private transient.
  • Define the serialPersistentFields field of the class in question, and omit the field from the list of field descriptors.
  • Write a class-specific serialization method (i.e., writeObject or writeExternal) which does not write the field to the serialization stream (i.e., by not calling ObjectOutputStream.defaultWriteObject).

A.5 Writing Class-Specific Serializing Methods

To guarantee that a deserialized object does not have state which violates some set of invariants that need to be guaranteed, a class can define its own serializing and deserializing methods. If there is some set of invariants that need to be maintained between the data members of a class, only the class can know about these invariants, and it is up to the class author to provide a deserialization method that checks these invariants.

Security-conscious implementors should keep in mind that a serializable class' readObject method is effectively a public constructor, and should be treated as such. This is true whether the readObject method is implicit or explicit. It is not safe to assume that the byte stream that is provided to the readObject method was generated by serializing a properly constructed object of the correct type. It is good defensive programming to assume that the byte stream is provided by an adversary whose goal is to compromise the object under construction.

This is important even if you are not worried about security; it is possible that disk files can be corrupted and serialized data be invalid. So checking such invariants is more than just a security measure; it is a validity measure. However, the only place it can be done is in the code for the particular class, since there is no way the serialization package can determine what invariants should be maintained or checked.

In version 1.4 of the JavaTM 2 SDK, Standard Edition, support was added for class-defined readObjectNoData methods (see Section 3.5, "The readObjectNoData Method"). Non-final serializable classes which initialize fields to non-default values should define a readObjectNoData method to ensure consistent state in the event that a subclass instance is deserialized and the serialization stream does not list the class in question as a superclass of the deserialized object. This may occur in cases where the receiving party uses a different version of the deserialized instance's class than the sending party, and the receiver's version extends classes that are not extended by the sender's version. This may also occur if the serialization stream has been tampered; hence, readObjectNoData is useful for initializing deserialized objects properly despite a "hostile" or incomplete source stream

A.6 Guarding Unshared Deserialized Objects

If a class has any private or package private object reference fields, and the class depends on the fact that these object references are not available outside the class (or package), then either the referenced objects must be defensively copied as part of the deserialization process, or else the ObjectOutputStream.writeUnshared and ObjectInputStream.readUnshared methods (introduced in version 1.4 of the JavaTM 2 SDK, Standard Edition) should be used to ensure unique references to the internal objects.

In the copying approach, the sub-objects deserialized from the stream should be treated as "untrusted input": newly created objects, initialized to have the same value as the deserialized sub-objects, should be substituted for the sub-objects by the readObject method. For example, suppose an object has a private byte array field, b, that must remain private:

    private void readObject(ObjectInputStream s)
        throws IOException, ClassNotFoundException
    {
        s.defaultReadObject();

        b = (byte[])b.clone();

        if (<invariants are not satisfied>)
            throw new java.io.StreamCorruptedException();
    }
This issue is particularly important when considering serialization of immutable objects containing internal (necessarily private) references to mutable sub-objects. If no special measures are taken to copy the sub-objects during deserialization of the container object, then a malicious party with write access to the serialization stream may violate the container object's immutability by forging references to its mutable sub-objects, and using these references to change the internal state of the container object. Thus, in this case it is imperative that the immutable container class provide a class-specific deserialization method which makes private copies of each mutable component object it deserializes. Note that for the purpose of maintaining immutability, it is unnecessary to copy immutable component objects.

It is also important to note that calling clone may not always be the right way to defensively copy a sub-object. If the clone method cannot be counted on to produce an independent copy (and not to "steal" a reference to the copy), an alternative means should be used to produce the copy. An alternative means of copying should always be used if the class of the sub-object is not final, since the clone method or helper methods that it calls may be overridden by subclasses.

Starting in version 1.4 of the JavaTM 2 SDK, Standard Edition, unique references to deserialized array objects can also be ensured by using the ObjectOutputStream.writeUnshared and ObjectInputStream.readUnshared methods, thus avoiding the complication, performance costs and memory overhead of defensive copying. The readUnshared and writeUnshared methods are further described in Section 3.1, "The ObjectInputStream Class" and Section 2.1, "The ObjectOutputStream Class".

A.7 Preventing Overwriting of Externalizable Objects

Objects which implement the Externalizable interface must provide a public readExternal method. Since this method is public, it can be called at arbitrary times by anyone with access to the object. To prevent overwriting of the object's internal state by multiple (illegal) calls to readExternal, implementors may choose to add checks to insure that internal values are only set when appropriate:

    public synchronized void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        if (! initialized) {
            initialized = true;

            // read in and set field values ...
        } else {
            throw new IllegalStateException();
        }
    }

A.8 Encrypting a Bytestream

Another way of protecting a bytestream outside the virtual machine is to encrypt the stream produced by the serialization package. Encrypting the bytestream prevents the decoding and the reading of a serialized object's private state, and can help safeguard against tampering with stream contents.

Object serialization allows encryption, both by allowing classes to define their own methods for serialization and deserialization (inside which encryption can be used), and by adhering to the composable stream abstraction (allowing the output of a serialization stream to be channelled into another filter stream which encrypts the data).

CONTENTS | PREV | NEXT
Copyright © 2005 Sun Microsystems, Inc. All Rights Reserved.


-

Copyright © 2001 Sun Microsystems, Inc.

901 San Antonio Road, Palo Alto, CA 94303 USA

All rights reserved. Copyright in this document is owned by Sun Microsystems, Inc.

Sun Microsystems, Inc. (SUN) hereby grants to you at no charge a nonexclusive, nontransferable, worldwide, limited license (without the right to sublicense) under Sun's intellectual property rights in the Java Image I/O API Specification (Specification) to use the Specification for internal evaluation purposes only. Other than this limited license, you acquire no right, title, or interest in or to the Specification and you shall have no right to use the Specification for productive or commercial use.

The Specification is the confidential and proprietary information of Sun Microsystems, Inc. (Confidential Information). You may not disclose such Confidential Information to any third part and shall use it only in accordance with the terms of this license.

THIS SPECIFICATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY YOU AS A RESULT OF USING THIS SPECIFICATION.

THIS SPECIFICATION COULD INCLUDE TECHNICAL INACCURACIES OR TYPOGRAPHICAL ERRORS. CHANGES ARE PERIODICALLY ADDED TO THE INFORMATION HEREIN; THESE CHANGES WILL BE INCORPORATED IN NEW EDITIONS OF THE SPECIFICATION. SUN MICROSYSTEMS, INC. MAY MAKE IMPROVEMENTS AND/OR CHANGES IN THE SPECIFICATION AT ANY TIME, IN ITS SOLE DISCRETION. SUN IS UNDER NO OBLIGATION TO PRODUCE FURTHER VERSIONS OF THE SPECIFICATION OR ANY PRODUCT OR TECHNOLOGY BASED UPON THE SPECIFICATION. NOR IS SUN UNDER ANY OBLIGATION TO LICENSE THE SPECIFICATION OR ANY ASSOCIATED TECHNOLOGY, NOW OR IN THE FUTURE, FOR PRODUCTIVE OR OTHER USE.

RESTRICTED RIGHTS LEGEND

Use, duplication, or disclosure by the U.S. government is subject to restrictions of FAR 52.227-14(g)(2)(6/87) and FAR 52.227-19(6/87), or DFAR 252.227- 7015(b)(6/95) and DFAR 227.7202-1(a).

Sun, the Sun Logo, Sun Microsystems, Jini, JavaBeans, JDK, Java Solaris, NEO, Netra, NFS, ONC, ONC+, OpenWindows, PC-NFS, EmbeddedJava, PersonalJava, SNM, SunNet Manager, Solaris sunburst design, Solstice, SunCore, SolarNet, SunWeb, Sun Workstation, The Network Is The Computer, ToolTalk, Ultra, Ultracomputing, Ultraserver, Where The Network Is Going, Sun WorkShop, XView, Java WorkShop, and the Java Coffee Cup logo are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries.


 All Classes
ActiveClient
LWTextComponent


The front page has been renamed.Please see:
Frame version
Non-frame version.


An application written in the Java programming language uses the JDBC
DriverManager class API to access a driver based on JDBC technology
("JDBC driver"). There are various JDBC driver alternatives. A JDBC-Net
driver connects to a middle tier server and translates JDBC calls into a
DBMS-independent net protocol.  The server then translates this to a DBMS
protocol.  Other driver implementations access a DBMS directly using
proprietary database access protocols.


--                    LDAP Schema for JSR 160 Lookup
--                    ------------------------------

-- AttributeTypes:
-----------------

-- jmxServiceURL attribute is an IA5 String

( 1.3.6.1.4.1.42.2.27.11.1.1 NAME 'jmxServiceURL'
  DESC 'String representation of a JMX Service URL'
  SYNTAX 1.3.6.1.4.1.1466.115.121.1.26
  SINGLE-VALUE )

-- jmxAgentName attribute is an IA5 String

( 1.3.6.1.4.1.42.2.27.11.1.2 NAME 'jmxAgentName'
  DESC 'Name of the JMX Agent'
  SYNTAX 1.3.6.1.4.1.1466.115.121.1.26
  SINGLE-VALUE )

-- jmxProtocolType attribute is an IA5 String

( 1.3.6.1.4.1.42.2.27.11.1.3 NAME 'jmxProtocolType'
  DESC 'Protocol used by the registered connector'
  SYNTAX 1.3.6.1.4.1.1466.115.121.1.26
  SINGLE-VALUE )

-- jmxAgentHost attribute is an IA5 String

( 1.3.6.1.4.1.42.2.27.11.1.4 NAME 'jmxAgentHost'
  DESC 'Names or IP Addresses of the host on which the agent is running.
        When multiple values are given, they should be aliases to the
        same host.'
  SYNTAX 1.3.6.1.4.1.1466.115.121.1.26  )

-- jmxProperty attribute is an IA5 String

( 1.3.6.1.4.1.42.2.27.11.1.5 NAME 'jmxProperty'
  DESC 'Java-like property characterizing the registered object.
        The form of each value should be: "<property-name>=<value>".
        For instance: "com.sun.jmx.remote.tcp.timeout=200"'
  SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )

-- jmxExpirationDate attribute is a Generalized Time
-- see [RFC 2252] - or X.208 for a description of
-- Generalized Time

( 1.3.6.1.4.1.42.2.27.11.1.6 NAME 'jmxExpirationDate'
  DESC 'Date at which the JMX Service URL will be considered obsolete
        and may be removed from the directory tree'
  SYNTAX 1.3.6.1.4.1.1466.115.121.1.24
  SINGLE-VALUE )

-- ObjectClasses:
-----------------

-- jmxConnector class - represents a JMX Connector.
-- must contain the JMX Service URL
-- and the JMX Agent Name

( 1.3.6.1.4.1.42.2.27.11.2.1 NAME 'jmxConnector'
  DESC  'A class representing a JMX Connector, and containing a
         JMX Service URL. The jmxServiceURL is not present if the server
         is not accepting connections'
  AUXILIARY
  MUST  ( jmxAgentName  )
  MAY   ( jmxServiceURL $ jmxAgentHost $ jmxProtocolType $ jmxProperty $
          jmxExpirationDate $ description ) )


CONTENTS | PREV | NEXT JNDI API

Contents

1. Introduction

2. Goals and Design Principles

3. Overview of the Architecture

4. Fundamentals
4.1 Naming -- The Foundation
4.2 Directory Objects
4.3 URLs and Composite Names
4.4 Events
5. Overview of the Interface
5.1 The Naming Package -- javax.naming
5.1.1 Contexts
5.1.2 The Initial Context
5.1.3 Names
5.1.4 Bindings
5.1.5 References
5.1.6 Referrals
5.2 The Directory Package -- javax.naming.directory
5.2.1 Directory Objects
5.2.2 Attributes
5.2.3 Directory Objects as Naming Contexts
5.2.4 The Initial Context
5.2.5 Searches
5.2.6 Schema
5.3 The Event Package -- javax.naming.event
5.3.1 Naming Events
5.3.2 Naming Listeners
5.3.3 Event Registration and Deregistration
5.3.4 Exception Handling
5.4 The LDAP Package -- javax.naming.ldap
5.4.1 Extended Operations
5.4.2 Controls
5.4.3 The Initial Context
5.4.4 Unsolicited Notifications
6. Configuration
6.1 Environment Properties
6.2 Context Environment
6.3 Resource Files
6.4 Application/Applet-scope Standard JNDI Properties
6.5 How the Environment Properties are Set
6.6 Modifications to the Environment
7. Scenarios
7.1 User authentication
7.2 Electronic Mail
7.3 Databases
7.4 Browsing
7.5 Network Printing
8. Security Considerations
8.1 JNDI Classes
8.2 Security Model
8.3 Access To Servers
8.4 Sharing Context Handles
8.5 Context Environment
8.6 Class Loading
8.7 Serializable Objects
8.8 Responsibilities of Service Providers
9. Design Choices
9.1 Separation of Interfaces into Context and DirContext
9.2 Separation of JNDI into Different Functional Packages
9.3 Separation of Client APIs and Service Provider Interfaces
9.4 Multiple methods for listing Context
9.5 Support for Federation
9.6 DirContext versus DirObject
9.7 Support for Schemas
9.8 Overloaded Methods in Context and DirContext
9.9 Reference and Referenceable
9.10 Automatically Turning References into Objects

Appendix A: JNDI Standard Environment Properties

Appendix B: Examples for LDAP Programmers

Appendix C: Legend for Class Diagram

Appendix D: JNDI Change History

CONTENTS | PREV | NEXT
Copyright ©1997-1999 Sun Microsystems, Inc. All Rights Reserved.


Copyright © 1999 by Sun Microsystems Inc.

901 San Antonio Road, Palo Alto, CA 94303.

All rights reserved.

RESTRICTED RIGHTS: Use, duplication or disclosure by the government is subject to the restrictions as set forth in subparagraph (c) (1) (ii) of the Rights in Technical Data and Computer Software Clause as DFARS 252.227-7013 and FAR 52.227-19.

Sun, Sun Microsystems, the Sun logo, Java, and JavaSoft, are trademarks or registered trademarks of Sun Microsystems, Inc.

THIS PUBLICATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MECHANTABILITY, FITNESS FOR A PARTICULAR USE, OR NON-INFRINGEMENT.

THIS PUBLICATION COULD INCLUDE TECHNICAL INACCURACIES OR TYPOGRAPHICAL ERRORS. CHANGES ARE PERIODICALLY ADDED TO THE INFORMATION HEREIN; THESE CHANGES WILL BE INCORPORATED IN NEW EDITIONS OF THE PUBLICATION. SUN MICROSYSTEMS, INC., MAY MAKE NEW IMPROVEMENTS AND/OR CHANGES IN THE PRODUCT(S) AND/OR THE PROGRAM(S) DESCRIBED IN THIS PUBLICATION AT ANY TIME.

jndi@java.sun.com
Copyright © 1999, Sun Microsystems, Inc. All rights reserved.


 [Top] [Prev] [Next] [Bottom]

1 Introduction
1.1 Document Overview
1.2 Interface Overview
1.2.1 NamingManager and DirectoryManager
1.2.2 Initial Contexts
1.2.3 Object Factories
1.2.4 State Factories
1.2.5 Federation Support
2 Building a Context Implementation
2.1 Ownership of Parameters
2.2 Reentrancy
2.3 Basic Support-Implementing the Context Interface(s)
2.4 Object Support
2.4.1 Reading an Object
2.4.2 Storing an Object
2.5 Federation Support
2.5.1 Names
2.5.2 Resolving Through a Context
2.5.3 Resolving Through to Subinterfaces of Context
2.5.4 Naming System Boundaries
2.5.5 Continuing an Operation in a Federation
2.5.6 "Dynamic" Location of Next Naming System
2.5.7 More about CannotProceedException
2.5.8 Contextual Information
2.6 Referral Support
2.7 Schema Support
2.8 Event Support
2.9 Context Environment Support
2.9.1 Property Naming Convention
2.9.2 Initializing a Context's Environment
2.9.3 Inheritance
2.9.4 Updates to the Environment
2.9.5 Provider Resource Files
2.10 Connection Management
3 The Initial Context
3.1 The Initial Context Factory
3.1.1 Exceptions
3.2 URL Support
3.2.1 URL Context
3.2.2 URL Context Factory
3.2.3 Service Provider's Responsibility
3.3 Overriding the Default Behavior
3.3.1 Removing URL Support
3.3.2 Removing All Policy
3.4 Implementing a Subclass of InitialContext
3.4.1 URL Support
3.4.2 New Method Support
3.4.3 Constructors
4 Customizing A Context Implementation
4.1 Reading Objects: Object Factories
4.1.1 Handling Structured References
4.1.2 Handling URL References
4.1.3 Handling Arbitrary References: The java.naming.factory.object Property
4.1.4 Overriding the Default Behavior
4.1.5 Context Factory
4.1.6 URL Context Factory
4.2 Storing Objects: State Factories
4.2.1 Input/Output Options
4.2.2 Locating State Factories: The java.naming.factory.state Property
4.3 Narrowing LDAP v3 Controls: Response Control Factories
4.3.1 Locating Response Control Factories: The java.naming.factory.control Property
4.4 Ownership of Parameters
4.5 Reentrancy
Appendix A: Service Provider Example
Appendix B: Legend for Class Diagram
Appendix C: JNDI Change History

[Top] [Prev] [Next] [Bottom]

jndi@java.sun.com
Copyright © 1999, Sun Microsystems, Inc. All rights reserved.


- JavaTM Print Service Glossary

CONTENTS | PREV | NEXT JavaTM Print Service API User Guide

APPENDIX G

JavaTM Print Service Glossary

attribute

a description of: a capability of a print service, a charactaristic of a doc, an instruction for processing a doc or an entire print job, or the state of a print job or printer.

attribute category

the name of the attribute without its range of values. The Java Print Service represents the attribute category with a class, such as the OrientationRequested class. An instance of an attribute class, such as an OrientationRequested object, is an attribute value.

attribute set

an attribute collection that usually is restricted to contain only a certain kind of attribute. The Java Print Service defines a superinterface for all attribute sets called AttributeSet and an interface for each kind of attribute set. The kinds of attribute sets are: doc attribute set, print request attribute set, print job attribute set, and print service attribute set.

attribute value

one of the range of values that an attribute supports. The Java Print Service represents each supported attribute with one of the attribute classes, such as the OrientationRequested class. The class itself is the attribute category. An instance of the class, such as an OrientationRequested object, is the attribute value. The term attribute often refers to the attribute value because the value of an attribute implies the attribute itself.

doc

a piece of print data. the Java Print Service uses the Doc interface to represent a piece of print data.

doc attribute

an attribute that specifies a characteristic of an individual document and the print job settings to be applied to an individual document.

doc attribute set

a collection of attributes that is restricted to only contain doc attributes.

doc flavor

a document type. The Java Print Service uses the DocFlavor class to represent a document type. A DocFlavor object encapsulates a String representing a MIME type, which indicates the format of the document, and a String representing a Java class, such as "java.io.InputStream", that indicates how the document is sent to the printer.

hash attribute set

an attribute set that can contain different kinds of attributes. The Java Print Service represents this attribute set with the HashAttributeSet class, which implements AttributeSet.

print job

a submitted print request, which includes one or more pieces of print data and a set of processing instructions. The Java Print Service represents a print job with the DocPrintJob object, which is obtained from a print service.

print job attribute

an attribute that reports the status of a print job. A client usually does not specify these attributes since these attributes describe the print job after the client has submitted it. To specify settings for a whole print job, the client instead uses the print request attributes.

print job attribute set

a collection of attributes that is restricted to only contain print job attributes.

print request

an unsubmitted print job.

print request attribute

an attribute that specifies a setting applied to a whole print job and to all the documents in the print job.

print request attribute set

a collection of attributes that is restricted to only contain print request attributes.

print service

an interface that represents a particular printer and is a factory for print jobs.

print service attribute

an attribute that describes a printer. An example of such an attribute is one that describes the printer's location.

print service attribute set

a collection of attributes that is restricted to only contain print service attributes.

print-service lookup

the action of attempting to locate a set of print services representing printers that can print a given set of print data according to a given set of processing instructions. A client uses the PrintServiceLookup class to perform this action.

stream print service

a print service that prints data to a client-provided output stream.

CONTENTS | PREV | NEXT
Copyright © 2001 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT JavaTM Print Service API User Guide

1. Introduction

History of Printing on the Java Platform
What the Java Print Service API Offers
Java Print Service Architecture
The javax.print Package
Discover Print Services
Specify the Print Data Format
Create Print Jobs
The javax.print.event Package
How Applications Use the Java Print Service
A Basic Example

2. Attributes

Attribute Categories and Values
Attribute Roles
Attribute Sets
How to Specify Attributes
Standard Attributes
OrientationRequested
Copies
Media
MediaSize
MediaPrintableArea
Destination
SheetCollate
Sides
Fidelity
Uses of JPS Attributes

3. Specifying Document Types

Client-Formatted Print Data
MIME Types for Preformatted Data
Text Data
Page Description Language Documents
Image Data
Autosense Print Data
Representation Classes
Importance of Character Encoding
Service-Formatted Print Data
How to Use DocFlavor

4. Printing and Streaming Documents

StreamPrintService Versus PrintService
Locating Services
Discovering Print Services
Discovering Stream Print Services
Obtaining a Print Job
Creating a Doc
Registering for Events
Print Service Events
Print Job Events
PrintJobAttributeListener
PrintJobListener
Submitting the Print Job
Submitting the Print Job to the Printer
Submitting the Print Job to the Stream
Print Service Providers

5. Printing and Streaming 2D Graphics

Using PrinterJob to Print or Stream Graphics
Printing 2D Graphics
Streaming 2D Graphics
Using Service-Formatted Data
Printing the Service-Formatted Data
Streaming Service-Formatted Print Data

A. Example: PrintPS.java

B. Example: PrintGIFtoStream.java

C. Example: Print2DPrinterJob.java

D. Example: Print2DGraphics.java

E. Example: Print2DtoStream.java

F. Example: PrintGIF.java

G. JavaTM Print Service Glossary

CONTENTS | PREV | NEXT
Copyright © 2001 Sun Microsystems, Inc. All Rights Reserved.


UML Sequence diagram shows how a client and a server normally make a TCP
connection with ServerSocket and Socket classes.


UML Sequence diagram show how a datagram packet is sent with
DatagramPacket and DatagramSocket classes.


UML Sequence diagram shows how to open a connection and access a URL with
the URL and URLConnection classes.


Contents | Prev | Next Java Core Reflection

Copyright Information

© 1996, 1997, 1998 Sun Microsystems, Inc. All rights reserved.
2550 Garcia Avenue, Mountain View, California 94043-1100 U.S.A.

This document is protected by copyright. No part of this document may be reproduced in any form by any means without prior written authorization of Sun and its licensors, if any.

The information described in this document may be protected by one or more U.S. patents, foreign patents, or pending applications.

TRADEMARKS

Sun, Sun Microsystems, Sun Microelectronics, the Sun Logo, SunXTL, JavaSoft, JavaOS, the JavaSoft Logo, Java, HotJava, JavaChips, picoJava, microJava, UltraJava, JDBC, the Java Cup and Steam Logo, "Write Once, Run Anywhere" and Solaris are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries.
UNIX ® is a registered trademark in the United States and other countries, exclusively licensed through X/Open Company, Ltd.
Adobe ® is a registered trademark of Adobe Systems, Inc.
Netscape NavigatorTM is a trademark of Netscape Communications Corporation.
All other product names mentioned herein are the trademarks of their respective owners.

THIS DOCUMENT IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.

THIS DOCUMENT COULD INCLUDE TECHNICAL INACCURACIES OR TYPOGRAPHICAL ERRORS. CHANGES ARE PERIODICALLY ADDED TO THE INFORMATION HEREIN; THESE CHANGES WILL BE INCORPORATED IN NEW EDITIONS OF THE DOCUMENT. SUN MICROSYSTEMS, INC. MAY MAKE IMPROVEMENTS AND/OR CHANGES IN THE PRODUCT(S) AND/OR THE PROGRAM(S) DESCRIBED IN THIS DOCUMENT AT ANY TIME.

Contents | Prev | Next
Copyright © 1996, 1997, 1998 Sun Microsystems, Inc. All rights reserved.


Certification Form for CSPs

Sun's JCE implements encryption using Cryptographic Service
Providers (CSPs). Only CSPs signed by a trusted entity can be
plugged into the JCE framework. You have indicated that you
will be providing a CSP for JCE. Please read, sign, and return
this form to:

    Sun Microsystems, Inc.
    International Trade Services/Export Compliance
    Attn: Encryption Export
    10 Network Circle MS: UMPK10-144
    Menlo Park, CA 94025

You can also fax paperwork to the follwing number, with the following headings:

    Fax #: 408-668-0918

    Subject Line: CSR #___
    Attention: Encryption Export
    Sun Microsystems, Inc.
    International Trade Services/Export Compliance

Before you return this form, you must send, via email, a
Certificate Signing Request (CSR) and contact information
to javasoft-cert-request@sun.com, as noted in
java.sun.com/j2se/1.4.2/docs/guide/security/jce/HowToImplAJCEProvider.html

In response, you will receive a request number, also via email.
You may then mail this form. Include the request number here:

    Request Number: ______________________________

Including the request number ensures this form can be matched
to your email message.

                        Overview

Export controls on commercial encryption products are
administered by the Bureau of Industry and Security (BIS) in the
U.S. Department of Commerce. Rules governing exports of
encryption are found in the Export Administration Regulations
(EAR), 15 CFR Parts 730-774  which implements the Export
Administration Act ("EAA" 50 U.S.C. App. 2401 et seq.).

BIS requires that each entity exporting products be familiar
with and comply with their affirmative obligations set forth in
the Export Administration Regulations.  Please note that the
regulations are subject to change.  We recommend that you obtain
your own legal advice when attempting to export.  In addition
some countries may restrict certain levels of encryption
imported into their country. We recommend consulting legal
counsel in the appropriate country or the applicable
governmental agencies in the particular country.

If you developed your CSP inside the United States, and you
want to export your CSP, it must be reviewed and approved
for export by the Bureau of Industry and Security.

If you developed your CSP outside the United States, then you may not
have to submit your product for a technical review, but it may be
subject to the requirements of the Export Administration
Regulations.

                      Certification

I certify that I have read the above "Overview" and will comply
with the Export Administration Regulations.  I understand that
any CSP developed in the United States may not be exported from
the United States without prior approval by the US Government
and that such approval is my responsibility.  I further understand that
any CSP developed outside the United States nevertheless may be
subject to the Export Administration Regulations.

Company: _______________________________________________

Address: _______________________________________________

Signature: ____________________________  	Date:  _______

Printed Name: ____________________________________

Title:  ____________________________________________


                Java(tm) Secure Socket Extension
            for the JavaTM 2 Standard Edition, v5.0

                        Sample Code

                          README

----------------------------------------------------------------------
CONTENTS
----------------------------------------------------------------------
    - Introduction
    - Sample KeyStores
    - Code Examples
    - Troubleshooting

----------------------------------------------------------------------
Introduction
----------------------------------------------------------------------
This JSSE sample code bundle provides some simple examples of how
the JSSE can be used to secure communications in the Java(tm) network
environment.

The samples do require some familiarity with Java and the JSSE API, so
please consult the appropriate documentation for more information.

JDK:	http://java.sun.com/doc/

JSSE:	Documentation for the JSSE API can be found in Sun's
    JDK implementation or documentation bundles, or at
    http://java.sun.com/j2se/1.5.0/docs/guide/security/jsse/JSSERefGuide.html

    If you use a JSSE implementation from a vendor other than Sun,
    also consult that JSSE implementation's documentation.  Follow any
    instructions given by the vendor as to how to configure the
    security provider, set the classpaths (if necessary), enable the
    https protocol handler, define HTTPS proxy servers, and so on.

----------------------------------------------------------------------
Sample Truststores
----------------------------------------------------------------------

This bundle includes sample KeyStore files that are used with
the sample code.  They are stored in the "JKS" KeyStore format,
which is the default format used by Sun's JDK implementation.  (If
another KeyStore format is desired, the JDK will need to be configured
to recognize the new default format.)

JSSE uses the following certificate KeyStore files to authenticate the
clients and servers.

*/testkeys      These files are used by the code samples as the source
        of public/private key and certificate material.  In the
        client program directories, the testkeys files contains
        the certificate entry for the Java mascot "Duke".  In
        the server program directories (./sockets/server and
        rmi), the file contains a certificate entry for the
        server "localhost".

        The sample code expects the testkeys file to be in the
        current working directory.

        NOTE:  These are very simple certificates and are not
        appropriate for a production environment, but they
        should be sufficient for running the samples here.

        The password for these keystores is:  passphrase

samplecacerts	This truststore file is very similar to the stock
        JDK cacerts file, in that it contains trust
        certificates from several vendors.  It also contains
        the trusted certificates from "Duke" and "localhost"
        above.

        The password for this keystore is the same as the
        JDK cacert's initial password:  changeit

        Please see your provider's documentation for
        how to configure the location of your trusted cert
        file.

        NOTES FOR RUNNING WITH SUN's JDK:
        ---------------------------------

            Users of the Sun JDK can specify the location of
            the truststore by using one of the following
            methods (and are described more fully in the Sun
            JDK JSSE Reference Guide):

            1.  System properties:

            java -Djavax.net.ssl.trustStore=samplecacerts \
                -Djavax.net.ssl.trustStorePassword=changeit
                Application

            2.  Install the file into:

            <java-home>/lib/security/jssecacerts

            3.  Install the file into:

            <java-home>/lib/security/cacerts

            If you choose 2) or 3), be sure to replace this
            file with a production cacerts file before
            deployment.

The Sun JDK utility "keytool" can be used to generate alternate
certificates and keystore files.

*******************************************

IMPORTANT NOTE:  Verify Your cacerts File

Since you trust the CAs in the cacerts file as entities for signing and
issuing certificates to other entities, you must manage the cacerts
file carefully.  The cacerts file should contain only certificates of
the entities and CAs you trust.  It is your responsibility to verify the
trusted root CA certificates bundled in the cacerts file and make your
own trust decisions.  To remove an untrusted CA certificate from the
cacerts file, use the delete option of the keytool command. You can
find the cacerts file in the JRE installation directory. Contact your
system administrator if you do not have permission to edit this file.

----------------------------------------------------------------------
Code Examples
----------------------------------------------------------------------
The sample code bundle is broken into several directories, based on
the style of SSL connections.

urls

    URLReader.java

    This example illustrates using a URL to access resources on a
    secure site.  By default, this example connects to
    www.verisign.com, but it can be adapted to connect to the
    ClassFileServer below.  To do so, the URL will need to be
    modified to point to the correct address.  You may also need to
    update the server's certificate or provide a custom
    HostNameVerifier (see HttpsURLConnection) if the hostname in
    the server's certificate doesn't match the URL's hostname.

    SPECIAL NOTES:
        If you are behind a firewall, you may need to set
        the "https.proxyHost" and "https.proxyPort" System
        properties to correctly specify the proxy.

    USAGE:
        java URLReader

    URLReaderWithOptions.java

    This example is very similar to URLReader above, but
    allows you to set the system properties via arguments to the
    main method, rather than as -D options to the java runtime
    environment.

    USAGE:
        java URLReaderWithOptions [-h proxyhost] [-p proxyport] \
            [-k protocolhandlerpkgs] [-c ciphersarray]

        proxyHost = secure proxy server hostname (https.proxyHost)
        proxyPort = secure proxy server port (https.proxyPort)
        protocolhandlerpkgs = a "|" separated list of protocol handlers
            (java.protocol.handler.pkgs)
        ciphersarray = enabled cipher suites as a comma separated list
            (https.cipherSuites)

sockets

    server

    ClassServer.java
    ClassFileServer.java

        This sample demonstrates the implementation of a
        mini-webserver, which can service simple HTTP or HTTPS
        requests (only the GET method is supported).

        By default, the server does not use SSL/TLS.  However,
        a command line option enables SSL/TLS.

        Requests must be of the form:

        GET /<filename>

        USAGE:
        java ClassFileServer port docroot [TLS [true]]

            port = the port on which the server resides
            docroot = the root of the local directory hierarchy
            TLS = an optional flag which enables SSL/TLS
            services
            true = an optional flag which requires that clients
            authenticate themselves.  This option requires
            that SSL/TLS support be enabled.

        The secure server comes preinstalled with a certificate for
        "localhost".  If server is on the same host as the client,
        URLs of the form "https://localhost:port/file" should pass
        hostname verification.  If you choose to run on separate
        hosts, you should create a new host certificate for the
        https hostname being used, otherwise there will be hostname
        mismatch problems.  (Note:  in Java this can be corrected
        in the HttpsURLConnection class by providing a custom
        HostnameVerifier implementation, or in a browswer by
        "Accept"ing the dialog box that describes the hostname
        mismatch.)

        If you are using the TLS variant (HTTPS), remember to
        specify the https protocol:

        https://hostname:2001/dir1/file1

        NOTE:  If you use a browser such as Microsoft's Internet
        Explorer or Netscape's Navigator you will see a dialog
        popup with the message that the application doesn't
        recognize the "localhost" certificate.  This is normal
        because the self-signed certificate being presented to the
        browser is not initially trusted.  If desired, you could
        import the "localhost" certificate into the browser's
        truststore.

    client

    SSLSocketClient.java

        This example demonstrates how to use a SSLSocket as a client to
        send a HTTP request and get a response from an HTTPS server.
        By default, this example connects to www.verisign.com, but
        it can easily be adapted to connect to the ClassFileServer
        above.  (Note:  The GET request must be slightly modified,
        so that a file is specified.)

        This application assumes the client is not behind a firewall.

        USAGE:
        java SSLSocketClient

    SSLSocketClientWithClientAuth.java

        This example is similar to SSLSocketClient above, but
        this shows how to set up a key manager to do client
        authentication if required by server.

        This application also assumes the client is not behind a
        firewall.

        USAGE:
        java SSLSocketClientWithClientAuth host port requestedfilepath

        NOTE:  If you are connecting to the ClassFileServer
        application above, be sure that it can find "duke"'s
        credentials.  See the "Sample Key Stores" section above.

    SSLSocketClientWithTunneling.java

        This example illustrates how to do proxy Tunneling to access a
        secure web server from behind a firewall.

        The System properties "https.proxyHost" and "https.proxyPort"
        are used to make a socket connection to the proxy host, and
        then the SSLSocket is layered on top of that Socket.

        USAGE:
        java SSLSocketClientWithTunneling

rmi

     Hello.java
     HelloImpl.java
     RMISSLClientSocketFactory.java
     RMISSLServerSocketFactory.java
     HelloClient.java

    This example illustrates how to use RMI over an SSL transport
    layer using JSSE.  The server runs HelloImpl, which sets up
    an internal RMI registry (rather than using the rmiregistry
    command).  The client runs HelloClient and communicates over
    a secured connection.

    Setting up this sample can be a little tricky, here are the
    necessary steps:

        % javac *.java
        % rmic HelloImpl
        % java \
        -Djava.security.policy=policy \
        HelloImpl   (run in another window)
        % java HelloClient (run in another window)

    For the server, the RMI security manager will be installed, and
    the supplied policy file grants permission to accept
    connections from any host.  Obviously, giving all permissions
    should not be done in a production environment.  You will need
    to give it the appropriate restrictive network privileges, such
    as:

        permission java.net.SocketPermission \
        "hostname:1024-", "accept,resolve";

    In addition, this example can be easily updated to run with
    the new standard SSL/TLS-based RMI Socket Factories. To do this,
    modify the HelloImpl.java file to use:

        javax.rmi.ssl.SslRMIClientSocketFactory
        javax.rmi.ssl.SslRMIServerSocketFactory

    instead of:

        RMISSLClientSocketFactory
        RMISSLServerSocketFactory

    These new classes use SSLSocketFactory.getDefault() and
    SSLServerSocketFactory.getDefault(), so you will need to
    configure the system properly to locate your key and trust
    material.

    NOTES FOR RUNNING WITH SUN's JDK:
    ---------------------------------

        If you use the new classes mentioned above, you can specify
        the key stores using the System properties:

        -Djavax.net.ssl.keyStore=testkeys
        -Djavax.net.ssl.keyStorePassword=passphrase

sslengine

    SSLEngineSimpleDemo.java

    This example demonstrates a very simple client/server
    application using SSLEngines.  It demonstrates the APIs without
    taking into account I/O or compute issues.

    USAGE:
    java SSLEngineSimpleDemo

NOTE:  There is a much more extensive SSLEngine sample available.
Please see the <jdk-home>/sample/nio/server directory for a
NIO/SSLEngine-based HTTP/HTTPS server.

----------------------------------------------------------------------
Troubleshooting
----------------------------------------------------------------------
One of the most common problems people have in using JSSE is when the
JSSE receives a certificate that is unknown to the mechanism that makes
trust decisions.  If an unknown certificate is received, the trust
mechanism will throw an exception saying that the certificate is
untrusted.  Make sure that the correct trust store is being used,
and that the JSSE is installed and configured correctly.

If you are using the "localhost" or "duke" credentials, be sure that
you have correctly specified the location of the samplecacerts file,
otherwise your application will not work.  (See "Sample Key Stores" for
more information.)

The SSL debug mechanism can be used to investigate such trust
problems.  See the implementation documentation for more information
about this subject.


More detailed instructions on how to compile/run this example can be
found in the sample top-level README file.

The following urls have more information about RMI and the
HelloWorld example:

        http://java.sun.com/j2se/1.5.0/docs/guide/rmi/index.html
    http://java.sun.com/docs/books/tutorial/rmi/index.html


Long description needed.


-

CONTENTS | PREV | NEXT Java Security Architecture

1 Introduction

Since the inception of Java technology, there has been strong and growing interest around the security of the Java platform as well as new security issues raised by the deployment of Java technology.

From a technology provider's point of view, Java security includes two aspects:

  • Provide the Java platform as a secure, ready-built platform on which to run Java-enabled applications in a secure fashion.
  • Provide security tools and services implemented in the Java programming language that enable a wider range of security-sensitive applications, for example, in the enterprise world.
This document discusses issues related to the first aspect, where the customers for such technologies include vendors that bundle or embed Java technology in their products (such as browsers and operating systems).

1.1 The Original Sandbox Model

The original security model provided by the Java platform is known as the sandbox model, which existed in order to provide a very restricted environment in which to run untrusted code obtained from the open network. The essence of the sandbox model is that local code is trusted to have full access to vital system resources (such as the file system) while downloaded remote code (an applet) is not trusted and can access only the limited resources provided inside the sandbox. This sandbox model is illustrated in the figure below.

The previous context describes this graphic.

The sandbox model was deployed through the Java Development Kit (JDK), and was generally adopted by applications built with JDK 1.0, including Java-enabled web browsers.

Overall security is enforced through a number of mechanisms. First of all, the language is designed to be type-safe and easy to use. The hope is that the burden on the programmer is such that the likelihood of making subtle mistakes is lessened compared with using other programming languages such as C or C++. Language features such as automatic memory management, garbage collection, and range checking on strings and arrays are examples of how the language helps the programmer to write safe code.

Second, compilers and a bytecode verifier ensure that only legitimate Java bytecodes are executed. The bytecode verifier, together with the Java Virtual Machine, guarantees language safety at run time.

Moreover, a classloader defines a local name space, which can be used to ensure that an untrusted applet cannot interfere with the running of other programs.

Finally, access to crucial system resources is mediated by the Java Virtual Machine and is checked in advance by a SecurityManager class that restricts the actions of a piece of untrusted code to the bare minimum.

JDK 1.1 introduced the concept of a "signed applet", as illustrated by the figure below. In that release, a correctly digitally signed applet is treated as if it is trusted local code if the signature key is recognized as trusted by the end system that receives the applet. Signed applets, together with their signatures, are delivered in the JAR (Java Archive) format. In JDK 1.1, unsigned applets still run in the sandbox.

The previous context describes this graphic

1.2 Evolving the Sandbox Model

The new Java 2 Platform Security Architecture, illustrated in the figure below, is introduced primarily for the following purposes.

See long description
[D]

  • Fine-grained access control.
This capability existed in the JDK from the beginning, but to use it, the application writer had to do substantial programming (e.g., by subclassing and customizing the SecurityManager and ClassLoader classes). The HotJava browser 1.0 is such an application, as it allows the browser user to choose from a small number of different security levels.

However, such programming is extremely security-sensitive and requires sophisticated skills and in-depth knowledge of computer security. The new architecture will make this exercise simpler and safer.

  • Easily configurable security policy.
Once again, this capability existed previously in the JDK but was not easy to use. Moreover, writing security code is not straightforward, so it is desirable to allow application builders and users to configure security policies without having to program.

  • Easily extensible access control structure.
Up to JDK 1.1, in order to create a new access permission, you had to add a new check method to the SecurityManager class. The new architecture allows typed permissions (each representing an access to a system resource) and automatic handling of all permissions (including yet-to-be-defined permissions) of the correct type. No new method in the SecurityManager class needs to be created in most cases. (In fact, we have so far not encountered a situation where a new method must be created.)

  • Extension of security checks to all Java programs, including applications as well as applets.
There is no longer a built-in concept that all local code is trusted. Instead, local code (e.g., non-system code, application packages installed on the local file system) is subjected to the same security control as applets, although it is possible, if desired, to declare that the policy on local code (or remote code) be the most liberal, thus enabling such code to effectively run as totally trusted. The same principle applies to signed applets and any Java application.

Finally, an implicit goal is to make internal adjustment to the design of security classes (including the SecurityManager and ClassLoader classes) to reduce the risks of creating subtle security holes in future programming.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

2 New Protection Mechanisms -- Overview of Basic Concepts

We now go over, in some detail, the new protection architecture and give a brief explanation of its functionality. We start with an overview of the basic concepts behind the new architecture. We then introduce the major new classes in a natural order, starting with permission specifications, going on to the policy and related features, followed by access control and its usage, and then covering secure class loading and resolution.

A fundamental concept and important building block of system security is the protection domain [Saltzer and Schroeder 75]. A domain can be scoped by the set of objects that are currently directly accessible by a principal, where a principal is an entity in the computer system to which permissions (and as a result, accountability) are granted. The sandbox utilized in JDK 1.0 is one example of a protection domain with a fixed boundary.

The protection domain concept serves as a convenient mechanism for grouping and isolation between units of protection. For example, it is possible (but not yet provided as a built-in feature) to separate protection domains from interacting with each other so that any permitted interaction must be either through trusted system code or explicitly allowed by the domains concerned. Note that existing object accessibility rules remain valid under the new security architecture.

Protection domains generally fall into two distinct categories: system domain and application domain. It is important that all protected external resources, such as the file system, the networking facility, and the screen and keyboard, be accessible only via system domains. The figure below illustrates the domain composition of a Java application environment.

See long description
[D]

A domain conceptually encloses a set of classes whose instances are granted the same set of permissions. Protection domains are determined by the policy currently in effect. The Java application environment maintains a mapping from code (classes and instances) to their protection domains and then to their permissions, as illustrated by the figure below.

See long description
[D]

A thread of execution (which is often, but not necessarily tied to, a single Java thread, which in turn is not necessarily tied to the thread concept of the underlying operation system) may occur completely within a single protection domain or may involve an application domain and also the system domain. For example, an application that prints a message out will have to interact with the system domain that is the only access point to an output stream. In this case, it is crucial that at any time the application domain does not gain additional permissions by calling the system domain. Otherwise, there can be serious security implications.

In the reverse situation where a system domain invokes a method from an application domain, such as when the AWT system domain calls an applet's paint method to display the applet, it is again crucial that at any time the effective access rights are the same as current rights enabled in the application domain.

In other words, a less "powerful" domain cannot gain additional permissions as a result of calling or being called by a more powerful domain.

This discussion of one thread involving two protection domains naturally generalizes to a thread that traverses multiple protection domains. A simple and prudent rule of thumb for calculating permissions is the following:

  • The permission set of an execution thread is considered to be the intersection of the permissions of all protection domains traversed by the execution thread.
  • When a piece of code calls the doPrivileged method (see below), the permission set of the execution thread is considered to include a permission if it is allowed by the said code's protection domain and by all protection domains that are called or entered directly or indirectly subsequently.
As you can see, the doPrivileged method enables a piece of trusted code to temporarily enable access to more resources than are available directly to the application that called it. This is necessary in some situations. For example, an application may not be allowed direct access to files that contain fonts, but the system utility to display a document must obtain those fonts, on behalf of the user. We provide the doPrivileged method for the system domain to deal with this situation, and the method is in fact available to all domains.

During execution, when access to a critical system resource (such as file I/O and network I/O) is requested, the resource-handling code directly or indirectly invokes a special AccessController class method that evaluates the request and decides if the request should be granted or denied.

Such an evaluation follows and generalizes the "rule of thumb" given above. The actual way in which the evaluation is conducted can vary between implementations. The basic principle is to examine the call history and the permissions granted to the relevant protection domains, and to return silently if the request is granted or throw a security exception if the request is denied.

Finally, each domain (system or application) may also implement additional protection of its internal resources within its own domain boundary. For example, a banking application may need to support and protect internal concepts such as checking accounts, deposits and withdrawals. Because the semantics of such protection is unlikely to be predictable or enforceable by the Java 2 SDK, the protection system at this level is best left to the system or application developers. Nevertheless, whenever appropriate, we provide helpful primitives to simplify developers' tasks. One such primitive is the SignedObject class, whose detail we will describe later.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

3 Permissions and Security Policy

3.1 The Permission Classes

The permission classes represent access to system resources. The java.security.Permission class is an abstract class and is subclassed, as appropriate, to represent specific accesses.

As an example of a permission, the following code can be used to produce a permission to read the file named "abc" in the /tmp directory:

    perm = new java.io.FilePermission("/tmp/abc", "read");
New permissions are subclassed either from the Permission class or one of its subclasses, such as java.security.BasicPermission. Subclassed permissions (other than BasicPermission) generally belong to their own packages. Thus, FilePermission is found in the java.io package.

A crucial abstract method that needs to be implemented for each new class of permission is the implies method. Basically, "a implies b" means that if one is granted permission "a", one is naturally granted permission "b". This is important when making access control decisions.

Associated with the abstract class java.security.Permission are the abstract class named java.security.PermissionCollection and the final class java.security.Permissions.

Class java.security.PermissionCollection represents a collection (i.e., a set that allows duplicates) of Permission objects for a single category (such as file permissions), for ease of grouping. In cases where permissions can be added to the PermissionCollection object in any order, such as for file permissions, it is crucial that the PermissionCollection object ensure that the correct semantics are followed when the implies function is called.

Class java.security.Permissions represents a collection of collections of Permission objects, or in other words, a super collection of heterogeneous permissions.

Applications are free to add new categories of permissions that the system supports. How to add such application-specific permissions is discussed later in this document.

Now we describe the syntax and semantics of all built-in permissions.

3.1.1 java.security.Permission

This abstract class is the ancestor of all permissions. It defines the essential functionalities required for all permissions.

Each permission instance is typically generated by passing one or more string parameters to the constructor. In a common case with two parameters, the first parameter is usually "the name of the target" (such as the name of a file for which the permission is aimed), and the second parameter is the action (such as "read" action on a file). Generally, a set of actions can be specified together as a comma-separated composite string.

3.1.2 java.security.PermissionCollection

This class holds a homogeneous collection of permissions. In other words, each instance of the class holds only permissions of the same type.

3.1.3 java.security.Permissions

This class is designed to hold a heterogeneous collection of permissions. Basically, it is a collection of java.security.PermissionCollection objects.

3.1.4 java.security.UnresolvedPermission

Recall that the internal state of a security policy is normally expressed by the permission objects that are associated with each code source. Given the dynamic nature of Java technology, however, it is possible that when the policy is initialized the actual code that implements a particular permission class has not yet been loaded and defined in the Java application environment. For example, a referenced permission class may be in a JAR file that will later be loaded.

The UnresolvedPermission class is used to hold such "unresolved" permissions. Similarly, the class java.security.UnresolvedPermissionCollection stores a collection of UnresolvedPermission permissions.

During access control checking on a permission of a type that was previously unresolved, but whose class has since been loaded, the unresolved permission is "resolved" and the appropriate access control decision is made. That is, a new object of the appropriate class type is instantiated, if possible, based on the information in the UnresolvedPermission. This new object replaces the UnresolvedPermission, which is removed.

If the permission is still unresolvable at this time, the permission is considered invalid, as if it is never granted in a security policy.

3.1.5 java.io.FilePermission

The targets for this class can be specified in the following ways, where directory and file names are strings that cannot contain white spaces.

file
directory (same as directory/)
directory/file
directory/* (all files in this directory)
* (all files in the current directory)
directory/- (all files in the file system under this directory)
- (all files in the file system under the current directory)
"<<ALL FILES>>" (all files in the file system)
Note that "<<ALL FILES>>" is a special string denoting all files in the system. On a Unix system, this includes all files under the root directory. On an MS-DOS system, this includes all files on all drives.

The actions are: read, write, delete, and execute. Therefore, the following are valid code samples for creating file permissions:

import java.io.FilePermission;

FilePermission p = new FilePermission("myfile", "read,write");
FilePermission p = new FilePermission("/home/gong/", "read");
FilePermission p = new FilePermission("/tmp/mytmp", "read,delete");
FilePermission p = new FilePermission("/bin/*", "execute");
FilePermission p = new FilePermission("*", "read");
FilePermission p = new FilePermission("/-", "read,execute");
FilePermission p = new FilePermission("-", "read,execute");
FilePermission p = new FilePermission("<<ALL FILES>>", "read");
The implies method in this class correctly interprets the file system. For example, FilePermission("/-", "read,execute") implies FilePermission("/home/gong/public_html/index.html", "read"), and FilePermission("bin/*", "execute") implies FilePermission("bin/emacs19.31", "execute").

Note: Most of these strings are given in platform-dependent format. For example, to represent read access to the file named "foo" in the "temp" directory on the C drive of a Windows system, you would use

FilePermission p = new FilePermission("c:\\temp\\foo", "read");
The double backslashes are necessary to represent a single backslash because the strings are processed by a tokenizer (java.io.StreamTokenizer), which allows "\" to be used as an escape string (e.g., "\n" to indicate a new line) and which thus requires two backslashes to indicate a single backslash. After the tokenizer has processed the above FilePermission target string, converting double backslashes to single backslashes, the end result is the actual path

"c:\temp\foo"
It is necessary that the strings be given in platform-dependent format until there is a universal file description language. Note also that the use of meta symbols such as "*" and "-" prevents the use of specific file names. We think this is a small limitation that can be tolerated for the moment. Finally, note that "/-" and "<<ALL FILES>>" are the same target on Unix systems in that they both refer to the entire file system. (They can refer to multiple file systems if they are all available). The two targets are potentially different on other operating systems, such as MS Windows and MacOS.

Also note that a target name that specifies just a directory, with a "read" action, as in

FilePermission p = new FilePermission("/home/gong/", "read");
means you are only giving permission to list the files in that directory, not read any of them. To allow read access to files, you must specify either an explicit file name, or an "*" or "-", as in

FilePermission p = new FilePermission("/home/gong/myfile", "read");
FilePermission p = new FilePermission("/home/gong/*", "read");
FilePermission p = new FilePermission("/home/gong/-", "read");
And finally, note that code always automatically has permission to read files from its same (URL) location, and subdirectories of that location; it does not need explicit permission to do so.

3.1.6 java.net.SocketPermission

This class represents access to a network via sockets. The target for this class can be given as "hostname:port_range", where hostname can be given in the following ways:

hostname (a single host)
IP address (a single host)
localhost (the local machine)
"" (equivalent to "localhost")
hostname.domain (a single host within the domain)
hostname.subdomain.domain
*.domain (all hosts in the domain)
*.subdomain.domain
* (all hosts)
That is, the host is expressed as a DNS name, as a numerical IP address, as "localhost" (for the local machine) or as "" (which is equivalent to specifying "localhost").

The wildcard "*" may be included once in a DNS name host specification. If it is included, it must be in the leftmost position, as in "*.sun.com".

The port_range can be given as follows:

N (a single port)
N- (all ports numbered N and above)
-N (all ports numbered N and below)
N1-N2 (all ports between N1 and N2, inclusive)
Here N, N1, and N2 are non-negative integers ranging from 0 to 65535 (2^16-1).

The actions on sockets are accept, connect, listen, and resolve (which is basically DNS lookup). Note that implicitly, the action "resolve" is implied by "accept", "connect", and "listen" -- i.e., those who can listen or accept incoming connections from or initiate out-going connections to a host should be able to look up the name of the remote host.

Below are some examples of socket permissions.

import java.net.SocketPermission;

SocketPermission p = new SocketPermission("java.sun.com","accept");
p = new SocketPermission("204.160.241.99","accept");
p = new SocketPermission("*.com","connect");
p = new SocketPermission("*.sun.com:80","accept");
p = new SocketPermission("*.sun.com:-1023","accept");
p = new SocketPermission("*.sun.com:1024-","connect");
p = new SocketPermission("java.sun.com:8000-9000",
         "connect,accept");
p = new SocketPermission("localhost:1024-",
          "accept,connect,listen");
Note that SocketPermission("java.sun.com:80,8080","accept") and SocketPermission("java.sun.com,javasun.sun.com","accept") are not valid socket permissions.

Moreover, because listen is an action that applies only to ports on the local host, whereas accept is an action that applies to ports on both the local and remote host, both actions are necessary.

3.1.7 java.security.BasicPermission

The BasicPermission class extends the Permission class. It can be used as the base class for permissions that want to follow the same naming convention as BasicPermission (see below).

The name for a BasicPermission is the name of the given permission (for example, "exitVM", "setFactory", "queuePrintJob", etc). The naming convention follows the hierarchical property naming convention. An asterisk may appear at the end of the name, following a ".", or by itself, to signify a wildcard match. For example: "java.*" or "*" is valid, "*java" or "a*b" is not valid.

The action string (inherited from Permission) is unused.Thus, BasicPermission is commonly used as the base class for "named" permissions (ones that contain a name but no actions list; you either have the named permission or you don't.) Subclasses may implement actions on top of BasicPermission, if desired.

Some of the BasicPermission subclasses are java.lang.RuntimePermission, java.security.SecurityPermission, java.util.PropertyPermission, and java.net.NetPermission.

3.1.8 java.util.PropertyPermission

The targets for this class are basically the names of Java properties as set in various property files. Examples are the "java.home" and "os.name" properties. Targets can be specified as "*" (any property), "a.*" (any property whose name has a prefix "a."), "a.b.*", and so on. Note that the wildcard can occur only once and can only be at the rightmost position.

This is one of the BasicPermission subclasses that implements actions on top of BasicPermission. The actions are read and write. Their meaning is defined as follows: "read" permission allows the getProperty method in java.lang.System to be called to get the property value, and "write" permission allows the setProperty method to be called to set the property value.

3.1.9 java.lang.RuntimePermission

The target for a RuntimePermission can be represented by any string, and there is no action associated with the targets. For example, RuntimePermission("exitVM") denotes the permission to exit the Java Virtual Machine.

The target names are:

createClassLoader
getClassLoader
setContextClassLoader
setSecurityManager
createSecurityManager
exitVM
setFactory
setIO
modifyThread
stopThread
modifyThreadGroup
getProtectionDomain
readFileDescriptor
writeFileDescriptor
loadLibrary.{library name}
accessClassInPackage.{package name}
defineClassInPackage.{package name}
accessDeclaredMembers.{class name}
queuePrintJob

3.1.10 java.awt.AWTPermission

This is in the same spirit as the RuntimePermission; it's a permission without actions. The targets for this class are:

accessClipboard
accessEventQueue
listenToAllAWTEvents
showWindowWithoutWarningBanner

3.1.11 java.net.NetPermission

This class contains the following targets and no actions:

requestPasswordAuthentication
setDefaultAuthenticator
specifyStreamHandler

3.1.12 java.lang.reflect.ReflectPermission

This is the Permission class for reflective operations. A ReflectPermission is a named permission (like RuntimePermission) and has no actions. The only name currently defined is

suppressAccessChecks
which allows suppressing the standard Java programming language access checks -- for public, default (package) access, protected, and private members -- performed by reflected objects at their point of use.

3.1.13 java.io.SerializablePermission

This class contains the following targets and no actions:

enableSubclassImplementation
enableSubstitution

3.1.14 java.security.SecurityPermission

SecurityPermissions control access to security-related objects, such as Security, Policy, Provider, Signer, and Identity objects. This class contains the following targets and no actions:

getPolicy
setPolicy
getProperty.{key}
setProperty.{key}
insertProvider.{provider name}
removeProvider.{provider name}
setSystemScope
setIdentityPublicKey
setIdentityInfo
printIdentity
addIdentityCertificate
removeIdentityCertificate
clearProviderProperties.{provider name}
putProviderProperty.{provider name}
removeProviderProperty.{provider name}
getSignerPrivateKey
setSignerKeyPair

3.1.15 java.security.AllPermission

This permission implies all permissions. It is introduced to simplify the work of system administrators who might need to perform multiple tasks that require all (or numerous) permissions. It would be inconvenient to require the security policy to iterate through all permissions. Note that AllPermission also implies new permissions that are defined in the future.

Clearly much caution is necessary when considering granting this permission.

3.1.16 javax.security.auth.AuthPermsision

AuthPermission handles authentication permissions and authentication-related object such as Subject, SubjectDomainCombiner, LoginContext, and Configuration. This class contains the following targets and no actions:

doAs
doAsPrivileged
getSubject
getSubjectFromDomainCombiner
setReadOnly
modifyPrincipals
modifyPublicCredentials
modifyPrivateCredentials
refreshCredential
destroyCredential
createLoginContext.{name}
getLoginConfiguration
setLoginConfiguration
refreshLoginConfiguration

3.1.17 Discussion of Permission Implications

Recall that permissions are often compared against each other, and to facilitate such comparisons, we require that each permission class defines an implies method that represents how the particular permission class relates to other permission classes. For example, java.io.FilePermission("/tmp/*", "read") implies java.io.FilePermission("/tmp/a.txt", "read") but does not imply any java.net.NetPermission.

There is another layer of implication that may not be immediately obvious to some readers. Suppose that one applet has been granted the permission to write to the entire file system. This presumbly allows the applet to replace the system binary, including the JVM runtime environment. This effectively means that the applet has been granted all permissions.

Another example is that if an applet is granted the runtime permission to create class loaders, it is effectively granted many more permissions, as a class loader can perform sensitive operations.

Other permissions that are "dangerous" to give out include those that allow the setting of system properties, runtime permissions for defining packages and for loading native code libraries (because the Java security architecture is not designed to and does not prevent malicious behavior at the level of native code), and of course the AllPermission.

For more information about permissions, including tables enumerating the risks of assigning specific permissions as well as a table of all the Java 2 SDK built-in methods that require permissions, see http://java.sun.com/j2se/sdk/1.2/docs/guide/security/permissions.html.

3.1.18 How To Create New Types of Permissions

It is essential that no one except Sun Microsystems should extend the permissions that are built into the Java 2 SDK, either by adding new functionality or by introducing additional target keywords into a class such as java.lang.RuntimePermission. This maintains consistency.

To create a new permission, the following steps are recommended, as shown by an example. Suppose an application developer from company ABC wants to create a customized permission to "watch TV".

First, create a new class com.abc.Permission that extends the abstract class java.security.Permission (or one of its subclasses), and another new class com.abc.TVPermission that extends the com.abc.Permission. Make sure that the implies method, among others, is correctly implemented. (Of course, com.abc.TVPermission can directly extend java.security.Permission; the intermediate com.abc.Permission is not required.)

public class com.abc.Permission extends java.security.Permission

public class com.abc.TVPermission extends com.abc.Permission
The following figure shows the subclass relationship.

Flow chart showing the logic flows from Permission to the subclass com.abc.Permission and then to com.abc.TVPermission

Second, include these new classes with the application package.

Each user that wants to allow this new type of permission for specific code does so by adding an entry in a policy file. (Details of the policy file syntax are given in a later section.) An example of a policy file entry granting code from http://java.sun.com/ permission to watch channel 5 would be:

grant codeBase  "http://java.sun.com/" {
    permission com.abc.TVPermission "channel-5", "watch";
    }
In the application's resource management code, when checking to see if a permission should be granted, call AccessController's checkPermission method using a com.abc.TVPermission object as the parameter.

   com.abc.TVPermission tvperm = new
        com.abc.TVPermission("channel-5", "watch");
   AccessController.checkPermission(tvperm);
Note that, when adding a new permission, one should create a new (permission) class and not add a new method to the security manager. (In the past, in order to enable checking of a new type of access, you had to add a new method to the SecurityManager class.)

If more elaborate TVPermissions such as "channel-1:13" or "channel-*" are allowed, then it may be necessary to implement a TVPermissionCollection object that knows how to deal with the semantics of these pseudo names.

New code should always invoke a permission check by calling the checkPermission method of the AccessController class in order to exercise the built-in access control algorithm. There is no essential need to examine whether there is a ClassLoader or a SecurityManager. On the other hand, if the algorithm should be left to the installed security manager class, then the method SecurityManager.checkPermission should be invoked instead.

3.2 java.security.CodeSource

This class extends the concept of a codebase within HTML to encapsulate not only the code location (URL) but also the certificate(s) containing public keys that should be used to verify signed code originating from that location. Note that this is not the equivalent of the CodeBase tag in HTML files. Each certificate is represented as a java.security.cert.Certificate, and each URL as a java.net.URL.

3.3 java.security.Policy

The system security policy for a Java application environment, specifying which permissions are available for code from various sources, is represented by a Policy object. More specifically, it is represented by a Policy subclass providing an implementation of the abstract methods in the Policy class.

In order for an applet (or an application running under a SecurityManager) to be allowed to perform secured actions, such as reading or writing a file, the applet (or application) must be granted permission for that particular action. The only exception is that code always automatically has permission to read files from its same CodeSource, and subdirectories of that CodeSource; it does not need explicit permission to do so.

There could be multiple instances of the Policy object, although only one is "in effect" at any time. The currently-installed Policy object can be obtained by calling the getPolicy method, and it can be changed by a call to the setPolicy method (by code with permission to reset the Policy).

The source location for the policy information utilized by the Policy object is up to the Policy implementation. The policy configuration may be stored, for example, as a flat ASCII file, as a serialized binary file of the Policy class, or as a database. There is a Policy reference implementation that obtains its information from static policy configuration files.

3.3.1 Policy File Format

In the Policy reference implementation, the policy can be specified within one or more policy configuration files. The configuration files indicate what permissions are allowed for code from specified code sources. Each configuration file must be encoded in UTF-8.

A policy configuration file essentially contains a list of entries. It may contain a "keystore" entry, and contains zero or more "grant" entries.

A keystore is a database of private keys and their associated digital certificates such as X.509 certificate chains authenticating the corresponding public keys. The keytool utility is used to create and administer keystores. The keystore specified in a policy configuration file is used to look up the public keys of the signers specified in the grant entries of the file. A keystore entry must appear in a policy configuration file if any grant entries specify signer aliases, or if any grant entries specify a principal alias (see below).

At this time, there can be only one keystore entry in the policy file (others after the first one are ignored), and it can appear anywhere outside the file's grant entries . It has the following syntax:

keystore "some_keystore_url", "keystore_type";
Here, "some_keystore_url" specifies the URL location of the keystore, and "keystore_type" specifies the keystore type. The latter is optional. If not specified, the type is assumed to be that specified by the "keystore.type" property in the security properties file.

The URL is relative to the policy file location. Thus if the policy file is specified in the security properties file as:

policy.url.1=http://foo.bar.com/blah/some.policy
and that policy file has an entry:

keystore ".keystore";
then the keystore will be loaded from:

http://foo.bar.com/blah/.keystore
The URL can also be absolute.

A keystore type defines the storage and data format of the keystore information, and the algorithms used to protect private keys in the keystore and the integrity of the keystore itself. The default type supported by Sun Microsystems is a proprietary keystore type named "JKS".

Each grant entry in a policy file essentially consists of a CodeSource and its permissions. Actually, a CodeSource consists of a URL and a set of certificates, while a policy file entry includes a URL and a list of signer names. The system creates the corresponding CodeSource after consulting the keystore to determine the certificate(s) of the specified signers.

Each grant entry in the policy file is of the following format, where the leading "grant" is a reserved word that signifies the beginning of a new entry and optional items appear in brackets. Within each entry, a leading "permission" is another reserved word that marks the beginning of a new permission in the entry. Each grant entry grants a set of permissions to a specified code source and principals.

grant [SignedBy "signer_names"] [, CodeBase "URL"]
      [, Principal [principal_class_name] "principal_name"]
      [, Principal [principal_class_name] "principal_name"] ... {
    permission permission_class_name [ "target_name" ]
               [, "action"] [, SignedBy "signer_names"];
    permission ...
};
White spaces are allowed immediately before or after any comma. The name of the permission class must be a fully qualified class name, such as java.io.FilePermission, and cannot be abbreviated (for example, to FilePermission).

Note that the action field is optional in that it can be omitted if the permission class does not require it. If it is present, then it must come immediately after the target field.

The exact meaning of a CodeBase URL value depends on the characters at the end. A CodeBase with a trailing "/" matches all class files (not JAR files) in the specified directory. A CodeBase with a trailing "/*" matches all files (both class and JAR files) contained in that directory. A CodeBase with a trailing "/-" matches all files (both class and JAR files) in the directory and recursively all files in subdirectories contained in that directory.

The CodeBase field (URL) is optional in that, if it is omitted, it signifies "any code base".

The first signer name field is a string alias that is mapped, via a separate mechanism, to a set of public keys (within certificates in the keystore) that are associated with the signers. These keys are used to verify that certain signed classes are really signed by these signers.

This signer field can be a comma-separated string containing names of multiple signers, an example of which is "Adam,Eve,Charles", which means signed by Adam and Eve and Charles (i.e., the relationship is AND, not OR).

This field is optional in that, if it is omitted, it signifies "any signer", or in other words, "It doesn't matter whether the code is signed or not".

The second signer field, inside a Permission entry, represents the alias to the keystore entry containing the public key corresponding to the private key used to sign the bytecodes that implemented the said permission class. This permission entry is effective (i.e., access control permission will be granted based on this entry) only if the bytecode implementation is verified to be correctly signed by the said alias.

A principal value specifies a class_name/principal_name pair which must be present within the executing threads principal set. The principal set is associated with the executing code by way of a Subject. The principal field is optional in that, if it is omitted, it signifies "any principals".

Note on KeyStore Alias Replacement:

If the principal class_name/principal_name pair is specified as a single quoted string, it is treated as a keystore alias. The keystore is consulted and queried (via the alias) for an X509 Certificate. If one is found, the principal_class is automatically treated as javax.security.auth.x500.X500Principal, and the principal_name is automatically treated as the subject distinguished name from the certificate. If an X509 Certificate mapping is not found, the entire grant entry is ignored.

The order between the CodeBase, SignedBy, and Principal fields does not matter.

An informal BNF grammer for the Policy file format is given below, where non-capitalized terms are terminals:

PolicyFile -> PolicyEntry | PolicyEntry; PolicyFile
PolicyEntry -> grant {PermissionEntry}; |
           grant SignerEntry {PermissionEntry} |
           grant CodebaseEntry {PermissionEntry} |
           grant PrincipalEntry {PermissionEntry} |
           grant SignerEntry, CodebaseEntry {PermissionEntry} |
           grant CodebaseEntry, SignerEntry {PermissionEntry} |
           grant SignerEntry, PrincipalEntry {PermissionEntry} |
           grant PrincipalEntry, SignerEntry {PermissionEntry} |
           grant CodebaseEntry, PrincipalEntry {PermissionEntry} |
           grant PrincipalEntry, CodebaseEntry {PermissionEntry} |
           grant SignerEntry, CodebaseEntry, PrincipalEntry {PermissionEntry} |
           grant CodebaseEntry, SignerEntry, PrincipalEntry {PermissionEntry} |
           grant SignerEntry, PrincipalEntry, CodebaseEntry {PermissionEntry} |
           grant CodebaseEntry, PrincipalEntry, SignerEntry {PermissionEntry} |
           grant PrincipalEntry, CodebaseEntry, SignerEntry {PermissionEntry} |
           grant PrincipalEntry, SignerEntry, CodebaseEntry {PermissionEntry} |
           keystore "url"
SignerEntry -> signedby (a comma-separated list of strings)
CodebaseEntry -> codebase (a string representation of a URL)
PrincipalEntry -> OnePrincipal | OnePrincipal, PrincipalEntry
OnePrincipal -> principal [ principal_class_name ] "principal_name" (a principal)
PermissionEntry -> OnePermission | OnePermission PermissionEntry
OnePermission -> permission permission_class_name
                 [ "target_name" ] [, "action_list"]
                 [, SignerEntry];
Now we give some examples. The following policy grants permission a.b.Foo to code signed by Roland:

grant signedBy "Roland" {
    permission a.b.Foo;
};
The following grants a FilePermission to all code (regardless of the signer and/or codeBase):

grant {
   permission java.io.FilePermission ".tmp", "read";
};
The following grants two permissions to code that is signed by both Li and Roland:

grant signedBy "Roland,Li" {
  permission java.io.FilePermission "/tmp/*", "read";
  permission java.util.PropertyPermission "user.*";
};
The following grants two permissions to code that is signed by Li and that comes from http://java.sun.com:

grant codeBase "http://java.sun.com/*", signedBy "Li" {
    permission java.io.FilePermission "/tmp/*", "read";
    permission java.io.SocketPermission "*", "connect";
};
The following grants two permissions to code that is signed by both Li and Roland, and only if the bytecodes implementing com.abc.TVPermission are genuinely signed by Li.

grant signedBy "Roland,Li" {
  permission java.io.FilePermission "/tmp/*", "read";
  permission com.abc.TVPermission "channel-5", "watch",
     signedBy "Li";
};
The reason for including the second signer field is to prevent spoofing when a permission class does not reside with the Java runtime installation. For example, a copy of the com.abc.TVPermission class can be downloaded as part of a remote JAR archive, and the user policy might include an entry that refers to it. Because the archive is not long-lived, the second time the com.abc.TVPermission class is downloaded, posssibly from a different web site, it is crucial that the second copy is authentic, as the presence of the permission entry in the user policy might reflect the user's confidence or belief in the first copy of the class bytecode.

The reason we chose to use digital signatures to ensure authenticity, rather than storing (a hash value of) the first copy of the bytecodes and using it to compare with the second copy, is because the author of the permission class can legitimately update the class file to reflect a new design or implementation.

Please note: The strings for a file path must be specified in a platform-dependent format; this is necessary until there is a universal file description language. The above examples have shown strings appropriate on Solaris systems. On Windows systems, when you directly specify a file path in a string, you need to include two backslashes for each actual single backslash in the path, as in

grant signedBy "Roland" {
  permission java.io.FilePermission "C:\\users\\Cathy\\*", "read";
};
This is because the strings are processed by a tokenizer (java.io.StreamTokenizer), which allows "\" to be used as an escape string (e.g., "\n" to indicate a new line) and which thus requires two backslashes to indicate a single backslash. After the tokenizer has processed the above FilePermission target string, converting double backslashes to single backslashes, the end result is the actual path

"C:\users\Cathy\*"
Finally, here are some principal-based grant entries:

grant principal javax.security.auth.x500.X500Principal "cn=Alice" {
  permission java.io.FilePermission "/home/Alice", "read, write";
};
This permits any code executing as the X500Principal, "cn=Alice", permission to read and write to "/home/Alice".

The following example shows a grant statement with both codesource and principal information.

  grant codebase "http://www.games.com",
        signedBy "Duke",
        principal javax.security.auth.x500.X500Principal "cn=Alice" {
    permission java.io.FilePermission "/tmp/games", "read, write";
  };
This allows code downloaded from "www.games.com", signed by "Duke", and executed by "cn=Alice", permission to read and write into the "/tmp/games" directory.

The following example shows a grant statement with KeyStore alias replacement:

  keystore "http://foo.bar.com/blah/.keystore";

  grant principal "alice" {
    permission java.io.FilePermission "/tmp/games", "read, write";
  };
"alice" will be replaced by
javax.security.auth.x500.X500Principal "cn=Alice"
assuming the X.509 certificate associated with the keystore alias, alice, has a subject distinguished name of "cn=Alice". This allows code executed by the X500Principal "cn=Alice" permission to read and write into the "/tmp/games" directory.

3.3.2 Property Expansion in Policy Files

Property expansion is possible in policy files and in the security properties file.

Property expansion is similar to expanding variables in a shell. That is, when a string like

"${some.property}"

appears in a policy file, or in the security properties file, it will be expanded to the value of the specified system property. For example,

permission java.io.FilePermission "${user.home}", "read";
will expand "${user.home}" to use the value of the "user.home" system property. If that property's value is "/home/cathy", then the above is equivalent to

permission java.io.FilePermission "/home/cathy", "read";
In order to assist in platform-independent policy files, you can also use the special notation of "${/}", which is a shortcut for "${file.separator}". This allows permission designations such as

permission java.io.FilePermission "${user.home}${/}*", "read";
If user.home is /home/cathy, and you are on Solaris, the above gets converted to:

permission java.io.FilePermission "/home/cathy/*", "read";
If on the other hand user.home is C:\users\cathy and you are on a Windows system, the above gets converted to:

permission java.io.FilePermission "C:\users\cathy\*", "read";
Also, as a special case, if you expand a property in a codebase, such as

grant codeBase "file:/${java.home}/lib/ext/"
then any file.separator characters will be automatically converted to /'s, which is desirable since codebases are URLs. Thus on a Windows system, even if java.home is set to C:\j2sdk1.2, the above would get converted to

grant codeBase "file:/C:/j2sdk1.2/lib/ext/"
Thus you don't need to use ${/} in codebase strings (and you shouldn't).

Property expansion takes place anywhere a double quoted string is allowed in the policy file. This includes the signedby, codebase, target names, and actions fields.

Whether or not property expansion is allowed is controlled by the value of the "policy.expandProperties" property in the security properties file. If the value of this property is true (the default), expansion is allowed.

Please note: You can't use nested properties; they will not work. For example,

"${user.${foo}}"
doesn't work, even if the "foo" property is set to "home". The reason is the property parser doesn't recognize nested properties; it simply looks for the first "${", and then keeps looking until it finds the first "}" and tries to interpret the result "${user.$foo}" as a property, but fails if there is no such property.

Also note: If a property can't be expanded in a grant entry, permission entry, or keystore entry, that entry is ignored. For example, if the system property "foo" is not defined and you have:

grant codeBase "${foo}" {
  permission ...;
  permission ...;
};
then all the permissions in this grant entry are ignored. If you have

grant {
  permission Foo "${foo}";
  permission Bar;
};
then only the "permission Foo..." entry is ignored. And finally, if you have

keystore "${foo}";
then the keystore entry is ignored.

One final note: On Windows systems, when you directly specify a file path in a string, you need to include two backslashes for each actual single backslash in the path, as in

"C:\\users\\cathy\\foo.bat"
This is because the strings are processed by a tokenizer (java.io.StreamTokenizer), which allows "\" to be used as an escape string (e.g., "\n" to indicate a new line) and which thus requires two backslashes to indicate a single backslash. After the tokenizer has processed the above string, converting double backslashes to single backslashes, the end result is

"C:\users\cathy\foo.bat"
Expansion of a property in a string takes place after the tokenizer has processed the string. Thus if you have the string

"${user.home}\\foo.bat"
then first the tokenizer processes the string, converting the double backslashes to a single backslash, and the result is

"${user.home}\foo.bat"
Then the ${user.home} property is expanded and the end result is

"C:\users\cathy\foo.bat"
assuming the user.home value is "C:\users\cathy". Of course, for platform independence, it would be better if the string was initially specified without any explicit slashes, i.e., using the ${/} property instead, as in

"${user.home}${/}foo.bat"

3.3.3 General Expansion in Policy Files

Generalized forms of expansion are also supported in policy files. For example, permission names may contain a string of the form:
${{protocol:protocol_data}}
If such a string occurs in a permission name, then the value in protocol determines the exact type of expansion that should occur, and protocol_data is used to help perform the expansion. protocol_data may be empty, in which case the above string should simply take the form:
${{protocol}}

There are two protocols supported in the default policy file implementation:

  1. ${{self}}

    The protocol, self, denotes a replacement of the entire string, ${{self}}, with one or more principal class/name pairs. The exact replacement performed depends upon the contents of the grant clause to which the permission belongs.

    If the grant clause does not contain any principal information, the permission will be ignored (permissions containing ${{self}} in their target names are only valid in the context of a principal-based grant clause). For example, BarPermission will always be ignored in the following grant clause:

            grant codebase "www.foo.com", signedby "duke" {
                permission BarPermission "... ${{self}} ...";
            };
    If the grant clause contains principal information, ${{self}} will be replaced with that same principal information. For example, ${{self}} in BarPermission will be replaced by javax.security.auth.x500.X500Principal "cn=Duke" in the following grant clause:
            grant principal javax.security.auth.x500.X500Principal "cn=Duke" {
                permission BarPermission "... ${{self}} ...";
            };
    If there is a comma-separated list of principals in the grant clause, then ${{self}} will be replaced by the same comma-separated list or principals. In the case where both the principal class and name are wildcarded in the grant clause, ${{self}} is replaced with all the principals associated with the Subject in the current AccessControlContext.

    The following example describes a scenario involving both self and KeyStore alias replacement together:

                keystore "http://foo.bar.com/blah/.keystore";

            grant principal "duke" {
                permission BarPermission "... ${{self}} ...";
            };
    In the above example, "duke" will first be expanded into
    javax.security.auth.x500.X500Principal "cn=Duke"
    assuming the X.509 certificate associated with the KeyStore alias, "duke", has a subject distinguished name of "cn=Duke". Next, ${{self}} will be replaced with the same principal information that just got expanded in the grant clause:
    javax.security.auth.x500.X500Principal "cn=Duke".
  2. ${{alias:alias_name}}

    The protocol, alias, denotes a java.security.KeyStore alias substitution. The KeyStore used is the one specified in the KeyStore entry. alias_name represents an alias into the KeyStore. ${{alias:alias_name}} is replaced with javax.security.auth.x500.X500Principal "DN", where DN represents the subject distinguished name of the certificate belonging to alias_name. For example:

                keystore "http://foo.bar.com/blah/.keystore";

            grant codebase "www.foo.com" {
                permission BarPermission "... ${{alias:duke}} ...";
            };
    In the above example the X.509 certificate associated with the alias, duke, is retrieved from the KeyStore, foo.bar.com/blah/.keystore. Assuming duke's certificate specifies "o=dukeOrg, cn=duke" as the subject distinguished name, then ${{alias:duke}} is replaced with javax.security.auth.x500.X500Principal "o=dukeOrg, cn=duke".

    The permission entry is ignored under the following error conditions:

    • The keystore entry is unspecified
    • The alias_name is not provided
    • The certificate for alias_name can not be retrieved
    • The certificate retrieved is not an X.509 certificate

3.3.4 Assigning Permissions

When a principal executes a class that originated from a particular CodeSource, the security mechanism consults the policy object to determine what permissions to grant. This is done by invoking the getPermissions or implies method on the Policy object that is installed in the VM.

Clearly, a given code source in a ProtectionDomain can match the code source given in multiple entries in the policy, for example because the wildcard "*" is allowed.

The following algorithm is used to locate the appropriate set of permissions in the policy.

1. match the public keys, if code is signed.
2. if a key is not recognized in the policy, ignore the key
   if every key is ignored, treat the code as unsigned.
3. if the keys are matched, or no signer was specified {
       try to match all URLs in the policy for the keys
   }
4. if the keys are matched (or no signer was specified),
   and the URLs are matched (or no codebase was specified) {
       try to match all principals in the policy with
       the principals associated with the current executing thread.
5. if either key, URL, or principals are not matched, use built-in default
       permission, which is the original sandbox permission.
The exact meaning of a policy entry codeBase URL value depends on the characters at the end. A codeBase with a trailing "/" matches all class files (not JAR files) in the specified directory. A codeBase with a trailing "/*" matches all files (both class and JAR files) contained in that directory. A codeBase with a trailing "/-" matches all files (both class and JAR files) in the directory and recursively all files in subdirectories contained in that directory.

As an example, given "http://java.sun.com/-" in the policy, then any code base that is on this web site matches the policy entry. Matching code bases include "http://java.sun.com/j2se/sdk/" and "http://java.sun.com/people/gong/appl.jar".

If multiple entries are matched, then all the permissions given in those entries are granted. In other words, permission assignment is additive. For example, if code signed with key A gets permission X and code signed by key B gets permission Y and no particular codebase is specified, then code signed by both A and B gets permissions X and Y. Similarly, if code with codeBase "http://java.sun.com/-" is given permission X, and "http://java.sun.com/people/*" is given permission Y, and no particular signers are specified, then an applet from "http://java.sun.com/people/applet.jar" gets both X and Y.

Note that URL matching here is purely syntactic. For example, a policy can give an entry that specifies a URL "ftp://ftp.sun.com". Such an entry is useful only when one can obtain Java code directly from ftp for execution.

To specify URLs for the local file system, a file URL can be used. For example, to specify files in the /home/cathy/temp directory in a Solaris system, you'd use

"file:/home/cathy/temp/*"
To specify files in the "temp" directory on the C drive in a Windows system, use

"file:/c:/temp/*"
Note: code base URLs always use slashes (no backlashes), regardless of the platform they apply to.

You can also use an absolute path name such as

"/home/gong/bin/MyWonderfulJava"

3.3.5 Default System and User Policy Files

In the Policy reference implementation, the policy can be specified within one or more policy configuration files. The configuration files specify what permissions are allowed for code from specified code sources.

A policy file can be composed via a simple text editor, or via a graphical PolicyTool utility that is described later.

There is by default a single system-wide policy file, and a single user policy file.

The system policy file is by default located at

{java.home}/lib/security/java.policy  (Solaris)
{java.home}\lib\security\java.policy  (Windows)
Here, java.home is a system property specifying the directory into which the Java 2 SDK was installed.

The user policy file is by default located at

{user.home}/.java.policy  (Solaris)
{user.home}\.java.policy  (Windows)
Here, user.home is a system property specifying the user's home directory.

When the Policy is initialized, the system policy is loaded in first, and then the user policy is added to it. If neither policy is present, a built-in policy is used. This built-in policy is the same as the original sandbox policy.

Policy file locations are specified in the security properties file, which is located at

{java.home}/lib/security/java.security  (Solaris)
{java.home}\lib/security\java.security  (Windows)
The policy file locations are specified as the values of properties whose names are of the form

policy.url.n
Here, n is a number. You specify each such property value in a line of the following form:

policy.url.n=URL
Here, URL is a URL specification. For example, the default system and user policy files are defined in the security properties file as

policy.url.1=file:${java.home}/lib/security/java.policy
policy.url.2=file:${user.home}/.java.policy
You can actually specify a number of URLs, including ones of the form "http://", and all the designated policy files will get loaded. You can also comment out or change the second one to disable reading the default user policy file.

The algorithm starts at policy.url.1, and keeps incrementing until it does not find a URL. Thus if you have policy.url.1 and policy.url.3, policy.url.3 will never be read.

It is also possible to specify an additional or a different policy file when invoking execution of an application. This can be done via the "-Djava.security.policy" command-line argument, which sets the value of the java.security.policy property. For example, if you use

java -Djava.security.manager -Djava.security.policy=pURL SomeApp
Here, pURL is a URL specifying the location of a policy file, then the specified policy file will be loaded in addition to all the policy files that are specified in the security properties file. (The "-Djava.security.manager" argument ensures that the default security manager is installed, and thus the application is subject to policy checks, as described in "Security Management for Applets and Applications". It is not required if the application SomeApp installs a security manager.)

If you use the following, with a double equals, then just the specified policy file will be used; all others will be ignored.

java -Djava.security.manager -Djava.security.policy==pURL SomeApp
If you want to pass a policy file to the appletviewer, again use a "-Djava.security.policy" argument as follows:

appletviewer -J-Djava.security.policy=pURL  myApplet
Please note: The "-Djava.security.policy" policy file value will be ignored (for both java and appletviewer commands) if the "policy.allowSystemProperty" property in the security properties file is set to false. The default is true.

3.3.6 Customizing Policy Evaluation

The current design of the Policy class is not as comprehensive as it could be. We have given the issues much thought and are progressing cautiously, partly to ensure that we define method calls that are appropriate for the most common cases. For the meantime, an alternative policy class can be given to replace the default policy class, as long as the former is a subclass of the abstract Policy class and implements the getPermissions method (and other methods as necessary).

The Policy reference implementation can be changed by resetting the value of the "policy.provider" security property (in the security properties file) to the fully qualified name of the desired Policy implementation class. The security properties file is located in the file named

{java.home}/lib/security/java.security (Solaris)
{java.home}\lib\security\java.security (Windows)
Here, {java.home} refers to the directory where the runtime environment is installed -- either the jre directory inside the Java 2 SDK, or the top-level directory of the Java 2 Runtime Environment.

The property policy.provider specifies the name of the policy class, and the default is the following:

policy.provider=sun.security.provider.PolicyFile
To customize, you can change the property value to specify another class, as in

policy.provider=com.mycom.MyPolicy
Note that the MyPolicy class must be a subclass of java.security.Policy. It is perhaps worth emphasizing that such an override of the policy class is a temporary solution and a more comprehensive policy API will probably make this unnecessary.

3.4 java.security.GeneralSecurityException

This is a new exception class that is a subclass of java.lang.Exception. The intention is that there should be two types of exceptions associated with security and the security packages.

  • java.lang.SecurityException and its subclasses should be runtime exceptions (unchecked, not declared) that are likely to cause the execution of a program to stop.
Such an exception is thrown only when some sort of security violation is detected. For example, such an exception is thrown when some code attempts to access a file, but it does not have permission for the access. Application developers may catch these exceptions, if they want.

  • java.security.GeneralSecurityException, which is a subclass of java.lang.Exception (must be declared or caught) that is thrown in all other cases from within the security packages.
Such an exception is security related but non-vital. For example, passing in an invalid key is probably not a security violation and should be caught and dealt with by a developer.

There are currently still two exceptions within the java.security package that are subclasses from RuntimeException. We at this moment cannot change these due to backward compatibility requirements. We will revisit this issue in the future.

CONTENTS | PREV | NEXT
Copyright © 1997-2002 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

4 Access Control Mechanisms and Algorithms

4.1 java.security.ProtectionDomain

The ProtectionDomain class encapsulates the characteristics of a domain. Such a domain encloses a set of classes whose instances are granted a set of permissions when being executed on behalf of a given set of Principals.

A ProtectionDomain is constructed with a CodeSource, a ClassLoader, an array of Principals, and a collection of Permissions. The CodeSource encapsulates the codebase (java.net.URL) for all classes in this domain, as well as a set of certificates (of type java.security.cert.Certificate) for public keys that correspond to the private keys that signed all code in this domain. The Principals represent the user on whose behalf the code is running.

The permissions passed in at ProtectionDomain construction time represent a static set of permissions bound to the domain regardless of the Policy in force. The ProtectionDomain subsequently consults the current policy during each security check to retrieve dynamic permissions granted to the domain.

Classes from different CodeSources, or that are being executed on behalf of different principals, belong to different domains.

Today all code shipped as part of the Java 2 SDK is considered system code and run inside the unique system domain. Each applet or application runs in its appropriate domain, determined by policy.

It is possible to ensure that objects in any non-system domain cannot automatically discover objects in another non-system domain. This partition can be achieved by careful class resolution and loading, for example, using different classloaders for different domains. However, SecureClassLoader (or its subclasses) can, at its choice, load classes from different domains, thus allowing these classes to co-exist within the same name space (as partitioned by a classloader).

4.2 java.security.AccessController

The AccessController class is used for three purposes, each of which is described in further detail in sections below:

  • to decide whether an access to a critical system resource is to be allowed or denied, based on the security policy currently in effect,
  • to mark code as being "privileged", thus affecting subsequent access determinations, and
  • to obtain a "snapshot" of the current calling context so access-control decisions from a different context can be made with respect to the saved context.
Any code that controls access to system resources should invoke AccessController methods if it wishes to use the specific security model and access control algorithm utilized by these methods. If, on the other hand, the application wishes to defer the security model to that of the SecurityManager installed at runtime, then it should instead invoke corresponding methods in the SecurityManager class.

For example, the typical way to invoke access control has been the following code (taken from an earlier version of JDK):

 ClassLoader loader = this.getClass().getClassLoader();
        if (loader != null) {
                SecurityManager security = System.getSecurityManager();
            if (security != null) {
                security.checkRead("path/file");
            }
        }
Under the new architecture, the check typically should be invoked whether or not there is a classloader associated with a calling class. It could be simply, for example:

FilePermission perm = new FilePermission("path/file", "read");
AccessController.checkPermission(perm);
The AccessController checkPermission method examines the current execution context and makes the right decision as to whether or not the requested access is allowed. If it is, this check returns quietly. Otherwise, an AccessControlException (a subclass of java.lang.SecurityException) is thrown.

Note that there are (legacy) cases, for example, in some browsers, where whether there is a SecurityManager installed signifies one or the other security state that may result in different actions being taken. For backward compatibility, the checkPermission method on SecurityManager can be used.

SecurityManager security = System.getSecurityManager();
if (security != null) {
    FilePermission perm = new FilePermission("path/file", "read");
    security.checkPermission(perm);
}
We currently do not change this aspect of the SecurityManager usage, but would encourage application developers to use new techniques introduced in the Java 2 SDK in their future programming when the built-in access control algorithm is appropriate.

The default behavior of the SecurityManager checkPermission method is actually to call the AccessController checkPermission method. A different SecurityManager implementation may implement its own security management approach, possibly including the addition of further constraints used in determining whether or not an access is permitted.

4.2.1 Algorithm for Checking Permissions

Suppose access control checking occurs in a thread of computation that has a chain of multiple callers (think of this as multiple method calls that cross the protection domain boundaries), as illustrated in the next figure.

Illustration of access control

When the checkPermission method of the AccessController is invoked by the most recent caller (e.g., a method in the File class), the basic algorithm for deciding whether to allow or deny the requested access is as follows.

If any caller in the call chain does not have the requested permission, AccessControlException is thrown, unless the following is true -- a caller whose domain is granted the said permission has been marked as "privileged" (see the next section) and all parties subsequently called by this caller (directly or indirectly) all have the said permission.
There are obviously two implementation strategies:

  • In an "eager evaluation" implementation, whenever a thread enters a new protection domain or exits from one, the set of effective permissions is updated dynamically.
The benefit is that checking whether a permission is allowed is simplified and can be faster in many cases. The disadvantage is that, because permission checking occurs much less frequently than cross-domain calls, a large percentage of permission updates are likely to be useless effort.

  • In a "lazy evaluation" implementation, whenever permission checking is requested, the thread state (as reflected by the current state, including the current thread's call stack or its equivalent) is examined and a decision is reached to either deny or grant the particular access requested.
One potential downside of this approach is performance penalty at permission checking time, although this penalty would have been incurred anyway in the "eager evaluation" approach (albeit at earlier times and spread out among each cross-domain call). Our implementation so far has yielded acceptable performance, so we feel that lazy evaluation is the most economical approach overall.

Therefore, the algorithm for checking permissions is currently implemented as "lazy evaluation". Suppose the current thread traversed m callers, in the order of caller 1 to caller 2 to caller m. Then caller m invoked the checkPermission method. The basic algorithm checkPermission uses to determine whether access is granted or denied is the following (see subsequent sections for refinements):

 i = m;
 while (i > 0) {
     if (caller i's domain does not have the permission)
         throw AccessControlException
     else if (caller i is marked as privileged)
         return;
     i = i - 1;
 };

4.2.2 Handling Privileges

A new, static method in the AccessController class allows code in a class instance to inform the AccessController that a body of its code is "privileged" in that it is solely responsible for requesting access to its available resources, no matter what code caused it to do so.

That is, a caller can be marked as being "privileged" when it calls the doPrivileged method. When making access control decisions, the checkPermission method stops checking if it reaches a caller that was marked as "privileged" via a doPrivileged call without a context argument (see a subsequent section for information about a context argument). If that caller's domain has the specified permission, no further checking is done and checkPermission returns quietly, indicating that the requested access is allowed. If that domain does not have the specified permission, an exception is thrown, as usual.

The normal use of the "privileged" feature is as follows:

If you don't need to return a value from within the "privileged" block, do the following:

  somemethod() {
       ...normal code here...
       AccessController.doPrivileged(new PrivilegedAction() {
           public Object run() {
               // privileged code goes here, for example:
               System.loadLibrary("awt");
               return null; // nothing to return
           }
       });
       ...normal code here...
  }
PrivilegedAction is an interface with a single method, named run, that returns an Object. The above example shows creation of an anonymous inner class implementing that interface; a concrete implementation of the run method is supplied. When the call to doPrivileged is made, an instance of the PrivilegedAction implementation is passed to it. The doPrivileged method calls the run method from the PrivilegedAction implementation after enabling privileges, and returns the run method's return value as the doPrivileged return value, which is ignored in this example.

(For more information about inner classes, see the Inner Classes Specification at http://java.sun.com/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc.html or pages of the More Features of the Java Language trail of the Java Tutorial, including http://java.sun.com/docs/books/tutorial/java/more/nested.html and http://java.sun.com/docs/books/tutorial/java/more/innerclasses.html.)

If you need to return a value, you can do something like the following:

  somemethod() {
       ...normal code here...
       String user = (String) AccessController.doPrivileged(
         new PrivilegedAction() {
           public Object run() {
               return System.getProperty("user.name");
           }
         }
       );
       ...normal code here...
  }
If the action performed in your run method could throw a "checked" exception (one listed in the throws clause of a method), then you need to use the PrivilegedExceptionAction interface instead of the PrivilegedAction interface:

  somemethod() throws FileNotFoundException {
       ...normal code here...
     try {
       FileInputStream fis = (FileInputStream)
        AccessController.doPrivileged(
         new PrivilegedExceptionAction() {
           public Object run() throws FileNotFoundException {
               return new FileInputStream("someFile");
           }
         }
       );
     } catch (PrivilegedActionException e) {
       // e.getException() should be an instance of
       // FileNotFoundException,
       // as only "checked" exceptions will be "wrapped" in a
       // <code>PrivilegedActionException</code>.
       throw (FileNotFoundException) e.getException();
     }
       ...normal code here...
 }
Some important points about being privileged: Firstly, this concept only exists within a single thread. As soon as the privileged code completes, the privilege is guaranteed to be erased or revoked.

Secondly, in this example, the body of code in the run method is privileged. However, if it calls less trustworthy code that is less privileged, that code will not gain any privileges as a result; a permission is only granted if the privileged code has the permission and so do all the subsequent callers in the call chain up to the checkPermission call.

For more information about marking code as "privileged," see http://java.sun.com/j2se/sdk/1.2/docs/guide/security/doprivileged.html.

4.3 Inheritence of Access Control Context

When a thread creates a new thread, a new stack is created. If the current security context was not retained when this new thread was created, then when AccessController.checkPermission was called inside the new thread, a security decision would be made based solely upon the new thread's context, not taking into consideration that of the parent thread.

This clean stack issue would not be a security problem per se, but it would make the writing of secure code, and especially system code, more prone to subtle errors. For example, a non-expert developer might assume, quite reasonably, that a child thread (e.g., one that does not involve untrusted code) inherits the same security context from the parent thread (e.g., one that involves untrusted code). This would cause unintended security holes when accessing controlled resources from inside the new thread (and then passing the resources along to less trusted code), if the parent context was not in fact saved.

Thus, when a new thread is created, we actually ensure (via thread creation and other code) that it automatically inherits the parent thread's security context at the time of creation of the child thread, in such a way that subsequent checkPermission calls in the child thread will take into consideration the inherited parent context.

In other words, the logical thread context is expanded to include both the parent context (in the form of an AccessControlContext, described in the next section) and the current context, and the algorithm for checking permissions is expanded to the following. (Recall there are m callers up to the call to checkPermission, and see the next section for information about the AccessControlContext checkPermission method.)

 i = m;
 while (i > 0) {
     if (caller i's domain does not have the permission)
         throw AccessControlException
     else if (caller i is marked as privileged)
         return;
     i = i - 1;
 };

 // Next, check the context inherited when
 // the thread was created. Whenever a new thread is created, the
 // AccessControlContext at that time is
 // stored and associated with the new thread, as the "inherited"
 // context.

 inheritedContext.checkPermission(permission);
Note that this inheritance is transitive so that, for example, a grandchild inherits both from the parent and the grandparent. Also note that the inherited context snapshot is taken when the new child is created, and not when the child is first run. There is no public API change for the inheritance feature.

4.4 java.security.AccessControlContext

Recall that the AccessController checkPermission method performs security checks within the context of the current execution thread (including the inherited context). A difficulty arises when such a security check can only be done in a different context. That is, sometimes a security check that should be made within a given context will actually need to be done from within a different context. For example, when one thread posts an event to another thread, the second thread serving the requesting event would not have the proper context to complete access control, if the service requests access to controller resources.

To address this issue, we provide the AccessController getContext method and AccessControlContext class. The getContext method takes a "snapshot" of the current calling context, and places it in an AccessControlContext object, which it returns. A sample call is the following:

AccessControlContext acc = AccessController.getContext();
This context captures relevant information so that an access control decision can be made by checking, from within a different context, against this context information. For example, one thread can post a request event to a second thread, while also supplying this context information. AccessControlContext itself has a checkPermission method that makes access decisions based on the context it encapsulates, rather than that of the current execution thread. Thus, the second thread can perform an appropriate security check if necessary by invoking the following:

acc.checkPermission(permission);
The above method call is equivalent to performing the same security check in the context of the first thread, even though it is done in the second thread.

There are also times where one or more permissions must be checked against an access control context, but it is unclear a priori which permissions are to be checked. In these cases you can use the doPrivileged method that takes a context:

  somemethod() {
        AccessController.doPrivileged(new PrivilegedAction() {
             public Object run() {
                // Code goes here. Any permission checks from
                // this point forward require both the current
                // context and the snapshot's context to have
                // the desired permission.
             }
        }, acc);
        ...normal code here...
Now the complete algorithm utilized by the AccessController checkPermission method can be given. Suppose the current thread traversed m callers, in the order of caller 1 to caller 2 to caller m. Then caller m invoked the checkPermission method. The algorithm checkPermission uses to determine whether access is granted or denied is the following

  i = m;
  while (i > 0) {
     if (caller i's domain does not have the permission)
        throw AccessControlException
     else if (caller i is marked as privileged) {
        if (a context was specified in the call to doPrivileged)
           context.checkPermission(permission);
        return;
     }
     i = i - 1;
  };

  // Next, check the context inherited when
  // the thread was created. Whenever a new thread is created, the
  // AccessControlContext at that time is
  // stored and associated with the new thread, as the "inherited"
  // context.

  inheritedContext.checkPermission(permission);

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

5 Secure Class Loading

Dynamic class loading is an important feature of the Java Virtual Machine because it provides the Java platform with the ability to install software components at run-time. It has a number of unique characteristics. First of all, lazy loading means that classes are loaded on demand and at the last moment possible. Second, dynamic class loading maintains the type safety of the Java Virtual Machine by adding link-time checks, which replace certain run-time checks and are performed only once. Moreover, programmers can define their own class loaders that, for example, specify the remote location from which certain classes are loaded, or assign appropriate security attributes to them. Finally, class loaders can be used to provide separate name spaces for various software components. For example, a browser can load applets from different web pages using separate class loaders, thus maintaining a degree of isolation between those applet classes. In fact, these applets can contain classes of the same name -- these classes are treated as distinct types by the Java Virtual Machine.

The class loading mechanism is not only central to the dynamic nature of the Java programming language. It also plays a critical role in providing security because the class loader is responsible for locating and fetching the class file, consulting the security policy, and defining the class object with the appropriate permissions.

5.1 Class Loader Class Hierarchies

When loading a class, because there can be multiple instances of class loader objects in one Java Virtual Machine, an important question is how do we determine which class loader to use. The Java 2 SDK has introduced multiple class loader classes are introduced that have distinct properties, so another important question is what type of class loader we should use.

The root of the class loader class hierarchy is an abstract class called java.lang.ClassLoader, originally defined in JDK 1.0 and since expanded. Class java.security.SecureClassLoader, introduced in Java 2 SDK, v 1.2, is a subclass and a concrete implementation of the abstract ClassLoader class. Class java.net.URLClassLoader is a subclass of SecureClassLoader.

A utility program called Appletviewer uses a private class sun.applet.AppletClassLoader to load applets. In JDK 1.0, AppletClassLoader is a subclass and concrete implementation of ClassLoader. In Java 2 SDK, it is a subclass of URLClassLoader.

When creating a custom class loader class, one can subclass from any of the above class loader classes, depending on the particular needs of the custom class loader. Because AppletClassLoader is a private class defined in the sun.* package, it is not supported and is subject to change, so one should not subclass from it.

5.2 The Primordial Class Loader

Because each class is loaded by its class loader, and each class loader itself is a class and must be loaded by another class loader, we seem to have the obvious chicken-and-egg problem, i.e., where does the first class loader come from? There is a "primordial'' class loader that bootstraps the class loading process. The primordial class loader is generally written in a native language, such as C, and does not manifest itself within the Java context. The primordial class loader often loads classes from the local file system in a platform-dependent manner.

Some classes, such as those defined in the java.* package, are essential for the correct functioning of the Java Virtual Machine and runtime system. They are often referred to as base classes. Due to historical reasons, all such classes have a class loader that is a null. This null class loader is perhaps the only sign of the existence of a primordial class loader. In fact, it is easier to simply view the null class loader as the primordial class loader.

Given all classes in one Java application environment, we can easily form a class loading tree to reflect the class loading relationship. Each class that is not a class loader is a leaf node. Each class's parent node is its class loader, with the null class loader being the root class. Such a structure is a tree because there cannot be cycles -- a class loader cannot have loaded its own ancestor class loader.

5.3 Class Loader Delegation

When one class loader is asked to load a class, this class loader either loads the class itself or it can ask another class loader to do so. In other words, the first class loader can delegate to the second class loader. The delegation relationship is virtual in the sense that it has nothing to do with which class loader loads which other class loader. Instead, the delegation relationship is formed when class loader objects are created, and in the form of a parent-child relationship. Nevertheless, the system class loader is the delegation root ancestor of all class loaders. Care must be taken to ensure that the delegation relationship does not contain cycles. Otherwise, the delegation process may enter into an infinite loop.

5.4 Class Resolution Algorithm

The default implementation of the Java 2 SDK ClassLoader method for loading a class searches for classes in the following order:

  • Check if the class has already been loaded.
  • If the current class loader has a specified delegation parent, delegate to the parent to try to load this class. If there is no parent, delegate to the primordial class loader.
  • Call a customizable method to find the class elsewhere.
Here, the first step looks into the class loader's local cache (or its functional equivalent, such as a global cache) to see if a loaded class matches the target class. The last step provides a way to customize the mechanism for looking for classes; thus a custom class loader can override this method to specify how a class should be looked up. For example, an applet class loader can override this method to go back to the applet host and try to locate the class file and load it over the network.

If at any step a class is located, it is returned. If the class is not found using the above steps, a ClassNotFound exception is thrown.

Observe that it is critical for type safety that the same class not be loaded more than once by the same class loader. If the class is not among those already loaded, the current class loader attempts to delegate the task to the parent class loader. This can occur recursively. This ensures that the appropriate class loader is used. For example, when locating a system class, the delegation process continues until the system class loader is reached.

We have seen the delegation algorithm earlier. But, given the name of any class, which class loader do we start with in trying to load the class? The rules for determining the class loader are the following:

  • When loading the first class of an application, a new instance of the URLClassLoader is used.
  • When loading the first class of an applet, a new instance of the AppletClassLoader is used.
  • When java.lang.Class.ForName is directly called, the primordial class loader is used.
  • If the request to load a class is triggered by a reference to it from an existing class, the class loader for the existing class is asked to load the class.
Note that rules about the use of URLClassLoader and AppletClassLoader instances have exceptions and can vary depending on the particular system environment. For example, a web browser may choose to reuse an existing AppletClassLoader to load applet classes from the same web page.

Due to the power of class loaders, we severely restrict who can create class loader instances. On the other hand, it is desirable to provide a convenient mechanism for applications or applets to specify URL locations and load classes from them. We provide static methods to allow any program to create instances of the URLClassLoader class, although not other types of class loaders.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

6 Security Management

6.1 Managing Applets and Applications

Currently, all Java 2 SDK system code invokes SecurityManager methods to check the policy currently in effect and perform access control checks. There is typically a security manager (SecurityManager implementation) installed whenever an applet is running; the appletviewer and most browsers, including those from Netscape and Microsoft, install a security manager.

A security manager is not automatically installed when an application is running. To apply the same security policy to an application found on the local file system as to downloaded applets, either the user running the application must invoke the Java Virtual Machine with the new "-Djava.security.manager" command-line argument (which sets the value of the java.security.manager property), as in

    java -Djava.security.manager  SomeApp
or the application itself must call the setSecurityManager method in the java.lang.System class to install a security manager.

It is possible to specify on the command line a particular security manager to be utilized, by following "-Djava.security.manager" with an equals and the name of the class to be used as the security manager, as in

    java -Djava.security.manager=COM.abc.MySecMgr  SomeApp
If no security manager is specified, the built-in default security manager is utilized (unless the application installs a different security manager). All of the following are equivalent and result in usage of the default security manager:

    java -Djava.security.manager  SomeApp
    java -Djava.security.manager=""  SomeApp
    java -Djava.security.manager=default  SomeApp
Java 2 SDK includes a property named java.class.path. Classes that are stored on the local file system but should not be treated as base classes (e.g., classes built into the SDK) should be on this path. Classes on this path are loaded with a secure class loader and are thus subjected to the security policy being enforced.

There is also a "-Djava.security.policy" command-line argument whose usage determines what policy files are utilized. This command-line argument is described in detail in the "Default System and User Policy Files" section. Basically, if you don't include "-Djava.security.policy" on the command line, then the policy files specified in the security properties file will be used.

You can use a "-Djava.security.policy" command-line argument to specify an additional or a different policy file when invoking execution of an application. For example, if you type the following, where pURL is a URL specifying the location of a policy file, then the specified policy file will be loaded in addition to all the policy files specified in the security properties file:

    java -Djava.security.manager -Djava.security.policy=pURL SomeApp
If you instead type the following command, using a double equals, then just the specified policy file will be used; all others will be ignored:

java -Djava.security.manager -Djava.security.policy==pURL SomeApp

6.2 SecurityManager versus AccessController

The new access control mechanism is fully backward compatible. For example, all check methods in SecurityManager are still supported, although most of their implementations are changed to call the new SecurityManager checkPermission method, whose default implementation calls the AccessController checkPermission method. Note that certain internal security checks may stay in the SecurityManager class, unless it can be parameterized.

We have not at this time revised any system code to call AccessController instead of calling SecurityManager (and checking for the existence of a classloader), because of the potential of existing third-party applications that subclass the SecurityManager and customize the check methods. In fact, we added a new method SecurityManager.checkPermission that by default simply invokes AccessController.checkPermission.

To understand the relationship between SecurityManager and AccessController, it is sufficient to note that SecurityManager represents the concept of a central point of access control, while AccessController implements a particular access control algorithm, with special features such as the doPrivileged method. By keeping SecurityManager up to date, we maintain backward compatibility (e.g., for those applications that have written their own security manager classes based on earlier versions of the JDK) and flexibility (e.g., for someone wanting to customize the security model to implement mandatory access control or multilevel security). By providing AccessController, we build in the algorithm that we believe is the most restrictive and that relieves the typical programmer from the burden of having to write extensive security code in most scenarios.

We encourage the use of AccessController in application code, while customization of a security manager (via subclassing) should be the last resort and should be done with extreme care. Moreover, a customized security manager, such as one that always checks the time of the day before invoking standard security checks, could and should utilize the algorithm provided by AccessController whenever appropriate.

6.3 Auxiliary Tools

This section briefly describes the usage of three tools that assist in the deployment of the new security features. These tools may be packaged together in the future.

More extensive documentation for the tools can be found in the

/docs/technotes/tools/solaris
and

/docs/technotes/tools/windows
subdirectories of the SDK release directory (where the directory separators are actually "\" on Windows systems).

For example, if the Java 2 SDK is installed in a directory named "/j2sdk1.2" on a Solaris system, then the keytool documentation for Solaris and Windows users, respectively, can be found in

/j2sdk1.2/docs/tooldocs/solaris/keytool.html
/j2sdk1.2/docs/tooldocs/windows/keytool.html
If the Java 2 SDK is installed in a directory named "C:\j2sdk1.2" on a Windows system, then the keytool documentation for Solaris and Windows users, respectively, can be found in

C:\j2sdk1.2\docs\tooldocs\solaris\keytool.html
C:\j2sdk1.2\docs\tooldocs\windows\keytool.html

6.3.1 The Key and Certificate Management Tool

keytool is a key and certificate management utility. It enables users to administer their own public/private key pairs and associated certificates for use in self-authentication (where the user authenticates himself/herself to other users/services) or data integrity and authentication services, using digital signatures. The authentication information includes both a sequence (chain) of X.509 certificates, and an associated private key, which can be referenced by a so-called "alias". This tool also manages certificates (that are "trusted" by the user), which are stored in the same database as the authentication information, and can be referenced by an "alias".

keytool stores the keys and certificates in a so-called keystore. The default keystore implementation implements the keystore as a file. It protects private keys with a password.

The chains of X.509 certificates are provided by organizations called Certification Authorities, or CAs. Identities (including CAs) use their private keys to authenticate their association with objects (such as with channels which are secured using SSL), with archives of code they signed, or (for CAs) with X.509 certificates they have issued. As a bootstrapping tool, certificates generated using the -genkey command may be used until a Certification Authority returns a certificate chain.

The private keys in this database are always stored in encrypted form, to make it difficult to disclose these private keys inappropriately. A password is required to access or modify the database. These private keys are encrypted using the "password", which should be several words long. If the password is lost, those authentication keys cannot be recovered.

In fact, each private key in the keystore can be protected using its own individual password, which may or may not be the same as the password that protects the keystore's overall integrity.

This tool is (currently) intended to be used from the command line, where one simply types "keytool" as a shell prompt. keytool is a script that executes the appropriate Java classes and is built together with the SDK.

The command line options for each command may be provided in any order. Typing an incorrect option or typing "keytool -help" will cause the tool's usage to be summarized on the output device (such as a shell window), as given below.

% keytool -help
KeyTool usage:

-certreq     [-v] [-alias <alias>] [-sigalg <sigalg>]
             [-file <certreq_file>] [-keypass <keypass>]
             [-keystore <keystore>] [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-delete      [-v] -alias <alias>
             [-keystore <keystore>] [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-export      [-v] [rfc] [-alias <alias>] [-file <cert_file>]
             [-keystore <keystore>] [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-genkey      [-v] [-alias <alias>] [-keyalg <keyalg>]
             [-keysize <keysize>] [-sigalg <sigalg>]
             [-dname <distinguished_name>] [-validity <valDays>]
             [-keypass <keypass>] [-keystore <keystore>]
             [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-help

-identitydb  [-v] [-file <idb_file>] [-keystore <keystore>]
             [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-import      [-v] [-noprompt] [-alias <alias>]
             [-file <cert_file>] [-keypass <keypass>]
             [-keystore <keystore>] [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-keyclone    [-v] [-alias <alias>] -dest <dest_alias>
             [-keypass <keypass>] [-new <new_keypass>]
             [-keystore <keystore>] [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-keypasswd   [-v] [-alias <alias>]
             [-keypass <old_keypass>] [-new <new_keypass>]
             [-keystore <keystore>] [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-list        [-v | -rfc] [-alias <alias>]
             [-keystore <keystore>] [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-printcert   [-v] [-file <cert_file>]

-selfcert    [-v] [-alias <alias>] [-sigalg <sigalg>]
             [-dname <distinguished_name>] [-validity <valDays>]
             [-keypass <keypass>] [-keystore <keystore>]
             [-storepass <storepass>]
             [-storetype <i>storetype</i>]

-storepasswd  [-v] [-new <new_storepass>]
             [-keystore <keystore>] [-storepass <storepass>]
              [-storetype <i>storetype</i>]

6.3.2 PolicyTool

The PolicyTool is a graphical user interface (illustrated below with a screen shot) that assists a user (such as a system administrator) in specifying, generating, editing, exporting, or importing a security policy. The tool is invoked from the command line as policytool. This again is a script built with the SDK that invokes the appropriate (non-public) implementation classes.

See the PolicyTool documentation for usage information and examples with up-to-date screen shots. The documentation can be found in the policytool.html file in the

/docs/technotes/tools/solaris/
or

/docs/technotes/tools/windows/
directory in the directory in which the SDK was installed (where the file separators are actually backslashes on Windows systems).

screenshot od PolicyTool window

6.3.3 The JAR Signing and Verification Tool

The jarsigner tool can be used to digitally sign Java archives (JAR files), and to verify such signatures. This tool, like the PolicyTool, depends on the keystore that is managed by the keytool. Its usage is quickly summarized below.

% jarsigner
Usage: jarsigner [options] jar-file alias
       jarsigner -verify [options] jar-file
  [-keystore <url>]         keystore file location
  [-storepass <password>]   password for keystore integrity
  [-keypass <password>]     password for private key (if different)
  [-sigfile <file>]         name of .SF/.DSA file
  [-signedjar <file>]       name of signed JAR file
  [-verify]                 verify a signed JAR file
  [-verbose]                verbose output when signing/verifying
  [-certs]          display certificates when verbose and verifying
  [-internalsf]             include .SF file inside signature block
  [-sectionsonly]           don't compute hash of entire manifest
Again, this tool is a script built with the SDK. Note that it is expected that this tool and the existing jar tool script may be merged in the near future to form a single command-line primitive to create JARs, either signed or unsigned.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

7 GuardedObject and SignedObject

7.1 java.security.GuardedObject and java.security.Guard

Recall that the class AccessControlContext is useful when an access control decision has to be made in a different context. There is another such scenario, where the supplier of a resource is not in the same thread as the comsumer of that resource, and the consumer thread cannot provide the supplier thread the access control context information (because the context is security-sensitive, or the context is too large to pass, or for other reasons). For this case, we provide a class called GuardedObject to protect access to the resource, illustrated in the figure below.

Illustration of previous context

The basic idea is that the supplier of the resource can create an object representing the resource, create a GuardedObject that embeds the resource object inside, and then provide the GuardedObject to the consumer. In creating the GuardedObject, the supplier also specifies a Guard object such that anyone (including the consumer) can only obtain the resource object if certain (security) checks inside the Guard are satisfied.

Guard is an interface, so any object can choose to become a Guard. The only method in this interface is called checkGuard. It takes an Object argument and it performs certain (security) checks. The Permission class in java.security implements the Guard interface.

For example, suppose a system thread is asked to open a file /a/b/c.txt for read access, but the system thread does not know who the requestor is or under what circumstances the request is made. Therefore, the correct access control decision cannot be made at the server side. The system thread can use GuardedObject to delay the access control checking, as follows.

FileInputStream f = new FileInputStream("/a/b/c.txt");
FilePermission p = new FilePermission("/a/b/c.txt", "read");
GuardedObject g = new GuardedObject(f, p);
Now the system thread can pass g to the consumer thread. For that thread to obtain the file input stream, it has to call

FileInputStream fis = (FileInputStream) g.getObject();
This method in turn invokes the checkGuard method on the Guard object p, and because p is a Permission, its checkGuard method is in fact:

SecurityManager sm = System.getSecurityManager();
if (sm != null) sm.checkPermission(this);
This ensures that a proper access control check takes place within the consumer context. In fact, one can replace often-used hash tables and access control lists in many cases and simply store a hash table of GuardedObjects.

This basic pattern of GuardedObject and Guard is very general, and we expect that by extending the basic Guard and GuardedObject classes, developers can easily obtain quite powerful access control tools. For example, per-method invocation can be achieved with an appropriate Guard for each method, and a Guard can check the time of the day, the signer or other identification of the caller, or any other relevant information.

Note that certain typing information is lost because GuardedObject returns an Object. GuardedObject is intended to be used between cooperating parties so that the receiving party should know what type of object to expect (and to cast for). In fact, we envision that most usage of GuardedObject involves subclassing it (say to form a GuardedFileInputStream class), thus encapsulating typing information, and casting can happen suitably in the subclass.

7.2 java.security.SignedObject

This class is an essential building block for other security primitives. SignedObject contains another Serializable object, the (to-be-)signed object and its signature. If the signature is not null, it contains a valid digital signature of the signed object. This is illustrated in the figure below.

The previous context describes this graphic

The underlying signing algorithm is set through a Signature object as a parameter to the sign method call, and the algorithm can be, among others, the NIST standard DSA, using DSA and SHA-1. The algorithm is specified using the same convention for signatures, such as "SHA/DSA".

The signed object is a "deep copy" (in serialized form) of an original object. Once the copy is made, further manipulation of the original object has no side effect on the copy. A signed object is immutable.

A typical example of creating a signed object is the following:

Signature signingEngine =
    Signature.getInstance(algorithm,provider);
SignedObject so =
    new SignedObject(myobject, signingKey, signingEngine);
A typical example of verification is the following (having received SignedObject so), where the first line is not needed if the name of the algorithm is known:

String algorithm = so.getAlgorithm();
Signature verificationEngine =
    Signature.getInstance(algorithm, provider);
so.verify(verificationEngine);
Potential applications of SignedObject include:

  • It can be used internally to any Java application environment as an unforgeable authorization token -- one that can be passed around without the fear that the token can be maliciously modified without being detected.
  • It can be used to sign and serialize data/object for storage outside the Java runtime (e.g., storing critical access control data on disk).
  • Nested SignedObjects can be used to construct a logical sequence of signatures, resembling a chain of authorization and delegation.
It is intended that this class can be subclassed in the future to allow multiple signatures on the same signed object. In that case, existing method calls in this base class will be fully compatible in semantics. In particular, any get method will return the unique value if there is only one signature, and will return an arbitrary one from the set of signatures if there is more than one signature.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

8 Discussion and Future Directions

8.1 Resource Consumption Management

Resource consumption management is relatively easy to implement in some cases (e.g., to limit the number of windows any application can pop up at any one time), while it can be quite hard to implement efficiently in other cases (e.g., to limit memory or file system usage). We plan to coherently address such issues in the future.

8.2 Arbitrary Grouping of Permissions

Sometimes it is convenient to group a number of permissions together and use a short-hand name to refer to them. For example, if we would like to have a permission called "SuperPermission" to include (and imply) both FilePermission("-", "read,write") and SocketPermission("*", "connect,accept"), technically we can use the class Permissions or a similar class to implement this super permission by using the add methods to add the required permissions. And such grouping can be arbitrarily complicated.

The more difficult issues are the following. First, to understand what actual permissions one is granting when giving out such a super permission, either a fixed and named permission class is created to denote a statically specified group of permissions, or the member permissions need to be spelled out in the policy file. Second, processing the policy (file) can become more complicated because the grouped permissions may need to be expanded. Moreover, nesting of grouped permission increases complexity even more.

8.3 Object-Level Protection

Given the object-oriented nature of the Java programming language, it is conceivable that developers will benefit from a set of appropriate object-level protection mechanisms that (1) goes beyond the natural protection provided by the Java programming language and that (2) supplements the thread-based access control mechanism.

One such mechanism is SignedObject. Parallel to this primitive, we will provide SealedObject that uses encryption to hide the content of an object. (Due to current U.S. export control regulations on the use of encryption, the SealedObject class will likely be provided separate from the SDK.)

GuardedObject is a general way to enforce access control at a per class/object per method level. This method, however, should be used only selectively, partly because this type of control can be difficult to administer at a high level.

8.4 Subdividing Protection Domains

A potentially useful concept not currently implemented is that of "subdomains." A subdomain is one that is enclosed in another. A subdomain would not have more permissions or privileges than the domain of which it is a subpart. A domain could be created, for example, to selectively further limit what a program can do.

Often a domain is thought of as supporting inheritance: a subdomain would automatically inherit the parent domain's security attributes, except in certain cases where the parent further restricts the subdomain explicitly. Relaxing a subdomain by right amplification is a possibility with the notion of trusted code.

For convenience, we can think of the system domain as a single, big collection of all system code. For better protection, though, system code should be run in multiple system domains, where each domain protects a particular type of resource and is given a special set of rights. For example, if file system code and network system code run in separate domains, where the former has no rights to the networking resources and the latter has no rights to the file system resources, the risks and consequence of an error or security flaw in one system domain is more likely to be confined within its boundary.

8.5 Running Applets with Signed Content

The JAR and Manifest specifications on code signing allow a very flexible format. Classes within the same archive can be signed with different keys, and a class can be unsigned, signed with one key, or signed with multiple keys. Other resources within the archive, such as audio clips and graphic images, can also be signed or unsigned, just like classes can.

This flexibility brings about the issue of interpretation. The following questions need to be answered, especially when keys are treated differently:

1. Should images and audios be required to be signed with the
   same key if any class in the archive is signed?
2. If images and audios are signed with different keys, can
   they be placed in the same appletviewer (or browser page),
   or should they be sent to different viewers for processing?
These questions are not easy to answer, and require consistency across platforms and products to be the most effective. Our intermediate approach is to provide a simple answer -- all images and audio clips are forwarded to be processed within the same applet classloader, whether they are signed or not. This temporary solution will be improved once a consensus is reached.

Moreover, if a digital signature cannot be verified because the bytecode content of a class file does not match the signed hash value in the JAR, a security exception is thrown, as the original intention of the JAR author is clearly altered. Previously, there was a suggestion to run such code as untrusted. This idea is undesirable because the applet classloader allows the loading of code signed by multiple parties. This means that accepting a partially modified JAR file would allow an untrusted piece of code to run together with and access other code through the same classloader.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

9 Summary

This document gives an overview of the motivation and the new security architecture of the major security features that are implemented for the Java 2 Platform.

Please send comments and feedback to java-security@sun.com (which is archived on the web at http://java.sun.com/security/hypermail/java-security-archive/index.html). Messages of a more confidential nature should be sent to the author directly (li.gong@sun.com).

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

10 Acknowledgments

The design and implementation of new security features in Java 2 SDK is the work of primarily members of the JavaSoft security group. Other (past and present) members of the JavaSoft community provided invaluable insight, detailed reviews, and much needed technical assistance. Significant contributors, in alphabetical order, include but are not limited to: Gigi Ankeny, Josh Bloch, Satya Dodda, Charlie Lai, Sheng Liang, Jan Luehe, Marianne Mueller, Jeff Nisewanger, Hemma Prafullchandra, Roger Riggs, Nakul Saraiya, Bill Shannon, Roland Schemers, and Vijay Srinivasan.

This work is not possible without strong support from JavaSoft management (our thanks go to Dick Neiss, Jon Kannegaard, and Alan Baratz), and the testing and documentation groups (especially Mary Dageforde). We are grateful for technical guidance from James Gosling, Graham Hamilton, and Jim Mitchell.

We received numerous suggestions from our corporate partners and licensees, whom we could not fully list here.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

11 References

M. Gasser. Building a Secure Computer System. Van Nostrand Reinhold Co., New York, 1988.

L. Gong, "Java Security: Present and Near Future". IEEE Micro, 17(3):14--19, May/June 1997.

L. Gong, T.M.A. Lomas, R.M. Needham, and J.H. Saltzer, "Protecting Poorly Chosen Secrets from Guessing Attacks". IEEE Journal on Selected Areas in Communications, 11(5):648--656, June, 1993.

J. Gosling, Bill Joy, and Guy Steele. The Java Language Specification. Addison-Wesley, Menlo Park, California, August 1996.

A.K. Jones. Protection in Programmed Systems. Ph.D. dissertation, Carnegie-Mellon University, Pittsburgh, PA 15213, June 1973.

B.W. Lampson. Protection. In Proceedings of the 5th Princeton Symposium on Information Sciences and Systems, Princeton University, March 1971. Reprinted in ACM Operating Systems Review, 8(1):18--24, January, 1974.

T. Lindholm and F. Yellin. The Java Virtual Machine Specification. Addison-Wesley, Menlo Park, California, 1997.

P.G. Neumann. Computer-Related Risks. Addison-Wesley, Menlo Park, California, 1995.

U.S. General Accounting Office. Information Security: Computer Attacks at Department of Defense Pose Increasing Risks. Technical Report GAO/AIMD-96-84, Washington, D.C. 20548, May 1996.

J.H. Saltzer. Protection and the Control of Information Sharing in Multics. Communications of the ACM, 17(7):388--402, July 1974.

J.H. Saltzer and M.D. Schroeder. The Protection of Information in Computer Systems}. Proceedings of the IEEE, 63(9):1278--1308, September 1975.

M.D. Schroeder. Cooperation of Mutually Suspicious Subsystems in a Computer Utility. Ph.D. dissertation, Massachusetts Institute of Technology, Cambridge, MA 02139, September 1972.

W.A. Wulf, R. Levin, and S.P. Harbison. HYDRA/C.mmp -- An Experimental Computer System. McGraw-Hill, 1981.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

12 Revision History

Various drafts on Java 2 Security Architecture, under different disguises, existed since August of 1996.

Java 2 Platform Security Architecture Specification v0.1 was drafted on March 12, 1997.

Revision 0.2 on March 27, 1997

Revision 0.3 on March 31, 1997

Revision 0.4 on June 3, 1997. Reflected changes in design and implementation based on comments and feedbacks of revision 0.3. Introduced SignedObject.

Revision 0.5 on July 10, 1997. Major reorganization. It now includes a detailed syntax and semantics for policy and permissions. The class java.lang.SecurityManager is changed from abstract to concrete, with a default implementation.

Revision 0.6 on September 3, 1997. Reorganized sections under clearer headings. Syntactical changes to policy file format, including adding an optional signer field to each permission entry. Introduced GuardedObject class and Guard interface. The Permission class is now Serializable and implements the Guard interface. Added a new AccessControlContext class that helps cross-thread access control decision making. Gave descriptions of keytool, policytool, and jarsigner. Revised Acknowledgements.

Revision 0.7 on October 1, 1997. Added description of a feature that automatically makes a new thread, at its creation time, inherit the parent thread's security context so that access control checking in the new child thread considers both the first current context and also the inherited context.

Revision 0.8 on March 9, 1998. The previously package private class java.security.ProtectionDomain is now made public, and suitable get, set, and define methods to use this class are added in java.lang.Class and java.security.SecureClassLoader. The class java.security.SignedObject is now immutable. Introduced a new class java.security.UnresolvedPermission. Added new method SecurityManager.checkPermission that, by default, invokes AccessController.checkPermission. Syntax change for FilePermission in the case of "*", "-", and introduced "<<ALL FILES>>". Other minor additions and changes, including two new options for jarsigner. Revised Acknowledgements.

Revision 0.9 on June 10, 1998. Some permission names have been modified to make permission naming clearer and more consistent. Added sections for Permission classes not previously documented herein. The evaluate method in Policy has been renamed getPermissions. Class.setProtectionDomain no longer exists. Corrected "file:" URL examples. The "-usepolicy" command-line argument for the "java" command has been replaced by "-Djava.security.manager" and "-Djava.security.policy". Updated command lists for the keytool and jarsigner tools. The AccessController beginPrivileged and endPrivileged methods have been replaced by the doPrivileged method.

Revision 1.0 on October 2, 1998. Updated description of the class loading mechanism with a new chapter. Rearranged some chapters and sections.

Revision 1.1 on December 20, 2000. Updated the document to reflect the new Policy and ProtectionDomain updates to support dynamic policies. Also added updates for the integration of the Java Authentication and Authorization Service (JAAS) into the core SDK. New policy syntax was described and examples were added.

Revision 1.2 (the current version) on March 22, 2002. Added notes on KeyStore Alias Replacement including an example of a grant statement with KeyStore alias replacement. Added new section 3.3 explaining generalized expansion in policy files including examples.

CONTENTS | PREV | NEXT
Copyright © 1997-1999 Sun Microsystems, Inc. All Rights Reserved.


-

CONTENTS | PREV | NEXT Java Security Architecture

Table of Contents

1 Introduction
1.1 The Original Sandbox Model
1.2 Evolving the Sandbox Model

2 New Protection Mechanisms -- Overview of Basic Concepts

3 Permissions and Security Policy
3.1 The Permission Classes
3.1.1 java.security.Permission
3.1.2 java.security.PermissionCollection
3.1.3 java.security.Permissions
3.1.4 java.security.UnresolvedPermission
3.1.5 java.io.FilePermission
3.1.6 java.net.SocketPermission
3.1.7 java.security.BasicPermission
3.1.8 java.util.PropertyPermission
3.1.9 java.lang.RuntimePermission
3.1.10 java.awt.AWTPermission
3.1.11 java.net.NetPermission
3.1.12 java.lang.reflect.ReflectPermission
3.1.13 java.io.SerializablePermission
3.1.14 java.security.SecurityPermission
3.1.15 java.security.AllPermission
3.1.16 javax.security.auth.AuthPermission
3.1.17 Discussion of Permission Implications
3.1.18 How To Create New Types of Permissions
3.2 java.security.CodeSource
3.3 java.security.Policy
3.3.1 Policy File Format
3.3.2 Property Expansion in Policy Files
3.3.3 General Expansion in Policy Files
3.3.4 Assigning Permissions
3.3.5 Default System and User Policy Files
3.3.6 Customizing Policy Evaluation
3.4 java.security.GeneralSecurityException

4 Access Control Mechanisms and Algorithms
4.1 java.security.ProtectionDomain
4.2 java.security.AccessController
4.2.1 Algorithm for Checking Permissions
4.2.2 Handling Privileges
4.3 Inheritence of Access Control Context
4.4 java.security.AccessControlContext

5 Secure Class Loading
5.1 Class Loader Class Hierarchies
5.2 The Primordial Class Loader
5.3 Class Loader Delegation
5.4 Class Resolution Algorithm

6 Security Management
6.1 Managing Applets and Applications
6.2 SecurityManager versus AccessController
6.3 Auxiliary Tools
6.3.1 The Key and Certificate Management Tool
6.3.2 PolicyTool
6.3.3 The JAR Signing and Verification Tool

7 GuardedObject and SignedObject
7.1 java.security.GuardedObject and java.security.Guard
7.2 java.security.SignedObject

8 Discussion and Future Directions
8.1 Resource Consumption Management
8.2 Arbitrary Grouping of Permissions
8.3 Object-Level Protection
8.4 Subdividing Protection Domains
8.5 Running Applets with Signed Content

9 Summary

10 Acknowledgments

11 References

12 Revision History

CONTENTS | PREV | NEXT
Copyright © 1997-2002 Sun Microsystems, Inc. All Rights Reserved.


The top interface is Line. Subinterfaces of Line are Port, Mixer, DataLine and GroupLine. Subinterfaces of DataLine are SourceDataLine, TargetDataLine and Clip.


An unexpected exception has been detected in native code outside the VM.
Unexpected Signal : EXCEPTION_ACCESS_VIOLATION occurred at PC=0xe6a1067
Function name=Java_NativeSEGV_foo
Library=D:\testcases\NativeSEGV\NativeSEGV.dll
Source file = NativeSEGV.c : 7

Current Java thread:
    at NativeSEGV.foo(Native Method)
    at NativeSEGV.main(NativeSEGV.java:26)

Dynamic libraries:
0x00400000 - 0x00405000 	d:\jdk1.3.1\bin\java.exe
0x77F60000 - 0x77FBE000 	C:\WINNT\System32\ntdll.dll
0x77DC0000 - 0x77DFF000 	C:\WINNT\system32\ADVAPI32.dll
0x77F00000 - 0x77F5E000 	C:\WINNT\system32\KERNEL32.dll
0x77E70000 - 0x77EC4000 	C:\WINNT\system32\USER32.dll
0x77ED0000 - 0x77EFC000 	C:\WINNT\system32\GDI32.dll
0x77E10000 - 0x77E67000 	C:\WINNT\system32\RPCRT4.dll
0x78000000 - 0x78040000 	C:\WINNT\system32\MSVCRT.dll
0x10000000 - 0x10018000 	C:\WINNT\System32\NVDESK32.DLL
0x08000000 - 0x08273000 	d:\jdk1.3.1\jre\bin\server\jvm.dll
0x77FD0000 - 0x77FFA000 	C:\WINNT\System32\WINMM.dll
0x4FA00000 - 0x4FA77000 	C:\WINNT\System32\cwcmmsys.dll
0x50220000 - 0x50227000 	d:\jdk1.3.1\jre\bin\hpi.dll
0x503B0000 - 0x503BD000 	d:\jdk1.3.1\jre\bin\verify.dll
0x50250000 - 0x50266000 	d:\jdk1.3.1\jre\bin\java.dll
0x503C0000 - 0x503CD000 	d:\jdk1.3.1\jre\bin\zip.dll
0x0E6A0000 - 0x0E6C2000 	D:\testcases\NativeSEGV\NativeSEGV.dll
0x77920000 - 0x77942000 	C:\WINNT\System32\imagehlp.dll
0x72A00000 - 0x72A2D000 	C:\WINNT\System32\DBGHELP.dll
0x731B0000 - 0x731BA000 	C:\WINNT\System32\PSAPI.DLL

Local Time = Fri Dec 15 17:14:02 2000
Elapsed Time = 1
#
# The exception above was detected in native code outside the VM
#
# Java VM: Java HotSpot(TM) Server VM (internal-release mixed mode)
#
# An error report file has been saved as hs_err_pid102.log.
# Please refer to the file for further information.
#