How to Use an Array List in Java

Create ArrayList from array

new ArrayList<>(Arrays.asList(array));

How does ArrayList work?

Internally an ArrayList uses an Object[].

As you add items to an ArrayList, the list checks to see if the backing array has room left. If there is room, the new item is just added at the next empty space. If there is not room, a new, larger, array is created, and the old array is copied into the new one.

Now, there is more room left, and the new element is added in the next empty space.

Since people really like the source code:

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer.
 */
private transient Object[] elementData;

Straight out of the JDK.

ArrayList initialization through List.of()

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

// ...
ArrayList<String> friends =  new ArrayList<>(List.of("Peter", "Paul"));

Is perfectly fine assuming you're running at least Java 9.

Prior to Java 9, you need to go for Arrays.asList() instead of List.of():

ArrayList<String> friends =  new ArrayList<>(Arrays.asList("Peter", "Paul"));

Arrays inside a Arraylist

Looks like you want to create a 2-dimansional integer array.

I assume you have a special use case in which you need a primitive array ob ArrayList-Objects.

Anyways you can create such a thing like any other primitive array
like

ArrayList<Integer>[] test = new ArrayList[2];

and access/set it by index..

test[0] = new ArrayList<Integer>();

You also can fill the array on init...

ArrayList<Integer>[] test = new ArrayList[] {
        new ArrayList<Integer>(),
        new ArrayList<Integer>(),
        new ArrayList<Integer>()
};

How to use a method in java to store information from an arraylist

There are two options to solve your problem:

Option(1): Your current ArrayList scope is local to the storage method because you are creating a brand new ArrayList on each call (to storage() method), but what you need is a static ArrayList object at class level as shown below, but because you are invoking storage() method using an object, this is not preferable option (explained below clearly) and compiler is already throwing a warning and you are ignoring it.

public class two {

    private static ArrayList<String> al = new ArrayList<String>();

    public static void storage(String toBeAdded)
    {
        al.add(toBeAdded);
        System.out.println(al);
    }
}

Option(2) (Prefer this): Remove the static scope and declare ArrayList<String> as an instance variable as shown below (prefer this option) because you are calling a static method using an object reference which is not required and creates confusion.

public class two {

        private ArrayList<String> al = new ArrayList<String>();

        public void storage(String toBeAdded)
        {
            al.add(toBeAdded);
            System.out.println(al);
        }
    }

Always ensure that static variables/methods are invoked using classname (like Two.storage()) without creating any object because they are class level members i.e., they are not meant for a single object. I strongly suggest you read this and understand this subject more clearly.

Apart from above important point, always ensure that you follow the Java naming standards like class names should start with uppercase which you are violating.

How do I know whether to use an array or an arraylist?

Use array when you know the exact size of the collection and you don't expect to add/remove elements.
Use List (ArrayList) when you don't know the exact size of the collection and you expect to alter it at some point.
If you're using Java8, there is the Stream API, which helps to significantly reduce the boilerplate code when working with collections. This is another plus for ArrayList (and all Collections and Maps).

More info:

Arrays vs ArrayList in performance

Converting array to list in Java

In your example, it is because you can't have a List of a primitive type. In other words, List<int> is not possible.

You can, however, have a List<Integer> using the Integer class that wraps the int primitive. Convert your array to a List with the Arrays.asList utility method.

Integer[] numbers = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(numbers);

See this code run live at IdeOne.com.

Convert list to array in Java

Either:

Foo[] array = list.toArray(new Foo[0]);

or:

Foo[] array = new Foo[list.size()];
list.toArray(array); // fill the array

Note that this works only for arrays of reference types. For arrays of primitive types, use the traditional way:

List<Integer> list = ...;
int[] array = new int[list.size()];
for(int i = 0; i < list.size(); i++) array[i] = list.get(i);

Update:

It is recommended now to use list.toArray(new Foo[0]);, not list.toArray(new Foo[list.size()]);.

From JetBrains Intellij Idea inspection:

There are two styles to convert a collection to an array: either using
a pre-sized array (like c.toArray(new String[c.size()])) or
using an empty array (like c.toArray(new String[0]).
In
older Java versions using pre-sized array was recommended, as the
reflection call which is necessary to create an array of proper size
was quite slow. However since late updates of OpenJDK 6 this call
was intrinsified, making the performance of the empty array version
the same and sometimes even better, compared to the pre-sized
version. Also passing pre-sized array is dangerous for a concurrent or
synchronized collection as a data race is possible between the
size and toArray call which may result in extra nulls
at the end of the array, if the collection was concurrently shrunk
during the operation.

This inspection allows to follow the
uniform style: either using an empty array (which is recommended in
modern Java) or using a pre-sized array (which might be faster in
older Java versions or non-HotSpot based JVMs).

Cant get java stream to work with arraylist

Here is what you wanted to do.

      Customer[] filtered = Stream.of(kunderne).filter(Customer::isGlad).map(
            cust -> new Customer(cust.name, cust.points, cust.glad)).toArray(
                  Customer[]::new);

      for (Customer c : filtered) {
         System.out.println(c.name + " " + c.points + " " + c.glad);
      }

You needed to map the filtered customer to a new customer and then put those in an array. Another option would be to add a constructor that takes an existing customer and uses that as input. Here is how that would work.

      Customer[] filtered = Stream.of(kunderne).filter(Customer::isGlad).map(
            Customer::new).toArray(Customer[]::new);

      for (Customer c : filtered) {
         System.out.println(c.name + " " + c.points + " " + c.glad);
      }

     // modified customer class with additional constructor

    class Customer {
       public String  name;
       public int     points;
       public boolean glad;

       public Customer(String name, int points, boolean glad) {
          this.name = name;
          this.points = points;
          this.glad = glad;
       }

       public Customer(Customer cust) {
          this(cust.name, cust.points, cust.glad);
       }

       public boolean isGlad() {
          return this.glad;
       }
    }

Is there any way to reuse an arraylist in java?

You're adding the same object and deleting it as well.
In order to add different temp-lists to arrayListContainer you should create a copy:

change the lines that do:

arrayListContainer.add(temporaryArrayList);

to:

ArrayList<String> copy = new ArrayList<>(temporaryArrayList)
arrayListContainer.add(copy);

Another option, as Thilo suggests in a comment below, would be to create a new temporaryArrayList every time, this way you'll ensure adding different temp lists to arrayListContainer as well.