How to create ArrayList (ArrayList<T>) from array of primitive type elements

Your array must be an array of Byte, not byte. addAll requires a collection of objects that match.

In other words: Byte[] a=new Byte[3];

Alternatively, if your source array is a primitive array of bytes, instead of Byte objects, then you have to loop through them and add one at a time:

for( byte toInsert: a ){
   c.add((Byte)a);// Probably don't need the cast, but included for clarity
}

With Java 8 you can use streams do it in a single statement, without the casting and iteration you want to avoid:

byte[] byteArray = {-128, 89, 103, 92, 0, 127};
List<Byte> byteList = IntStream.range(0, byteArray.length) 
                               .mapToObj((int i) -> byteArray[i]) 
                               .collect(Collectors.toList()); 
System.out.println("byteList = " + byteList);

The basic idea is to get the array values into a Stream, then load those stream values into a List:

• range() yields an IntStream 0,1,2,3,4,5 corresponding to the index
  values in the byte array.
• mapToObj() yields a Stream -128, 89, 103, 92, 0, 127 corresponding to the byte array's values.
• collect() puts those stream values into a List.

You can use the same approach for char[] and short[] transformations.

In Java, there are classes that "wrap" around primitive types, so to speak. These classes are: Integer, Byte, Long, Double, Float, Character, etc.

Now here are the primitive types: int, byte, long, double, float, char, etc.

You see the similarity? So when you are using type parameters (notated like this: ), you have to use these wrapper classes instead of the primitive types because primitives aren't classes (that's why String isn't a primitive but it is a class.) You can add primitive types like "byte b = 1" to the list you have up there, but because the array you have doesn't match the class of your list, it doesn't work.

It's an easy fix, just changed the type of your array from "byte" to "Byte."

The simple way I would recommend to new programmers:

static ArrayList<Integer> primitiveArrayToArrayList(int[] input)
{
    ArrayList<Integer> result = new ArrayList<>();
    for (int i : input)
        result.add(i);
    return result;
}

The modern way I would recommend to advanced programmers:

static ArrayList<Integer> primitiveArrayToArrayList(int[] input)
{
    return Arrays.stream(input).boxed().collect(Collectors.toCollection(ArrayList::new));
}

note: Arrays.stream() is only available for int, long, double and reference types

This way allows simple modifications in a more complex use case, like here:

static ArrayList<Integer> findValues(int[] input, Predicate<Integer> filter, int limit)
{
    return Arrays.stream(input).boxed().filter(filter).limit(limit).collect(Collectors.toCollection(ArrayList::new));
}

public static void main(String[] args)
{
    int[] values = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    Predicate<Integer> filter = i -> i % 2 == 0;
    int limit = 3;

    System.out.println(findValues(values, filter, limit));
}

converting the Array to an ArrayList, while filtering for even numbers and limit the result size to 3 results in:

out: [0, 2, 4]

Stream API chain vs. loop

static ArrayList<Integer> findValues(int[] input, Predicate<Integer> filter, int limit)
{
    return Arrays.stream(input).boxed().filter(filter).limit(limit).collect(Collectors.toCollection(ArrayList::new));
}

static ArrayList<Integer> findValues(int[] input, Predicate<Integer> filter, int limit)
{
    ArrayList<Integer> integers = new ArrayList<>();
    for (int i : input)
    {
        if (filter.test(i))
        {
            if (limit-- == 0) break;
            integers.add(i);
        }
    }
    return integers;
}