අරාව ජාවා හි ලැයිස්තුවට පරිවර්තනය කිරීම

ජාවා හි ලැයිස්තුවක් වෙත අරාවක් පරිවර්තනය කරන්නේ කෙසේද?

මම භාවිතා කළ Arrays.asList()නමුත් හැසිරීම (සහ අත්සන) කෙසේ හෝ ජාවා එස්ඊ 1.4.2 (දැන් ලේඛනාගාරයේ ඇති) සිට 8 දක්වා වෙනස් කර ඇති අතර වෙබයේ මා සොයාගත් බොහෝ ස්නිපෙට් 1.4.2 හැසිරීම භාවිතා කරයි.

උදාහරණයක් වශයෙන්:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(spam)

• 1.4.2 හි 1, 2, 3 මූලද්‍රව්‍ය අඩංගු ලැයිස්තුවක් ලබා දෙයි
• 1.5.0+ හි අරාව අයාචිත තැපැල් අඩංගු ලැයිස්තුවක් ලබා දෙයි

බොහෝ අවස්ථාවන්හීදී එය පහසුවෙන් හඳුනාගත හැකි නමුත් සමහර විට එය නොදැනුවත්වම ලිස්සා යා හැකිය:

Assert.assertTrue(Arrays.asList(spam).indexOf(4) == -1);

ඔබේ උදාහරණයේ දී, ඔබට ප්‍රාථමික වර්ගයක ලැයිස්තුවක් තිබිය නොහැකි බැවිනි. වෙනත් වචන වලින් කිවහොත්, කළ List<int>නොහැකි ය.

කෙසේ වෙතත්, ඔබට ප්‍රාථමිකය ඔතා ඇති පන්තිය List<Integer>භාවිතා කළ හැකිය . උපයෝගිතා ක්‍රමය සමඟ ඔබේ අරාව a බවට පරිවර්තනය කරන්න .IntegerintListArrays.asList

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

IdeOne.com හි මෙම කේතය සජීවීව ක්‍රියාත්මක වන ආකාරය බලන්න .

ජාවා 8 හි, ඔබට ධාරාවන් භාවිතා කළ හැකිය:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

පරිවර්තන ක්‍රමය ගැන කථා කිරීම, එය ඔබට අවශ්‍ය වන්නේ ඇයිද යන්න මත රඳා පවතී List. ඔබට එය අවශ්‍ය නම් දත්ත කියවීම පමණි. හරි, මෙන්න ඔබ යන්න:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

නමුත් ඔබ මේ වගේ දෙයක් කරන්නේ නම්:

list.add(1);

ඔබට ලැබෙනවා java.lang.UnsupportedOperationException. එබැවින් සමහර අවස්ථාවල ඔබට මෙය අවශ්‍ය වේ:

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

පළමු ප්‍රවේශය ඇත්ත වශයෙන්ම අරාව පරිවර්තනය නොකරන නමුත් එය 'නිරූපණය' කරයි List. නමුත් අරාව යනු මූලද්‍රව්‍ය ගණන වැනි සියළුම ගුණාංග සහිත කබාය යටය. ඉදි කිරීමේදී ඔබ වර්ගය නියම කළ යුතු බව කරුණාවෙන් සලකන්න ArrayList.

ගැටළුව වන්නේ ජාවා 5 හි වරග්ස් හඳුන්වා දීම සහ අවාසනාවකට මෙන්, Arrays.asList()වරග් අනුවාදයක් සමඟ අධික ලෙස පැටවීමයි. නිසාArrays.asList(spam) int පෙලගැස්මක් ක vararg පරාමිතියක් ලෙස Java5 සම්පාදක විසින් අවබෝධ කර ගත හැකි ය.

මෙම ගැටළුව වඩාත් සවිස්තරාත්මක ජාවා 2 වන සංස්කරණයේ 7 වන පරිච්ඡේදයේ 42 වන අයිතමයේ විස්තර කර ඇත.

එය ටිකක් ප්‍රමාද බවක් පෙනේ, නමුත් මෙන්න මගේ ශත දෙකයි. ප්‍රාථමික වර්ගයක් List<int>ලෙස අපට තිබිය නොහැක, intඑබැවින් අපට තිබිය හැක්කේ එය පමණි List<Integer>.

ජාවා 8 (int array)

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

ජාවා 8 සහ ඊට පහළ (පූර්ණ සංඛ්‍යා අරාව)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

අරා ලැයිස්තු අවශ්‍යද?

අපට Listඋදා: නිශ්චිත ලෙස ක්‍රියාත්මක කිරීමට අවශ්‍ය ArrayListනම් අපට පහත පරිදි භාවිතා කළ හැකිය toCollection:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

list21ව්‍යුහාත්මකව වෙනස් කළ නොහැක්කේ ඇයි ?

අප භාවිතා Arrays.asListකරන විට ආපසු ලබා දුන් ලැයිස්තුවේ ප්‍රමාණය සවි කර ඇත්තේ ආපසු ලබා දුන් ලැයිස්තුව නොවන java.util.ArrayListනිසා නොව ඇතුළත අර්ථ දක්වා ඇති පුද්ගලික ස්ථිතික පන්තියකි java.util.Arrays. එබැවින් අපි ආපසු ලබා දුන් ලැයිස්තුවෙන් අංග එකතු කළහොත් හෝ ඉවත් කළහොත්, එය UnsupportedOperationExceptionවිසි කරනු ලැබේ. එබැවින් list22ලැයිස්තුව වෙනස් කිරීමට අවශ්‍ය විට අප සමඟ යා යුතුය . අපට ජාවා 8 තිබේ නම් අපටද යා හැකිය list23.

පැහැදිලි list21වීමට නම් අපට ඇමතිය හැකි අර්ථයෙන් වෙනස් කළ හැකි list21.set(index,element)නමුත් මෙම ලැයිස්තුව ව්‍යුහාත්මකව වෙනස් නොකළ හැකිය, එනම් ලැයිස්තුවෙන් අංග එකතු කිරීමට හෝ ඉවත් කිරීමට නොහැකිය. වැඩි විස්තර සඳහා ඔබට මගේ මෙම පිළිතුර පරීක්ෂා කළ හැකිය .

අපට වෙනස් කළ නොහැකි ලැයිස්තුවක් අවශ්‍ය නම් අපට එය මෙසේ ඔතා ගත හැකිය:

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

සැලකිල්ලට ගත යුතු තවත් කරුණක් නම්, මෙම ක්‍රමය Collections.unmodifiableListමඟින් නිශ්චිත ලැයිස්තුවේ වෙනස් කළ නොහැකි දර්ශනයක් ලබා දීමයි . වෙනස් කළ නොහැකි දර්ශන එකතුවක් යනු වෙනස් කළ නොහැකි එකතුවක් වන අතර එය පසුබිම් එකතුවක් පිළිබඳ දර්ශනයකි. පසුබිම් එකතුවෙහි වෙනස්කම් තවමත් සිදුවිය හැකි බව සලකන්න, ඒවා සිදුවුවහොත් ඒවා වෙනස් කළ නොහැකි දර්ශනය හරහා දැකිය හැකිය.

ජාවා 9 සහ 10 හි අපට සැබවින්ම වෙනස් කළ නොහැකි ලැයිස්තුවක් තිබිය හැකිය.

සැබවින්ම වෙනස් කළ නොහැකි ලැයිස්තුව

ජාවා 9:

String[] objects = {"Apple", "Ball", "Cat"};
List<String> objectList = List.of(objects);

ජාවා 10 (සැබවින්ම වෙනස් කළ නොහැකි ලැයිස්තුව) ආකාර දෙකකින්:

1. List.copyOf(Arrays.asList(integers))
2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

මට මෑතකදී අරාව ලැයිස්තුවක් බවට පරිවර්තනය කිරීමට සිදුවිය. පසුව වැඩසටහන මඟින් දත්ත ඉවත් කිරීමට උත්සාහ කරමින් ලැයිස්තුව පෙරහන් කරන ලදි. ඔබ Arrays.asList (array) ශ්‍රිතය භාවිතා කරන විට, ඔබ ස්ථාවර ප්‍රමාණ එකතුවක් සාදයි: ඔබට එකතු කිරීමට හෝ මකා දැමිය නොහැක. මෙම ප්‍රවේශය මට වඩා හොඳින් ගැටලුව පැහැදිලි කරයි: ලැයිස්තුවකින් මූලද්‍රව්‍යයක් ඉවත් කිරීමට උත්සාහ කරන විට මට සහාය නොදක්වන ක්‍රියාන්විතයක් ලැබෙන්නේ ඇයි? .

අවසානයේදී, මට "අත්පොත" පරිවර්තනයක් කිරීමට සිදු විය:

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

List.addAll (අයිතම) මෙහෙයුමක් භාවිතා කරමින් මට අරාවකින් ලැයිස්තුවකට පරිවර්තනයක් එක් කළ හැකි යැයි සිතමි.

ඊටත් වඩා කෙටි:

List<Integer> list = Arrays.asList(1, 2, 3, 4);

අරා භාවිතා කිරීම

අරාව බවට පරිවර්තනය කිරීමේ සරලම ක්‍රමය මෙයයි List. කෙසේ වෙතත්, ඔබ නව අංගයක් එක් කිරීමට හෝ ලැයිස්තුවෙන් පවතින මූලද්‍රව්‍යයක් ඉවත් කිරීමට උත්සාහ කළහොත්, එය UnsupportedOperationExceptionවිසි කරනු ලැබේ.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

අරා ලැයිස්තු හෝ වෙනත් ලැයිස්තු ක්‍රියාත්මක කිරීම් භාවිතා කිරීම

ක්‍රියාවට නැංවීම forසඳහා අරාවෙහි සියලුම අංග එකතු කිරීමට ඔබට ලූපයක් භාවිතා කළ හැකිය List, උදා ArrayList:

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

ජාවා 8 හි ධාරා API භාවිතා කිරීම

ඔබට අරාව ප්‍රවාහයක් බවට පත් කළ හැකිය, ඉන්පසු විවිධ එකතුකරන්නන් භාවිතා කරමින් ධාරාව එකතු කරන්න: ජාවා 8 හි පෙරනිමි එකතු කරන්නා ArrayListතිරය ​​පිටුපස භාවිතා කරයි, නමුත් ඔබට කැමති ක්‍රියාත්මක කිරීමක් ද පැනවිය හැකිය.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

මෙයද බලන්න:

• අපි ජාවා හි ස්වයංක්‍රීය බොක්සිං සහ බොක්සිං භාවිතා කරන්නේ ඇයි?
• ArrayList හරහා LinkedList භාවිතා කරන්නේ කවදාද?

ඔබ අපාචේ කොමන්ස්-ලැන්ග් භාවිතා කරන්නේ නම් තවත් ක්‍රියාමාර්ගයක්:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(ArrayUtils.toObject(spam));

කොහෙද ArrayUtils.toObject පරිවර්තනය int[]කිරීමටInteger[]

ඔබ ජාවා 8 (හෝ පසුව) ඉලක්ක කරන්නේ නම්, ඔබට මෙය උත්සාහ කළ හැකිය:

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

සටහන:

වෙත වැටුප් අවධානය Collectors.<Integer>toList(), මේ ලිපිය තුළ වර්ගීය ක්රමය දෝෂය මග ගැනීමට ඔබට උපකාරී "වර්ගය නොගැලපීම: මගින් පරිවර්තනය නොහැකි List<Object>කිරීමට List<Integer>".

ඔබ අරාව වෙත දැමිය යුතුයි

Arrays.asList((Object[]) array)

එක් ලයිනර්:

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

ජාවා 9 හි ඔබට නව පහසුව කර්මාන්තශාලා ක්‍රමය හරහා වෙනස් කළ නොහැකි ලැයිස්තු භාවිතා කිරීමේ ඊටත් වඩා අලංකාර විසඳුමක් ඇත List.of:

List<String> immutableList = List.of("one","two","three");

(නිර්ලජ්ජිතව මෙතැනින් පිටපත් කරන ලදි )

1. ගුවා භාවිතා කිරීම:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = Lists.newArrayList(sourceArray);

2. Apache Commons එකතුව භාවිතා කිරීම:

   Integer[] array = { 1, 2, 3};
   List<Integer> list = new ArrayList<>(6);
   CollectionUtils.addAll(list, array);

මෙය උපකාරී වන්නේ නම්: මට එකම ගැටළුවක් ඇති අතර සරලවම අරාව ගෙන සාමාන්‍ය අන්තර්ගතයක් ලියා ඇති අතර එම වර්ගයේ අරා ලැයිස්තුවක් එකම අන්තර්ගතයකින් ලබා දෙයි:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}

අරාව ලබා දී ඇත:

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

පූර්ණ සංඛ්‍යා අරාව පූර්ණ සංඛ්‍යා ලැයිස්තුවට පරිවර්තනය කිරීම

එක් ක්‍රමයක්: කොටු කළ () -> IntStream නැවත ලබා දෙයි

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

දෙවන මාර්ගය: ධාරාවේ සෑම අංගයක්ම අනුකලනය වෙත සිතියම් ගත කර එකතු කරන්න

සටහන: mapToObj භාවිතා කිරීමෙන් ඔබට සෑම වර්‍ග මූලද්‍රව්‍යයක්ම නූල් ප්‍රවාහයට, වර්‍ග ප්‍රවාහයට ආවරණය කළ හැකිය.

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

එක් අරාව වර්ගයක් වෙනත් වර්ගයකට පරිවර්තනය කිරීම උදාහරණය:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

එබැවින් එය ඔබ උත්සාහ කරන ජාවා අනුවාදය මත රඳා පවතී.

ජාවා 7

 Arrays.asList(1, 2, 3);

හෝ

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

හෝ

Integer[] arr = new Integer[] { 1, 2, 3 };
Arrays.asList(arr);

ජාවා 8 හි

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

යොමුව - http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

කරුණාකර ඔබට මෙම පිළිතුර වැඩිදියුණු කළ හැකිද? මෙය මා භාවිතා කරන නමුත් 100% ක් පැහැදිලි නැත. එය හොඳින් ක්‍රියාත්මක වන නමුත් intelliJ නව කාලගුණ මධ්‍යස්ථානය එකතු කළේය [0]. ඇයි 0?

    public WeatherStation[] removeElementAtIndex(WeatherStation[] array, int index)
    {
        List<WeatherStation> list = new ArrayList<WeatherStation>(Arrays.asList(array));
        list.remove(index);
        return list.toArray(new WeatherStation[0]);
    }

අරාව ලැයිස්තුවට පරිවර්තනය කිරීම සඳහා කේත පේළි දෙකක් භාවිතා කරන්න ඔබ එය පූර්ණ සංඛ්‍යා අගයකින් භාවිතා කරන්නේ නම් ඔබ ප්‍රාථමික දත්ත වර්ගය සඳහා ස්වයංක්‍රීය බොක්සිං වර්ගය භාවිතා කළ යුතුය

  Integer [] arr={1,2};
  Arrays.asList(arr);