public MemoryUsage(long init,
    long used,
    long committed,
    long max) 
{
        if (init <  -1) {
            throw new IllegalArgumentException( "init parameter = " +
                init + " is negative but not -1.");
        }
        if (max <  -1) {
            throw new IllegalArgumentException( "max parameter = " +
                max + " is negative but not -1.");
        }
        if (used <  0) {
            throw new IllegalArgumentException( "used parameter = " +
                used + " is negative.");
        }
        if (committed <  0) {
            throw new IllegalArgumentException( "committed parameter = " +
                committed + " is negative.");
        }
        if (used  > committed) {
            throw new IllegalArgumentException( "used = " + used +
                " should be < = committed = " + committed);
        }
        if (max  >= 0 && committed  > max) {
            throw new IllegalArgumentException( "committed = " + committed +
                " should be <  max = " + max);
        }
        this.init = init;
        this.used = used;
        this.committed = committed;
        this.max = max;
}

Constructs a MemoryUsage object.

Parameters:

init - the initial amount of memory in bytes that the Java virtual machine allocates; or -1 if undefined.

used - the amount of used memory in bytes.

committed - the amount of committed memory in bytes.

max - the maximum amount of memory in bytes that can be used; or -1 if undefined.

Throws:

IllegalArgumentException - if
• the value of init or max is negative but not -1; or
• the value of used or committed is negative; or
• used is greater than the value of committed; or
• committed is greater than the value of max max if defined.

 public static MemoryUsage from(CompositeData cd) 
{
        if (cd == null) {
            return null;
        }
        if (cd instanceof MemoryUsageCompositeData) {
            return ((MemoryUsageCompositeData) cd).getMemoryUsage();
        } else {
            return new MemoryUsage(cd);
        }
}

Returns a MemoryUsage object represented by the given CompositeData. The given CompositeData must contain the following attributes:

Attribute Name	Type
init	java.lang.Long
used	java.lang.Long
committed	java.lang.Long
max	java.lang.Long

 public long getCommitted() 
{
        return committed;
}

Returns the amount of memory in bytes that is committed for the Java virtual machine to use. This amount of memory is guaranteed for the Java virtual machine to use.

 public long getInit() 
{
        return init;
}

Returns the amount of memory in bytes that the Java virtual machine initially requests from the operating system for memory management. This method returns -1 if the initial memory size is undefined.

 public long getMax() 
{
        return max;
}

Returns the maximum amount of memory in bytes that can be used for memory management. This method returns -1 if the maximum memory size is undefined.

This amount of memory is not guaranteed to be available for memory management if it is greater than the amount of committed memory. The Java virtual machine may fail to allocate memory even if the amount of used memory does not exceed this maximum size.

 public long getUsed() 
{
        return used;
}

Returns the amount of used memory in bytes.

 public String toString() 
{
        StringBuffer buf = new StringBuffer();
        buf.append("init = " + init + "(" + (init  > > 10) + "K) ");
        buf.append("used = " + used + "(" + (used  > > 10) + "K) ");
        buf.append("committed = " + committed + "(" +
                   (committed  > > 10) + "K) " );
        buf.append("max = " + max + "(" + (max  > > 10) + "K)");
        return buf.toString();
}

Returns a descriptive representation of this memory usage.