DEV Community: Marta Kravchuk

Arrays in Java: A Deep Dive

Marta Kravchuk — Mon, 09 Jun 2025 19:24:09 +0000

Arrays are a fundamental data structure in Java, used to store collections of elements of the same type. This article provides a comprehensive guide to working with arrays, covering everything from basic declaration and initialization to multidimensional arrays, searching, sorting, comparing and copying. In addition, the material provides essential insights whether you’re preparing for an interview or looking to brush up on your knowledge.

Array Declarations
Creating an Array
Working with Arrays
- Sorting Arrays
- Searching Arrays
- Comparing Arrays
Shallow Copy vs. Deep Copy

In Java, an array is a container object that holds a fixed number of elements of the same data type. These elements can be either primitive types (like int, char, boolean, etc.) or objects (like String or custom classes) and arrays implementing interfaces (like CharSequence, etc.). Array functionality is part of the java.util.Arrays package.

Key characteristics of Java arrays include:

The length of an array is established upon creation and cannot be changed.
All elements in an array must be of the same type.
Arrays can store duplicate values.
Arrays can be one-dimensional, two-dimensional, or multi-dimensional by representing a matrix of data. Note that "true support" of multi-dimensional arrays is not supported, but Java offers an array of arrays to support a multi-dimensional structure.
An array declared with a superclass or interface type can store subclass objects, supporting polymorphism. For example, an array of CharSequence can store references to String and StringBuilder objects.
Array elements are accessed using an index, starting at 0. Therefore, the last element in an array is at index length - 1.

1. Array Declarations

Arrays in Java must adhere to specific declaration rules to be properly defined. The following rules outline the correct syntax for declaring arrays:

1️⃣. Data Type: Arrays can store elements of any valid Java data type, including primitive, class, and interface types.
2️⃣. Brackets: The square brackets [] indicate that a variable is an array.

One-Dimensional Arrays: One set of brackets is used. The brackets can be placed either after the data type or after the variable name.

int[] numbers;    // brackets next to the type
String fruits[];  // brackets next to the variable name

Multidimensional Arrays: Sets of brackets are used on both sides to create a multidimensional array, like a table.

int[][] matrix;               // 2D array
int matrix[][];               // 2D array
int[] matrix[];               // 2D array
int[] matrix [], space [][];  // 2D array and 3D array

No Size in Declaration: The size of the array is not specified during declaration. The size is determined later, during array creation.

int[] numbers;           // Declaration
numbers = new int[5];    // Initialization with size

To consolidate these rules, consider the following examples of valid and invalid array declarations.

Valid Array Declarations:

Multiple variables of the same type can be defined on one line, including both arrays and non-array variables. Here, a and c are int variables, while b is an array of integers (i.e., int[]):

int a, b[], c;

The following declaration implies that d and e are of type int[] whereas, the variable f is a two-dimensional array (i.e., int[][]):

int[] d, e, f[];

Invalid Array Declarations:

Size is not part of the declaration:

int[2] intArray;    // compilation error
int intArray[2];    // compilation error

You cannot define multiple variables of different types in the same line, separated by commas. Java is strongly typed and this is invalid:

int a, float b[];   // compilation error

2. Creating an Array

Once an array is declared, it must be created. Java provides several ways to create and initialize arrays, each with its own characteristics:

1️⃣. The new Operator and Size: The new operator can be used to define the size of the array within brackets without specifying the initial values:

int[] intArray = new int[10];           // creates an array of int with 10 elements initialised to 0
String[] atringArray = new String[10];  // creates an array of String with 10 elements, all initialised to null

❗ Once an array's size is defined during creation, it cannot be changed. This means an existing array object cannot be resized directly.

int[] numbers = new int[5];
numbers = new int[10];   // not resizing! This creates a new array

In this example, the size of the original array object is not changed. Instead, it creates a new int[] array with a size of 10 and assigns its reference to the numbers variable. The original array (with a size of 5) is now eligible for garbage collection, assuming it is no longer referenced elsewhere. If it had some data, it's lost.

When an array is declared and created, but no values have been assigned, each slot in the array has a default value:

Numeric primitives are set to 0.
Boolean primitives are set to false.
References, including primitive data type wrappers, are set to null.

String names[];

This array points to null. The code never instantiated the array, so it is just a reference variable to null.

String names[] = new String[6];

It is an array because it has brackets. It is an array of type String since that is the type mentioned in the declaration. It has six elements because the length is 6. Each of those six slots currently is null but can potentially point to a String object.

2️⃣. The new Operator and Values: The new operator can be used without specifying the size in brackets, provided the initial values are specified directly within curly braces {}:

int[] numbers = new int[] {42, 55, 99}; // int array of size 3

In this example, an int array of size 3 is created, and its elements are immediately initialized with the given values. The size of the array is implicitly determined by the number of values provided within the curly braces. Again, it is important to emphasize that the initial definition and size of an array cannot be changed once created.

3️⃣. Array Initializer: An array initializer, a shortcut that allows an array to be created and initialized in one statement. The initial values of the array elements are specified directly using curly braces {}. This approach is called an anonymous array:

int[] intArray = {4, 7, 9};
String[] stringArray = {"one", null, "two"};

4️⃣. And finally, let's consider how to create multidimensional arrays. The most important thing to remember about multidimensional arrays in Java is that they are essentially arrays of arrays. This allows you to represent data in a tabular format (rows and columns) or in higher-dimensional structures. While Java doesn't have true built-in multidimensional arrays, it provides the ability to create arrays where each element holds a reference to another array.

Declaration and Initialization with Size: The size of a multidimensional array can be specified during declaration and initialization:

String[][] matrix = new String[3][2];    // сreates a 2D array of 3 rows and 2 columns

This creates an array named matrix with three elements. Each of these three elements is a reference to an array of two String objects. It's helpful to think of the addressable range as [0][0] through [2][1]. To visualize this matrix, let's take a look at the code.
For example, suppose one of these values is set as:

matrix[0][1] = "set";

Schematically, this can be depicted as follows:

[0,0] [0,1]  //Here we set a value for matrix[0][1]
[1,0] [1,1]
[2,0] [2,1]

Asymmetric Arrays: Multidimensional arrays don't have to be rectangular. Asymmetric arrays can be created where each row has a different number of columns:

int[][] matrix = {{1, 4}, {3}, {9,8,7}};

Schematically, this can be depicted as follows:

[0,0] [0,1]         => {1,4}
[1,0]               => {3}
[2,0] [2,1] [2,2]   => {9,8,7}

Another way to create an asymmetric array is to initialize just an array’s first dimension and define the size of each array component in a separate statement:

int[][] matrix = new int[3][];
matrix[0] = new int[]{4, 9, 7};
matrix[1] = new int[2];

And here an example visual how does work:

[0,0] [0,1] [0,2]     => {4, 9, 7}
[1,0] [1,1]           => {0, 0}
[2,0]                 => null

You can easy create matrix in tabular format like example:

int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

To consolidate these rules, consider the following examples of valid and invalid array creation statements.

Valid Array Creation Statements:

The new operator is used to allocate memory for the array, specifying its data type and size:

int[] myIntArray = new int[30];        // Brackets associated with the type
short myShortArray[] = new short[20];  // Brackets associated with the variable name

An array can be declared first, and then initialized later using the new operator:

String[] myStringArray;
myStringArray = new String[12];

The initial values of the array elements are directly specified using {}:

String[] myArray = {"one", "two", null, "three"};    // An array of strings with 4 elements

An array with a length of zero can be created:

String[] myArray = {}; // This array has a length of 0

You can declare and initialize variables like array and non array, but you need to know that both can have same type, it's also you can chain create variables like that as:

int[] mySecondIntArray, myIntArray = mySecondIntArray = new int[50]; // Initializes both arrays

But if you want to create two array, and you give to only one parameter this as will work as:

int[] myIntArray, mySecondIntArray = new int[50]; // The second array is initialized to size 50, but the "first" array is not initialized.

A reference-type array can be explicitly set to null:

int[] mySecondIntArray = null;

As arrays are ultimately objects in Java, they can be assigned to variables of type Object:

Object o = new int[5];     // Valid initialization and assignment to an Object

The new operator can be combined with the array initializer, but the size cannot be specified in the brackets:

int a[] = new int[]{1, 2, 3, 4, 5};    // Size is determined by the initializer

This creates a two-dimensional array:

String[] stringArray[] = {{"one", "two"}, {"three", "four"}};

This is a valid two-dimensianal array declaration and initialization. Only the first dimension is required to have a size, because you can have an array of arrays, and the arrays referenced by the element indices can be of different sizes:

int[][] matrix = new int[2][];

Invalid Array Creation Statements:

The parentheses in this statement generate a compile error and size needs to be on the right side of the equation:

String[] stringArray = new String(){3};   // compilation error

Size needs to be on the right side of the equation:

String[3] stringArray = new String[];     // compilation error

An array initializer doesn't require a restatement of the array type:

int a[] = int[]{1, 2, 3, 4, 5};           // compilation error

This is invalid because you are stating the size, but the array initilizer already defines the size:

int b[] = new int[5] {1, 2, 3, 4, 5};     // compilation error

You cannot use the array initializer on a separate statement line from the declaration of the array:

String[] myArray; 
myArray = {"one", "two", null, "three”};  // compilation error

This statement is invalid, unlike using the new operator on the right hand side of this equation. You cannot use array initializer in a compound statement:

short[] mySecondShortArray, myShortArray = mySecondShortArray = {1, 2, 3, 4, 5};   // compilation error

The type of second argument is incorrect. Only the first dimension in two-dimensional array is required to have a size. And this initialization does not give it a size, so it is incorrect:

int[][] matrix = new int[][2];            // compilation error

You cannot initialize a two-dimensional array and assign it to a one-dimensional array:

int c[] = new int[5][3];                  // compilation error

3. Working with Arrays

Once you've declared and created an array, it's time to use it. This section covers common operations and functionalities associated with working with arrays in Java.

Arrays in Java are objects, which means they inherit certain characteristics from the Object class. So, arrays can call equals() method. Remember, this would work even on an int[], too. Since int is a primitive, therefore int[] is an object.

String[] bugs = {"cricket", "beetle", "ladybug”};
String[] alias = bugs;
bugs.equals(alias);                          // true

Java has provided the Arrays.toString() method that prints an array:

System.out.println(bugs.toString());         // Output: [Ljava…
System.out.println(Arrays.toString(bugs));   // Output: [cricket, beetle, ladybug]

The length property gives the number of slots have been allocated. This property is a field, not a method, it should not contain parentheses:

String[] birds = new String[6];
System.out.println(birds.length);        // Output: 6

Sorting Arrays

Java provides a convenient Arrays.sort() method for sorting arrays in ascending order. When sorting arrays containing different data types (numbers, strings, etc.), it's important to be aware of the rules Java uses to compare these types, as this will determine the final order of the elements.

Syntax:

void Arrays.sort(T[] array)

The easy way with numbers:

int[] numbers = { 6, 9, 1 };
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));    // Output: [1, 6, 9]

Try this again with String types:

