Slices in Karel

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

public class Slices {
    public static void main(String[] args) {
        // In Java, we use ArrayList as a dynamic array, which is similar to slices in Go
        // An uninitialized ArrayList is empty but not null
        List<String> s = new ArrayList<>();
        System.out.println("uninit: " + s + " " + s.isEmpty() + " " + (s.size() == 0));

        // To create an empty ArrayList with non-zero capacity, we can use the constructor
        s = new ArrayList<>(3);
        System.out.println("emp: " + s + " len: " + s.size() + " cap: " + ((ArrayList<String>) s).ensureCapacity(3));

        // We can add and get elements from ArrayList
        s.add("a");
        s.add("b");
        s.add("c");
        System.out.println("set: " + s);
        System.out.println("get: " + s.get(2));

        // size() returns the length of the ArrayList
        System.out.println("len: " + s.size());

        // We can add elements to ArrayList using add method
        s.add("d");
        s.addAll(Arrays.asList("e", "f"));
        System.out.println("apd: " + s);

        // We can create a copy of an ArrayList
        List<String> c = new ArrayList<>(s);
        System.out.println("cpy: " + c);

        // In Java, we can use subList to get a view of a portion of the list
        List<String> l = s.subList(2, 5);
        System.out.println("sl1: " + l);

        l = s.subList(0, 5);
        System.out.println("sl2: " + l);

        l = s.subList(2, s.size());
        System.out.println("sl3: " + l);

        // We can declare and initialize an ArrayList in a single line
        List<String> t = new ArrayList<>(Arrays.asList("g", "h", "i"));
        System.out.println("dcl: " + t);

        // In Java, we can use equals method to compare lists
        List<String> t2 = new ArrayList<>(Arrays.asList("g", "h", "i"));
        if (t.equals(t2)) {
            System.out.println("t == t2");
        }

        // We can create a 2D ArrayList in Java
        List<List<Integer>> twoD = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            int innerLen = i + 1;
            List<Integer> innerList = new ArrayList<>();
            for (int j = 0; j < innerLen; j++) {
                innerList.add(i + j);
            }
            twoD.add(innerList);
        }
        System.out.println("2d: " + twoD);
    }
}

This Java code demonstrates concepts similar to slices in Go, using ArrayList as the primary data structure. Here’s a breakdown of the key points:

We use ArrayList as a dynamic array, which is similar to slices in Go.
An uninitialized ArrayList is empty but not null.
We can create an ArrayList with a specific initial capacity.
Elements can be added and retrieved from an ArrayList.
The size() method returns the length of the ArrayList.
We can add multiple elements using addAll().
Copying an ArrayList can be done using the constructor.
subList() is used to get a view of a portion of the list, similar to slicing in Go.
We can declare and initialize an ArrayList in a single line using Arrays.asList().
The equals() method is used to compare lists.
We can create multi-dimensional lists (2D ArrayList) in Java.

Note that while Java’s ArrayList provides similar functionality to Go’s slices, there are some differences in syntax and available methods. The concept of capacity is not as prominent in Java’s ArrayList as it is in Go’s slices.

To run this program, save it as Slices.java, compile it with javac Slices.java, and then run it with java Slices. The output will demonstrate the various operations performed on the ArrayList.

Arrays in Karel

Maps in Karel

Learn X By Example

Title here

Slices in Karel