What is the StudyGrid Java tutorial?

The StudyGrid Java tutorial is a full beginner-to-advanced track: syntax, types, input, loops, methods, classes, collections, generics, maps, and lambdas. Each chapter has copy-and-run examples.

Should I run java examples examples locally for better learning?

Yes. Use the browser editor on StudyGrid for a quick check, then Download the example and run it on your computer. Local runs show real errors and the real toolchain, which is one of the fastest ways to learn java examples in this Java Java lesson (Java Examples).

Is the Java editor the same as Try Python or Try C++?

No. Try Java compiles with javac at /java/try and shows stdout plus compiler messages. Try Python stays at /try. Try C++ stays at /cpp/try. Java lessons never open those editors.

Do I need to install a JDK to learn Java?

No. Open a chapter, click Try it in Java, and compile in the browser. You can also download a .java file and compile locally with javac.

Where should I start the Java tutorial?

Start at Java Intro, then Get Started and Syntax. After the first program, continue to output, variables, and if-else. After classes, open Java Examples, then generics, map, and lambdas. Use Next at the bottom of each chapter.

Is the Java tutorial free?

Yes. The Java workshop on StudyGrid (studygrid.in) is free: dashboard, chapters, and the compile-and-run editor.

Java Tutorial

Java Examples

147 complete Java programs, including STEM labs from maths, physics, and chemistry. Compile them at /java/try with javac.

← Garbage Collection Ternary Operator →

147 copy-and-run snippets. Open one in Try Java at /java/try, change a value, and run it again. Each language has its own shelf and its own editor.

Basics

Hello, Java

public class Main {
  public static void main(String[] args) {
    System.out.println("Hello, Java");
  }
}

Print a name

public class Main {
  public static void main(String[] args) {
    System.out.println("Ada in " + 2026);
  }
}

Variables

public class Main {
  public static void main(String[] args) {
    int a = 8;
    int b = 11;
    System.out.println(a + b);
  }
}

Final

public class Main {
  public static void main(String[] args) {
    final int seats = 12;
    System.out.println(seats);
  }
}

var type

public class Main {
  public static void main(String[] args) {
    var n = 7;
    System.out.println(n);
  }
}

Arithmetic

public class Main {
  public static void main(String[] args) {
    System.out.println((7 + 3) + " " + (7 * 3));
  }
}

Division remainder

public class Main {
  public static void main(String[] args) {
    System.out.println((17 / 5) + " " + (17 % 5));
  }
}

Float average

public class Main {
  public static void main(String[] args) {
    int sum = 8 + 11 + 5;
    System.out.println(sum / 3.0);
  }
}

Boolean

public class Main {
  public static void main(String[] args) {
    boolean ready = true;
    System.out.println(ready);
  }
}

Cast

public class Main {
  public static void main(String[] args) {
    System.out.println((int) 9.8);
  }
}

Enum

enum Day { MON, TUE, WED }

public class Main {
  public static void main(String[] args) {
    Day d = Day.TUE;
    System.out.println(d.ordinal());
  }
}

Object reference

public class Main {
  public static void main(String[] args) {
    String a = "Ada";
    String b = a;
    System.out.println(b);
  }
}

Null check

public class Main {
  public static void main(String[] args) {
    String p = null;
    System.out.println(p == null ? "null" : "set");
  }
}

Hex output

public class Main {
  public static void main(String[] args) {
    System.out.println(Integer.toHexString(255));
  }
}

String concat

public class Main {
  public static void main(String[] args) {
    String a = "Try ";
    String b = "Java";
    System.out.println(a + b);
  }
}

String length

public class Main {
  public static void main(String[] args) {
    String word = "compiler";
    System.out.println(word.length());
  }
}

String index

public class Main {
  public static void main(String[] args) {
    String word = "python";
    System.out.println("" + word.charAt(0) + word.charAt(word.length() - 1));
  }
}

Substring

public class Main {
  public static void main(String[] args) {
    String word = "StudyGrid";
    System.out.println(word.substring(0, 5));
  }
}

Find in string

