A more detailed introduction to Java¶

int i = 1000;        // int variable i = 1000.
int j;               // int variable j = 0 (numbers are default initialized to 0).

long k = 3123456789;   // COMPILER ERROR: 3123456789 is too large to be an int!
long m = 3123456789L;  // OK: 3123456789L is a long constant and fits into a long variable.

byte a = 100;        // byte variable a = 100. int constant 100 --> byte value 100.
byte b = i;          // COMPILER ERROR: value changing conversion int --> byte.
                     // Java converts an int constant into a smaller integer type IF
                     // the smaller type can represent the value. i = 1000 does not fit
                     // into a byte and the actual result would be a byte value -24.
byte c = (byte) i;   // OK: an explicit type cast int --> byte which results in c = -24.
                     // Java type cast uses the C syntax: the target type is given
                     // in parentheses in front of the value we want to convert.

boolean e;                // boolean variable e = false (default initialized to false).
boolean f = true;         // boolean variable f = true.
boolean g = (boolean) i;  // COMPILER ERROR: int i cannot be converted into a truth value.
                          // Different from C/C++/Python: in Java truth values and integers
                          // cannot be converted from/to each other!
boolean h = i > j;        // h = true because the condition i > j, ie. 1000 > 0, is true.

float x = 0.0;       // COMPILER ERROR: 0.0 is a double constant and Java does not convert
                     // a double into a float without explicit type cast.

float y = 1.5F;      // OK: 1.5F is a float constant.
float z = 0;         // OK: Java automatically converts int 0 --> float 0.0F.

double p = 3.14;
float q = p;          // COMPILER ERROR: double cannot be assigned to float!
float r = (float) p;  // OK: explicit type cast double --> float.

int s = p;           // COMPILER ERROR: double cannot be assigned to int!
int t = y;           // COMPILER ERROR: float cannot be assigned to int!
int u = (int) y;     // OK: explicit type cast float --> int. The result is u = 1, which
                     // is simply y = 1.5 without the fractional part.

int x = 100;       // primitive value int = 100.
Integer y = 200;   // An Integer object enclosing int = 200; created by a boxing conversion.
x + y;             // Arithmetic and logical operations can be applied to wrapper objects.
y / 3;             // E.g here x + y = 300 and y / 3 = 66.
x > y;             // Evaluates to false because the condition 100 > 200 does not hold.

String s1 = "One";                    // s1 refers to a constant String object "One".
String s2 = new String(" to three:"); // s2 is a new String object " to three:".
String n1 = " 1";
String n2 = " 2";
String n3 = " 3";

// The + operator means concatenation when applied to (at least one) string: the result is
// a new String object that represents the concatenation of the two operands. If one of
// the operands is not a String, Java will automatically convert it into a String.
// Below s3 will eventually refer to a String object representing "One to three: 1 2 3".
String s3 = s1 + s2 + n1 + n2 + n3;

// Above s3 was constructed by a chain of String concatenation operations, each creating
// new strings: "One to three:", "One to three: 1", "One to three: 1 2" and
// "One to three: 1 2 3". This is clearly inefficient: repeated concatenations involved
// copying 13 + 15 + 17 + 19 = 64 characters although the end result has only 19 characters.
// In this kind of a situation it might be a good idea to use the mutable String type
// StringBuilder instead. A StringBuilder object can be manipulated e.g. with the member
// function append that adds a given string to the end of the current string. The code
// below makes similar concatenations as above, but this time the use of StringBuilder
// avoids building a new string et each step and needs to copy only 19 characters: the first
// StringBuilder object contains "One" and will be extended with s2, n1, n2 and n3.
StringBuilder b = new StringBuilder(s1);
b.append(s2).append(n1).append(n2).append(n3);

// The contents of a StringBuilder object can be transformed into a regular immutable String
// by calling the member function toString. Here it will create a new String with 19 characters.
// Constructing the String s4 hence requires copying a total of 19 + 19 = 38 characters, if we
// take account the work required to build the StringBuilder object b above.
String s4 = b.toString();  // s4 is initialized with b's string "One to three: 1 2 3".

