मैं गतिशील रूप से जावा सरणी में आइटम कैसे जोड़ सकता हूं?

Question 1

PHP में, आप गतिशील रूप से निम्न द्वारा सरणियों में तत्व जोड़ सकते हैं:

$x = new Array();
$x[] = 1;
$x[] = 2;

इसके बाद, इस $xतरह एक सरणी होगी {1,2}:।

क्या जावा में कुछ ऐसा ही करने का एक तरीका है?

Question 2

Java.util को देखें।लिंकडलिस्ट या java.util.ArrayList

List<Integer> x = new ArrayList<Integer>();
x.add(1);
x.add(2);

Question 3

जावा में एरर्स का एक निश्चित आकार है, इसलिए आप पीएचपी में जैसा कर सकते हैं वैसा कुछ "अंत में नहीं जोड़ सकते हैं"।

PHP व्यवहार के समान एक सा है:

int[] addElement(int[] org, int added) {
    int[] result = Arrays.copyOf(org, org.length +1);
    result[org.length] = added;
    return result;
}

तो आप लिख सकते हैं:

x = new int[0];
x = addElement(x, 1);
x = addElement(x, 2);

System.out.println(Arrays.toString(x));

लेकिन यह योजना बड़ी सरणियों के लिए बहुत ही अयोग्य है , क्योंकि यह हर बार पूरे सरणी की एक प्रति बनाती है। (और यह वास्तव में पूरी तरह से PHP के समतुल्य नहीं है, क्योंकि आपकी पुरानी सरणियाँ वही रहती हैं)।

PHP सरणियाँ वास्तव में एक अतिरिक्त "अधिकतम कुंजी" के साथ एक जावा हैशपॅप के समान हैं, इसलिए यह पता चलेगा कि आगे किस कुंजी का उपयोग करना है, और एक अजीब पुनरावृत्ति क्रम (और पूर्णांक संबंध और कुछ स्ट्रिंग्स के बीच एक अजीब समानता का संबंध)। लेकिन सरल अनुक्रमित संग्रह के लिए, अन्य उत्तरदाताओं की तरह जावा में एक सूची का बेहतर उपयोग करें।

यदि आप Listइंटेगर में हर इंट को लपेटने के ओवरहेड के कारण उपयोग करने से बचना चाहते हैं , तो आदिम प्रकारों के लिए संग्रह के पुन: कार्यान्वयन का उपयोग करने पर विचार करें, जो आंतरिक रूप से सरणियों का उपयोग करते हैं, लेकिन हर बदलाव पर एक प्रति नहीं करेंगे, केवल आंतरिक सरणी पूर्ण होने पर ArrayList की तरह)। (एक जल्दी से जाना जाता उदाहरण इस IntList वर्ग है ।)

अमरूद में शामिल है इस तरह के रैपर बनाने के तरीकों में Ints.asList, Longs.asListआदि

Question 4

अपाचे कॉमन्स में नए सरणी के अंत में एक तत्व जोड़ने के लिए एक ArrayUtils कार्यान्वयन है:

/** Copies the given array and adds the given element at the end of the new array. */
public static <T> T[] add(T[] array, T element)

Question 5

मैंने इस प्रश्न को वेब और मेरी राय में बहुत बार देखा है, उच्च प्रतिष्ठा वाले कई लोगों ने इन सवालों का ठीक से जवाब नहीं दिया। इसलिए मैं यहां अपना जवाब व्यक्त करना चाहूंगा।

पहले हमें विचार करना चाहिए कि और के बीच अंतर है ।arrayarraylist

एक तत्व को एक सरणी में जोड़ने के लिए प्रश्न पूछता है , और न कि ArrayList

जवाब बहुत सरल है। इसे 3 चरणों में किया जा सकता है।

सरणी को एक सरणी सूची में बदलें
तत्व को arrayList में जोड़ें
नई arrayList को array में कन्वर्ट करें

यहाँ इसका साधारण चित्र दिया गया है

और अंत में यहाँ कोड है:

चरण 1:

public List<String> convertArrayToList(String[] array){
        List<String> stringList = new ArrayList<String>(Arrays.asList(array));
        return stringList;
    }

चरण 2:

public  List<String> addToList(String element,List<String> list){

            list.add(element);
            return list;
    }

