Professional Documents
Culture Documents
public class Java2701 { public static void main (String args[]) { System.out.println("\nJava2701.java\n"); String stringVar = "Tango"; System.out.println(stringVar); System.out.println(); System.out.println("Literal String"); System.out.println(); } }
// Java2702.java // This demonstrates how <int>, <double>, <char> and <boolean> // variables are printed. public class Java2702 { public static void main (String args[]) { System.out.println("\nJava2702.java\n"); int intVar = 100; double dblVar = 3.14159; char chrVar = 'A'; boolean blnVar = true; System.out.println(intVar); System.out.println(dblVar); System.out.println(chrVar); System.out.println(blnVar); System.out.println(); } }
// Java2703.java // This program demonstrates how Java <int> and <double> arrays are // displayed when only the object identifier is printed. public class Java2703 { public static void main (String args[]) { System.out.println("\nJava2703java\n"); int intList[] = {11,22,33,44,55,66,77,88,99}; System.out.println("intList: " + intList); System.out.println(); double dblList[] = {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9}; System.out.println("dblList: " + dblList); System.out.println(); String strList[] = {"Tom","Joe","Sue","Meg"}; System.out.println("strList: " + strList); System.out.println(); } }
720eeb 11
3179c3 1.1
310d42 Tom
// Java2704.java // In this program the user-defined <Student> class uses the <toString> method inherited from the // <Object> class. The <Object> class <toString> method returns an actual string representation of // the object value, which is a memory address. public class Java2704 { public static void main (String args[]) { System.out.println("\nJava2704.java\n"); Student student1 = new Student("Tom",21,3.85); Student student2 = new Student("Joe",17,3.65); Student student3 = new Student("Sue",18,2.85); Student student4 = new Student("Meg",19,3.90); System.out.println("student1: " + student1); System.out.println("student2: " + student2); System.out.println("student3: " + student3); System.out.println("student4: " + student4); System.out.println(); } } class Student { private String name; private int age; private double gpa; public Student(String n, int a, double g) { name = n; age = a; gpa = g; } }
This means that every class has access to the toString method.
The toString method, as defined by the Object class, returns the actual string representation values of all the primitive types like int, double, char and boolean.
toString equals
// Java2705.java // This program demonstrates <toString> behaves differently for the <ArrayList> // class. Note that "referenced" values are displayed, not the references. import java.util.ArrayList; public class Java2705 { public static void main (String args[]) { System.out.println("\nJaba2705.java\n"); ArrayList<String> names = new ArrayList<String>(); names.add("Isolde"); names.add("John"); names.add("Greg"); names.add("Maria"); names.add("Heidi"); System.out.println("names: " + names); System.out.println(); } }
// Java2706.java.java // The <toString> method of an ArrayList object displays the contents of the <ArrayList> // object, but the non-Java class <Student> objects display memory addresses. import java.util.ArrayList; public class Java2706 { public static void main (String args[]) { System.out.println("\nJava2706.java\n"); ArrayList<Student> students = new ArrayList<Student>(); students.add(new Student("Tom",21,3.85)); students.add(new Student("Joe",17,3.65)); students.add(new Student("Sue",18,2.85)); students.add(new Student("Meg",19,3.90)); System.out.println("students: " + students); System.out.println(); } }
class Student { private String name; private int age; private double gpa; public Student(String n, int a, double g) { name = n; age = a; gpa = g; } }
// Java2707.java. // This program examples shows that <toString> manages to handle objects of objects very nicely. // In this case you see a display of an <ArrayList> object or <ArrayList> objects. // Observe how generics are handled with an <ArrayList> object of <ArrayList> objects.import java.util.ArrayList; public class Java2707 { public static void main (String args[]) { System.out.println("\nJava2707.java\n"); ArrayList<String> cats = new ArrayList<String>(); cats.add("Lions"); cats.add("Tigers");
This means that the toString method is redefined for the ArrayList class or some superclass of ArrayList.
// Java2708.java // This program demonstrates defining a <toString> method // in the <Student> class so that it displays the name field of a <Student> object. import java.util.ArrayList; public class Java2708 { public static void main (String args[]) { System.out.println("\nJava2708.java\n"); Student student1 = new Student("Kathy Alexander",21,3.75); Student student2 = new Student("Peter VanVliet",18,2.265); System.out.println(student1.toString()); System.out.println(student2.toString()); System.out.println(); } } class Student { private String name; private int age; private double gpa; public Student(String n, int a, double g) { name = n; age = a; gpa = g; }
// Java2709.java // This program is almost identical to the previous program. This time the <toString> method is not // called by any <Student> object. Yet the result is the same because <println> uses the // string representation of <toString> for its output. import java.util.ArrayList; public class Java2709 { public static void main (String args[]) { System.out.println("\nJava2709.java\n"); Student student1 = new Student("Kathy Alexander",21,3.75); Student student2 = new Student("Peter VanVliet",18,2.265); System.out.println(student1); System.out.println(student2); System.out.println(); } } class Student { private String name; private int age; private double gpa; public Student(String n, int a, double g) { name = n; age = a; gpa = g; }
// Java2710.java // This program demonstrates "redefining the <toString> method in the // <Student> class so that it displays every field of a <Student> object. // Note how this implementation resembles the <ArrayList> format. import java.util.ArrayList; public class Java2710 { public static void main (String args[]) { System.out.println("\nJava2710.java\n"); Student student1 = new Student("Kathy Alexander",21,3.475); Student student2 = new Student("Peter VanVliet",18,2.265); System.out.println(student1); System.out.println(student2); System.out.println(); } } class Student { private String name; private int age; private double gpa; public Student(String n, int a, double g) { name = n; age = a; gpa = g; }
public String toString() { return "[" + name + "," + age + "," + gpa + "]"; }
}
// Java2711.java // This program uses a <TimeTest> class, which displays the elapsed time // in hh:mm:ss.fractions between some event. This <toString> method // includes control structures to determine the correct format. import java.util.Scanner; import java.text.DecimalFormat; public class Java2711 { public static void main(String args[]) { System.out.println("\nJava2711.java\n"); Scanner input = new Scanner(System.in); TimeTest time = new TimeTest(); { System.out.print("Press <Enter> to start the clock ===>> "); String dummy = input.nextLine(); time.startClock(); System.out.println(); System.out.print("Press <Enter> to stop the clock ===>> "); dummy = input.nextLine(); time.stopClock(); } System.out.println(); System.out.println(time); System.out.println(); } }
class TimeTest { private long startNanos; private long endNanos; private long nanos; private long hours; private long minutes; private long seconds; private long fractions;
// tick count at the start of the test // tick count at the end of the test // elapsed number of nano seconds // elapsed hours // elapsed minutes // elapsed seconds // elapsed fractions of a second
private void computeTime() { nanos = endNanos - startNanos; hours = nanos / 3600000000000L; long leftOver = nanos % 3600000000000L; minutes = leftOver / 60000000000L; leftOver = leftOver % 60000000000L; seconds = leftOver / 1000000000L; fractions = leftOver % 1000000000L; }
public String toString() { DecimalFormat twos = new DecimalFormat("00"); DecimalFormat nines = new DecimalFormat("000000000"); String temp = twos.format(hours) + ":"; temp = temp + twos.format(minutes) + ":"; temp = temp + twos.format(seconds) + "."; temp = temp + nines.format(fractions); return temp; }}
// Java2712.java // This program repeats the <TimeTest> class with a different output // format for the <toString> method. import java.util.Scanner; public class Java2712 { public static void main(String args[]) { System.out.println("\nJava2712.java\n"); Scanner input = new Scanner(System.in); TimeTest time = new TimeTest(); { System.out.print("Press <Enter> to start the clock ===>> "); String dummy = input.nextLine(); time.startClock(); System.out.println(); System.out.print("Press <Enter> to stop the clock ===>> "); dummy = input.nextLine(); time.stopClock(); } System.out.println(); System.out.println(time); System.out.println(); } }
class TimeTest { private long startTicks; private long endTicks; private long millis; private long hours; private long minutes; private long seconds; private long fractions;
// tick count at the start of the test // tick count at the end of the test // elapsed number of ticks // elapsed hours // elapsed minutes // elapsed seconds // elapsed fractions of a second
//These 4 methods are the same as the last program public TimeTest() public void startClock() public void stopClock() private void computeTime()
public String toString() { String temp = "Hours: temp = temp + "Minutes: temp = temp + "Seconds: temp = temp + "Fractions: return temp; }
}
+ + + +
Redefining toString
Every class has indirect access to the toString method defined by the Object class.
If some output is desired with println that is different from the default toString output, you must redefine toString in the class that you are using with a method, like the one shown below.
public String toString() { String temp = "Hours: temp = temp + "Minutes: temp = temp + "Seconds: temp = temp + "Fractions: return temp; }
+ + + +
// Java2713.java // This program demonstrates how <String> objects respond to the == operator.
import java.util.Scanner;
public class Java2713 { public static void main (String args[]) { Scanner input = new Scanner(System.in); System.out.println("\nJava2713.java\n"); System.out.print("Enter string 1 ===>> "); String s1 = input.nextLine(); System.out.print("Enter string 2 ===>> "); String s2 = input.nextLine();
if (s1 == s2)
System.out.println("They are equal");
else System.out.println("They are not equal"); System.out.println(); }
string1 @720eeb
== compares
string2 @3179c3
720eeb Foxtrot
equals compares
3179c3 Foxtrot
// Java2714.java // This program demonstrates how the <equals> methods properly handles // <String> objects. import java.util.Scanner; public class Java2714 { public static void main (String args[]) { Scanner input = new Scanner(System.in); System.out.println("\nJava2714.java\n"); System.out.print("Enter string 1 ===>> "); String s1 = input.nextLine(); System.out.print("Enter string 2 ===>> "); String s2 = input.nextLine();
if (s1.equals(s2))
System.out.println("They are equal");
else System.out.println("They are not equal"); System.out.println(); }
Redefining equals
The == operator compares the immediate values stored by variables. This means that == only works correctly for primitive data types. Java has an equals method, which works correctly for comparing String objects.
// Java2715.java // This program demonstrates how the <equals> method behaves with <ArrayList> objects. import java.util.ArrayList; public class Java2715 { public static void main (String args[]) { System.out.println("\nJava2715.java\n");
ArrayList<String> list1 = new ArrayList<String>(); list1.add("John"); list1.add("Greg"); ArrayList<String> list2 = new ArrayList<String>(); list2.add("John"); list2.add("Greg"); ArrayList<String> list3 = new ArrayList<String>(); list3.add("Maria"); list3.add("Heidi");
if (list1.equals(list2))
else
if (list2.equals(list3))
else
// Java2716.java // This demonstrates how the <equals> method handles user-defined <Student> objects. public class Java2716 class Student { { public static void main (String args[]) private String name; { private int age; System.out.println("\nJava2716.java\n"); Student student1 = new Student("Tom",21); Student student2 = new Student("Tom",21); Student student3 = new Student("Meg",20); public Student(String n, int a) { name = n; age = a; }
if (student1.equals(student2))
System.out.println("They are equal"); else System.out.println("They are not equal"); System.out.println();
if (student2.equals(student3))
else
// Java2717.java // This redefines the <equals> method for the <Student> class. // For this implementation equality is based on GPA. class Student public class Java2717 { public static void main (String args[]) { System.out.println("\nJava2717.java\n"); Student student1 = new Student("Tom",2.165); Student student2 = new Student("Tom",3.675); Student student3 = new Student("Meg",3.675);
{
if (student1.equals(student2))
System.out.println("They are equal"); else System.out.println("They are not equal"); System.out.println();
if (student2.equals(student3))
System.out.println("They are equal"); else System.out.println("They are not equal"); System.out.println(); } }
// Java2718.java This redefines the <equals> method for the <Student> class. For this implementation equality is based on equality in every field. public class Java2718 { public static void main (String args[]) { System.out.println("\nJava2718.java\n"); Student student1 = new Student("Meg",2.165); Student student2 = new Student("Tom",3.675); Student student3 = new Student("Tom",3.675);
class Student { private String name; private double gpa; public Student(String n, double g) { name = n; gpa = g; }
if (student1.equals(student2))
System.out.println("They are equal"); else System.out.println("They are not equal"); System.out.println();
if (student2.equals(student3))
else
// Java2719.java // This program demonstrates how the <compareTo> // method work with <String> objects. public class Java2719 { public static void main (String args[]) { System.out.println("\nJava2719.java\n"); String s1 = "Aardvark"; String s2 = "Zulu"; String s3 = "Aardvark"; System.out.println(s1 + " compares to " + s2 + " : " + s1.compareTo(s2)); System.out.println(s2 + " compares to " + s1 + " : " + s2.compareTo(s1)); System.out.println(s1 + " compares to " + s3 + " : " + s1.compareTo(s3)); System.out.println(); }
// Java2720.java // The <equals> method is a member of the <Object> class, but this is not true // for the <compareTo> method. The program below will not compile with the // comments removed. public class Java2720 { public static void main (String args[]) { System.out.println("\nJava2720.java\n"); Object obj1 = new Object(); Object obj2 = new Object(); obj2 = obj1; if (obj1.equals(obj2)) System.out.println("equals"); else System.out.println("no equals");
//
// }
System.out.println(obj1.compareTo(obj2));
remove comments after first execution System.out.println();
// Java2721.java // The <compareTo> method also does not work for the <ArrayList> class, // just like the <Object> class. import java.util.ArrayList; public class Java2721 { public static void main (String args[]) { System.out.println("\nJava2721.java\n"); ArrayList<String> list1 = new ArrayList<String>(); ArrayList<String> list2 = new ArrayList<String>(); list1.add("John"); list1.add("Greg"); list2.add("Maria"); list2.add("Heidi");
System.out.println(list1.compareTo(list2)); System.out.println(list2.compareTo(list1));
System.out.println();
// Java2722.java // This program implements the <Comparable> interface only method, <compareTo>. // Note how it also redefines the <toString> method so that the <Student> object's // name is displayed, rather than a memory address. public class Java2722 { public static void main (String args[]) { System.out.println("\nJava2722.java\n"); Student st1 = new Student("Tom",21); Student st2 = new Student("Meg",21); Student st3 = new Student("Tom",20); System.out.println(st1 + " compares to " + st2 + " : " + st1.compareTo(st2)); System.out.println(st2 + " compares to " + st1 + " : " + st2.compareTo(st1)); System.out.println(st1 + " compares to " + st3 + " : " + st1.compareTo(st3));
System.out.println(); }
public int compareTo (Object source) { Student temp = (Student) source; return name.compareTo(temp.name); }
public String toString() { return name; }
// This is still program Java2722.java // This an attempt to make the compareTo method simpler. // This does not work. Source must be of type Object.
You might be wondering what point the is if it requires the method to be more complicated.
comparable interface
public int compareTo (Student source) { return name.compareTo(source.name); The purpose is that } when you see a class
public String toString() { return name; }
that implements a known interface, you know what methods it will have, and how they are expected to work.
// Java2723.java // This program demonstrates that the <swap> method does not alter // the parameter values passed in the <main> method. public class Java2723 { public static void main (String args[]) { System.out.println("\nJava2723.java\n"); int num1 = 100; int num2 = 200; System.out.println("num1: " + num1); System.out.println("num2: " + num2); public static void swap(int x, int y) { System.out.println(); System.out.println("x: " + x); System.out.println("y: " + y); int temp = x; x = y; y = temp; System.out.println(); System.out.println("x: " + x); System.out.println("y: " + y); System.out.println(); } }
swap(num1,num2);
System.out.println("num1: " + num1); System.out.println("num2: " + num2); System.out.println();
// Java2724.java // This program demonstrates that the <swap> method does not alter // the <String> values passed in the <main> method.
public class Java2724 { public static void main (String args[]) { System.out.println("\nJava2724.java\n"); String name1 = "Tom"; String name2 = "Sue"; System.out.println("name1: " + name1); System.out.println("name2: " + name2); public static void swap(String n1, String n2) { System.out.println(); System.out.println("n1: " + n1); System.out.println("n2: " + n2); String temp = n1; n1 = n2; n2 = temp; System.out.println(); System.out.println("n1: " + n1); System.out.println("n2: " + n2); System.out.println(); } } System.out.println();
swap(name1,name2);
System.out.println("name1: " + name1); System.out.println("name2: " + name2);
// Java2725.java // This program demonstrates that the <swap> method does not alter // the <Student> values passed in the <main> method.
public class Java2725 { public static void main (String args[]) { System.out.println("\nJava2725.java\n"); Student st1 = new Student("Sue",21,3.5); Student st2 = new Student("Tom",20,2.2); System.out.println("st1: " + st1); System.out.println("st2: " + st2); } public static void swap(Student s1, Student s2) { System.out.println(); System.out.println("s1: " + s1); System.out.println("s2: " + s2); Student temp = s1; s1 = s2; s2 = temp; System.out.println(); System.out.println("s1: " + s1); System.out.println("s2: " + s2); System.out.println(); } class Student { private String name; private int age; private double gpa; public Student(String n, int a, double g) { name = n; age = a; gpa = g; } public String toString() { return name; } }
swap(st1,st2);
System.out.println("st1: " + st1); System.out.println("st2: " + st2); System.out.println(); }
// Java2726.java // This program is the same as Java2725 with the <toString> redefinition removed from // the <Student> class, so that memory references can be observed.
public class Java2726 { public static void main (String args[]) { System.out.println("\nJava2726.java\n"); Student st1 = new Student("Sue",21,3.5); Student st2 = new Student("Tom",20,2.2); System.out.println("st1: " + st1); System.out.println("st2: " + st2); public static void swap(Student s1, Student s2) { System.out.println(); System.out.println("s1: " + s1); System.out.println("s2: " + s2); Student temp = s1; s1 = s2; s2 = temp; System.out.println(); System.out.println("s1: " + s1); System.out.println("s2: " + s2); System.out.println(); } } class Student { private String name; private int age; private double gpa; public Student(String n, int a, double g) { name = n; age = a; gpa = g; } }
swap(st1,st2);
System.out.println("st1: " + st1); System.out.println("st2: " + st2); System.out.println(); }
st1 @82ba41
st2 @923e40
st1 @82ba41
st2 @923e40
// Java2727.java // This program now appears to work as expected. Note that this time the object values, which are // references, are not swapped, but the content values which are referenced by the objects.
public static void main (String args[]) { System.out.println( "\nJava2727.java\n"); Student st1 = new Student("Sue",21,3.5); Student st2 = new Student("Tom",20,2.2); System.out.println( "st1: " + st1); System.out.println( "st2: " + st2); public static void swap( Student s1, Student s2) { System.out.println(); System.out.println( "s1: " + s1); System.out.println( "s2: " + s2); String sTemp = s1.getName(); s1.setName(s2.getName()); s2.setName(sTemp); int iTemp = s1.getAge(); s1.setAge(s2.getAge()); s2.setAge(iTemp); double dTemp = s1.getGpa(); s1.setGpa(s2.getGpa()); s2.setGpa(dTemp); class Student { private String name; private int age; private double gpa; public Student( String n, int a, double g) { name = n; age = a; gpa = g; } public String getName () { return name; } public int getAge () { return age; } public double getGpa () { return gpa; } public void setName (String s) { name = s; } public void setAge (int a) { age = a; } public void setGpa (double g) { gpa = g; } public String toString() { return name; } }
swap(st1,st2);
System.out.println( "st1: " + st1); System.out.println( "st2: " + st2); System.out.println(); } }
System.out.println(); System.out.println( "s1: " + s1); System.out.println( "s2: " + s2); System.out.println();
}
// Java2728.java // This program uses a <createList> method to generate random integers for an // integer array. The program executes as desired. import java.util.Random; public class Java2728 { public static void main (String args[]) { System.out.println( "\nJava2728.java\n"); int list[] = new int[100]; displayList(list); createList(list); displayList(list); System.out.println(); } public static void createList(int list[]) { Random rnd = new Random(12345); for (int k = 0; k < list.length; k++) { int rndInt = rnd.nextInt(9000) + 1000; list[k] = rndInt; } } public static void displayList(int list[]) { System.out.println(); for (int k = 0; k < list.length; k++) System.out.print(list[k] + " "); System.out.println(); } }
// Java2729.java // This program is yet another example that parameters are only passed by value. // It is not possible to pass the reference from the temp array to the list parameter. import java.util.Random; public class Java2729 { public static void main (String args[]) { System.out.println( "\nJava2729.java\n"); int list[] = new int[100]; displayList(list); public static void createList(int list[]) { Random rnd = new Random(12345); int temp[] = new int[100]; for (int k = 0; k < list.length; k++) { int rndInt = rnd.nextInt(9000) + 1000; temp[k] = rndInt; }
list = temp;
} public static void displayList(int list[]) { System.out.println(); for (int k = 0; k < list.length; k++) System.out.print(list[k] + " "); System.out.println(); } }
createList(list);
displayList(list); System.out.println();
Bottom Line
// Java2730.java // If in fact it is desirable to change the memory reference of an object, it can be // done with a return method, as is demonstrated in this program. import java.util.Random; public class Java2730 { public static void main (String args[]) { System.out.println( "\nJava2730.java\n"); int list[] = new int[100]; displayList(list); public static int[] createList(int list[]) { Random rnd = new Random(12345); int temp[] = new int[100]; for (int k = 0; k < list.length; k++) { int rndInt = rnd.nextInt(9000) + 1000; temp[k] = rndInt; } list = temp;
return list;
} public static void displayList(int list[]) { System.out.println(); for (int k = 0; k < list.length; k++) System.out.print(list[k] + " "); System.out.println(); } }
list = createList(list);
displayList(list); System.out.println();