Some Java Skills

// Use printf function:
System.out.printf("hello!\n"); 
     

// %d for integer, %f for real(double)
int value = 7;   
double recip = 1.0 / 7; 
System.out.printf("reciprocal of %d is %f\n", value, recip);

// Use %.2f for 2 decimal places of precision
System.out.printf("Payment amount is $ %.2f\n", amount);

// Let's declare 2 scanners:  kbd to read from the keyboard,
// and in to read from a file.
Scanner kbd = new Scanner(System.in);
Scanner in = new Scanner(new FileInputStream("input.txt"));

// Most often we use nextInt(), nextDouble() and nextLine()
double value = in.nextDouble();

// Let's declare some variables and set them to some default
// initial values.
int numCards = 52;
boolean found = false;
double sum = 0.0;
String dessert = "ice cream";

// Multiply by 1.0
     

// We can simply use a "cast" and this will chop off the decimal places.
// If you want to round a real number to the nearest integer, we should first
// call Math.round().
double exactValue = 6.7;
int truncatedValue = (int) exactValue;
int roundedValue = (int) Math.round(exactValue);

// Append (concatenate) onto an empty string.
int value = 42;
String s = "" + value;

// Use Integer.parseInt()
String s = "456";   
int value = Integer.parseInt(s);

// Use if statement.  Note the use of ==, !=, && and ||
if (year % 400 == 0 ||
    year % 100 != 0 && year % 4 == 0)
  System.out.printf("Leap year\n");

// See if value is an even number
if (value % 2 == 0)
  System.out.printf("%d is an even number\n", value);
	  

// Use length() function on the string.
String message = "dinner is ready!";
int length = message.length();

// Use charAt(), and put the position # inside the parentheses.
// Remember that indices start at 0.
char thirdChar = message.charAt(2);

// indexOf can look for either a single character or a substring
// returns -1 if the pattern doesn't exist
int location = message.indexOf("ready"); 

// Use substring
String phoneNumber = (305)667-1651;
String areaCode = phoneNumber.substring(1,4);

// Use equals() instead of ==
if (enteredPassword.equals(correctPassword))
  System.out.printf("Welcome!\n");

// compareTo subtracts the two strings.  
// e.g. Negative result means the first string appears earlier in dictionary.
if(s1.compareTo(s2) < 0)
  System.out.printf("%s comes before %s in the dictionary\n", s1, s2);

// use +

// Use while loop, with a variable that counts.
int i = 0;
while (i < 10)
{
  // insert the code that you want to perform
  i = i + 1;
}
    

// Use while loop with a boolean variable
// In this example, we are trying to obtain a positive number.
boolean needInput = true;
while (needInput)
{
  System.out.printf("Please enter positive int:");
	value = kbd.nextInt();
  if (value > 0)
    needInput = false;
  else
    System.out.printf("Sorry, your input is " +
					"invalid.  Try again.\n");
}

// Here is an array of 50 integers, called a.
int [] a = new int [50];

// First, assume first value contains largest value.
// Then, look at each of the elements and compare to what
// we currently think is the max.  Update the max if necessary.
// Note that a.length stores the size of the array.  :)
int max = a[0];
int i = 0;
while (i < a.length)
{
  if (a[i] > max)
    max = a[i];
}
System.out.printf("The largest number is %d\n", max);

// While loop:  as long as there are still lines in the file,
// keep reading lines one at a time.
// Let's assume the variable in refers to a file we've opened.
while (in.hasNextLine())
{

  String line = in.nextLine();
  // do something with this line, as appropriate
}

// Use the String.format function.  It works like printf.
// This is useful when we write toString() functions.
// For example, let's suppose we want to write out a team's
// win-loss-overtime loss record.
// Note:  as with printf, we should not end with \n.
String s = String.format("%d-%d-%d", wins, losses, overtimeLosses);

// Simple example:  a rectangle.  We need to define our attributes,
// at least one constructor... and whatever other functions we desire.
public class Rectangle
{
  private int length;
  private int width;

  public Rectangle(int length, int width)
  {
    this.length = length;
    this.width = width;
  }


  public int findArea()
  {
    return length * width;
  }
}

