सरणी में नए तत्व कैसे जोड़ें?

Question

मेरे पास निम्नलिखित कोड हैं:

String[] where;
where.append(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1");
where.append(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1");

उन दो append संकलित नहीं कर रहे हैं। वह सही तरीके से कैसे काम करेगा?

Answer 1

किसी सरणी का आकार संशोधित नहीं किया जा सकता। यदि आप एक बड़ा सरणी चाहते हैं, तो आपको एक नया इंस्टेंट करना होगा।

एक बेहतर उपाय यह होगा कि आप इसका इस्तेमाल ArrayListकर सकें। ArrayList.toArray( T[] a )यदि आपको इस रूप में इसकी आवश्यकता है, तो विधि आपको अपना सरणी वापस दे देती है।

List<String> where = new ArrayList<String>();
where.add( ContactsContract.Contacts.HAS_PHONE_NUMBER+"=1" );
where.add( ContactsContract.Contacts.IN_VISIBLE_GROUP+"=1" );

यदि आप इसे एक सरल सरणी में बदलने की जरूरत है ...

String[] simpleArray = new String[ where.size() ];
where.toArray( simpleArray );

लेकिन अधिकांश चीजें जो आप एक सरणी के साथ करते हैं, आप इस ArrayList के साथ भी कर सकते हैं:

// iterate over the array
for( String oneItem : where ) {
    ...
}

// get specific items
where.get( 1 );

Comments

अगर आप ArrayList के साथ भी ऐसा कर सकते हैं तो Array का उपयोग करने में क्या हर्ज है?

— स्कौआ

@ tangens.I android के लिए नया है, लेकिन आपके जवाब ने मेरी मदद की। फिर भी मैंने जवाब ढूंढने में कई घंटे बर्बाद कर दिए

— scott

@ सोकौआ अर्रे अधिक कुशल हैं। ऑब्जेक्ट आकार को पूर्व-परिभाषित करने से कंपाइलर मेमोरी को ऑप्टिमाइज़ करने की अनुमति देता है। कुछ अनुप्रयोगों के लिए, यह मायने रखता है। एक आधुनिक कंप्यूटर पर चलने वाला एक छोटा सा ऐप शायद मेमोरी की समस्या बनने से पहले बहुत सारी सूचियों के साथ दूर हो सकता है।

— ड्रेक्सडोमैक्स

Answer 2

ए का उपयोग करें List<String>, जैसे कि ए ArrayList<String>। यह गतिशील रूप से बढ़ने योग्य है, सरणियों के विपरीत (देखें: प्रभावी जावा 2 संस्करण, आइटम 25: सरणियों की सूची को वरीयता दें )।

import java.util.*;
//....

List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
System.out.println(list); // prints "[1, 2, 3]"

यदि आप सरणियों का उपयोग java.util.Arrays.copyOfकरने पर जोर देते हैं, तो आप अतिरिक्त तत्व को समायोजित करने के लिए एक बड़ा सरणी आवंटित करने के लिए उपयोग कर सकते हैं । यह वास्तव में सबसे अच्छा समाधान नहीं है, हालांकि।

static <T> T[] append(T[] arr, T element) {
    final int N = arr.length;
    arr = Arrays.copyOf(arr, N + 1);
    arr[N] = element;
    return arr;
}

String[] arr = { "1", "2", "3" };
System.out.println(Arrays.toString(arr)); // prints "[1, 2, 3]"
arr = append(arr, "4");
System.out.println(Arrays.toString(arr)); // prints "[1, 2, 3, 4]"

यह O(N)प्रति है append। ArrayListदूसरी ओर, O(1)प्रति ऑपरेशन लागत में वृद्धि हुई है।

यह सभी देखें

• जावा ट्यूटोरियल / एरेज़
  • एक सरणी एक कंटेनर ऑब्जेक्ट है जो एक एकल प्रकार के मूल्यों की एक निश्चित संख्या रखता है। किसी सरणी की लंबाई तब बनाई जाती है जब सरणी बनाई जाती है। निर्माण के बाद, इसकी लंबाई तय हो गई है।
• जावा ट्यूटोरियल / सूची इंटरफ़ेस

Comments

आप हर बार क्षमता के हिसाब से सरणी का आकार दोगुना कर सकते हैं। इस तरह से परिशिष्ट O (1) को परिशोधित किया जाएगा। शायद ArrayListआंतरिक रूप से क्या करता है।

— सियुआन रेन

Answer 3

अपाचे कॉमन्स लैंग के पास है

T[] t = ArrayUtils.add( initialArray, newitem );

यह एक नया सरणी देता है, लेकिन यदि आप किसी कारण से वास्तव में सरणियों के साथ काम कर रहे हैं, तो यह ऐसा करने का आदर्श तरीका हो सकता है।

Answer 4

एक और विकल्प है जो मैंने यहां नहीं देखा है और जिसमें "जटिल" ऑब्जेक्ट या संग्रह शामिल नहीं है।

String[] array1 = new String[]{"one", "two"};
String[] array2 = new String[]{"three"};
String[] array = new String[array1.length + array2.length];
System.arraycopy(array1, 0, array, 0, array1.length);
System.arraycopy(array2, 0, array, array1.length, array2.length);

Answer 5

append()सरणियों पर कोई विधि नहीं है । इसके बजाय जैसा कि पहले ही सुझाव दिया गया है कि एक सूची ऑब्जेक्ट गतिशील रूप से सम्मिलित तत्वों जैसे की आवश्यकता की सेवा कर सकता है।

List<String> where = new ArrayList<String>();
where.add(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1");
where.add(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1");

या यदि आप वास्तव में एक सरणी का उपयोग करने के लिए उत्सुक हैं:

String[] where = new String[]{
    ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1",
    ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1"
};

लेकिन फिर यह एक निश्चित आकार है और इसमें कोई तत्व नहीं जोड़ा जा सकता है।

Comments

तो क्या एक पैरामीटर क्वेरी क्वेरी को ArrayList के रूप में भी स्वीकार करती है?

— स्काइनेट

Answer 6

जैसा कि tangens ने कहा, एक सरणी का आकार निश्चित है। लेकिन आपको इसे पहले तुरंत करना होगा, अन्यथा यह केवल एक शून्य संदर्भ होगा।

String[] where = new String[10];

इस सरणी में केवल 10 तत्व हो सकते हैं। तो आप केवल 10 गुना मूल्य जोड़ सकते हैं। आपके कोड में आप एक अशक्त संदर्भ एक्सेस कर रहे हैं। इसलिए यह काम नहीं करता है। गतिशील रूप से बढ़ते संग्रह के लिए, ArrayList का उपयोग करें।

Answer 7

String[] source = new String[] { "a", "b", "c", "d" };
String[] destination = new String[source.length + 2];
destination[0] = "/bin/sh";
destination[1] = "-c";
System.arraycopy(source, 0, destination, 2, source.length);

for (String parts : destination) {
  System.out.println(parts);
}

Answer 8

मैंने यह कोड बना लिया है! यह एक सम्मोहन की तरह काम करता है!

public String[] AddToStringArray(String[] oldArray, String newString)
{
    String[] newArray = Arrays.copyOf(oldArray, oldArray.length+1);
    newArray[oldArray.length] = newString;
    return newArray;
}

मुझे आशा है कि आप इसे पसंद करते हो!!

Answer 9

आपको एक संग्रह सूची का उपयोग करने की आवश्यकता है। आप किसी सरणी को पुनः आयाम नहीं दे सकते।

Answer 10

यदि आप इस तरह से अपने डेटा को सरल सरणी में संग्रहीत करना चाहते हैं

String[] where = new String[10];

और आप इसमें कुछ तत्वों को जोड़ना चाहते हैं जैसे संख्याएँ हमें StringBuilder दें जो कि समवर्ती स्ट्रिंग की तुलना में बहुत अधिक कुशल है।

StringBuilder phoneNumber = new StringBuilder();
phoneNumber.append("1");
phoneNumber.append("2");
where[0] = phoneNumber.toString();

यह आपके स्ट्रिंग बनाने और इसे अपने 'जहाँ' सरणी में संग्रहीत करने के लिए बेहतर तरीका है।

Answer 11

स्ट्रिंग सरणी में नए आइटम जोड़ना।

String[] myArray = new String[] {"x", "y"};

// Convert array to list
List<String> listFromArray = Arrays.asList(myArray);

// Create new list, because, List to Array always returns a fixed-size list backed by the specified array.
List<String> tempList = new ArrayList<String>(listFromArray);
tempList.add("z");

//Convert list back to array
String[] tempArray = new String[tempList.size()];
myArray = tempList.toArray(tempArray);

Comments

आह, मैं देख रहा हूं, आपने <code>टैग का उपयोग किया था और इससे जेनेरिक प्रकारों की समस्या थी। कृपया इस टैग से बचने की कोशिश करें, क्योंकि ... इसमें समस्याएं हैं, और उचित स्वरूपण प्राप्त करने के लिए अपने कोड को 4 व्हाट्सएप के साथ इंडेंट करें। मैंने आपके प्रश्न के लिए ऐसा किया :)।

— टॉम

Answer 12

एक एरे में एलीमेंट को जोड़ने के कई तरीके हैं। आप Listतत्व को प्रबंधित करने के लिए एक अस्थायी का उपयोग कर सकते हैं और फिर इसे वापस में बदल Arrayसकते हैं या आप इसका उपयोग कर सकते हैं java.util.Arrays.copyOfऔर बेहतर परिणामों के लिए इसे जेनरिक के साथ जोड़ सकते हैं ।

यह उदाहरण आपको दिखाएगा कि कैसे:

public static <T> T[] append2Array(T[] elements, T element)
{
    T[] newArray = Arrays.copyOf(elements, elements.length + 1);
    newArray[elements.length] = element;

    return newArray;
}

इस विधि का उपयोग करने के लिए आपको बस इसे इस तरह से कॉल करने की आवश्यकता है:

String[] numbers = new String[]{"one", "two", "three"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(numbers, "four");
System.out.println(Arrays.toString(numbers));

यदि आप दो ऐरे मर्ज करना चाहते हैं तो आप पिछली विधि को इस तरह से संशोधित कर सकते हैं:

public static <T> T[] append2Array(T[] elements, T[] newElements)
{
    T[] newArray = Arrays.copyOf(elements, elements.length + newElements.length);
    System.arraycopy(newElements, 0, newArray, elements.length, newElements.length);

    return newArray;
}

अब आप इस तरह से विधि को कॉल कर सकते हैं:

String[] numbers = new String[]{"one", "two", "three"};
String[] moreNumbers = new String[]{"four", "five", "six"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(numbers, moreNumbers);
System.out.println(Arrays.toString(numbers));

जैसा कि मैंने उल्लेख किया है, आप Listवस्तुओं का उपयोग भी कर सकते हैं । हालाँकि, इसे सुरक्षित रखने के लिए इसे थोड़ा हैक करने की आवश्यकता होगी:

public static <T> T[] append2Array(Class<T[]> clazz, List<T> elements, T element)
{
    elements.add(element);
    return clazz.cast(elements.toArray());
}

अब आप इस तरह से विधि को कॉल कर सकते हैं:

String[] numbers = new String[]{"one", "two", "three"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(String[].class, Arrays.asList(numbers), "four");
System.out.println(Arrays.toString(numbers));

Comments

newArray[elements.length] = element;क्या आपका मतलब था newArray[elements.length - 1] = element;?

— डेविड रिक्सेटली

Answer 13

मैं जावा में अनुभवी नहीं हूं, लेकिन मुझे हमेशा बताया गया है कि सरणियाँ स्थिर संरचनाएं हैं जिनका पूर्वनिर्धारित आकार है। आपको एक ArrayList या एक वेक्टर या किसी अन्य गतिशील संरचना का उपयोग करना होगा।

Answer 14

आप एक Collection.addAll()सरणी सूची बना सकते हैं, और स्ट्रिंग सरणी को अपनी सरणी सूची में बदलने के लिए उपयोग कर सकते हैं

Answer 15

आप बस यह कर सकते हैं:

System.arraycopy(initialArray, 0, newArray, 0, initialArray.length);

Answer 16

अगर कोई वास्तव में एक सरणी का आकार बदलना चाहता है, तो आप ऐसा कुछ कर सकते हैं:

String[] arr = {"a", "b", "c"};
System.out.println(Arrays.toString(arr)); 
// Output is: [a, b, c]

arr = Arrays.copyOf(arr, 10); // new size will be 10 elements
arr[3] = "d";
arr[4] = "e";
arr[5] = "f";

System.out.println(Arrays.toString(arr));
// Output is: [a, b, c, d, e, f, null, null, null, null]

Answer 17

सरणी का आकार संशोधित नहीं किया जा सकता है। यदि आपको किसी सरणी का उपयोग करना है, तो आप उपयोग कर सकते हैं:

System.arraycopy(src, srcpos, dest, destpos, length); 

Answer 18

यह संभव है कि बड़े पर्याप्त मेमोरी साइज का प्री-एलोकेशन किया जाए। यहां एक सरल स्टैक कार्यान्वयन है: कार्यक्रम को 3 और 5 आउटपुट के लिए माना जाता है।

class Stk {
    static public final int STKSIZ = 256;
    public int[] info = new int[STKSIZ];
    public int sp = 0; // stack pointer
    public void push(int value) {
        info[sp++] = value;
    }
}
class App {
    public static void main(String[] args) {
        Stk stk = new Stk();
        stk.push(3);
        stk.push(5);
        System.out.println(stk.info[0]);
        System.out.println(stk.info[1]);
    }
}