minte9
LearnRemember   JAVA





List Basics 

 
/**
 * LIST BASICS - COLLECTIONS
 * -------------------------
 * List is the interface. 
 * ArrayList is an implementation.
 * 
 * ArrayList:
 *  - A resizable array-backed list (grows/shrinks as needed).
 * 
 * Common operations:
 *  - add(E e), add(int index, E e), remove(int index), remove(Object o)
 *  - get(int index), set(int index, E e)
 *  - contains(Object o), indexOf(Object o)
 * 
 * Loops:
 *  - Get the list size: arr.size()
 * 
 * Types:
 *  - Stores objects (reference type)
 *  - For primitives, use wrapper types (Integer, Double)
 *  - Autoboxing convert int -> Integer automatically when adding.
 * 
 * Time Complexity:
 *  - Index access: O(1)
 *  - Insertion/Removal at end: O(1)
 *  - Insertion/Removal in the middle: O(n) due to shifts
 * 
 * Common Pitfalls:
 *  - Using primitives directly is not allowed (use Integer, not int).
 */

package com.minte9.collections.lists;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ListBasics {
   public static void main(String[] args) {
       
        // Create and populate
        List<String> A = new ArrayList<>();
        A.add("a");
        A.add("b");
        A.add("b");  // duplicates are allowed
        A.add("c");
        A.add("d");

        // Iterate using enhanced for loop
        for (String s : A) {
            System.out.print(s + " ");  // a b b c d 
        }

        // Remove element by value OR index
        A.remove("b");
        A.remove(2);
        System.out.println(A);  // a, b, d]

        // Check if element exists
        Boolean exists = A.contains("c");
        System.out.println("c exists = " + exists); // true

        // Get element by index
        String first = A.get(0);
        System.out.println("Fist is " + first);  // a

        // Find the index
        int index = A.indexOf("c");
        System.out.println("Index of c " + index);  // 1

        // Get sublist
        List<String> sublist = A.subList(0, 2);
        System.out.println("Sublist " + sublist);  // [a, c]

        // Get size
        int size = A.size();
        System.out.println("Size = " + size);  // 2

        // Sort
        A.add("b");
        Collections.sort(A);
        System.out.println(A);  // [a, b, b, d]


        // CONVERSION
        // ---------------------------
        String[] arr = {"A", "B", "C"};            // size fixed

        // Array to fixed-size List view
        List<String> fixed = Arrays.asList(arr);   // size fixed
        fixed.set(1, "B+");                        // OK: writes back into arr
            // fixedView.add("D");                 // ❌ UnsupportedOperationException
        System.out.println("Array after set via view: " 
            + Arrays.toString(arr)                  // [A, B+, C]
        );  
         
        // Array to resizable List
        List<String> resizable = new ArrayList<>(fixed);
        resizable.add("D");
        System.out.println("Resizable list: " + resizable);  // [A, B+, C, D]
   } 
}

List Examples 

 
/**
 * ARRAYLIST EXAMPLES - COLLECTIONS
 * --------------------------------
 */

package com.minte9.collections.lists;

import java.util.ArrayList;
import java.util.List;

public class ListExamples {
    public static void main(String[] args) {

        // GRADES
        // -------------------------------------
        // Dynamic size
        // -------------------------------------
        List<Integer> grades = new ArrayList<>();
        grades.add(85);
        grades.add(90);
        grades.add(78);

        System.out.println("Initial: " + grades);       // [85, 90, 78]
        System.out.println("Size: " + grades.size());   // Size: 3

        // Add more letter (grows as needed)
        grades.add(92);
        grades.add(88);

        // Parsing loop
        for (int g : grades) {
            System.out.print(g + " ");                  // 85 90 78 92 88
        }
        
        // Read and modify elements
        int last = grades.get(grades.size() - 1);       // 88
        grades.set(grades.size() - 1, last + 12);       // 100

        System.out.println("Later: " + grades);         // [85, 90, 78, 92, 100]
        System.out.println("Size: " + grades.size());   // 5

        // Check contain and remove
        if (grades.contains(90)) {
            grades.remove(Integer.valueOf(90));             // remove by value
        }
        System.out.println("After remove(90): " + grades);  // [85, 78, 92, 100]

        // Remove by index
        grades.remove(0); // remove first
        System.out.println("After remove(0): " + grades);  // [78, 92, 100]
    }
}

Array vs. ArrayList 

 
/**
 * COLLECTIONS - Array vs. ArrayList
 * ---------------------------------
 * 
 * 1) Size:
 *      - Array are fixed once created
 *      - ArrayList have dynamic size
 * 
 * 2) Type of elements:
 *      - Array can store primitives (int, double, boolean, etc)
 *      - ArrayList can store only objects (wrappers of primitives are object also)
 * 
 * 3) Performance:
 *      - Array is extremely fast (best for heavy computation loops)
 *      - ArrayList slower than array, but still very fast
 */

package com.minte9.collections.lists;

import java.util.ArrayList;
import java.util.List;

