CHAPTER 20

The Package java.lang

The java.lang package contains classes that are fundamental to the design of the Java language. The most important classes are Object, which is the root of the class hierarchy, and Class, instances of which represent classes at run time.

Frequently it is necessary to represent a value of primitive type as if it were an object. The wrapper classes Boolean, Character, Integer, Long, Float, and Double serve this purpose. An object of type Double, for example, contains a field whose type is double, representing that value in such a way that a reference to it can be stored in a variable of reference type. These classes also provide a number of methods for converting among primitive values, as well as supporting such standard methods as equals and hashCode.

The class Math provides commonly used mathematical functions such as sine, cosine, and square root. The classes String and StringBuffer similarly provide commonly used operations on character strings.

Classes ClassLoader, Process, Runtime, SecurityManager, and System provide "system operations" that manage the dynamic loading of classes, creation of external processes, host environment inquiries such as the time of day, and enforcement of security policies.

Class Throwable encompasses objects that may be thrown by the throw statement (§14.16). Subclasses of Throwable represent errors and exceptions.

The hierarchy of classes defined in package java.lang is as follows.

Object												§20.1	
	interface Cloneable												§20.2
	Class												§20.3
	Boolean												§20.4
	Character												§20.5
	Number												§20.6
		Integer												§20.7
		Long												§20.8
		Float												§20.9
		Double												§20.10
	Math												§20.11
	String												§20.12
	StringBuffer												§20.13
	ClassLoader												§20.14
	Process												§20.15
	Runtime												§20.16
	SecurityManager												§20.17
	System												§20.18
	interface Runnable												§20.19
	Thread												§20.20
	ThreadGroup												§20.21
	Throwable												§20.22
		Error
			LinkageError
				ClassCircularityError
				ClassFormatError
				ExceptionInInitializerError
				IncompatibleClassChangeError
					AbstractMethodError
					IllegalAccessError
					InstantiationError
					NoSuchFieldError
					NoSuchMethodError
				NoClassDefFoundError
				UnsatisfiedLinkError
				VerifyError
			VirtualMachineError
				InternalError
				OutOfMemoryError
				StackOverflowError
				UnknownError
			ThreadDeath
		Exception
			ClassNotFoundException
			CloneNotSupportedException
			IllegalAccessException
			InstantiationException
			InterruptedException
			RuntimeException
				ArithmeticException
				ArrayStoreException
				ClassCastException
				IllegalArgumentException
					IllegalThreadStateException
					NumberFormatException
				IllegalMonitorStateException
				IndexOutOfBoundsException
				NegativeArraySizeException
				NullPointerException
				SecurityException

20.1 The Class java.lang.Object

public class Object {
	public final Class getClass();
	public String toString();
	public boolean equals(Object obj);
	public int hashCode();
	protected Object clone()
		throws CloneNotSupportedException;
	public final void wait()

		throws IllegalMonitorStateException,

			InterruptedException;
	public final void wait(long millis)

		throws IllegalMonitorStateException,

			InterruptedException;
	public final void wait(long millis, int nanos)

		throws IllegalMonitorStateException,
			InterruptedException;
	public final void notify()
		throws IllegalMonitorStateException;
	public final void notifyAll()
		throws IllegalMonitorStateException;
	protected void finalize()

		throws Throwable;
}

20.1.1 public final Class getClass()

This method returns a reference to the unique object of type Class (§20.3) that represents the class of this object. That Class object is the object that is locked by static synchronized methods of the represented class.

20.1.2 public String toString()

The general contract of toString is that it returns a string that "textually represents" this object. The idea is to provide a concise but informative representation that will be useful to a person reading it.

The toString method defined by class Object returns a string consisting of the name of the class of which the object is an instance, a commercial at character '@', and the unsigned hexadecimal representation of the hashcode of the object. In other words, this method returns a string equal to the value of:

getClass().getName() + '@' + Integer.toHexString(hashCode())

20.1.3 public boolean equals(Object obj)

This method indicates whether some other object is "equal to" this one.

The general contract of equals is that it implements an equivalence relation:

• It is reflexive: for any reference value x, x.equals(x) should return true.
• It is symmetric: for any reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
• It is consistent: for any reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used by x and y in equals comparisons is modified.
• For any non-null reference value x, x.equals(null) should return false.

Overridden by Boolean (§20.4), Character (§20.5), Integer (§20.7), Long (§20.8), Float (§20.9), Double (§20.10), String (§20.12), and Bitset (§21.2).

20.1.4 public int hashCode()

This method is supported principally for the benefit of hash tables such as those provided by the Java library class java.util.Hashtable (§21.5).

The general contract of hashCode is as follows:

• Whenever it is invoked on the same object more than once during an execution of a Java application, hashCode must consistently return the same integer. The integer may be positive, negative, or zero. This integer does not, however, have to remain consistent from one Java application to another, or from one execution of an application to another execution of the same application.
• If two objects are equal according to the equals method (§20.1.3), then calling the hashCode method on each of the two objects must produce the same integer result.
• It is not required that if two objects are unequal according to the equals method (§20.1.3), then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.

Overridden by Boolean (§20.4), Character (§20.5), Integer (§20.7), Long (§20.8), Float (§20.9), Double (§20.10), String (§20.12), and Bitset (§21.2).

20.1.5 protected Object clone()
throws CloneNotSupportedException

The general contract of clone is that it creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object. The general intent is that, for any object x, the expression:

x.clone() != x

x.clone.getClass() == x.getClass()

x.clone.equals(x)

The method clone for class Object performs a specific cloning operation. First, if the class of this object does not implement the interface Cloneable, then a CloneNotSupportedException is thrown. Note that all arrays are considered to implement the interface Cloneable. Otherwise, this method creates a new instance of the class of this object and initializes all its fields with exactly the contents of the corresponding fields of this object, as if by assignment; the contents of the fields are not themselves cloned. Thus, this method performs a "shallow copy" of this object, not a "deep copy" operation.

The class Object does not itself implement the interface Cloneable, so calling the clone method on an object whose class is Object will result in throwing an exception at run time. The clone method is implemented by the class Object as a convenient, general utility for subclasses that implement the interface Cloneable, possibly also overriding the clone method, in which case the overriding definition can refer to this utility definition by the call:

super.clone()

20.1.6 public final void wait()
throws IllegalMonitorStateException, InterruptedException

This method causes the current thread to wait until some other thread invokes the notify method (§20.1.9) or the notifyAll method (§20.1.10) for this object.

In other words, this method behaves exactly as if it simply performs the call wait(0) (§20.1.7).

20.1.7 public final void wait(long millis)
throws IllegalMonitorStateException, InterruptedException

This method causes the current thread to wait until either some other thread invokes the notify method (§20.1.9) or the notifyAll method (§20.1.10) for this object, or a certain amount of real time has elapsed.

This method may be called only when the current thread is already synchronized on this object. If the current thread does not own the lock on this object, an IllegalMonitorStateException is thrown.

This method causes the current thread (call it T) to place itself in the wait set (§17.14) for this object and then to relinquish any and all synchronization claims on this object. Thread T becomes disabled for thread scheduling purposes and lies dormant until one of four things happens:

• Some other thread invokes the notify method for this object and thread T happens to be arbitrarily chosen as the thread to be awakened.
• Some other thread invokes the notifyAll method for this object.
• Some other thread interrupts (§20.20.31) thread T.
• The specified amount of real time has elapsed, more or less. The amount of real time, measured in milliseconds, is given by millis. If millis is zero, however, then real time is not taken into consideration and the thread simply waits until notified.

If the current thread is interrupted (§20.20.31) by another thread while it is waiting, then an InterruptedException is thrown. This exception is not thrown until the lock status of this object has been restored as described above.

Note that the wait method, as it places the current thread into the wait set for this object, unlocks only this object; any other objects on which the current thread may be synchronized remain locked while the thread waits.

20.1.8 public final void wait(long millis, int nanos)
throws IllegalMonitorStateException, InterruptedException

This method causes the current thread to wait until either some other thread invokes the notify method (§20.1.9) or the notifyAll method (§20.1.10) for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.

The amount of real time, measured in nanoseconds, is given by:

1000000*millis+nanos

20.1.9 public final void notify()
throws IllegalMonitorStateException

If any threads are waiting (§20.1.7) on this object, one of them is chosen to be awakened. The choice is arbitrary and at the discretion of the implementation.

The notify method may be called only when the current thread is already synchronized on this object. If the current thread does not own the lock on this object, an IllegalMonitorStateException is thrown.

The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object. The awakened thread will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.

20.1.10 public final void notifyAll()
throws IllegalMonitorStateException

All the threads waiting (§20.1.7) on this object are awakened.

The notifyAll method may be called only when the current thread is already synchronized on this object. If the current thread does not own the lock on this object, an IllegalMonitorStateException is thrown.

The awakened threads will not be able to proceed until the current thread relinquishes the lock on this object. The awakened threads will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened threads enjoy no reliable privilege or disadvantage in being the next thread to lock this object.

20.1.11 protected void finalize() throws Throwable

The general contract of finalize is that it is invoked if and when the Java Virtual Machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died (§12.7), except as a result of an action taken by the finalization of some other object or class which is ready to be finalized. The finalize method may take any action, including making this object available again to other threads; the usual purpose of finalize, however, is to perform cleanup actions before the object is irrevocably discarded. For example, the finalize method for an object that represents an input/output connection might perform explicit I/O transactions to break the connection before the object is permanently discarded.

The finalize method of class Object performs no special action; it simply returns normally. Subclasses of Object may override this definition.

Java does not guarantee which thread will invoke the finalize method for any given object. It is guaranteed, however, that the thread that invokes finalize will not be holding any user-visible synchronization locks when finalize is invoked. If an uncaught exception is thrown by the finalize method, the exception is ignored and finalization of that object terminates.

After the finalize method has been invoked for an object, no further action is taken until the Java Virtual Machine has again determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, including possible actions by other objects or classes which are ready to be finalized, at which point the object may be discarded.

The finalize method is never invoked more than once by a Java Virtual Machine for any given object.

20.2 The Interface java.lang.Cloneable

public interface Cloneable { }

20.3 The Class java.lang.Class

There is no public constructor for the class Class. The Java Virtual Machine automatically constructs Class objects as classes are loaded; such objects cannot be created by user programs.

public final class Class {
	public String toString();
	public String getName();
	public boolean isInterface();
	public Class getSuperclass();
	public Class[] getInterfaces();
	public Object newInstance()
		throws InstantiationException, IllegalAccessException;
	public ClassLoader getClassLoader();
	public static Class forName(String className)

		throws ClassNotFoundException;
}

20.3.1 public String toString()

If this Class object represents a class (which may be a declared class or an array class), a string is returned consisting of the word class, a space, and the name of the class as returned by the getName method (§20.3.2). If this Class object represents an interface, a string is returned consisting of the word interface, a space, and the name of the interface as returned by the getName method.

In other words, this method returns a string equal to the value of:

(isInterface() ? "interface " : "class ") + getName()

20.3.2 public String getName()

The fully qualified name of the class or interface represented by this Class object is returned as a String. For example:

new Object().getClass().getName()

If this class object represents a class of arrays, then the name consists of the name of the element type in Java signature format, preceded by one or more "[" characters representing the depth of array nesting. For example:

(new Object[3]).getClass().getName()

(new int[3][4][5][6][7][8][9]).getClass().getName()

B				byte
C				char
D				double
F				float
I				int
J				long
Lclassname;				class or interface
S				short
Z				boolean

20.3.3 public boolean isInterface()

If this Class object represents an interface, true is returned. If this Class object represents a class, false is returned.

20.3.4 public Class getSuperclass()

If this Class object represents any class other than the class Object, then the Class that represents the superclass of that class is returned. If this Class object is the one that represents the class Object, or if it represents an interface, null is returned. If this Class object represents an array class, then the Class that represents class Object is returned.

20.3.5 public Class[] getInterfaces()

This method returns an array of objects that represent interfaces. The array may be empty.

If this Class object represents a class, the array contains objects representing all interfaces directly implemented by the class. The order of the interface objects in the array corresponds to the order of the interface names in the implements clause of the declaration of the class represented by this Class object. For example, given the class declaration:

class Shimmer implements FloorWax, DessertTopping { ... }

s.getClass().getInterfaces()[0]

s.getClass().getInterfaces()[1]

If this Class object represents an interface, the array contains objects representing all interfaces directly extended by the interface-that is, the immediate superinterfaces of the interface. The order of the interface objects in the array corresponds to the order of the interface names in the extends clause of the declaration of the interface represented by this Class object.

20.3.6 public Object newInstance()
throws InstantiationException, IllegalAccessException

This method creates and returns a new instance of the class represented by this Class object. This is done exactly as if by a class instance creation expression (§15.8) with an empty argument list; for example, if t is the Class object that represents class Thread, then t.newInstance() does exactly the same thing as new Thread(). If evaluation of such a class instance creation expression would complete abruptly, then the call to the newInstance method will complete abruptly for the same reason. See also §11.5.1.2 for more on InstantiationException.