// It is worth noting that the compiler can concatenate string literals efficiently at compile
// time. The preceding note about possible inefficiency concerns concatenation where at least
// one operand is a String object. E.g. s5 below will be initialized directly into the string
// "One to three: 1 2 3" without excessive copying: the compiler can first stitch the string
// literals together into "One to three: 1 2 3" and then use that to initialize a String object.
String s5 = "One" + " to three:" + " 1" + " 2" + " 3";

// Note that if the basic comparison operators != and == are applied to reference variables,
// the result will tell whether the two variables refer to the same object. Java has a convention
// that a class should implement an object comparison function "equals" if the class implementor
// expects that objects of that class need to be compared for similarity.
s3 == s4;       // false bacause s3 and s4 refer to different String objects.
s3 != s4;       // true because s3 and s4 refer to different String objects.
s3.equals(s4);  // true because s3 and s4 refer to similar strings "One to three: 1 2 3".

// String literals are String objects so you can call also their member functions!
"One two three: 1 2 3".equals(s3);    // true because s3 is "One to three: 1 2 3".

// If you compare a string literal and a String object, use the above order where the equals
// function of the string literal is called: this works correctly even if the compared other
// String happens to be null!
String s5 = null;
"One two three: 1 2 3".equals(s5);  // false (and not an error!) because s5 is null.
// The same comparison but using opposite order: now the program would crash with a runtime error!
s5.equals("One two three: 1 2 3");  // Cannot call a member function of a null reference...

String s6;  // A reference variable without an explicit initializer is initialized to null.
s5 == s6    // true because both s5 and s6 are null.

// The wrapper class of each primitive type "TYPE" contains a class function named "parseTYPE"
// that interprets a string into a value of that particular primitive type. A string can e.g.
// be converted into an int value by calling Integer.parseInt, into a float value by calling
// Float.parseFloat and into a boolean value by calling Boolean.parseBoolean.
int i = Integer.parseInt("2021");                       // i = 2021.
float pi = Float.parseFloat("3.1415926535");            // pi = 3.1415926535F.
boolean t = Boolean.parseBoolean("tRuE");               // t = true (case insensitive).

// Each wrapper class also contains a class function "toString" that converts a primitive value
// given as a parameter into a String. Use these to convert primitive values into strings. If the
// original value is already wrapped, the conversion should be done more directly by calling
// the "toString()" member function .
String piStr = Float.toString(pi);           // piStr = "3.1415927"  (float is inaccurate!)
String weekHourStr = Integer.toString(24*7); // weekHourStr = "168"
String yStr = y.toString();                  // yStr = "200", here y was an Integer object.

// The Java array syntax is quite similar to C/C++: a variable definition is changed into an
// array definition of the same type by adding one pair of square brackets per array dimension.
// There are two notable differences:
//   1) the square brackets should be placed after the type and not after the name.
//      (Java does allow also the latter C-style, but this is consided bad style in Java.)
//   2) Brackets are given as empty, without size information: the array dimension sizes are
//      specified either implicitly in form of an array initializer or explicitly as part of a
//      new operator call that creates a new array.

// Define vals as a reference variable that can refer to an int array.
// Here it = null as we did not give an initializing value.
int[] it;

// Set it to refer to a new int array of size 100 created with the new operator. The size is
// given inside square brackets after the array item type. The array values are default
// initialized with zeros.
it = new int[100];

// An array can naturally be created directly when defining an array reference variable.
// This time we create an array of reference type values; they are default initialized to null.
// The result below will thus be a Double array initialized with 1000 null references.
Double[] dt = new Double[1000];

// Below the result will be dt[172] = 0.0 as it[5] = 0. Here we first need an explicit type cast
// from an int into a double so that Java can then perform an automatic autoboxing conversion
// double -> Double. E.g. an attempt to cast an int directly into a Double would lead into a
// compiler error.
dt[172] = (double) it[5];

// The initial contents of an array can be defined using similar syntax as in C/C++: list the
// comma separated array items inside curly brackets. Autoboxing is apllied also to array value
// initializers so e.g. below we may give int constants as initializer values for an Integer
// array: Java will automatically convert them to Integer objects.
Integer[] it2 = {1, 2, 3, 4};

// It is possible to use new operator explicitly with an array initializer expression. In this
// case the array size is not specified inside square brackets. Here it3 is similar to it2.
Integer[] it3 = new Integer[]{1, 2, 3, 4};

// Java arrays have an int member variable "length" that tells the size of the array.
it2.length == 4;            // true because the array it2 was initialized to contain 4 values.