// First, we need to ask ourselves 3 questions to help us plan:
// 1.  Do we need parameters (extra information) ?
// 2.  Do we change any attributes?
// 3.  Should we return some kind of result?
// Let's look at the withdraw example from the Account class:
public boolean withdraw (double amount)
{
  if (amount > this.balance)
    return false;
  else
  {
    this.balance = this.balance - amount;
    return true;
  }
}

// Often a default constructor will need to get input in order
// to set the values of the attributes.  Let's do one for Rectangle.
public Rectangle()
{
  System.out.printf("Please enter length:  ");
  Scanner kbd = new Scanner(System.in);
  this.length = kbd.nextInt();
  System.out.printf("Please enter width:  ");
  this.width = kbd.nextInt();
}

// See the "define a class" example above.
// It uses an initial-value constructor.

// There should be 1 parameter:  the object we want to copy.
// Let's do one for Rectangle.
public Rectangle (Rectangle r)
{
  this.length = r.length;
  this.width = r.width;
}

// Let's suppose all bank accounts have the same interest rate.
public static void double RATE = 3.25;

// Once we've defined a class (new data type), we'd like to
// create objects (variables) of this new type.
// First, you have to decide which constructor is appropriate,
// then pass the right parameters.
Rectangle tableTop = new Rectangle (6, 3);

// Do this in 2 steps.
// First, declare the name of the array at the top of the class
//   where we normally declare our attributes.
// Second, at the beginning of the constructor(s), we need to
//   allocate space for the array.
// For example, let's say we want a hand to have 13 cards.
public class Hand
{
  private Card [] c;
  