public class Main {
  public static void main(String[] args) {
    String word = "banana";
    System.out.println(word.indexOf("na"));
  }
}

Reverse string

public class Main {
  public static void main(String[] args) {
    String word = "compiler";
    System.out.println(new StringBuilder(word).reverse());
  }
}

Optional-style null

public class Main {
  public static void main(String[] args) {
    String name = null;
    String shown = java.util.Optional.ofNullable(name).orElse("guest");
    System.out.println(shown);
  }
}

String split join

public class Main {
  public static void main(String[] args) {
    String[] parts = "a,b,c".split(",");
    System.out.println(String.join("-", parts));
  }
}

StringBuilder append

public class Main {
  public static void main(String[] args) {
    StringBuilder sb = new StringBuilder();
    sb.append("Study").append("Grid");
    System.out.println(sb);
  }
}

Count vowels

public class Main {
  public static void main(String[] args) {
    String word = "education";
    int count = 0;
    for (char c : word.toCharArray())
      if ("aeiou".indexOf(c) >= 0) count++;
    System.out.println(count);
  }
}

Control

If else

public class Main {
  public static void main(String[] args) {
    int n = 7;
    if (n % 2 == 0) System.out.println("even");
    else System.out.println("odd");
  }
}

Else if chain

public class Main {
  public static void main(String[] args) {
    int score = 82;
    if (score >= 90) System.out.println("A");
    else if (score >= 80) System.out.println("B");
    else System.out.println("C");
  }
}

Ternary

public class Main {
  public static void main(String[] args) {
    int n = 4;
    System.out.println(n % 2 == 0 ? "even" : "odd");
  }
}

Switch

public class Main {
  public static void main(String[] args) {
    int day = 3;
    switch (day) {
      case 1 -> System.out.println("Mon");
      default -> System.out.println("later");
    }
  }
}

For loop

public class Main {
  public static void main(String[] args) {
    for (int n = 1; n <= 5; n++) System.out.println(n);
  }
}

For-each

public class Main {
  public static void main(String[] args) {
    int[] nums = {4, 17, 9};
    for (int n : nums) System.out.print(n + " ");
    System.out.println();
  }
}

While

public class Main {
  public static void main(String[] args) {
    int n = 3;
    while (n > 0) {
      System.out.println(n);
      n--;
    }
  }
}

Break continue

public class Main {
  public static void main(String[] args) {
    for (int n = 0; n < 6; n++) {
      if (n % 2 == 0) continue;
      System.out.println(n);
    }
  }
}

FizzBuzz

public class Main {
  public static void main(String[] args) {
    for (int n = 1; n <= 15; n++) {
      if (n % 15 == 0) System.out.println("FizzBuzz");
      else if (n % 3 == 0) System.out.println("Fizz");
      else if (n % 5 == 0) System.out.println("Buzz");
      else System.out.println(n);
    }
  }
}

Nested loops

public class Main {
  public static void main(String[] args) {
    for (int r = 1; r <= 3; r++) {
      for (int c = 1; c <= 3; c++) System.out.print(r * c + " ");
      System.out.println();
    }
  }
}

Max of three

public class Main {
  public static void main(String[] args) {
    int a = 8, b = 11, c = 5;
    System.out.println(Math.max(a, Math.max(b, c)));
  }
}

Leap year

public class Main {
  public static void main(String[] args) {
    int year = 2024;
    boolean leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    System.out.println(leap ? "leap" : "common");
  }
}

Switch on string

public class Main {
  public static void main(String[] args) {
    String cmd = "save";
    switch (cmd) {
      case "save" -> System.out.println("ok");
      case "quit" -> System.out.println("bye");
      default -> System.out.println("?");
    }
  }
}

Do-while countdown

public class Main {
  public static void main(String[] args) {
    int n = 3;
    do {
      System.out.println(n);
      n--;
    } while (n > 0);
  }
}

Binary search loop

public class Main {
  public static void main(String[] args) {
    int[] nums = {1, 3, 5, 7, 9};
    int target = 7, lo = 0, hi = nums.length - 1, found = -1;
    while (lo <= hi) {
      int mid = (lo + hi) / 2;
      if (nums[mid] == target) { found = mid; break; }
      if (nums[mid] < target) lo = mid + 1;
      else hi = mid - 1;
    }
    System.out.println(found);
  }
}

Bubble sort short

public class Main {
  public static void main(String[] args) {
    int[] a = {4, 1, 3, 2};
    for (int i = 0; i < a.length - 1; i++)
      for (int j = 0; j < a.length - 1 - i; j++)
        if (a[j] > a[j + 1]) { int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t; }
    System.out.println(java.util.Arrays.toString(a));
  }
}

Palindrome check

public class Main {
  public static void main(String[] args) {
    String word = "level";
    String rev = new StringBuilder(word).reverse().toString();
    System.out.println(word.equals(rev) ? "yes" : "no");
  }
}

Day of week switch

public class Main {
  public static void main(String[] args) {
    int day = 5;
    switch (day) {
      case 1 -> System.out.println("Mon");
      case 2 -> System.out.println("Tue");
      case 3 -> System.out.println("Wed");
      case 4 -> System.out.println("Thu");
      case 5 -> System.out.println("Fri");
      case 6 -> System.out.println("Sat");
      case 7 -> System.out.println("Sun");
      default -> System.out.println("?");
    }
  }
}

Menu switch

public class Main {
  public static void main(String[] args) {
    int choice = 2;
    switch (choice) {
      case 1 -> System.out.println("New");
      case 2 -> System.out.println("Open");
      case 3 -> System.out.println("Quit");
      default -> System.out.println("Invalid");
    }
  }
}

Nested if login

public class Main {
  public static void main(String[] args) {
    String user = "ada", pass = "secret";
    if (user.equals("ada")) {
      if (pass.equals("secret")) System.out.println("welcome");
      else System.out.println("bad password");
    } else System.out.println("unknown user");
  }
}

While sum until 0

public class Main {
  public static void main(String[] args) {
    int[] vals = {4, 7, 2, 0, 9};
    int i = 0, sum = 0;
    while (i < vals.length && vals[i] != 0) { sum += vals[i]; i++; }
    System.out.println(sum);
  }
}

For reverse print

public class Main {
  public static void main(String[] args) {
    int[] nums = {1, 2, 3, 4};
    for (int i = nums.length - 1; i >= 0; i--) System.out.print(nums[i] + " ");
    System.out.println();
  }
}

Continue odds sum

public class Main {
  public static void main(String[] args) {
    int sum = 0;
    for (int n = 1; n <= 10; n++) {
      if (n % 2 == 0) continue;
      sum += n;
    }
    System.out.println(sum);
  }
}

Break on sentinel

public class Main {
  public static void main(String[] args) {
    int[] vals = {3, 8, -1, 5};
    int sum = 0;
    for (int n : vals) {
      if (n < 0) break;
      sum += n;
    }
    System.out.println(sum);
  }
}

Enum switch

enum Mode { ON, OFF, AUTO }

public class Main {
  public static void main(String[] args) {
    Mode m = Mode.AUTO;
    switch (m) {
      case ON -> System.out.println("lit");
      case OFF -> System.out.println("dark");
      case AUTO -> System.out.println("sensor");
    }
  }
}

Containers

Array sum

public class Main {
  public static void main(String[] args) {
    int[] nums = {8, 11, 5};
    int sum = 0;
    for (int n : nums) sum += n;
    System.out.println(sum);
  }
}

Array max

public class Main {
  public static void main(String[] args) {
    int[] nums = {4, 17, 9, 2, 13};
    int best = nums[0];
    for (int n : nums) if (n > best) best = n;
    System.out.println(best);
  }
}

2D array

public class Main {
  public static void main(String[] args) {
    int[][] grid = {{1, 2, 3}, {4, 5, 6}};
    System.out.println(grid[1][0]);
  }
}

ArrayList add

public class Main {
  public static void main(String[] args) {
    java.util.ArrayList<Integer> nums = new java.util.ArrayList<>();
    nums.add(4);
    nums.add(17);
    System.out.println(nums.size() + " " + nums.get(1));
  }
}

ArrayList for-each

public class Main {
  public static void main(String[] args) {
    java.util.List<Integer> nums = java.util.List.of(1, 2, 3);
    for (int n : nums) System.out.print(n + " ");
    System.out.println();
  }
}

Sort a list

public class Main {
  public static void main(String[] args) {
    java.util.List<Integer> nums = new java.util.ArrayList<>(java.util.List.of(9, 2, 7, 1, 4));
    java.util.Collections.sort(nums);
    System.out.println(nums);
  }
}

Find in list

public class Main {
  public static void main(String[] args) {
    java.util.List<Integer> nums = java.util.List.of(4, 17, 9);
    System.out.println(nums.contains(9) ? 9 : -1);
  }
}

Count in list

public class Main {
  public static void main(String[] args) {
    java.util.List<Integer> nums = java.util.List.of(3, 1, 3, 2, 3);
    System.out.println(java.util.Collections.frequency(nums, 3));
  }
}

Map lookup

public class Main {
  public static void main(String[] args) {
    java.util.Map<String, Integer> scores = new java.util.HashMap<>();
    scores.put("Mia", 95);
    scores.put("Kai", 88);
    System.out.println(scores.get("Mia"));
  }
}

Map iterate

public class Main {
  public static void main(String[] args) {
    java.util.Map<String, Integer> scores = java.util.Map.of("Ada", 99, "Kai", 88);
    scores.forEach((k, v) -> System.out.println(k + " " + v));
  }
}

Set unique

public class Main {
  public static void main(String[] args) {
    java.util.Set<Integer> nums = new java.util.LinkedHashSet<>(java.util.List.of(3, 1, 3, 2));
    System.out.println(nums);
  }
}

Set contains

public class Main {
  public static void main(String[] args) {
    java.util.Set<String> tags = java.util.Set.of("html", "css");
    System.out.println(tags.contains("html"));
  }
}

Record pair

record Pair(String name, int year) {}

public class Main {
  public static void main(String[] args) {
    Pair p = new Pair("Ada", 2026);
    System.out.println(p.name() + " " + p.year());
  }
}

Stack

public class Main {
  public static void main(String[] args) {
    java.util.Deque<Integer> s = new java.util.ArrayDeque<>();
    s.push(1);
    s.push(2);
    System.out.println(s.pop());
    System.out.println(s.peek());
  }
}

Queue

public class Main {
  public static void main(String[] args) {
    java.util.Queue<Integer> q = new java.util.ArrayDeque<>();
    q.add(1);
    q.add(2);
    System.out.println(q.remove());
    System.out.println(q.peek());
  }
}

Deque

public class Main {
  public static void main(String[] args) {
    java.util.Deque<Integer> d = new java.util.ArrayDeque<>(java.util.List.of(1, 2));
    d.addFirst(0);
    d.addLast(3);
    System.out.println(d.getFirst() + " " + d.getLast());
  }
}

Reverse list

public class Main {
  public static void main(String[] args) {
    java.util.List<Integer> nums = new java.util.ArrayList<>(java.util.List.of(1, 2, 3));
    java.util.Collections.reverse(nums);
    System.out.println(nums);
  }
}

Stream sum

public class Main {
  public static void main(String[] args) {
    int sum = java.util.List.of(8, 11, 5).stream().mapToInt(n -> n).sum();
    System.out.println(sum);
  }
}

Min max

public class Main {
  public static void main(String[] args) {
    java.util.List<Integer> nums = java.util.List.of(4, 17, 9);
    System.out.println(java.util.Collections.min(nums) + " " + java.util.Collections.max(nums));
  }
}

Stream filter

public class Main {
  public static void main(String[] args) {
    java.util.List.of(1, 2, 3, 4).stream().filter(n -> n % 2 == 0).forEach(n -> System.out.print(n + " "));
    System.out.println();
  }
}

2D array sum

public class Main {
  public static void main(String[] args) {
    int[][] grid = {{1, 2, 3}, {4, 5, 6}};
    int sum = 0;
    for (int[] row : grid) for (int n : row) sum += n;
    System.out.println(sum);
  }
}

