Welcome to CIS 1100’s JavaDocs! This will serve as a means to document what functions are fair game for student usage to better assist with homework and exam prep. As always, please direct all questions to Ed and/or Office Hours!
Notes before reading the docs:
()
, while static values such as Integer.MAX_VALUE
, Math.PI
etc. are constants with some value.In.java
and PennDraw.java
have their own reference pages linked in the headers.public static double MAX_VALUE;
Definition: Maximum value a double can store
Use Case:
double x = Double.MAX_VALUE;
double y = Double.max_value; // Error (it's case sensitive)
public static double MIN_VALUE;
Definition: Minimum value a double can store
Use Case:
double x = Double.MIN_VALUE;
double y = Double.min_value; // Error (it's case sensitive)
public static double POSITIVE_INFINITY;
Definition: Representation of positive infinity (\(\infty\)) in Java
Use Case:
double x = Double.POSITIVE_INFINITY;
double y = Double.positive_infinity; // Error (case sensitive)
public static double NEGATIVE_INFINITY;
Definition: Representation of negative infinity (\(-\infty\)) in Java
Use Case:
double x = Double.NEGATIVE_INFINITY;
double y = Double.negative_infinity; // Error (case sensitive)
public double parseDouble() {...}
Definition: parseDouble()
reads a string and returns a number if it contains one, else throws a NumberFormatException
if string has no number, or NullPointerException
if the string is null
Use Case:
double x = Double.parseDouble("1100"); // returns 1100.0
double y = Double.parseDouble("cis1100"); // NumberFormatException
String s; // s is null
double z = Double.parseDouble(s); // NullPointerException
public int parseInt() {...}
Definition: parseInt()
reads a String
and returns a number if it contains one, else throws a NumberFormatException
Use Case:
int x = Integer.parseInt("-1100"); // returns -1100
int y = Integer.parseInt("cis1100"); // NumberFormatException
String s; // s is null
int y = Integer.parseInt(s); // NumberFormatException
// (NOT a NullPointerException as seen in Double.parseDouble() with a null string)
public static int MAX_VALUE;
Definition: Maximum value an int can store (\(2^{31} - 1\))
Use Case:
int x = Integer.MAX_VALUE;
int y = Integer.max_value; // Error (it's case sensitive)
public static int MIN_VALUE;
Definiton: Minimum value an int can store (\(-2^{31}\))
Use Case:
int x = Integer.MIN_VALUE;
int y = Integer.min_value; // Error (it's case sensitive)
public static double abs(double/int a) {...}
Definition: Takes in a double
or int
as argument, and returns absolute value of respective type
Use Case:
double x = Math.abs(-3); // returns 3
double y = Math.abs(-245.34); // returns 245.34
int x = Math.abs(-2.3); // Error (type mismatch)
public static double ceil(double a) {...}
Definition: Returns the smallest double
value \(\geq a\) which is an integer
Use Case:
double x = Math.ceil(-5.5); // returns -5.0
double y = Math.ceil(3.2); // returns 4.0
double z = Math.ceil(2); // returns 2.0
int p = Math.ceil(2.4); // Error (assigning double to int)
public static double floor(double a) {...}
Definition: Returns the largest double
value \(\leq a\) which is an integer
Use Case:
double x = Math.floor(-5.5); // returns -6.0
double y = Math.floor(3.2); // returns 3.0
double z = Math.floor(2); // returns 2.0
int p = Math.floor(2.4); // Error (assigning double to int)
public static double max(double/int a, double/int b) {...}
Definition: Returns the larger of 2 values. (In case of doubles, +0 > -0)
Use Case:
double a = 7;
double b = 3;
double maxVal = Math.max(a, b); // returns 7
public static double min(double/int a, double/int b) {...}
Definition: Returns the smaller of 2 values. (In case of doubles, -0 < +0)
Use Case:
double a = 7;
double b = 3;
double minVal = Math.min(a, b); // returns 3
public static double random() {...}
Definition: Generates a pseudo-random double
[0, 1) (1 isn’t a possible result, 0 is).
Let’s say we wanted to generate \([3,\ldots,6]\) inclusive, as integers, we would do the following:
int x = (int) (3 + Math.random() * 4)
More generally for range \([\texttt{low},\ldots,\texttt{high}]\):
int range = low + (int) (Math.random() * (high - low + 1))
Other Use Cases:
double x = Math.random(); // can store in variable
if (Math.random() > 0.5) { ... } // or, can call it directly
boolean b = Math.random() < 1; // ALWAYS true
public static double PI;
Definition: Stores the value of \(\pi\)
Use Case:
double pi = Math.PI;
double x = Math.pi; // Error (case sensitive)
public static double pow(double base, double exponent) {...}
Definition: Returns \(\texttt{base}^{\texttt{exponent}}\).
Note Inefficiency - squaring and cubing should instead be \(x * x\) and \(x * x * x\), as Math.pow()
is inefficient for low powers.
Use Case:
double x = Math.pow(-3, 3); // returns -27.0
double y = Math.pow(2, 2); // returns 4.0
double z = Math.pow(4, -1); // returns 0.25
public static double sqrt(double a) {...}
Definition: Returns \(\sqrt a\)
Note: Math.sqrt()
of a negative number just gives you NaN
(Not a Number).
Use Case:
double x = Math.sqrt(25); // returns 5.0
double y = Math.sqrt(2); // returns 1.4142135623730951
double z = Math.sqrt(-4); // returns NaN
public char charAt(int index) {...}
Definition: charAt
returns the character at the specified index of the String
variable. Make sure the index is within the bounds of the String!
Use Case:
String s = "CIS1100";
s.charAt(0); // returns 'C'
s.charAt(7); // throws IndexOutOfBoundsException
public boolean equals(Object anObject) {...}
Definition: equals
will compare the String
with another String
passed into the function and check for equality. Make sure to use .equals()
rather than comparing two strings with ==.
Use Case:
String s = "CIS1100";
s.equals("CIS1100"); // returns true
s.equals("CIS1200"); // returns false
public int indexOf(int ch) {...}
Definition: indexOf
will return the first index that the character (represented as an integer) ch
appears at in the String
. If the character does not appear in the String
, then indexOf
returns -1.
Use Case:
String s = "CIS1100";
s.indexOf('C'); // returns 0
s.indexOf('2'); // returns -1
public int length() {...}
Definition: length returns the length of this String
.
Use Case:
String s = "CIS1100";
s.length(); // returns 7
public String substring(int beginIndex) {...}
Definition: substring(int beginIndex)
will return a substring of this String
that begins at the index beginIndex
and ends at the end of the String
. substring()
is overloaded.
public String substring(int beginIndex, int endIndex) {...}
Definition: substring(int beginIndex, int endIndex)
returns a substring of this String
that begins at the index beginIndex
and ends at the index endIndex - 1
inclusive (that is, endIndex
is not included).
In both cases, if beginIndex
or endIndex
are out of bounds of the String’s length, or if beginIndex
> endIndex
, substring()
will throw an IndexOutOfBoundsException
.
Use Case:
String s = "CIS1100";
s.substring(3); // returns "1100"
s.substring(2, 5); // returns "S11"
s.substring(-4); // throws IndexOutOfBoundsException
s.substring(2, 10); // throws IndexOutOfBoundsException
s.substring(5, 2); // throws IndexOutOfBoundsException
public String toLowerCase() {...}
Definition: toLowerCase()
converts all the characters in the String
to lowercase characters. Doesn’t change non-letter characters, such as numbers and punctuation.
Use Case:
String s = "CIS1100";
s.toLowerCase(); // returns "cis1100"
System.out.println(s) // prints "CIS1100" becuase strings are immutable
s = s.toLowerCase();
System.out.println(s); // now prints "cis1100"
public String toUpperCase() {...}
Definition: toUpperCase()
converts all the characters in the String
to uppercase characters. Again, doesn’t change non-letter characters, such as numbers and punctuation.
Use Case:
String s = "cis1100";
s.toUpperCase(); // returns "CIS1100"
System.out.println(s) // prints "cis1100" becuase strings are immutable
s = s.toUpperCase();
System.out.println(s); // now prints "CIS1100"