  public Hand()
  {
    c = new Card [13];
    // rest of the program

// Same idea as with the array attribute:  declare the attribute at 
// the beginning of the class.  Then, inside the constructor, don't
// forget to allocate space.

// Use String.format() just like you would use printf.
// Aside:  Recall that inside toString() we generally do not use \n
// at the end of the string.  This is because whoever is calling
// toString() will likely be printing \n after our string,
// and we would not want to inadvertently have two \n in a row.
// An exception to this rule would be if our string has multiple lines
// anyway.


String s = String.format("%-20s %5d", name, value);

// The purpose of toString() is to provide a text representation of
// an object.  Usually we want to put the attributes inside a string
// so that it can be printed out later.  
// But if an attribute is an array (or ArrayList), we will need a loop.
// The following example may be suitable for a shopping list.
public String toString()
{
  String build = "";
  for (int i = 0; i < shoppingList.length; ++i)
  {
    build += shoppingList[i].toString() + "\n";
  }
  return build;
}

// Sometimes we need to find the sum of an array.  But the array 
// cells each contain an object, not just a number.  For example,
// for a shopping list, we have an array of Items, and we want to
// find the sum of all the item's prices.  For each item, we need
// to look up the price and add it to our total.
double total = 0.00;
for (int i = 0; i < shoppingList.length; ++i)
  total += shoppingList[i].getPrice();

// When you pass an array as a parameter to a function, you can just
// type its name, just like it were any other kind of variable.
// However, when declaring the function, be sure to remember the "[]"
// in the formal parameter list.


// In Driver:
   City c = new City(name, tempArray, rainArray);
// In City:
   public City(String n, double [] temp, double [] rain) ...

// First, create Random generator object.  Then, when you want a
// random integer, call nextInt().  The parameter to nextInt()
// indicates how many possible values to choose from, starting at 0.
// For example, we can generate a value from 0-19:
Random gen = new Random();
int value = gen.nextInt(20);



// You may need to do some arithmetic if this is not the range you want.

// The Random class also has a nextDouble() function.  It takes no
// parameter and always returns a value between 0.0 and 1.0.
// We can multiply and/or add to adjust the desired range.  For example,
// to obtain a number between 0.0 and 10.0:

double value = gen.nextDouble() * 10;

// This is the most common type of loop in Java.  (The other kinds
// are the while loop and do-while loop.)
// The format of a for-loop is:
//    for (INITIALIZATION; CONDITION; INCREMENT)
//      BODY

// Let's find the sum of all the values in an array using a for loop:
int sum = 0;
for (int i = 0; i < a.length; ++i)
  sum += a[i];

// Least common kind of the 3 kinds of loops.  
// The loop is guaranteed to do at least 1 iteration because we don't
// check the condition until the bottom of the loop.
// Here is how we can do error checking with a do-while loop:

boolean needInput = true;

do

{

  System.out.printf("Enter a positive number:  ");

  value = in.nextInt();
  if (value > 0)
    needInput = false;
  else

    System.out.printf("Sorry, try again...\n");

} while (needInput);

// Example of using break statement:
// If you are searching an array, and you want to stop the search
// immediately once you've found something.  Let's look for 0.

for (int i = 0; i < a.length; ++i)
  if (a[i] == 0)
  {
    found = true;
    break;
  }

// Nested loop.  Outer loop is responsible for all the rows, and
// inner loop handles a single row.  We need to print \n after
// each row.  Here is a grid of '*' with 4 rows and 7 columns:

for (int i = 0; i < 4; ++i)

{
  for (int j = 0; j < 7; ++i)

    System.out.printf("*");
  System.out.printf("\n");
}

// 2-D array needs nested loop for rows and columns.
// Suppose the array is called a.  Then a.length is the number of
// rows and a[0].length is the number of columns.
// Let's count the positive elements.
int count = 0;

for (int i = 0; i < a.length; ++i)
  for (int j = 0; j < a[0].length; ++j)
    if (a[i][j] > 0)
      ++count;

// To do something on just 1 row of an array, we only need one loop.
// Here, the row number is fixed and the column number needs to vary.
// Let's say we want to set all of the 2nd row elements to 0.
// (To handle a column would be analogous.)
for (int col = 0; col < a.length; ++col)
  a[1][col] = 0;

// Can replace a lot of tedious if-else statements.  For example,
// we can write out the name of a card's suit.
String suitName = "":
switch (suitChar)
{
  case 'c':  suitName = "clubs"; break;
  case 'd':  suitName = "diamonds"; break;
  case 'h':  suitName = "hearts"; break;
  case 's':  suitName = "spades"; break;
  default:  suitName = "ERROR"; break;
}

// Need to introduce a temporary variable that is the same type as
// what we are swapping.  Let's swap 2 Cards called c1 and c2.
Card temp = c1;
c1 = c2;
c2 = temp;

// Although there are more efficient ways to sort, this technique
// is straightforward to explain:  Look at each possible pair of
// elements.  If they are out of order, swap them.
// In this example, we sort descendingly, so "<" means out of order.

for (int i = 0; i < a.length; ++i)
  for (int j = i+1; j < a.length; ++j)
    if (a[i] < a[j])

    {
      int temp = a[i];
      a[i] = a[j];
      a[j] = temp;
    }



// If the base type of the array is not a primitive type, then
// we need to teach Java how to compare elements.  Instead of
// using < or >, we write a compareTo function like String has.

// If Driver needs additional functions besides main(), we can
// make them static.  
public static void sort(Card [] c)

...

/** These are comments we put at the top of the file and before
 *  each function.  When compiling, our comments come out as HTML.
 *  They begin with a slash and two stars.  They end with a
 *  star and a slash.  Inside the comment, we can specify
 *  certain features about a function such as the parameters
 *  and return value.  For a comment that goes at the top of
 *  the source file, we need to put the Javadoc comment after
 *  the "import" statements.
 */

// When you declare, be sure to specify the base type in <>.
// The most important functions are:  add, get, set and size.
ArrayList<Card> hand = new ArrayList<Card>();

hand.add(new Card('Q', 'd'));



// Let's count the aces in our list of card.
// Assume that the Card class has a function isAce():
int count;

for (int i = 0; i < hand.size(); ++i)
  if (hand.get(i).isAce())
    ++count;

// Suppose we want the user to enter a file name.  It's possible
// that the file does not exist, and this is called an exception.

Scanner in = null;
try
{
  in = new Scanner(new FileInputStream(fileName));
}
catch(FileNotFoundException e)
{
  System.out.printf("Can't open file.  Try again...\n");
}

// A shortcut to doing an "if" statement.  Helpful if the choice
// needs to be made in the middle of another expression.
System.out.printf("I found %d %s.\n", numLogins,
                  (numLogins == 1) ? "login" : "logins");

// char can be treated like integers.  For example, we can use
// a for-loop with a character variable to print out the alphabet:
for (char c = 'a'; c <= 'z'; ++c)
  System.out.printf("%c", c);