Core Java

Fundamental Programming Structures in Java

Slide navigation: Forward with space bar, → arrow key, or PgDn. Backwards with ← or PgUp.

Write a simple Java program

We will not use ‘Hello, World!’

• public class FirstSample
  {
     public static void main(String[] args)
     {
        System.out.println("We will not use 'Hello, World!'");
     }
  }

• Java is case sensitive: Main ≠ main.
• Keywords public, static, etc.
• Braces { } are used for blocks.
• Statements end in semicolons.
• Everything is inside a class.
• By convention, class names are CamelCase.
• Source file must be called FirstSample.java.

Method Calls

• System.out.println("We will not use 'Hello, World!'");
  

• General structure:

  object.method(parameters)

• Parentheses needed even if there are no parameters:

  System.out.println();

Comments

• Single-line comments:

  // like this

• Multi-line comments:

  /*
     like
     this
     ...
  */

• Documentation comments:

  /**
   * This is the first sample program in Core Java Chapter 3
   * @version 1.01 1997-03-22
   * @author Gary Cornell
   */

• Caution: /* ... */ comments do not nest.

FirstSample

Work with numeric data types

Integers

• Four integer types:

  int	4 bytes	–2,147,483,648 to 2,147,483, 647 (just over 2 billion)
  short	2 bytes	–32,768 to 32,767
  long	8 bytes	–9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
  byte	1 byte	–128 to 127

• Literals:
  • Long: 4000000000L
  • Hex: 0xCAFE
  • Binary: 0b1111_0100_0010_0100_0000

Floating-Point Numbers

• Two floating-point types:

  float	4 bytes	Approximately ±3.40282347E+38F (6–7 significant decimal digits)
  double	8 bytes	Approximately ±1.79769313486231570E+308 (15 significant decimal digits)

• float literals: 0.5F
• Only use float if a library requires it.
• Special values Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NaN.

The char Type

• Originally used to describe Unicode characters.
• Nowadays: “Code Units” in the UTF-16 encoding.
• Every Unicode character requires one or two char values:
  • A has “code point” U+0041 and is encoded as a single char value (hex 0041 or decimal 65).
  • 𝕆 has “code point” U+1D546 and is encoded by two code units with hex values D835 DD46.
• Avoid char unless you know that you won't run into Unicode characters ≥ U+10000.
• Character literals enclosed in single quotes: 'A', '\n', '\u2122'.

The boolean Type

• Two values: false, true.
• No conversion between int and boolean.
• All together, Java has eight primitive types:
  • int, long, short, byte
  • double, float
  • char
  • boolean

Variables

• Every variable must be declared with a type, which comes before the name:

  int vacationDays;
  

• Initialization is optional:

  int vacationDays = 12;
  

• Declaration can appear anywhere in block.
  • Declare as close as possible to first use.
• Can assign new value with = operator:

  vacationDays = 11;

• Constant declared with final:

  final int vacationDays = 12;

Mathematical Operators and Functions

• Arithmetic: +, -, *, /
• Integer division and modulus: / and % (with integer operands):
  • 15 / 2 is 7.
  • 15 % 2 is 1.
  • 15.0 / 2 is 7.5.
• Math.sqrt(x) is √ x.
• Math.pow(a, b) is a^b
• Math.floorMod(a, b) is like a % b with better behavior for negative values:
  • Math.floorMod(-15, 2) is 1.
• Trig and log functions: Math.sin, Math.log, ...

Type Conversions

• These conversions are automatic:
  
  (Dotted arrows indicate possible precision loss.)
• Use casts for explicit conversions:

  double x = 9.997;
  int nx = (int) x;
  int rx = (int) Math.round(x)

More Operators

• Combining assignment with operators:

  n += 4; // Same as n = n + 4

• Also -=, *=, /=, %=, and so on.
• Increment, decrement:

  n++; n--;

• Relational operators: ==, !=, <, <=, >, >=
• boolean operators: &&, ||, !
• Bitwise operators: &, |, ^, ~, >>, >>>, <<
• Conditional operator:

  x < y ? x : y

Enumerated Types

• A type with a restricted set of values.
• Example:

  enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

• Can declare variable of this type:

  Size s = Size.MEDIUM;

• Variable of type s can only hold size values or null.

Java 9 News Flash - JShell

• jshell is a part of Java 9.
• Work with me as I do this.
• Open a terminal.
• Type jshell and hit the Enter key.
• Type Math.sqrt(1764) and hit the Enter key.
• Type $1 + 1
  • The resulting value was stored in $1
  • The next result will be in $2 and so on.

