Int[] converteren naar List<Integer> op Java?

Hoe converteer ik int[]naar List<Integer>in Java?

Natuurlijk ben ik geïnteresseerd in elk ander antwoord dan het in een lus te doen, item voor item. Maar als er geen ander antwoord is, kies ik dat als het beste om te laten zien dat deze functionaliteit geen deel uitmaakt van Java.


Antwoord 1, autoriteit 100%

Er is geen snelkoppeling voor het converteren van int[]naar List<Integer>aangezien Arrays.asListniet over boksen gaat en maak gewoon een List<int[]>die niet is wat je wilt. U moet een hulpprogramma-methode maken.

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

Antwoord 2, autoriteit 96%

Streamen

  1. In Java 8+ kun je een stream maken van je intarray. Bel ofwel Arrays.streamof IntStream.of.
  2. Bel IntStream#boxedom boksconversie te gebruiken van intprimitief naar Integer-objecten.
  3. Verzamel in een lijst met Stream.collect( Collectors.toList() ). Of eenvoudiger in Java 16+, bel Stream#toList().

Voorbeeld:

int[] ints = {1,2,3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

In Java 16 en hoger:

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

Antwoord 3, autoriteit 59%

Ook van guavebibliotheken… com.google.common.primitives.Ints:

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

Antwoord 4, autoriteit 36%

Arrays.asList zal niet werken zoals sommige van de andere antwoorden verwachten.

Deze code maakt geeneen lijst van 10 gehele getallen. Er wordt 1afgedrukt, niet 10:

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

Hiermee wordt een lijst met gehele getallen gemaakt:

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

Als je de array van ints al hebt, is er geen snelle manier om te converteren, je bent beter af met de lus.

Aan de andere kant, als uw array objecten bevat en geen primitieven, zal Arrays.asList werken:

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

Antwoord 5, autoriteit 17%

Ik zal nog een antwoord toevoegen met een andere methode; geen lus maar een anonieme klasse die de autoboxing-functies zal gebruiken:

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; }
    };
}

Antwoord 6, autoriteit 13%

Het kleinste stukje code zou zijn:

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

waar ArrayUtils vandaan komt commons-lang 🙂


Antwoord 7, autoriteit 10%

In Java 8 met stream:

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

of met Verzamelaars

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

Antwoord 8, autoriteit 7%

In Java 8 :

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

Antwoord 9, autoriteit 7%

Als u java 8 gebruikt, kunnen we de stream-API gebruiken om deze om te zetten in een lijst.

List<Integer> list = Arrays.stream(arr)     // IntStream 
                                .boxed()        // Stream<Integer>
                                .collect(Collectors.toList());

U kunt ook de IntStream gebruiken om te converteren.

List<Integer> list = IntStream.of(arr) // return Intstream
                                    .boxed()        // Stream<Integer>
                                    .collect(Collectors.toList());

Er zijn andere externe bibliotheken zoals guave en apache commons
ook beschikbaar converteer het.

proost.


Antwoord 10, autoriteit 4%

Het is ook de moeite waard om dit bugrapportte bekijken, dat is gesloten met als reden “Geen defect” en de volgende tekst:

“Het autoboxen van hele arrays is om een goede reden niet gespecificeerd.
Het kan onbetaalbaar zijn voor grote arrays.”


Antwoord 11, autoriteit 3%

probeer deze les eens:

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;
    }
}

testcase:

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

Antwoord 12, autoriteit 2%

int[] arr = { 1, 2, 3, 4, 5 };
List<Integer> list = Arrays.stream(arr)     // IntStream
                            .boxed()        // Stream<Integer>
                            .collect(Collectors.toList());

zie dit


Antwoord 13, autoriteit 2%

De beste foto:

**
 * 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;
    }
}
  • Ondersteuning ophalen en instellen.
  • Geen duplicatie van geheugengegevens.
  • Geen tijd verspillen in loops.

Voorbeelden:

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

Antwoord 14

Hier is nog een mogelijkheid, opnieuw met Java 8 Streams:

void intArrayToListOfIntegers(int[] arr, List<Integer> list) {
    IntStream.range(0, arr.length).forEach(i -> list.add(arr[i]));
}

Antwoord 15

Als u openstaat voor het gebruik van een bibliotheek van derden, werkt dit in Eclipse Collections:

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

Opmerking: ik ben een committer voor Eclipse Collections.


Antwoord 16

  /* 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);

Antwoord 17

En dit:

int[] a = {1,2,3};
Integer[] b = ArrayUtils.toObject(a);
List<Integer> c = Arrays.asList(b);


Antwoord 18

Hier is een oplossing:

int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Integer[] iArray = Arrays.stream(array).boxed().toArray(Integer[]::new);
System.out.println(Arrays.toString(iArray));
List<Integer> list = new ArrayList<>();
Collections.addAll(list, iArray);
System.out.println(list);

Uitvoer:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Antwoord 19

Hier is een algemene manier om array naar ArrayList te converteren

<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;
}

Gebruik

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

Antwoord 20

Arrays.stream(ints).forEach(list::add);

Other episodes