// Java does not allow illegal array index references. E.g. the attempt below to increment the
// value it2[4] leads into a runtime error as the legal indices for a size-4 array are 0...3.
it2[4] += 1;

// If you wish to test this code on your own computer, copy the code into a file LegalDate.java,
// compile it as "javac LegalDate.java" and run as "java LegalDate dd.mm.yyyy", where
// missä dd.mm.yyyy is some date (e.g. 29.2.2021).
public class LegalDate {
  // Note how all members of LegalDate are static.

  // A Java function definition has a similar form as C/C++ functions: the return type is in
  // front of the function name, and the parameter types and names are listed inside parentheses
  // after the function name.
  // The function isLeapYear returs a truth value telling whether "year" is a leap year.
  static boolean isLeapYear(int year) {
    // A leap year: divisible by 4 and either not divisible by 100 or divisible by 400.
    // Java has taken arithmetic logical operation syntax quite directly from C.
    return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
  }

  // We could store information about the number of days in each month in many ways. Here, as a
  // further example of array syntax, we define a two-dimensional int array: one size-2 subarray
  // for each month that tells the number of day in a normal and leap year. Only February has
  // a difference between the two.
  static int[][] mDays = {{31, 31}, {28, 29}, {31, 31}, {30, 30}, {31, 31}, {30, 30},
                          {31, 31}, {31, 31}, {30, 30}, {31, 31}, {30, 30}, {31, 31}};

  // The function monthDays tells how many days the specified month has in the specified year.
  // A return value -1 signals illegal month number.
  static int monthDays(int month, int year) {
    int days = -1;
    if(1 <= month && month <= 12) {
      // Conditional operator same as in C/C++.
      days = isLeapYear(year) ? mDays[month-1][1] : mDays[month-1][0];
    }
    return days;
  }

  // The function isLegalDate checks whether the parameters day, month and year correspond
  // to a legal date. The year is assumed to be always legal (e.g. also negative values).
  static boolean isLegalDate(int day, int month, int year) {
    // The result is simple to compute as monthDays returns -1 if the month is illegal.
    return (1 <= day) && (day <= monthDays(month, year));
  }

  public static void main(String[] args) {
    // Java String class has a member function "split" that returns a String array that
    // contains the result of partitioning the string based of the specified delimiter.
    // Here we partition the command line parameter args[0] based on the dot character ".".
    // There are two escape characters '\' in front of the dot due to technical reasons:
    // split interprets its parameter as a regular expression where dot has a special meaning.
    String[] dayMonthYear = args[0].split("\\.");
    boolean dateOk = false;
    if(dayMonthYear.length == 3) {
      // Convert the string parts into integers with Integer.parseInt.
      int day = Integer.parseInt(dayMonthYear[0]);
      int month = Integer.parseInt(dayMonthYear[1]);
      int year = Integer.parseInt(dayMonthYear[2]);
      dateOk = isLegalDate(day, month, year);
    }
    System.out.println("The date " + args[0] + (dateOk ? " is legal." : " is illegal!"));
  }
}

// If you try to run the program e.g. as "java TuniSearch use your opportunities", the program
// should find the string "tuni" in the parameter args[2] = "opportunities" and print a message:
// Found "tuni" at index 5 of opportunities.
public class TuniSearch {
  // This example contains all functionality brutely in the main function.
  public static void main(String[] args) {
    // The variable "key" holds the string to search for. Here we fix it to "tuni". The extra
    // specifier "final" corresponds to "const" in C/C++: the value of key may not be changed.
    final String key = "tuni";

    // A Java for-each loop that iterates some value sequence is similar to C++11 (and Java
    // actually had this earlier than C++). C does not have this for loop variant.
    // The variable "word" iterates over all strings in the command line parameter array "args".
    // Here we have also given the label "SEARCH_LOOP" to the outer loop. A loop label allows
    // to easily exit a nested loop by using Java's labeled break statement. C/C++ don't have
    // labeled break; they have the more general (and dangerous?) goto statement instead.
    SEARCH_LOOP:
    for(String word : args) {
      // A traditional index based for loop that iterates over all
      // potential starting positions of "key" inside "word".
      // The length of a String is given by its member function length().
      // Note how length is a function (in arrays it is a member variable).
      for(int i = 0; i <= word.length() - key.length(); i++) {
        // Now use a while loop for a change. The loop checks character by character
        // whether an occurrence of "key" is found starting at index i.
        // The String member function cal charAt(x) returns the character at index x.
        int j = 0;
        while(j < key.length() && word.charAt(i+j) == key.charAt(j)) {
          j += 1;
        }
        // Did we match all key.length() characters?
        if(j == key.length()) {
          // Now use "format" printing function for a change. It is very similar
          // to the printf function in C. One visible difference below is that
          // the format specifier %n means a new line.
          System.out.format("Found \"tuni\" at index %d of %s%n", i, word);
          // Exit the outer loop by using a labeled break statement. A normal
          // break would exit the nearest enclosing loop, but a labeled break
          // exits the loop that has a matching label.
          break SEARCH_LOOP;
        }
      }
    }
  }
}

