/************************************************************************
* *
* java.util *
* *
* Interfaces: *
* Enumeration Observer *
* EventListener *
* *
* #Collection #Map *
* #Comparator #Map.Entry *
* #Iterator #Set *
* #List #SortedMap *
* #ListIterator #SortedSet *
* *
* Classes: *
* BitSet Properties *
* Calendar PropertyResourceBundle *
* Date Random *
* Dictionary ResourceBundle *
* EventObject SimpleTimeZone *
* GregorianCalendar Stack *
* Hashtable StringTokenizer *
* ListResourceBundle TimeZone *
* Locale Vector *
* Observable *
* *
* #AbstractCollection #HashMap *
* #AbstractList #HashSet *
* #AbstractMap #LinkedList *
* #AbstractSequentialList #PropertyPermission *
* #AbstractSet #TreeMap *
* #ArrayList #TreeSet *
* #Arrays #WeakHashMap *
* #Collections *
* *
* Exceptions: *
* EmptyStackException NoSuchElementException *
* MissingResourceException TooManyListenersException *
* *
* #ConcurrentModificationException *
* *
************************************************************************/
package Test.Chris;
import java.util.*;
public class Java_util {
public static void main(String[] args) {
Java_util obj = new Java_util();
obj.exercise();
System.exit(0);
}
public void exercise() {
enumeration();
vector();
stack();
bitset();
hashtable();
observable();
random();
date();
calendar();
dictionary();
eventobject();
gregoriancalendar();
locale();
properties();
propertyresourcebundle();
resourcebundle();
simpletimezone();
stringtokenizer();
timezone();
eventlistener();
abstractcollection();
abstractlist();
abstractmap();
abstractsequentiallist();
abstractset();
arraylist();
arrays();
collections();
hashmap();
hashset();
linkedlist();
propertypermission();
treemap();
treeset();
weakhashmap();
collection();
comparator();
iterator();
list();
listiterator();
map();
map_entry();
set();
sortedmap();
sortedset();
}
class Chris {
int a = 0;
Chris(int i) {
a = i;
}
}
/*********************************************************************
* *
* Enumeration Interface: *
* *
* Desc: Collection of objects that can be retrieved serially *
* *
* Methods: *
* hasMoreElements nextElement *
* *
*********************************************************************/
class ChrisEnumeration implements Enumeration {
int index = 0;
String[] sar;
ChrisEnumeration() {
sar = new String[3];
sar[0] = "abc";
sar[1] = "def";
sar[2] = "ghi";
}
public boolean hasMoreElements() {
return (index < sar.length);
}
public Object nextElement() throws NoSuchElementException {
if (index >= sar.length) throw new NoSuchElementException();
return sar[index++];
}
}
void enumeration() {
String c;
Enumeration z = new ChrisEnumeration();
while (z.hasMoreElements()) { // tests if this enumeration contains more elements
c = (String)z.nextElement(); // returns the next element of this enumeration
}
}
/*********************************************************************
* *
* Vector: *
* *
* Desc: Define collection of objects that acts like an array *
* *
* Methods: *
* addElement firstElement removeElementAt *
* capacity indexOf setElementAt *
* clone insertElementAt setSize *
* contains isEmpty size *
* copyInto lastElement toString *
* elementAt lastIndexOf trimToSize *
* elements removeAllElements *
* ensureCapacity removeElement *
* *
* #add #get #removeAll *
* #addAll #hashCode #retainAll *
* #clear #get #set *
* #containsAll #hashCode #subList *
* #equals #remove #toArray *
* *
*********************************************************************/
void vector() {
int i;
boolean b;
String s;
Chris obj = new Chris(0);
Vector x = new Vector(10, 5); // specify initial capacity and incremental allocation
x.addElement(new Chris(1)); // adds the component to end of vector, increasing its size by one
x.addElement(new Chris(2));
x.addElement(new Chris(3));
x.addElement(new Chris(4));
x.addElement(new Chris(5));
x.setElementAt(new Chris(6), 4); // sets object as a component at specified index
x.insertElementAt(obj, 2); // inserts object as a component at specified index
b = x.isEmpty(); // tests if this vector has no components
b = x.contains(obj); // tests if the specified object is a component in this vector
obj = (Chris)x.firstElement(); // returns the first component of this vector
obj = (Chris)x.lastElement(); // returns the last component of the vector
obj = (Chris)x.elementAt(2); // returns the component at the specified index
i = x.indexOf(obj); // returns index of first occurrence of object
i = x.indexOf(obj, 2); // returns index of first occurrence of object starting at index
i = x.lastIndexOf(obj); // returns index of last occurrence of object
i = x.lastIndexOf(obj, 4); // returns index of last occurrence of object ending at index
Enumeration z = x.elements(); // returns an enumeration of the components of this vector
while (z.hasMoreElements()) {
obj = (Chris)z.nextElement();
}
Chris[] pob = new Chris[x.size()];
x.copyInto(pob); // copies the components of this vector into the specified array
Vector y = (Vector)x.clone(); // returns a clone of this vector
x.ensureCapacity(15); // ensure minumum allocated capacity
i = x.capacity(); // returns current capacity
i = x.size(); // returns the number of components
x.setSize(5); // sets the size of this vector (increase-null or decrease-truncate)
x.trimToSize(); // trims the capacity to be the vector's current size
b = x.removeElement(obj); // removes first occurrence of the argument from this vector
x.removeElementAt(2); // deletes the component at the specified index
x.removeAllElements(); // removes all components from this vector and sets its size to zero
s = y.toString(); // returns a string representation of this vector - fairly useless
/* TO BE DETERMINED
void add(int index, Object element) // Inserts the specified element at the specified position in this Vector.
boolean add(Object o) // Appends the specified element to the end of this Vector.
boolean addAll(Collection c) // Appends all of the elements in the specified Collection to the end of this Vector, in the order that they are returned by the specified Collection's Iterator.
boolean addAll(int index, Collection c) // Inserts all of the elements in in the specified Collection into this Vector at the specified position.
void clear() // Removes all of the elements from this Vector.
boolean containsAll(Collection c) // Returns true if this Vector contains all of the elements in the specified Collection.
boolean equals(Object o) // Compares the specified Object with this Vector for equality.
Object get(int index) // Returns the element at the specified position in this Vector.
int hashCode() // Returns the hash code value for this Vector.
Object get(int index) // Returns the element at the specified position in this Vector.
int hashCode() // Returns the hash code value for this Vector.
Object remove(int index) // Removes the element at the specified position in this Vector.
boolean remove(Object o) // Removes the first occurrence of the specified element in this Vector If the Vector does not contain the element, it is unchanged.
boolean removeAll(Collection c) // Removes from this Vector all of its elements that are contained in the specified Collection.
boolean retainAll(Collection c) // Retains only the elements in this Vector that are contained in the specified Collection.
Object set(int index, Object element) // Replaces the element at the specified position in this Vector with the specified element.
List subList(int fromIndex, int toIndex) // Returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive.
Object[] toArray() // Returns an array containing all of the elements in this Vector in the correct order.
Object[] toArray(Object[] a) // Returns an array containing all of the elements in this Vector in the correct order.
*/
}
/*********************************************************************
* *
* Stack: *
* *
* Desc: Define collection of objects that acts like a stack *
* *
* Methods: *
* empty pop search *
* peek push *
* *
*********************************************************************/
void stack() {
int i;
boolean b;
String s;
Chris obj = new Chris(0);
Stack x = new Stack(); // default constructor - initial capacity = 10
x.push(new Chris(1)); // pushes an item onto the top of this stack
b = x.empty(); // tests if this stack is empty
i = x.search(obj); // returns where an object is on this stack
obj = (Chris)x.peek(); // looks at the object at the top of stack without removing it
obj = (Chris)x.pop(); // removes object at top of stack
// stack is derived from Vector and has all it's methods available
x.addElement(new Chris(1)); // adds the component to end of vector, increasing its size by one
x.addElement(new Chris(2));
x.addElement(new Chris(3));
x.addElement(new Chris(4));
x.addElement(new Chris(5));
x.setElementAt(new Chris(6), 4); // sets object as a component at specified index
x.insertElementAt(obj, 2); // inserts object as a component at specified index
b = x.isEmpty(); // tests if this vector has no components
b = x.contains(obj); // tests if the specified object is a component in this vector
obj = (Chris)x.firstElement(); // returns the first component of this vector
obj = (Chris)x.lastElement(); // returns the last component of the vector
obj = (Chris)x.elementAt(2); // returns the component at the specified index
i = x.indexOf(obj); // returns index of first occurrence of object
i = x.indexOf(obj, 2); // returns index of first occurrence of object starting at index
i = x.lastIndexOf(obj); // returns index of last occurrence of object
i = x.lastIndexOf(obj, 4); // returns index of last occurrence of object ending at index
Enumeration z = x.elements(); // returns an enumeration of the components of this vector
while (z.hasMoreElements()) {
obj = (Chris)z.nextElement();
}
Chris[] pob = new Chris[x.size()];
x.copyInto(pob); // copies the components of this vector into the specified array
Stack y = (Stack)x.clone(); // returns a clone of this vector
x.ensureCapacity(15); // ensure minumum allocated capacity
i = x.capacity(); // returns current capacity
i = x.size(); // returns the number of components
x.setSize(5); // sets the size of this vector (increase-null or decrease-truncate)
x.trimToSize(); // trims the capacity to be the vector's current size
b = x.removeElement(obj); // removes first occurrence of the argument from this vector
x.removeElementAt(2); // deletes the component at the specified index
x.removeAllElements(); // removes all components from this vector and sets its size to zero
s = y.toString(); // returns a string representation of this vector - fairly useless
}
/*********************************************************************
* *
* BitSet: *
* *
* Desc: Vector of bits (boolean) in 64 bit chunks *
* *
* Methods: *
* and get size *
* clear hashCode toString *
* clone or xor *
* equals set *
* *
* #andNot #length *
* *
*********************************************************************/
void bitset() {
int i;
boolean b;
String s;
BitSet x = new BitSet();
BitSet y = new BitSet();
for (i = 0; i < 32; i++) x.clear(i);
for (i = 0; i < 32; i++) y.set(i);
x.set(0); // sets a bit
x.clear(1); // clears a bit
x.and(y); // logically ANDs this bit set with the specified set of bits
x.or(y); // logically ORs this bit set with the specified set of bits
x.xor(y); // logically XORs this bit set with the specified set of bits
b = x.get(0); // gets a bit
i = x.size(); // calculates and returns the set's size in bits
s = x.toString(); // converts the BitSet to a String
x = (BitSet)y.clone(); // clones the BitSet
b = x.equals(y); // compares this object against the specified object
i = x.hashCode(); // gets the hashcode
/* TO BE DETERMINED
void andNot(BitSet set) // Clears all of the bits in this BitSet whose corresponding bit is set in the specified BitSet
int length() // Returns the "logical size" of this BitSet: the index of the highest set bit in the BitSet plus one
*/
}
/*********************************************************************
* *
* HashTable: *
* *
* Desc: Define collection of objects - retrieved by key *
* *
* Methods: *
* clear elements put *
* clone get remove *
* contains isEmpty size *
* containsKey keys toString *
* *
* #containsValue #hashCode #putAll *
* #entrySet #keySet #values *
* #equals *
* *
*********************************************************************/
void hashtable() {
int i;
boolean b;
String s;
Chris obj = new Chris(1);
Chris nob;
Hashtable x = new Hashtable(10, 0.75F); // specify initial capacity and load factor
nob = (Chris)x.put("A", obj); // maps the specified key to the specified value in hashtable
nob = (Chris)x.put("B", new Chris(2));
nob = (Chris)x.put("C", new Chris(3));
nob = (Chris)x.put("D", new Chris(4));
i = x.size(); // returns the number of keys in this hashtable
b = x.isEmpty(); // tests if this hashtable maps no keys to values
b = x.contains(obj); // tests if some key maps into specified value in hashtable
b = x.containsKey("A"); // tests if some key maps into specified value in hashtable
Hashtable y = (Hashtable)x.clone(); // returns a clone of this hashtable
obj = (Chris)x.get("B"); // returns value which key is mapped in this hashtable
Enumeration z = x.elements(); // returns an enumeration of the values in this hashtable
while (z.hasMoreElements()) {
obj = (Chris)z.nextElement();
}
z = x.keys(); // returns an enumeration of the keys in this hashtable
while (z.hasMoreElements()) {
s = (String)z.nextElement();
obj = (Chris)x.get(s);
}
obj = (Chris)x.remove(obj); // removes the key (and its corresponding value) from this hashtable
x.clear(); // clears this hashtable so that it contains no keys
s = y.toString(); // returns a string representation of this vector - fairly useless
/* TO BE DETERMINED
boolean containsValue(Object value) // Returns true if this Hashtable maps one or more keys to this value. Note that this method is identical in functionality to contains (which predates the Map interface).
Set entrySet() // Returns a Set view of the entries contained in this Hashtable.
boolean equals(Object o) // Compares the specified Object with this Map for equality, as per the definition in the Map interface.
int hashCode() // Returns the hash code value for this Map as per the definition in the Map interface.
Set keySet() // Returns a Set view of the keys contained in this Hashtable.
void putAll(Map t) // Copies all of the mappings from the specified Map to this Hashtable These mappings will replace any mappings that this Hashtable had for any of the keys currently in the specified Map.
Collection values() // Returns a Collection view of the values contained in this Hashtable.
*/
}
/*********************************************************************
* *
* Dictionary: *
* *
* Desc: abstract class used for hashtable *
* *
* Methods: *
* elements keys size *
* get put *
* isEmpty remove *
* *
*********************************************************************/
void dictionary() {
/* TO BE DETERMINED
elements() // returns an enumeration of the values in this dictionary
get(Object) // returns the value to which the key is mapped in this dictionary
isEmpty() // tests if this dictionary maps no keys to value
keys() // returns an enumeration of the keys in this dictionary
put(Object, Object) // maps the specified key to the specified value in this dictionary
remove(Object) // removes the key (and its corresponding value) from this dictionary
size() // returns the number of keys in this dictionary
*/
}
/*********************************************************************
* *
* Observer Interface: *
* *
* Desc: Detect change in observable class via update method *
* *
* Methods: *
* update *
* *
*********************************************************************/
class ChrisObserver implements Observer {
String name;
public ChrisObserver(String name) {
this.name = name;
}
// this method is called whenever the observed object is changed
public void update(Observable obs, Object obj) {
if (obj == null) {
// System.out.println(name + " Update = " + ((ChrisObservable)obs).myName());
} else {
// System.out.println(name + " Update = " + ((ChrisObservable)obs).myName() + " " + (String)obj);
}
}
}
/*********************************************************************
* *
* Observable: *
* *
* Desc: Communicate change in class object to other classes *
* *
* Methods: *
* addObserver deleteObserver notifyObservers *
* clearChanged deleteObservers setChanged *
* countObservers hasChanged *
* *
*********************************************************************/
class ChrisObservable extends Observable {
public String name = "Chris";
public void nameMe(String name) {
this.name = name;
}
public void changeMe() {
setChanged(); // indicates that this object has changed
}
public void unchangeMe() {
clearChanged(); // clear changed flag
}
public String myName() {
return name;
}
}
void observable() {
int i;
boolean b;
ChrisObservable Chris = new ChrisObservable();
ChrisObserver Fred = new ChrisObserver("Fred");
ChrisObserver Hank = new ChrisObserver("Hank");
ChrisObserver Pete = new ChrisObserver("Pete");
Chris.addObserver(Fred); // adds an observer to the set of observers for this object
Chris.addObserver(Hank);
Chris.addObserver(Pete);
Chris.nameMe("Critter");
Chris.changeMe();
i = Chris.countObservers(); // returns the number of observers of this object
b = Chris.hasChanged(); // tests if this object has changed
Chris.notifyObservers(); // if changed, notify observers and call clearChanged
Chris.nameMe("Cris");
Chris.changeMe();
Chris.notifyObservers("Hello"); // if changed, notify observers with object and call clearChanged
Chris.nameMe("Cris");
Chris.changeMe();
Chris.unchangeMe();
Chris.deleteObserver(Fred); // deletes an observer from the set of observers of this object
Chris.deleteObservers(); // clears the observer list
}
/*********************************************************************
* *
* Random: *
* *
* Desc: Deterministic random number generator *
* *
* Methods: *
* next nextFloat nextLong *
* nextBytes nextGaussian setSeed *
* nextDouble nextInt *
* *
* #nextBoolean *
* *
*********************************************************************/
void random() {
int i;
long n;
float f;
double d;
byte[] bx = new byte[10];
boolean b;
Random x = new Random(997L);
x.setSeed(997L); // sets seed of random number generator using a single long seed
i = x.nextInt(); // returns the next pseudorandom as int value (-2^32 - 2^32-1)
n = x.nextLong(); // returns the next pseudorandom as long value (-2^64 - 2^64-1)
f = x.nextFloat(); // returns the next pseudorandom as float value (0.0 - 1.0)
d = x.nextDouble(); // returns the next pseudorandom as double value (0.0 - 1.0)
d = x.nextGaussian(); // gaussian distributed double value (mean=0.0 sdev=1.0)
x.nextBytes(bx); // generates a user specified number of random bytes (-2^8 - 2^8-1)
b = x.nextBoolean(); // returns the next pseudorandom as boolean value (true - false)
}
/*********************************************************************
* *
* Date: *
* *
* Desc: encapsulates a point in time - specific date/time *
* *
* Methods: *
* *
* %getDate %getTimezoneOffset %setMonth *
* %getDay %getYear %setSeconds *
* %getHours %parse %setYear *
* %getMinutes %setDate %toGMTString *
* %getMonth %setHours %toLocaleString *
* %getSeconds %setMinutes %UTC *
* *
* after getTime setTime *
* before hashCode toString *
* equals *
* *
* #clone #compareTo *
* *
*********************************************************************/
void date() {
boolean b;
Date x = new Date(); // current date/time
Date y = new Date(1000L*60*60*24);// date/time in milliseconds relative to 1/1/1970
b = x.after(y); // tests if this date is after the specified date
b = x.before(y); // tests if this date is before the specified date
b = x.equals(y); // compares two dates
y.setTime(1000L*60*60*24*365); // sets to specified number of milliseconds since 1/1/1970
long n = y.getTime(); // number of milliseconds since 1//1/1970 GMT
int i = y.hashCode(); // computes a hashcode for the object
String s = y.toString(); // creates a canonical string representation of the date
/* TO BE DETERMINED
Object clone() // Return a copy of this object.
int compareTo(Date anotherDate) // Compares two Dates for ordering.
int compareTo(Object o) // Compares this Date to another Object.
*/
}
/*********************************************************************
* *
* GregorianCalendar: (extends Calendar) *
* *
* Desc: x *
* *
* Vars: *
* AD BC *
* *
* Methods: *
* add getGregorianChange isLeapYear *
* after getLeastMaximum roll *
* before getMaximum setGregorianChange*
* equals getMinimum *
* getGreatestMinimum hashCode *
* *
* #getActualMaximum #getActualMinimum *
* *
*********************************************************************/
void gregoriancalendar() {
int i;
boolean f;
Date d;
GregorianCalendar x;
GregorianCalendar y;
x = new GregorianCalendar(); // current date/time
y = new GregorianCalendar(1998, Calendar.JULY, 1, 11, 20);
f = x.isLeapYear(1996); // determines if the given year is a leap year
f = x.after(y); // compares the time field records
f = x.before(y); // compares the time field records
f = x.equals(y); // compares this calendar to the specified object
y.add(Calendar.DATE, 4); // overrides Calendar Date Arithmetic function
y.roll(Calendar.DATE, true); // field rolling function - true=rollup; false=rolldown
i = y.getMinimum(Calendar.MINUTE); // returns minimum value for the given field
i = y.getMaximum(Calendar.MONTH); // returns maximum value for the given field
i = y.getLeastMaximum(Calendar.YEAR); // returns lowest maximum value for the given field if varies
i = y.getGreatestMinimum(Calendar.HOUR); // returns highest minimum value for the given field if varies
d = y.getGregorianChange(); // gets the Gregorian Calendar change date (switch from Julian)
i = x.hashCode(); // override hashCode
/* TO BE DETERMINED
AD // useful constant for GregorianCalendar
BC // useful constant for GregorianCalendar
int getActualMaximum(int field) // Return the maximum value that this field could have, given the current date.
int getActualMinimum(int field) // Return the minimum value that this field could have, given the current date.
*/
}
/*********************************************************************
* *
* Calendar: (abstract) *
* *
* Desc: *
* *
* Vars: *
* AM FRIDAY PM *
* AM_PM HOUR SATURDAY *
* APRIL HOUR_OF_DAY SECOND *
* AUGUST JANUARY SEPTEMBER *
* DATE JULY SUNDAY *
* DAY_OF_MONTH JUNE THURSDAY *
* DAY_OF_WEEK MARCH TUESDAY *
* DAY_OF_WEEK_IN_MONTH MAY UNDECIMBER *
* DAY_OF_YEAR MILLISECOND WEDNESDAY *
* DECEMBER MINUTE WEEK_OF_MONTH *
* DST_OFFSET MONDAY WEEK_OF_YEAR *
* ERA MONTH YEAR *
* FEBRUARY NOVEMBER ZONE_OFFSET *
* FIELD_COUNT OCTOBER *
* *
* Methods: *
* add getMinimum *
* after getTime *
* before getTimeZone *
* clear isLenient *
* clone isSet *
* equals roll *
* get set *
* getAvailableLocales setFirstDayOfWeek *
* getFirstDayOfWeek setLenientWeek *
* getGreatestMinimum setMinimalDaysInFirstWeek *
* getInstance setTime *
* getLeastMaximum setTimeZone *
* getMaximum toString *
* getMinimalDaysInFirst *
* *
* #getActualMaximum #hashcode *
* #getActualMinimum *
* *
*********************************************************************/
void calendar() {
int i;
boolean f;
String s = "";
Locale[] z;
Calendar x = new GregorianCalendar();
Calendar y = new GregorianCalendar(1998, Calendar.JULY, 1, 11, 20, 5);
TimeZone tz = x.getTimeZone(); // gets the time zone
tz = TimeZone.getTimeZone("CST");
x.setTimeZone(tz); // sets the time zone with the given time zone value
z = x.getAvailableLocales(); // gets the set of locales for which Calendars are installed
for (i = 0; i < z.length; i++) {
s = z[i].getDisplayName();
}
y.set(1998, x.JULY, 1, 11, 20, 5);// sets fields yyyy, mm, dd, hh, mm, ss
y = Calendar.getInstance(); // gets a Calendar using the default timezone and locale
Date d = x.getTime(); // gets this Calendar's current time
x.setTime(d); // sets this Calendar's current time with the given Date
i = x.get(x.YEAR); // Gets the value for a given time field
i = x.get(x.MONTH);
i = x.get(x.WEEK_OF_YEAR);
i = x.get(x.WEEK_OF_MONTH);
i = x.get(x.DAY_OF_YEAR);
i = x.get(x.DAY_OF_MONTH);
i = x.get(x.DAY_OF_WEEK);
i = x.get(x.DAY_OF_WEEK_IN_MONTH);
i = x.get(x.HOUR);
i = x.get(x.HOUR_OF_DAY);
i = x.get(x.MINUTE);
i = x.get(x.SECOND);
i = x.get(x.MILLISECOND);
switch (x.get(x.DAY_OF_WEEK)) {
case x.SUNDAY: s = "Sun"; break;
case x.MONDAY: s = "Mon"; break;
case x.TUESDAY: s = "Tue"; break;
case x.WEDNESDAY: s = "Wed"; break;
case x.THURSDAY: s = "Thu"; break;
case x.FRIDAY: s = "Fri"; break;
case x.SATURDAY: s = "Sat"; break;
}
switch (x.get(x.MONTH)) {
case x.JANUARY: s = "Jan"; break;
case x.FEBRUARY: s = "Feb"; break;
case x.MARCH: s = "Mar"; break;
case x.APRIL: s = "Apr"; break;
case x.MAY: s = "May"; break;
case x.JUNE: s = "Jun"; break;
case x.JULY: s = "Jul"; break;
case x.AUGUST: s = "Aug"; break;
case x.SEPTEMBER: s = "Sep"; break;
case x.OCTOBER: s = "Oct"; break;
case x.NOVEMBER: s = "Nov"; break;
case x.DECEMBER: s = "Dec"; break;
}
i = x.getFirstDayOfWeek(); // gets what the first day of the week is
i = x.getMinimum(x.MINUTE); // returns minimum value for the given field
i = x.getMaximum(x.MONTH); // returns maximum value for the given field
i = x.getLeastMaximum(x.YEAR); // returns lowest maximum value for the given field if varies
i = x.getGreatestMinimum(x.HOUR); // returns highest minimum value for the given field if varies
i = x.getMinimalDaysInFirstWeek();// minimal days required in the first week of the year
x.add(Calendar.DATE, 4); // date Arithmetic function
x.roll(Calendar.DATE, true); // field rolling function - true=rollup; false=rolldown
y.clear(); // clears the values of all the time fields
x.clear(x.MILLISECOND); // clears the value in the given time field
x.setFirstDayOfWeek(x.SUNDAY); // sets what the first day of the week is
x.setLenient(false); // specify whether or not date/time interpretation is to be lenient
x.setMinimalDaysInFirstWeek(1); // minimal days required in the first week of the year
f = x.after(y); // compares the time field records
f = x.before(y); // compares the time field records
f = x.isLenient(); // tell whether date/time interpretation is to be lenient
f = x.isSet(x.MONTH); // determines if the given time field has a value set
f = x.equals(y); // compares this calendar to the specified object
y = (Calendar)x.clone(); // overrides Cloneable
s = x.toString(); // return a string representation of this calendar
/* TO BE DETERMINED
AM // useful constant for hour in 12-hour clock
AM_PM // useful constant for date and time
DATE // useful constant for date and time
DST_OFFSET // useful constant for date and time
ERA // useful constant for date and time
FIELD_COUNT // useful constant for date and time
PM // useful constant for hour in 12-hour clock
UNDECIMBER // useful constant for month
ZONE_OFFSET // useful constant for date and time
int getActualMaximum(int field) // Return the maximum value that this field could have, given the current date.
int getActualMinimum(int field) // Return the minimum value that this field could have, given the current date.
int hashCode() // Returns a hash code for this calendar.
*/
}
/*********************************************************************
* *
* TimeZone: *
* *
* Desc: *
* *
* Fields: *
* LONG SHORT *
* *
* Methods: *
* clone getOffset setDefault *
* getAvailableIDs getRawOffset setID *
* getDefault getTimeZone setRawOffset *
* getID inDaylightTime useDaylightTime *
* *
* #getDisplayName #hasSameRules *
* *
*********************************************************************/
void timezone() {
int i;
boolean f;
String s;
String[] sx;
Date d = new Date();
GregorianCalendar c = new GregorianCalendar();
TimeZone tz;
TimeZone ty;
tz = TimeZone.getTimeZone("CST"); // gets the TimeZone for the given ID
tz = TimeZone.getDefault(); // gets the default TimeZone for this host
TimeZone.setDefault(tz); // sets time zone to using the given TimeZone
ty = (TimeZone)tz.clone(); // overrides Cloneable
f = tz.useDaylightTime(); // queries if this time zone uses Daylight Savings Time
f = tz.inDaylightTime(d); // queries if the given date is in Daylight Savings Time in time zone
s = tz.getID(); // gets the ID of this time zone
tz.setID(s); // sets the time zone ID
sx = TimeZone.getAvailableIDs(); // gets all the available IDs supported
i = tz.getRawOffset(); // gets unmodified offset, NOT modified in case of daylight savings
tz.setRawOffset(i); // sets the base time zone offset to GMT
sx = TimeZone.getAvailableIDs(i); // gets the available IDs according to the given time zone offset
i = tz.getOffset(GregorianCalendar.AD, 1960, 7, 1, 3, 0); // gets the time zone offset for current date
/* TO BE DETERMINED
static int LONG // A style specifier for getDisplayName() indicating a long name, such as "Pacific Standard Time."
static int SHORT // A style specifier for getDisplayName() indicating a short name, such as "PST."
String getDisplayName() // Returns a name of this time zone suitable for presentation to the user in the default locale.
String getDisplayName(boolean daylight, int style) // Returns a name of this time zone suitable for presentation to the user in the default locale.
String getDisplayName(boolean daylight, int style, Locale locale) // Returns a name of this time zone suitable for presentation to the user in the specified locale.
String getDisplayName(Locale locale) // Returns a name of this time zone suitable for presentation to the user in the specified locale.
boolean hasSameRules(TimeZone other) // Returns true if this zone has the same rule and offset as another zone.
*/
}
/*********************************************************************
* *
* SimpleTimeZone: *
* *
* Desc: TimeZone for use with GregorianCalendar *
* *
* Methods: *
* clone hashCode setStartRule *
* equals inDaylightTime setStartYear *
* getOffset setEndRule toString *
* getRawOffset setRawOffset useDaylightTime *
* *
* #getDSTSavings #hasSameRules #setDSTSavings *
* *
*********************************************************************/
void simpletimezone() {
int i;
boolean f;
String s;
Date d = new Date();
TimeZone tz = TimeZone.getDefault();
SimpleTimeZone ty;
SimpleTimeZone ts = new SimpleTimeZone(tz.getRawOffset(), "CST");
i = ts.getRawOffset(); // gets the GMT offset for this time zone
ts.setRawOffset(i); // sets the base time zone offset to GMT
i = ts.getOffset(GregorianCalendar.AD, 1960, 7, 1, 3, 0); // gets the time zone offset for current date
f = ts.inDaylightTime(d); // queries if the given date is in Daylight Savings Time
f = ts.useDaylightTime(); // queries if this time zone uses Daylight Savings Time
ts.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2*60*60*1000); // daylight savings starting rule
ts.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*60*60*1000); // daylight savings ending rule
ts.setStartYear(1968); // sets the daylight savings starting year
ty = (SimpleTimeZone)ts.clone(); // overrides Cloneable
f = ts.equals(ty); // compares the equality of two SimpleTimeZone objects
i = ts.hashCode(); // override hashCode
s = ts.toString(); // return a string representation of this time zone
/* TO BE DETERMINED
int getDSTSavings() // Returns the amount of time in ms that the clock is advanced during DST
boolean hasSameRules(TimeZone other) // Return true if this zone has the same rules and offset as another zone.
void setDSTSavings(int millisSavedDuringDST) // Sets the amount of time in ms that the clock is advanced during DST.
*/
}
/*********************************************************************
* *
* Locale: *
* *
* Desc: *
* *
* Vars: *
* CANADA GERMAN KOREAN *
* CANADA_FRENCH GERMANY PRC *
* CHINA ITALIAN SIMPLIFIED_CHINESE *
* CHINESE ITALY TAIWAN *
* ENGLISH JAPAN TRADITIONAL_CHINESE *
* FRANCE JAPANESE UK *
* FRENCH KOREA US *
* *
* Methods: *
* clone getDisplayLanguage getLanguage *
* equals getDisplayName getVariant *
* getCountry getDisplayVariant hashCode *
* getDefault getISO3Country setDefault *
* getDisplayCountry getISO3Language toString *
* *
* #getAvailableLocales #getISOCountries #getISOLanguages *
* *
*********************************************************************/
void locale() {
int i;
boolean f;
String s;
Locale x = new Locale("EN", "US");
Locale y = Locale.getDefault(); // common method of getting the current default Locale
Locale.setDefault(Locale.US); // sets the default
s = x.getCountry(); // two-letter ISO-3166 country code
s = x.getISO3Country(); // three-letter ISO country abbreviation of the locale
s = x.getDisplayCountry(); // name for the locale's country
s = x.getDisplayLanguage(); // name for the locale's language
s = x.getDisplayName(); // name for the locale
s = x.getDisplayVariant(); // name for the locale's variant code
s = x.getISO3Language(); // three-letter ISO language abbreviation of the locale
s = x.getLanguage(); // name of field, an lowercased two-letter ISO-639 code
s = x.getVariant(); // name of field
s = x.getDisplayCountry(Locale.US);
s = x.getDisplayLanguage(Locale.US);
s = x.getDisplayName(Locale.US);
s = x.getDisplayVariant(Locale.US);
x = Locale.CANADA;
x = Locale.CANADA_FRENCH;
x = Locale.CHINA;
x = Locale.CHINESE;
x = Locale.ENGLISH;
x = Locale.FRANCE;
x = Locale.FRENCH;
x = Locale.GERMAN;
x = Locale.GERMANY;
x = Locale.ITALIAN;
x = Locale.ITALY;
x = Locale.JAPAN;
x = Locale.JAPANESE;
x = Locale.KOREA;
x = Locale.KOREAN;
x = Locale.PRC;
x = Locale.SIMPLIFIED_CHINESE;
x = Locale.TAIWAN;
x = Locale.TRADITIONAL_CHINESE;
x = Locale.UK;
x = Locale.US;
y = (Locale)x.clone(); // overrides Cloneable
f = x.equals(y); // compares two Objects for equality
i = x.hashCode(); // override hashCode
s = x.toString(); // name of the entire locale
/* TO BE DETERMINED
static Locale[] getAvailableLocales() // Returns a list of all installed locales.
static String[] getISOCountries() // Returns a list of all 2-letter country codes defined in ISO 3166.
static String[] getISOLanguages() // Returns a list of all 2-letter language codes defined in ISO 639.
*/
}
/*********************************************************************
* *
* EventObject: *
* *
* Desc: *
* *
* Vars: *
* source *
* *
* Methods: *
* getSource toString *
* *
*********************************************************************/
void eventobject() {
/* TO BE DETERMINED
source
getSource()
toString() // Returns a string representation of the object
*/
}
/*********************************************************************
* *
* EventListener Interface: *
* *
* Desc: x *
* *
*********************************************************************/
void eventlistener() {
}
/*********************************************************************
* *
* Properties: *
* *
* Desc: hashtable used to store/retrive environment variables *
* *
* Methods: *
* getProperty load %save *
* list propertyNames *
* *
* #setProperty #store *
* *
*********************************************************************/
void properties() {
String s;
Enumeration z;
Properties p = new Properties();
Properties d = new Properties(p); // specify second table for defaults
p.put("myApp.x", "100");
p.put("myApp.y", "200");
d.put("myApp.a", "50");
s = p.getProperty("myApp.x"); // searches for the property with the specified key
s = p.getProperty("myApp.z", "0");// searches for the property with the specified key - with default
z = d.propertyNames(); // enumeration of keys in this property list and default property list
while (z.hasMoreElements()) {
s = (String)z.nextElement();
}
p = System.getProperties(); // returns system properties list
// p.list(System.out); // prints this property list out to the specified output stream
// p.save(System.out, "Properties"); // stores this property list to the specified output stream
/* TO BE DETERMINED
load(InputStream) // reads a property list from an input stream
Object setProperty(String key, String value) // Calls the hashtable method put.
void store(OutputStream out, String header) // Writes this property list (key and element pairs) in this Properties table to the output stream in a format suitable for loading into a Properties table using the load method.
*/
}
/*********************************************************************
* *
* StringTokenizer: *
* *
* Desc: parse string into smaller strings (tokens) *
* *
* Methods: *
* countTokens hasMoreTokens nextToken *
* hasMoreElements nextElement *
* *
*********************************************************************/
void stringtokenizer() {
int i;
String s;
boolean f;
StringTokenizer x = new StringTokenizer("Hello, my name is Chris!");
i = x.countTokens(); // calculates number of tokens
while (x.hasMoreTokens()) { // tests if more tokens available from this tokenizer's string
s = x.nextToken(); // next token from this string tokenizer
}
f = x.hasMoreElements(); // same value as the hasMoreTokens method
/* TO BE DETERMINED
nextElement() // Returns the same value as the nextToken method, except that its declared return value is Object rather than String
nextToken(String) // Returns the next token in this string tokenizer's string
*/
}
/*********************************************************************
* *
* ResourceBundle: *
* *
* Desc: x *
* *
* Methods: *
* getBundle getObject getStringArray *
* getKeys getString setParent *
* *
* #getLocale *
* *
*********************************************************************/
void resourcebundle() {
String s;
Enumeration z;
ResourceBundle x;
x = ResourceBundle.getBundle("Test.Chris.Java_util_ResourceBundle_Message", Locale.ITALY);
s = x.getString("HelloMessage"); // Get an object from a ResourceBundle
x = ResourceBundle.getBundle("Test.Chris.Java_util_ResourceBundle_Message", Locale.US);
s = x.getString("HelloMessage");
s = (String)x.getObject("OtherMessage"); // get an object from a ResourceBundle
z = x.getKeys(); // return an enumeration of the keys
while (z.hasMoreElements()) {
s = (String)z.nextElement();
}
/* TO BE DETERMINED
getStringArray(String) // Get an object from a ResourceBundle
Locale getLocale() // Return the Locale for this ResourceBundle.
*/
}
/*********************************************************************
* *
* PropertyResourceBundle: *
* *
* Desc: x *
* *
* Methods: *
* getKeys handleGetObject *
* *
*********************************************************************/
void propertyresourcebundle () {
/* TO BE DETERMINED
getKeys() // Implementation of ResourceBundle.getKeys
handleGetObject(String) // Override of ResourceBundle, same semantics
*/
}
/*********************************************************************
* *
* #AbstractCollection: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
addAll
clear
contains
containsAll
isEmpty
iterator
remove
removeAll
retainAll
size
toArray
toArray
toString
* *
*********************************************************************/
void abstractcollection() {
/* TO BE DETERMINED
boolean add(Object o) // Ensures that this collection contains the specified element (optional operation).
boolean addAll(Collection c) // Adds all of the elements in the specified collection to this collection (optional operation).
void clear() // Removes all of the elements from this collection (optional operation).
boolean contains(Object o) // Returns true if this collection contains the specified element.
boolean containsAll(Collection c) // Returns true if this collection contains all of the elements in the specified collection.
boolean isEmpty() // Returns true if this collection contains no elements. This implementation returns size() == 0.
abstract Iterator iterator() // Returns an iterator over the elements contained in this collection.
boolean remove(Object o) // Removes a single instance of the specified element from this collection, if it is present (optional operation).
boolean removeAll(Collection c) // Removes from this collection all of its elements that are contained in the specified collection (optional operation).
boolean retainAll(Collection c) // Retains only the elements in this collection that are contained in the specified collection (optional operation).
abstract int size() // Returns the number of elements in this collection.
Object[] toArray() // Returns an array containing all of the elements in this collection.
Object[] toArray(Object[] a) // Returns an array with a runtime type is that of the specified array and that contains all of the elements in this collection.
String toString() // Returns a string representation of this collection.
*/
}
/*********************************************************************
* *
* #AbstractList: *
* *
* Desc: *
* *
modCount
* Methods: *
* x y y *
add
addAll
clear
equals
get
hashCode
indexOf
iterator
lastIndexOf
listIterator
remove
removeRange
set
subList
* *
*********************************************************************/
void abstractlist() {
/* TO BE DETERMINED
protected int modCount // The number of times this list has been structurally modified.
void add(int index, Object element) // Inserts the specified element at the specified position in this list (optional operation).
boolean add(Object o) // Appends the specified element to the end of this List (optional operation).
boolean addAll(int index, Collection c) // Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
void clear() // Removes all of the elements from this collection (optional operation).
boolean equals(Object o) // Compares the specified object with this list for equality.
abstract Object get(int index) // Returns the element at the specified position in this list.
int hashCode() // Returns the hash code value for this list.
int indexOf(Object o) // Returns the index in this list of the first occurence of the specified element, or -1 if the list does not contain this element.
Iterator iterator() // Returns an iterator over the elements in this list in proper sequence.
int lastIndexOf(Object o) // Returns the index in this list of the last occurence of the specified element, or -1 if the list does not contain this element.
ListIterator listIterator() // Returns an iterator of the elements in this list (in proper sequence).
ListIterator listIterator(int index) // Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in the list.
Object remove(int index) // Removes the element at the specified position in this list (optional operation).
protected void removeRange(int fromIndex, int toIndex) // Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element (optional operation).
List subList(int fromIndex, int toIndex) // Returns a view of the portion of this list between fromIndex, inclusive, and toIndex, exclusive.
*/
}
/*********************************************************************
* *
* #AbstractMap: *
* *
* Desc: *
* *
* Methods: *
* x y y *
clear
containsKey
containsValue
entrySet
equals
get
hashCode
isEmpty
keySet
put
putAll
remove
size
toString
values
* *
*********************************************************************/
void abstractmap() {
/* TO BE DETERMINED
void clear() // Removes all mappings from this map (optional operation).
boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
boolean containsValue(Object value) // Returns true if this map maps one or more keys to this value.
abstract Set entrySet() // Returns a set view of the mappings contained in this map.
boolean equals(Object o) // Compares the specified object with this map for equality.
Object get(Object key) // Returns the value to which this map maps the specified key.
int hashCode() // Returns the hash code value for this map.
boolean isEmpty() // Returns true if this map contains no key-value mappings.
Set keySet() // Returns a Set view of the keys contained in this map.
Object put(Object key, Object value) // Associates the specified value with the specified key in this map (optional operation).
void putAll(Map t) // Copies all of the mappings from the specified map to this map (optional operation).
Object remove(Object key) // Removes the mapping for this key from this map if present (optional operation).
int size() // Returns the number of key-value mappings in this map.
String toString() // Returns a string representation of this map.
Collection values() // Returns a collection view of the values contained in this map.
*/
}
/*********************************************************************
* *
* #AbstractSequentialList: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
addAll
get
iterator
listIterator
remove
set
* *
*********************************************************************/
void abstractsequentiallist() {
/* TO BE DETERMINED
void add(int index, Object element) // Inserts the specified element at the specified position in this list.
boolean addAll(int index, Collection c) // Inserts all of the elements in in the specified collection into this list at the specified position.
Object get(int index) // Returns the element at the specified position in this list.
Iterator iterator() // Returns an iterator over the elements in this list (in proper sequence). This implementation merely returns a list iterator over the list.
abstract ListIterator listIterator(int index) // Returns a list iterator over the elements in this list (in proper sequence).
Object remove(int index) // Removes the element at the specified position in this list.
Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element.
*/
}
/*********************************************************************
* *
* #AbstractSet: *
* *
* Desc: *
* *
* Methods: *
* x y y *
equals
hashCode
* *
*********************************************************************/
void abstractset() {
/* TO BE DETERMINED
boolean equals(Object o) // Compares the specified object with this set for equality.
int hashCode() // Returns the hash code value for this set.
*/
}
/*********************************************************************
* *
* #ArrayList: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
addAll
clear
clone
contains
ensureCapacity
get
indexOf
isEmpty
lastIndexOf
remove
removeRange
set
size
toArray
trimToSize
* *
*********************************************************************/
void arraylist() {
/* TO BE DETERMINED
void add(int index, Object element) // Inserts the specified element at the specified position in this list.
boolean add(Object o) // Appends the specified element to the end of this list.
boolean addAll(Collection c) // Appends all of the elements in the specified Collection to the end of this list, in the order that they are returned by the specified Collection's Iterator.
boolean addAll(int index, Collection c) // Inserts all of the elements in the specified Collection into this list, starting at the specified position.
void clear() // Removes all of the elements from this list.
Object clone() // Returns a shallow copy of this ArrayList instance.
boolean contains(Object elem) // Returns true if this list contains the specified element.
void ensureCapacity(int minCapacity) // Increases the capacity of this ArrayList instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
Object get(int index) // Returns the element at the specified position in this list.
int indexOf(Object elem) // Searches for the first occurence of the given argument, testing for equality using the equals method.
boolean isEmpty() // Tests if this list has no elements.
int lastIndexOf(Object elem) // Returns the index of the last occurrence of the specified object in this list.
Object remove(int index) // Removes the element at the specified position in this list.
protected void removeRange(int fromIndex, int toIndex) // Removes from this List all of the elements whose index is between fromIndex, inclusive and toIndex, exclusive.
Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element.
int size() // Returns the number of elements in this list.
Object[] toArray() // Returns an array containing all of the elements in this list in the correct order.
Object[] toArray(Object[] a) // Returns an array containing all of the elements in this list in the correct order.
void trimToSize() // Trims the capacity of this ArrayList instance to be the list's current size.
*/
}
/*********************************************************************
* *
* #Arrays: *
* *
* Desc: *
* *
* Methods: *
* x y y *
asList
binarySearch
equals
fill
sort
* *
*********************************************************************/
void arrays() {
/* TO BE DETERMINED
static List asList(Object[] a) // Returns a fixed-size list backed by the specified array.
static int binarySearch(byte[] a, byte key) // Searches the specified array of bytes for the specified value using the binary search algorithm.
static int binarySearch(char[] a, char key) // Searches the specified array of chars for the specified value using the binary search algorithm.
static int binarySearch(double[] a, double key) // Searches the specified array of doubles for the specified value using the binary search algorithm.
static int binarySearch(float[] a, float key) // Searches the specified array of floats for the specified value using the binary search algorithm.
static int binarySearch(int[] a, int key) // Searches the specified array of ints for the specified value using the binary search algorithm.
static int binarySearch(long[] a, long key) // Searches the specified array of longs for the specified value using the binary search algorithm.
static int binarySearch(Object[] a, Object key) // Searches the specified array for the specified object using the binary search algorithm.
static int binarySearch(Object[] a, Object key, Comparator c) // Searches the specified array for the specified object using the binary search algorithm.
static int binarySearch(short[] a, short key) // Searches the specified array of shorts for the specified value using the binary search algorithm.
static boolean equals(boolean[] a, boolean[] a2) // Returns true if the two specified arrays of equals are equal to one another.
static boolean equals(byte[] a, byte[] a2) // Returns true if the two specified arrays of bytes are equal to one another.
static boolean equals(char[] a, char[] a2) // Returns true if the two specified arrays of chars are equal to one another.
static boolean equals(double[] a, double[] a2) // Returns true if the two specified arrays of doubles are equal to one another.
static boolean equals(float[] a, float[] a2) // Returns true if the two specified arrays of floats are equal to one another.
static boolean equals(int[] a, int[] a2) // Returns true if the two specified arrays of ints are equal to one another.
static boolean equals(long[] a, long[] a2) // Returns true if the two specified arrays of longs are equal to one another.
static boolean equals(Object[] a, Object[] a2) // Returns true if the two specified arrays of Objects are equal to one another.
static boolean equals(short[] a, short[] a2) // Returns true if the two specified arrays of shorts are equal to one another.
static void fill(boolean[] a, boolean val) // Assigns the specified boolean value to each element of the specified array of booleans.
static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) // Assigns the specified boolean value to each element of the specified range of the specified array of booleans.
static void fill(byte[] a, byte val) // Assigns the specified byte value to each element of the specified array of bytes.
static void fill(byte[] a, int fromIndex, int toIndex, byte val) // Assigns the specified byte value to each element of the specified range of the specified array of bytes.
static void fill(char[] a, char val) // Assigns the specified char value to each element of the specified array of chars.
static void fill(char[] a, int fromIndex, int toIndex, char val) // Assigns the specified char value to each element of the specified range of the specified array of chars.
static void fill(double[] a, double val) // Assigns the specified double value to each element of the specified array of doubles.
static void fill(double[] a, int fromIndex, int toIndex, double val) // Assigns the specified double value to each element of the specified range of the specified array of doubles.
static void fill(float[] a, float val) // Assigns the specified float value to each element of the specified array of floats.
static void fill(float[] a, int fromIndex, int toIndex, float val) // Assigns the specified float value to each element of the specified range of the specified array of floats.
static void fill(int[] a, int val) // Assigns the specified int value to each element of the specified array of ints.
static void fill(int[] a, int fromIndex, int toIndex, int val) // Assigns the specified int value to each element of the specified range of the specified array of ints.
static void fill(long[] a, int fromIndex, int toIndex, long val) // Assigns the specified long value to each element of the specified range of the specified array of longs.
static void fill(long[] a, long val) // Assigns the specified long value to each element of the specified array of longs.
static void fill(Object[] a, int fromIndex, int toIndex, Object val) // Assigns the specified Object reference to each element of the specified range of the specified array of Objects.
static void fill(Object[] a, Object val) // Assigns the specified Object reference to each element of the specified array of Objects.
static void fill(short[] a, int fromIndex, int toIndex, short val) // Assigns the specified short value to each element of the specified range of the specified array of shorts.
static void fill(short[] a, short val) // Assigns the specified short value to each element of the specified array of shorts.
static void sort(byte[] a) // Sorts the specified array of bytes into ascending numerical order.
static void sort(byte[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of bytes into ascending numerical order.
static void sort(char[] a) // Sorts the specified array of chars into ascending numerical order.
static void sort(char[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of chars into ascending numerical order.
static void sort(double[] a) // Sorts the specified array of doubles into ascending numerical order.
static void sort(double[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of doubles into ascending numerical order.
static void sort(float[] a) // Sorts the specified array of floats into ascending numerical order.
static void sort(float[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of floats into ascending numerical order.
static void sort(int[] a) // Sorts the specified array of ints into ascending numerical order.
static void sort(int[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of ints into ascending numerical order.
static void sort(long[] a) // Sorts the specified array of longs into ascending numerical order.
static void sort(long[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of longs into ascending numerical order.
static void sort(Object[] a) // Sorts the specified array of objects into ascending order, according to the natural ordering of its elements.
static void sort(Object[] a, Comparator c) // Sorts the specified array of objects according to the order induced by the specified comparator.
static void sort(Object[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of objects into ascending order, according to the natural ordering of its elements.
static void sort(Object[] a, int fromIndex, int toIndex, Comparator c) // Sorts the specified range of the specified array of objects according to the order induced by the specified comparator.
static void sort(short[] a) // Sorts the specified array of shorts into ascending numerical order.
static void sort(short[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of shorts into ascending numerical order.
*/
}
/*********************************************************************
* *
* #Collections: *
* *
* Desc: *
* *
EMPTY_LIST
EMPTY_SET
* Methods: *
* x y y *
binarySearch
copy
enumeration
fill
max
min
nCopies
reverse
reverseOrder
shuffle
singleton
sort
synchronizedCollection
synchronizedList
synchronizedMap
synchronizedSet
synchronizedSortedMap
synchronizedSortedSet
unmodifiableCollection
unmodifiableList
unmodifiableMap
unmodifiableSet
unmodifiableSortedMap
unmodifiableSortedSet
* *
*********************************************************************/
void collections() {
/* TO BE DETERMINED
static List EMPTY_LIST // The empty list (immutable).
static Set EMPTY_SET // The empty set (immutable).
static int binarySearch(List list, Object key) // Searches the specified list for the specified object using the binary search algorithm.
static int binarySearch(List list, Object key, Comparator c) // Searches the specified list for the specified object using the binary search algorithm.
static void copy(List dest, List src) // Copies all of the elements from one list into another.
static Enumeration enumeration(Collection c) // Returns an enumeration over the specified collection.
static void fill(List list, Object o) // Replaces all of the elements of the specified list with the specified element.
static Object max(Collection coll) // Returns the maximum element of the given collection, according to the natural ordering of its elements.
static Object max(Collection coll, Comparator comp) // Returns the maximum element of the given collection, according to the order induced by the specified comparator.
static Object min(Collection coll) // Returns the minimum element of the given collection, according to the natural ordering of its elements.
static Object min(Collection coll, Comparator comp) // Returns the minimum element of the given collection, according to the order induced by the specified comparator.
static List nCopies(int n, Object o) // Returns an immutable list consisting of n copies of the specified object.
static void reverse(List l) // Reverses the order of the elements in the specified list. This method runs in linear time.
static Comparator reverseOrder() // Returns a comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface.
static void shuffle(List list) // Randomly permutes the specified list using a default source of randomness.
static void shuffle(List list, Random rnd) // Randomly permute the specified list using the specified source of randomness.
static Set singleton(Object o) // Returns an immutable set containing only the specified object.
static void sort(List list) // Sorts the specified list into ascending order, according to the natural ordering of its elements.
static void sort(List list, Comparator c) // Sorts the specified list according to the order induced by the specified comparator.
static Collection synchronizedCollection(Collection c) // Returns a synchronized (thread-safe) collection backed by the specified collection.
static List synchronizedList(List list) // Returns a synchronized (thread-safe) list backed by the specified list.
static Map synchronizedMap(Map m) // Returns a synchronized (thread-safe) map backed by the specified map.
static Set synchronizedSet(Set s) // Returns a synchronized (thread-safe) set backed by the specified set.
static SortedMap synchronizedSortedMap(SortedMap m) // Returns a synchronized (thread-safe) sorted map backed by the specified sorted map.
static SortedSet synchronizedSortedSet(SortedSet s) // Returns a synchronized (thread-safe) sorted set backed by the specified sorted set.
static Collection unmodifiableCollection(Collection c) // Returns an unmodifiable view of the specified collection.
static List unmodifiableList(List list) // Returns an unmodifiable view of the specified list.
static Map unmodifiableMap(Map m) // Returns an unmodifiable view of the specified map.
static Set unmodifiableSet(Set s) // Returns an unmodifiable view of the specified set.
static SortedMap unmodifiableSortedMap(SortedMap m) // Returns an unmodifiable view of the specified sorted map.
static SortedSet unmodifiableSortedSet(SortedSet s) // Returns an unmodifiable view of the specified sorted set.
*/
}
/*********************************************************************
* *
* #HashMap: *
* *
* Desc: *
* *
* Methods: *
* x y y *
clear
clone
containsKey
containsValue
entrySet
get
isEmpty
keySet
put
putAll
remove
size
values
* *
*********************************************************************/
void hashmap() {
/* TO BE DETERMINED
void clear() // Removes all mappings from this map.
Object clone() // Returns a shallow copy of this HashMap instance: the keys and values themselves are not cloned.
boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
boolean containsValue(Object value) // Returns true if this map maps one or more keys to the specified value.
Set entrySet() // Returns a collection view of the mappings contained in this map.
Object get(Object key) // Returns the value to which this map maps the specified key.
boolean isEmpty() // Returns true if this map contains no key-value mappings.
Set keySet() // Returns a set view of the keys contained in this map.
Object put(Object key, Object value) // Associates the specified value with the specified key in this map.
void putAll(Map t) // Copies all of the mappings from the specified map to this one.
Object remove(Object key) // Removes the mapping for this key from this map if present.
int size() // Returns the number of key-value mappings in this map.
Collection values() // Returns a collection view of the values contained in this map.
*/
}
/*********************************************************************
* *
* #HashSet: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
clear
clone
contains
isEmpty
iterator
remove
size
* *
*********************************************************************/
void hashset() {
/* TO BE DETERMINED
boolean add(Object o) // Adds the specified element to this set if it is not already present.
void clear() // Removes all of the elements from this set.
Object clone() // Returns a shallow copy of this HashSet instance: the elements themselves are not cloned.
boolean contains(Object o) // Returns true if this set contains the specified element.
boolean isEmpty() // Returns true if this set contains no elements.
Iterator iterator() // Returns an iterator over the elements in this set.
boolean remove(Object o) // Removes the given element from this set if it is present.
int size() // Returns the number of elements in this set (its cardinality).
*/
}
/*********************************************************************
* *
* #LinkedList: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
addAll
addFirst
addLast
clear
clone
contains
get
getFirst
getLast
indexOf
lastIndexOf
listIterator
remove
removeFirst
removeLast
set
size
toArray
* *
*********************************************************************/
void linkedlist() {
/* TO BE DETERMINED
void add(int index, Object element) // Inserts the specified element at the specified position in this list.
boolean add(Object o) // Appends the specified element to the end of this list.
boolean addAll(Collection c) // Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator.
boolean addAll(int index, Collection c) // Inserts all of the elements in the specified collection into this list, starting at the specified position.
void addFirst(Object o) // Inserts the given element at the beginning of this list.
void addLast(Object o) // Appends the given element to the end of this list.
void clear() // Removes all of the elements from this list.
Object clone() // Returns a shallow copy of this LinkedList.
boolean contains(Object o) // Returns true if this list contains the specified element.
Object get(int index) // Returns the element at the specified position in this list.
Object getFirst() // Returns the first element in this list.
Object getLast() // Returns the last element in this list.
int indexOf(Object o) // Returns the index in this list of the first occurrence of the specified element, or -1 if the List does not contain this element.
int lastIndexOf(Object o) // Returns the index in this list of the last occurrence of the specified element, or -1 if the list does not contain this element.
ListIterator listIterator(int index) // Returns a list-iterator of the elements in this list (in proper sequence), starting at the specified position in the list.
Object remove(int index) // Removes the element at the specified position in this list.
boolean remove(Object o) // Removes the first occurrence of the specified element in this list.
Object removeFirst() // Removes and returns the first element from this list.
Object removeLast() // Removes and returns the last element from this list.
Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element.
int size() // Returns the number of elements in this list.
Object[] toArray() // Returns an array containing all of the elements in this list in the correct order.
Object[] toArray(Object[] a) // Returns an array containing all of the elements in this list in the correct order.
*/
}
/*********************************************************************
* *
* #PropertyPermission: *
* *
* Desc: *
* *
* Methods: *
* x y y *
equals
getActions
hashCode
implies
newPermissionCollection
* *
*********************************************************************/
void propertypermission() {
/* TO BE DETERMINED
boolean equals(Object obj) // Checks two PropertyPermission objects for equality.
String getActions() // Returns the "canonical string representation" of the actions.
int hashCode() // Returns the hash code value for this object.
boolean implies(Permission p) // Checks if this PropertyPermission object "implies" the specified permission.
PermissionCollection newPermissionCollection() // Returns a new PermissionCollection object for storing PropertyPermission objects.
*/
}
/*********************************************************************
* *
* #TreeMap: *
* *
* Desc: *
* *
* Methods: *
* x y y *
clear
clone
comparator
containsKey
containsValue
entrySet
firstKey
get
headMap
keySet
lastKey
put
putAll
remove
size
subMap
tailMap
values
* *
*********************************************************************/
void treemap() {
/* TO BE DETERMINED
void clear() // Removes all mappings from this TreeMap.
Object clone() // Returns a shallow copy of this TreeMap instance.
Comparator comparator() // Returns the comparator used to order this map, or null if this map uses its keys' natural order.
boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
boolean containsValue(Object value) // Returns true if this map maps one or more keys to the specified value.
Set entrySet() // Returns a set view of the mappings contained in this map.
Object firstKey() // Returns the first (lowest) key currently in this sorted map.
Object get(Object key) // Returns the value to which this map maps the specified key.
SortedMap headMap(Object toKey) // Returns a view of the portion of this map whose keys are strictly less than toKey.
Set keySet() // Returns a Set view of the keys contained in this map.
Object lastKey() // Returns the last (highest) key currently in this sorted map.
Object put(Object key, Object value) // Associates the specified value with the specified key in this map.
void putAll(Map map) // Copies all of the mappings from the specified map to this map.
Object remove(Object key) // Removes the mapping for this key from this TreeMap if present.
int size() // Returns the number of key-value mappings in this map.
SortedMap subMap(Object fromKey, Object toKey) // Returns a view of the portion of this map whose keys range from fromKey, inclusive, to toKey, exclusive.
SortedMap tailMap(Object fromKey) // Returns a view of the portion of this map whose keys are greater than or equal to fromKey.
Collection values() // Returns a collection view of the values contained in this map.
*/
}
/*********************************************************************
* *
* #TreeSet: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
addAll
clear
clone
comparator
contains
first
headSet
isEmpty
iterator
last
remove
size
subSet
tailSet
* *
*********************************************************************/
void treeset() {
/* TO BE DETERMINED
boolean add(Object o) // Adds the specified element to this set if it is not already present.
boolean addAll(Collection c) // Adds all of the elements in the specified collection to this set.
void clear() // Removes all of the elements from this set.
Object clone() // Returns a shallow copy of this TreeSet instance.
Comparator comparator() // Returns the comparator used to order this sorted set, or null if this tree map uses its keys natural ordering.
boolean contains(Object o) // Returns true if this set contains the specified element.
Object first() // Returns the first (lowest) element currently in this sorted set.
SortedSet headSet(Object toElement) // Returns a view of the portion of this set whose elements are strictly less than toElement.
boolean isEmpty() // Returns true if this set contains no elements.
Iterator iterator() // Returns an iterator over the elements in this set.
Object last() // Returns the last (highest) element currently in this sorted set.
boolean remove(Object o) // Removes the given element from this set if it is present.
int size() // Returns the number of elements in this set (its cardinality).
SortedSet subSet(Object fromElement, Object toElement) // Returns a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive.
SortedSet tailSet(Object fromElement) // Returns a view of the portion of this set whose elements are greater than or equal to fromElement.
*/
}
/*********************************************************************
* *
* #WeakHashMap: *
* *
* Desc: *
* *
* Methods: *
* x y y *
clear
containsKey
entrySet
get
isEmpty
put
remove
size
* *
*********************************************************************/
void weakhashmap() {
/* TO BE DETERMINED
void clear() // Removes all mappings from this map.
boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
Set entrySet() // Returns a Set view of the mappings in this map.
Object get(Object key) // Returns the value to which this map maps the specified key.
boolean isEmpty() // Returns true if this map contains no key-value mappings.
Object put(Object key, Object value) // Updates this map so that the given key maps to the given value.
Object remove(Object key) // Removes the mapping for the given key from this map, if present.
int size() // Returns the number of key-value mappings in this map.
*/
}
/*********************************************************************
* *
* #Collection: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
addAll
clear
contains
containsAll
equals
hashCode
isEmpty
iterator
remove
removeAll
retainAll
size
toArray
* *
*********************************************************************/
void collection() {
/* TO BE DETERMINED
boolean add(Object o) // Ensures that this collection contains the specified element (optional operation).
boolean addAll(Collection c) // Adds all of the elements in the specified collection to this collection (optional operation).
void clear() // Removes all of the elements from this collection (optional operation).
boolean contains(Object o) // Returns true if this collection contains the specified element.
boolean containsAll(Collection c) // Returns true if this collection contains all of the elements in the specified collection.
boolean equals(Object o) // Compares the specified object with this collection for equality.
int hashCode() // Returns the hash code value for this collection.
boolean isEmpty() // Returns true if this collection contains no elements.
Iterator iterator() // Returns an iterator over the elements in this collection.
boolean remove(Object o) // Removes a single instance of the specified element from this collection, if it is present (optional operation).
boolean removeAll(Collection c) // Removes all this collection's elements that are also contained in the specified collection (optional operation).
boolean retainAll(Collection c) // Retains only the elements in this collection that are contained in the specified collection (optional operation).
int size() // Returns the number of elements in this collection.
Object[] toArray() // Returns an array containing all of the elements in this collection.
Object[] toArray(Object[] a) // Returns an array containing all of the elements in this collection whose runtime type is that of the specified array.
*/
}
/*********************************************************************
* *
* #Comparator: *
* *
* Desc: *
* *
* Methods: *
* x y y *
compare
equals
* *
*********************************************************************/
void comparator() {
/* TO BE DETERMINED
int compare(Object o1, Object o2) // Compares its two arguments for order.
boolean equals(Object obj) // Indicates whether some other object is "equal to" this Comparator.
*/
}
/*********************************************************************
* *
* #Iterator: *
* *
* Desc: *
* *
* Methods: *
* x y y *
hasNext
next
remove
* *
*********************************************************************/
void iterator() {
/* TO BE DETERMINED
boolean hasNext() // Returns true if the iteration has more elements.
Object next() // Returns the next element in the interation.
void remove() // Removes from the underlying collection the last element returned by the iterator (optional operation).
*/
}
/*********************************************************************
* *
* #List: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
addAll
clear
contains
containsAll
equals
get
hashCode
indexOf
isEmpty
iterator
lastIndexOf
listIterator
listIterator
remove
remove
removeAll
retainAll
set
size
subList
toArray
* *
*********************************************************************/
void list() {
/* TO BE DETERMINED
void add(int index, Object element) // Inserts the specified element at the specified position in this list (optional operation).
boolean add(Object o) // Appends the specified element to the end of this list (optional operation).
boolean addAll(Collection c) // Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator (optional operation).
boolean addAll(int index, Collection c) // Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
void clear() // Removes all of the elements from this list (optional operation).
boolean contains(Object o) // Returns true if this list contains the specified element.
boolean containsAll(Collection c) // Returns true if this list contains all of the elements of the specified collection.
boolean equals(Object o) // Compares the specified object with this list for equality.
Object get(int index) // Returns the element at the specified position in this list.
int hashCode() // Returns the hash code value for this list.
int indexOf(Object o) // Returns the index in this list of the first occurrence of the specified element, or -1 if this list does not contain this element.
boolean isEmpty() // Returns true if this list contains no elements.
Iterator iterator() // Returns an iterator over the elements in this list in proper sequence.
int lastIndexOf(Object o) // Returns the index in this list of the last occurrence of the specified element, or -1 if this list does not contain this element.
ListIterator listIterator() // Returns a list iterator of the elements in this list (in proper sequence).
ListIterator listIterator(int index) // Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in this list.
Object remove(int index) // Removes the element at the specified position in this list (optional operation).
boolean remove(Object o) // Removes the first occurrence in this list of the specified element (optional operation).
boolean removeAll(Collection c) // Removes from this list all the elements that are contained in the specified collection (optional operation).
boolean retainAll(Collection c) // Retains only the elements in this list that are contained in the specified collection (optional operation).
Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element (optional operation).
int size() // Returns the number of elements in this list.
List subList(int fromIndex, int toIndex) // Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.
Object[] toArray() // Returns an array containing all of the elements in this list in proper sequence.
Object[] toArray(Object[] a) // Returns an array containing all of the elements in this list in proper sequence; the runtime type of the returned array is that of the specified array.
*/
}
/*********************************************************************
* *
* #ListIterator: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
hasNext
hasPrevious
next
nextIndex
previous
previousIndex
remove
set
* *
*********************************************************************/
void listiterator() {
/* TO BE DETERMINED
void add(Object o) // Inserts the specified element into the list (optional operation).
boolean hasNext() // Returns true if this list iterator has more elements when traversing the list in the forward direction.
boolean hasPrevious() // Returns true if this list iterator has more elements when traversing the list in the reverse direction.
Object next() // Returns the next element in the list.
int nextIndex() // Returns the index of the element that would be returned by a subsequent call to next.
Object previous() // Returns the previous element in the list.
int previousIndex() // Returns the index of the element that would be returned by a subsequent call to previous.
void remove() // Removes from the list the last element that was returned by next or previous (optional operation).
void set(Object o) // Replaces the last element returned by next or previous with the specified element (optional operation).
*/
}
/*********************************************************************
* *
* #Map: *
* *
* Desc: *
* *
* Methods: *
* x y y *
interface Map.Entry // A map entry
clear
containsKey
containsValue
entrySet
equals
get
hashCode
isEmpty
keySet
put
putAll
remove
size
values
* *
*********************************************************************/
void map() {
/* TO BE DETERMINED
static interface Map.Entry // A map entry (key-value pair).
void clear() // Removes all mappings from this map (optional operation).
boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
boolean containsValue(Object value) // Returns true if this map maps one or more keys to the specified value.
Set entrySet() // Returns a set view of the mappings contained in this map.
boolean equals(Object o) // Compares the specified object with this map for equality.
Object get(Object key) // Returns the value to which this map maps the specified key.
int hashCode() // Returns the hash code value for this map.
boolean isEmpty() // Returns true if this map contains no key-value mappings.
Set keySet() // Returns a set view of the keys contained in this map.
Object put(Object key, Object value) // Associates the specified value with the specified key in this map (optional operation).
void putAll(Map t) // Copies all of the mappings from the specified map to this map (optional operation).
Object remove(Object key) // Removes the mapping for this key from this map if present (optional operation).
int size() // Returns the number of key-value mappings in this map.
Collection values() // Returns a collection view of the values contained in this map.
*/
}
/*********************************************************************
* *
* #Map.Entry: *
* *
* Desc: *
* *
* Methods: *
* x y y *
equals
getKey
getValue
hashCode
setValue
* *
*********************************************************************/
void map_entry() {
/* TO BE DETERMINED
boolean equals(Object o) // Compares the specified object with this entry for equality.
Object getKey() // Returns the key corresponding to this entry.
Object getValue() // Returns the value corresponding to this entry.
int hashCode() // Returns the hash code value for this map entry.
Object setValue(Object value) // Replaces the value corresponding to this entry with the specified value (optional operation).
*/
}
/*********************************************************************
* *
* #Set: *
* *
* Desc: *
* *
* Methods: *
* x y y *
add
addAll
clear
contains
containsAll
equals
hashCode
isEmpty
iterator
remove
removeAll
retainAll
size
toArray
* *
*********************************************************************/
void set() {
/* TO BE DETERMINED
boolean add(Object o) // Adds the specified element to this set if it is not already present (optional operation).
boolean addAll(Collection c) // Adds all of the elements in the specified collection to this set if they're not already present (optional operation).
void clear() // Removes all of the elements from this set (optional operation).
boolean contains(Object o) // Returns true if this set contains the specified element.
boolean containsAll(Collection c) // Returns true if this set contains all of the elements of the specified collection.
boolean equals(Object o) // Compares the specified object with this set for equality.
int hashCode() // Returns the hash code value for this set.
boolean isEmpty() // Returns true if this set contains no elements.
Iterator iterator() // Returns an iterator over the elements in this set.
boolean remove(Object o) // Removes the specified element from this set if it is present (optional operation).
boolean removeAll(Collection c) // Removes from this set all of its elements that are contained in the specified collection (optional operation).
boolean retainAll(Collection c) // Retains only the elements in this set that are contained in the specified collection (optional operation).
int size() // Returns the number of elements in this set (its cardinality).
Object[] toArray() // Returns an array containing all of the elements in this set.
Object[] toArray(Object[] a) // Returns an array containing all of the elements in this set whose runtime type is that of the specified array.
*/
}
/*********************************************************************
* *
* #SortedMap: *
* *
* Desc: *
* *
* Methods: *
* x y y *
interface Map.Entry // A map entry
clear
containsKey
containsValue
entrySet
equals
get
hashCode
isEmpty
keySet
put
putAll
remove
size
values
* *
*********************************************************************/
void sortedmap() {
/* TO BE DETERMINED
Comparator comparator() // Returns the comparator associated with this sorted map, or null if it uses its keys' natural ordering.
Object firstKey() // Returns the first (lowest) key currently in this sorted map.
SortedMap headMap(Object toKey) // Returns a view of the portion of this sorted map whose keys are strictly less than toKey.
Object lastKey() // Returns the last (highest) key currently in this sorted map.
SortedMap subMap(Object fromKey, Object toKey) // Returns a view of the portion of this sorted map whose keys range from fromKey, inclusive, to toKey, exclusive.
SortedMap tailMap(Object fromKey) // Returns a view of the portion of this sorted map whose keys are greater than or equal to fromKey.
*/
}
/*********************************************************************
* *
* #SortedSet: *
* *
* Desc: *
* *
* Methods: *
* x y y *
comparator
first
headSet
last
subSet
tailSet
* *
*********************************************************************/
void sortedset() {
/* TO BE DETERMINED
Comparator comparator() // Returns the comparator associated with this sorted set, or null if it uses its elements' natural ordering.
Object first() // Returns the first (lowest) element currently in this sorted set.
SortedSet headSet(Object toElement) // Returns a view of the portion of this sorted set whose elements are strictly less than toElement.
Object last() // Returns the last (highest) element currently in this sorted set.
SortedSet subSet(Object fromElement, Object toElement) // Returns a view of the portion of this sorted set whose elements range from fromElement, inclusive, to toElement, exclusive.
SortedSet tailSet(Object fromElement) // Returns a view of the portion of this sorted set whose elements are greater than or equal to fromElement.
*/
}
}