Complete Java Reference Course

int     num       = 5;
float   floatNum  = 5.99f;       // 'f' suffix required for float literals
char    letter    = 'D';         // single quotes for char
boolean bool      = true;
String  site      = "quickref.me"; // String is a class, not primitive

String first = "John";
String last  = "Doe";
String name  = first + " " + last;  // concatenation with +
System.out.println(name);           // => John Doe

String word = "QuickRef";
for (char c : word.toCharArray()) {
  System.out.print(c + "-");
}
// Outputs: Q-u-i-c-k-R-e-f-

char[]    chars   = new char[10];   // empty array of 10 chars
chars[0]  = 'a';
chars[1]  = 'b';

String[]  letters = {"A", "B", "C"};    // array literal
int[]     mylist  = {100, 200};
boolean[] answers = {true, false};

int a = 1;
int b = 2;
System.out.println(a + " " + b); // => 1 2

int temp = a;  // save a
a = b;          // a gets b's value
b = temp;       // b gets saved a
System.out.println(a + " " + b); // => 2 1

// Widening (automatic) — byte < short < int < long < float < double
int i  = 10;
long l = i;          // int → long, automatic, no data loss
                      // l = 10

// Narrowing (explicit) — must use cast operator
double d = 10.02;
long   l = (long) d;  // double → long, truncates decimal
                       // l = 10 (0.02 is lost)

// Number ↔ String conversion
String.valueOf(10);          // int → String  => "10"
Integer.parseInt("10");      // String → int  => 10
Double.parseDouble("10");   // String → double => 10.0

int j = 10;

if (j == 10) {
  System.out.println("I get printed");   // runs
} else if (j > 10) {
  System.out.println("I don't");
} else {
  System.out.println("I also don't");
}

import java.util.Scanner;   // import first

Scanner in = new Scanner(System.in);

String str = in.nextLine();     // read a full line
System.out.println(str);

int num = in.nextInt();          // read an integer
System.out.println(num);

String str1 = "value";               // literal — uses String Pool
String str2 = new String("value");   // new object on heap
String str3 = String.valueOf(123);   // number → string "123"

String s = 3 + "str" + 3;     // => "3str3"    (3+"str" → "3str", +"3" → "3str3")
       s = 3 + 3 + "str";     // => "6str"     (3+3=6, 6+"str" → "6str")
       s = "3" + 3 + "str";   // => "33str"    ("3"+3 → "33", +"str" → "33str")
       s = "3" + "3" + "23"; // => "3323"     (all strings, concat)
       s = "" + 3 + 3 + "23";// => "3323"     (""+3 → "3", +"3" → "33", +"23")
       s = 3 + 3 + 23;        // => 29         (no String — pure arithmetic)

// Initial capacity 10 (auto-grows as needed)
StringBuilder sb = new StringBuilder(10);
// [ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]   indices 0-9

sb.append("QuickRef");
// [Q][u][i][c][k][R][e][f][ ][ ]

sb.delete(5, 9);        // delete chars at index 5 to 8
// [Q][u][i][c][k][ ][ ][ ][ ][ ]

sb.insert(0, "My ");    // insert "My " at index 0
// [M][y][ ][Q][u][i][c][k][ ][ ]

sb.append("!");
// [M][y][ ][Q][u][i][c][k][!][ ]

System.out.println(sb.toString()); // => "My Quick!"

String s1 = new String("QuickRef");
String s2 = new String("QuickRef");

s1 == s2                       // false — different objects in memory
s1.equals(s2)                  // true  — same content

"AB".equalsIgnoreCase("ab")   // true  — case-insensitive match

String str = "Abcd";

str.toUpperCase();      // => "ABCD"
str.toLowerCase();      // => "abcd"
str.concat("#");         // => "Abcd#"
str.replace("b", "-");  // => "A-cd"

"  abc ".trim();         // => "abc"  (removes leading/trailing spaces)
"ab".toCharArray();      // => {'a', 'b'}  (String → char[])

String str = "abcd";

str.charAt(2);           // => 'c'        (char at index 2)
str.indexOf("a");         // => 0          (first position of "a")
str.indexOf("z");         // => -1         (not found)
str.length();             // => 4
str.toString();           // => "abcd"     (returns itself)
str.substring(2);         // => "cd"       (from index 2 to end)
str.substring(2, 3);      // => "c"        (index 2 inclusive, 3 exclusive)
str.contains("c");        // => true
str.endsWith("d");        // => true
str.startsWith("a");      // => true
str.isEmpty();            // => false

// WRONG — return value not captured, str unchanged
String str = "hello";
str.concat("world");
System.out.println(str);    // => "hello"  (unchanged!)

// CORRECT — capture the new String returned by concat()
String str2   = "hello";
String result = str2.concat("world");
System.out.println(result); // => "helloworld"

int[] a1;                            // reference only, not yet allocated
int[] a2 = {1, 2, 3};              // array literal
int[] a3 = new int[]{1, 2, 3};    // new keyword with values

int[] a4 = new int[3];            // empty array, size 3 (default 0)
a4[0] = 1;
a4[1] = 2;
a4[2] = 3;

int[] a = {1, 2, 3};
System.out.println(a[0]);      // => 1

a[0] = 9;                       // modify element at index 0
System.out.println(a[0]);      // => 9

System.out.println(a.length);  // => 3  (property, no parentheses)

import java.util.Arrays;