20.3.7 public ClassLoader getClassLoader()

This method returns a reference to the class loader (§20.14) that loaded this class. If this class has no class loader, then null is returned.

20.3.8 public static Class forName(String className)
throws ClassNotFoundException

Given the fully-qualified name of a class, this method attempts to locate, load, and link the class (§12.2). If it succeeds, then a reference to the Class object for the class is returned. If it fails, then a ClassNotFoundException is thrown.

20.4 The Class java.lang.Boolean

public final class Boolean {
	public static final Boolean TRUE = new Boolean(true);
	public static final Boolean FALSE = new Boolean(false);
	public Boolean(boolean value);
	public Boolean(String s);
	public String toString();
	public boolean equals(Object obj);
	public int hashCode();
	public boolean booleanValue();
	public static Boolean valueOf(String s);
	public static boolean getBoolean(String name);
}

20.4.1 public static final Boolean TRUE = new Boolean(true);

The constant value of this field is a Boolean object corresponding to the primitive value true.

20.4.2 public static final Boolean FALSE = new Boolean(false);

The constant value of this field is a Boolean object corresponding to the primitive value false.

20.4.3 public Boolean(boolean value)

This constructor initializes a newly created Boolean object so that it represents the primitive value that is the argument.

20.4.4 public Boolean(String s)

This constructor initializes a newly created Boolean object so that it represents true if and only if the argument is not null and is equal, ignoring case, to the string "true".

Examples:

new Boolean("True") produces a Boolean object that represents true.
new Boolean("yes") produces a Boolean object that represents false.

20.4.5 public String toString()

If this Boolean object represents true, a string equal to "true" is returned. If this Boolean object represents false, a string equal to "false" is returned.

Overrides the toString method of Object (§20.1.2).

20.4.6 public boolean equals(Object obj)

The result is true if and only if the argument is not null and is a Boolean object that represents the same boolean value as this Boolean object.

Overrides the equals method of Object (§20.1.3).

20.4.7 public int hashCode()

If this Boolean object represents true, the integer 1231 is returned. If this Boolean object represents false, the integer 1237 is returned.

Overrides the hashCode method of Object (§20.1.4).

20.4.8 public boolean booleanValue()

The primitive boolean value represented by this Boolean object is returned.

20.4.9 public static boolean valueOf(String s)

The result is true if and only if the argument is not null and is equal, ignoring case, to the string "true".

Example: Boolean.valueOf("True") returns true.

Example: Boolean.valueOf("yes") returns false.

20.4.10 public static boolean getBoolean(String name)

The result is true if and only if the value of the system property (§20.18.9) named by the argument is equal, ignoring case, to the string "true".

20.5 The Class java.lang.Character

public final class Character {
	public static final char MIN_VALUE = '\u0000';
	public static final char MAX_VALUE = '\uffff';
	public static final int MIN_RADIX = 2;
	public static final int MAX_RADIX = 36;
	public Character(char value);
	public String toString();
	public boolean equals(Object obj);
	public int hashCode();
	public char charValue();
	public static boolean isDefined(char ch);
	public static boolean isLowerCase(char ch);
	public static boolean isUpperCase(char ch);
	public static boolean isTitleCase(char ch);
	public static boolean isDigit(char ch);
	public static boolean isLetter(char ch);
	public static boolean isLetterOrDigit(char ch);
	public static boolean isJavaLetter(char ch);
	public static boolean isJavaLetterOrDigit(char ch);)
	public static boolean isSpace(char ch);
	public static char toLowerCase(char ch);
	public static char toUpperCase(char ch);
	public static char toTitleCase(char ch);
	public static int digit(char ch, int radix);
	public static char forDigit(int digit, int radix);
}

The Unicode 1.1.5 attribute table is available on the World Wide Web as:

ftp://unicode.org/pub/MappingTables/UnicodeData-1.1.5.txt

• The following entries should have titlecase mappings as shown here:

  03D0;GREEK BETA SYMBOL;Ll;0;L;;;;;N;GREEK SMALL LETTER CURLED BETA;;0392;;0392

  03D1;GREEK THETA SYMBOL;Ll;0;L;;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398

  03D5;GREEK PHI SYMBOL;Ll;0;L;;;;;N;GREEK SMALL LETTER SCRIPT PHI;;03A6;;03A6

  03D6;GREEK PI SYMBOL;Ll;0;L;;;;;N;GREEK SMALL LETTER OMEGA PI;;03A0;;03A0

  03F0;GREEK KAPPA SYMBOL;Ll;0;L;;;;;N;GREEK SMALL LETTER SCRIPT KAPPA;;039A;;039A

  03F1;GREEK RHO SYMBOL;Ll;0;L;;;;;N;GREEK SMALL LETTER TAILED RHO;;03A1;;03A1

• The following entries should have numeric values as shown here:

  FF10;FULLWIDTH DIGIT ZERO;Nd;0;EN;0030;0;0;0;N;;;;;

  FF11;FULLWIDTH DIGIT ONE;Nd;0;EN;0031;1;1;1;N;;;;;

  FF12;FULLWIDTH DIGIT TWO;Nd;0;EN;0032;2;2;2;N;;;;;

  FF13;FULLWIDTH DIGIT THREE;Nd;0;EN;0033;3;3;3;N;;;;;

  FF14;FULLWIDTH DIGIT FOUR;Nd;0;EN;0034;4;4;4;N;;;;;

  FF15;FULLWIDTH DIGIT FIVE;Nd;0;EN;0035;5;5;5;N;;;;;

  FF16;FULLWIDTH DIGIT SIX;Nd;0;EN;0036;6;6;6;N;;;;;

  FF17;FULLWIDTH DIGIT SEVEN;Nd;0;EN;0037;7;7;7;N;;;;;

  FF18;FULLWIDTH DIGIT EIGHT;Nd;0;EN;0038;8;8;8;N;;;;;

  FF19;FULLWIDTH DIGIT NINE;Nd;0;EN;0039;9;9;9;N;;;;;

• The following entries should have no lowercase equivalents:

  03DA;GREEK LETTER STIGMA;Lu;0;L;;;;;N;GREEK CAPITAL LETTER STIGMA;;;;

  03DC;GREEK LETTER DIGAMMA;Lu;0;L;;;;;N;GREEK CAPITAL LETTER DIGAMMA;;;;

  03DE;GREEK LETTER KOPPA;Lu;0;L;;;;;N;GREEK CAPITAL LETTER KOPPA;;;;

  03E0;GREEK LETTER SAMPI;Lu;0;L;;;;;N;GREEK CAPITAL LETTER SAMPI;;;;

• This entry should have uppercase and titlecase equivalents as shown here:

  03C2;GREEK SMALL LETTER FINAL SIGMA;Ll;0;L;;;;;N;;;03A3;;03A3

Java 1.1 will include the methods defined here, either based on Unicode 1.1.5 or, we hope, updated versions of the methods that use the newer Unicode 2.0. The character attribute table for Unicode 2.0 is currently available on the World Wide Web as the file:

ftp://unicode.org/pub/MappingTables/UnicodeData-2.0.12.txt

http://java.sun.com/Series

The biggest change in Unicode 2.0 is a complete rearrangement of the Korean Hangul characters. There are numerous smaller improvements as well.

It is our intention that Java will track Unicode as it evolves over time. Given that full Unicode support is just emerging in the marketplace, and that changes in Unicode are in areas which are not yet widely used, this should cause minimal problems and further Java's goal of worldwide language support.

20.5.1 public static final char MIN_VALUE = '\u0000';

The constant value of this field is the smallest value of type char.

[This field is scheduled for introduction in Java version 1.1.]

20.5.2 public static final char MAX_VALUE = '\uffff';

The constant value of this field is the smallest value of type char.

[This field is scheduled for introduction in Java version 1.1.]

20.5.3 public static final int MIN_RADIX = 2;

The constant value of this field is the smallest value permitted for the radix argument in radix-conversion methods such as the digit method (§20.5.23), the forDigit method (§20.5.24), and the toString method of class Integer (§20.7).

20.5.4 public static final int MAX_RADIX = 36;

The constant value of this field is the largest value permitted for the radix argument in radix-conversion methods such as the digit method (§20.5.23), the forDigit method (§20.5.24), and the toString method of class Integer (§20.7).

20.5.5 public Character(char value)

This constructor initializes a newly created Character object so that it represents the primitive value that is the argument.

20.5.6 public String toString()

The result is a String whose length is 1 and whose sole component is the primitive char value represented by this Character object.

Overrides the toString method of Object (§20.1.2).

20.5.7 public boolean equals(Object obj)

The result is true if and only if the argument is not null and is a Character object that represents the same char value as this Character object.

Overrides the equals method of Object (§20.1.3).

20.5.8 public int hashCode()

The result is the primitive char value represented by this Character object, cast to type int.

Overrides the hashCode method of Object (§20.1.4).

20.5.9 public char charValue()

The primitive char value represented by this Character object is returned.

20.5.10 public static boolean isDefined(char ch)

The result is true if and only if the character argument is a defined Unicode character.

A character is a defined Unicode character if and only if at least one of the following is true:

• It has an entry in the Unicode attribute table.
• It is not less than \u3040 and not greater than \u9FA5.
• It is not less than \uF900 and not greater than \uFA2D.

[This method is scheduled for introduction in Java version 1.1, either as defined here, or updated for Unicode 2.0; see §20.5.]

20.5.11 public static boolean isLowerCase(char ch)

The result is true if and only if the character argument is a lowercase character.

A character is considered to be lowercase if and only if all of the following are true:

• The character ch is not in the range \u2000 through \u2FFF.
• The Unicode attribute table does not specify a mapping to lowercase for this character (the purpose of this requirement is to exclude titlecase characters).
• At least one of the following is true:
  • The Unicode attribute table specifies a mapping to uppercase for this character.
  • The name for the character in the Unicode attribute table contains the words SMALL LETTER or the words SMALL LIGATURE.

Of the first 128 Unicode characters, exactly 26 are considered to be lowercase:

abcdefghijklmnopqrstuvwxyz

20.5.12 public static boolean isUpperCase(char ch)

The result is true if and only if the character argument is an uppercase character.

A character is considered to be uppercase if and only if all of the following are true:

• The character ch is not in the range \u2000 through \u2FFF.
• The Unicode attribute table does not specify a mapping to uppercase for this character (the purpose of this requirement is to exclude titlecase characters).
• At least one of the following is true:
  • The Unicode attribute table specifies a mapping to lowercase for this character.
  • The name for the character in the Unicode attribute table contains the words CAPITAL LETTER or the words CAPITAL LIGATURE.

Of the first 128 Unicode characters, exactly 26 are considered to be uppercase:

ABCDEFGHIJKLMNOPQRSTUVWXYZ

20.5.13 public static boolean isTitleCase(char ch)

The result is true if and only if the character argument is a titlecase character.