चरण 3:

public String[] convertListToArray(List<String> list){
           String[] ins = (String[])list.toArray(new String[list.size()]);
           return ins;
    }

चरण 4

public String[] addNewItemToArray(String element,String [] array){
        List<String> list = convertArrayToList(array);
        list= addToList(element,list);
        return  convertListToArray(list);
}

Question 6

आप एक का उपयोग कर सकते हैं ArrayListऔर फिर toArray()विधि का उपयोग कर सकते हैं । लेकिन आप जो कर रहे हैं, उसके आधार पर, आपको एक सरणी की भी आवश्यकता नहीं हो सकती है। देखने में देखो Listsकि क्या आप चाहते हैं और अधिक कर रहे हैं।

देखें: जावा सूची ट्यूटोरियल

Question 7

आप शायद इसके लिए एक ArrayList का उपयोग करना चाहते हैं - संरचना की तरह गतिशील आकार सरणी के लिए।

Question 8

आप गतिशील रूप से JAVA में संग्रह चौखटे का उपयोग करके एक सरणी में तत्वों को जोड़ सकते हैं। संग्रह फ्रेमवर्क आदिम डेटा प्रकारों पर काम नहीं करता है।

यह कलेक्शन फ्रेमवर्क "java.util। *" पैकेज में उपलब्ध होगा

उदाहरण के लिए यदि आप ArrayList का उपयोग करते हैं,

उस पर एक ऑब्जेक्ट बनाएं और फिर तत्वों की संख्या जोड़ें (किसी भी प्रकार जैसे स्ट्रिंग, इंटेगर ... आदि)

ArrayList a = new ArrayList();
a.add("suman");
a.add(new Integer(3));
a.add("gurram");

अब आपको एक एरे में 3 एलिमेंट्स जोड़े गए।

यदि आप किसी भी जोड़े गए तत्वों को हटाना चाहते हैं

a.remove("suman");

यदि आप किसी भी तत्व को जोड़ना चाहते हैं तो फिर से

a.add("Gurram");

तो सरणी का आकार बढ़ रहा है / गतिशील रूप से घट रहा है।

Question 9

सरणी आकार को बढ़ाने के लिए सरणियों के लिए एक ArrayList या बाजीगरी का उपयोग करें।

Question 10

जहां आप आदिम सरणी में हैं, उसकी एक गणना रखें

class recordStuff extends Thread
{
    double[] aListOfDoubles;
    int i = 0;

    void run()
    {
        double newData;
        newData = getNewData(); // gets data from somewhere

        aListofDoubles[i] = newData; // adds it to the primitive array of doubles
        i++ // increments the counter for the next pass

        System.out.println("mode: " + doStuff());
    }

    void doStuff()
    {
        // Calculate the mode of the double[] array

        for (int i = 0; i < aListOfDoubles.length; i++) 
        {
            int count = 0;
            for (int j = 0; j < aListOfDoubles.length; j++)
            {
                if (a[j] == a[i]) count++;
            }
            if (count > maxCount) 
            {
                maxCount = count;
                maxValue = aListOfDoubles[i];
            }
        }
        return maxValue;
    }
}

Question 11

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

    int [] test = {12,22,33};
    int [] test2= new int[test.length+1];
    int m=5;int mz=0;
    for ( int test3: test)        
    {          
    test2[mz]=test3; mz++;        
    } 
    test2[mz++]=m;
    test=test2;

    for ( int test3: test)

    {
      System.out.println(test3);
    }

Question 12

जावा में सरणी का आकार निश्चित है, लेकिन आप इसके सूचकांक का उपयोग करते हुए और लूप के लिए एक निश्चित आकार के सरणी में तत्वों को गतिशील रूप से जोड़ सकते हैं। कृपया नीचे उदाहरण देखें।

package simplejava;

import java.util.Arrays;

/**
 *
 * @author sashant
 */
public class SimpleJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        try{
            String[] transactions;
            transactions = new String[10];

            for(int i = 0; i < transactions.length; i++){
                transactions[i] = "transaction - "+Integer.toString(i);            
            }

            System.out.println(Arrays.toString(transactions));

        }catch(Exception exc){
            System.out.println(exc.getMessage());
            System.out.println(Arrays.toString(exc.getStackTrace()));
        }
    }

}