Wie konvertiert man int [] in die Liste <Integer> in Java?

Question

Wie konvertiere ich int[] in List<Integer> in Java?

Natürlich interessiert mich jede andere Antwort, als es in einer Schleife zu tun, Stück für Stück. Aber wenn es keine andere Antwort gibt, wähle ich diese als die beste, um zu zeigen, dass diese Funktionalität nicht Teil von Java ist.

Answer 1

Es gibt keine Abkürzung für von int[] zu List<Integer> als Arrays.asList Umwandlung nicht mit Boxen befassen und wird nur eine List<int[]> schaffen, das ist nicht das, was Sie wollen. Sie müssen eine Hilfsmethode erstellen.

int[] ints = {1, 2, 3}; 
List<Integer> intList = new ArrayList<Integer>(); 
for (int i : ints) 
{ 
    intList.add(i); 
} 

Answer 2

Es lohnt sich auch this bug report Check-out, die mit Vernunft „nicht um einen Defekt“ geschlossen wurde und der folgende Text:.

„Autoboxing ganzer Arrays Verhalten nicht anders angegeben, aus gutem Grund Es kann für große Arrays unerschwinglich teuer sein. "

Answer 3

Arrays.asList wird nicht funktionieren, wie einige der anderen Antworten erwarten.

Dieser Code wird nicht erstellen Sie eine Liste von 10 Ganzzahlen. Es wird , nicht drucken:

int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
List lst = Arrays.asList(arr); 
System.out.println(lst.size()); 

Dies wird eine Liste von ganzen Zahlen erstellen:

List<Integer> lst = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 

Wenn Sie schon ein Array von ints haben, gibt es nicht schnellen Weg, um zu konvertieren , du bist besser dran mit der Schleife.

Auf der anderen Seite, wenn Ihr Array Objekte, nicht Primitiven in sich hat, wird Arrays.asList arbeiten:

String str[] = { "Homer", "Marge", "Bart", "Lisa", "Maggie" }; 
List<String> lst = Arrays.asList(str); 

Answer 4

einen Versuch zu dieser Klasse geben:

class PrimitiveWrapper<T> extends AbstractList<T> { 

    private final T[] data; 

    private PrimitiveWrapper(T[] data) { 
     this.data = data; // you can clone this array for preventing aliasing 
    } 

    public static <T> List<T> ofIntegers(int... data) { 
     return new PrimitiveWrapper(toBoxedArray(Integer.class, data)); 
    } 

    public static <T> List<T> ofCharacters(char... data) { 
     return new PrimitiveWrapper(toBoxedArray(Character.class, data)); 
    } 

    public static <T> List<T> ofDoubles(double... data) { 
     return new PrimitiveWrapper(toBoxedArray(Double.class, data)); 
    } 

    // ditto for byte, float, boolean, long 

    private static <T> T[] toBoxedArray(Class<T> boxClass, Object components) { 
     final int length = Array.getLength(components); 
     Object res = Array.newInstance(boxClass, length); 

     for (int i = 0; i < length; i++) { 
      Array.set(res, i, Array.get(components, i)); 
     } 

     return (T[]) res; 
    } 

    @Override 
    public T get(int index) { 
     return data[index]; 
    } 

    @Override 
    public int size() { 
     return data.length; 
    } 
} 

Testfall:

List<Integer> ints = PrimitiveWrapper.ofIntegers(10, 20); 
List<Double> doubles = PrimitiveWrapper.ofDoubles(10, 20); 
// etc 

Answer 5

Ich werde eine andere Antwort mit einer anderen Methode hinzufügen; keine Schleife, sondern eine anonyme Klasse, die die Autoboxing Funktionen nutzen werden:

public List<Integer> asList(final int[] is) 
{ 
    return new AbstractList<Integer>() { 
      public Integer get(int i) { return is[i]; } 
      public int size() { return is.length; } 
    }; 
} 

Answer 6

Das kleinste Stück Code wäre:

public List<Integer> myWork(int[] array) { 
    return Arrays.asList(ArrayUtils.toObject(array)); 
} 

wo ArrayUtils kommt von commons-lang :)

Answer 7

auch von guava libraries ... com.google.common.primitives.Ints:

List<Integer> Ints.asList(int...) 

Answer 8

Der beste Schuss:

** 
* Integer modifiable fix length list of an int array or many int's. 
* 
* @author Daniel De Leon. 
*/ 
public class IntegerListWrap extends AbstractList<Integer> { 

    int[] data; 

    public IntegerListWrap(int... data) { 
     this.data = data; 
    } 

    @Override 
    public Integer get(int index) { 
     return data[index]; 
    } 

    @Override 
    public Integer set(int index, Integer element) { 
     int r = data[index]; 
     data[index] = element; 
     return r; 
    } 

    @Override 
    public int size() { 
     return data.length; 
    } 
} 

• Unterstützung erhalten und eingestellt.
• Keine Speicherdatenduplizierung.
• Keine Zeitverschwendung in Schleifen.

Beispiele:

int[] intArray = new int[]{1, 2, 3}; 
List<Integer> integerListWrap = new IntegerListWrap(intArray); 
List<Integer> integerListWrap1 = new IntegerListWrap(1, 2, 3); 

Answer 9

In Java 8 mit Strom:

int[] ints = {1, 2, 3}; 
List<Integer> list = new ArrayList<Integer>(); 
Collections.addAll(list, Arrays.stream(ints).boxed().toArray(Integer[]::new)); 

oder mit Collectors

List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Answer 10

in Java 8 können Sie diese

0 do

Answer 11

Hier ist eine generische Art und Weise ist Array zu konvertieren

<T> ArrayList<T> toArrayList(Object o, Class<T> type){ 
    ArrayList<T> objects = new ArrayList<>(); 
    for (int i = 0; i < Array.getLength(o); i++) { 
     //noinspection unchecked 
     objects.add((T) Array.get(o, i)); 
    } 
    return objects; 
} 

Nutzungs

ArrayList<Integer> list = toArrayList(new int[]{1,2,3}, Integer.class); 

Answer 12

Wenn Sie mit einem Dritten Bibliothek sind offen zu Arraylist, wird dies in Eclipse Collections arbeiten:

int[] a = {1, 2, 3}; 
List<Integer> integers = IntLists.mutable.with(a).collect(i -> i); 
Assert.assertEquals(Lists.mutable.with(1, 2, 3), integers); 

Hinweis: Ich bin ein Committer für Eclipse Collections.

Answer 13

/* Integer[] to List<Integer> */ 



     Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 }; 
     List<Integer> arrList = new ArrayList<>(); 
     arrList.addAll(Arrays.asList(intArr)); 
     System.out.println(arrList); 


/* Integer[] to Collection<Integer> */ 


    Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 }; 
    Collection<Integer> c = Arrays.asList(intArr); 

Answer 14

In Java 8:

int[] arr = {1,2,3}; 
IntStream.of(arr).boxed().collect(Collectors.toList());