import java.util.Arrays;  // The test code needs the java.util.Arrays class.

public class Max {

  // Take the first two values as normal parameters in order to ensure that
  // the caller gives at least 2 values (and there is something to calculate).
  public static int max(int first, int second, int... rest) {
    int maxVal = (first > second) ? first : second;
    for(int val : rest) {
      if(maxVal < val) {
        maxVal = val;
      }
    }
    return maxVal;
  }

  // A test main funtion that converts command line parameters to integers
  // and computes some maxima over them.
  public static void main(String[] args) {
    int[] it = new int[args.length];
    for(int i = 0; i < args.length; i++) {
      it[i] = Integer.parseInt(args[i]);
    }

    // First a couple of test with a fixed number of parameters:
    // the calls max(it[0], it[1]), max(it[0], it[1], it[2]) and
    // max(it[0], it[1], it[2], it[3]).
    if(it.length >= 2) {
    System.out.format("Max(%d, %d) = %d%n", it[0], it[1],
                                        max(it[0], it[1]));
    }
    if(it.length >= 3) {
      System.out.format("Max(%d, %d, %d) = %d%n", it[0], it[1], it[2],
                                              max(it[0], it[1], it[2]));
    }
    if(it.length >= 4) {
      System.out.format("Max(%d, %d, %d, %d) = %d%n", it[0], it[1], it[2], it[3],
                                                  max(it[0], it[1], it[2], it[3]));
    }

    // Then a test where we compute the maximum over all command line parameters
    // (if there were at least 2) with a single function call. Since the number of parameters
    // is not known beforehand, it would not be possible to give the parameters separately.
    // But we can give the remaining parameters (after the first two) as an array.
    if(it.length >= 2) {
      // Arrays.copyOfRange(t, a, b) copies the array t interval a..b-1 into a new array.
      int[] rest = Arrays.copyOfRange(it, 2, it.length);
      // Arrays.toString gives a reasonable string representation of a primitive array.
      System.out.format("Max(%d, %d, %s) = %d%n", it[0], it[1], Arrays.toString(rest),
                                                              max(it[0], it[1], rest));
    }
  }
}

// Note: this code should be placed in a file named WhatDayIsIt.java.

// Declare the contents of this file to belong to a package named "fi.tuni.itc.programming3".
// A file can have at most one package declaration.
package fi.tuni.itc.programming3;

// The code uses the class DateFormat from Java package java.text and the
// classes Date and Locale from the package java.util. These must be made
//  accessible by importing them with import statements.
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;

// A top level class definition.
// Recommendation: one top level class / interface per file.
public class WhatDayIsIt {
  public static void main(String[] args) {
    Date now = new Date();  // Create a Date object corresponding to current time.
    // The locales used in this example: Gernamy, Japan, Korea and USA
    Locale[] locales = {Locale.GERMANY, Locale.JAPAN,
                        Locale.KOREA, Locale.US};
    System.out.println("What day is it now in different locales?");
    // Iterate over the four locales put into locales array above.
    for(Locale locale : locales) {
      // First print the locale name in US english (= Locale.US).
      System.out.print("In " + locale.getDisplayName(Locale.US) + ": ");
      // Initialize a DateFormat object df that formats a Date object according
      // to the format parameter and locale supplied to getDateInstance.
      DateFormat df = DateFormat.getDateInstance(DateFormat.FULL, locale);
      // The call df.format(now) formats the date represented by the Date object "now".
      System.out.println(df.format(now));
    }
  }
}