Arrays
An array is a fixed-size object that stores multiple values of the same type. Every array has a length determined at creation time that cannot be changed.int[] numbers = new int[5];Array Declaration
Arrays can be declared in multiple ways.int[] numbers;
String[] names;
Employee[] employees;int numbers[];Array Initialization
Arrays may be initialized during declaration.int[] numbers = {10, 20, 30, 40};int[] numbers = new int[3];
numbers[0] = 100;
numbers[1] = 200;
numbers[2] = 300;Default Values
Array elements receive default values.| Type | Default Value |
|---|---|
| Numeric | 0 |
| boolean | false |
| char | '\u0000' |
| Reference | null |
int[] values = new int[3];
System.out.println(values[0]);0Array Length
Every array exposes a public final length field.int[] numbers = {1, 2, 3};
System.out.println(numbers.length);3length field instead of a method.
Accessing Array Elements
Elements are accessed using zero-based indexing.int[] numbers = {10, 20, 30};
System.out.println(numbers[0]);
System.out.println(numbers[2]);Iterating Arrays
Arrays can be traversed using a traditional for loop.for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}for (int number : numbers) {
System.out.println(number);
}Multidimensional Arrays
Java supports multidimensional arrays.int[][] matrix = {
{1, 2, 3},
{4, 5, 6}
};System.out.println(matrix[1][2]);6Jagged Arrays
Java multidimensional arrays are actually arrays of arrays. Rows may have different lengths.int[][] values = {
{1, 2},
{3, 4, 5},
{6}
};Array Copying
Assigning one array variable to another copies only the reference.int[] first = {1, 2, 3};
int[] second = first;int[] copy = Arrays.copyOf(first, first.length);int[] copy = first.clone();System.arraycopy(first, 0, copy, 0, first.length);Comparing Arrays
The== operator compares references.
int[] a = {1, 2};
int[] b = {1, 2};
System.out.println(a == b);falseArrays.equals(a, b);Arrays.deepEquals(array1, array2);Arrays Utility Class
The Arrays class provides common operations.Arrays.sort(numbers);
Arrays.binarySearch(numbers, 30);
Arrays.fill(numbers, 100);
Arrays.copyOf(numbers, 5);
Arrays.equals(a, b);
Arrays.toString(numbers);Variable-Length Arrays
Method parameters can accept arrays of variable size using varargs.void print(int... values) {
for (int value : values) {
System.out.println(value);
}
}Strings
A String represents an immutable sequence of Unicode characters.String language = "Java";String Creation
Strings can be created using literals.String language = "Java";String language = new String("Java");String Pool
Java maintains a special memory area called the String Pool. Identical string literals share the same object.String a = "Java";
String b = "Java";
System.out.println(a == b);trueString a = "Java";
String b = new String("Java");
System.out.println(a == b);falseString Immutability
Strings are immutable.String text = "Java";
text.concat(" Programming");
System.out.println(text);Javatext = text.concat(" Programming");String Comparison
Useequals() to compare contents.
String a = "Java";
String b = new String("Java");
System.out.println(a.equals(b));true== operator compares object references.
System.out.println(a == b);falsea.equalsIgnoreCase(b);Common String Methods
Frequently used String methods include:text.length();
text.isEmpty();
text.isBlank();
text.charAt(0);
text.substring(1, 4);
text.contains("Java");
text.startsWith("Ja");
text.endsWith("va");
text.indexOf("a");
text.lastIndexOf("a");
text.replace("Java", "Python");
text.toUpperCase();
text.toLowerCase();
text.trim();
text.strip();
text.repeat(3);
text.split(",");
text.matches(regex);String Concatenation
Strings can be concatenated using the + operator.String fullName = firstName + " " + lastName;concat().
String fullName = firstName.concat(lastName);StringBuilder
StringBuilder provides mutable strings.StringBuilder builder = new StringBuilder();
builder.append("Java");
builder.append(" Programming");
String result = builder.toString();StringBuffer
StringBuffer is similar to StringBuilder but provides synchronized methods.StringBuffer buffer = new StringBuffer();
buffer.append("Java");StringBuilder vs StringBuffer
- Use StringBuilder for single-threaded code.- Use StringBuffer only when synchronized mutable strings are explicitly required.
- Most modern applications use StringBuilder.
String Formatting
Java supports formatted strings.String message = String.format(
"Employee: %s Age: %d",
"John",
30
);Text Blocks
Java supports Text Blocks for multiline strings.String query = """
SELECT *
FROM employees
WHERE active = true
""";String Interning
Theintern() method returns the pooled String representation.
String a = new String("Java");
String b = a.intern();Character Encoding
Internally, Java Strings represent Unicode characters. Conversion between Strings and byte arrays requires a character encoding.byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
String value = new String(bytes, StandardCharsets.UTF_8);
Performance Considerations
Array element access provides constant-time performance. String concatenation inside loops repeatedly creates new immutable objects and should be avoided.StringBuilder builder = new StringBuilder();
for (String word : words) {
builder.append(word);
}Final Notes
Arrays provide fixed-size indexed storage with efficient random access, while Strings provide immutable text handling with extensive built-in functionality.Understanding array copying, multidimensional arrays, the String Pool, String immutability, String comparison, and choosing between String, StringBuilder, and StringBuffer is fundamental for writing efficient, reliable, and maintainable Java applications.
