ජාවා හි 'අරේලිස්ට් <ස්ට්‍රිං>' ස්ට්‍රිං [] 'බවට පරිවර්තනය කිරීම

ජාවා හි ArrayList<String>වස්තුවක් String[]අරාවකට පරිවර්තනය කරන්නේ කෙසේද ?

List<String> list = ..;
String[] array = list.toArray(new String[0]);

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

List<String> list = new ArrayList<String>();
//add some stuff
list.add("android");
list.add("apple");
String[] stringArray = list.toArray(new String[0]);

මෙම toArray()කිසිදු තර්කයක් ප්රතිලාභ සම්මත නොකර ක්රමය Object[]. එබැවින් ඔබට අරාව තර්කයක් ලෙස සම්මත කළ යුතු අතර එය ලැයිස්තුවේ දත්ත වලින් පුරවා ආපසු එනු ඇත. ඔබට හිස් අරාවක් ද පසු කළ හැකිය, නමුත් ඔබට අපේක්ෂිත ප්‍රමාණයෙන් අරාවක් ද සම්මත කළ හැකිය.

වැදගත් යාවත්කාලීන කිරීම : මුලින් ඉහත කේතය භාවිතා කරන ලදි new String[list.size()]. කෙසේ වෙතත්, මෙම බ්ලොග් පෝස්ට් එකෙන් හෙළි වන්නේ ජේවීඑම් ප්‍රශස්තිකරණය නිසා new String[0]දැන් භාවිතා කිරීම වඩා හොඳ බවයි.

ජාවා 8 හි විකල්පයක්:

String[] strings = list.stream().toArray(String[]::new);

ජාවා 11+:

String[] strings = list.toArray(String[]::new);

ඔබට මෙම toArray()ක්‍රමය භාවිතා කළ හැකිය List:

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

list.add("apple");
list.add("banana");

String[] array = list.toArray(new String[list.size()]);

නැතහොත් ඔබට අරා වලට මූලද්‍රව්‍ය අතින් එකතු කළ හැකිය:

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

list.add("apple");
list.add("banana");

String[] array = new String[list.size()];

for (int i = 0; i < list.size(); i++) {
    array[i] = list.get(i);
}

මෙය උපකාරී වේ යැයි සිතමු!

ArrayList<String> arrayList = new ArrayList<String>();
Object[] objectList = arrayList.toArray();
String[] stringArray =  Arrays.copyOf(objectList,objectList.length,String[].class);

CopyOf භාවිතා කරමින්, අරා වෙත අරා ලැයිස්තු ද කළ හැකිය.

ජාවා -11 සිට ඇරඹෙන කෙනෙකුට විකල්පයක් ලෙස ඒපීඅයි භාවිතා කළ හැකිය Collection.toArray(IntFunction<T[]> generator).

List<String> list = List.of("x","y","z");
String[] arrayBeforeJDK11 = list.toArray(new String[0]);
String[] arrayAfterJDK11 = list.toArray(String[]::new); // similar to Stream.toArray

ජාවා 8 හි:

String[] strings = list.parallelStream().toArray(String[]::new);

ජාවා 8 හි එය භාවිතයෙන් කළ හැකිය

String[] arrayFromList = fromlist.stream().toArray(String[]::new);

ඔබගේ යෙදුම දැනටමත් Apache Commons lib භාවිතා කරන්නේ නම්, සෑම විටම නව හිස් අරාවක් නිර්මාණය නොකිරීමට ඔබට පිළිගත් පිළිතුර තරමක් වෙනස් කළ හැකිය:

List<String> list = ..;
String[] array = list.toArray(ArrayUtils.EMPTY_STRING_ARRAY);

// or if using static import
String[] array = list.toArray(EMPTY_STRING_ARRAY);

විවිධ වර්ගවල පූර්ව වෙන්කර ඇති හිස් අරා කිහිපයක් තිබේ ArrayUtils.

මේ ආකාරයෙන් අපට හිස් අරා නිර්මාණය කිරීම සඳහා ජේවීඑම් වංචා කළ හැකිය:

String[] array = list.toArray(ArrayUtils.toArray());

// or if using static import
String[] array = list.toArray(toArray());

නමුත් මේ ආකාරයෙන් කිසිදු වාසියක් නැත, රසය පිළිබඳ කාරණයක්, IMO.

Iterator<String>මෙහි මූලද්‍රව්‍ය නැවත සැකසීමට ඔබට භාවිතා කළ හැකිය ArrayList<String>:

ArrayList<String> list = new ArrayList<>();
String[] array = new String[list.size()];
int i = 0;
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); i++) {
    array[i] = iterator.next();
}

දැන් ඔබට ඕනෑම ලූපයක් String[]භාවිතා කිරීමෙන් මූලද්‍රව්‍ය ලබා ගත හැකිය .

ඕනෑම List<Type>දෙයක් සඟවා තැබීමට ජනක විසඳුම String []:

public static  <T> String[] listToArray(List<T> list) {
    String [] array = new String[list.size()];
    for (int i = 0; i < array.length; i++)
        array[i] = list.get(i).toString();
    return array;
}

සටහන ඔබ override toString()ක්‍රමවේදය කළ යුතුය .

class Car {
  private String name;
  public Car(String name) {
    this.name = name;
  }
  public String toString() {
    return name;
  }
}
final List<Car> carList = new ArrayList<Car>();
carList.add(new Car("BMW"))
carList.add(new Car("Mercedes"))
carList.add(new Car("Skoda"))
final String[] carArray = listToArray(carList);

List <String> list = ...
String[] array = new String[list.size()];
int i=0;
for(String s: list){
  array[i++] = s;
}

පරිශීලකයාට ශ්‍රිතයක් අවශ්‍ය වන දත්තවල අමතර හැසිරවීමක් අවශ්‍ය නම්, මෙම ප්‍රවේශය පරිපූර්ණ නොවේ (මූලද්‍රව්‍යයේ පන්තිය දෙවන පරාමිතිය ලෙස සම්මත කිරීම අවශ්‍ය බැවින්), නමුත් ක්‍රියා කරයි:

ආනයනය java.util.ArrayList; ආනයනය java.lang.reflect.Array;

public class Test {
  public static void main(String[] args) {
    ArrayList<Integer> al = new ArrayList<>();
    al.add(1);
    al.add(2);
    Integer[] arr = convert(al, Integer.class);
    for (int i=0; i<arr.length; i++)
      System.out.println(arr[i]);
  }

  public static <T> T[] convert(ArrayList<T> al, Class clazz) {
    return (T[]) al.toArray((T[])Array.newInstance(clazz, al.size()));
  }
}

ජාවා 11 හි අපට Collection.toArray(generator)ක්‍රමය භාවිතා කළ හැකිය . පහත කේතය මඟින් නව නූල් පෙළක් නිර්මාණය වනු ඇත:

List<String> list = List.of("one", "two", "three");
String[] array = list.toArray(String[]::new)

සිට java.base ගේ java.util.Collection.toArray() .

    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    String [] strArry= list.stream().toArray(size -> new String[size]);

අදහස් දැක්වීමකට, පරිවර්තනය ක්‍රියාත්මක වන ආකාරය පැහැදිලි කිරීම සඳහා මම ඡේදයක් එක් කළෙමි. පළමුව, ලැයිස්තුව සංගීත ප්‍රවාහයක් බවට පරිවර්තනය වේ. ඉන්පසු එය ධාරාවේ මූලද්‍රව්‍ය අරාව බවට පරිවර්තනය කිරීම සඳහා Stream.toArray භාවිතා කරයි. "ප්‍රමාණය -> නව නූල් [ප්‍රමාණය]" ට ඉහළින් ඇති අවසාන ප්‍රකාශයේ ඇත්ත වශයෙන්ම ඉන්ටර්ෆන්ෂන් ශ්‍රිතයකි. ප්රකාශය සමාන වේ

IntFunction<String []> allocateFunc = size -> { 
return new String[size];
};   
String [] strArry= list.stream().toArray(allocateFunc);

මෙම ක්‍රමය භාවිතා කිරීමෙන් ඔබට ලැයිස්තුවට සංගීත අරා බවට පරිවර්තනය කළ හැකිය:

 Object[] stringlist=list.toArray();

සම්පූර්ණ උදාහරණය:

ArrayList<String> list=new ArrayList<>();
    list.add("Abc");
    list.add("xyz");

    Object[] stringlist=list.toArray();

    for(int i = 0; i < stringlist.length ; i++)
    {
          Log.wtf("list data:",(String)stringlist[i]);
    }

private String[] prepareDeliveryArray(List<DeliveryServiceModel> deliveryServices) {
    String[] delivery = new String[deliveryServices.size()];
    for (int i = 0; i < deliveryServices.size(); i++) {
        delivery[i] = deliveryServices.get(i).getName();
    }
    return delivery;
}