created sorting with comparison, and part of method shuffle

Author: phongus

20.7.1.3 Sorting with Comparator/20.7.1.3.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

20.7.1.3 Sorting with Comparator/src/Sort3.java

@@ -0,0 +1,27 @@
+// Fig. 20.9: Sort3.java
+//  Collections method sortwith a custom Comparator object.
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+public class Sort3
+{
+    public static void main(String [] args)
+    {
+        List<Time2> list = new ArrayList<Time2>();  //  create List
+
+        list.add(new Time2(6, 24, 40));
+        list.add(new Time2(18, 14, 58));
+        list.add(new Time2(6, 05, 34));
+        list.add(new Time2(12, 14, 58));
+        list.add(new Time2(6, 24, 22));
+
+        //  output List elements
+        System.out.printf("Unsorted array elements:\n%s\n", list);
+
+        //  sort in order using a comparator
+        Collections.sort(list, new TimeComparator());
+
+        //  output List elements
+        System.out.printf("Sorted list elements:\n%s\n", list);
+    }
+}

20.7.1.3 Sorting with Comparator/src/Time2.java

@@ -0,0 +1,110 @@
+//  Fig. 8.5: Time2.java
+//  Time2 class declaration with overloaded constructors.
+
+public class Time2
+{
+    private int hour;   //  0 - 23
+    private int minute; //  0 - 59
+    private int second; //  0 - 59
+
+    //  Time2 no-argument constructor;
+    //  initializes each instance variable to zero
+    public Time2()
+    {
+        this(0,0,0);    //  invote Time2 constructor with three arguments
+    }   //  end Time2 no-argument constructor
+
+    //  Time2 constructor: hour supplied, minute and second defaulted to 0
+    public Time2(int h)
+    {
+        this(h, 0, 0);  //  invoke Time2 constructor with three arguments
+    }   //  end Time2 one-argument constructor
+
+    //  Time2 constructor: hour and minute supplied, second defaulted to 0
+    public Time2(int h, int m)
+    {
+        this(h, m, 0);  //  invoke Time2 constructor with three arguments
+    }   //  end Time2 two-argument constructor
+
+    //  Time2 constructor: hour, mintute, and second supplied
+    public Time2(int h, int m, int s)
+    {
+        setTime(h, m, s);   //  invoke setTime to validate time
+    }   //  end Time2 three-argument constructor
+
+    //  Time2 constructor: another Time2 object supplied
+    public Time2(Time2 time)
+    {
+        //  invoke Time2 threes-argument constructor
+        this(time.getHour(), time.getMinute(), time.getSecond());
+    }   //  end Time2 constructor with a Time2 object argument
+
+    //  Set Methods
+    //  set a new time valiue using universal time;
+    //  validate the data
+    public void setTime(int h, int m, int s)
+    {
+        setHour(h); //  set the hour
+        setMinute(m);   //  set the minute
+        setSecond(s);   //  set the second
+    }   //  end method setTime
+    public void setHour(int h)
+    {
+        if(h >= 0 && h < 24)
+            hour = h;
+        else
+            throw new IllegalArgumentException("hour must be 0-23");
+    }   //  end method setHour
+
+    //  validate and set minute
+    public void setMinute(int m)
+    {
+        if (m >= 0 && m < 60)
+            minute = m;
+        else
+            throw new IllegalArgumentException("minute must be 0-59");
+    }   //  end method setMinute
+
+    //  validate and set second
+    public void setSecond(int s)
+    {
+        if (s >= 0 && s < 60)
+            second = ((s >= 0 && s < 60) ? s : 0);
+        else
+            throw new IllegalArgumentException("second must be 0-59");
+    }   //  end method setSecond
+
+    //  Get Methods
+    //  get hour value
+    public int getHour()
+    {
+        return hour;
+    }   //  end method getHour
+
+    //  get minute value
+    public int getMinute()
+    {
+        return minute;
+    }   //  end method getMinute
+
+    //  get second value
+    public int getSecond()
+    {
+        return second;
+    }   //  end method getSecond
+
+    //  convert to String in universal-time format (HH:MM:SS)
+    public String toUniversalString()
+    {
+        return String.format(
+                "%20d:%02d:%02d", getHour(), getMinute(), getSecond());
+    }   //  end method toUniversalString
+
+    //  convert to String in standard-time format (H:MM:SS AM or PM)
+    public String toString()
+    {
+        return String.format("%d:%02d:%02d %s",
+                ( (getHour() == 0 || getHour() == 12) ? 12 : getHour() % 12 ),
+                getMinute(), getSecond(), (getHour() < 12 ? "AM" : "PM"));
+    }   //  end method toString
+}   //  end class Time2

20.7.1.3 Sorting with Comparator/src/TimeComparator.java

@@ -0,0 +1,27 @@
+//  Fig. 20.8: TimeComparator.java
+//  Custom Comparator class that compares two Time2 objects
+import java.util.Comparator;
+
+public class TimeComparator implements Comparator<Time2>
+{
+    public int compare(Time2 time1, Time2 time2)
+    {
+        int hourCompare = time1.getHour() - time2.getHour();    //  compare hour
+
+        //  test the hour first
+        if (hourCompare != 0)
+            return hourCompare;
+
+        int minuteCompare =
+                time1.getMinute() - time2.getMinute();  //  compare minute
+
+        //  then test the minute
+        if (minuteCompare != 0)
+            return minuteCompare;
+
+        int secondCompare =
+                time1.getSecond() - time2.getSecond();  //  compare second
+
+        return secondCompare;   //  return result of comparing seconds
+    }   //  end method compare
+}   //  end class TimeComparator

20.7.2 Method shuffle/src/DeckOfCards.java

@@ -0,0 +1,15 @@
+//  Fig. 20.10: DeckOfCards.java
+//  Card shuffle and dealing with Collections method shuffle
+
+//  class to represent a Card in a deck of cards
+class Card
+{
+    public static enum Face{Ace, Deuce, Three, Four, Five, Six,
+        Seven, Eight, Nine, Ten, Jack, Queen, King };
+
+    public static enum Suit {Club, Diamonds, Heart, Spades};
+
+    private final Face face;    //  face of card
+    private final Suit suit;    //  suit of card
+
+}