Cursor Keys and Tab Completion

• Use the arrow keys to recall/edit prior commands.
• Hitting the Tab key brings up reasonable suggestions.
• Type "Hello". and then hit the Tab key.
  • You'll get all methods that can apply.
• Type toU and hit the Tab key again.
  • The toUpperCase method is completed.
• Hit the Tab key again.
  • You get to see the two overloaded methods.
• Hit the Tab key again.
  • You get to see the online documentation.

JShell Tips

• Tip #1: Shift+Tab and V key fills in variable declaration.
  • Try it: new Random(), then Shift+Tab, then the V key (unshifted).
• Tip #2: Shift+Tab and I key fills in import declaration.
  • Try it: Instant, then Shift+Tab, then the I key.

Java 10 News Flash - Local Type Inference

• Can use var instead of type for local variables:

  var counter = 0; // an int
  var message = "Greetings, earthlings!"; // a String
  

• Still strongly typed:

  counter = 0.5; // Error—can't assign a double to an int

• Useful for unwieldy type names:

  var traces = Thread.getAllStackTraces(); // a Map<Thread,StackTraceElement[]>

Work with Strings and the API documentation

Strings

• Sequences of Unicode characters.
• String literals enclosed in double quotes: "Java\u2122".
• Instances of String class.
• Use substring method to extract substrings:

  String greeting = "Hello";
  String s = greeting.substring(0, 3);

• Positions start at zero.
• Last position is excluded—s.substring(a, b) has length b - a.
• Positions are code units (not code points).

String Concatenation

• Concatenation (+) joins strings:

  String expletive = "Expletive";
  String PG13 = "deleted";
  String message = expletive + PG13;

• If one operand is not a string, it is turned into a string:

  int age = 13;
  String rating = "PG" + age;

More About Strings

• Strings are immutable: greeting.substring(0, 3), greeting + "!" don't change greeting.
• Can reassign string variables:

  greeting = greeting.substring(0, 3) + "p!";

• String comparison:

  "Hello".equals(greeting)
  "Hello".equalsIgnoreCase(greeting)

• Caution: Do not use the == operator.

  "Hello".substring(0, 3) == "Hel" // probably false

• Empty string "" has length 0.
• null indicates no string at all.

Code Points and Code Units

• s.length() is the number of code units (not Unicode characters).
• s.charAt(i) is the i^th code unit.
• To get the i^th code point:

  int index = s.offsetByCodePoints(0, i);
  int cp = s.codePointAt(index);

• To get all code points:

  int[] codePoints = str.codePoints().toArray();

The String API

• Many other useful String methods.
• trim yields a new string, trimming leading and trailing white space.
• toLowerCase yields a new string that coverts all uppercase characters to lowercase.
• indexOf, lastIndexOf find the location of a substring.
• Check out the online API documentation!

Java 9 News Flash - API Search

• The Java API now has a search bar.
• So much better than searching the package list.

Write programs that read input and produce output

Console Input

• Read console input from a Scanner:

  Scanner in = new Scanner(System.in);
  

• Use nextLine, next, nextInt, nextDouble to read input:

  int age = in.nextInt();

• Need to add import statement:

  import java.util.*;

Formatted Output

• Use printf for formatted printing:

  System.out.printf("Price:%8.2f", 10000.0 / 3.0); // Prints Price: 3333.33

• Use f for floating-point, d for integer, s for strings and other objects.
• Flags modify output:

  System.out.printf("%(,.2f", -10000.0 / 3.0); // prints (3,333.33) 

• Use String.format if you don't want to print:

  String message = String.format("Hello, %s. Next year, you'll be %d", name, age);

File Input and Output

• Reading from a file:

  Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");

• Writing to a file:

  PrintWriter out = new PrintWriter("myfile.txt", "UTF-8");
  out.println(...);

• Need to import java.io, java.nio.path packages.
• Need to tag main like this:

  public static void main(String[] args) throws IOException
  {
     Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");
     . . .
  }

InputTest

Use the control flow constructs of the Java language

The if Statement

if (yourSales >= 2 * target)
{
   performance = "Excellent";
   bonus = 1000;
}
else if (yourSales >= 1.5 * target)
{
   performance = "Fine";
   bonus = 500;
}
else if (yourSales >= target)
{
   performance = "Satisfactory";
   bonus = 100;
}
else
{
   System.out.println("You're fired");
}

The while Statement