The notion of "titlecase" was introduced into Unicode to handle a peculiar situation: there are single Unicode characters whose appearance in each case looks exactly like two ordinary Latin letters. For example, there is a single Unicode character `LJ' (\u01C7) that looks just like the characters `L' and `J' put together. There is a corresponding lowercase letter `lj' (\u01C9) as well. These characters are present in Unicode primarily to allow one-to-one translations from the Cyrillic alphabet, as used in Serbia, for example, to the Latin alphabet. Now suppose the word "LJUBINJE" (which has six characters, not eight, because two of them are the single Unicode characters `LJ' and `NJ', perhaps produced by one-to-one translation from the Cyrillic) is to be written as part of a book title, in capitals and lowercase. The strategy of making the first letter uppercase and the rest lowercase results in "LJubinje"-most unfortunate. The solution is that there must be a third form, called a titlecase form. The titlecase form of `LJ' is `Lj' (\u01C8) and the titlecase form of `NJ' is `Nj'. A word for a book title is then best rendered by converting the first letter to titlecase if possible, otherwise to uppercase; the remaining letters are then converted to lowercase.

A character is considered to be titlecase if and only if both of the following are true:

• The character ch is not in the range \u2000 through \u2FFF.
• The Unicode attribute table specifies a mapping to uppercase and a mapping to lowercase for this character.

\u01C5	    LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
\u01C8	    LATIN CAPITAL LETTER L WITH SMALL LETTER J
\u01CB	    LATIN CAPITAL LETTER N WITH SMALL LETTER J
\u01F2	    LATIN CAPITAL LETTER D WITH SMALL LETTER Z

20.5.14 public static boolean isDigit(char ch)

The result is true if and only if the character argument is a digit.

A character is considered to be a digit if and only if both of the following are true:

• The character ch is not in the range \u2000 through \u2FFF.
• The name for the character in the Unicode attribute table contains the word DIGIT.

0030-0039	ISO-Latin-1 (and ASCII) digits ('0'-'9')
0660-0669	Arabic-Indic digits
06F0-06F9	Eastern Arabic-Indic digits
0966-096F	Devanagari digits
09E6-09EF	Bengali digits
0A66-0A6F	Gurmukhi digits
0AE6-0AEF	Gujarati digits
0B66-0B6F	Oriya digits
0BE7-0BEF	Tamil digits (there are only nine of these-no zero digit)
0C66-0C6F	Telugu digits
0CE6-0CEF	Kannada digits
0D66-0D6F	Malayalam digits
0E50-0E59	Thai digits
0ED0-0ED9	Lao digits
FF10-FF19	Fullwidth digits

0123456789

20.5.15 public static boolean isLetter(char ch)

The result is true if and only if the character argument is a letter.

A character is considered to be a letter if and only if it is a letter or digit (§20.5.16) but is not a digit (§20.5.14).

[This method is scheduled for introduction in Java version 1.1, either as defined here, or updated for Unicode 2.0; see §20.5.]

20.5.16 public static boolean isLetterOrDigit(char ch)

The result is true if and only if the character argument is a letter-or-digit.

A character is considered to be a letter-or-digit if and only if it is a defined Unicode character (§20.5.10) and its code lies in one of the following ranges:

0030-0039	ISO-Latin-1 (and ASCII) digits ('0'-'9')
0041-005A	ISO-Latin-1 (and ASCII) uppercase Latin letters ('A'-'Z')
0061-007A	ISO-Latin-1 (and ASCII) lowercase Latin letters ('a'-'z')
00C0-00D6	ISO-Latin-1 supplementary letters
00D8-00F6	ISO-Latin-1 supplementary letters
00F8-00FF	ISO-Latin-1 supplementary letters
0100-1FFF	Latin extended-A, Latin extended-B, IPA extensions, 
spacing modifier letters, combining diacritical marks, basic 
Greek, Greek symbols and Coptic, Cyrillic, Armenian, 
Hebrew extended-A, Basic Hebrew, Hebrew extended-B, 
Basic Arabic, Arabic extended, Devanagari, Bengali, 
Gurmukhi, Gujarati, Oriya, Tamil, Telugu, Kannada, 
Malayalam, Thai, Lao, Basic Georgian, Georgian extended, 
Hanguljamo, Latin extended additional, Greek extended
3040-9FFF	Hiragana, Katakana, Bopomofo, Hangul compatibility 
Jamo, CJK miscellaneous, enclosed CJK characters and 
months, CJK compatibility, Hangul, Hangul 
supplementary-A, Hangul supplementary-B, CJK unified 
ideographs
F900-FDFF	CJK compatibility ideographs, alphabetic presentation 
forms, Arabic presentation forms-A
FE70-FEFE	Arabic presentation forms-B
FF10-FF19	Fullwidth digits
FF21-FF3A	Fullwidth Latin uppercase
FF41-FF5A	Fullwidth Latin lowercase
FF66-FFDC	Halfwidth Katakana and Hangul

[This method is scheduled for introduction in Java version 1.1, either as defined here, or updated for Unicode 2.0; see §20.5.]

20.5.17 public static boolean isJavaLetter(char ch)

The result is true if and only if the character argument is a character that can begin a Java identifier.

A character is considered to be a Java letter if and only if it is a letter (§20.5.15) or is the dollar sign character '$' (\u0024) or the underscore ("low line") character '_' (\u005F).

[This method is scheduled for introduction in Java version 1.1, either as defined here, or updated for Unicode 2.0; see §20.5.]

20.5.18 public static boolean isJavaLetterOrDigit(char ch)

The result is true if and only if the character argument is a character that can occur in a Java identifier after the first character.

A character is considered to be a Java letter-or-digit if and only if it is a letter-or-digit (§20.5.16) or is the dollar sign character '$' (\u0024) or the underscore ("low line") character '_' (\u005F).

[This method is scheduled for introduction in Java version 1.1, either as defined here, or updated for Unicode 2.0; see §20.5.]

20.5.19 public static boolean isSpace(char ch)

The result is true if the argument ch is one of the following characters:

'\t'		\u0009			HT		HORIZONTAL TABULATION
'\n'		\u000A			LF		LINE FEED (also known as NEW LINE)
'\f'		\u000C			FF		FORM FEED
'\r'		\u000D			CR		CARRIAGE RETURN
' '		\u0020			SP		SPACE

20.5.20 public static char toLowerCase(char ch)

If the character ch has a lowercase equivalent specified in the Unicode attribute table, then that lowercase equivalent character is returned. Otherwise, the argument ch is returned.

The lowercase equivalents specified in the Unicode attribute table, for Unicode 1.1.5 as corrected above, are as follows, where character codes to the right of arrows are the lowercase equivalents of character codes to the left of arrows: 0041-005A0061-007A, 00C0-00D600E0-00F6, 00D8-00DE00F8-00FE, 0100-012E0101-012F (evens to odds), 0132-01360133-0137 (evens to odds), 0139-0147013A-0148 (odds to evens), 014A-0176014B-0177 (evens to odds), 017800FF, 0179-017D017A-017E (odds to evens), 01810253, 01820183, 01840185, 01860254, 01870188, 018A0257, 018B018C, 018E0258, 018F0259, 0190025B, 01910192, 01930260, 01940263, 01960269, 01970268, 01980199, 019C026F, 019D0272, 01A0-01A401A1-01A5 (evens to odds), 01A701A8, 01A90283, 01AC01AD, 01AE0288, 01AF01B0, 01B1028A, 01B2028B, 01B301B4, 01B501B6, 01B70292, 01B801B9, 01BC01BD, 01C401C6, 01C501C6, 01C701C9, 01C801C9, 01CA01CC, 01CB-01DB01CC-01DC (odds to evens), 01DE-01EE01DF-01EF (evens to odds), 01F101F3, 01F201F3, 01F401F5, 01FA-021601FB-0217 (evens to odds), 038603AC, 0388-038A03AD-03AF, 038C03CC, 038E03CD, 038F03CE, 0391-03A103B1-03C1, 03A3-03AB03C3-03CB, 03E2-03EE03E3-03EF (evens to odds), 0401-040C0451-045C, 040E045E, 040F045F, 0410-042F0430-044F, 0460-04800461-0481 (evens to odds), 0490-04BE0491-04BF (evens to odds), 04C104C2, 04C304C4, 04C704C8, 04CB04CC, 04D0-04EA04D1-04EB (evens to odds), 04EE-04F404EF-04F5 (evens to odds), 04F804F9, 0531-05560561-0586, 10A0-10C510D0-10F5, 1E00-1E941E01-1E95 (evens to odds), 1EA0-1EF81EA1-1EF9 (evens to odds), 1F08-1F0F1F00-1F07, 1F18-1F1D1F10-1F15, 1F28-1F2F1F20-1F27, 1F38-1F3F1F30-1F37, 1F48-1F4D1F40-1F45, 1F591F51, 1F5B1F53, 1F5D1F55, 1F5F1F57, 1F68-1F6F1F60-1F67, 1F88-1F8F1F80-1F87, 1F98-1F9F1F90-1F97, 1FA8-1FAF1FA0-1FA7, 1FB81FB0, 1FB91FB1, 1FBA1F70, 1FBB1F71, 1FBC1FB3, 1FC8-1FCB1F72-1F75, 1FCC1FC3, 1FD81FD0, 1FD91FD1, 1FDA1F76, 1FDB1F77, 1FE81FE0, 1FE91FE1, 1FEA1F7A, 1FEB1F7B, 1FEC1FE5, 1FF81F78, 1FF91F79, 1FFA1F7C, 1FFB1F7D, 1FFC1FF3, 2160-216F2170-217F, 24B6-24CF24D0-24E9, FF21-FF3AFF41-FF5A.

Note that the method isLowerCase (§20.5.11) will not necessarily return true when given the result of the toLowerCase method.

[This specification for the method toLowerCase is scheduled for introduction in Java version 1.1, either as defined here, or updated for Unicode 2.0; see §20.5. In previous versions of Java, this method returns its argument for all arguments larger than \u00FF.]

20.5.21 public static char toUpperCase(char ch)

If the character ch has an uppercase equivalent specified in the Unicode attribute table, then that uppercase equivalent character is returned. Otherwise, the argument ch is returned.

The uppercase equivalents specified in the Unicode attribute table for Unicode 1.1.5 as corrected above, are as follows, where character codes to the right of arrows are the uppercase equivalents of character codes to the left of arrows: 0061-007A0041-005A, 00E0-00F600C0-00D6, 00F8-00FE00D8-00DE, 00FF0178, 0101-012F0100-012E (odds to evens), 0133-01370132-0136 (odds to evens), 013A-01480139-0147 (evens to odds), 014B-0177014A-0176 (odds to evens), 017A-017E0179-017D (evens to odds), 017F0053, 0183-01850182-0184 (odds to evens), 01880187, 018C018B, 01920191, 01990198, 01A1-01A501A0-01A4 (odds to evens), 01A801A7, 01AD01AC, 01B001AF, 01B401B3, 01B601B5, 01B901B8, 01BD01BC, 01C501C4, 01C601C4, 01C801C7, 01C901C7, 01CB01CA, 01CC01CA, 01CE-01DC01CD-01DB (evens to odds), 01DF-01EF01DE-01EE (odds to evens), 01F201F1, 01F301F1, 01F501F4, 01FB-021701FA-0216 (odds to evens), 02530181, 02540186, 0257018A, 0258018E, 0259018F, 025B0190, 02600193, 02630194, 02680197, 02690196, 026F019C, 0272019D, 028301A9, 028801AE, 028A01B1, 028B01B2, 029201B7, 03AC0386, 03AD-03AF0388-038A, 03B1-03C10391-03A1, 03C203A3, 03C3-03CB03A3-03AB, 03CC038C, 03CD038E, 03CE038F, 03D00392, 03D10398, 03D503A6, 03D603A0, 03E3-03EF03E2-03EE (odds to evens), 03F0039A, 03F103A1, 0430-044F0410-042F, 0451-045C0401-040C, 045E040E, 045F040F, 0461-04810460-0480 (odds to evens), 0491-04BF0490-04BE (odds to evens), 04C204C1, 04C404C3, 04C804C7, 04CC04CB, 04D1-04EB04D0-04EA (odds to evens), 04EF-04F504EE-04F4 (odds to evens), 04F904F8, 0561-05860531-0556, 1E01-1E951E00-1E94 (odds to evens), 1EA1-1EF91EA0-1EF8 (odds to evens), 1F00-1F071F08-1F0F, 1F10-1F151F18-1F1D, 1F20-1F271F28-1F2F, 1F30-1F371F38-1F3F, 1F40-1F451F48-1F4D, 1F511F59, 1F531F5B, 1F551F5D, 1F571F5F, 1F60-1F671F68-1F6F, 1F701FBA, 1F711FBB, 1F72-1F751FC8-1FCB, 1F761FDA, 1F771FDB, 1F781FF8, 1F791FF9, 1F7A1FEA, 1F7B1FEB, 1F7C1FFA, 1F7D1FFB, 1F80-1F871F88-1F8F, 1F90-1F971F98-1F9F, 1FA0-1FA71FA8-1FAF, 1FB01FB8, 1FB11FB9, 1FB31FBC, 1FC31FCC, 1FD01FD8, 1FD11FD9, 1FE01FE8, 1FE11FE9, 1FE51FEC, 1FF31FFC, 2170-217F2160-216F, 24D0-24E924B6-24CF, FF41-FF5AFF21-FF3A.

Note that the method isUpperCase (§20.5.12) will not necessarily return true when given the result of the toUpperCase method.

[This specification for the method toUpperCase is scheduled for introduction in Java version 1.1, either as defined here, or updated for Unicode 2.0; see §20.5. In previous versions of Java, this method returns its argument for all arguments larger than \u00FE. Note that although \u00FF is a lowercase character, its uppercase equivalent is \u0178; toUpperCase in versions of Java prior to version 1.1 simply do not consistently handle or use Unicode character codes above \u00FF.]

20.5.22 public static char toTitleCase(char ch)

If the character ch has a titlecase equivalent specified in the Unicode attribute table, then that titlecase equivalent character is returned; otherwise, the argument ch is returned.

Note that the method isTitleCase (§20.5.13) will not necessarily return true when given the result of the toTitleCase method. The Unicode attribute table always has the titlecase attribute equal to the uppercase attribute for characters that have uppercase equivalents but no separate titlecase form.

Example: Character.toTitleCase('a') returns 'A'

Example: Character.toTitleCase('Q') returns 'Q'

Example: Character.toTitleCase('lj') returns 'Lj' where 'lj' is the Unicode character \u01C9 and 'Lj' is its titlecase equivalent character \u01C8.

[This method is scheduled for introduction in Java version 1.1.]

20.5.23 public static int digit(char ch, int radix)

Returns the numeric value of the character ch considered as a digit in the specified radix. If the value of radix is not a valid radix, or the character ch is not a valid digit in the specified radix, then -1 is returned.

A radix is valid if and only if its value is not less than Character.MIN_RADIX (§20.5.3) and not greater than Character.MAX_RADIX (§20.5.4).

A character is a valid digit if and only if one of the following is true:

• The method isDigit returns true for the character, and the decimal digit value of the character, as specified in the Unicode attribute table, is less than the specified radix. In this case, the decimal digit value is returned.
• The character is one of the uppercase Latin letters 'A'-'Z' (\u0041-\u005A) and its code is less than radix+'A'-10. In this case ch-'A'+10 is returned.
• The character is one of the lowercase Latin letters 'a'-'z' (\u0061-\u007A) and its code is less than radix+'a'-10. In this case ch-'a'+10 is returned.

20.5.24 public static char forDigit(int digit, int radix)

Returns a character that represents the given digit in the specified radix. If the value of radix is not a valid radix, or the value of digit is not a valid digit in the specified radix, the null character '\u0000' is returned.

A radix is valid if and only if its value is not less than Character.MIN_RADIX (§20.5.3) and not greater than Character.MAX_RADIX (§20.5.4).

A digit is valid if and only if it is nonnegative and less than the radix.

If the digit is less than 10, then the character value '0'+digit is returned; otherwise, 'a'+digit-10 is returned. Thus, the digits produced by forDigit, in increasing order of value, are the ASCII characters:

0123456789abcdefghijklmnopqrstuvwxyz

Character.toUpperCase(Character.forDigit(digit, radix))

20.6 The Class java.lang.Number

public abstract class Number {
	public abstract int intValue();
	public abstract long longValue();
	public abstract float floatValue();
	public abstract double doubleValue();
}

20.6.1 public abstract int intValue()

The general contract of the intValue method is that it returns the numeric value represented by this Number object after converting it to type int.

Overridden by Integer (§20.7.8), Long (§20.8.8), Float (§20.9.12), and Double (§20.10.11).

20.6.2 public abstract long longValue()

The general contract of the longValue method is that it returns the numeric value represented by this Number object after converting it to type long.

Overridden by Integer (§20.7.9), Long (§20.8.9), Float (§20.9.13), and Double (§20.10.12).

20.6.3 public abstract float floatValue()

The general contract of the floatValue method is that it returns the numeric value represented by this Number object after converting it to type float.

Overridden by Integer (§20.7.10), Long (§20.8.10), Float (§20.9.14), and Double (§20.10.13).

20.6.4 public abstract double doubleValue()

The general contract of the doubleValue method is that it returns the numeric value represented by this Number object after converting it to type double.

Overridden by Integer (§20.7.11), Long (§20.8.11), Float (§20.9.15), and Double (§20.10.14).

20.7 The Class java.lang.Integer

public final class Integer extends Number {
	public static final int MIN_VALUE = 0x80000000;
	public static final int MAX_VALUE = 0x7fffffff;
	public Integer(int value);
	public Integer(String s)

		throws NumberFormatException;
	public String toString();
	public boolean equals(Object obj);
	public int hashCode();
	public int intValue();
	public long longValue();
	public float floatValue();
	public double doubleValue();
	public static String toString(int i);
	public static String toString(int i, int radix);
	public static String toHexString(long i);
	public static String toOctalString(long i);
	public static String toBinaryString(long i);
	public static int parseInt(String s)

		throws NumberFormatException;
	public static int parseInt(String s, int radix)

		throws NumberFormatException;
	public static Integer valueOf(String s)

		throws NumberFormatException;
	public static Integer valueOf(String s, int radix)

		throws NumberFormatException;
	public static Integer getInteger(String nm);
	public static Integer getInteger(String nm, int val);
	public static Integer getInteger(String nm, Integer val);
}

20.7.1 public static final int MIN_VALUE = 0x80000000;

The constant value of this field is -2147483648, the lowest value of type int.

20.7.2 public static final int MAX_VALUE = 0x7fffffff;

The constant value of this field is 2147483647, the highest value of type int.

20.7.3 public Integer(int value)

This constructor initializes a newly created Integer object so that it represents the primitive value that is the argument.

20.7.4 public Integer(String s) throws NumberFormatException

This constructor initializes a newly created Integer object so that it represents the integer represented by the string in decimal form. The string is converted to an int in exactly the manner used by the parseInt method (§20.7.18) for radix 10.

20.7.5 public String toString()

The integer value represented by this Integer object is converted to signed decimal representation and returned as a string, exactly as if the integer value were given as an argument to the toString method that takes one argument (§20.7.12).

Overrides the toString method of Object (§20.1.2).

20.7.6 public boolean equals(Object obj)

The result is true if and only if the argument is not null and is an Integer object that represents the same int value as this Integer object.

Overrides the equals method of Object (§20.1.3).

20.7.7 public int hashCode()

The result is the primitive int value represented by this Integer object.

Overrides the hashCode method of Object (§20.1.4).

20.7.8 public int intValue()

The int value represented by this Integer object is returned.

Overrides the intValue method of Number (§20.6.1).

20.7.9 public long longValue()

The int value represented by this Integer object is converted (§5.1.2) to type long and the result of the conversion is returned.

Overrides the longValue method of Number (§20.6.2).

20.7.10 public float floatValue()

The int value represented by this Integer object is converted (§5.1.2) to type float and the result of the conversion is returned.

Overrides the floatValue method of Number (§20.6.3).

20.7.11 public double doubleValue()

The int value represented by this Integer object is converted (§5.1.2) to type double and the result of the conversion is returned.

Overrides the doubleValue method of Number (§20.6.4).

20.7.12 public static String toString(int i)

The argument is converted to signed decimal representation and returned as a string, exactly as if the argument and the radix 10 were given as arguments to the toString method that takes two arguments (§20.7.13).

20.7.13 public static String toString(int i, int radix)

The first argument is converted to a signed representation in the radix specified by the second argument; this representation is returned as a string.

If the radix is smaller than Character.MIN_RADIX (§20.5.3) or larger than Character.MAX_RADIX (§20.5.4), then the value 10 is used instead.

If the first argument is negative, the first character of the result will be the character '-' ('\u002d'). If the first argument is not negative, no sign character appears in the result.

The remaining characters of the result represent the magnitude of the first argument. If the magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the magnitude will not be the zero character.The following ASCII characters are used as digits:

0123456789abcdefghijklmnopqrstuvwxyz

Integer.toString(n, 16).toUpperCase()

20.7.14 public static String toHexString(int i)

The argument is converted to an unsigned representation in hexadecimal radix (base 16); this representation is returned as a string.

The result represents the unsigned magnitude of the argument. This equals the argument plus if the argument is negative; otherwise, it equals the argument.

If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The following characters are used as hexadecimal digits:

0123456789abcdef

Long.toHexString(n).toUpperCase()

20.7.15 public static String toOctalString(int i)

The argument is converted to an unsigned representation in octal radix (base 8); this representation is returned as a string.

The result represents the unsigned magnitude of the argument. This equals the argument plus if the argument is negative; otherwise, it equals the argument.

If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The octal digits are:

01234567

20.7.16 public static String toBinaryString(int i)

The argument is converted to an unsigned representation in binary radix (base 2); this representation is returned as a string.

The result represents the unsigned magnitude of the argument. This equals the argument plus if the argument is negative; otherwise, it equals the argument.

If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The characters '0' ('\u0030') and '1' ('\u0031') are used as binary digits.

20.7.17 public static int parseInt(String s)
throws NumberFormatException

The argument is interpreted as representing a signed decimal integer. The components of the string must all be decimal digits, except that the first character may be '-' ('\u002d') to indicate a negative value. The resulting integer value is returned, exactly as if the argument and the radix 10 were given as arguments to the parseInt method that takes two arguments (§20.7.18).

20.7.18 public static int parseInt(String s, int radix)
throws NumberFormatException

The first argument is interpreted as representing a signed integer in the radix specified by the second argument. The components of the string must all be digits of the specified radix (as determined by whether Character.digit (§20.5.23) returns a nonnegative value), except that the first character may be '-' ('\u002d') to indicate a negative value. The resulting integer value is returned.

An exception of type NumberFormatException is thrown if any of the following situations occurs:

• The first argument is null or is a string of length zero.
• The radix is either smaller than Character.MIN_RADIX (§20.5.3) or larger than Character.MAX_RADIX (§20.5.4).
• Any character of the string is not a digit of the specified radix, except that the first character may be a minus sign '-' ('\u002d') provided that the string is longer than length 1.
• The integer value represented by the string is not a value of type int.

parseInt("0", 10) returns 0
parseInt("473", 10) returns 473
parseInt("-0", 10) returns 0
parseInt("-FF", 16) returns -255
parseInt("1100110", 2) returns 102
parseInt("2147483647", 10) returns 2147483647
parseInt("-2147483648", 10) returns -2147483648
parseInt("2147483648", 10) throws a NumberFormatException
parseInt("99", 8) throws a NumberFormatException
parseInt("Kona", 10) throws a NumberFormatException
parseInt("Kona", 27) returns 411787

20.7.19 public static Integer valueOf(String s)
throws NumberFormatException

The argument is interpreted as representing a signed decimal integer, exactly as if the argument were given to the parseInt method that takes one argument (§20.7.17). The result is an Integer object that represents the integer value specified by the string.

In other words, this method returns an Integer object equal to the value of:

new Integer(Integer.parseInt(s))

20.7.20 public static Integer valueOf(String s, int radix)
throws NumberFormatException

The first argument is interpreted as representing a signed integer in the radix specified by the second argument, exactly as if the arguments were given to the parseInt method that takes two arguments (§20.7.18). The result is an Integer object that represents the integer value specified by the string.

In other words, this method returns an Integer object equal to the value of:

new Integer(Integer.parseInt(s, radix))

20.7.21 public static Integer getInteger(String nm)

The first argument is treated as the name of a system property to be obtained as if by the method System.getProperty (§20.18.9). The string value of this property is then interpreted as an integer value and an Integer object representing this value is returned. If there is no property of the specified name, or if the property does not have the correct numeric format, then null is returned.

In other words, this method returns an Integer object equal to the value of:

getInteger(nm, null)

20.7.22 public static Integer getInteger(String nm, int val)

The first argument is treated as the name of a system property to be obtained as if by the method System.getProperty (§20.18.9). The string value of this property is then interpreted as an integer value and an Integer object representing this value is returned. If the property does not have the correct numeric format, then an Integer object that represents the value of the second argument is returned.

In other words, this method returns an Integer object equal to the value of:

getInteger(nm, new Integer(val))

Integer result = getInteger(nm, null);
return (result == null) ? new Integer(val) : result;

20.7.23 public static Integer getInteger(String nm, Integer val)

The first argument is treated as the name of a system property to be obtained as if by the method System.getProperty (§20.18.9). The string value of this property is then interpreted as an integer value and an Integer object representing this value is returned.

• If the property value begins with the two ASCII characters 0x or the ASCII character #, not followed by a minus sign, then the rest of it is parsed as a hexadecimal integer exactly as for the method Integer.valueOf (§20.7.20) with radix 16.
• If the property value begins with the ASCII character 0 followed by another character, it is parsed as an octal integer exactly as for the method Integer.valueOf (§20.7.20) with radix 8.
• Otherwise, the property value is parsed as a decimal integer exactly as for the method Integer.valueOf (§20.7.20) with radix 10.

20.8 The Class java.lang.Long

public final class Long extends Number {
	public static final long MIN_VALUE = 0x8000000000000000L;
	public static final long MAX_VALUE = 0x7fffffffffffffffL;
	public Long(long value);
	public Long(String s)

		throws NumberFormatException;
	public String toString();
	public boolean equals(Object obj);
	public int hashCode();
	public int intValue();
	public long longValue();
	public float floatValue();
	public double doubleValue();
	public static String toString(long i);
	public static String toString(long i, int radix);
	public static String toHexString(long i);
	public static String toOctalString(long i);
	public static String toBinaryString(long i);
	public static long parseLong(String s)

		throws NumberFormatException;
	public static long parseLong(String s, int radix)

		throws NumberFormatException;
	public static Long valueOf(String s)

		throws NumberFormatException;
	public static Long valueOf(String s, int radix)

		throws NumberFormatException;
	public static Long getLong(String nm);
	public static Long getLong(String nm, long val);
	public static Long getLong(String nm, Long val);
}

20.8.1 public static final long MIN_VALUE = 0x8000000000000000L;

The constant value of this field is the lowest value of type long.

20.8.2 public static final long MAX_VALUE = 0x7fffffffffffffffL;

The constant value of this field is the highest value of type long.

20.8.3 public Long(long value)

This constructor initializes a newly created Long object so that it represents the primitive value that is the argument.

20.8.4 public Long(String s) throws NumberFormatException

This constructor initializes a newly created Long object so that it represents the integer represented by the string in decimal form. The string is converted to a long value in exactly the manner used by the parseLong method (§20.8.17) for radix 10.

20.8.5 public String toString()

The long integer value represented by this Long object is converted to signed decimal representation and returned as a string, exactly as if the integer value were given as an argument to the toString method that takes one argument (§20.7.12).

Overrides the toString method of Object (§20.1.2).

20.8.6 public boolean equals(Object obj)

The result is true if and only if the argument is not null and is a Long object that represents the same long value as this Long object.

Overrides the equals method of Object (§20.1.3).

20.8.7 public int hashCode()

The result is the exclusive OR of the two halves of the primitive long value represented by this Long object. That is, the hashcode is the value of the expression:

(int)(this.longValue()^(this.longValue()>>>32))

20.8.8 public int intValue()

The long value represented by this Long object is converted (§5.1.3) to type int and the result of the conversion is returned.

Overrides the intValue method of Number (§20.6.1).

20.8.9 public long longValue()

The long value represented by this Long object is returned.

Overrides the longValue method of Number (§20.6.2).

20.8.10 public float floatValue()

The long value represented by this Long object is converted (§5.1.2) to type float and the result of the conversion is returned.

Overrides the floatValue method of Number (§20.6.3).

20.8.11 public double doubleValue()

The long value represented by this Long object is converted (§5.1.2) to type double and the result of the conversion is returned.

Overrides the doubleValue method of Number (§20.6.4).

20.8.12 public static String toString(long i)

The argument is converted to signed decimal representation and returned as a string, exactly as if the argument and the radix 10 were given as arguments to the toString method that takes two arguments (§20.8.13).

20.8.13 public static String toString(long i, int radix)

The first argument is converted to a signed representation in the radix specified by the second argument; this representation is returned as a string.

If the radix is smaller than Character.MIN_RADIX (§20.5.3) or larger than Character.MAX_RADIX (§20.5.4), then the value 10 is used instead.

If the first argument is negative, the first character of the result will be the character '-' ('\u002d'). If the first argument is not negative, no sign character appears in the result.

The remaining characters of the result represent the magnitude of the first argument. If the magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the magnitude will not be the zero character. The following ASCII characters are used as digits:

0123456789abcdefghijklmnopqrstuvwxyz

Long.toString(n, 16).toUpperCase()

20.8.14 public static String toHexString(long i)

The argument is converted to an unsigned representation in hexadecimal radix (base 16); this representation is returned as a string.

The result represents the unsigned magnitude of the argument. This equals the argument plus if the argument is negative; otherwise, it equals the argument.

If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The following characters are used as hexadecimal digits:

0123456789abcdef

Long.toHexString(n).toUpperCase()

20.8.15 public static String toOctalString(long i)

The argument is converted to an unsigned representation in octal radix (base 8); this representation is returned as a string.

The result represents the unsigned magnitude of the argument. This equals the argument plus if the argument is negative; otherwise, it equals the argument.

If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The following characters are used as octal digits:

01234567

20.8.16 public static String toBinaryString(long i)

The argument is converted to an unsigned representation in binary radix (base 2); this representation is returned as a string.

The result represents the unsigned magnitude of the argument. This equals the argument plus if the argument is negative; otherwise, it equals the argument.

If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The characters '0' ('\u0030') and '1' ('\u0031') are used as binary digits.

20.8.17 public static long parseLong(String s)
throws NumberFormatException

The argument is interpreted as representing a signed decimal integer. The components of the string must all be decimal digits, except that the first character may be '-' ('\u002d') to indicate a negative value. The resulting long value is returned, exactly as if the argument and the radix 10 were given as arguments to the parseLong method that takes two arguments (§20.8.18).

Note that neither L nor l is permitted to appear at the end of the string as a type indicator, as would be permitted in Java source code (§3.10.1).

20.8.18 public static long parseLong(String s, int radix)
throws NumberFormatException

The first argument is interpreted as representing a signed integer in the radix specified by the second argument. The components of the string must all be digits of the specified radix (as determined by whether Character.digit (§20.5.23) returns a nonnegative value), except that the first character may be '-' ('\u002d') to indicate a negative value. The resulting long value is returned.

Note that neither L nor l is permitted to appear at the end of the string as a type indicator, as would be permitted in Java source code (§3.10.1)-except that either L or l may appear as a digit for a radix greater than 22.

An exception of type NumberFormatException is thrown if any of the following situations occurs:

• The first argument is null or is a string of length zero.
• The radix is either smaller than Character.MIN_RADIX (§20.5.3) or larger than Character.MAX_RADIX (§20.5.4).
• The first character of the string is not a digit of the specified radix and is not a minus sign '-' ('\u002d').
• The first character of the string is a minus sign and the string is of length 1.
• Any character of the string after the first is not a digit of the specified radix.
• The integer value represented by the string cannot be represented as a value of type long.

parseLong("0", 10) returns 0L
parseLong("473", 10) returns 473L
parseLong("-0", 10) returns 0L
parseLong("-FF", 16) returns -255L
parseLong("1100110", 2) returns 102L
parseLong("99", 8) throws a NumberFormatException
parseLong("Hazelnut", 10) throws a NumberFormatException
parseLong("Hazelnut", 36) returns 1356099454469L

20.8.19 public static Long valueOf(String s)
throws NumberFormatException

The argument is interpreted as representing a signed decimal integer, exactly as if the argument were given to the parseLong method that takes one argument (§20.8.17). The result is a Long object that represents the integer value specified by the string.

In other words, this method returns a Long object equal to the value of:

new Long(Long.parseLong(s))

20.8.20 public static Long valueOf(String s, int radix)
throws NumberFormatException

The first argument is interpreted as representing a signed integer in the radix specified by the second argument, exactly as if the arguments were given to the parseLong method that takes two arguments (§20.8.18). The result is a Long object that represents the integer value specified by the string.

In other words, this method returns a Long object equal to the value of:

new Long(Long.parseLong(s, radix))

20.8.21 public static Long getLong(String nm)

The first argument is treated as the name of a system property to be obtained as if by the method System.getProperty (§20.18.9). The string value of this property is then interpreted as an integer value and a Long object representing this value is returned. If there is no property of the specified name, or if the property does not have the correct numeric format, then null is returned.

In other words, this method returns a Long object equal to the value of:

getLong(nm, null)

20.8.22 public static Long getLong(String nm, long val)

The first argument is treated as the name of a system property to be obtained as if by the method System.getProperty (§20.18.9). The string value of this property is then interpreted as an integer value and a Long object representing this value is returned. If there is no property of the specified name, or if the property does not have the correct numeric format, then a Long object that represents the value of the second argument is returned.

In other words, this method returns a Long object equal to the value of:

getLong(nm, new Long(val))

Long result = getLong(nm, null);
return (result == null) ? new Long(val) : result;

20.8.23 public static Long getLong(String nm, Long val)

The first argument is treated as the name of a system property to be obtained as if by the method System.getProperty (§20.18.9). The string value of this property is then interpreted as an integer value and a Long object representing this value is returned.

• If the property value begins with the two ASCII characters 0x or the ASCII character #, not followed by a minus sign, then the rest of it is parsed as a hexadecimal integer exactly as for the method Long.valueOf (§20.7.20) with radix 16.

• If the property value begins with the character 0 followed by another character, it is parsed as an octal integer exactly as for the method Long.valueOf (§20.7.20) with radix 8.
• Otherwise the property value is parsed as a decimal integer exactly as for the method Long.valueOf (§20.7.20) with radix 10.

The second argument serves as a default value. If there is no property of the specified name, or if the property does not have the correct numeric format, then the second argument is returned.

20.9 The Class java.lang.Float

public final class Float extends Number {
	public static final float MIN_VALUE = 1.4e-45f;
	public static final float MAX_VALUE = 3.4028235e+38f;
	public static final float NEGATIVE_INFINITY = -1.0f/0.0f;
	public static final float POSITIVE_INFINITY = 1.0f/0.0f;
	public static final float NaN = 0.0f/0.0f;
	public Float(float value);
	public Float(double value);
	public Float(String s)
		throws NumberFormatException;
	public String toString();
	public boolean equals(Object obj);
	public int hashCode();
	public int intValue();
	public long longValue();
	public float floatValue();
	public double doubleValue();
	public static String toString(float f);
	public static Float valueOf(String s)
		throws NullPointerException, NumberFormatException;
	public boolean isNaN();
	public static boolean isNaN(float v);
	public boolean isInfinite();
	public static boolean isInfinite(float v);
	public static int floatToIntBits(float value);
	public static float intBitsToFloat(int bits);
}

20.9.1 public static final float MIN_VALUE = 1.4e-45f;

The constant value of this field is the smallest positive nonzero value of type float. It is equal to the value returned by Float.intBitsToFloat(0x1).

20.9.2 public static final float MAX_VALUE = 3.4028235e+38f;

The constant value of this field is the largest positive finite value of type float. It is equal to the value returned by Float.intBitsToFloat(0x7f7fffff).

20.9.3 public static final float NEGATIVE_INFINITY =
-1.0f/0.0f;

The constant value of this field is the negative infinity of type float. It is equal to the value returned by Float.intBitsToFloat(0xff800000).

20.9.4 public static final float POSITIVE_INFINITY =
1.0f/0.0f;

The constant value of this field is the positive infinity of type float. It is equal to the value returned by Float.intBitsToFloat(0x7f800000).

20.9.5 public static final float NaN = 0.0f/0.0f;

The constant value of this field is the Not-a-Number value of type float. It is equal to the value returned by Float.intBitsToFloat(0x7fc00000).

20.9.6 public Float(float value)

This constructor initializes a newly created Float object so that it represents the primitive value that is the argument.

20.9.7 public Float(double value)

This constructor initializes a newly created Float object so that it represents the result of narrowing (§5.1.3) the argument from type double to type float.

20.9.8 public Float(String s) throws NumberFormatException

This constructor initializes a newly created Float object so that it represents the floating-point value of type float represented by the string. The string is converted to a float value in exactly the manner used by the valueOf method (§20.9.17).

20.9.9 public String toString()

The primitive float value represented by this Float object is converted to a string exactly as if by the method toString of one argument (§20.9.16).

Overrides the toString method of Object (§20.1.2).

20.9.10 public boolean equals(Object obj)

The result is true if and only if the argument is not null and is a Float object that represents the same float value as this Float object. For this purpose, two float values are considered to be the same if and only if the method floatToIntBits (§20.9.22) returns the same int value when applied to each. Note that even though the == operator returns false if both operands are NaN, this equals method will return true if this Float object and the argument are both Float objects that represent NaN. On the other hand, even though the == operator returns true if one operand is positive zero and the other is negative zero, this equals method will return false if this Float object and the argument represent zeroes of different sign. This definition allows hashtables to operate properly.

Overrides the equals method of Object (§20.1.3).

20.9.11 public int hashCode()

The result is the integer bit representation, exactly as produced by the method floatToIntBits (§20.9.22), of the primitive float value represented by this Float object.

Overrides the hashCode method of Object (§20.1.4).

20.9.12 public int intValue()

The float value represented by this Float object is converted (§5.1.3) to type int and the result of the conversion is returned.

Overrides the intValue method of Number (§20.6.1).

20.9.13 public long longValue()

The float value represented by this Float object is converted (§5.1.3) to type long and the result of the conversion is returned.

Overrides the longValue method of Number (§20.6.2).

20.9.14 public float floatValue()

The float value represented by this Float object is returned.

Overrides the floatValue method of Number (§20.6.3).

20.9.15 public double doubleValue()

The float value represented by this Float object is converted (§5.1.2) to type double and the result of the conversion is returned.

Overrides the doubleValue method of Number (§20.6.4).

20.9.16 public static String toString(float f)

The argument is converted to a readable string format as follows. All characters and characters in strings mentioned below are ASCII characters.

• If the argument is NaN, the result is the string "NaN".
• Otherwise, the result is a string that represents the sign and magnitude (absolute value) of the argument. If the sign is negative, the first character of the result is '-' ('\u002d'); if the sign is positive, no sign character appears in the result. As for the magnitude m:
  • If m is infinity, it is represented by the characters "Infinity"; thus, positive infinity produces the result "Infinity" and negative infinity produces the result "-Infinity".
  • If m is zero, it is represented by the characters "0.0"; thus, negative zero produces the result "-0.0" and positive zero produces the result "0.0".
  • If m is greater than or equal to but less than , then it is represented as the integer part of m, in decimal form with no leading zeroes, followed by '.' (\u002E), followed by one or more decimal digits representing the fractional part of m.
  • If m is less than or not less than , then it is represented in so-called "computerized scientific notation." Let n be the unique integer such that ; then let a be the mathematically exact quotient of m and so that . The magnitude is then represented as the integer part of a, as a single decimal digit, followed by '.' (\u002E), followed by decimal digits representing the fractional part of a, followed by the letter 'E' (\u0045), followed by a representation of n as a decimal integer, as produced by the method Integer.toString of one argument (§20.7.12).

[This specification for the method toString is scheduled for introduction in Java version 1.1. In previous versions of Java, this method produces Inf instead of Infinity for infinite values. Also, it renders finite values in the same form as the %g format of the printf function in the C programming language, which can lose precision because it produces at most six digits after the decimal point.]

20.9.17 public static Float valueOf(String s)
throws NullPointerException, NumberFormatException

The string s is interpreted as the representation of a floating-point value and a Float object representing that value is created and returned.

If s is null, then a NullPointerException is thrown.

Leading and trailing whitespace (§20.5.19) characters in s are ignored. The rest of s should constitute a FloatValue as described by the lexical syntax rules:

FloatValue:

	Signopt Digits . Digitsopt ExponentPartopt

	Signopt . Digits ExponentPartopt

Note that neither F nor f is permitted to appear in s as a type indicator, as would be permitted in Java source code (§3.10.1).

20.9.18 public boolean isNaN()

The result is true if and only if the value represented by this Float object is NaN.

20.9.19 public static boolean isNaN(float v)

The result is true if and only if the value of the argument is NaN.

20.9.20 public boolean isInfinite()

The result is true if and only if the value represented by this Float object is positive infinity or negative infinity.

20.9.21 public static boolean isInfinite(float v)

The result is true if and only if the value of the argument is positive infinity or negative infinity.

20.9.22 public static int floatToIntBits(float value)

The result is a representation of the floating-point argument according to the IEEE 754 floating-point "single format" bit layout:

• Bit 31 (the bit that is selected by the mask 0x80000000) represents the sign of the floating-point number.
• Bits 30-23 (the bits that are selected by the mask 0x7f800000) represent the exponent.
• Bits 22-0 (the bits that are selected by the mask 0x007fffff) represent the significand (sometimes called the mantissa) of the floating-point number.
• If the argument is positive infinity, the result will be 0x7f800000.
• If the argument is negative infinity, the result will be 0xff800000.
• If the argument is NaN, the result will be 0x7fc00000.

20.9.23 public static float intBitsToFloat(int bits)

The argument is considered to be a representation of a floating-point value according to the IEEE 754 floating-point "single format" bit layout. That floating-point value is returned as the result.

• If the argument is 0x7f800000, the result will be positive infinity.
• If the argument is 0xff800000, the result will be negative infinity.
• If the argument is any value in the range 0x7f800001 through 0x7fffffff or in the range 0xff800001 through 0xffffffff, the result will be NaN. (All IEEE 754 NaN values are, in effect, lumped together by the Java language into a single value called NaN.)
• In all other cases, let s, e, and m be three values that can be computed from the argument:

int s = ((bits >> 31) == 0) ? 1 : -1;
int e = ((bits >> 23) & 0xff);
int m = (e == 0) ?
		(bits & 0x7fffff) << 1 :
		(bits & 0x7fffff) | 0x800000;

20.10 The Class java.lang.Double

public final class Double extends Number {
	public static final double MIN_VALUE =

			5e-324;
	public static final double MAX_VALUE =
		      1.7976931348623157e+308;
	public static final double NEGATIVE_INFINITY = -1.0/0.0;
	public static final double POSITIVE_INFINITY = 1.0/0.0;
	public static final double NaN = 0.0/0.0;
	public Double(double value);
	public Double(String s)

		throws NumberFormatException;
	public String toString();
	public boolean equals(Object obj);
	public int hashCode();
	public int intValue();
	public long longValue();
	public float floatValue();
	public double doubleValue();
	public static String toString(double d);
	public static Double valueOf(String s)

		throws NullPointerException, NumberFormatException;
	public boolean isNaN();
	public static boolean isNaN(double v);
	public boolean isInfinite();
	public static boolean isInfinite(double v);
	public static long doubleToLongBits(double value);
	public static double longBitsToDouble(long bits);
}

20.10.1 public static final double MIN_VALUE = 5e-324;

The constant value of this field is the smallest positive nonzero value of type double. It is equal to the value returned by Double.longBitsToDouble(0x1L).

20.10.2 public static final double MAX_VALUE = 1.7976931348623157e+308;

The constant value of this field is the largest positive finite value of type double. It is equal to the returned by:

Double.longBitsToDouble(0x7fefffffffffffffL)

20.10.3 public static final double NEGATIVE_INFINITY = -1.0/0.0;

The constant value of this field is the negative infinity of type double. It is equal to the value returned by Double.longBitsToDouble(0xfff0000000000000L).

20.10.4 public static final double POSITIVE_INFINITY = 1.0/0.0;

The constant value of this field is the positive infinity of type double. It is equal to the value returned by Double.longBitsToDouble(0x7ff0000000000000L).

20.10.5 public static final double NaN = 0.0/0.0;

The constant value of this field is the Not-a-Number of type double. It is equal to the value returned by Double.longBitsToDouble(0x7ff8000000000000L).

20.10.6 public Double(double value)

This constructor initializes a newly created Double object so that it represents the primitive value that is the argument.

20.10.7 public Double(String s)
throws NumberFormatException

This constructor initializes a newly created Double object so that it represents the floating-point value of type double represented by the string. The string is converted to a double value in exactly the manner used by the valueOf method (§20.9.17).

20.10.8 public String toString()

The primitive double value represented by this Double object is converted to a string exactly as if by the method toString of one argument (§20.10.15).

Overrides the toString method of Object (§20.1.2).

20.10.9 public boolean equals(Object obj)

The result is true if and only if the argument is not null and is a Double object that represents the same double value as this Double object. For this purpose, two double values are considered to be the same if and only if the method doubleToLongBits (§20.10.21) returns the same long value when applied to each. Note that even though the == operator returns false if both operands are NaN, this equals method will return true if this Double object and the argument are both Double objects that represent NaN. On the other hand, even though the == operator returns true if one operand is positive zero and the other is negative zero, this equals method will return false if this Double object and the argument represent zeroes of different sign. This allows hashtables to operate properly.

Overrides the equals method of Object (§20.1.3).

20.10.10 public int hashCode()

The result is the exclusive OR of the two halves of the long integer bit representation, exactly as produced by the method doubleToLongBits (§20.10.21), of the primitive double value represented by this Double object. That is, the hashcode is the value of the expression:

(int)(v^(v>>>32))

long v = Double.doubleToLongBits(this.longValue());

20.10.11 public int intValue()

The double value represented by this Double object is converted (§5.1.3) to type int and the result of the conversion is returned.

Overrides the intValue method of Number (§20.6.1).

20.10.12 public long longValue()

The double value represented by this Double object is converted (§5.1.3) to type long and the result of the conversion is returned.

Overrides the longValue method of Number (§20.6.2).

20.10.13 public float floatValue()

The double value represented by this Double object is converted (§5.1.3) to type float and the result of the conversion is returned.

Overrides the floatValue method of Number (§20.6.3).

20.10.14 public double doubleValue()

The double value represented by this Double object is returned.

Overrides the doubleValue method of Number (§20.6.4).

20.10.15 public static String toString(double d)

The argument is converted to a readable string format as follows. All characters mentioned below are ASCII characters.

• If the argument is NaN, the result is the string "NaN".
• Otherwise, the result is a string that represents the sign and magnitude (absolute value) of the argument. If the sign is negative, the first character of the result is '-' ('\u002d'); if the sign is positive, no sign character appears in the result. As for the magnitude m:
  • If m is infinity, it is represented by the characters "Infinity"; thus, positive infinity produces the result "Infinity" and negative infinity produces the result "-Infinity".
  • If m is zero, it is represented by the characters "0.0"; thus, negative zero produces the result "-0.0" and positive zero produces the result "0.0".
  • If m is greater than or equal to but less than , then it is represented as the integer part of m, in decimal form with no leading zeroes, followed by '.' (\u002E), followed by one or more decimal digits representing the fractional part of m.
  • If m is less than or not less than , then it is represented in so-called "computerized scientific notation." Let n be the unique integer such that ; then let a be the mathematically exact quotient of m and so that . The magnitude is then represented as the integer part of a, as a single decimal digit, followed by '.' (\u002E), followed by decimal digits representing the fractional part of a, followed by the letter 'E' (\u0045), followed by a representation of n as a decimal integer, as produced by the method Integer.toString of one argument (§20.7.12).

[This specification for the method toString is scheduled for introduction in Java version 1.1. In previous versions of Java, this method produces Inf instead of Infinity for infinite values. Also, it rendered finite values in the same form as the %g format of the printf function in the C programming language, which can lose information because it produces at most six digits after the decimal point.]

20.10.16 public static Double valueOf(String s)
throws NullPointerException, NumberFormatException

The string s is interpreted as the representation of a floating-point value and a Double object representing that value is created and returned.

If s is null, then a NullPointerException is thrown.

Leading and trailing whitespace (§20.5.19) characters in s are ignored. The rest of s should constitute a FloatValue as described by the lexical syntax rule:

FloatValue:

	Signopt Digits . Digitsopt ExponentPartopt

	Signopt . Digits ExponentPartopt

Note that neither D nor d is permitted to appear in s as a type indicator, as would be permitted in Java source code (§3.10.1).

20.10.17 public boolean isNaN()

The result is true if and only if the value represented by this Double object is NaN.

20.10.18 public static boolean isNaN(double v)

The result is true if and only if the value of the argument is NaN.

20.10.19 public boolean isInfinite()

The result is true if and only if the value represented by this Double object is positive infinity or negative infinity.

20.10.20 public static boolean isInfinite(double v)

The result is true if and only if the value of the argument is positive infinity or negative infinity.

20.10.21 public static long doubleToLongBits(double value)

The result is a representation of the floating-point argument according to the IEEE 754 floating-point "double format" bit layout:

• Bit 63 (the bit that is selected by the mask 0x8000000000000000L) represents the sign of the floating-point number.
• Bits 62-52 (the bits that are selected by the mask 0x7ff0000000000000L) represent the exponent.
• Bits 51-0 (the bits that are selected by the mask 0x000fffffffffffffL) represent the significand (sometimes called the mantissa) of the floating-point number.
• If the argument is positive infinity, the result will be 0x7ff0000000000000L.
• If the argument is negative infinity, the result will be 0xfff0000000000000L.
• If the argument is NaN, the result will be 0x7ff8000000000000L.

20.10.22 public static double longBitsToDouble(long bits)

The argument is considered to be a representation of a floating-point value according to the IEEE 754 floating-point "double format" bit layout. That floating-point value is returned as the result.

• If the argument is 0x7f80000000000000L, the result will be positive infinity.
• If the argument is 0xff80000000000000L, the result will be negative infinity.
• If the argument is any value in the range 0x7ff0000000000001L through 0x7fffffffffffffffL or in the range 0xfff0000000000001L through 0xffffffffffffffffL, the result will be NaN. (All IEEE 754 NaN values are, in effect, lumped together by the Java language into a single value called NaN.)
• In all other cases, let s, e, and m be three values that can be computed from the argument:

int s = ((bits >> 63) == 0) ? 1 : -1;
int e = (int)((bits >> 52) & 0x7ffL);
long m = (e == 0) ?
		(bits & 0xfffffffffffffL) << 1 :
		(bits & 0xfffffffffffffL) | 0x10000000000000L;

20.11 The Class java.lang.Math

public final class Math {
	public static final double E = 2.7182818284590452354;
	public static final double PI = 3.14159265358979323846;
	public static double sin(double a);
	public static double cos(double a);
	public static double tan(double a);
	public static double asin(double a);
	public static double acos(double a);
	public static double atan(double a);
	public static double atan2(double a, double b);
	public static double exp(double a);
	public static double log(double a);
	public static double sqrt(double a);
	public static double pow(double a, double b);
	public static double IEEEremainder(double f1, double f2);
	public static double ceil(double a);
	public static double floor(double a);
	public static double rint(double a);
	public static int round(float a);
	public static long round(double a);
	public static double random();
	public static int abs(int a);
	public static long abs(long a);
	public static float abs(float a);
	public static double abs(double a);
	public static int min(int a, int b);
	public static long min(long a, long b);
	public static float min(float a, float b);
	public static double min(double a, double b);
	public static int max(int a, int b);
	public static long max(long a, long b);
	public static float max(float a, float b);
	public static double max(double a, double b);
}

The network library may be found at http://netlib.att.com on the World Wide Web; then perform a keyword search for fdlibm. The library may also be retrieved by E-mail; to begin the process, send a message containing the line:

send index from fdlibm

A complete and self-contained description of the algorithms to be used for these functions will be provided in a future version of this specification. It is also anticipated that the algorithms will be coded in Java to provide a reference implementation that is not tied to fdlibm.

20.11.1 public static final double E = 2.7182818284590452354;

The constant value of this field is the double value that is closer than any other to e, the base of the natural logarithms.

20.11.2 public static final double PI = 3.14159265358979323846;

The constant value of this field is the double value that is closer than any other to , the ratio of the circumference of a circle to its diameter.

20.11.3 public static double sin(double a)

This method computes an approximation to the sine of the argument, using the sin algorithm as published in fdlibm (see the introduction to this section).

Special cases:

• If the argument is NaN or an infinity, then the result is NaN.
• If the argument is positive zero, then the result is positive zero; if the argument is negative zero, then the result is negative zero.

20.11.4 public static double cos(double a)

This method computes an approximation to the cosine of the argument, using the cos algorithm as published in fdlibm (see the introduction to this section).

Special case:

• If the argument is NaN or an infinity, then the result is NaN.

20.11.5 public static double tan(double a)

This method computes an approximation to the tangent of the argument, using the tan algorithm as published in fdlibm (see the introduction to this section).

Special cases:

• If the argument is NaN or an infinity, then the result is NaN.
• If the argument is positive zero, then the result is positive zero; if the argument is negative zero, then the result is negative zero.

20.11.6 public static double asin(double a)

This method computes an approximation to the arc sine of the argument, using the asin algorithm as published in fdlibm (see the introduction to this section).

Special cases:

• If the argument is NaN or its absolute value is greater than 1, then the result is NaN.
• If the argument is positive zero, then the result is positive zero; if the argument is negative zero, then the result is negative zero.

20.11.7 public static double acos(double a)

This method computes an approximation to the arc cosine of the argument, using the acos algorithm as published in fdlibm (see the introduction to this section).

Special case:

• If the argument is NaN or its absolute value is greater than 1, then the result is NaN.

20.11.8 public static double atan(double a)

This method computes an approximation to the arc tangent of the argument, using the atan algorithm as published in fdlibm (see the introduction to this section).

Special cases:

• If the argument is NaN, then the result is NaN.
• If the argument is positive zero, then the result is positive zero; if the argument is negative zero, then the result is negative zero.

20.11.9 public static double atan2(double y, double x)

This method computes an approximation to the arc tangent of the quotient of the arguments, using the atan2 algorithm as published in fdlibm (see the introduction to this section).

Special cases:

• If either argument is NaN, then the result is NaN.
• If the first argument is positive zero and the second argument is positive, or the first argument is positive and finite and the second argument is positive infinity, then the result is positive zero.
• If the first argument is negative zero and the second argument is positive, or the first argument is negative and finite and the second argument is positive infinity, then the result is negative zero.
• If the first argument is positive zero and the second argument is negative, or the first argument is positive and finite and the second argument is negative infinity, then the result is the double value closest to .
• If the first argument is negative zero and the second argument is negative, or the first argument is negative and finite and the second argument is negative infinity, then the result is the double value closest to .
• If the first argument is positive and the second argument is positive zero or negative zero, or the first argument is positive infinity and the second argument is finite, then the result is the double value closest to .
• If the first argument is negative and the second argument is positive zero or negative zero, or the first argument is negative infinity and the second argument is finite, then the result is the double value closest to .
• If both arguments are positive infinity, then the result is the double value closest to .
• If the first argument is positive infinity and the second argument is negative infinity, then the result is the double value closest to .
• If the first argument is negative infinity and the second argument is positive infinity, then the result is the double value closest to .
• If both arguments are negative infinity, then the result is the double value closest to .

20.11.10 public static double exp(double a)

This method computes an approximation to the exponential function of the argument (e raised to the power of the argument, where e is the base of the natural logarithms (§20.11.1)), using the exp algorithm as published in fdlibm (see the introduction to this section).

Special cases:

• If the argument is NaN, then the result is NaN.
• If the argument is positive infinity, then the result is positive infinity.
• If the argument is negative infinity, then the result is positive zero.

20.11.11 public static double log(double a)

This method computes an approximation to the natural logarithm of the argument, using the log algorithm as published in fdlibm (see the introduction to this section).

Special cases:

• If the argument is NaN or less than zero, then the result is NaN.
• If the argument is positive infinity, then the result is positive infinity.
• If the argument is positive zero or negative zero, then the result is negative infinity.

20.11.12 public static double sqrt(double a)

This method computes an approximation to the square root of the argument.

Special cases:

• If the argument is NaN or less than zero, then the result is NaN.
• If the argument is positive infinity, then the result is positive infinity.
• If the argument is positive zero or negative zero, then the result is the same as the argument.

20.11.13 public static double pow(double a, double b)

This method computes an approximation to the mathematical operation of raising the first argument to the power of the second argument, using the pow algorithm as published in fdlibm (see the introduction to this section).

Special cases:

• If the second argument is positive or negative zero, then the result is 1.0.
• If the second argument is 1.0, then the result is the same as the first argument.
• If the second argument is NaN, then the result is NaN.
• If the first argument is NaN and the second argument is nonzero, then the result is NaN.
• If the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or the absolute value of the first argument is less than 1 and the second argument is negative infinity, then the result is positive infinity.
• If the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or the absolute value of the first argument is less than 1 and the second argument is positive infinity, then the result is positive zero.
• If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN.
• If the first argument is positive zero and the second argument is greater than zero, or the first argument is positive infinity and the second argument is less than zero, then the result is positive zero.
• If the first argument is positive zero and the second argument is less than zero, or the first argument is positive infinity and the second argument is greater than zero, then the result is positive infinity.
• If the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or the first argument is negative infinity and the second argument is less than zero but not a finite odd integer, then the result is positive zero.
• If the first argument is negative zero and the second argument is a positive finite odd integer, or the first argument is negative infinity and the second argument is a negative finite odd integer, then the result is negative zero.
• If the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer, then the result is positive infinity.
• If the first argument is negative zero and the second argument is a negative finite odd integer, or the first argument is negative infinity and the second argument is a positive finite odd integer, then the result is negative infinity.
• If the first argument is less than zero and the second argument is a finite even integer, then the result is equal to the result of raising the absolute value of the first argument to the power of the second argument.
• If the first argument is less than zero and the second argument is a finite odd integer, then the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument.
• If the first argument is finite and less than zero and the second argument is finite and not an integer, then the result is NaN.
• If both arguments are integers, then the result is exactly equal to the mathematical result of raising the first argument to the power of the second argument if that result can in fact be represented exactly as a double value.

20.11.14 public static double IEEEremainder(double x, double y)

This method computes the remainder operation on two arguments as prescribed by the IEEE 754 standard: the remainder value is mathematically equal to where is the mathematical integer closest to the exact mathematical value of the quotient ; if two mathematical integers are equally close to then n is the integer that is even. If the remainder is zero, its sign is the same as the sign of the first argument.

Special cases:

• If either argument is NaN, or the first argument is infinite, or the second argument is positive zero or negative zero, then the result is NaN.
• If the first argument is finite and the second argument is infinite, then the result is the same as the first argument.

20.11.15 public static double ceil(double a)

The result is the smallest (closest to negative infinity) double value that is not less than the argument and is equal to a mathematical integer.

Special cases:

• If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
• If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.
• If the argument value is less than zero but greater than -1.0, then the result is negative zero.

20.11.16 public static double floor(double a)

The result is the largest (closest to positive infinity) double value that is not greater than the argument and is equal to a mathematical integer.

Special cases:

• If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
• If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.

20.11.17 public static double rint(double a)

The result is the double value that is closest in value to the argument and is equal to a mathematical integer. If two double values that are mathematical integers are equally close to the value of the argument, the result is the integer value that is even.

Special cases:

• If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
• If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.

20.11.18 public static int round(float a)

The result is rounded to an integer by adding , taking the floor of the result, and casting the result to type int.

In other words, the result is equal to the value of the expression:

(int)Math.floor(a + 0.5f)

• If the argument is NaN, the result is 0.
• If the argument is negative infinity, or indeed any value less than or equal to the value of Integer.MIN_VALUE (§20.7.1), the result is equal to the value of Integer.MIN_VALUE.
• If the argument is positive infinity, or indeed any value greater than or equal to the value of Integer.MAX_VALUE (§20.7.2), the result is equal to the value of Integer.MAX_VALUE.

20.11.19 public static long round(double a)

The result is rounded to an integer by adding , taking the floor of the result, and casting the result to type long.

In other words, the result is equal to the value of the expression:

(long)Math.floor(a + 0.5d)

• If the argument is NaN, the result is 0.
• If the argument is negative infinity, or indeed any value less than or equal to the value of Long.MIN_VALUE (§20.7.1), the result is equal to the value of Long.MIN_VALUE.
• If the argument is positive infinity, or indeed any value greater than or equal to the value of Long.MAX_VALUE (§20.7.2), the result is equal to the value of Long.MAX_VALUE.

20.11.20 public static double random()

The result is a double value with positive sign, greater than or equal to zero but less than 1.0, chosen pseudorandomly with (approximately) uniform distribution from that range.

When this method is first called, it creates a single new pseudorandom-number generator, exactly as if by the expression

new java.util.Random()

This method is properly synchronized to allow correct use by more than one thread. However, if many threads need to generate pseudorandom numbers at a great rate, it may reduce contention for each thread to have its own pseudorandom number generator.

20.11.21 public static int abs(int a)

The result is the absolute value of the argument, if possible.

If the argument is not negative, the argument is returned.

If the argument is negative, the negation of the argument is returned. Note that if the argument is equal to the value of Integer.MIN_VALUE (§20.7.1), the most negative representable int value, the result will be that same negative value.

20.11.22 public static long abs(long a)

The result is the absolute value of the argument, if possible.

If the argument is not negative, the argument is returned.

If the argument is negative, the negation of the argument is returned. Note that if the argument is equal to the value of Long.MIN_VALUE (§20.8.1), the most negative representable long value, the result will be that same negative value.

20.11.23 public static float abs(float a)

The argument is returned with its sign changed to be positive.

Special cases:

• If the argument is positive zero or negative zero, the result is positive zero.
• If the argument is infinite, the result is positive infinity.
• If the argument is NaN, the result is NaN.

Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))

20.11.24 public static double abs(double a)

The argument is returned with its sign changed to be positive.

Special cases:

• If the argument is positive zero or negative zero, the result is positive zero.
• If the argument is infinite, the result is positive infinity.
• If the argument is NaN, the result is NaN.

Double.longBitsToDouble((Double.doubleToLongBits(a)<<1)>>>1)

20.11.25 public static int min(int a, int b)

The result is the smaller of the two arguments-that is, the one closer to the value of Integer.MIN_VALUE (§20.7.1). If the arguments have the same value, the result is that same value.

20.11.26 public static long min(long a, long b)

The result is the smaller of the two arguments-that is, the one closer to the value of Long.MIN_VALUE (§20.8.1). If the arguments have the same value, the result is that same value.

20.11.27 public static float min(float a, float b)

The result is the smaller of the two arguments-that is, the one closer to negative infinity. If the arguments have the same value, the result is that same value.

Special cases:

• If one argument is positive zero and the other is negative zero, the result is negative zero.
• If either argument is NaN, the result is NaN.

20.11.28 public static double min(double a, double b)

The result is the smaller of the two arguments-that is, the one closer to negative infinity. If the arguments have the same value, the result is that same value.

Special cases:

• If one argument is positive zero and the other is negative zero, the result is negative zero.
• If either argument is NaN, the result is NaN.

20.11.29 public static int max(int a, int b)

The result is the larger of the two arguments-that is, the one closer to the value of Integer.MAX_VALUE (§20.7.2). If the arguments have the same value, the result is that same value.

20.11.30 public static long max(long a, long b)

The result is the larger of the two arguments-that is, the one closer to the value of Long.MAX_VALUE (§20.8.2). If the arguments have the same value, the result is that same value.

20.11.31 public static float max(float a, float b)

The result is the larger of the two arguments-that is, the one closer to positive infinity. If the arguments have the same value, the result is that same value.

Special cases:

• If one argument is positive zero and the other is negative zero, the result is positive zero.
• If either argument is NaN, the result is NaN.

20.11.32 public static double max(double a, double b)

The result is the larger of the two arguments-that is, the one closer to positive infinity. If the arguments have the same value, the result is that same value.

Special cases:

• If one argument is positive zero and the other is negative zero, the result is positive zero.
• If either argument is NaN, the result is NaN.

20.12 The Class java.lang.String

The class String has methods for examining individual characters of the sequence, for comparing strings, for searching strings, for extracting substrings, for creating a copy of a string with all characters translated to uppercase or to lowercase, and so on.

public final class String {
	public String();
	public String(String value)
		throws NullPointerException;
	public String(StringBuffer buffer)
		throws NullPointerException;
	public String(char[] value)
		throws NullPointerException;
	public String(char[] value, int offset, int count)
		throws NullPointerException, IndexOutOfBoundsException;
	public String(byte[] ascii, int hibyte)
		throws NullPointerException;
	public String(byte[] ascii, int hibyte,
			int offset, int count)
		throws NullPointerException, IndexOutOfBoundsException;
	public String toString();
	public boolean equals(Object anObject);
	public int hashCode();
	public int length();
	public char charAt(int index);
	public void getChars(int srcBegin, int srcEnd,
			char dst[], int dstBegin)

		throws NullPointerException, IndexOutOfBoundsException;
	public void getBytes(int srcBegin, int srcEnd,
			byte dst[], int dstBegin)
		throws NullPointerException, IndexOutOfBoundsException;
	public char[] toCharArray();
	public boolean equalsIgnoreCase(String anotherString);
	public int compareTo(String anotherString)
		throws NullPointerException;
	public boolean regionMatches(int toffset, String other,

			int ooffset, int len)
		throws NullPointerException;
	public boolean regionMatches(boolean ignoreCase, int toffset,

			String other, int ooffset, int len)
		throws NullPointerException;
	public boolean startsWith(String prefix)
		throws NullPointerException;
	public boolean startsWith(String prefix, int toffset)
		throws NullPointerException;
	public boolean endsWith(String suffix)
		throws NullPointerException;
	public int indexOf(int ch);
	public int indexOf(int ch, int fromIndex);
	public int indexOf(String str)
		throws NullPointerException;
	public int indexOf(String str, int fromIndex)
		throws NullPointerException;
	public int lastIndexOf(int ch);
	public int lastIndexOf(int ch, int fromIndex);
	public int lastIndexOf(String str)
		throws NullPointerException;
	public int lastIndexOf(String str, int fromIndex)
		throws NullPointerException;
	public String substring(int beginIndex);
	public String substring(int beginIndex, int endIndex);
	public String concat(String str)
		throws NullPointerException;
	public String replace(char oldChar, char newChar);
	public String toLowerCase();
	public String toUpperCase();
	public String trim();
	public static String valueOf(Object obj);
	public static String valueOf(char[] data)
		throws NullPointerException;
	public static String valueOf(char[] data,
			int offset, int count)
		throws NullPointerException, IndexOutOfBoundsException;
	public static String valueOf(boolean b);
	public static String valueOf(char c);
	public static String valueOf(int i);
	public static String valueOf(long l);
	public static String valueOf(float f);
	public static String valueOf(double d);
	public String intern();
}

20.12.1 public String()

This constructor initializes a newly created String object so that it represents an empty character sequence.

20.12.2 public String(String value)

This constructor initializes a newly created String object so that it represents the same sequence of characters as the argument; in other words, the newly created string is a copy of the argument string.

20.12.3 public String(StringBuffer buffer)
throws NullPointerException

This constructor initializes a newly created String object so that it represents the sequence of characters that is currently contained in the StringBuffer argument (§20.13). The contents of the string buffer are copied; subsequent modification of the string buffer does not affect the newly created string.

If buffer is null, then a NullPointerException is thrown.

20.12.4 public String(char[] data)
throws NullPointerException

This constructor initializes a newly created String object so that it represents the sequence of characters currently contained in the character array argument. The contents of the character array are copied; subsequent modification of the character array does not affect the newly created string.

If data is null, then a NullPointerException is thrown.

20.12.5 public String(char[] data, int offset, int count)
throws NullPointerException, IndexOutOfBoundsException

This constructor initializes a newly created String object so that it represents the sequence of characters currently contained in a subarray of the character array argument. The offset argument is the index of the first character of the subarray and the count argument specifies the length of the subarray. The contents of the subarray are copied; subsequent modification of the character array does not affect the newly created string.

If data is null, then a NullPointerException is thrown.

If offset is negative, or count is negative, or offset+count is larger than data.length, then an IndexOutOfBoundsException is thrown.

20.12.6 public String(byte[] ascii, int hibyte)
throws NullPointerException

This constructor initializes a newly created String object so that it represents a sequence of characters constructed from an array of 8-bit integer values. Each character c in the result string is constructed from the corresponding element b of the byte array in such a way that:

c == ((hibyte & 0xff) << 8) | (b & 0xff)

20.12.7 public String(byte[] ascii, int hibyte,
int offset, int count)
throws NullPointerException,
IndexOutOfBoundsException

This constructor initializes a newly created String object so that it represents the sequence of characters constructed from a subarray of an array of 8-bit integer values. The offset argument is the index of the first byte of the subarray and the count argument specifies the length of the subarray. Each character c in the result string is constructed from the corresponding element b of the byte subarray in such a way that:

c == ((hibyte & 0xff) << 8) | (b & 0xff)

If offset is negative, or count is negative, or offset+count is larger than ascii.length, then an IndexOutOfBoundsException is thrown.

20.12.8 public String toString()

A reference to this object (which is, after all, already a String) is returned.

Overrides the toString method of Object (§20.1.2).

20.12.9 public boolean equals(Object anObject)

The result is true if and only if the argument is not null and is a String object that represents the same sequence of characters as this String object.

Overrides the equals method of Object (§20.1.3).

See also the methods equalsIgnoreCase (§20.12.16) and compareTo (§20.12.17).

20.12.10 public int hashCode()

The hashcode for a String object is computed in one of two ways, depending on its length. Let n be the length (§20.12.11) of the character sequence and let mean the character with index i.

• If , then the hashcode is computed as
  using int arithmetic.
• If , then the hashcode is computed as
  using int arithmetic, where and , sampling only eight or nine characters of the string.

20.12.11 public int length()

The length of the sequence of characters represented by this String object is returned.

20.12.12 public char charAt(int index)
throws IndexOutOfBoundsException

This method returns the character indicated by the index argument within the sequence of characters represented by this String. The first character of the sequence is at index 0, the next at index 1, and so on, as for array indexing. If the index argument is negative or not less than the length (§20.12.11) of this string, then an IndexOutOfBoundsException is thrown.

20.12.13 public void getChars(int srcBegin, int srcEnd,
char dst[], int dstBegin)
throws NullPointerException,
IndexOutOfBoundsException

Characters are copied from this String object into the destination character array dst. The first character to be copied is at index srcBegin; the last character to be copied is at index srcEnd-1 (thus the total number of characters to be copied is srcEnd-srcBegin). The characters are copied into the subarray of dst starting at index dstBegin and ending at index dstbegin+(srcEnd-srcBegin)-1.

If dst is null, then a NullPointerException is thrown.

An IndexOutOfBoundsException is thrown if any of the following is true:

• srcBegin is negative
• srcBegin is greater than srcEnd
• srcEnd is greater than the length of this String
• dstBegin is negative
• dstBegin+(srcEnd-srcBegin) is larger than dst.length

20.12.14 public void getBytes(int srcBegin, int srcEnd,
byte dst[], int dstBegin)
throws NullPointerException,
IndexOutOfBoundsException

Characters are copied from this String object into the destination byte array dst. Each byte receives only the eight low-order bits of the corresponding character. The eight high-order bits of each character are not copied and do not participate in the transfer in any way. The first character to be copied is at index srcBegin; the last character to be copied is at index srcEnd-1 (thus the total number of characters to be copied is srcEnd-srcBegin). The characters, converted to bytes, are copied into the subarray of dst starting at index dstBegin and ending at index dstbegin+(srcEnd-srcBegin)-1.

If dst is null, then a NullPointerException is thrown.

An IndexOutOfBoundsException is thrown if any of the following is true:

• srcBegin is negative
• srcBegin is greater than srcEnd
• srcEnd is greater than the length of this String
• dstBegin is negative
• dstBegin+(srcEnd-srcBegin) is larger than dst.length

20.12.15 public char[] toCharArray()

A new character array is created and returned. The length of the array is equal to the length (§20.12.11) of this String object. The array is initialized to contain the character sequence represented by this String object.

20.12.16 public boolean equalsIgnoreCase(String anotherString)

The result is true if and only if the argument is not null and is a String object that represents the same sequence of characters as this String object, where case is ignored.

Two characters are considered the same, ignoring case, if at least one of the following is true:

• The two characters are the same (as compared by the == operator).
• Applying the method Character.toUppercase (§20.5.21) to each character produces the same result.
• Applying the method Character.toLowercase (§20.5.20) to each character produces the same result.

See also the method equals (§20.12.9).

20.12.17 public int compareTo(String anotherString)
throws NullPointerException

The character sequence represented by this String object is compared lexicographically to the character sequence represented by the argument string. The result is a negative integer if this String object lexicographically precedes the argument string. The result is a positive integer if this String object lexicographically follows the argument string. The result is zero if the strings are equal; compareTo returns 0 exactly when the equals method (§20.12.9) would return true.

If anotherString is null, then a NullPointerException is thrown.

This is the definition of lexicographic ordering. If two strings are different, then either they have different characters at some index that is a valid index for both strings, or their lengths are different, or both. If they have different characters at one or more index positions, let k be the smallest such index; then the string whose character at position k has the smaller value, as determined by using the < operator, lexicographically precedes the other string. In this case, compareTo returns the difference of the two character values at position k in the two strings- that is, the value:

this.charAt(k)-anotherString.charAt(k)

this.length()-anotherString.length()

20.12.18 public boolean regionMatches(int toffset,
String other, int ooffset, int len)
throws NullPointerException

A substring of this String object is compared to a substring of the argument other. The result is true if these substrings represent identical character sequences. The substring of this String object to be compared begins at index toffset and has length len. The substring of other to be compared begins at index ooffset and has length len. The result is false if and only if at least one of the following is true:

• toffset is negative.
• ooffset is negative.
• toffset+len is greater than the length of this String object.
• ooffset+len is greater than the length of the other argument.
• There is some nonnegative integer k less than len such that: this.charAt(toffset+k) != other.charAt(ooffset+k)

20.12.19 public boolean regionMatches(boolean ignoreCase,
int toffset, String other, int ooffset, int len)
throws NullPointerException

A substring of this String object is compared to a substring of the argument other. The result is true if these substrings represent character sequences that are the same, ignoring case if and only if ignoreCase is true. The substring of this String object to be compared begins at index toffset and has length len. The substring of other to be compared begins at index ooffset and has length len. The result is false if and only if at least one of the following is true:

• toffset is negative.
• ooffset is negative.
• toffset+len is greater than the length of this String object.
• ooffset+len is greater than the length of the other argument.
• There is some nonnegative integer k less than len such that: this.charAt(toffset+k) != other.charAt(ooffset+k)
• ignoreCase is true and there is some nonnegative integer k less than len such that:

Character.toLowerCase(this.charAt(toffset+k)) !=
	Character.toLowerCase(other.charAt(ooffset+k))

and:

Character.toUpperCase(this.charAt(toffset+k)) !=
	Character.toUpperCase(other.charAt(ooffset+k))

20.12.20 public boolean startsWith(String prefix)
throws NullPointerException

The result is true if and only if the character sequence represented by the argument is a prefix of the character sequence represented by this String object.

If prefix is null, a NullPointerException is thrown.

Note that the result will be true if the argument is an empty string or is equal to this String object as determined by the equals method (§20.12.9).

20.12.21 public boolean startsWith(String prefix, int toffset)
throws NullPointerException

The result is true if and only if the character sequence represented by the argument is a prefix of the substring of this String object starting at index toffset.

If prefix is null, then a NullPointerException is thrown.

The result is false if toffset is negative or greater than the length of this String object; otherwise, the result is the same as the result of the expression

this.subString(toffset).startsWith(prefix)

20.12.22 public boolean endsWith(String suffix)
throws NullPointerException

The result is true if and only if the character sequence represented by the argument is a suffix of the character sequence represented by this String object.

If suffix is null, then a NullPointerException is thrown.

Note that the result will be true if the argument is an empty string or is equal to this String object as determined by the equals method (§20.12.9).

20.12.23 public int indexOf(int ch)

If a character with value ch occurs in the character sequence represented by this String object, then the index of the first such occurrence is returned-that is, the smallest value k such that:

this.charAt(k) == ch

20.12.24 public int indexOf(int ch, int fromIndex)

If a character with value ch occurs in the character sequence represented by this String object at an index no smaller than fromIndex, then the index of the first such occurrence is returned-that is, the smallest value k such that:

(this.charAt(k) == ch) && (k >= fromIndex)

There is no restriction on the value of fromIndex. If it is negative, it has the same effect as if it were zero: this entire string may be searched. If it is greater than the length of this string, it has the same effect as if it were equal to the length of this string: -1 is returned.

20.12.25 public int indexOf(String str)
throws NullPointerException

If the string str occurs as a substring of this String object, then the index of the first character of the first such substring is returned-that is, the smallest value k such that:

this.startsWith(str, k)

If str is null, a NullPointerException is thrown.

20.12.26 public int indexOf(String str, int fromIndex)
throws NullPointerException

If the string str occurs as a substring of this String object starting at an index no smaller than fromIndex, then the index of the first character of the first such substring is returned-that is, the smallest value k such that: