මා සතුව අරාව ඇත, එය ආරම්භ කර ඇත්තේ:

Element[] array = {new Element(1), new Element(2), new Element(3)};

මෙම අරාව ArrayListපන්තියේ වස්තුවක් බවට පරිවර්තනය කිරීමට මම කැමතියි .

ArrayList<Element> arraylist = ???;

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

ලබා දී ඇත්තේ:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

සරලම පිළිතුර නම්:

List<Element> list = Arrays.asList(array);

මෙය හොඳින් ක්‍රියාත්මක වේ. නමුත් සමහර අවවාද:

1. AsList වෙතින් ආපසු ලබා දුන් ලැයිස්තුවට ස්ථාවර ප්‍රමාණයක් ඇත. එබැවින්, ඔබේ කේතයේ ආපසු ලබා දුන් ලැයිස්තුවෙන් අංග එකතු කිරීමට හෝ ඉවත් කිරීමට ඔබට අවශ්‍ය නම්, ඔබට එය නව ආකාරයකින් ඔතා තැබිය යුතුය ArrayList. නැතිනම් ඔබට ලැබෙනු ඇත UnsupportedOperationException.
2. වෙතින් ආපසු එන ලැයිස්තුව asList()මුල් අරාව මඟින් අනුබල දෙනු ලැබේ. ඔබ මුල් අරාව වෙනස් කරන්නේ නම්, ලැයිස්තුවද වෙනස් කරනු ලැබේ. මෙය පුදුමයට කරුණක් විය හැකිය.

^{(පැරණි නූල්, නමුත් ගුවා හෝ වෙනත් ලිබ් සහ වෙනත් විස්තර කිසිවක් සඳහන් නොකරන පරිදි ශත 2 ක් පමණි)}

ඔබට හැකි නම්, ගුවා භාවිතා කරන්න

මෙම ෂෙනානිගන් බොහෝ සෙයින් සරල කරන ගුවා මාර්ගය පෙන්වා දීම වටී:

භාවිතය

වෙනස් කළ නොහැකි ලැයිස්තුවක් සඳහා

භාවිතා ImmutableListපන්තිය හා එහි of()සහ copyOf()කර්මාන්ත ශාලාව ක්රම ^{(අංග ශූන්ය විය නොහැකි)} :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

විකෘති ලැයිස්තුවක් සඳහා

භාවිතා Listsපන්තිය හා එහි newArrayList()කර්මාන්ත ශාලාව ක්රම:

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

වෙනත් පංතිවල දත්ත ව්‍යුහයන් සඳහා සමාන ක්‍රම කරුණාකර සටහන් කරන්න Sets.

ඇයි ගුවා?

ප්‍රධාන ආකර්ෂණය වනුයේ ගයිවා කර්මාන්තශාලා ක්‍රම භාවිතා කිරීම මඟින් බොහෝ විට වර්ග අනුමාන කිරීමට ඉඩ සලසන බැවින් , වර්ගය-ආරක්ෂාව සඳහා ජනකතා නිසා ඇති වන කැළඹිලි අවම කිරීමයි . කෙසේ වෙතත්, ජාවා 7 නව දියමන්ති ක්‍රියාකරු සමඟ පැමිණි බැවින් මෙම තර්කය අඩු ජල ප්‍රමාණයක් දරයි.

නමුත් එය එකම හේතුව නොවේ (සහ ජාවා 7 තවමත් සෑම තැනකම නොමැත): කෙටිකාලීන වාක්‍ය ඛණ්ඩය ද ඉතා පහසු වන අතර, ඉහත දැක්වෙන පරිදි ආරම්භක ක්‍රම මඟින් වඩාත් ප්‍රකාශන කේත ලිවීමට ඉඩ ලබා දේ. ඔබ එක් ජාවා ඇමතුමකින් වත්මන් ජාවා එකතුව සමඟ 2 ක් ගනී.

ඔබට නොහැකි නම් ...

වෙනස් කළ නොහැකි ලැයිස්තුවක් සඳහා

මෙම JDK ගේ භාවිතා Arraysපන්තිය හා එහි asList()සමඟ ඔතා කර්මාන්ත ක්රමය, Collections.unmodifiableList():

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

සඳහා ආපසු වර්ගය බව සටහන asList()යනු Listකොන්ක්රීට් භාවිතා ArrayListක්රියාත්මක කිරීම, නමුත් එය එසේ නොවේ java.util.ArrayList . එය අභ්‍යන්තර වර්ගයකි, එය අනුකරණය කරන ArrayListනමුත් ඇත්ත වශයෙන්ම සම්මත කළ අරාව සෘජුවම යොමු කර එය "හරහා ලිවීමට" සලස්වයි (වෙනස් කිරීම් අරාවෙහි පිළිබිඹු වේ).

එය Listහුදෙක් API දීර් ing කිරීම මගින් සමහර API ක්‍රම වෙනස් කිරීම තහනම් කරයි AbstractList(එබැවින්, මූලද්‍රව්‍ය එකතු කිරීම හෝ ඉවත් කිරීම සහාය නොදක්වයි), කෙසේ වෙතත් එය ඇමතුම් වලට set()මූලද්‍රව්‍ය අභිබවා යාමට ඉඩ දෙයි . මේ අනුව මෙම ලැයිස්තුව සැබවින්ම වෙනස් කළ නොහැකි අතර ඇමතුමක් asList()ඔතා තිබිය යුතුය Collections.unmodifiableList().

ඔබට විකෘති ලැයිස්තුවක් අවශ්‍ය නම් ඊළඟ පියවර බලන්න.

විකෘති ලැයිස්තුවක් සඳහා

ඉහත ආකාරයටම, නමුත් සත්‍යයකින් ඔතා java.util.ArrayList:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

අධ්‍යාපනික අරමුණු සඳහා: හොඳ ඔල් අත්පොත

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}

මෙම ප්‍රශ්නය තරමක් පැරණි බැවින්, කිසිවෙකු තවමත් සරලම ආකෘතිය යෝජනා නොකිරීම මට පුදුමයකි:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

ජාවා 5 වන Arrays.asList()විට, වරග්ස් පරාමිතියක් ගන්නා අතර ඔබට පැහැදිලිවම අරාව සෑදිය යුතු නැත.

new ArrayList<T>(Arrays.asList(myArray));

myArrayඑය එකම වර්ගයේ බවට වග බලා ගන්න T. උදාහරණයක් ලෙස ඔබ List<Integer>අරාවකින් නිර්මාණය කිරීමට උත්සාහ කළහොත් ඔබට සම්පාදක දෝෂයක් ලැබෙනු ඇත int.

තවත් ක්‍රමයක් (අත්‍යවශ්‍යයෙන්ම සමාන වුවත් new ArrayList(Arrays.asList(array)) විසඳුමට කාර්ය සාධනය අනුව :

Collections.addAll(arraylist, array);

ජාවා 9

දී ජාවා 9 , ඔබ භාවිතා කළ හැකිය List.ofනිර්මාණය කිරීම සඳහා ස්ථිතික කර්මාන්ත ක්රමය Listප්රායෝගික. පහත සඳහන් දේ වැනි දෙයක්:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

මෙය මූලද්‍රව්‍ය තුනක් අඩංගු වෙනස් කළ නොහැකි ලැයිස්තුවක් නැවත ලබා දෙනු ඇත . ඔබට විකෘති ලැයිස්තුවක් අවශ්‍ය නම් , එම ලැයිස්තුව ArrayListඉදිකිරීම්කරු වෙත යවන්න :

new ArrayList<>(List.of(// elements vararg))

JEP 269: එකතු කිරීම සඳහා පහසු කර්මාන්තශාලා ක්‍රම

JEP 269 ජාවා එකතු කිරීමේ API සඳහා පහසු කර්මාන්තශාලා ක්‍රම කිහිපයක් සපයයි . මෙම අණුවල පැවැත්ම ස්ථිතික කර්මාන්ත ක්රම තුලට ගොඩනගා List, Setසහ Mapජාවා 9 මුහුණත් හා පසුව.

ඔබට බොහෝ විට අවශ්‍ය වන්නේ ලැයිස්තුවක් මිස අරා ලැයිස්තුවක් නොවේ. එවැනි අවස්ථාවක ඔබට කළ හැක්කේ:

List<Element> arraylist = Arrays.asList(array);

තවත් යාවත්කාලීනයක්, 2014 වසර ආසන්න වශයෙන් අවසන් වන ඔබට ජාවා 8 සමඟද එය කළ හැකිය:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

මෙය හුදෙක් විය හැකි නම් අක්ෂර කිහිපයක් සුරකිනු ඇත List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

ඔබ භාවිතා කරන්නේ නම්:

new ArrayList<T>(Arrays.asList(myArray));

ඔබ විය හැක නිර්මාණය හා පිරවීම ලැයිස්තු දෙකක්! විශාල ලැයිස්තුවක් දෙවරක් පුරවා ගැනීම හරියටම ඔබට කිරීමට අවශ්‍ය නැති නිසා Object[]ධාරිතාවය පුළුල් කළ යුතු සෑම අවස්ථාවකම එය තවත් අරාවක් නිර්මාණය කරයි.

වාසනාවකට මෙන් JDK ක්‍රියාත්මක කිරීම වේගවත් වන අතර Arrays.asList(a[])එය ඉතා හොඳින් සිදු කරයි. එය අරේස් නම් අරේලිස්ට් වර්ගයක් නිර්මාණය කරයි. අරේලිස්ට් වස්තුව [] දත්ත කෙලින්ම අරාව වෙත යොමු කරයි.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

භයානක පැත්ත නම් ඔබ ආරම්භක අරාව වෙනස් කළහොත් ඔබ ලැයිස්තුව වෙනස් කිරීමයි!ඔබට එය අවශ්‍ය බව විශ්වාසද? සමහර විට ඔව්, සමහර විට නැත.

එසේ නොවේ නම්, වඩාත්ම තේරුම් ගත හැකි ක්‍රමය මෙය කිරීමයි:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

හෝ @glglgl පැවසූ පරිදි, ඔබට තවත් ස්වාධීන අරා ලැයිස්තුවක් නිර්මාණය කළ හැකිය:

new ArrayList<T>(Arrays.asList(myArray));

භාවිතා කිරීමට මම ආදරෙයි Collections, Arraysහෝ පේර. නමුත් එය නොගැලපේ නම් හෝ ඔබට එය දැනෙන්නේ නැත්නම්, ඒ වෙනුවට වෙනත් අනවශ්‍ය රේඛාවක් ලියන්න.

දී Java 9ඔබ භාවිතා කළ හැක:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

ප්රශ්නය සමඟ ජාවා 1.7 භාවිතා කරන පිළිතුර:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

කෙසේ වෙතත් සෑම විටම අතුරු මුහුණත භාවිතා කිරීම වඩා හොඳය:

List<Element> arraylist = Arrays.<Element>asList(array);

// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

ඔබට විවිධ ක්‍රම භාවිතා කර පරිවර්තනය කළ හැකිය

1. List<Element> list = Arrays.asList(array);

2. List<Element> list = new ArrayList();
Collections.addAll(list, array);

3. Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));

වැඩි විස්තර සඳහා ඔබට http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html වෙත යොමු විය හැකිය.

සියල්ලෝම පැවසූ පරිදි මෙය එසේ වනු ඇත

 new ArrayList<>(Arrays.asList("1","2","3","4"));

අරාව නිර්මාණය කිරීමේ පොදු නවතම ක්‍රමය නිරීක්ෂණය කළ හැකි අරාවයි

නිරීක්ෂණය කළ හැකි ලැයිස්තුව: ලැයිස්තුව සවන්දෙන්නන්ට වෙනස්කම් සිදු වූ විට ඒවා නිරීක්ෂණය කිරීමට ඉඩ දෙන ලැයිස්තුවක්.

ජාවා එස්ඊ සඳහා ඔබට උත්සාහ කළ හැකිය

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

එය ඔරකල් ඩොක්ස් වලට අනුව ය

නිරීක්‍ෂණය කළ හැකි අරා ලැයිස්තු () නව හිස් නිරීක්‍ෂණය කළ හැකි ලැයිස්තුවක් සාදයි. නිරීක්‍ෂණය කළ හැකි අරා ලැයිස්තු (ඊ ... අයිතම) එයට එකතු කළ අයිතම සමඟ නව නිරීක්‍ෂණය කළ හැකි අරාව ලැයිස්තුවක් සාදයි.

ජාවා 9 යාවත්කාලීන කරන්න

ජාවා 9 හි ද එය ටිකක් පහසු ය:

List<String> list = List.of("element 1", "element 2", "element 3");

ජාවා 8 සිට පරිවර්තනය කිරීමට පහසු ක්‍රමයක් ඇත:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

ඔබට එය ජාවා 8 හි ධාරාව සමඟ කළ හැකිය.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 

1. Arrays.asList()ක්‍රමයේ අර්ථ දැක්වීම අප දුටුවහොත් ඔබට මෙවැනි දෙයක් ලැබෙනු ඇත:

    public static <T> List<T> asList(T... a) //varargs are of T type. 

   එබැවින්, ඔබට arraylistමේ ආකාරයට ආරම්භ කළ හැකිය :

    List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

   සටහන : සෑම එකක්ම new Element(int args)තනි වස්තුවක් ලෙස සලකනු ලබන අතර එය සම්මත කළ හැකිය var-args.

2. මෙම ප්‍රශ්නයට තවත් පිළිතුරක් තිබිය හැකිය. ක්‍රමවේදය
   සඳහා ප්‍රකාශය ඔබ දුටුවහොත් java.util.Collections.addAll()ඔබට මෙවැනි දෙයක් ලැබෙනු ඇත:

   public static <T> boolean addAll(Collection<? super T> c, T... a);

   එබැවින්, මෙම කේතය ද එසේ කිරීමට ප්‍රයෝජනවත් වේ

   Collections.addAll(arraylist, array);

තවත් සරල ක්‍රමයක් නම්, එක් එක් ලූපය භාවිතා කරමින් අරාවේ සිට සියලුම අංග නව අරා ලැයිස්තුවකට එක් කිරීමයි.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);

අරාව ප්‍රාථමික වර්ගයට අයත් නම්, දී ඇති පිළිතුරු ක්‍රියාත්මක නොවේ. නමුත් ජාවා 8 සිට ඔබට මෙය භාවිතා කළ හැකිය:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());

ඔබට එය පහත පරිදි java 8 හි කළ හැකිය

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

අපට පහසුවෙන් අරාව පරිවර්තනය කළ හැකිය ArrayList. addAll()එක් ලැයිස්තුවක සිට තවත් ලැයිස්තුවකට අන්තර්ගතය පිටපත් කිරීම සඳහා අපි එකතු කිරීමේ අතුරු මුහුණතේ ක්‍රමය භාවිතා කරමු .

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));

මෙම ප්‍රශ්නයට පරිපූර්ණ ලෙස ලිඛිත පිළිතුරු බොහෝමයක් තිබුණද, මම මගේ යෙදවුම් එකතු කරමි.

ඔබට ඇති බව පවසන්න Element[] array = { new Element(1), new Element(2), new Element(3) };

නව අරා ලැයිස්තු පහත දැක්වෙන ආකාරයෙන් නිර්මාණය කළ හැකිය

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

අරේලිස්ට් හි සියලුම මෙහෙයුම් සඳහා ඔවුන් ඉතා හොඳින් සහාය දක්වයි

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

නමුත් පහත දැක්වෙන මෙහෙයුම් මඟින් අරා ලැයිස්තුවේ ලැයිස්තු දර්ශනයක් පමණක් මිස සත්‍ය අරා ලැයිස්තු නොවේ.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

එම නිසා, සමහර අරා ලැයිස්තු මෙහෙයුම් කිරීමට උත්සාහ කිරීමේදී ඒවා දෝෂයක් ලබා දෙනු ඇත

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

අරාව සම්බන්ධකයේ ලැයිස්තු නිරූපණය පිළිබඳ වැඩි විස්තර .

එය කළ හැකි සරලම ක්‍රමය වන්නේ පහත කේතය එක් කිරීමයි. උත්සාහ කර පරීක්ෂා කර ඇත.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

තවත් ජාවා 8 විසඳුමක් (විශාල කට්ටලය අතර මට පිළිතුර මග හැරී ඇති. එසේ නම්, මගේ සමාව ඉල්ලන්න). මෙය අරා ලැයිස්තුවක් නිර්මාණය කරයි (ලැයිස්තුවකට පටහැනිව) එනම් කෙනෙකුට මූලද්‍රව්‍ය මකා දැමිය හැකිය

package package org.something.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

ප්‍රතිදානය නම් ...
ආයුබෝවන්
ලෝකය

මූලද්‍රව්‍ය අරාව අරා ලැයිස්තුවක් බවට පරිවර්තනය කිරීමට පහත කේතය භාවිතා කරන්න.

Element[] array = {new Element(1), new Element(2), new Element(3)};

ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}

දැනටමත් සෑම කෙනෙකුම ඔබේ ගැටලුවට හොඳ පිළිතුරක් ලබා දී ඇත. දැන් සියලු යෝජනා වලින්, ඔබේ අවශ්‍යතාවයට ගැලපෙන දේ ඔබ තීරණය කළ යුතුය. ඔබ දැනගත යුතු එකතු වර්ග දෙකක් තිබේ. එකක් නවීකරණය නොකළ එකතුවක් වන අතර අනෙක එක් එකතුවක් වන අතර එමඟින් පසුව වස්තුව වෙනස් කිරීමට ඔබට ඉඩ සලසයි.

ඉතින්, මෙන්න මම භාවිත අවස්ථා දෙකක් සඳහා කෙටි උදාහරණයක් දෙන්නෙමි.

• වෙනස් කළ නොහැකි එකතු කිරීමේ නිර්මාණය :: එකතු කිරීමෙන් පසු වස්තු වෙනස් කිරීමට ඔබට අවශ්‍ය නොවන විට

  List<Element> elementList = Arrays.asList(array)

• විකෘති එකතු කිරීමේ නිර්මාණය :: නිර්මාණය කිරීමෙන් පසු සාදන ලද එකතු කිරීමේ වස්තුව වෙනස් කිරීමට ඔබට අවශ්‍ය වූ විට.

  List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));

ලබා දී ඇති වස්තු අරාව:

Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};

අරාව ලැයිස්තුවට පරිවර්තනය කරන්න:

    List<Element> list = Arrays.stream(array).collect(Collectors.toList());

අරාව අරේලිස්ට් බවට පරිවර්තනය කරන්න

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

අරාව සබැඳි ලැයිස්තුවට පරිවර්තනය කරන්න

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

මුද්‍රණ ලැයිස්තුව:

    list.forEach(element -> {
        System.out.println(element.i);
    });

පිටත

1

2

3

ජාවා 8 හි අරාස් පන්තිය මඟින් ප්‍රවාහ () ක්‍රමයක් සපයන අතර එය ප්‍රාථමික අරා සහ වස්තු අරා යන දෙකම පිළිගෙන අධික ලෙස පටවා ඇත.

/**** Converting a Primitive 'int' Array to List ****/

int intArray[] = {1, 2, 3, 4, 5};

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());

පහත කේතය මෙය කිරීමට හොඳ ක්‍රමයක් ලෙස පෙනේ.

new ArrayList<T>(Arrays.asList(myArray));