while (balance < goal)
{
   balance += payment;
   double interest = balance * interestRate / 100;
   balance += interest;
   years++;
}
System.out.println(years + " years.");

The do/while Statement

do
{
   balance += payment;
   double interest = balance * interestRate / 100;
   balance += interest;
   year++;
   // print current balance
   . . .
   // ask if ready to retire and get input
   . . .
}
while (input.equals("N"));

Retirement

Retirement2

The for Statement

for (int i = 1; i <= 10; i++)
   System.out.println(i);

LotteryOdds

The switch Statement

Scanner in = new Scanner(System.in);
System.out.print("Select an option (1, 2, 3, 4) ");
int choice = in.nextInt();
switch (choice)
{
   case 1:
      . . .
      break;
   case 2:
      . . .
      break;
   case 3:
      . . .
      break;
   case 4:
      . . .
      break;
   default:
      // bad input
      . . .
      break;
}

The break Statement

• Breaks out of a loop:

  while (years <= 100)
  {
     balance += payment;
     double interest = balance * interestRate / 100;
     balance += interest;
     if (balance >= goal) break;
     years++;
  }

• Can always replace break by placing the remainder inside if and adding another termination condition:

  while (years <= 100 && balance < goal)
  {
     balance += payment;
     double interest = balance * interestRate / 100;
     balance += interest;
     if (balance < goal)
        years++;
  }

• A “labeled break” lets you break out of multiple nested loops.

The continue Statement

• Continues with the next loop iteration:

  Scanner in = new Scanner(System.in);
  while (sum < goal)
  {
     System.out.print("Enter a number: ");
     n = in.nextInt();
     if (n < 0) continue;
     sum += n; // not executed if n < 0
  }
  

• If n < 0, then sum < goal is checked next.
• Can always replace continue by placing the remainder inside if.
• A “labeled continue” lets you continue in an outer loop.

Work with big numbers when arbitrary precision is required

Big Numbers

• If the precision of int and double doesn't suffice, use BigInteger or BigDecimal.
• Turn an int into a BigInteger:

  BigInteger a = BigInteger.valueOf(100);

• Use methods such as add and multiply to combine big numbers:

  BigInteger c = a.add(b); // c = a + b
  BigInteger d = c.multiply(b.add(BigInteger.valueOf(2))); // d = c * (b + 2)

• Example: Pick 60 numbers out of 490. Your odds of winning are 1 in 716395843461995557415116222540092933411717612789263493493351013459481104668848. Good luck!

BigIntegerTest

Java 9 News Flash - BigInteger.TWO

• Java 8 had constants BigInteger.ZERO, BigInteger.ONE, and BigInteger.TEN
• Java 9 gives us BigInteger.TWO
• No BigInteger.THREE in Java 10, but there is always hope for Java 11.

Use arrays to store multiple elements of the same type

Arrays

• int[] is an array of integers.
• Array variable declaration:

  int[] a;

• new operator creates array:

  int[] a = new int[100];

• Array indexes are from 0 to a.length - 1.
• Use [] to access elements:

  for (int i = 0; i < a.length; i++)
     System.out.println(a[i]);

• Or use the “for each” loop:

  for (int element : a)
     System.out.println(element);

Supplying Element Values

• Array initializers:

  int[] smallPrimes = { 2, 3, 5, 7, 11, 13 };

• Anonymous arrays:

  new int[] { 17, 19, 23, 29, 31, 37 }

Copying Arrays

• Copying array variables yields two references to the same array:

  int[] luckyNumbers = smallPrimes;
  luckyNumbers[5] = 12; // now smallPrimes[5] is also 12

  
• Use Arrays.copyOf to make a true copy:

  int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length);

LotteryDrawing

Multidimensional Arrays

• int[][] is an array of arrays or a two-dimensional array:

  int[][] magicSquare =
  {
     {16, 3, 2, 13},
     {5, 10, 11, 8},
     {9, 6, 7, 12},
     {4, 15, 14, 1}
  };

• Without initializer:

  int[][] magicSquare = new int[ROWS][COLUMNS];
  

• Use two indexes to access element: magicSquare[1][2] is 11.
• Use this loop to traverse the elements:

  for (int[] row : magicSquare)
     for (int element : row)
        do something with value
  

• If the rows have different lengths, the array is “ragged”:

  int[][] triangle = new int[ROWS][];
  for (int i = 0; i < ROWS; i++) triangle[i] = new int[i + 1];

CompoundInterest

LotteryArray