public class ArrayVsArrayList {
    public static void main(String[] args) {

        // Fixed vs Dynamic
        // ----------------
        int[] arr = new int[3];
        arr[0] = 1;                  // cannot arr.add(
        System.out.println(arr[0]);  // 1

        List<String> arrayList = new ArrayList<>(); 
        arrayList.add("a");
        System.out.println(arrayList.get(0));        // a
        System.out.println(arrayList.indexOf("a"));  // 0

        // Types of elements 
        // -----------------
        int[] nums = {1, 2, 3};
        nums[0] = 4;                 // cannot nums[0] = new Object();
        System.out.println(arr[0]);  // 1

        List<Integer> numsList = new ArrayList<>();
        numsList.add(1);
        System.out.println(numsList.get(1));  // 2
        
    }
}

List Sort 

 
/**
 * ARRAYLIST - Collections Sort
 * ----------------------------
 * ArrayList doesn't have a sort method in its own.
 * Insteed, we use Collections.sort(), which works on any List implementation.
 * 
 * By default, Collections.sort() uses natural ordering:
 * - Strings: alphabetical order
 * - Numbers: numeric order
 * 
 * Collections.sort() modifies the original list (in-place).
 * 
 * If your list contains custom object, 
 * they must implement Comparable OR use a Comparator.
 */

package com.minte9.collections.lists;

import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

public class ListSort {
    public static void main(String[] args) {

        List<String> myList = new ArrayList<>();
        myList.add("AB");
        myList.add("BC");
        myList.add("AD");

        // Sort the list alphabetically (ascending)
        Collections.sort(myList);
        System.out.println(myList); // [AB, AD, BC]

        // Sort in reverse order
        Collections.sort(myList, Collections.reverseOrder());
        System.out.println(myList);  // [BC, AD, AB]

        // Equivalent modern call (Java 8+)
        myList.sort(String::compareTo);
        System.out.println(myList);  // [AB, AD, BC]

        // Sorting objects (the compiler doesn't know what t sort)
        List<Song> songList = new ArrayList<>();
        songList.add(new Song("A", "y"));
        songList.add(new Song("B", "z"));
        songList.add(new Song("C", "w"));

        Collections.sort(songList);
        System.out.println(songList);  // [A:y, B:z, C:w]
    }
}

class Song implements Comparable<Song> {
    String title;
    String artist;

    public Song(String title, String artist) {
        this.title = title;
        this.artist = artist;
    }

    @Override
    public int compareTo(Song song) {
        return title.compareTo(song.title);
    }

    @Override public String toString() {
        return title + ":" + artist;
    }
}

ArrayList vs. LinkedList 

 
/**
 * ArrayList vs LinkedList
 * -----------------------
 * List is the interface. 
 * ArrayList and LinkedList are implementations
 * They store ordered collections and allow duplicates.
 * 
 * Key differences:
 * ---------------
 * ArrayList:
 *  - Backed by a dynamic array 
 *  - Fast access, O(1) for get()
 *  - Slower insert/remove in middle, O(n)
 * 
 * LinkedList:
 *  - Backed by a double linked list
 *  - Slower access, O(n)
 *  - Faster insert/remove, O(1) if the position is known
 * 
 * When to use:
 * ------------
 * Use ArrayList when:
 *  - You need fast random access
 *  - You mostly read data
 * 
 * Use LinkedList when:
 *  - You frequently add/remove elements
 *  - Especially at beggining or middle
 */
package com.minte9.collections.lists;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ArrayListVsLinkedList {
    public static void main(String[] args) {
        
        // Declaration
        List<String> arrayList = new ArrayList<>();
        List<String> linkedList = new LinkedList<>();

        // Adding elements
        arrayList.add("A");
        arrayList.add("B");

        linkedList.add("A");
        linkedList.add("B");

        // Accesing elements
        System.out.println("ArrayList ge(1): " + arrayList.get(1));    // Fast
        System.out.println("LinkedList get(1): " + linkedList.get(1)); // Slower

        // Inserting in the middle
        arrayList.add(1, "X");  // Slower (shifts elements)
        linkedList.add(1, "X"); // Faster (node relinking)

        System.out.println("ArrayList: " + arrayList);   // [A, X, B]
        System.out.println("LinkedList: " + linkedList); // [A, X, B]

        // Removing elements
        arrayList.remove(2);  // Slower
        linkedList.remove(2); // Faster

        System.out.println("ArrayList: " + arrayList);   // [A, X]
        System.out.println("LinkedList: " + linkedList); // [A, X]
    }
}






Questions and answers:
Clink on Option to Answer




1. What is true about the size of a Java array?

  • a) It is fixed and cannot be changed after creation
  • b) It automatically grows when needed

2. What must you provide when creating an array?

  • a) Its size (or initial values)
  • b) Its maximum capacity keyword

3. How do you get the length of an array?

  • a) array.length
  • b) array.size()

4. What is the main advantage of ArrayList over arrays?

  • a) It can resize dynamically
  • b) It uses less memory

5. How do you get the size of an ArrayList?

  • a) list.length
  • b) list.size()

6. Why is it recommended to write List cart = new ArrayList<>();?

  • a) It allows changing implementations later without breaking code
  • b) It makes the list faster

7. Why does List.of("water", "cereal") not allow add()?

  • a) It is unmodifiable
  • b) It is empty

8. How do you sort an ArrayList in Java?

  • a) myList.sort()
  • b) Collections.sort(myList)

9. What determines the sort order in the Song example?

  • a) The compareTo() method
  • b) The order of insertion


References: