import javax.swing.JOptionPane;
public class Ordering
{
/** Ask the user for three Workers. Print the one that is
* last in alphabetical order of names. */
public static void main (String[ ] args)
{
javax.swing.JOptionPane.showMessageDialog (null,
"reading 3 workers, printing the last.");
Buffin infile = new Buffin ("workers.txt");
Worker first = new Worker (infile.readLine());
Worker second = new Worker (infile.readLine());
Worker third = new Worker (infile.readLine());
if (third.getName() != null) // in case of insufficient input
{ javax.swing.JOptionPane.showMessageDialog (null,
"The alphabetically last is "
+ CompOp.lastOne (first, second, third));
}
System.exit (0);
} //======================
}
public class CompOp
{
/** Return the String representation of the last/largest of
* three IComparable values. */
public static String lastOne (Comparable first,
Comparable second, Comparable third)
{ Comparable last = first.compareTo (second) >= 0
? first : second;
if (last.compareTo (third) < 0)
last = third;
return last.toString();
} //======================
}
import javax.swing.JOptionPane;
public class PersonnelData
{
private Buffin itsFile = new Buffin ("workers.txt");
/** Read a file and return the name of the Worker that is
* alphabetically first. */
public String findEarliestWorker()
{ Worker answerSoFar = new Worker (itsFile.readLine()); //1
if (answerSoFar.getName() == null) //2
return "no workers!"; //3
else //4
{ Worker data = new Worker (itsFile.readLine()); //5
while (data.getName() != null) //6
{ if (data.compareTo (answerSoFar) < 0) //7
answerSoFar = data; //8
data = new Worker (itsFile.readLine()); //9
} //10
return answerSoFar.getName() + " is first of all."; //11
} //12
} //======================
private static final int TIME_SPAN = 10;
private static final int YEAR = 1960;
/** Read a file and return the string representation of the
* number of Workers born in each of 1960 to 1969. */
public String countBirthYears()
{ int[ ] count = new int [TIME_SPAN]; // all zeros //1
//== READ THE WORKER DATA AND UPDATE THE COUNTS
Worker data = new Worker (itsFile.readLine()); //2
while (data.getName() != null) //3
{ int lastDigit = data.getBirthYear() - YEAR; //4
count[lastDigit]++; // error check left as exercise//5
data = new Worker (itsFile.readLine()); //6
} //7
//== CONSTRUCT THE STRING OF ANSWERS
String s = ""; //8
for (int k = 0; k < TIME_SPAN; k++) //9
s += (YEAR + k) + " : " + count[k] + " workers\n"; //10
return s; //11
} //======================
public static final int MAX_WORKERS = 5000;
/** Read a file of up to 5000 Workers and display those who
* make more than fifty percent above the average pay. */
public void printHighlyPaid()
{
//== INITIALIZE VARIABLES
Worker[ ] item = new Worker[MAX_WORKERS]; //1
int size = 0; // number of workers in the array //2
//== READ THE WORKER DATA AND ADD EACH TO THE ARRAY
Worker data = new Worker (itsFile.readLine()); //3
while (data.getName() != null && size < item.length) //4
{ item[size] = data; //5
size++; //6
data = new Worker (itsFile.readLine()); //7
} //8
//== CALCULATE THE AVERAGE WEEK'S PAY
double totalPay = 0; //9
for (int k = 0; k < size; k++) //10
totalPay += item[k].seeWeeksPay(); //11
double average = size == 0 ? 0.0 : totalPay / size; //12
//== PRINT THOSE MAKING MORE THAN 50% OVER THE AVERAGE
double highlyPaid = 1.5 * average; //13
String s = ""; //14
for (int k = 0; k < size; k++) //15
{ if (item[k].seeWeeksPay() > highlyPaid) //16
s += item[k].toString() + "\n"; //17
} //18
JOptionPane.showMessageDialog (null, s); //19
} //======================
/** Read a file of up to 5000 Workers and display them
* in ascending (increasing) order of birth years. */
public void printOrderedByYear()
{ WorkerList job = new WorkerList (MAX_WORKERS);
Worker data = new Worker (itsFile.readLine());
while (data.getName() != null && job.size() < MAX_WORKERS)
{ job.insertByYear (data);
data = new Worker (itsFile.readLine());
}
System.out.println (job.toString());
} //======================
} //########################################################
class PersonnelDataTester
{
public static void main (String[ ] args)
{ JOptionPane.showMessageDialog (null, "finding the first");
String out = new PersonnelData().findEarliestWorker();
JOptionPane.showMessageDialog (null, out);
out = new PersonnelData().countBirthYears();//test Listing 7.4
JOptionPane.showMessageDialog (null, out);
new PersonnelData().printHighlyPaid(); // testing Listing 7.7
System.exit (0);
} //======================
}
class OrderedPersonnelDataTester
{
public static void main (String[ ] args)
{ System.out.println ("Workers in order of birth year.");
new PersonnelData().printOrderedByYear();
System.exit (0);
} //======================
}
public class Worker implements Comparable
{
public static final double WEEK = 40.0; // regular work week
public static final int NUM_DAYS = 5; // days in 1 work week
////////////////////////////////////
private String itsFirstName = null;
private String itsLastName = null;
private int itsBirthYear = 0;
private double itsHourlyRate = 0;
private double [] itsHoursPaid = {8, 8, 8, 8, 8}; // 1 per day
/** Return the first name plus last name of the Worker.
* But return null if it does not represent a real Worker. */
public String getName()
{ return (itsLastName == null) ? null
: itsFirstName + " " + itsLastName;
} //======================
/** Return a String value containing most or all of the
* Worker's data, suitable for printing in a report. */
public String toString()
{ return itsLastName + ", " + itsFirstName + "; born "
+ itsBirthYear + ". rate = " + itsHourlyRate;
} //======================
/** Record the hours worked in the most recent day. */
public void addHoursWorked (double hoursWorked)
{ for (int k = NUM_DAYS - 1; k > 0; k--)
itsHoursPaid[k] = itsHoursPaid[k - 1];
itsHoursPaid[0] = hoursWorked;
} //======================
/** Return the Worker's gross pay for the week. */
public double seeWeeksPay()
{ double sum = 0.0;
for (int k = 0; k < NUM_DAYS; k++)
sum += itsHoursPaid[k];
return sum <= WEEK ? itsHourlyRate * sum
: itsHourlyRate * (sum * 1.5 - WEEK / 2);
} //======================
public boolean equals (Worker par)
{ return par != null && this.itsLastName != null
&& this.itsLastName.equals (par.itsLastName)
&& this.itsFirstName.equals (par.itsFirstName);
} //======================
/** Return 0 if equal, negative if the executor is before
* ob (executor has an earlier last name or else the same
* last name and an earlier first name), positive otherwise.
* Precondition: ((Worker) ob).getName() is non-null. */
public int compareTo (Object ob)
{ Worker that = (Worker) ob;
int comp = this.itsLastName.compareTo (that.itsLastName);
return comp != 0 ? comp
: this.itsFirstName.compareTo (that.itsFirstName);
} //======================
/** Return the Worker's birth year. */
public int getBirthYear()
{ return itsBirthYear;
} //======================
/** Create a Worker from an input String, a single line with
* first name, last name, year, and rate in that order.
* If the String value is bad, the name is made null. */
public Worker (String par)
{ StringInfo si = new StringInfo (par);
si.trimFront (0);
if (si.toString().length() > 0)
{ itsFirstName = si.firstWord();
si.trimFront (itsFirstName.length());
itsLastName = si.firstWord();
si.trimFront (itsLastName.length());
itsBirthYear = (int) si.parseDouble (-1);
si.trimFront (si.firstWord().length());
itsHourlyRate = si.parseDouble (-1);
}
if (itsBirthRate < 0 || itsHourlyRate < 0)
itsLastName = null;
} //======================
}
public class WorkerList
{
private Worker[ ] itsItem;
private int itsSize = 0;
/** Create an empty list capable of holding max Workers. */
public WorkerList (int max)
{ itsItem = max > 5 ? new Worker[max] : new Worker[5];
} //======================
/** Add all Worker values in the non-null file to this list,
* except no more than there is room for in the list. */
public void addFromFile (Buffin file)
{ Worker data = new Worker (file.readLine());
while (data.getName() != null && itsSize < itsItem.length)
{ itsItem[itsSize] = data;
itsSize++;
data = new Worker (file.readLine());
}
} //======================
/** Return the average pay for all workers in the list.
* Return zero if the list is empty. */
public double getAveragePay()
{ double totalPay = 0;
for (int k = 0; k < itsSize; k++)
totalPay += itsItem[k].seeWeeksPay();
return itsSize == 0 ? 0.0 : totalPay / itsSize;
} //======================
/** Return names of workers making more than the cutoff. */
public String thosePaidOver (double cutoff)
{ String s = "";
for (int k = 0; k < itsSize; k++)
{ if (itsItem[k].seeWeeksPay() > cutoff)
s += itsItem[k].toString() + "\n";
}
return s;
} //======================
/** Tell whether par is a value in this WorkerList. */
public boolean contains (Worker par) // in WorkerList
{ for (int k = 0; k < itsSize; k++)
{ if (itsItem[k].equals (par))
return true;
}
return false;
} //======================
/** Return a new object, a duplicate of this WorkerList. */
public WorkerList copy() // in WorkerList
{ WorkerList valueToReturn;
valueToReturn = new WorkerList (this.itsItem.length);
valueToReturn.itsSize = this.itsSize;
for (int k = 0; k < this.itsSize; k++)
valueToReturn.itsItem[k] = this.itsItem[k];
return valueToReturn;
} //=======================
/** Tell how many Workers are in this WorkerList. */
public int size() // in WorkerList
{ return itsSize;
} //======================
/** Return a String value representing the entire WorkerList.
* It has one Worker's toString() value on each line. */
public String toString() // in WorkerList
{ String valueToReturn = "";
for (int k = 0; k < itsSize; k++)
valueToReturn += itsItem[k].toString() + "\n";
return valueToReturn;
} //=======================
/** Put the non-null data just before all Workers at the end
* of the WorkerList that have a larger birth year.
* Precondition: The WorkerList has room for the data. */
public void insertByYear (Worker data) // in WorkerList
{ int year = data.getBirthYear();
int k = itsSize;
for (; k > 0 && itsItem[k - 1].getBirthYear() > year; k--)
itsItem[k] = itsItem[k - 1];
itsItem[k] = data;
itsSize++;
} //=======================
/** Put all the Workers in ascending order of birth year. */
public void sort() // in WorkerList
{ if (itsSize > 1)
{ int save = itsSize;
itsSize = 1;
while (itsSize < save)
insertByYear (itsItem[itsSize]);
}
} //======================
}
public class Network
{
/** Internal invariant: The sequence of available Nodes is
* itsNode[0][k] for 0 <= k < itsNumNodes. The sequence of
* Nodes that itsNode[0][k] connects to is itsNode[k+1][j]
* for 0 <= j < n for some n <= itsNumNodes. The null value
* comes after the last value of each such sequence. */
private Node [][] itsNode;
private int itsNumNodes;
private java.util.Random randy = new java.util.Random();
/** Return a Position object that produces all nodes 1 at a time. */
public Position nodes()
{ return new Position (itsNode[0]);
} //======================
/** Create a random Network with 6 to 15 Nodes, about half
* blue, and with 3 connections per Node on average. No Node
* connects to itself. This is the only method you need to
* replace if you want to obtain Network data from a file. */
public Network()
{ itsNumNodes = 6 + randy.nextInt (10);
itsNode = new Node [itsNumNodes + 1][itsNumNodes + 1];
for (int k = 1; k <= itsNumNodes; k++)
itsNode[0][k - 1] = new Node ("Node#" + k,
randy.nextInt(2) == 1, itsNode[k]);
decideWhichConnectionsNodesHave();
} //======================
/** Choose about 3 nodes at random for each node to connect to. */
private void decideWhichConnectionsNodesHave()
{ for (int k = 1; k <= itsNumNodes; k++)
{ int j = 0;
for (int conn = 1; conn <= itsNumNodes; conn++)
{ if (randy.nextInt (itsNumNodes - 1) < 3 && conn != k)
{ itsNode[k][j] = itsNode[0][conn - 1];
j++;
}
}
}
} //======================
}
// The following are supplied only to allow Network to compile
public class Position
{
public Position (Node[] list)
{
} //======================
}
public class Node // just so Position will compile
{ public Node (String name, boolean blue, Node[] list)
{
} //======================
}
public class Add
{
/** Print the total of the values in the command line arguments.
Precondition: All arguments are parsable as doubles. */
public static void main (String[ ] args)
{ double total = Double.parseDouble (args[0]);
for (int k = 1; k < args.length; k++)
total += Double.parseDouble (args[k]);
System.out.println ("The total is " + total);
} //=======================
}
public class Queue extends java.util.ArrayList
{
/** Create an empty Queue. */
public Queue()
{ super(); // just to remind you of the default constructor
} //======================
/** Tell whether the queue has no more elements. */
public boolean isEmpty()
{ return size() == 0;
} //======================
/** Remove the value that has been in the queue the longest
* time. Throw an Exception if the queue is empty. */
public Object dequeue()
{ return remove (0);
} //======================
/** Return what dequeue would give, without modifying
* the queue. Throw an Exception if the queue is empty. */
public Object peekFront()
{ return get (0);
} //======================
/** Add the given value to the queue. */
public void enqueue (Object ob)
{ add (ob);
} //======================
}
|
2