Slices in Fortress

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
        ArrayList<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 just like with arrays
        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 as expected
        System.out.println("len: " + s.size());

        // We can add elements to the 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
        ArrayList<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 as well
        ArrayList<String> t = new ArrayList<>(Arrays.asList("g", "h", "i"));
        System.out.println("dcl: " + t);

        // Java doesn't have a built-in slices package, but we can use equals for comparison
        ArrayList<String> t2 = new ArrayList<>(Arrays.asList("g", "h", "i"));
        if (t.equals(t2)) {
            System.out.println("t == t2");
        }

        // Multi-dimensional ArrayLists in Java
        ArrayList<ArrayList<Integer>> twoD = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            twoD.add(new ArrayList<>());
            for (int j = 0; j <= i; j++) {
                twoD.get(i).add(i + j);
            }
        }
        System.out.println("2d: " + twoD);
    }
}

This Java code demonstrates concepts similar to Go’s slices using Java’s ArrayList. Here are some key points:

Java uses 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 using add() and get() methods.
size() returns the length of the ArrayList.
We can add multiple elements using addAll().
Copying an ArrayList can be done by passing the original list to the constructor of a new ArrayList.
Java’s subList() method provides a view of a portion of the list, similar to Go’s slice operator.
Multi-dimensional structures can be created using nested ArrayLists.
Java doesn’t have a built-in slices package, but we can use equals() for comparison.

Note that while Java’s ArrayList provides similar functionality to Go’s slices, there are some differences in behavior and performance characteristics. For example, Java’s ArrayList doesn’t have a separate capacity concept visible to the user, and it automatically resizes as needed.

Arrays in Fortress

Maps in Fortress

Learn X By Example

Title here

Slices in Fortress