ArrayList remove

public class Main {
  public static void main(String[] args) {
    java.util.ArrayList<String> tags = new java.util.ArrayList<>(java.util.List.of("a", "b", "c"));
    tags.remove("b");
    System.out.println(tags);
  }
}

TreeMap order

public class Main {
  public static void main(String[] args) {
    java.util.Map<String, Integer> scores = new java.util.TreeMap<>();
    scores.put("Kai", 88);
    scores.put("Ada", 99);
    System.out.println(scores);
  }
}

LinkedHashSet order

public class Main {
  public static void main(String[] args) {
    java.util.Set<String> seen = new java.util.LinkedHashSet<>();
    seen.add("first");
    seen.add("second");
    seen.add("first");
    System.out.println(seen);
  }
}

Stream collect list

public class Main {
  public static void main(String[] args) {
    java.util.List<Integer> evens = java.util.List.of(1, 2, 3, 4).stream()
        .filter(n -> n % 2 == 0)
        .collect(java.util.stream.Collectors.toList());
    System.out.println(evens);
  }
}

Arrays.sort

public class Main {
  public static void main(String[] args) {
    int[] nums = {9, 2, 7, 1};
    java.util.Arrays.sort(nums);
    System.out.println(java.util.Arrays.toString(nums));
  }
}

HashMap word count

public class Main {
  public static void main(String[] args) {
    String[] words = {"to", "be", "or", "not", "to", "be"};
    java.util.Map<String, Integer> tally = new java.util.HashMap<>();
    for (String w : words) tally.merge(w, 1, Integer::sum);
    System.out.println(tally);
  }
}

Set intersection size

public class Main {
  public static void main(String[] args) {
    java.util.Set<Integer> a = new java.util.HashSet<>(java.util.List.of(1, 2, 3));
    java.util.Set<Integer> b = new java.util.HashSet<>(java.util.List.of(2, 3, 4));
    a.retainAll(b);
    System.out.println(a.size());
  }
}

Stream reduce

public class Main {
  public static void main(String[] args) {
    int product = java.util.List.of(2, 3, 4).stream().reduce(1, (a, b) -> a * b);
    System.out.println(product);
  }
}

Comparator sort strings

public class Main {
  public static void main(String[] args) {
    java.util.List<String> names = new java.util.ArrayList<>(java.util.List.of("Kai", "Ada", "Mia"));
    names.sort(java.util.Comparator.naturalOrder());
    System.out.println(names);
  }
}

Functions and OOP

Add method

public class Main {
  static int add(int a, int b) {
    return a + b;
  }
  public static void main(String[] args) {
    System.out.println(add(8, 11));
  }
}

Overload add

public class Main {
  static int add(int a, int b) { return a + b; }
  static double add(double a, double b) { return a + b; }
  public static void main(String[] args) {
    System.out.println(add(2, 3));
    System.out.println(add(2.5, 3.5));
  }
}

Default-style arg

public class Main {
  static void greet() { greet("friend"); }
  static void greet(String name) { System.out.println("Hi, " + name); }
  public static void main(String[] args) {
    greet();
    greet("Kai");
  }
}

Factorial

public class Main {
  static int factorial(int n) {
    int result = 1;
    for (int i = 2; i <= n; i++) result *= i;
    return result;
  }
  public static void main(String[] args) {
    System.out.println(factorial(5));
  }
}

Recursive fibonacci

public class Main {
  static int fib(int n) {
    if (n < 2) return n;
    return fib(n - 1) + fib(n - 2);
  }
  public static void main(String[] args) {
    for (int n = 0; n < 10; n++) System.out.print(fib(n) + " ");
    System.out.println();
  }
}

Lambda

public class Main {
  public static void main(String[] args) {
    java.util.List.of(1, 2, 3, 4).forEach(n -> System.out.print((n * n) + " "));
    System.out.println();
  }
}

Generic max

public class Main {
  static <T extends Comparable<T>> T bigger(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
  }
  public static void main(String[] args) {
    System.out.println(bigger(3, 9));
    System.out.println(bigger(2.5, 1.2));
  }
}