String[] strings = {"10", "9", "a", "100", "M", "0”};
Arrays.sort(strings);
System.out.println(Arrays.toString(strings)); // Output: [0, 10, 100, 9, M, a]

String sorts in alphabetic order, and 1 sorts before 9. The numbers are sorted before letters, and uppercase sorts before lowercase.

Searching Arrays

Java provides a convenient method, Arrays.binarySearch(), to efficiently search for a specific element within an array. This method requires that the array already be sorted for the results to be accurate.

Syntax:

int Arrays.binarySearch(int[] array, int key)
int Arrays.binarySearch(Object[] array, Object key)

The rules for searching:

If the target element is found in the sorted array, the method returns the index of the matching element (a positive integer).
If the target element is not found in the sorted array, the method returns a negative value. The returned value can be used to determine the insertion point for the element to maintain the sorted order. The formula is [-n] - 1, where n is an imaginary index to insert to keep the sorted order.

int[] numbers = {2, 4, 6, 8};
Arrays.binarySearch(numbers, 2);   // 0: match
Arrays.binarySearch(numbers, 4);   // 1: match
Arrays.binarySearch(numbers, 1);   // -1: insertion point would be index 0 => [-0] - 1 = -1
Arrays.binarySearch(numbers, 3);   // -2: [-1] - 1 = -2
Arrays.binarySearch(numbers, 9);   // -5: [-4] - 1 = -5

It is critical to understand that Arrays.binarySearch() only works correctly on sorted arrays. If you use it on an unsorted array, the results are unpredictable and likely incorrect. The only way can make sort (if it's necessary):

int[] numbers = new int[]{3, 2, 1};
Arrays.binarySearch(numbers, 2);        // 1: match
Arrays.binarySearch(numbers, 3);        // output not predictable: -4

String[] strings = new String[]{"9", "100", "10"};
Arrays.sort(strings);                         // Now: [10, 100, 9]
Arrays.binarySearch(strings, "10");           // 0: match
Arrays.binarySearch(strings, "8");            // -3: [-2] - 1 = -3

Comparing Arrays

Java provides two methods, Arrays.compare() and Arrays.mismatch(), to compare two arrays to determine which is smaller.

Syntax: Arrays.compare()

<T> int Arrays.compare(T[] array1, T[] array2)

The method returns:

A negative integer is if the first array is less than the second array.
Zero if the arrays are equal.
A positive integer is if the first array is greater than the second array.

The rules that define a smaller value:

null is smaller than any other value.
For numbers, normal numeric order applies.
For strings, one is smaller if it is a prefix of another.
For strings/characters, numbers are smaller than letters.
For strings/characters, uppercase is smaller than lowercase.

Arrays.compare(
    new int[] {1, 2}, new int[] {1});           // 1

Result: Positive number
Reason: The first element is the same, but the first array is longer.

Arrays.compare(
    new int[] {1, 2}, new int[] {1, 2});        // 0

Result: Zero
Reason: Exact match

Arrays.compare(
    new String[] {"a"}, new String[] {"aa"});   // -1

Result: Negative number
Reason: The first element is a substring of the second.

Arrays.compare(
    new String[] {"a"}, new String[] {"A"});    // 32

Result: Positive number
Reason: Uppercase is smaller than lowercase.

Arrays.compare(
    new String[] {"a"}, new String[] {null});   // 1

Result: Positive number
Reason: null is smaller than a letter.

Arrays.compare(
   new String[] {"1"}, new String[] {"a"});     // -48

Result: Negative number
Reason: Numbers are smaller than letters

Finally, this code does not compile because the types are different. When comparing two arrays, they must be the same array type.

Arrays.compare(
   new int[] {1}, new String[] {"a"});          // DOES NOT COMPILE

Syntax: Arrays.mismatch()

<T> int mismatch(T[] array1, T[] array2)

If the arrays are equal, mismatch() returns -1. Otherwise, it returns the first index where they differ.

The method returns:

If the arrays are equal, it returns -1
If one array is null, it returns 0
If the arrays are not equal, it returns the first index where they differ

Arrays.mismatch(
   new int[] {1}, new int[] {1});                  // -1

Arrays.mismatch(
   new String[] {"a"}, new String[] {"A"});        // 0

Arrays.mismatch(
   new String[] {"a"}, new String[] {null});       // 0

Arrays.mismatch(
   new int[] {1, 2}, new int[] {1});               // 1

4. Shallow Copy vs. Deep Copy

Each type of array implements the Cloneable and Serializable interfaces. Therefore, it's logical to discuss the clone() method, which is related to two important concepts: shallow and deep copy.

Shallow Copy

A shallow copy creates a new object (or array) but does not clone the objects contained within. Instead, it copies the references to the same objects in memory. As a result, changes made to the objects through one reference will be reflected in the other reference.

@Setter
@Getter
public class Friend implements Cloneable {

    private String name;
    private int age;

    public Friend(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public Friend clone() {
        return new Friend(this.name, this.age);
    }
}

Shallow Copy of Primitive Array:

private static void shallowCopyOfPrimitive() {
    int[] a = {1, 2, 3};
    int[] copy = a.clone();

    copy[1] = 4;
    System.out.println("Origin: " + Arrays.toString(a));
    System.out.println("Copy: " + Arrays.toString(copy)); 
}

Output:

Origin: [1, 2, 3]
Copy: [1, 4, 3]

As primitives are copied directly, the original array remains unchanged, illustrating that primitive types are independent when cloned.

Shallow Copy of Object Array:

private static void shallowCopyOfObject() {
    Friend[] a = {new Friend("Monica", 28), new Friend("Ross", 26)};
    Friend[] copy = a.clone();

    copy[0].setName("Chandler");
    System.out.println("Origin: " + Arrays.toString(a)); 
    System.out.println("Copy: " + Arrays.toString(copy)); 
}

Output:

Origin: [Name: Chandler, Age: 28, Name: Ross, Age: 26]
Copy: [Name: Chandler, Age: 28, Name: Ross, Age: 26]

This shows the behavior of shallow copying, where both arrays point to the same underlying Friend objects. Changes in one affect the other because they share the same references.

Deep Copy

A deep copy creates a new object (or array) and also clones the objects contained within. This means that two independent objects are created in memory, so changes made to one do not affect the other.

private static void deepCopy() {
    Friend[] a = {new Friend("Monica", 28), new Friend("Ross", 26)};
    Friend[] copy = new Friend[a.length];

    for (int i = 0; i < a.length; i++) {
        copy[i] = a[i].clone();     // Calling clone method to create independent copies
    }

    copy[0].setName("Chandler");
    System.out.println("Origin: " + Arrays.toString(a)); 
    System.out.println("Copy: " + Arrays.toString(copy)); 
}

Output:

Origin: [Name: Monica, Age: 28, Name: Ross, Age: 26]
Copy: [Name: Chandler, Age: 28, Name: Ross, Age: 26]

This illustrates deep copying, where modifications in one array do not impact the other because they hold separate object instances in memory.

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. 😊

Mastering String APIs in Java

Marta Kravchuk — Sat, 31 May 2025 06:30:33 +0000

In Java, strings are fundamental for data manipulation. This article delves into the core concepts of Java's `String` and `StringBuilder` classes, essential components of the Java Standard Library. It will explore how to create and manipulate String objects, understand the nuances of immutability, and leverage the string pool for efficiency. Additionally, the mutable nature of the StringBuilder class and its methods for dynamic string construction will be discussed here, providing a comprehensive understanding of string handling in Java.

Working with String Objects
- Concatenation
- Immutability and the String Pool
- Essential String Methods and the Method Chaining
Manipulate Data Using the StringBuilder Class
Understanding Equality: String vs. StringBuilder

String APIs refer to the set of methods and functionalities provided by the String and StringBuilder classes, which are part of the Java Standard Library.

1. Working with `String` Objects

The String class is fundamental in Java, representing an immutable sequence of characters. It implements the CharSequence interface, a general way of representing character sequences, also implemented by classes like StringBuilder. In Java, a String object can be created as follows (the new keyword is optional):

String name = "Fluffy";
String name = new String("Fluffy");

In both examples, a reference variable name is created, pointing to a String object with the value "Fluffy". However, the creation process differs subtly. The String class is unique in that it doesn’t require instantiation with new, it can be created directly from a literal.

Concatenation

Placing one String object before another String object and combining them (using the + operator) is called string concatenation.
The most important rules to know are:

If both operands are numeric, + means numeric addition.
If either operand is a String, + means concatenation. 
The expression is evaluated left to right.

System.out.println(1 + 2);               // 3
System.out.println("a" + "b");           // "ab"
System.out.println("a" + "b" + 3);       // "ab3"
System.out.println(1 + 2 + "c");         // "3c"
System.out.println("c" + 1 + 2);         // "c12" => "c1" + 2 => "c12"
int three = 3;
String four = "4";
System.out.println(1 + 2 + three + four); // "64" => 3 + 3 + "4" => 6 + “4"

Immutability and the String Pool

In Java, the String class is immutable. Once a String object is created, its value cannot be changed. This design choice offers key benefits:

Immutable String objects are inherently thread-safe, which prevents data corruption in parallel environments.
Immutability increases security. For example, class names or arguments passed to methods are often represented as strings. By making strings immutable, you prevent attackers from changing these values after they are passed.
Since String objects are immutable, their hash codes can be cached without worrying about changes. This makes String objects suitable for use as keys in HashMap and other hash-based data structures, improving performance.

The immutability of String objects is demonstrated in the following example:

String s1 = "1";
String s2 = s1.concat("2");
s2.concat("3");            // This call is effectively ignored
System.out.println(s2);    // Output: "12"

In this example, s1.concat("2") creates a new String object, "12", and assigns its reference to s2. Even though s2.concat("3") is called, it doesn't change the value of s2. Because strings are immutable, concat() always returns a new String object. Since the result of s2.concat("3") isn't assigned to anything, it's discarded, and s2 remains "12".

Since strings are everywhere in Java, they can consume significant memory, especially in production applications. To mitigate this, Java reuses common strings through the string pool (also known as the intern pool), a special memory area in the Java Virtual Machine (JVM) that stores String literals to optimize memory usage.

So, the string pool contains String literals and constants. For example, x or y are String literals and will be placed in the string pool. But, the myObject.toString() is a string but not a literal, so it typically doesn’t go into the string pool directly. And String objects created with the new keyword are not automatically added to the string pool:

String x = "Hello World";       // x goes into the string pool
String y = "Hello World";       // y goes into the string pool
System.out.println(x == y);     // true (x and y refer to the same object)

String z = "Hello World";
String myObject = new String("Hello World");     // this is object
System.out.println(z == myObject);               // false

The String object created as a result of runtime calculations (e.g., using String methods), even if they have the same content, a new String object will be created:

String x = "Hello World";
String z = " Hello World".trim();   // a new String object is created
System.out.println(x == z);         // false (x and z are different objects)

Concatenation with non-literals also results in a new String object:

String single = "hello world";
String concat = "hello ";
concat += "world";
System.out.println(single == concat);   // false

When a String literal is created, the JVM first checks if an identical String already exists in the pool. If it does, the variable simply points to the existing String object in the pool, avoiding the creation of a duplicate. This mechanism offers significant memory savings, especially in applications that use many identical string values.

Essential `String` Methods and the Method Chaining

For all these methods, remember that a String is a sequence of characters, and Java indexing starts at 0.

length() returns the length of the String object (number of characters):

"animals".length();    // 7
"".length();           // 0

toLowerCase() / toUpperCase() return a new String object with all characters converted to lowercase or uppercase, respectively:

"AniMaLs".toLowerCase();    // "animals"
"AniMaLs".toUpperCase();    // "ANIMALS"

equals() / equalsIgnoreCase() compare the content of two String objects. The equals() is case-sensitive, while equalsIgnoreCase() is not. Both methods return a boolean:

"animals".equals("animals");             // true
"animals".equals("ANIMALS");             // false
"animals".equalsIgnoreCase("ANIMALS");   // true

contains() checks if the String object contains a specified sequence of characters. Returns a boolean:

"animals".contains("ani");     // true
"animals".contains("als");     // true
"animals".contains("AlS");     // false (case-sensitive)

startsWith() / endsWith() check if the String object starts or ends with a specified prefix or suffix. Returns a boolean:

"animals".startsWith("ani");    // true
"animals".endsWith("als");      // true
"animals".startsWith("als");    // false

replace() returns a new String object in which all occurrences of a specified sequence of characters are replaced with another sequence:

"animals".replace("a", "o");       // "onimols"
"animals".replace("als", "zzz");   // "animzzz"

charAt() returns the char at the specified index:

"animals".charAt(0);      // a
"animals".charAt(6);      // s
"animals".charAt(7);      // throws exception

indexOf() finds the first index that matches the specified character or substring. Returns -1 if no match is found and doesn’t throw an exception. Returns an int:

"animals".indexOf('a');        // 0
"animals".indexOf("al");       // 4
"animals".indexOf('a', 4);     // 4
"animals".indexOf("al", 5);    // -1

substring() returns parts of the String object:

String string = "animals";


"animals".substring(3);                     // "mals"
"animals".substring(string.indexOf('m'));   // "mals"
"animals".substring(3, 5);                  // "ma"
"animals".substring(3, 3);                  // empty string
"animals".substring(3, 2);                  // throws exception
"animals".substring(3, 8);                  // throws exception

trim() / strip() remove whitespace from the beginning and end of a String object. The trim() works only with ASCII-spaces, the strip() (new in Java 11) and supports Unicode:

String text = " abc\t ";
text.trim().length();             // 3
text.strip().length();            // 3

stripLeading() / stripTrailing() (new in Java 11). The first removes whitespace from the beginning and leaves it at the end. The stripTrailing() does the opposite:

String text = " abc\t ";
text.stripLeading().length();            // 5
text.stripTrailing().length();           // 4

intern() uses an object in the string pool if one is present. If the literal is not yet in the string pool, Java will add it at this time:

String x = "Hello World";
String y = new String("Hello World").intern();
System.out.println(x == y);              // true

String first = "rat" + 1;
String second = "r" + "a" + "t" + "1";
String third = "r" + "a" + "t" + new String("1");
System.out.println(first == second);             // true
System.out.println(first == second.intern());    // true
System.out.println(first == third);              // false
System.out.println(first == third.intern());     // true

So, String methods can be used sequentially, with each method call assigning its resulting String object to a new variable:

String start = "AniMaL   ";
String trimmed = start.trim();               // "AniMaL"
String lowercase = trimmed.toLowerCase();    // "animal"
String result = lowercase.replace('a', 'A'); // "AnimAl"

However, this approach can become verbose and less readable. Instead, Java allows you to use a technique called method chaining, where multiple method calls are chained together in a single expression:

String result = "AniMaL   "
    .trim()
    .toLowerCase()
    .replace('a', 'A');   // "AnimAl"

2. Manipulate Data Using the `StringBuilder` Class

The StringBuilder class represents mutable sequences of characters. Most of its methods return a reference to the current object, enabling method chaining.

StringBuilder Methods

The StringBuilder class has many methods: substring() does not change the value of a StringBuilder, whereas append(), delete(), and insert() does change it.

StringBuilder sb = new StringBuilder("start");
sb.append("+middle");                       // "start+middle"
StringBuilder same = sb.append("+end");     // "start+middle+end"

StringBuilder a = new StringBuilder("abc");
StringBuilder b = a.append("de");
b = b.append("f").append("g");
System.out.println(a);               // Output: "abcdefg"
System.out.println(b);               // Output: "abcdefg"

charAt(), indexOf(), length(), and substring(): these four methods work the same as in the String class:

append() adds values (e.g., String, char, int, Object, etc.) to the end of the current StringBuilder object:

StringBuilder sb = new StringBuilder().append(1).append('c');
sb.append("-").append(true);                // sb -> "1c-true"

insert() adds characters at the requested index. The offset is the index where we want to insert the requested parameter:

StringBuilder sb = new StringBuilder("animals");
sb.insert(7, "-");                          // sb -> "animals-"
sb.insert(0, "-");                          // sb -> "-animals-"
sb.insert(4, "-");                          // sb -> "-ani-mals-"

As we add and remove characters, their indexes change. Also, if offset is equal to length() + 1 a StringIndexOutOfBoundsException will be thrown.

delete() / deleteCharAt(), the first removes characters from sequence, as deleteCharAt() uses to remove only one character at the specified index:

StringBuilder sb = new StringBuilder("abcdef");
sb.delete(1, 3);       // sb -> "adef" (the length is 4)
sb.deleteCharAt(5);    // throws an exception (the index is out of range)

Even if delete() is called with an end index beyond the length of the StringBuilder, it will not throw an exception but will simply delete up to the end of the StringBuilder:

StringBuilder sb = new StringBuilder("abcdef");
sb.delete(1, 100);                  // sb -> "a"

replace() deletes the characters starting with startIndex and ending before endIndex:

StringBuilder builder = new StringBuilder("pigeon dirty");
builder.replace(3, 6, "sty");        // sb -> "pigsty dirty"
builder.replace(3, 100, "a");        // sb -> "piga"
builder.replace(2, 100, "");         // sb -> "pi"

reverse() reverses the characters in the StringBuilder object:

StringBuilder sb = new StringBuilder("ABC");
sb.reverse();                        // sb -> "CBA"

3. Understanding Equality: `String` vs. `StringBuilder`

Equality Comparison in Java: `String`

==: Can return true if both String literals point to the same object in the string pool. For new String(), it typically returns false.
String.equals(): Compares the content (sequence of characters) of the strings. Returns true if the contents are identical.

String a = "Fluffy";
String b = new String("Fluffy");
a == b;                       // false
a.equals(b);                  // true

String x = "Hello World";
String z = " Hello World".trim();
x == y;                       // false
x.equals(z);                  // true

Equality Comparison in Java: `StringBuilder`

==: Always checks for reference equality, just like other non-pooled objects. It will return true only when both references point to the same StringBuilder object.
StringBuilder.equals(): Compares the object references. Returns true only if both references point to the same StringBuilder object.

StringBuilder one = new StringBuilder();
StringBuilder two = new StringBuilder();
StringBuilder three = one.append("a");

one == two;                       // false
one.equals(two);                  // false

one == three;                     // true
one.equals(three);                // true

❗Note: If the class does not have an equals() method, Java uses the == operator to check equality. Remember that == is checking for object reference equality.

public class Cat {
    String name;

    public void main(String[] args) {
        Cat t1 = new Cat();
        Cat t2 = new Cat();
        Cat t3 = t1;

        t1 == t2;         // false
        t1 == t3;         // true

        t1.equals(t2);    // false: equals() is absent -> t1 == t2
    }
}

The compiler is smart enough to know that two references can’t possibly point to the same object when they are completely different types.

String string = "a";
StringBuilder builder = new StringBuilder("a");
string == builder;          // DOES NOT COMPILE
builder.equals(string)      // false

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. Stay tuned here for a new Java series every week! And feel free to connect with me on LinkedIn 😊

Garbage Collection in Java: A Simple Explanation

Marta Kravchuk — Wed, 21 May 2025 07:00:00 +0000

Effective memory management is essential in Java development. Fortunately, Java automates this task through a process called garbage collection (GC), which helps prevent memory leaks. This article explains Java garbage collection in simple terms, covering its core principles, the `System.gc()` method for suggesting garbage collection, the deprecated `finalize()` method, and modern ways to manage resources.

What is Java Garbage Collection?
Suggesting Garbage Collection with System.gc()
Why the Deprecated finalize() Should Be Avoided
Modern Resource Management Techniques

All Java objects are stored in a memory heap. The heap, also called free storage, is a large pool of unused memory that is specifically allocated for your Java program. Depending on the environment you're working in, the heap can be quite large, but its size is always limited. After all, there is no computer with infinite memory. So if you create many objects without cleaning them up, your program could run out of memory and crash.

1. What is Java Garbage Collection?

Garbage collection refers to the process where Java automatically deletes objects that are no longer needed to free up memory, operating silently in the background.

To understand how garbage collection works, it's important to know when an object becomes eligible for removal. In Java, an object is considered eligible for garbage collection when it's no longer accessible to the program and therefore able to be garbage collected. This happens in two primary cases:

The object has no more references pointing to it, indicating that no part of the code is actively using it.
All references to the object have gone out of scope, such as when the object was created inside a method that has finished executing.

2. Suggesting Garbage Collection with `System.gc()`

Java includes a built-in method to help support garbage collection that can be called at any time: System.gc().

public static void main(String[] args) {
   System.gc();
}

❗Note: When you call System.gc(), you are simply suggesting to Java that it should perform garbage collection. It doesn’t guarantee that it will actually do this. The JVM may perform garbage collection at that moment, or it might be busy and choose not to. The JVM is free to ignore the request.

The following example demonstrates this more concretely, by creating Cat objects and manipulates references to them to demonstrate how garbage collection eligibility works in Java.

public class Cat { 
   public static void main(String[] args) { 
      Cat one = new Cat(); 
      Cat two = new Cat(); 
      Cat three = one; 
      one = null; 
      Cat four = one; 
      three = null; 
      two = null; 
      two = new Cat(); 
      System.gc(); 
   } 
}

Initially, Cat one and Cat two are created, each referencing a new Cat object. Assigning Cat three = one makes both one and three point to the same Cat object. Setting one = null does not make that Cat object eligible for garbage collection, because the variable three still holds an active reference. Assigning Cat four = one assigns a null reference and does not affect garbage collection eligibility. It's only when both one and three are set to null that the first Cat object becomes eligible for garbage collection, because there are then no more active references pointing to it. Similarly, when two = null is executed, the second Cat object becomes eligible, since two was the only reference to that object. The assignment where two is a new Cat() makes the third object collected when method scope is closed. Finally, the line System.gc() suggests to the JVM that it might be a good time to run the garbage collector. However, it doesn't guarantee that garbage collection will actually occur. Even if garbage collection runs, it simply reclaims the memory.

That is, in short:

The first Cat object becomes eligible for garbage collection after three = null because no other variables reference it.
The second Cat object becomes eligible for garbage collection after two = null because no other variables reference it.
The third Cat object becomes eligible for garbage collection after the method ends.

The System.gc() is just a request, and the JVM may choose to ignore it.

3. Why the Deprecated `finalize()` Should Be Avoided

The finalize() method in Java was part of the Object class. This function can be confusing and difficult to use. In a few words, the garbage collector may call the finalize() method once — or not at all, depending on whether and when garbage collection occurs. If the garbage collector failed to collect an object and tried again later, there was no second call to finalize(). In fact, it was used as a finalisation mechanism to perform certain actions before the object was destroyed by the garbage collector. However, since Java 9, this method has been deprecated in Object, as reported in the official documentation:

The finalisation mechanism is inherently problematic.

It is important to know that finalize() could be executed zero or once. It could be executed twice.

How the `finalize()` method worked:

The finalize() method provided a last opportunity to clean up resources that the object hadn't released, such as closing open files or breaking database connections.

protected void finalize() throws Throwable {
   try {
      // Perform cleanup, like releasing resources
   } finally {
      super.finalize();
   }
}

Problems with `finalize()` method:

Unreliability: the method was not always called immediately after the object became unnecessary, which led to delays in freeing resources.
Performance: this slowed down the garbage collector as it required additional work to be done.
Security: the method could allow unsafe code to be executed while cleaning up objects, which created security risks.

Alternatives:

Instead of finalize(), other resource management techniques are recommended, such as:

try-with-resources automatically closes resources after use, avoiding the need for garbage collection participation.
Cleaner and PhantomReference provide better control and flexibility for resource cleanup without the issues associated with finalize().

4. Modern Resource Management Techniques

Java includes the try-with-resources statement to automatically close all resources opened in a try clause. This feature, known as automatic resource management, ensures that resources are properly closed without requiring additional code in finally blocks. This is especially useful for managing files, databases, and network connections, where you need to ensure that the resource is closed regardless of the success of the operation or exceptions.

void readFile() {
   try (FileReader file = new FileReader("file.txt")) {
      ...
   } catch (IOException e) {
      System.out.println("An error: " + e.getMessage());
   }
}

❗Note: Only a try-with-resources statement is permitted to omit both the catch and finally blocks. A traditional try statement must have either or both.

void readFile() throws IOException {
   try (FileReader file = new FileReader("file.txt")) {
        ...
   }
}

When using a try-with-resources statement, you cannot use just any class. Instead, Java requires that the classes you use must implement the AutoCloseable interface. When you use a try-with-resources statement, the Java compiler automatically generates a hidden finally block behind the scenes. This implicit finally block is responsible for calling the close() method on all resources declared in the try-with-resources statement.

The Cleaner and PhantomReference mechanisms provide more flexible ways to perform cleanup actions for objects that are no longer reachable, offering alternatives to the deprecated finalize() method.

The Cleaner class was introduced in Java 9 as part of the java.lang.ref package. It provides a mechanism to register cleanup actions that will be executed when an object becomes unreachable.

import java.lang.ref.Cleaner;

class Resource {
    private static final Cleaner cleaner = Cleaner.create();

    private final Cleaner.Cleanable cleanable;

    public Resource() {
        cleanable = cleaner.register(this, new CleanupAction());
        System.out.println("Resource allocated.");
    }

    private static class CleanupAction implements Runnable {
        public void run() {
            System.out.println("Cleanup actions executed.");
        }
    }

// Other methods for the resource...
// If you need to explicitly clean up, you could provide a close method

    public void close() {
        cleanable.clean();
    }
}

public class CleanerExample {
    public static void main(String[] args) {
        Resource resource = new Resource();
// Use the resource. The cleanup action will be called when the resource becomes unreachable
        resource = null; // Make the resource eligible for garbage collection
        System.gc(); // Suggest garbage collection
    }
}

PhantomReference provides a mechanism to detect when an object becomes unreachable and to perform cleanup actions before the memory is reclaimed — similar in purpose to finalize(), but more reliable. The key feature of PhantomReference is the use of a ReferenceQueue. When an object becomes unreachable, it is automatically added to this queue.

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

class PhantomReferenceExample {
    public static void main(String[] args) {
        ReferenceQueue<MyObject> queue = new ReferenceQueue<>();
        MyObject obj = new MyObject();
        PhantomReference<MyObject> phantomRef = new PhantomReference<>(obj, queue);

        // Make the object eligible for garbage collection
        obj = null;
        System.gc(); // Suggest garbage collection

        // Check if phantom reference is added to the queue
        PhantomReference<MyObject> ref = (PhantomReference<MyObject>) queue.poll();
        if (ref != null) {
            System.out.println("Phantom reference has been cleared.");
        } else {
            System.out.println("Phantom reference not yet cleared.");
        }
    }
}

class MyObject {
    // Class implementation...
}

Both approaches, Cleaner and PhantomReference, offer a more reliable and controlled way to manage resource cleanup compared to the finalize() method.

Conclusion

This article has provided an overview of how Java automatically frees up memory using the garbage collector. Objects become eligible for removal when they are no longer referenced or go out of scope. Local variables disappear once their block ends, instance fields become unreachable when the object itself is no longer accessible, and static variables live throughout the entire runtime of the program.
Understanding how garbage collector works is essential for performance optimization, as unintentional memory leaks can lead to OutOfMemoryErrors and degraded application performance. Instead of relying on the deprecated finalize() method, Java provides more efficient alternatives: try-with-resources, Cleaner, and PhantomReference — to ensure timely cleanup of resources.

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. Stay tuned here for a new Java series every week! And feel free to connect with me on LinkedIn 😊

Java Variables: A Complete Guide (feat. var Type Inference)

Marta Kravchuk — Sat, 17 May 2025 07:00:00 +0000

This article provides a complete overview of Java variables, covering everything from basic concepts to modern features like local variable type inference `var`. It explores variable types, declaration, initialization, scope, lifetime, and naming conventions. Whether you're preparing for an interview or seeking a quick refresher, this guide provides essential insights.

What is a Variable?
- Variable Types
- Declaring and Initializing Variables
- Naming Conventions and Legal Identifiers for Variables
Variable Scope and Lifetime
Local Variable Type Inference (var)

Java classes have two primary elements: methods, often called functions or procedures in other languages, and fields, more generally known as variables. Together these are called the members of the class. Variables hold the state of the program, and methods operate on that state. Other building blocks include interfaces. So, variables are essentially data members within a class.

1. What is a Variable?

In Java, a variable is a named storage location that holds a value. Think of it as a container with a label (the variable name) where you can store data. Variables are essential for storing, retrieving, and manipulating information during program execution. Each variable has a specific data type (e.g., int, String, boolean) that determines the kind of values it can hold. Variables are the building blocks for storing and processing information.

Variable Types

In Java, variables are categorized into two main types: primitive and reference types. For a detailed explanation of these types, refer to previous article. There you will find a brief overview of each type and their key differences.

Declaring and Initializing Variables

When you declare a variable, you associate its name with a specific data type.

String name;
int number;

After a variable's declaration, it can be assigned a value, a process known as initialization.

name = "The Best Zoo";
number = 100;

Below, the previous declarations and initializations are merged into concise code:

String name = "The Best Zoo";
int number = 100;

Declaring Multiple Variables: you can declare many variables in the same declaration as long as they are all of the same type.

void sandFence() {
   String s1, s2;                // declared but not yet initialized
   String s3 = "yes", s4 = "no"; // initialized variables
}

void paintFence() {
   int i1, i2, i3 = 0;           // variable 'i3' is initialized
}

There are three variables: i1, i2 (are declared), and i3 (is initialized).

int num, String value;           // DOES NOT COMPILE

This code doesn’t compile because it tries to declare multiple variables of different types in the same statement.

Here are a few ways to summarize those variable declaration examples, presented in a more informative style:

int i1, i2, i3 = 0;             // all declared; 'i3' is initialized
int num, String value;          // DOES NOT COMPILE: different types
boolean b1, b2;                
String s1 = "1", s2;            
double d1, double d2;           // DOES NOT COMPILE
int i1; int i2;                 
int i3; i4;                     // DOES NOT COMPILE

Naming Conventions and Legal Identifiers for Variables

An identifier is the name of a variable, method, class, interface, or package.

identifiers may begin with a letter, a $ symbol, or a _ symbol.
identifiers can include numbers but not start with them.
since Java 9, a single underscore _ is not allowed as an identifier.
you cannot use the same name as a Java-reserved word.
the first character is not allowed to be a number, and reserved words are not allowed.

A reserved word is a special keyword that Java uses for specific purposes, so you are not allowed to use it. Remember that Java is case-sensitive, so you can use versions of the keywords that only differ in case.

abstract	assert	boolean	break	byte	case	catch
char	class	const	continue	default	do	double
else	enum	extends	false	final	finally	float
for	goto	if	import	instanceof	int	interface
long	implements	native	new	null	package	private
protected	public	return	short	static	strictfp	super
switch	synchronized	this	throw	throws	transient	true
try	void	volatile	while	_ (underscore)

❗Note: In this table, bold text indicates reserved keywords (like const and goto) that are not currently used in Java but are still restricted to avoid potential conflicts with other languages. And highlighted terms (like true, false, and null) aren’t actually reserved words, but literal values, which are also prohibited as identifiers and are listed here for clarity.

To solidify understanding of identifier rules, consider these examples:
Legal Identifiers:

long okidentifier;
float $OK2Identifier;
boolean _alsoOK1d3ntifi3r;
char __SStillOkbutKnotsonice$;

Illegal Identifiers:

int 3DPointClass;     // identifiers cannot begin with a number
byte hollywood@vine;  // @ is not a letter, digit, $ or _
String *$coffee;      // * is not a letter, digit, $ or _
double public;        // public is a reserved word
short _;              // a single underscore is not allowed

Beyond the rules for legal identifiers, following consistent naming conventions is crucial for code readability and maintainability.

Style: camelCase
While Java technically allows different styles, the development community largely adheres to camelCase, the preferred style for most Java identifiers. In camelCase:

method and variable names are written with the first letter being lowercase, capitalizing subsequent words (e.g., calculateTotal, userFirstName).
class and interface names are written with the first letter being uppercase, capitalizing subsequent words (e.g., CustomerService, Printable). Note: Avoid starting class names with $, as the compiler uses this symbol for internal files.

Style: snake_case
While syntactically valid, snake_case is generally discouraged for variable and method names in Java. However, there are some common exceptions:

static final constants are commonly written in uppercase snake_case (e.g., THIS_IS_A_CONSTANT).
enum values tend to be written in uppercase snake_case for consistency and readability, as in Color.RED, Color.DARK_GRAY, and so on.

2. Variable Scope and Lifetime

In Java, variables have a scope that determines where they can be accessed in your code, and a lifetime that dictates how long they exist. Java defines three primary types of variables based on these characteristics: class variables, instance variables, and local variables.

2.1. Class Variables (Static Fields)

You can define a static field using the static keyword. You do not need an instance of the class to access static fields. You can access static class fields by writing the class name before the field. There is only one copy of a static variable, no matter how many instances of the class there are.

2.2. Instance Variables (Non-Static Fields)

Instance variables in Java are variables declared within a class without the static keyword, outside of any method. Such a variable is associated with a specific instance of a class, and the value of the variable in one instance does not affect the value of the same variable in another instance of this class.

Default initialization values by type: Class and Instance variables do not require initialization, they are automatically initialized to default values. As soon as you declare them, they receive default values: null for objects and 0 / false for primitives.
boolean -> false
byte, short, int -> 0
long -> 0L
double -> 0.0
float -> 0.0f
char -> '\u0000' (NULL)
All object references (everything else) -> null

2.3. Local Variables

This is a variable defined within a method (also method parameters or constructor parameters) and cannot be used outside the method. Local variables must be initialized before use (it’s ok to have an uninitialized local variable as long as you never use it). They do not have default values and contain garbage data until initialized.

public void findAnswer(boolean check) {
   int answer;
   int onlyOneBranch;

   if (check) {
      onlyOneBranch = 1;
      answer = 1;
   } else {
      answer = 2; 
   }
   System.out.println(answer);
   System.out.println(onlyOneBranch);    // DOES NOT COMPILE
}

In the method, the variable answer is guaranteed to be initialized before it is used, so the code compiles successfully. However, the variable onlyOneBranch is only initialized if the check is true. If a check is false, onlyOneBranch remains uninitialized, leading to a compile error when trying to print it. So, the compiler knows the check can also be false, resulting in uninitialized code and giving a compiler error.

public void findAnswer(boolean check) { }
public void checkAnswer() {
   boolean value;
   findAnswer(value);                     // DOES NOT COMPILE
}

The call to findAnswer() does not compile because it tries to use a local variable that is not initialized.

The scope and lifetime of a Java variable are intrinsically linked to its type and where it is declared.

Local variable: scope extends from the point of declaration to the end of the enclosing block.
Instance variable: available from the point of declaration until the object is garbage collected.
Class variable: available from the moment of declaration until the program terminates.

3. Local Variable Type Inference (var)

Starting in Java 10, you can use the keyword var instead of the type for local variables under certain conditions. To use this feature, you just type var instead of the primitive or reference type.

public void whatTypeAmI() {
   var name = "Hello";
   var size = 7;
}

The formal name of this feature is local variable type inference. This means that it is used only as a local variable. It cannot be used as a static var (class or local):

public class VarKeyword {
   var tricky = "Hello";        // DOES NOT COMPILE: instance var
   static var h = "String";     // DOES NOT COMPILE: class var

   public void whatTypeAmI() {
      static var size = 7;      // DOES NOT COMPILE: static local
   }
}

In Java, var is still a specific type defined at compile time. It does not change type at runtime.

public void reassignment() {
   var number = 7;
   number = 4; 
   number = "five";             // DOES NOT COMPILE     
}

To better understand how var works and where it can be used, let's look at some practical code snippets.

int a, var b = 3;               // DOES NOT COMPILE
var a = 2, b = 3;               // DOES NOT COMPILE

All the types declared on a single line must be the same type and share the same declaration. Java does not allow var in multiple variable declarations.

var n = null;                  // DOES NOT COMPILE

The compiler is prompted to define the null type. It can be any type of reference. The only choice the compiler can make is an Object. Java developers have decided that it is better not to allow var for null than to guess about intentions.

While a var cannot be initialized with a null value without a type, it can be assigned a null value after it is declared, provided that the underlying data type of the var is an object.

var n = "myData";
n = null;
var m = 4;
m = null;     // DOES NOT COMPILE: primitives are not assigned a null

The n is of type String, which is an object that compiles without issue. But since the type of m is a primitive int, it cannot be assigned a null value that does not compile.

var o = (String) null;

By the way, a var can be initialized to a null value if the type is specified.

public int addition(var a, var b) {    // DOES NOT COMPILE
   return a + b;
}

Also, it can’t be used as method parameters. Since, the a and b are method parameters. These are not local variables.

While var is not a reserved word and is allowed to be used as an identifier, it is considered a reserved type name. Naming a local variable var is legal. The following examples illustrate this:

package var;

public class Var {
   public void var() {
      var var = "var";
   }

   public void Var() {
      Var var = new Var();
   }
}

A reserved type name means it cannot be used to define a type, such as a class, interface, or enum.

public class var {     // DOES NOT COMPILE
   public var() { }
}

Summarizing the use of var, let's consider the key rules.
What you can do with var:

A var can be used as a local variable in a constructor, method, or initializer block.
The value of a var can change, but the type cannot.

What you cannot do with var:

A var cannot be used as a parameter in a constructor and method, instance variables, or class variables.
A var must always be initialized on the same line (or statement) where it is declared.
A var cannot be initialized with a null value without a type.
A var is not permitted in a multiple-variable declaration.
A var is a reserved type name but not a reserved word, meaning it can be used as an identifier except as a class, interface, or enum name.

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. Stay tuned here for a new Java series every week! And feel free to connect with me on LinkedIn 😊

Java Data Types: A Quick Reference Guide

Marta Kravchuk — Fri, 16 May 2025 07:00:00 +0000

This article offers concise technical Java notes, covering primitive and reference types, literals, type conversion rules, and more. Whether you're preparing for an interview or seeking a quick refresher, this guide provides essential insights.

Primitive Types
- Literals
- Declaring Primitive Types
- Type Conversion Rules
Reference Types
Wrapper Classes

Java contains two types of data: primitive types and reference types.

1. Primitive Types

Java has 8 built-in data types, referred to as the Java primitive types. A primitive is not an object in Java and does not represent an object. A primitive is simply a single value in memory, such as a number or a character.

Keyword	Type	Example	Wrapper class
`boolean`	`true` or `false`	`true`	`Boolean`
`byte`	8-bit integral	`123`	`Byte`
`short`	16-bit	`123`	`Short`
`int`	32-bit	`123`	`Integer`
`long`	64-bit	`123L`	`Long`
`float`	32-bit floating-point	`123.45f`	`Float`
`double`	64-bit floating-point	`123.45`	`Double`
`char`	16-bit Unicode	`'a'`	`Character`

The data value of a primitive data type is stored in memory and is not a location reference of the data. This makes accessing primitive data types faster and leads to more efficient performance when it really matters.

Each primitive type has a corresponding wrapper class, which is an object type.

Key Differences: `short` vs. `char`

The primary difference is that short is signed integer type (can represent both positive and negative values). Alternatively, char is unsigned character type (can represent only positive including 0).

short bird = 'd';           // 'bird' is equal to 100 (the Unicode value of 'd')
char mammal = (short) 83;   // 'mammal' is equal to 'S' (the Unicode character with value 83)
short negative = -100;

❗Note: If you try to set a value outside the range of short or char, the compiler will report an error.

short reptile = 65535;     // DOES NOT COMPILE
char fish = (short) -1;    // DOES NOT COMPILE

Literals

When a numeric primitive is present in the code, it is called a literal. And you can use underscores in numbers to make them easier to read:

int million1 = 1000000;
int million2 = 1_000_000;

❗Note: Underscores cannot be placed at the beginning or end of a literal, or immediately before/after a decimal point.

double notAtStart = _1000.00;   // DOES NOT COMPILE
double notAtEnd = 1000.00_;     // DOES NOT COMPILE
double notByDecimal = 1000_.00; // DOES NOT COMPILE

double annoyingButLegal = 1_00_0.0_0; // Ugly, but works
double reallyUgly = 1__________2;     // Also compiles

Declaring Primitive Types

A declaration consists of the data type and variable name(s). A variable name must be a valid identifier. You can identify multiple variables of the same type on a single line, but not multiple variables of different types.

int x, y, z;
int a, double b;     // DOES NOT COMPILE

Declaring `float` and `double`

When declaring float or double variables with decimal literals, remember that decimal literals are treated as double by default. To define a float, use the 'f' suffix.

double decimalValue = 3.14;  // Valid double declaration
float floatValue = 3.14f;    // 'f' is required for float

Type Conversion Rules

Java supports both widening (implicit) and narrowing (explicit) conversions between data types. They increase type safety, maintain code clarity, control data loss, and optimize performance.

Widening Conversion: occurs when a smaller data type is converted to a larger data type, allowing expanding the range of values without losing information.

Java's primitive types can be converted in the following order:
byte -> short -> int -> long -> float -> double
char -> int -> long -> float -> double

float myFloat = 1000L;
double myDouble = 1000L;

Narrowing Conversion: occurs when a larger data type is converted to a smaller data type. This can potentially lead to loss of information or truncation of data and, therefore, requires explicit casting.

char myChar = (char) 1000L;
byte myByte = (byte) 1000L;
short myShort = (short) 1000L;
int myInt = (int) 1000L;

2. Reference Types

A reference type refers to an object (an instance of a class). A value is assigned to a reference in one of two ways:

A reference can be assigned to another object of the same or compatible type.
A reference can be assigned to a new object using the new keyword.

An object is a specific instance of a class that exists in memory while the program is running. An object is also referred to as an instance of the class. A variable that points to an object is called a reference. To create an instance of a class, you have to write new before the class name and add parentheses after it.

Park p = new Park();

First, you declare the type you’ll create Park and give the variable a name p. This gives Java a place to store a reference to the object. Then you write new Park() to create the object.

Key Differences: Primitives vs. References

There are a few important differences between primitives and reference types.

The reference types can be assigned null, which means they do not currently refer to an object. But instead, primitive types will give you a compiler error if you attempt to assign them null.

int value = null;          // DOES NOT COMPILE
String s = null;

The reference types can be used to call methods, assuming the reference is not null. And, primitives do not have methods declared on them.

String reference = "hello";
int len = reference.length();
int bad = len.length();     // DOES NOT COMPILE

3. Wrapper Classes

Wrapper classes encapsulate primitive types into objects. They offer methods for converting between primitives and objects.

Common Methods:

parse(): used for converting objects back to primitives.

int number = Integer.parseInt("10");          // String to int
double decimal = Double.parseDouble("3.14");  // String to double

valueOf(): returns an instance of the corresponding wrapper class. If the value is a primitive, it is converted to the appropriate wrapper object.

Integer wrappedInteger = Integer.valueOf(10);
Double wrappedDouble = Double.valueOf("5");

MIN_VALUE and MAX_VALUE: constants representing the smallest and largest possible values of that primitive type.

int min = Integer.MIN_VALUE;  // -2147483648
int max = Integer.MAX_VALUE;  // 2147483647

Autoboxing and Unboxing:

With autoboxing, the compiler automatically converts a primitive to the corresponding wrapper. Unsurprisingly, unboxing is the process in which the compiler automatically converts a wrapper class back to a primitive.

Primitive type	Wrapper class	Example of initializing
`boolean`	`Boolean`	Boolean.valueOf(true)
`byte`	`Byte`	Byte.valueOf((byte) 1)
`short`	`Short`	Short.valueOf((short) 1)
`int`	`Integer`	Integer.valueOf(1)
`long`	`Long`	Long.valueOf(1)
`float`	`Float`	Float.valueOf((float) 1.0)
`double`	`Double`	Double.valueOf(1.0)
`char`	`Character`	Character.valueOf('c’)

Integer pounds = 120;

This is an example of autoboxing as the int primitive is autoboxed into an Integer object.

Character letter = "robot".charAt(0);

This line demonstrates that autoboxing can involve methods. The charAt() method returns a primitive char. It is then autoboxed into the wrapper object Character.

char r = letter;

Finally, this line shows an example of unboxing. The Character object is unboxed into a primitive char.

❗Note: There are two tricks in the space of autoboxes and unboxes. The first is related to null values. This harmless-looking code throws exceptions:

var heights = new ArrayList<Integer>();
heights.add(null);
int h = heights.get(0);           // NullPointerException

Adding null to a list is legal, as a null reference can be assigned to any reference variable. However, when attempting to unbox that null to an int primitive, a problem arises. Java tries to get the int value of null, but since any method call on null results in a NullPointerException, that is precisely what occurs. Therefore, caution is advised when dealing with null in relation to autoboxing.

❗Note: And the second one, be careful using autoboxing with Integer in collections, as it can affect the behavior of methods like remove().

List<Integer> numbers = new ArrayList<Integer>();
numbers.add(1);
numbers.add(Integer.valueOf(3));
numbers.add(Integer.valueOf(5));   // the list 'numbers' contains the elements [1, 3, 5]
numbers.remove(1);
numbers.remove(Integer.valueOf(5));
System.out.println(numbers);       // [1]

The remove() method has two overloaded versions:

remove(int index) removes the element at the specified index.
remove(Object obj) removes the first occurrence of the object obj from the list.

Since numbers.remove(1) receives an int, Java invokes remove(int index), deleting the element at index 1 (this is a value 3). The list then becomes [1, 5].

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. More cool Java stuff is coming soon!

The Path to OCP Java SE 11 Certification (1Z0-819): What It Takes and How I Did It

Marta Kravchuk — Sun, 11 May 2025 18:23:18 +0000

If you're working with Java professionally and seriously aim to elevate your skills, taking the OCP Java SE certification may be a natural step forward. It’s not just about passing an exam — it’s a different way to learn and practice the material, deepening your understanding of Java and boosting your proficiency as a developer. And honestly, the preparation process in itself can be an invaluable experience.

Why even consider this certification? The benefits are definitely worth exploring, and there are numerous motivations to do that. These certifications are widely recognized in the Java community, opening doors to new opportunities, interesting projects, and career advancement. Nevertheless, research suggests that many companies prioritize certified developers, believing it helps mitigate potential project risks. Keep in mind that any certification isn't a magic bullet — it's often the learning process that truly unlocks your capabilities.

About a month ago, I became an Oracle Certified Java SE 11 Professional after successfully passing the 1Z0-819 exam. The summary and syllabus for it can be found here. So, how did I prepare? Well, that’s the key question and I decided to share my experience in case it helps someone else. While this article mainly covers the Java SE 11 exam, most OCP exams are structurally similar and require about the same amount of preparation. I hope some of my tips will be useful not only for passing the Java SE 11 certification but also when preparing for other Long-Term Support (LTS) versions, such as Java 17 and 21.

Let’s be honest, the exam is tough, but it’s definitely achievable. If you’re determined to pass, persistence and daily effort are crucial. For me, it was a long-awaited goal, a target I had kept postponing for too long. I’ve been working with Java a good 8+ years, mainly on building automation frameworks, but in reality, this exam was a whole new ballgame for me. It took me two attempts to pass, so prepare yourself to dedicate a lot of time and to keep going even when faced with difficulties.

As for how long it takes to prepare, that’s hard to say right away, since it really depends on your current workload and how many hours per day you can dedicate. In my case, I devoted more than three months entirely to focused preparation for this exam.

First, let’s review what it takes to pass the exam, and then we’ll consider the benefits you can gain from it.

Effective Study Materials and Approaches

The exam has been popular for years, leading to a wide demand for quality study resources. Fortunately, there are many options available, and I found that the following are among the most effective:

1. Complete Study Guide:

OCP Oracle Certified Professional Java SE 11 Developer Complete Study Guide by Scott Selikoff and Jeanne Boyarsky is, in my opinion, the best resource for preparation. It covers 100% of the exam objectives for exams 1Z0-819, 1Z0-815, 1Z0-816, and the upgrade exam 1Z0-817.

The book provides clear explanations for each topic, with practice questions after every chapter, totaling 22 chapters. It also includes 4 full practice exams, which can be taken through the Wiley Efficient Learning portal, allowing you to take these exams and chapter review questions online in an environment that closely resembles the actual exam you'll face.

The guide is split into two parts, each consisting of 11 chapters. The reason it’s organized this way is due to recent changes in Oracle’s certification structure. In October 2020, Oracle moved from separate exams (1Z0-815 and 1Z0-816) to a single exam (1Z0-819). Before this change, passing both exams was required to earn certification. Now, a single exam (1Z0-819) covers the topics of both previous exams, minus some removed topics. This explains why the book is split into two parts, each aligned with the previous exam structure.

A key thing I wish I knew earlier. Initially, I bought the OCP Oracle Certified Professional Java SE 11 Programmer I Study Guide: Exam 1Z0-815, thinking I needed to study both parts separately. Later, I realized that this was unnecessary and a waste of money, because Oracle’s latest exams consolidate the objectives of both parts into one. It’s more cost-effective and efficient to buy the Complete Study Guide right away, as it covers both previous exams in a single resource. Incidentally, the second book OCP Oracle Certified Professional Java SE 11 Programmer II Study Guide: Exam 1Z0-816 and Exam 1Z0-187, has become quite hard to find nowadays. As you might have guessed, it’s much wiser to buy the Complete Study Guide right from the start.

For studying, I find that having both formats can be very helpful. The platforms like Amazon offer the choice between eBook and paperback editions. In the early stages, the printed book is great for practicing tests, highlighting key points, and making handwritten notes to reinforce understanding. The eBook, on the other hand, makes it easy to copy code snippets, save notes, and quickly find information. And combining both approaches helps organize your preparation effectively and saves time during last-minute review. Ultimately, everyone has their own preferences, so you should choose what works best for you.

2. Udemy courses by Tim Buchalka:

These video series, part 1 and part 2, are a valuable supplement to your study plan. They include theory, practical demonstrations, and quick quizzes after each section, making complex topics easier to understand and remember. They’re especially useful for reviewing tough topics after going them through the Complete Study Guide.

The exam includes challenging topics like Concurrency, I/O, and NIO.2. I strongly recommend dedicating additional time to brushing up on these areas. Watching the relevant videos in these series can help you grasp the concepts more clearly and prepare more confidently for questions on these topics.

3. Practice Tests and Virtual Simulators:

Thorough exam preparation requires extensive practice with mock questions and simulators. These tools not only help identify weak spots but also improve time management and help you get comfortable with the exam format.

One of the most valuable resources for me was the paper book OCP Oracle Certified Professional Java SE 11 Developer Practice Tests: Exam 1Z0-819 and Upgrade Exam 1Z0-817 by Scott Selikoff and Jeanne Boyarsky. A book from the same authors as the previously mentioned study guide. It contains over 1,000 questions across 13 goal-based chapters and includes 3 full-length practice exams. It's perfect for practicing without the pressure of a timer, using pencil and eraser to thoroughly review each question. And, just like the study guide, you can register on the Wiley Efficient Learning portal to access all practice tests online.
A key part of my preparation was using multiple practice platforms. I started with Enthuware's mock exams, known for their high difficulty. So, I didn’t complete all of them, but they were invaluable for identifying my weak spots, deepening my understanding, and getting familiar with the exam’s challenging nature. Additionally, I found a simulator on Udemy, based on the author’s personal experience, featuring around 100 questions covering a wide range of topics with detailed explanations after each question.

The main benefit of such simulators is that they replicate the pressure and difficulty of the real exam, helping you to normalize the test environment. Regularly doing these tests builds confidence, improves timing, and reduces exam anxiety. I recommend scheduling multiple tries, each with a timer, to simulate real exam conditions. This way, you get used to managing your time effectively and ensure you're mentally prepared.

Throughout my preparation, I completed countless of questions, making a daily 90-minute Java quiz part of my routine. This consistent effort turned practicing into a ritual, which eventually reassured me that I was on the right track.

The Real Exam Itself

The first step is purchasing the exam attempt. Each attempt is single-use, so if you fail, you’ll need to buy another. To pass, you must score at least 68%. You’ll face 50 multiple-choice questions in just 90 minutes, so effective time management is crucial. To this end, developing a clear strategy for answering questions and pacing yourself can greatly improve your chances.

Moreover, Oracle provides important instructions and short video tutorials that can be found here. They cover everything from the process of purchasing the attempt, passing the exam readiness check, to testing your computer for compliance with the exam requirements. Watching these materials is essential to ensure you are fully prepared both mentally and technically for the real test.

The exam costs between $240 and $300, depending on your location. It’s not cheap, so it’s wise to treat it as a key part of your Personal Development Plan and discuss the possibility of sponsorship with your company's management. Many organizations, especially those involved in Java enterprise projects, highly value industry certifications and actively encourage their engineers to pursue them for professional growth.

To give you a clearer picture, here is my story. To start, the exam is strictly supervised: your camera must be on, the screen shared, and it’s just you in the room, no extra voices or talking. If you have pets or noisy neighbors, consider that in advance and find a quiet spot. Support staff may make comments or ask questions during the session, such as requesting your email, so just be prepared for that.

My first attempt was pretty uncomfortable. I mean, the silence, constant focus on the screen, and the pressure were a lot to handle, honestly, I wasn’t fully prepared for that kind of atmosphere. My approach to answering questions was unclear, so I spent too much time on some, and out of anxiety, I started changing answers near the end.

But, the second time was completely different story. I knew what to expect and had a clear plan. Here’s what worked for me:

First, instead of strictly tracking time, I focused on pacing. If I felt stuck on a question, I quickly decided whether to mark it for review without an answer or make an educated guess and also mark it. The goal was to avoid getting bogged down and missing easier questions, to attempt all 50 questions, and to have approximately 30 minutes left for reviewing the more challenging ones.
Second, in addition to the above, I only marked unsure questions for review later. Remember, it’s always worth making an educated guess, since unanswered questions guarantee zero points.

These strategies helped me manage my time effectively, avoid getting stuck on difficult questions, and approach the exam with a sense of control. Just to clarify, in both attempts, I received the results immediately after finishing, with no delays.

Make sure to read each question carefully, reading several times if needed. The exam creators often make questions tricky to throw you off, so learning to spot their tricks is key to passing. And of course, practicing with mock tests sharpens your eye for common errors and patterns in code, helping you focus your attention where it’s needed most. Building this skill can make a big difference in quickly identifying mistakes and selecting the correct answer with confidence.

Is It Worth the Effort?

If you’re considering whether to pursue this certification, ask yourself: do you want to have an official proof of your skills? Want to stand out during a recruitment process? Or maybe you aim to explore Java APIs more deeply, fill in gaps in your knowledge, or get familiar with the latest language features? Perhaps you want to learn to read code faster, review it more effectively, or simply boost your confidence after a challenging achievement. And beyond that, many find that preparing for the exam motivates them to write articles, join discussions, and engage more actively in the tech community.

So, what did I really gain from this experience? Something even better! It significantly enhanced my Java expertise. Of course, it involved digging deeper into the fundamentals, but it also meant tackling technologies less commonly encountered in daily work. I'm referring to the less-traveled corners of the Java ecosystem: JDBC, Serialization, Java Platform Module System, Parallel Streams, and even intricate aspects of the Reflection API. Furthermore, working with Concurrency: diving into Threads, Runnables, Callables, and ExecutorServices, and understanding thread-safe code and how to avoid common concurrency issues like race conditions, deadlocks, and thread starvation.

The truth is, the path isn’t easy. Preparation was intense, and I had to make sacrifices — yes, it cost me both time and money. But looking back, I can confidently say that every minute and every penny was worth it. Not just the final certification, but the journey itself, along with all the challenges faced and the knowledge gained, made it truly valuable. Most importantly, I proved to myself that perseverance and determination truly pay off and that I am ready to go to the next stage.

If you found this article helpful, it means there’s more to come. Stay tuned for the next series of Java articles, where I’ll share even more insights on core Java topics. I’ll give you the information and tools you need to deepen your understanding of the language and be well-prepared for challenging technical interviews — or at least give you a solid foundation for building something awesome.

DEV Community: Marta Kravchuk

Arrays in Java: A Deep Dive

Table of Contents

1. Array Declarations

Valid Array Declarations:

Invalid Array Declarations:

2. Creating an Array

Valid Array Creation Statements:

Invalid Array Creation Statements:

3. Working with Arrays

Sorting Arrays

Searching Arrays

Comparing Arrays

4. Shallow Copy vs. Deep Copy

Shallow Copy

Deep Copy

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. 😊

Mastering String APIs in Java

Table of Contents

1. Working with String Objects

Concatenation

Immutability and the String Pool

Essential String Methods and the Method Chaining

2. Manipulate Data Using the StringBuilder Class

StringBuilder Methods

3. Understanding Equality: String vs. StringBuilder

Equality Comparison in Java: String

Equality Comparison in Java: StringBuilder

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. Stay tuned here for a new Java series every week! And feel free to connect with me on LinkedIn 😊

Garbage Collection in Java: A Simple Explanation

Table of Contents

1. What is Java Garbage Collection?

2. Suggesting Garbage Collection with System.gc()

3. Why the Deprecated finalize() Should Be Avoided

How the finalize() method worked:

Problems with finalize() method:

Alternatives:

4. Modern Resource Management Techniques

Conclusion

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. Stay tuned here for a new Java series every week! And feel free to connect with me on LinkedIn 😊

Java Variables: A Complete Guide (feat. var Type Inference)

Table of Contents

1. What is a Variable?

Variable Types

Declaring and Initializing Variables

Naming Conventions and Legal Identifiers for Variables

2. Variable Scope and Lifetime

2.1. Class Variables (Static Fields)

2.2. Instance Variables (Non-Static Fields)

2.3. Local Variables

3. Local Variable Type Inference (var)

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. Stay tuned here for a new Java series every week! And feel free to connect with me on LinkedIn 😊

Java Data Types: A Quick Reference Guide

This article offers concise technical Java notes, covering primitive and reference types, literals, type conversion rules, and more. Whether you're preparing for an interview or seeking a quick refresher, this guide provides essential insights.

Table of Contents

1. Primitive Types

Key Differences: short vs. char

Literals

Declaring Primitive Types

Declaring float and double

Type Conversion Rules

2. Reference Types

Key Differences: Primitives vs. References

3. Wrapper Classes

Common Methods:

Autoboxing and Unboxing:

Thanks for reading! Hope you found some useful info in this article. Got any questions or ideas? Drop them in the comments below. More cool Java stuff is coming soon!

The Path to OCP Java SE 11 Certification (1Z0-819): What It Takes and How I Did It

Effective Study Materials and Approaches

1. Complete Study Guide:

2. Udemy courses by Tim Buchalka:

3. Practice Tests and Virtual Simulators:

The Real Exam Itself

Is It Worth the Effort?

1. Working with `String` Objects

Essential `String` Methods and the Method Chaining

2. Manipulate Data Using the `StringBuilder` Class

3. Understanding Equality: `String` vs. `StringBuilder`

Equality Comparison in Java: `String`

Equality Comparison in Java: `StringBuilder`

2. Suggesting Garbage Collection with `System.gc()`

3. Why the Deprecated `finalize()` Should Be Avoided

How the `finalize()` method worked:

Problems with `finalize()` method:

Key Differences: `short` vs. `char`

Declaring `float` and `double`