Class objects can be used as type specifications too, at runtime. For instance, you can create a generified method like this:
public static <T> T getInstance(Class<T> theClass)
throws IllegalAccessException, InstantiationException {
return theClass.newInstance();
}
Here are a few examples of calls to the getInstance() method:
String string = getInstance(String.class);
MyClass myClass = getInstance(MyClass.class);
As you can see the return type changes depending on what class object you pass in as parameter to the method. This can be quite handy in database API's like Butterfly Persistence where you read objects from a database. Here is an example method definition:
public static <T> T read(Class<T> theClass, String sql)
throws IllegalAccessException, InstantiationException {
//execute SQL.
T o = theClass.newInstance();
//set properties via reflection.
return o;
}
Here is how you would call the read() method:
Driver employee = read(Driver.class, "select * from drivers where id=1");
Vehicle vehicle = read(Vehicle.class, "select * from vehicles where id=1");
List<? extends Vehicle> vehicles = new ArrayList<? extends Vehicle>(); Vehicle. I can now define the printElements() method like this:public void printElements(List<? extends Vehicle> elements){
for(Vehicle o : elements){
System.out.println(o);
}
}Vehicle, as it is done by the new for loop inside the method. List<Car> instance, provided that Car extends Vehicle. Here is an example: List<Car> elements = new ArrayList<Car>
// ... add Car elements to the list.
printElements(elements);
List. After all, a Car is always a Vehicle, but a Vehicle is not always a Car.'?' is a wild-card character and it stands for any Java type. It can be java.lang.Object type or some other type. It is just a place-holder that tells that it can be assigned with any type. Considering this case, the following are now valid syntaxes. List<?> anyObjects = null;
List<Integer> integers = new ArrayList<Integer>();
anyObjects = integers;
List<Double> doubles = new ArrayList<Double>();
anyObjects = doubles;
List using the wildcard operator:List<?> listOfUnknown = new ArrayList<?>();
printElements() method like this:public void printElements(List<?> elements){
for(Object o : elements){
System.out.println(o);
}
}
You can call the
printElements() with any generified List instance. For instance: List<String> elements = new ArrayList<String>
// ... add String elements to the list.
printElements(elements);
When you upcast a
List<String> to a List<?> you can now read all elements of the List<?> safely as Object instances. But you still cannot insert elements into the List<?>. The ? could represent any type, and thus it would be possible to insert types that did not match the original definition of the List. Let’s test our understanding of generics. Is the following code snippet legal?
List<String> ls = new ArrayList<String>(); //1List<Object> lo = ls; //2
Line 1 is certainly legal. The trickier part of the question is line 2. This boils down
to the question: is a List of String a List of Object. Most people’s instinct is to answer:
“sure!”.
Well, take a look at the next few lines:
lo.add(new Object()); // 3String s = ls.get(0); // 4: attempts to assign an Object to a String!
Here we’ve aliased ls and lo. Accessing ls, a list of String, through the alias lo, we
can insert arbitrary objects into it. As a result ls does not hold just Strings anymore,
and when we try and get something out of it, we get a rude surprise.
The Java compiler will prevent this from happening of course. Line 2 will cause a
compile time error.
In general, if Foo is a subtype (subclass or subinterface) of Bar, and G is some
generic type declaration, it is not the case that G<Foo> is a subtype of G<Bar>.
This is probably the hardest thing you need to learn about generics, because it goes
against our deeply held intuitions.
So we had list of String not subtype of list of Objects.
The problem with that intuition is that it assumes that collections don’t change.
Our instinct takes these things to be immutable.
For example, if the department of motor vehicles supplies a list of drivers to the census
bureau, this seems reasonable. We think that a List<Driver> is a List<Person>,
assuming that Driver is a subtype of Person. In fact, what is being passed is a copy
of the registry of drivers. Otherwise, the census bureau could add new people who are
not drivers into the list, corrupting the DMV’s records.
In order to cope with this sort of situation, it’s useful to consider more flexible
generic types. The rules we’ve seen so far are quite restrictive.
java.util:
public interface List<E> {
void add(E x);
Iterator<E> iterator();
}
public interface Iterator<E> {
E next();
boolean hasNext();
}
public interface IntegerList {
void add(Integer x);
Iterator<Integer> iterator();
}
List myIntList = new LinkedList(); // line no. 1
myIntList.add(new Integer(0)); // line no. 2
Integer x = (Integer) myIntList.iterator().next(); //line no. 3
List<Integer> myIntList = new LinkedList<Integer>(); // 1’
//OR
List<Integer> myIntList = new LinkedList(); // 1’
myIntList.add(new Integer(0)); //2’
Integer x = myIntList.iterator().next(); // 3’
In addition to the regular expression methods that are available in the String class (see String Regular Expressions), there are two classes that are specifically user for regular expression matching.
java.util.regex.Pattern precompiles regular expressions so they can be executed more efficiently. It also has a few utility functions. This same pattern can be reused by many Matcher objects. Pattern pat = Pattern.compile(regexString);
java.util.regex.Matcher objects are created from a Pattern object and a subject string to scan. This class provides a full set of methods to do the sacnning. Matcher m = pat.matcher(subject);
The following variables represent elements of their declared type in the prototypes below.
import java.util.regex.*;
. . .
boolean b; // may be used in if statement.
int i; // index or character position.
int g; // group number
int n; // number of groups
CharSequence cs; // effectively either String or StringBuffer
String s; // Subject string.
String regex; // Regular expression string.
StringBuffer sb; // Used to build up string from repeated scans.
Pattern p = Pattern.compile(regex); // Compiles regular expression into Pattern.
Matcher m = p.matcher(s); // Creates Matcher with subject s and Pattern p.
Result
Method
Description
Creating a Pattern
p = Pattern.compile(regex);
Creates Pattern based on regex. May throw PatternSyntaxException.
p = Pattern.compile(regex, f);
As above. Flag f can be Pattern.CASE_INSENSITIVE, ....
Finding pattern matches
b = m.find();
True if pattern can be found in the subject string. First call starts trying at beginning of string. Subsequent calls start after last character previously matched, which makes it good for a while loop.
b = m.find(i);
True if pattern can match somewhere at or after position i.
b = m.matches();
True if pattern matches entire subject string.
b = Pattern.matches(regex, s);
As above, but less efficient if regex used more than once.
b = m.lookingAt();
True if pattern matches starting at first char.
Getting results of last pattern match. Corresponds to group 0, then entire match.
s = m.group();
String which was matched.
i = m.start();
Index of first character of match.
i = m.end();
Index of last character plus 1 of match.
Getting group results of last match
s = m.group(g);
String which was matched by group g.
i = m.start(g);
Index of first character of group g.
i = m.end(g);
Index of last character plus 1 of group g.
n = m.groupCount();
Number of groups that were matched.
Misc
m = m.reset();
Resets Matcher m so that next find starts at beginning.
m = m.reset(cs);
Resets Matcher m to match subject cs.
Replacing text
s = m.replaceFirst(rep);
Returns string which is subject with first match replaced by rep.
s = m.replaceAll(rep);
Returns string with all matches replaced by rep.
Building replacement in a StringBuffer
m = m.appendReplacement(sb, s);
When it matches, (1) everything skipped before the match is appended to the StringBuffer sb, then (2) it appends s, with "$n" replaced by group n.
sb = m.appendTail(sb);
Appends last part that m didn't match to StringBuffer. Useful after loop calling appendReplacement() to finish.
Regular expressions are the most common programming technique to search for patterns in strings, extracting, and replacing substrings. They are an essential part of many languages, editors, and utilities, for example, Perl, JavaScript, awk, sed, vi, ....
They are powerful and useful. Simple regexes are simple, but large regexes are extremely difficult to debug. They are often not the right solution for complex parsing problems. Two quotes illustrate some feelings about them. Despite the name, as someone said, Regular expressions are neither regular nor expressions. And Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems. Regular expressions form a quirky, error-prone, terse, but useful, programming language for pattern matching.
Java, as of version 1.4, has extensive support for regular expressions in two areas.
java.util.Pattern and java.util.Matcher, allow use of precompiled regular expressions as well as providing many additional functions. See Pattern and Matcher. Regular expressions provide more general mechanisms for parsing input strings than, eg, StringTokenizer.
Programming language. Regular expressions (often refereed to as regex) are essentially a programming language of their own.
This program reads in a file name and displays the extension (that last part of the name after the final dot).
import javax.swing.*;
public class FileExt {
public static void main(String[] args) {
//... Declare local variables.
String fileName; // The file name the user entered.
String extension; // The extension.
//... Input a file name and remove whitespace.
fileName = JOptionPane.showInputDialog(null, "Enter file name.");
fileName = fileName.trim();
//... Find the position of the last dot. Get extension.
int dotPos = fileName.lastIndexOf(".");
extension = fileName.substring(dotPos);
//... Output extension.
JOptionPane.showMessageDialog(null, "Extension is " + extension);
}
}
Here is a simple, but slow, program to concatenate all of the strings in an array, each separated by a specifed string separater.
//-------------------------------------------------- arrayToString()
// Convert an array of strings to one string.
// Put the 'separator' string between each element.
public static String arrayToString(String[] a, String separator) {
String result = "";
if (a.length > 0) {
result = a[0]; // start with the first element
for (int i=1; i<a.length; i++) {
result = result + separator + a[i];
}
}
return result;
}
The problem with the above program is that a new String object is created each time thru the loop, and the old String object becomes eligible for garbage collection. This constant creation and abandoning objects is terribly inefficient. A more efficient way to do this is to use a StringBuffer or the equivalent Java 5 StringBuilder, which will grow as needed, but generally only has to expand a few times to do the job.
//-------------------------------------------------- arrayToString2()
// Convert an array of strings to one string.
// Put the 'separator' string between each element.
public static String arrayToString2(String[] a, String separator) {
StringBuffer result = new StringBuffer();
if (a.length > 0) {
result.append(a[0]);
for (int i=1; i<a.length; i++) {
result.append(separator);
result.append(a[i]);
}
}
return result.toString();
}
Problem: Change the extension of a file name
//============================================== changeExtension
// changes extension to new extension
// example: x = changeExtension("data.txt", ".java")
// will assign "data.java" to x.
static String changeExtension(String originalName, String newExtension) {
int lastDot = originalName.lastIndexOf(".");
if (lastDot != -1) {
return originalName.substring(0, lastDot) + newExtension;
} else {
return originalName + newExtension;
}
}//end changeExtension
//========================================================= isPalindrome
// This method returns 'true' if the parameter
// is a palindrome, a word that is spelled the
// same both forwards and backwards, eg, radar.
public static boolean isPalindrome(String word) {
int left = 0; // index of leftmost unchecked char
int right = word.length() -1; // index of the rightmost
while (left < right) {
// continue until they reach center
if (word.charAt(left) != word.charAt(right)) {
return false;// if chars are different, finished
}
left++; // move left index toward the center
right--; // move right index toward the center
}
return true; // if finished, all chars were same
}
This method uses two indexes that point to the left and right ends of the string. You could also write this with a for loop that goes only to the middle.
Problem: Write a method to replaces all occurences a word in a string with another word. Assume the method signature is
static String replaceWord(String original, String find, String replacement)
Note that Strings are immutable, so we must create a new String. The word "replace" is probably misleading. Also, the method is static because it doesn't reference instance variables. This allows some optimizations by the compiler.
This first attempt only replaces one word, but we could fix that up later with a loop -- but it's not worth the effort because it's wrong anyway.
//--------------------------------------------- replaceWord()
// BAD BAD BAD BAD BAD
static String replaceWord(String original, String find, String replacement) {
int i = original.indexOf(find);
if (i < 0) {
return original; // return original if 'find' is not in it.
}
String partBefore = original.substring(0, i);
String partAfter = original.substring(i + find.length());
return partBefore + replacement + partAfter;
}
This example method replaces the first occurrence of a one string with another. If we execute the following code,
t = "A great man";
s = replaceWord(t, "man", "woman");
the value in s will be "A great woman". Ok, but what if we changed the orginal string to contain the word "human", or anything else that contained a substring, but not a separate word, that has "man" in it.
t = "A great human";
s = replaceWord(t, "man", "woman");
Now s will contain "A great huwoman". Not what was intended.
Simply finding a substring isn't sufficient. There are several ways to solve the problem.
This replaces all occurences of a "word", not just the first.
static String replaceAllWords1(String original, String find, String replacement) {
String result = "";
String delimiters = "+-*/(),. ";
StringTokenizer st = new StringTokenizer(original, delimiters, true);
while (st.hasMoreTokens()) {
String w = st.nextToken();
if (w.equals(find)) {
result = result + replacement;
} else {
result = result + w;
}
}
return result;
}
This breaks the string into tokens, consisting of the text between delimiters, as well as the tokens consisting of the delimiters. The true parameter causes the delimiters to also be returned as tokens. You might not need them if you are only interested in what comes between them. Naturally, you would choose the delimiters appropriate to your problem.
Buiding a string by sucessive concatenations is inefficient, as it creates new string as it is immutable and should be replaced by StringBuilder (or the equivalent pre-Java 5 StringBuffer) for efficiency. See below.
Creating new strings in a loop can be inefficient because of the number of new objects that are created and discarded. It's better to use a StringBuilder (introduced Java 5) or the slightly slower, synchronized, StringBuffer, which has been in Java from the beginning.
static String replaceAllWords2(String original, String find, String replacement) {
StringBuilder result = new StringBuilder(original.length());
String delimiters = "+-*/(),. ";StringTokenizer st = new StringTokenizer(original, delimiters, true);
while (st.hasMoreTokens()) {
String w = st.nextToken();
if (w.equals(find)) {
result.append(replacement);
} else {
result.append(w);
}
}
return result.toString();
}
This creates a StringBuilder with an initial capacity equal to the original string. It will expand if necessary, so this initial capacity isn't critical. Theappend(...)method is used to add to the end of it. ThetoString()call at the end returns a String. This is an efficient conversion.
split(regex) - Probably the easiest.java.util.Scanner - This can "read" from strings. Very general.java.util.regex. Pattern and Matcher use regular expressions - The most powerful solution. java.util.StringTokenizer - This has been superceded by regular expressions, Scanner, and split().split(...) method. For example,String test = "It's the number 1 way.";Produces the following output:
String[] tokens = test.split(" "); // Single blank is the separator.
System.out.println(Arrays.toString(tokens));
[It's, the, number, 1, way.]
String test = "It's the number 1 way.";
ArrayList<String> tokens = new ArrayList<String>();
Scanner tokenize = new Scanner(test);
while (tokenize.hasNext()) {
tokens.add(tokenize.next());
}
System.out.println(tokens);
[It's, the, number, 1, way.]It doesn't care about what makes up a "token", only that they must be separated by single blanks. To allow one or more blanks as a separator, use " +", which means one or more blanks.
String s; int i; long l; float f; double d;
| type | Example statement |
int | i = Integer.parseInt(s); |
long | l = Long.parseLong(s); |
float | f = Float.parseFloat(s); |
double | d = Double.parseDouble(s); |
NumberFormatException. See below. try . . . catch statement so that you can do something if bad input is entered. The conversion method will throw a NumberFormatException when there is bad input. Catch the NumberFormatException, and do something to handle this error condition. Put your conversion in the try clause, and the error handling in the catch clause. Here is an example of the kind of utility function you might write to do this checking. //--- Utility function to get int using a dialog.
public static int getInt(String mess) {
int val;
while (true) { // loop until we get a valid int
String s = JOptionPane.showInputDialog(null, mess);
try {
val = Integer.parseInt(s);
break; // exit loop with valid int >>>>>>>>>>>>>>>>>>>>>>
}catch (NumberFormatException nx) {
JOptionPane.showMessageDialog(null, "Enter valid integer");
}
}
return val;
}//end getInt
| type | Example statement |
int | i = Integer.parseInt(s, radix); |
long | l = Long.parseLong(s, radix); |
i = Integer.parseInt("F7", 16)
public enum Color {
//
RED, BLUE, YELLOW, GREEN, ORANGE, PURPLE;
public static EnumSet<Color> getPrimaryColors() {
return EnumSet.of(RED, BLUE, YELLOW);
}
public static EnumSet<Color> getSecondaryColors() {
return EnumSet.complementOf(getPrimaryColors());
}
public static void main(String[] args) {
System.out.println("Primary Colors: "+Color.getPrimaryColors());
System.out.println("Secondary Colors: "+Color.getSecondaryColors());
System.out.println("Universe: "+EnumSet.allOf(Color.class));
}
}
public enum Shape { RECTANGLE, CIRCLE, LINE } The valueOf() method can be used to convert a string value to an enum value. Here is an example of reading in a Shape value from a Scanner object in. drawing = Shape.valueOf(in.next());or
drawing = Shape.valueOf("RECTANGLE") We can have custom methods to deal with this, if we dont want to have some extra customization.public enum Blah {
A("text1"),
B("text2"),
C("text3"),
D("text4");
private String text;
Blah(String text) {
this.text = text;
}
public String getText() {
return this.text;
}
public static Blah fromString(String text) {
if (text != null) {
for (Blah b : Blah.values()) {
if (text.equalsIgnoreCase(b.text)) {
return b;
}
}
return null;
}
}
public enum Shape { RECTANGLE, CIRCLE, LINE }Shape drawing = Shape.RECTANGLE; // Only a Shape value can be assigned.
System.out.println(drawing); // Prints RECTANGLE
public enum Color {
WHITE, BLACK, RED, YELLOW, BLUE; //; is required here.
@Override public String toString() {
//only capitalize the first letter
String s = super.toString();
return s.substring(0, 1) + s.substring(1).toLowerCase();
}
}public enum MyType {
ONE {
public String toString() {
return "this is one";
}
},
TWO {
public String toString() {
return "this is two";
}
}
}public class EnumTest {
public static void main(String[] args) {
System.out.println(MyType.ONE);
System.out.println(MyType.TWO);
}
}
-------------
this is one
this is twoMyType.class
MyType$1.class
MyType$2.classjava.lang.Enum. Since java doesn't allow multiple inheritance, enum types can't have superclass. They can't even extend from java.lang.Enum, nor java.lang.Object. It also means enum A can't inherit or extend enum B.public enum MyType extends Object {
ONE, TWO
}MyType.java:3: '{' expectedpublic enum MyType extends Object {
MyType.java:6: expected
2 errors The correct form should be:public enum MyType {
ONE, TWO
}
java.io.Serializable, and java.lang.Comparable.public enum Color implements Runnable {
WHITE, BLACK, RED, YELLOW, BLUE;
public void run() {
System.out.println("name()=" + name() +
", toString()=" + toString());
}
}A sample test program to invoke this run() method:for(Color c : Color.values()) {
c.run();
}Or,for(Runnable r : Color.values()) {
r.run();
}
public enum Color { //Color is of type enumWHITE(21), BLACK(22), RED(23), YELLOW(24), BLUE(25);
private int code;
private Color(int c) {
code = c;
}
public int getCode() {
return code;
}
public enum Shape { RECTANGLE, CIRCLE, LINE }switch statement was enhanced to allow a convenient use of enums. Note that the case values don't have to be qualified with the enum class name, which can be determined from the switch control value. switch (drawing) {
case RECTANGLE: g.drawRect(x, y, width, height);
break;
case CIRCLE : g.drawOval(x, y, width, height);
break;
case LINE : g.drawLine(x, y, x + width, y + height);
break;
}
You can use a format, a string which tells how you want values converted to string.
The basic support is in the java.util.Formatter class, where a Formatter object is created and it's format method is called. However, it's more common to use one of these convenience methods:
String.format(format, values...) System.out.printf(format, values...) or System.err.print.%[argument_index$][flags][width][.precision]conversion
%[argument_index$][flags][width][.precision]conversion
%[flags][width]conversion
Like C's printf. If you are familiar with C's printf formats, you will be very comfortable with Java's formats, although they are slightly different.
Sun's Java documentation has a full description of the formatting codes. You should download the latest version of the API documentation. Here is a link to Java version 5 documentation: java.sun.com/j2se/1.5.0/docs/api/java/util/Formatter.html .
String
The basic class for strings. String objects can NOT be changed.
char
Primitive type for 16-bit Unicode characters.
Character
Primarily useful for its utility functions for working with characters.
StringBuffer
StringBuffers are used to build or change strings. Conversion between String and StringBuffer is easy.
StringBuilder
StringBuilder was added in Java 5. It is the same as StringBuilder, but slightly faster because it's unsynchronized.
StringTokenizer
Used to break a String into tokens (words).
BufferedReaderBufferedWriter
Useful for reading and writing text files.
Pattern, Matcher
JDK 1.4 added java.util.Pattern and Matcher to do regular expression matching.
The java.util.Collections class contains static utility methods for manipulating collections.
Assume the following declarations have been made, where T is a class or interface type.
int i;
List<T> listC; // List of the Comparable objects.
List<T> list; // Any kind of list. Need not be Comparable.
Comparator<T> comp;
T key;
T t;
Collection<T> coll; // Any kind of Collection (List, Set, Deque).
Collection<T> collC; // Any kind of Collection implementing Comparable.
Rearranging - Sorting, Shuffling, . . .
Collections.sort(listC)
Sorts listC. Elements must be Comparable<T>. Stable, O(N log N).
Collections.sort(list, comp)
Sorts list using a comparator.
Collections.shuffle(list)
Puts the elements of list in random order.
Collections.reverse(list)
Reverses the elements of list.
Searching
i = Collections.binarySearch(listC, key)
Searches list for key. Returns index of element or negative value if not found. See Binary Search.
i = Collections.binarySearch(list, key, comp)
Searches in list for key using Comparator comp.
t = Collections.max(collC)
Returns maximum valued Comparable object in collC.
t = Collections.max(coll, comp)
Maximum valued object in coll using Comparator comp.
t = Collections.min(collC)
Returns minimum valued Comparable object in collC.
t = Collections.min(coll, comp)
Minimum valued object in coll using Comparator comp.
There are many additional methods in Collections, but the above are a good start.
All List and Set classes implement the contains() method, which performes a linear search on lists (O(N)), a binary search for TreeSets (O(log N)), and a hashed search for HashSets (O(1)).
Maps define get() to search for the key. For HashMaps the search is O(1), and for TreeMaps the search is O(log N).
TreeSet data and TreeMap keys are sorted at all times. They are implemented as binary trees, so insertion and search are both O(log N). An iterator can be used to get retrieve the data (TreeSets) or keys (TreeMaps) in sorted order. Either the element class must be Comparable, or a Comparator must be supplied.
//define the variables int age, gender, height;
short packed_info;
. . .
// packing
packed_info = (((age << 1) | gender) << 7) | height;
. . .
// unpacking
height = packed_info & 0x7f;
gender = (packed_info >>> 7) & 1;
age = (packed_info >>> 8);
y = x << 3; // Assigns 8*x to y.
y = (x << 2) + x; // Assigns 5*x to y.
x = x ^ 1; // Or the more cryptic x ^= 1;
(a & b) - Result is 1 in every bit position where both operands have a 1. (a | b) - Result is 1 only in positions where one or both operands have a 1. (a ^ b)- Result is 1 in positions where the two corresponding bits are different. (~a) - Unary operator. Result is each bit of operand inverted. (a << n) - Shifts bits n positions left. Zeros added on right. (a >> n) - Shifts bits n positions right. High-order bit inserted on left. (a >>> n) - Shifts bits n positions right. Zeros inserted at left.Mathematical tradition, which programming languages generally try to match, dictates that some operations are done before others (for example, multiplication and division are done before addition and subtraction).
a+b*c is the same as a+(b*c), not (a+b)*c.
Ever operator has a precedence (a number) associated with it. The precedence determines which operations will be performed first. Multiplication has higher precedence than addition, as illustrated in the previous example..
In addition to the precedence of each operator, the compiler also knows whether equal-precedence operators should be performed left-to-right (almost all) or right-to-left (basically only assignment).
If you have any doubt about the order of evaluation, or have a potentially confusing expression, use parentheses. Remember that one of your goals should be to make your programs as readable as possible. Use parentheses when it makes an expression easier to read, not must when they are absolutely required. Few programmers know the precedence of all operators, so it's common for extra parentheses to be used.
Unary operators have only one operand, for example, in
a = -b;
The "-" operator is the unary (one operand) operator which changes the sign of its operand.
a = b - c
The "-" operator is a binary (two operand) operator which subtracts c from b.
Most unary operators are performed before binary operators (exceptions "." (qualification), "[]" (subscription), and "()" (method call).
When you can work out the precedence, it's often useful to use parentheses to figure out the order of evaluation. For example, let's say you're evaluating the following expression.
1 + 2 - 3 * 4 / 5
Addition and subtraction are equal in precedence and lower than multiplication and division, which are equal. Form the parenthesized form and work out the values in steps.
1 + 2 - 3 * 4 / 5= (1 + 2) - ((3 * 4) / 5)= 3 - (12/5)= 3 - 2 The result of the integer division, 12/5, is 2 . = 1This table gives the precedence of all operators. You may not be familiar with all operators, but take the advice on the right side and only learn a few precedences.
Operator Precedence
. [] (args) post ++ --
! ~ unary + - pre ++ --
(type) new
* / %
+ -
<< >> >>>
< <= > >= instanceof
== !=
&
^
|
&&
||
?:
= += -= etc
Let's look at the expression x = a+b-c*d/e, which can be parenthesized as x = ((a+b) - ((c*d)/e)). Instead of parentheses, we can draw a diagram.
This dataflow diagram shows another way to think about expression evaluation.
Boxes represent values in memory, ovals represent operations, and arrows show the direction of data flow. The assignment operator ("=") is treated as an operator with low precedence by the compiler, but from a dataflow point of view it only moves data so it's represented as an arrow, not an operation.
Dataflow diagrams show which operations must necessarily be performed before others, but doesn't show which are actually performed first. Java performs most operations left-to-right, so the addition would, in principle, be performed before the multiplication. I believe reordering of operations that can have no side effects is allowed, however.
Postfix. Altho it's not directly relevant to learning Java, there are other systems for writing expressions that don't need parentheses or precedence. Normal mathematical notation is called infix notation because the operators occur in between the operands. A common alternative is called postfix notation where the operator is written after its two operands.
Example. For example, a+b would be written as ab+ , and x = a+b-c*d/e would be written as xab+cd*e/-=.
RPN. This is often called Reverse Polish Notation in honor of the Polish mathematician Jan Lukasiewicz.
Postfix notation is used in the following, among others.
| ~ | Not operator |
| ^ | Xor or Exclusive OR |
| | | OR |
| & | And operator |
| >> | Right shift |
| >>> | Unsigned right shift |
| << | left shift |
Note that operands for Bitwise operators must be numeric datatypes(char, short, int, or long).
| Operator | Usage | Example | Result | Reason |
| & or and Operator | a & b | 3 & 5 | 1 | 1 if both bits are 1. |
| | OR operator | a | b | 3 | 5 | 7 | 1 if either bit is 1. |
| ^ or xor operator | a ^ b | 3 ^ 5 | 6 | 1 if both bits are different. |
| ~ or not operator | ~a | ~3 | 4 | Inverts the bits. |
| Left shift | n << p | 3 <<< 2 | 12 | Shifts the bits of n left p positions. Zero bits are shifted into the low-order positions. |
| Right shift | n >> p | 5 >> 2 | 1 | Shifts the bits of n right p positions. If n is a 2's complement signed number, the sign bit is shifted into the high-order positions. |
| Unsigned right shift | n >>> p | -4 >>> 28 | 15 | Shifts the bits of n right p positions. Zeros are shifted into the high-order positions. |
==,equals, compareTo, compare all help in comparing the object in one or other way.
== with object references is generally limited to the following:
equals() method Usage : a.equals(b)
Compares values for equality. Because this method is defined in the Object class, from which all other classes are derived, it's automatically defined for every class. However, it doesn't perform an intelligent comparison for most classes unless the class overrides it. It has been defined in a meaningful way for most Java core classes. If it's not defined for a (user) class, it behaves the same as ==.
It turns out that defining equals() isn't trivial; in fact it's moderately hard to get it right, especially in the case of subclasses. The best treatment of the issues is in Horstmann's Core Java Vol 1. See equals() method here.
Also to see == vs equals() , refer here.
compareTo() method a.compareTo(b) is present in Comparable interface. Compares values and returns an int which tells if the values compare less than, equal, or greater than. If your class objects have a natural order, implement the Comparable<T> interface and define this method. All Java classes that have a natural ordering implement this (String, Double, BigInteger, ...).
For more on Comparable interface, refer here.
compare(a,b) method Usage : compare(a, b)
is implemented using Comparator interface. Compares values of two objects. This is implemented as part of the Comparator<T> interface, and the typical use is to define one or more small utility classes that implement this, to pass to methods such as sort() or for use by sorting data structures such as TreeMap and TreeSet. You might want to create a Comparator object for the following.
sort() method.import java.util.*;
import java.io.*;
public final class Account implements Comparable<Account> {
//Constructor
enum AccountType {CASH, MARGIN, RRSP};
public Account (
String aFirstName,
String aLastName,
int aAccountNumber,
int aBalance,
boolean aIsNewAccount,
AccountType aAccountType
) {
//..parameter validations elided fFirstName = aFirstName;
fLastName = aLastName;
fAccountNumber = aAccountNumber;
fBalance = aBalance;
fIsNewAccount = aIsNewAccount;
fAccountType = aAccountType;
}
/**
* @param aThat is a non-null Account.
*
* @throws NullPointerException if aThat is null.
*/
public int compareTo( Account aThat ) {
final int BEFORE = -1;
final int EQUAL = 0;
final int AFTER = 1;
//this optimization is usually worthwhile, and can
//always be added
if ( this == aThat ) return EQUAL;
//primitive numbers follow this form
if (this.fAccountNumber < aThat.fAccountNumber) return BEFORE;
if (this.fAccountNumber > aThat.fAccountNumber) return AFTER;
//booleans follow this form if (!this.fIsNewAccount && aThat.fIsNewAccount) return BEFORE;
if (this.fIsNewAccount && !aThat.fIsNewAccount) return AFTER;
//objects, including type-safe enums, follow this form //note that null objects will throw an exception here int comparison = this.fAccountType.compareTo(aThat.fAccountType);
if ( comparison != EQUAL ) return comparison;
comparison = this.fLastName.compareTo(aThat.fLastName);
if ( comparison != EQUAL ) return comparison;
comparison = this.fFirstName.compareTo(aThat.fFirstName);
if ( comparison != EQUAL ) return comparison;
if (this.fBalance < aThat.fBalance) return BEFORE;
if (this.fBalance > aThat.fBalance) return AFTER;
//all comparisons have yielded equality //verify that compareTo is consistent with equals (optional) assert this.equals(aThat) : "compareTo inconsistent with equals.";
return EQUAL;
}
/**
* Define equality of state.
*/
@Override public boolean equals( Object aThat ) {
if ( this == aThat ) return true;
if ( !(aThat instanceof Account) ) return false;
Account that = (Account)aThat;
return
( this.fAccountNumber == that.fAccountNumber ) &&
( this.fAccountType == that.fAccountType ) &&
( this.fBalance == that.fBalance ) &&
( this.fIsNewAccount == that.fIsNewAccount ) &&
( this.fFirstName.equals(that.fFirstName) ) &&
( this.fLastName.equals(that.fLastName) );
}
/**
* A class that overrides equals must also override hashCode.
*/
@Override public int hashCode() {
int result = HashCodeUtil.SEED;
result = HashCodeUtil.hash( result, fAccountNumber );
result = HashCodeUtil.hash( result, fAccountType );
result = HashCodeUtil.hash( result, fBalance );
result = HashCodeUtil.hash( result, fIsNewAccount );
result = HashCodeUtil.hash( result, fFirstName );
result = HashCodeUtil.hash( result, fLastName );
return result;
}
//// PRIVATE ///////
private String fFirstName; //non-null private String fLastName; //non-null private int fAccountNumber;
private int fBalance;
private boolean fIsNewAccount;
/**
* Type of the account, expressed as a type-safe enumeration (non-null).
*/
private AccountType fAccountType;
/**
* Exercise compareTo.
*/
public static void main (String[] aArguments) {
//Note the difference in behaviour in equals and compareTo, for nulls: String text = "blah";
Integer number = new Integer(10);
//x.equals(null) always returns false: System.out.println("false: " + text.equals(null));
System.out.println("false: " + number.equals(null) );
//x.compareTo(null) always throws NullPointerException: //System.out.println( text.compareTo(null) ); //System.out.println( number.compareTo(null) );
Account flaubert = new Account(
"Gustave", "Flaubert", 1003, 0,true, AccountType.MARGIN
);
//all of these other versions of "flaubert" differ from the //original in only one field Account flaubert2 = new Account(
"Guy", "Flaubert", 1003, 0, true, AccountType.MARGIN
);
Account flaubert3 = new Account(
"Gustave", "de Maupassant", 1003, 0, true, AccountType.MARGIN
);
Account flaubert4 = new Account(
"Gustave", "Flaubert", 2004, 0, true, AccountType.MARGIN
);
Account flaubert5 = new Account(
"Gustave", "Flaubert", 1003, 1, true, AccountType.MARGIN
);
Account flaubert6 = new Account(
"Gustave", "Flaubert", 1003, 0, false, AccountType.MARGIN
);
Account flaubert7 = new Account(
"Gustave", "Flaubert", 1003, 0, true, AccountType.CASH
);
System.out.println( "0: " + flaubert.compareTo(flaubert) );
System.out.println( "first name +: " + flaubert2.compareTo(flaubert) );
//Note capital letters precede small letters System.out.println( "last name +: " + flaubert3.compareTo(flaubert) );
System.out.println( "acct number +: " + flaubert4.compareTo(flaubert) );
System.out.println( "balance +: " + flaubert5.compareTo(flaubert) );
System.out.println( "is new -: " + flaubert6.compareTo(flaubert) );
System.out.println( "account type -: " + flaubert7.compareTo(flaubert) );
}
}
reverse() method reverses the order of the characters in a StringBuffer object. Unlike the methods of immutable objects, this method changes the data of its object. For practice, let us write another method that does this. append() method puts a new character at the end of a StringBuffer object. No new object is created. We can use this method to build up the reversed characters as the original String is scanned from right to left: public class ReverseTesterIn this version of
{
public static String reverse( String data )
{
StringBuffer temp = new StringBuffer();
for ( int j=data.length()-1; j >= 0; j-- ) // scan the String from right to left
temp.append( data.charAt(j) ); // append characters on the right
return temp.toString(); // return a String created from the StringBuffer
}
public static void main ( String[] args )
{
System.out.println( reverse( "Hello" ) );
}
}
reverse(), only two new objects are created: the StringBuffer and the String object that is returned to the caller.String
StringBuffer to be somewhat larger than you might need. This doesn't waste much space and puts fewer demands on the run-time system. StringBuffer indexes start at 0 and go up to length-1. Some StringBuffer methods are: | StringBuffer Methods | |
|---|---|
StringBuffer append( char c ) | append c to the end of the StringBuffer |
StringBuffer append( int i ) | convert i to characters, then append them to the end of the StringBuffer |
StringBuffer append( long L ) | convert L to characters, then append them to the end of the StringBuffer |
StringBuffer append( float f ) | convert f to characters, then append them to the end of the StringBuffer |
StringBuffer append( double d ) | convert d to characters, then append them to the end of the StringBuffer |
StringBuffer append( String s ) | append the characters in s to the end of the StringBuffer |
int capacity() | return the current capacity (capacity will grow as needed). |
char charAt( int index ) | get the character at index. |
StringBuffer delete( int start, int end) | delete characters from start to end-1 |
StringBuffer deleteCharAt( int index) | delete the character at index |
StringBuffer insert( int index, char c) | insert character c at index (old characters move over to make room). |
StringBuffer insert( int index, String st) | insert characters from st starting at position i. |
StringBuffer insert( int index, int i) | convert i to characters, then insert them starting at index. |
StringBuffer insert( int index, long L) | convert L to characters, then insert them starting at index. |
StringBuffer insert( int index, float f) | convert f to characters, then insert them starting at index. |
StringBuffer insert( int index, double d) | convert d to characters, then insert them starting at index. |
int length() | return the number of characters. |
StringBuffer reverse() | Reverse the order of the characters. |
void setCharAt( int index, char c) | set the character at index to c. |
String toString() | return a String object containing the characters in the StringBuffer. |