Class running total

class Total {
  int sum;
  void add(int n) { sum += n; }
  int get() { return sum; }
}

public class Main {
  public static void main(String[] args) {
    Total t = new Total();
    t.add(4);
    t.add(7);
    System.out.println(t.get());
  }
}

Constructor

class User {
  String name;
  User(String n) { name = n; }
  void hello() { System.out.println("Hi, " + name); }
}

public class Main {
  public static void main(String[] args) {
    User u = new User("Ada");
    u.hello();
  }
}

Inheritance

class Animal {
  void speak() { System.out.println("..."); }
}
class Dog extends Animal {
  @Override void speak() { System.out.println("woof"); }
}

public class Main {
  public static void main(String[] args) {
    new Dog().speak();
  }
}

Polymorphism

abstract class Shape {
  abstract int area();
}
class Square extends Shape {
  @Override int area() { return 9; }
}

public class Main {
  public static void main(String[] args) {
    Shape p = new Square();
    System.out.println(p.area());
  }
}

Interface

interface Drawable {
  void draw();
}
class Dot implements Drawable {
  public void draw() { System.out.println("."); }
}

public class Main {
  public static void main(String[] args) {
    new Dot().draw();
  }
}

Record

record Point(int x, int y) {}

public class Main {
  public static void main(String[] args) {
    Point a = new Point(1, 2);
    System.out.println(a.x() + " " + a.y());
  }
}

Static member

class Counter {
  static int count;
  Counter() { count++; }
}

public class Main {
  public static void main(String[] args) {
    new Counter();
    new Counter();
    System.out.println(Counter.count);
  }
}

Package import

public class Main {
  public static void main(String[] args) {
    System.out.println(java.util.List.of(1, 2, 3).size());
  }
}

Exception

public class Main {
  static int positive(int n) {
    if (n < 0) throw new IllegalArgumentException("need a positive number");
    return n;
  }
  public static void main(String[] args) {
    try {
      System.out.println(positive(-1));
    } catch (Exception err) {
      System.out.println(err.getMessage());
    }
  }
}

Constructor overload

class Point {
  int x, y;
  Point() { this(0, 0); }
  Point(int x, int y) { this.x = x; this.y = y; }
}

public class Main {
  public static void main(String[] args) {
    Point a = new Point();
    Point b = new Point(3, 4);
    System.out.println(a.x + "," + a.y + " " + b.x + "," + b.y);
  }
}

Record with method

record Rect(int w, int h) {
  int area() { return w * h; }
}

public class Main {
  public static void main(String[] args) {
    System.out.println(new Rect(3, 4).area());
  }
}

Generic Box

class Box<T> {
  private T value;
  void set(T v) { value = v; }
  T get() { return value; }
}

public class Main {
  public static void main(String[] args) {
    Box<String> b = new Box<>();
    b.set("Ada");
    System.out.println(b.get());
  }
}

Method reference print

public class Main {
  public static void main(String[] args) {
    java.util.List.of("Ada", "Kai", "Mia").forEach(System.out::println);
  }
}

Polymorphism list

abstract class Shape {
  abstract int area();
}
class Square extends Shape {
  int side;
  Square(int s) { side = s; }
  @Override int area() { return side * side; }
}
class Rect extends Shape {
  int w, h;
  Rect(int w, int h) { this.w = w; this.h = h; }
  @Override int area() { return w * h; }
}

public class Main {
  public static void main(String[] args) {
    java.util.List<Shape> shapes = java.util.List.of(new Square(3), new Rect(2, 5));
    int total = 0;
    for (Shape s : shapes) total += s.area();
    System.out.println(total);
  }
}

Try finally print

public class Main {
  public static void main(String[] args) {
    try {
      System.out.println(10 / 2);
    } finally {
      System.out.println("done");
    }
  }
}

Library

Sqrt

public class Main {
  public static void main(String[] args) {
    System.out.println(Math.sqrt(64.0));
  }
}

Pow

public class Main {
  public static void main(String[] args) {
    System.out.println(Math.pow(2.0, 10.0));
  }
}