int[][] matrix = { {1, 2, 3}, {4, 5} };  // jagged — row 1 has 2 elements

int x = matrix[1][0];  // => 4  (row 1, col 0)

// Pretty-print 2D array
Arrays.deepToString(matrix);  // => "[[1, 2, 3], [4, 5]]"

// Nested loop to traverse all elements
for (int i = 0; i < matrix.length; ++i) {
  for (int j = 0; j < matrix[i].length; ++j) {
    System.out.println(matrix[i][j]);
  }
}
// Outputs: 1 2 3 4 5

import java.util.Arrays;

char[] chars = {'b', 'a', 'c'};
Arrays.sort(chars);                   // sorts in-place

Arrays.toString(chars);               // => "[a, b, c]"

int k = 15;
if (k > 20) {
  System.out.println(1);
} else if (k > 10) {
  System.out.println(2);   // runs — 15 > 10
} else {
  System.out.println(3);
}

int month = 3;
String str;
switch (month) {
  case 1:
    str = "January";
    break;
  case 2:
    str = "February";
    break;
  case 3:
    str = "March";       // matches month==3
    break;
  default:
    str = "Some other month";
    break;
}
// Outputs: Result March
System.out.println("Result " + str);

int a = 10;
int b = 20;

// condition ? value_if_true : value_if_false
int max = (a > b) ? a : b;

System.out.println(max);   // => 20

// Standard for loop
for (int i = 0; i < 10; i++) {
  System.out.print(i);
}
// Outputs: 0123456789

// Two variables — i counts up, j counts down
for (int i = 0, j = 0; i < 3; i++, j--) {
  System.out.print(j + "|" + i + " ");
}
// Outputs: 0|0 -1|1 -2|2

int[] numbers = {1, 2, 3, 4, 5};

for (int number : numbers) {  // "for each number in numbers"
  System.out.print(number);
}
// Outputs: 12345

int count = 0;

while (count < 5) {
  System.out.print(count);
  count++;
}
// Outputs: 01234

int count = 0;

do {
  System.out.print(count);
  count++;
} while (count < 5);   // semicolon required!
// Outputs: 01234

for (int i = 0; i < 5; i++) {
  if (i == 3) {
    continue;   // skip printing when i is 3
  }
  System.out.print(i);
}
// Outputs: 01245  (3 is skipped)

for (int i = 0; i < 5; i++) {
  System.out.print(i);
  if (i == 3) {
    break;   // exit loop when i reaches 3
  }
}
// Outputs: 0123  (stops after printing 3)

import java.util.ArrayList;
import java.util.List;

List<Integer> nums = new ArrayList<>();

// Adding elements
nums.add(2);
nums.add(5);
nums.add(8);

// Retrieving by index — O(1)
System.out.println(nums.get(0));   // => 2

// Indexed for loop
for (int i = 0; i < nums.size(); i++) {
    System.out.println(nums.get(i));
}

// Remove last element (fast) — remove first is VERY slow
nums.remove(nums.size() - 1);

// Enhanced for loop
for (Integer value : nums) {
    System.out.println(value);
}

import java.util.HashMap;
import java.util.Map;

Map<Integer, String> m = new HashMap<>();
m.put(5, "Five");
m.put(8, "Eight");
m.put(6, "Six");
m.put(4, "Four");
m.put(2, "Two");

// Retrieve by key — O(1) average
System.out.println(m.get(6));  // => "Six"

// Lambda forEach — key and value together
m.forEach((key, value) -> {
    String msg = key + ": " + value;
    System.out.println(msg);
});

import java.util.HashSet;
import java.util.Set;

Set<String> set = new HashSet<>();
if (set.isEmpty()) {
    System.out.println("Empty!");
}

set.add("dog");
set.add("cat");
set.add("mouse");
set.add("snake");
set.add("bear");

if (set.contains("cat")) {
    System.out.println("Contains cat");
}

set.remove("cat");          // removes "cat" from the set

for (String element : set) {
    System.out.println(element);  // order not guaranteed
}

import java.util.ArrayDeque;
import java.util.Deque;

Deque<String> a = new ArrayDeque<>();

a.add("Dog");           // add to back (tail)
a.addFirst("Cat");      // add to front (head)
a.addLast("Horse");    // add to back (tail)

// Deque is now: [Cat, Dog, Horse]
System.out.println(a);   // => [Cat, Dog, Horse]

// peek() — view head without removing
System.out.println(a.peek());  // => "Cat"

// pop() — remove and return head
System.out.println(a.pop());   // => "Cat"
// Deque is now: [Dog, Horse]

import java.util.regex.Pattern;

String text = "I am learning Java";

// Remove all whitespace (\s+ matches one or more whitespace chars)
text.replaceAll("\\s+", "");
// => "IamlearningJava"

// Split on pipe | (must escape in regex, or use Pattern.quote)
text.split("\\|");
text.split(Pattern.quote("|"));  // safer — treats | as literal

// Single-line comment

/*
 Multi-line comment —
 can span many lines
*/

/**
 * Javadoc comment — used to generate API documentation.
 * This
 * is
 * documentation
 * comment
 */

try {
  // Code that might throw an exception
  String s = null;
  s.length(); // throws NullPointerException

} catch (Exception e) {
  e.printStackTrace();  // print stack trace to stderr

} finally {
  System.out.println("always printed");
  // Runs whether exception happened or not
  // Perfect for closing resources
}