Core Language Features

indexOf finds the first position of a character or substring and returns that index, or -1 if not found. lastIndexOf does the same but finds the last (rightmost) occurrence.

substring(begin, end) returns the part of the string from begin up to but not including end. The original string is unchanged because strings are immutable; you get a new string back.

Java Strings are immutable, so each + creates a brand-new String object. In a loop that copies the text over and over, which is slow and wasteful. StringBuilder edits one mutable buffer in place, so it is much faster.

The + operator joins two strings into a new string. Because String objects can't be changed, every + makes a brand-new String holding the combined text; the originals stay untouched.

== checks whether two String variables point to the same object in memory. equals() checks whether the two strings contain the same characters. To compare text, always use equals().

Java checks every array access at runtime. If the index is below 0 or at/above the array's length, it throws an ArrayIndexOutOfBoundsException instead of reading wrong memory.

An array's length is set when you create it and can never change. To grow, you either create a bigger array and copy the elements over, or use a class like ArrayList that does that copying for you.

You can write the brackets after the type, like int[] a, or after the variable name, like int a[]. Both declare an array of ints and behave identically. The first style is preferred in Java.

You read the public length field, like a.length (no parentheses). It tells you how many elements the array has. It is fixed for the array's lifetime and you cannot change it.

Use new with the element type and a length, like new int[5]. This allocates an array of 5 ints on the heap. The length is fixed for the array's lifetime, and you fill the slots by index afterwards.

Every Java file automatically imports the java.lang package, where String, Integer, Object, System, and similar core types live. So you can use them by simple name without writing any import.

A single-type import names one class, like import java.util.List;. A wildcard import, like import java.util.*;, lets you use any class from that package. Single imports are clearer and usually preferred.

A package declaration is the first line of code in a Java file, like package com.example.app;. It groups related classes under a name. The folders on disk must match the package name: com.example.app lives in com/example/app/.

String, System, Integer and similar core types live in the package java.lang, which Java imports automatically into every file. So you don't write import java.lang.String; — it's always already available.

You name packages by reversing your organization's internet domain. If your domain is example.com, your packages start with com.example. This makes names globally unique, since domains are unique, so your classes won't clash with anyone else's.

A static block is code inside static { ... } that runs once when the class is first loaded. You use it to set up static fields when the setup needs more than one line, like a loop, a try/catch, or several steps.

static means the member belongs to the class itself, not to any one object. There is one shared copy for all instances, and you call it on the class (e.g. Math.max) without creating an object.

They run top to bottom, in the exact order they appear in the source code. Static field initializers and static blocks are treated as one combined sequence, and each runs once when the class is initialized.

A static method runs without any particular object, so there is no this to point at instance data. Instance variables belong to objects, so the static method has no object to read them from. To use them, pass or create an object and access them through it.

Static blocks run first and only once (when the class is first loaded). Then for each new object: the parent's instance setup and constructor run, then the child's. Static = once per class; instance initializers/constructors = once per object.

A final field must be given a value exactly once and can never be changed afterward. You can set it where you declare it, in an instance initializer block, or in every constructor. If you try to leave it unset or assign it twice, the code will not compile.

Static initializers (static fields and static blocks) run once, when the class is first loaded. Instance initializers (instance fields and instance blocks) run every time you create an object with new, just before the constructor body.

A blank final is a final field declared without a value, like private final int id;. Because it has no initializer, every constructor must assign it exactly once before the constructor ends. If any constructor leaves it unset, the code won't compile.

On new: fields first get default values (0/null/false), then the parent constructor runs fully, then this class's instance field initializers and instance blocks run top-to-bottom, and finally the constructor body runs. Parent is always fully built before the child.

Field initializers and instance initializer blocks run in the order they appear in the source, after the superclass constructor and before the rest of the constructor body. A final field can be set in one of these places or in the constructor, but only once total.