Abs

public class Main {
  public static void main(String[] args) {
    System.out.println(Math.abs(-12));
  }
}

Duration

public class Main {
  public static void main(String[] args) {
    java.time.Duration d = java.time.Duration.ofMillis(5);
    System.out.println(d.toMillis());
  }
}

LocalDate

public class Main {
  public static void main(String[] args) {
    System.out.println(java.time.LocalDate.of(2026, 8, 21));
  }
}

Parse int

public class Main {
  public static void main(String[] args) {
    System.out.println(Integer.parseInt("42") + " seats");
  }
}

Parse double

public class Main {
  public static void main(String[] args) {
    System.out.println(Double.parseDouble("3.5") + 1);
  }
}

Ternary pass

public class Main {
  public static void main(String[] args) {
    int score = 71;
    System.out.println(score >= 70 ? "pass" : "retry");
  }
}

String equals

public class Main {
  public static void main(String[] args) {
    System.out.println("ada".equals("ada"));
  }
}

List get

public class Main {
  public static void main(String[] args) {
    java.util.List<Integer> nums = java.util.List.of(1, 2, 3);
    System.out.println(nums.get(1));
  }
}

Map default

public class Main {
  public static void main(String[] args) {
    java.util.Map<String, Integer> tally = new java.util.HashMap<>();
    tally.merge("rye", 1, Integer::sum);
    tally.merge("rye", 1, Integer::sum);
    System.out.println(tally.get("rye"));
  }
}

Set add

public class Main {
  public static void main(String[] args) {
    java.util.Set<Integer> nums = new java.util.HashSet<>();
    nums.add(3);
    nums.add(1);
    nums.add(3);
    System.out.println(nums.size());
  }
}

Stream map

public class Main {
  public static void main(String[] args) {
    java.util.List.of(1, 2, 3).stream().map(n -> n * n).forEach(n -> System.out.print(n + " "));
    System.out.println();
  }
}

All match

public class Main {
  public static void main(String[] args) {
    boolean ok = java.util.List.of(2, 4, 6).stream().allMatch(n -> n % 2 == 0);
    System.out.println(ok);
  }
}

Any match

public class Main {
  public static void main(String[] args) {
    boolean hit = java.util.List.of(1, 2, 3).stream().anyMatch(n -> n > 2);
    System.out.println(hit);
  }
}

Swap values

public class Main {
  public static void main(String[] args) {
    int a = 3, b = 9;
    int t = a; a = b; b = t;
    System.out.println(a + " " + b);
  }
}

Clamp

public class Main {
  public static void main(String[] args) {
    System.out.println(Math.min(10, Math.max(0, 12)));
  }
}

Hypot

public class Main {
  public static void main(String[] args) {
    System.out.println(Math.hypot(3.0, 4.0));
  }
}

Floor ceil

public class Main {
  public static void main(String[] args) {
    System.out.println((int) Math.floor(4.7) + " " + (int) Math.ceil(4.1));
  }
}

Printf

public class Main {
  public static void main(String[] args) {
    System.out.printf("%.2f%n", 3.14159);
  }
}

Comment reminder

public class Main {
  public static void main(String[] args) {
    // change a value, compile again
    System.out.println(1 + 1);
  }
}

Do while

public class Main {
  public static void main(String[] args) {
    int n = 0;
    do {
      n++;
    } while (n < 3);
    System.out.println(n);
  }
}

Data class

class Point {
  int x, y;
}

public class Main {
  public static void main(String[] args) {
    Point p = new Point();
    p.x = 3;
    p.y = 4;
    System.out.println(p.x + " " + p.y);
  }
}

This field

class Box {
  int n;
  Box(int n) { this.n = n; }
  int get() { return this.n; }
}

public class Main {
  public static void main(String[] args) {
    System.out.println(new Box(7).get());
  }
}

Private getter

class Score {
  private int n;
  void set(int v) { if (v >= 0) n = v; }
  int get() { return n; }
}

public class Main {
  public static void main(String[] args) {
    Score s = new Score();
    s.set(9);
    System.out.println(s.get());
  }
}

