ā† Back to All Data Structures

Arrays & Strings

šŸŽÆ Explain Like I'm 5...

Imagine you have a row of toy boxes lined up on a shelf! Each box has a number (like 0, 1, 2, 3...) and you can put one toy in each box.

šŸ“¦ Arrays - A Row of Boxes:

  • ā€¢ Box 0: Put a red car šŸš—
  • ā€¢ Box 1: Put a blue ball āš½
  • ā€¢ Box 2: Put a yellow duck šŸ¦†

To get the ball, just say 'Give me what's in box 1!' Super fast! āš”

šŸ”¤ Strings - Letters in Boxes:

A string is just an array of letters! The word 'CAT' is like having 3 boxes:

  • ā€¢ Box 0: 'C'
  • ā€¢ Box 1: 'A'
  • ā€¢ Box 2: 'T'

šŸš€ Why Are They Useful?

  • ā€¢ Arrays let you find things super fast if you know the box number!
  • ā€¢ Strings let you work with words and sentences in your programs!
  • ā€¢ Both are the building blocks for almost everything in programming!

šŸ”§ Basic Operations

Creating an Array

ArrayBasics.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ArrayBasics {
    public static void main(String[] args) {
        // Creating an array - like setting up toy boxes!
        int[] numbers = new int[5];  // 5 empty boxes
        // Creating with values
        int[] myToys = {10, 20, 30, 40, 50};  // 5 boxes with toys!
        // String array
        String[] colors = {"red", "blue", "green"};
        System.out.println("First number: " + myToys[0]);  // Output: 10
        System.out.println("First color: " + colors[0]);   // Output: red
    }
}

Accessing Elements (Getting toys from boxes)

ArrayAccess.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ArrayAccess {
    public static void main(String[] args) {
        int[] scores = {85, 90, 78, 92, 88};
        // Access elements by index (box number)
        System.out.println("First score: " + scores[0]);   // 85
        System.out.println("Third score: " + scores[2]);   // 78
        System.out.println("Last score: " + scores[4]);    // 88
        // Loop through all elements
        System.out.println("All scores:");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("Score " + i + ": " + scores[i]);
        }
        // Enhanced for loop (easier way!)
        System.out.println("\nUsing enhanced for:");
        for (int score : scores) {
            System.out.println(score);
        }
    }
}

Updating Elements (Putting new toys in boxes)

ArrayUpdate.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ArrayUpdate {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println("Before: " + numbers[0]);  // 1
        // Update element (put new toy in box!)
        numbers[0] = 100;
        System.out.println("After: " + numbers[0]);   // 100
        // Update multiple elements
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = numbers[i] * 2;  // Double each number!
        }
        System.out.println("Doubled array:");
        for (int num : numbers) {
            System.out.print(num + " ");  // 200 4 6 8 10
        }
    }
}

šŸ“ String Operations

String Basics

StringBasics.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class StringBasics {
    public static void main(String[] args) {
        // Creating strings
        String name = "Alice";
        String greeting = "Hello";
        // String length (how many letters?)
        System.out.println("Length: " + name.length());  // 5
        // Access character at index
        System.out.println("First letter: " + name.charAt(0));  // A
        System.out.println("Last letter: " + name.charAt(4));   // e
        // Concatenation (joining strings)
        String message = greeting + " " + name + "!";
        System.out.println(message);  // Hello Alice!
        // String comparison
        String word1 = "cat";
        String word2 = "cat";
        String word3 = "dog";
        System.out.println(word1.equals(word2));  // true
        System.out.println(word1.equals(word3));  // false
    }
}

String Manipulation

StringManipulation.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class StringManipulation {
    public static void main(String[] args) {
        String text = "Hello World";
        // Convert to uppercase/lowercase
        System.out.println(text.toUpperCase());  // HELLO WORLD
        System.out.println(text.toLowerCase());  // hello world
        // Substring (get part of string)
        System.out.println(text.substring(0, 5));  // Hello
        System.out.println(text.substring(6));     // World
        // Replace characters
        System.out.println(text.replace('o', '0'));  // Hell0 W0rld
        // Check if string contains something
        System.out.println(text.contains("World"));  // true
        System.out.println(text.contains("Java"));   // false
        // Split string into array
        String sentence = "I love Java";
        String[] words = sentence.split(" ");
        for (String word : words) {
            System.out.println(word);  // I, love, Java
        }
        // StringBuilder for building strings efficiently
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        System.out.println(sb.toString());  // Hello World
    }
}

šŸ’” Common Problems & Solutions

Problem 1: Reverse an Array

Flip the order of elements - like reading your toy boxes from right to left!

šŸ’” How it works:

Step 1: Use two pointers - one at start (left), one at end (right)

Step 2: Swap the elements at these positions

Step 3: Move left pointer right, right pointer left

Step 4: Repeat until pointers meet in middle

Example: [1, 2, 3, 4, 5] ā†’ [5, 4, 3, 2, 1]

ā±ļø Time Complexity: O(n) - visit each element once

šŸ’¾ Space Complexity: O(1) - no extra space needed

ReverseArray.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class ReverseArray {
    public static void reverse(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        // Swap elements from both ends moving towards center
        while (left < right) {
            // Swap
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.print("Before: ");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        reverse(numbers);
        System.out.print("\nAfter: ");
        for (int num : numbers) {
            System.out.print(num + " ");  // 5 4 3 2 1
        }
    }
}

Problem 2: Check if String is Palindrome

A palindrome reads the same forwards and backwards, like 'racecar' or 'mom'!

šŸ’” How it works:

Step 1: Clean the string (lowercase, remove spaces)

Step 2: Use two pointers - one at start, one at end

Step 3: Compare characters at both positions

Step 4: If they don't match, it's NOT a palindrome

Step 5: Move pointers towards center and repeat

Examples:

āœ… "racecar" ā†’ r-a-c-e-c-a-r (same forwards & backwards)

āœ… "mom" ā†’ m-o-m (same both ways)

āŒ "hello" ā†’ h-e-l-l-o vs o-l-l-e-h (different)

ā±ļø Time Complexity: O(n) - check each character

šŸ’¾ Space Complexity: O(1) - only use pointers

Palindrome.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Palindrome {
    public static boolean isPalindrome(String str) {
        // Clean string: remove spaces and make lowercase
        str = str.toLowerCase().replaceAll(" ", "");
        int left = 0;
        int right = str.length() - 1;
        while (left < right) {
            if (str.charAt(left) != str.charAt(right)) {
                return false;  // Not matching!
            }
            left++;
            right--;
        }
        return true;  // All characters matched!
    }
    public static void main(String[] args) {
        System.out.println(isPalindrome("racecar"));  // true
        System.out.println(isPalindrome("hello"));    // false
        System.out.println(isPalindrome("A man a plan a canal Panama"));  // true
        System.out.println(isPalindrome("mom"));      // true
    }
}

Problem 3: Find Maximum in Array

Find the biggest number in your array - like finding the tallest toy!

šŸ’” How it works:

Step 1: Start by assuming the first element is the maximum

Step 2: Look at each other element one by one

Step 3: If you find a bigger number, update the maximum

Step 4: After checking all elements, you have the maximum!

Visual Example:

Array: [3, 7, 2, 9, 1, 5]

ā€¢ Start: max = 3

ā€¢ Check 7: bigger! ā†’ max = 7

ā€¢ Check 2: smaller, skip

ā€¢ Check 9: bigger! ā†’ max = 9

ā€¢ Check 1: smaller, skip

ā€¢ Check 5: smaller, skip

āœ… Final answer: 9

ā±ļø Time Complexity: O(n) - check every element

šŸ’¾ Space Complexity: O(1) - only store one max value

FindMaximum.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class FindMaximum {
    public static int findMax(int[] arr) {
        if (arr.length == 0) {
            throw new IllegalArgumentException("Array is empty!");
        }
        int max = arr[0];  // Assume first is biggest
        // Check all others
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];  // Found bigger one!
            }
        }
        return max;
    }
    public static void main(String[] args) {
        int[] numbers = {3, 7, 2, 9, 1, 5};
        int maximum = findMax(numbers);
        System.out.println("Maximum: " + maximum);  // 9
        // Also find minimum
        int min = numbers[0];
        for (int num : numbers) {
            if (num < min) {
                min = num;
            }
        }
        System.out.println("Minimum: " + min);  // 1
    }
}

Problem 4: Two Sum Problem

Find two numbers that add up to a target - a classic interview question!

šŸ’” How it works:

The Challenge: Find two numbers that add up to a target number

Smart Solution (Using HashMap):

Step 1: For each number, calculate what we NEED to make the target

(complement = target - current number)

Step 2: Check if we've seen that complement before (in HashMap)

Step 3: If yes, we found our pair! Return both indices

Step 4: If no, store current number in HashMap and continue

Visual Example:

Array: [2, 7, 11, 15], Target: 9

i=0: num=2, need 9-2=7, not in map yet ā†’ store {2:0}
i=1: num=7, need 9-7=2, found in map! āœ…
Return [0, 1] ā†’ numbers[0] + numbers[1] = 2 + 7 = 9

Why HashMap?

ā€¢ Checking if number exists: O(1) super fast!

ā€¢ Better than checking every pair: O(nĀ²) slow

ā±ļø Time Complexity: O(n) - one pass through array

šŸ’¾ Space Complexity: O(n) - HashMap stores numbers

TwoSum.java
java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.HashMap;
public class TwoSum {
    public static int[] twoSum(int[] nums, int target) {
        // HashMap to store number and its index
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            // Check if complement exists in map
            if (map.containsKey(complement)) {
                return new int[]{map.get(complement), i};
            }
            // Store current number and index
            map.put(nums[i], i);
        }
        return new int[]{-1, -1};  // Not found
    }
    public static void main(String[] args) {
        int[] numbers = {2, 7, 11, 15};
        int target = 9;
        int[] result = twoSum(numbers, target);
        if (result[0] != -1) {
            System.out.println("Indices: " + result[0] + ", " + result[1]);
            System.out.println("Numbers: " + numbers[result[0]] + " + " +
                             numbers[result[1]] + " = " + target);
            // Output: 2 + 7 = 9
        }
    }
}

šŸ”‘ Key Points to Remember

  • 1ļøāƒ£Arrays have fixed size (can't easily add more boxes)
  • 2ļøāƒ£Accessing by index is O(1) - super fast!
  • 3ļøāƒ£Strings in Java are immutable (can't change, must create new ones)
  • 4ļøāƒ£Arrays are zero-indexed (first element is at index 0)

šŸ’Ŗ Practice Problems

  • ā€¢ Remove duplicates from sorted array
  • ā€¢ Rotate array by K positions
  • ā€¢ Longest substring without repeating characters
  • ā€¢ Valid anagram
  • ā€¢ Merge two sorted arrays