representationClass = java.lang.String
    mimeType           = "application/x-java-serialized-object"

    representationClass = java.awt.Image
    mimeType            = "image/x-java-image"

    representationClass = InputStream
    mimeType            = "text/plain; charset=unicode"

The object reference returned from Transferable.getTransferData for a DataFlavor with this MIME Content-Type is required to be an instance of the representation Class of the DataFlavor. 

 public DataFlavor() 
{
        super();
}

Constructs a new DataFlavor. This constructor is provided only for the purpose of supporting the Externalizable interface. It is not intended for public (client) use.

since: 1.2 -

 public DataFlavor(String mimeType) throws ClassNotFoundException 
{
        super();
        if (mimeType == null) {
            throw new NullPointerException("mimeType");
        }
        try {
            initialize(mimeType, null, this.getClass().getClassLoader());
        } catch (MimeTypeParseException mtpe) {
            throw new IllegalArgumentException("failed to parse:" + mimeType);
        }
}

Constructs a DataFlavor from a mimeType string. The string can specify a "class=" parameter to create a DataFlavor with the desired representation class. If the string does not contain "class=" parameter, java.io.InputStream is used as default.

Parameters:

mimeType - the string used to identify the MIME type for this flavor; if the class specified by "class=" parameter is not successfully loaded, then an ClassNotFoundException is thrown

Throws:

ClassNotFoundException - if the class is not loaded

IllegalArgumentException - if mimeType is invalid

NullPointerException - if mimeType is null

exception: ClassNotFoundException - if the class is not loaded

exception: IllegalArgumentException - if mimeType is invalid

exception: NullPointerException - if mimeType is null

 public DataFlavor(Class<?> representationClass,
    String humanPresentableName) 
{
        this("application", "x-java-serialized-object", null, representationClass, humanPresentableName);
        if (representationClass == null) {
            throw new NullPointerException("representationClass");
        }
}

Constructs a DataFlavor that represents a Java class.

The returned DataFlavor will have the following characteristics:

   representationClass = representationClass
   mimeType            = application/x-java-serialized-object

Parameters:

representationClass - the class used to transfer data in this flavor

humanPresentableName - the human-readable string used to identify this flavor; if this parameter is null then the value of the the MIME Content Type is used

Throws:

NullPointerException - if representationClass is null

exception: NullPointerException - if representationClass is null

 public DataFlavor(String mimeType,
    String humanPresentableName) 
{
        super();
        if (mimeType == null) {
            throw new NullPointerException("mimeType");
        }
        try {
            initialize(mimeType, humanPresentableName, this.getClass().getClassLoader());
        } catch (MimeTypeParseException mtpe) {
            throw new IllegalArgumentException("failed to parse:" + mimeType);
        } catch (ClassNotFoundException cnfe) {
            throw new IllegalArgumentException("can't find specified class: " + cnfe.getMessage());
        }
}

Constructs a DataFlavor that represents a MimeType.

The returned DataFlavor will have the following characteristics:

If the mimeType is "application/x-java-serialized-object; class=<representation class>", the result is the same as calling new DataFlavor(Class:forName(<representation class>).

Otherwise:

    representationClass = InputStream
    mimeType            = mimeType

Parameters:

mimeType - the string used to identify the MIME type for this flavor; if the the mimeType does not specify a "class=" parameter, or if the class is not successfully loaded, then an IllegalArgumentException is thrown

humanPresentableName - the human-readable string used to identify this flavor; if this parameter is null then the value of the the MIME Content Type is used

Throws:

IllegalArgumentException - if mimeType is invalid or if the class is not successfully loaded

NullPointerException - if mimeType is null

exception: IllegalArgumentException - if mimeType is invalid or if the class is not successfully loaded

exception: NullPointerException - if mimeType is null

 public DataFlavor(String mimeType,
    String humanPresentableName,
    ClassLoader classLoader) throws ClassNotFoundException 
{
        super();
        if (mimeType == null) {
            throw new NullPointerException("mimeType");
        }
        try {
            initialize(mimeType, humanPresentableName, classLoader);
        } catch (MimeTypeParseException mtpe) {
            throw new IllegalArgumentException("failed to parse:" + mimeType);
        }
}

Constructs a DataFlavor that represents a MimeType.

The returned DataFlavor will have the following characteristics:

If the mimeType is "application/x-java-serialized-object; class=<representation class>", the result is the same as calling new DataFlavor(Class:forName(<representation class>).

Otherwise:

    representationClass = InputStream
    mimeType            = mimeType

Parameters:

mimeType - the string used to identify the MIME type for this flavor

humanPresentableName - the human-readable string used to identify this flavor

classLoader - the class loader to use

Throws:

ClassNotFoundException - if the class is not loaded

IllegalArgumentException - if mimeType is invalid

NullPointerException - if mimeType is null

exception: ClassNotFoundException - if the class is not loaded

exception: IllegalArgumentException - if mimeType is invalid

exception: NullPointerException - if mimeType is null

 public Object clone() throws CloneNotSupportedException 
{
        Object newObj = super.clone();
        if (mimeType != null) {
            ((DataFlavor)newObj).mimeType = (MimeType)mimeType.clone();
        }
        return newObj;
}

Returns a clone of this DataFlavor.

 public boolean equals(Object o) 
{
        return ((o instanceof DataFlavor) && equals((DataFlavor)o));
}

{@inheritDoc}

The equals comparison for the {@code DataFlavor} class is implemented as follows: Two DataFlavors are considered equal if and only if their MIME primary type and subtype and representation class are equal. Additionally, if the primary type is "text", the subtype denotes a text flavor which supports the charset parameter, and the representation class is not java.io.Reader, java.lang.String, java.nio.CharBuffer, or [C, the charset parameter must also be equal. If a charset is not explicitly specified for one or both DataFlavors, the platform default encoding is assumed. See selectBestTextFlavor for a list of text flavors which support the charset parameter.

 public boolean equals(DataFlavor that) 
{
        if (that == null) {
            return false;
        }
        if (this == that) {
            return true;
        }
        if (representationClass == null) {
            if (that.getRepresentationClass() != null) {
                return false;
            }
        } else {
            if (!representationClass.equals(that.getRepresentationClass())) {
                return false;
            }
        }
        if (mimeType == null) {
            if (that.mimeType != null) {
                return false;
            }
        } else {
            if (!mimeType.match(that.mimeType)) {
                return false;
            }
            if ("text".equals(getPrimaryType()) &&
                DataTransferer.doesSubtypeSupportCharset(this) &&
                representationClass != null &&
                !(isRepresentationClassReader() ||
                  String.class.equals(representationClass) ||
                  isRepresentationClassCharBuffer() ||
                  DataTransferer.charArrayClass.equals(representationClass)))
            {
                String thisCharset =
                    DataTransferer.canonicalName(getParameter("charset"));
                String thatCharset =
                    DataTransferer.canonicalName(that.getParameter("charset"));
                if (thisCharset == null) {
                    if (thatCharset != null) {
                        return false;
                    }
                } else {
                    if (!thisCharset.equals(thatCharset)) {
                        return false;
                    }
                }
            }
        }
        return true;
}

This method has the same behavior as #equals(Object) . The only difference being that it takes a {@code DataFlavor} instance as a parameter.

 public boolean equals(String s) 
{
        if (s == null || mimeType == null)
            return false;
        return isMimeTypeEqual(s);
}

Compares only the mimeType against the passed in String and representationClass is not considered in the comparison. If representationClass needs to be compared, then equals(new DataFlavor(s)) may be used.

 public final Class<?> getDefaultRepresentationClass() 
{
        return ioInputStreamClass;
}

 public final String getDefaultRepresentationClassAsString() 
{
        return getDefaultRepresentationClass().getName();
}

 public String getHumanPresentableName() 
{
        return humanPresentableName;
}

Returns the human presentable name for the data format that this DataFlavor represents. This name would be localized for different countries.

 public String getMimeType() 
{
        return (mimeType != null) ? mimeType.toString() : null;
}

Returns the MIME type string for this DataFlavor.

 public String getParameter(String paramName) 
{
        if (paramName.equals("humanPresentableName")) {
            return humanPresentableName;
        } else {
            return (mimeType != null)
                ? mimeType.getParameter(paramName) : null;
        }
}

Returns the human presentable name for this DataFlavor if paramName equals "humanPresentableName". Otherwise returns the MIME type value associated with paramName.

 public String getPrimaryType() 
{
        return (mimeType != null) ? mimeType.getPrimaryType() : null;
}

Returns the primary MIME type for this DataFlavor.

 public Reader getReaderForText(Transferable transferable) throws UnsupportedFlavorException, IOException 
{
        Object transferObject = transferable.getTransferData(this);
        if (transferObject == null) {
            throw new IllegalArgumentException
                ("getTransferData() returned null");
        }
        if (transferObject instanceof Reader) {
            return (Reader)transferObject;
        } else if (transferObject instanceof String) {
            return new StringReader((String)transferObject);
        } else if (transferObject instanceof CharBuffer) {
            CharBuffer buffer = (CharBuffer)transferObject;
            int size = buffer.remaining();
            char[] chars = new char[size];
            buffer.get(chars, 0, size);
            return new CharArrayReader(chars);
        } else if (transferObject instanceof char[]) {
            return new CharArrayReader((char[])transferObject);
        }
        InputStream stream = null;
        if (transferObject instanceof InputStream) {
            stream = (InputStream)transferObject;
        } else if (transferObject instanceof ByteBuffer) {
            ByteBuffer buffer = (ByteBuffer)transferObject;
            int size = buffer.remaining();
            byte[] bytes = new byte[size];
            buffer.get(bytes, 0, size);
            stream = new ByteArrayInputStream(bytes);
        } else if (transferObject instanceof byte[]) {
            stream = new ByteArrayInputStream((byte[])transferObject);
        }
        if (stream == null) {
            throw new IllegalArgumentException("transfer data is not Reader, String, CharBuffer, char array, InputStream, ByteBuffer, or byte array");
        }
        String encoding = getParameter("charset");
        return (encoding == null)
            ? new InputStreamReader(stream)
            : new InputStreamReader(stream, encoding);
}

Gets a Reader for a text flavor, decoded, if necessary, for the expected charset (encoding). The supported representation classes are java.io.Reader, java.lang.String, java.nio.CharBuffer, [C, java.io.InputStream, java.nio.ByteBuffer, and [B.

Because text flavors which do not support the charset parameter are encoded in a non-standard format, this method should not be called for such flavors. However, in order to maintain backward-compatibility, if this method is called for such a flavor, this method will treat the flavor as though it supports the charset parameter and attempt to decode it accordingly. See selectBestTextFlavor for a list of text flavors which do not support the charset parameter.

 public Class<?> getRepresentationClass() 
{
        return representationClass;
}

Returns the Class which objects supporting this DataFlavor will return when this DataFlavor is requested.

 public String getSubType() 
{
        return (mimeType != null) ? mimeType.getSubType() : null;
}

Returns the sub MIME type of this DataFlavor.

 public static final DataFlavor getTextPlainUnicodeFlavor() 
{
        String encoding = null;
        DataTransferer transferer = DataTransferer.getInstance();
        if (transferer != null) {
            encoding = transferer.getDefaultUnicodeEncoding();
        }
        return new DataFlavor(
            "text/plain;charset="+encoding
            +";class=java.io.InputStream", "Plain Text");
}

Returns a DataFlavor representing plain text with Unicode encoding, where:

    representationClass = java.io.InputStream
    mimeType            = "text/plain;
                           charset=<platform default Unicode encoding>"

Sun's implementation for Microsoft Windows uses the encoding utf-16le. Sun's implementation for Solaris and Linux uses the encoding iso-10646-ucs-2.

 public int hashCode() 
{
        int total = 0;
        if (representationClass != null) {
            total += representationClass.hashCode();
        }
        if (mimeType != null) {
            String primaryType = mimeType.getPrimaryType();
            if (primaryType != null) {
                total += primaryType.hashCode();
            }
            // Do not add subType.hashCode() to the total. equals uses
            // MimeType.match which reports a match if one or both of the
            // subTypes is '*', regardless of the other subType.
            if ("text".equals(primaryType) &&
                DataTransferer.doesSubtypeSupportCharset(this) &&
                representationClass != null &&
                !(isRepresentationClassReader() ||
                  String.class.equals(representationClass) ||
                  isRepresentationClassCharBuffer() ||
                  DataTransferer.charArrayClass.equals
                  (representationClass)))
            {
                String charset =
                    DataTransferer.canonicalName(getParameter("charset"));
                if (charset != null) {
                    total += charset.hashCode();
                }
            }
        }
        return total;
}

Returns hash code for this DataFlavor. For two equal DataFlavors, hash codes are equal. For the String that matches DataFlavor.equals(String), it is not guaranteed that DataFlavor's hash code is equal to the hash code of the String.

 public boolean isFlavorJavaFileListType() 
{
        if (mimeType == null || representationClass == null)
            return false;
        return java.util.List.class.isAssignableFrom(representationClass) &&
               mimeType.match(javaFileListFlavor.mimeType);
}

Returns true if the DataFlavor specified represents a list of file objects.

 public boolean isFlavorRemoteObjectType() 
{
        return isRepresentationClassRemote()
            && isRepresentationClassSerializable()
            && isMimeTypeEqual(javaRemoteObjectMimeType);
}

Returns true if the DataFlavor specified represents a remote object.

 public boolean isFlavorSerializedObjectType() 
{
        return isRepresentationClassSerializable() && isMimeTypeEqual(javaSerializedObjectMimeType);
}

Returns true if the DataFlavor specified represents a serialized object.

 public boolean isFlavorTextType() 
{
        return (DataTransferer.isFlavorCharsetTextType(this) ||
                DataTransferer.isFlavorNoncharsetTextType(this));
}

Returns whether this DataFlavor is a valid text flavor for this implementation of the Java platform. Only flavors equivalent to DataFlavor.stringFlavor and DataFlavors with a primary MIME type of "text" can be valid text flavors.

If this flavor supports the charset parameter, it must be equivalent to DataFlavor.stringFlavor, or its representation must be java.io.Reader, java.lang.String, java.nio.CharBuffer, [C, java.io.InputStream, java.nio.ByteBuffer, or [B. If the representation is java.io.InputStream, java.nio.ByteBuffer, or [B, then this flavor's charset parameter must be supported by this implementation of the Java platform. If a charset is not specified, then the platform default charset, which is always supported, is assumed.

If this flavor does not support the charset parameter, its representation must be java.io.InputStream, java.nio.ByteBuffer, or [B.

See selectBestTextFlavor for a list of text flavors which support the charset parameter.

 public boolean isMimeTypeEqual(String mimeType) 
{
        // JCK Test DataFlavor0117: if 'mimeType' is null, throw NPE
        if (mimeType == null) {
            throw new NullPointerException("mimeType");
        }
        if (this.mimeType == null) {
            return false;
        }
        try {
            return this.mimeType.match(new MimeType(mimeType));
        } catch (MimeTypeParseException mtpe) {
            return false;
        }
}

Returns whether the string representation of the MIME type passed in is equivalent to the MIME type of this DataFlavor. Parameters are not included in the comparison.

 public final boolean isMimeTypeEqual(DataFlavor dataFlavor) 
{
        return isMimeTypeEqual(dataFlavor.mimeType);
}

Compares the mimeType of two DataFlavor objects. No parameters are considered.

 public boolean isMimeTypeSerializedObject() 
{
        return isMimeTypeEqual(javaSerializedObjectMimeType);
}

Does the DataFlavor represent a serialized object?

 public boolean isRepresentationClassByteBuffer() 
{
        return java.nio.ByteBuffer.class.isAssignableFrom(representationClass);
}

Returns whether the representation class for this DataFlavor is java.nio.ByteBuffer or a subclass thereof.

 public boolean isRepresentationClassCharBuffer() 
{
        return java.nio.CharBuffer.class.isAssignableFrom(representationClass);
}

Returns whether the representation class for this DataFlavor is java.nio.CharBuffer or a subclass thereof.

 public boolean isRepresentationClassInputStream() 
{
        return ioInputStreamClass.isAssignableFrom(representationClass);
}

Does the DataFlavor represent a java.io.InputStream?

 public boolean isRepresentationClassReader() 
{
        return java.io.Reader.class.isAssignableFrom(representationClass);
}

Returns whether the representation class for this DataFlavor is java.io.Reader or a subclass thereof.

 public boolean isRepresentationClassRemote() 
{
        return DataTransferer.isRemote(representationClass);
}

Returns true if the representation class is Remote.

 public boolean isRepresentationClassSerializable() 
{
        return java.io.Serializable.class.isAssignableFrom(representationClass);
}

Returns true if the representation class can be serialized.

 public boolean match(DataFlavor that) 
{
        return equals(that);
}

Identical to #equals(DataFlavor) .

 protected String normalizeMimeType(String mimeType) 
{
        return mimeType;
}

Called for each MIME type string to give DataFlavor subtypes the opportunity to change how the normalization of MIME types is accomplished. One possible use would be to add default parameter/value pairs in cases where none are present in the MIME type string passed in. This method is never invoked by this implementation from 1.1 onwards.

 protected String normalizeMimeTypeParameter(String parameterName,
    String parameterValue) 
{
        return parameterValue;
}

Called on DataFlavor for every MIME Type parameter to allow DataFlavor subclasses to handle special parameters like the text/plain charset parameters, whose values are case insensitive. (MIME type parameter values are supposed to be case sensitive.

This method is called for each parameter name/value pair and should return the normalized representation of the parameterValue. This method is never invoked by this implementation from 1.1 onwards.

 public synchronized  void readExternal(ObjectInput is) throws IOException, ClassNotFoundException 
{
       String rcn = null;
        mimeType = (MimeType)is.readObject();
        if (mimeType != null) {
            humanPresentableName =
                mimeType.getParameter("humanPresentableName");
            mimeType.removeParameter("humanPresentableName");
            rcn = mimeType.getParameter("class");
            if (rcn == null) {
                throw new IOException("no class parameter specified in: " +
                                      mimeType);
            }
        }
        try {
            representationClass = (Class)is.readObject();
        } catch (OptionalDataException ode) {
            if (!ode.eof || ode.length != 0) {
                throw ode;
            }
            // Ensure backward compatibility.
            // Old versions didn't write the representation class to the stream.
            if (rcn != null) {
                representationClass =
                    DataFlavor.tryToLoadClass(rcn, getClass().getClassLoader());
            }
        }
}

Restores this DataFlavor from a Serialized state.

 public static final DataFlavor selectBestTextFlavor(DataFlavor[] availableFlavors) 
{
        if (availableFlavors == null || availableFlavors.length == 0) {
            return null;
        }
        if (textFlavorComparator == null) {
            textFlavorComparator = new TextFlavorComparator();
        }
        DataFlavor bestFlavor =
            (DataFlavor)Collections.max(Arrays.asList(availableFlavors),
                                        textFlavorComparator);
        if (!bestFlavor.isFlavorTextType()) {
            return null;
        }
        return bestFlavor;
}

Selects the best text DataFlavor from an array of DataFlavors. Only DataFlavor.stringFlavor, and equivalent flavors, and flavors that have a primary MIME type of "text", are considered for selection.

Flavors are first sorted by their MIME types in the following order:

• "text/sgml"
• "text/xml"
• "text/html"
• "text/rtf"
• "text/enriched"
• "text/richtext"
• "text/uri-list"
• "text/tab-separated-values"
• "text/t140"
• "text/rfc822-headers"
• "text/parityfec"
• "text/directory"
• "text/css"
• "text/calendar"
• "application/x-java-serialized-object"
• "text/plain"
• "text/<other>"

For example, "text/sgml" will be selected over "text/html", and DataFlavor.stringFlavor will be chosen over DataFlavor.plainTextFlavor.

If two or more flavors share the best MIME type in the array, then that MIME type will be checked to see if it supports the charset parameter.

The following MIME types support, or are treated as though they support, the charset parameter:

• "text/sgml"
• "text/xml"
• "text/html"
• "text/enriched"
• "text/richtext"
• "text/uri-list"
• "text/directory"
• "text/css"
• "text/calendar"
• "application/x-java-serialized-object"
• "text/plain"
The following MIME types do not support, or are treated as though they do not support, the charset parameter:
• "text/rtf"
• "text/tab-separated-values"
• "text/t140"
• "text/rfc822-headers"
• "text/parityfec"
For "text/<other>" MIME types, the first time the JRE needs to determine whether the MIME type supports the charset parameter, it will check whether the parameter is explicitly listed in an arbitrarily chosen DataFlavor which uses that MIME type. If so, the JRE will assume from that point on that the MIME type supports the charset parameter and will not check again. If the parameter is not explicitly listed, the JRE will assume from that point on that the MIME type does not support the charset parameter and will not check again. Because this check is performed on an arbitrarily chosen DataFlavor, developers must ensure that all DataFlavors with a "text/<other>" MIME type specify the charset parameter if it is supported by that MIME type. Developers should never rely on the JRE to substitute the platform's default charset for a "text/<other>" DataFlavor. Failure to adhere to this restriction will lead to undefined behavior.

If the best MIME type in the array does not support the charset parameter, the flavors which share that MIME type will then be sorted by their representation classes in the following order: java.io.InputStream, java.nio.ByteBuffer, [B, <all others>.

If two or more flavors share the best representation class, or if no flavor has one of the three specified representations, then one of those flavors will be chosen non-deterministically.

If the best MIME type in the array does support the charset parameter, the flavors which share that MIME type will then be sorted by their representation classes in the following order: java.io.Reader, java.lang.String, java.nio.CharBuffer, [C, <all others>.

If two or more flavors share the best representation class, and that representation is one of the four explicitly listed, then one of those flavors will be chosen non-deterministically. If, however, no flavor has one of the four specified representations, the flavors will then be sorted by their charsets. Unicode charsets, such as "UTF-16", "UTF-8", "UTF-16BE", "UTF-16LE", and their aliases, are considered best. After them, the platform default charset and its aliases are selected. "US-ASCII" and its aliases are worst. All other charsets are chosen in alphabetical order, but only charsets supported by this implementation of the Java platform will be considered.

If two or more flavors share the best charset, the flavors will then again be sorted by their representation classes in the following order: java.io.InputStream, java.nio.ByteBuffer, [B, <all others>.

If two or more flavors share the best representation class, or if no flavor has one of the three specified representations, then one of those flavors will be chosen non-deterministically.

 public  void setHumanPresentableName(String humanPresentableName) 
{
        this.humanPresentableName = humanPresentableName;
}

Sets the human presentable name for the data format that this DataFlavor represents. This name would be localized for different countries.

 public String toString() 
{
        String string = getClass().getName();
        string += "["+paramString()+"]";
        return string;
}

String representation of this DataFlavor and its parameters. The resulting String contains the name of the DataFlavor class, this flavor's MIME type, and its representation class. If this flavor has a primary MIME type of "text", supports the charset parameter, and has an encoded representation, the flavor's charset is also included. See selectBestTextFlavor for a list of text flavors which support the charset parameter.

 protected static final Class<?> tryToLoadClass(String className,
    ClassLoader fallback) throws ClassNotFoundException 
{
        ClassLoader systemClassLoader = (ClassLoader)
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction() {
                    public Object run() {
                        ClassLoader cl = Thread.currentThread().
                            getContextClassLoader();
                        return (cl != null)
                            ? cl
                            : ClassLoader.getSystemClassLoader();
                    }
                    });
        try {
            return Class.forName(className, true, systemClassLoader);
        } catch (ClassNotFoundException e2) {
            if (fallback != null) {
                return Class.forName(className, true, fallback);
            } else {
                throw new ClassNotFoundException(className);
            }
        }
}

Tries to load a class from: the bootstrap loader, the system loader, the context loader (if one is present) and finally the loader specified.

 public synchronized  void writeExternal(ObjectOutput os) throws IOException 
{
       if (mimeType != null) {
           mimeType.setParameter("humanPresentableName", humanPresentableName);
           os.writeObject(mimeType);
           mimeType.removeParameter("humanPresentableName");
       } else {
           os.writeObject(null);
       }
       os.writeObject(representationClass);
}

Serializes this DataFlavor.