Abstract class

abstract class Animal {
  abstract String kind();
}
class Cat extends Animal {
  String kind() { return "cat"; }
}

public class Main {
  public static void main(String[] args) {
    System.out.println(new Cat().kind());
  }
}

GC drop reference

public class Main {
  public static void main(String[] args) {
    String a = "keep";
    String b = a;
    a = null;
    System.out.println(b);
  }
}

Access public

class Player {
  public String name = "Rin";
}

public class Main {
  public static void main(String[] args) {
    System.out.println(new Player().name);
  }
}

LocalTime

public class Main {
  public static void main(String[] args) {
    java.time.LocalTime t = java.time.LocalTime.of(14, 30);
    System.out.println(t);
  }
}

LocalDate plusDays

public class Main {
  public static void main(String[] args) {
    java.time.LocalDate d = java.time.LocalDate.of(2026, 8, 21);
    System.out.println(d.plusDays(7));
  }
}

Count lines in text

public class Main {
  public static void main(String[] args) {
    String text = "alpha\nbeta\ngamma";
    long lines = text.lines().count();
    System.out.println(lines);
  }
}

Math.random roll

public class Main {
  public static void main(String[] args) {
    int roll = (int) (Math.random() * 6) + 1;
    System.out.println(roll);
  }
}

STEM

Resistor power

public class Main {
  public static void main(String[] args) {
    double I = 0.050;
    double R = 100.0;
    System.out.println(I * I * R + " W");
  }
}

Hypotenuse force

public class Main {
  public static void main(String[] args) {
    System.out.println(Math.hypot(5.0, 12.0) + " N");
  }
}

Gravitational PE

public class Main {
  static double pe(double m, double h) {
    return m * 9.81 * h;
  }
  public static void main(String[] args) {
    System.out.println(pe(0.50, 2.0) + " J");
  }
}

Density

public class Main {
  public static void main(String[] args) {
    double m = 54.0;
    double V = 20.0;
    System.out.println(m / V + " g/cm^3");
  }
}

gcd Euclid

public class Main {
  public static void main(String[] args) {
    int a = 48, b = 18;
    while (b != 0) { int r = a % b; a = b; b = r; }
    System.out.println(a);
  }
}

RNA codon

public class Main {
  public static void main(String[] args) {
    String codon = "AUG";
    System.out.println(codon + " " + codon.length());
  }
}

Element Z map

public class Main {
  public static void main(String[] args) {
    java.util.Map<String, Integer> z = new java.util.HashMap<>();
    z.put("Fe", 26);
    System.out.println(z.get("Fe"));
  }
}

Titre mean

public class Main {
  public static void main(String[] args) {
    java.util.List<Double> ml = java.util.List.of(24.6, 24.7, 24.6);
    double s = 0;
    for (double v : ml) s += v;
    System.out.println(s / ml.size());
  }
}

n = cV

class Solution {
  double conc, vol;
  double moles() { return conc * vol; }
}

public class Main {
  public static void main(String[] args) {
    Solution sol = new Solution();
    sol.conc = 0.100;
    sol.vol = 0.25;
    System.out.println(sol.moles());
  }
}

Photon energy

public class Main {
  public static void main(String[] args) {
    final double h = 6.626e-34;
    System.out.println(h * 5.00e14 + " J");
  }
}

Prime check

public class Main {
  public static void main(String[] args) {
    int n = 17;
    boolean prime = n > 1;
    for (int d = 2; d * d <= n; d++) if (n % d == 0) { prime = false; break; }
    System.out.println(prime);
  }
}

Celsius to Fahrenheit

public class Main {
  public static void main(String[] args) {
    double c = 25.0;
    System.out.println(c * 9 / 5 + 32);
  }
}

BMI

public class Main {
  public static void main(String[] args) {
    double kg = 70.0, m = 1.75;
    System.out.println(kg / (m * m));
  }
}

Compound interest

public class Main {
  public static void main(String[] args) {
    double P = 1000, r = 0.05;
    int n = 3;
    System.out.println(P * Math.pow(1 + r, n));
  }
}