Java.lang.ArrayIndexOutOfBoundsException का क्या कारण है और मैं इसे कैसे रोकूं?

298

ArrayIndexOutOfBoundsExceptionइसका क्या मतलब है और मैं इससे कैसे छुटकारा पाऊं?

यहाँ एक कोड नमूना है जो अपवाद को ट्रिगर करता है:

String[] names = { "tom", "bob", "harry" };
for (int i = 0; i <= names.length; i++) {
    System.out.println(names[i]);
}

— हारून
स्रोत

1

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

— justkt

43

के i <= name.lengthसाथ बदलें i < name.length- या बेहतर, लूप के लिए एक बढ़ाया लिखें। ( for (String aName : name) { ... })

— जीन होमिनल

1

इसका अर्थ है, कि आप ऐसे तत्व को प्राप्त करना चाहते हैं जो मौजूद नहीं हैं, 'i <= name.length' का अर्थ है कि आप तत्व की लंबाई + 1 प्राप्त करना चाहते हैं - इसका अस्तित्व नहीं है।

— gbk

en.wikipedia.org/wiki/Off-by-one_error

— sakhunzai

लूप के लिए ArrayIndexOutOfBounds देखें ।

— aioobe

296

कॉल का आपका पहला पोर्ट प्रलेखन होना चाहिए जो इसे स्पष्ट रूप से स्पष्ट करता है:

यह इंगित करने के लिए फेंक दें कि एक सरणी को एक अवैध सूचकांक के साथ एक्सेस किया गया है। सूचकांक या तो ऋणात्मक है या सरणी के आकार के बराबर या उससे अधिक है।

उदाहरण के लिए:

int[] array = new int[5];
int boom = array[10]; // Throws the exception

कैसे से बचने के लिए के रूप में ... उम, ऐसा मत करो। अपने ऐरे इंडेक्स के साथ सावधान रहें।

एक समस्या जिसे लोग कभी-कभी चलाते हैं वह सोच रहा है कि सरणियाँ 1-अनुक्रमित हैं, उदाहरण के लिए

int[] array = new int[5];
// ... populate the array here ...
for (int index = 1; index <= array.length; index++)
{
    System.out.println(array[index]);
}

यह पहला तत्व याद करेगा (इंडेक्स 0) और जब इंडेक्स 5. हो तो अपवाद छोड़ दें। यहां वैध इंडेक्स 0-4 शामिल हैं। यहाँ सही, मुहावरेदार forकथन होगा:

for (int index = 0; index < array.length; index++)

(यह मानते हुए कि आपको सूचकांक की आवश्यकता है, निश्चित रूप से। यदि आप लूप के बदले संवर्धित का उपयोग कर सकते हैं, तो ऐसा करें।)

— जॉन स्कीट
स्रोत

1

मुझे लगता है कि जावा में एक मनमाना आकार हो सकता है कि बहुआयामी सरणियों के लिए जोड़ सकते हैं, नेस्टेड छोरों को प्रासंगिक सबर्रे लंबाई के लिए जाँच करनी चाहिए

for (int nestedIndex = 0; nestedIndex < array[outerIndex].length; nestedIndex++) { ... array[outerIndex][nestedIndex] ... }

:।

— एंड्री

52

if (index < 0 || index >= array.length) {
    // Don't use this index. This is out of bounds (borders, limits, whatever).
} else {
    // Yes, you can safely use this index. The index is present in the array.
    Object element = array[index];
}

यह सभी देखें:

जावा ट्यूटोरियल्स - लैंग्वेज बेसिक्स - एरेस

अपडेट : अपने कोड स्निपेट के अनुसार,

for (int i = 0; i<=name.length; i++) {

सूचकांक सरणी की लंबाई को सम्मिलित करता है। यह सीमा से बाहर है। आपको <=द्वारा प्रतिस्थापित करने की आवश्यकता है <।

for (int i = 0; i < name.length; i++) {

— BalusC
स्रोत

22

इस उत्कृष्ट लेख से: लूप के लिए ArrayIndexOutOfBoundsException

इसे संक्षेप में रखने के लिए:

के अंतिम पुनरावृत्ति में

for (int i = 0; i <= name.length; i++) {

i बराबर होगा name.length जो एक अवैध सूचकांक है, क्योंकि सरणी सूचकांक शून्य-आधारित हैं।

आपका कोड पढ़ना चाहिए

for (int i = 0; i < name.length; i++) 
                  ^

— aioobe
स्रोत

17

इसका मतलब है कि आप किसी ऐसे ऐरे के इंडेक्स को एक्सेस करने की कोशिश कर रहे हैं जो मान्य नहीं है क्योंकि यह सीमा के बीच में नहीं है।

उदाहरण के लिए यह ऊपरी बाउंड 4 के साथ एक आदिम पूर्णांक सरणी को इनिशियलाइज़ करेगा।

int intArray[] = new int[5];

प्रोग्रामर की गिनती शून्य से होती है। इसलिए यह उदाहरण के ArrayIndexOutOfBoundsExceptionलिए ऊपरी सीमा 4 है और 5 नहीं है।

intArray[5];

— ऑक्टेवियन ए। डामियन
स्रोत

4

सीमा सीमा के भीतर हैं। अर्थात; 0-5

— जॉन गोट्टा

11

एक सरणी इंडेक्स आउट-ऑफ-बाउंड अपवाद से बचने के लिए, किसी को एन्हांस्डfor स्टेटमेंट का उपयोग करना चाहिए, जहां और जब वे कर सकते हैं।

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

आपको गारंटी दी जाती है कि ऐसा करते समय तत्वों से बाहर न भागें, और आपका [सही] उदाहरण आसानी से बदल दिया जाता है।

नीचे दिए गए कोड:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i< name.length; i++) {
    System.out.print(name[i] + "\n");
}

... इसके बराबर है:

String[] name = {"tom", "dick", "harry"};
for(String firstName : name) {
    System.out.println(firstName + "\n");
}

— माकोटो
स्रोत

11

क्या कारण हैं ArrayIndexOutOfBoundsException?

यदि आप एक "बॉक्स" के रूप में एक चर के बारे में सोचते हैं जहां आप एक मूल्य रख सकते हैं, तो एक सरणी प्रत्येक अभिभावक के बगल में रखी गई बक्से की एक श्रृंखला है, जहां बक्से की संख्या एक परिमित और स्पष्ट पूर्णांक है।

इस तरह एक सरणी बनाना:

final int[] myArray = new int[5]

5 बक्से की एक पंक्ति बनाता है, प्रत्येक एक पकड़े int। प्रत्येक बक्से में एक सूचकांक होता है, बक्से की श्रृंखला में एक स्थिति। यह सूचकांक 0 से शुरू होता है, और एन -1 पर समाप्त होता है, जहां एन सरणी का आकार (बक्से की संख्या) है।

बक्से की इस श्रृंखला से किसी एक मान को पुनः प्राप्त करने के लिए, आप इसे इसके सूचकांक के माध्यम से संदर्भित कर सकते हैं, जैसे:

myArray[3]

जो आपको श्रृंखला में चौथे बॉक्स का मूल्य देगा (चूंकि पहले बॉक्स में सूचकांक 0 है)।

एक ArrayIndexOutOfBoundsException"बॉक्स" को वापस लेने की कोशिश करने के कारण होता है जो मौजूद नहीं है, एक इंडेक्स पास करने से जो पिछले "बॉक्स" के सूचकांक से अधिक है, या नकारात्मक है।

मेरे चल रहे उदाहरण के साथ, ये कोड स्निपेट ऐसा अपवाद उत्पन्न करेंगे:

myArray[5] //tries to retrieve the 6th "box" when there is only 5
myArray[-1] //just makes no sense
myArray[1337] //waay to high

कैसे बचें ArrayIndexOutOfBoundsException

रोकने के लिए ArrayIndexOutOfBoundsException, विचार करने के लिए कुछ प्रमुख बिंदु हैं:

लूपिंग

जब एक सरणी के माध्यम से लूपिंग करते हैं, तो हमेशा सुनिश्चित करें कि आप जो इंडेक्स प्राप्त कर रहे हैं वह सरणी की लंबाई (बक्से की संख्या) से कड़ाई से छोटा है। उदाहरण के लिए:

for (int i = 0; i < myArray.length; i++) {

नोटिस <, =वहाँ में एक मिश्रण कभी नहीं ..

आप इस तरह से कुछ करने के लिए लुभा सकते हैं:

for (int i = 1; i <= myArray.length; i++) {
    final int someint = myArray[i - 1]

बस नहीं है। ऊपर वाले से चिपके रहें (यदि आपको सूचकांक का उपयोग करने की आवश्यकता है) और यह आपको बहुत दर्द से बचाएगा।

जहां संभव हो, फॉरच का उपयोग करें:

for (int value : myArray) {

इस तरह से आपको इंडेक्स के बारे में बिल्कुल नहीं सोचना पड़ेगा।

जब आप कुछ भी करते हैं तो लूपिंग, लूप इटरेटर का मान बदल देते हैं (यहाँ:) i। यह एकमात्र स्थान होना चाहिए जिसमें मूल्य बदलना चाहिए, लूप को चालू रखना है। इसे बदलना अन्यथा केवल एक अपवाद है, और ज्यादातर मामलों में परिवादात्मक नहीं है।

पुनर्प्राप्ति / अद्यतन

सरणी का एक मनमाना तत्व प्राप्त करते समय, हमेशा जांचें कि यह सरणी की लंबाई के विरुद्ध एक वैध सूचकांक है:

public Integer getArrayElement(final int index) {
    if (index < 0 || index >= myArray.length) {
        return null; //although I would much prefer an actual exception being thrown when this happens.
    }
    return myArray[index];
}

— Tobb
स्रोत

6

आपके कोड में आपने इंडेक्स 0 से स्ट्रिंग ऐरो की लंबाई तक तत्वों को एक्सेस किया है। name.lengthस्ट्रिंग वस्तुओं की संख्या में स्ट्रिंग ऑब्जेक्ट्स की संख्या देता है अर्थात 3, लेकिन आप केवल अनुक्रमणिका 2 तक पहुँच सकते हैं name[2], क्योंकि सरणी को अनुक्रमणिका 0 से name.length - 1जहाँ आप प्राप्त करते हैं, तक पहुँचा जा सकता है।name.length ऑब्जेक्ट की संख्या ।

यहां तक कि एक forलूप का उपयोग करते समय आपने सूचकांक शून्य के साथ शुरू किया है और आपको समाप्त होना चाहिए name.length - 1। एक सरणी में [एन] आप एक [एन] के रूप में [एन -१] तक पहुंच सकते हैं।

उदाहरण के लिए:

String[] a={"str1", "str2", "str3" ..., "strn"};

for(int i=0;i<a.length()i++)
    System.out.println(a[i]);

आपके मामले में:

String[] name = {"tom", "dick", "harry"};

for(int i = 0; i<=name.length; i++) {
    System.out.print(name[i] +'\n');
}

— मधुसूदन चौधरी
स्रोत

5

आपके दिए गए सरणी के लिए सरणी की लंबाई 3 है (यानी name.length = 3)। लेकिन जब यह इंडेक्स 0 से शुरू होने वाले तत्व को स्टोर करता है, तो इसमें अधिकतम इंडेक्स 2 होता है।

तो, 'i ** <= name.length' के बजाय आपको ' ArrayIndexOutOfBoundsException' से बचने के लिए 'i <** name.length' लिखना चाहिए ।

— निखिल
स्रोत

3

इस सरल प्रश्न के लिए बहुत कुछ है, लेकिन मैं सिर्फ जावा में एक नई सुविधा को उजागर करना चाहता था जो शुरुआती लोगों के लिए सरणियों में अनुक्रमण के आसपास सभी भ्रमों से बचना होगा। Java-8 ने आपके लिए पुनरावृति के कार्य को समाप्त कर दिया है।

int[] array = new int[5];

//If you need just the items
Arrays.stream(array).forEach(item -> { println(item); });

//If you need the index as well
IntStream.range(0, array.length).forEach(index -> { println(array[index]); })

फायदा क्या है? वैसे, एक बात अंग्रेजी जैसी पठनीयता है। दूसरा, आपको चिंता करने की आवश्यकता नहीं हैArrayIndexOutOfBoundsException

— सत्येंद्र कुमार
स्रोत

3

तुम भाग के ArrayIndexOutOfBoundsExceptionकारण हो रहे हो i<=name.length। name.lengthस्ट्रिंग की लंबाई लौटाएं name, जो 3. है। इसलिए जब आप एक्सेस करने की कोशिश करते हैं name[3], तो यह अवैध है और एक अपवाद फेंकता है।

हल कोड:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i < name.length; i++) { //use < insteadof <=
  System.out.print(name[i] +'\n');
}

यह जावा भाषा विनिर्देश में परिभाषित किया गया है :

public finalक्षेत्र lengthहै, जो सरणी के घटकों की संख्या में शामिल है। lengthसकारात्मक या शून्य हो सकता है।

— roottraveller
स्रोत

3

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

myArray[5]

त्रुटि तब डाली जाती है जब आप एक इंडेक्स तक पहुंचने का प्रयास करते हैं जो उस सरणी में मौजूद नहीं होता है। यदि किसी सरणी की लंबाई 3 है,

int[] intArray = new int[3];

तब केवल मान्य अनुक्रमित हैं:

intArray[0]
intArray[1]
intArray[2]

यदि किसी सरणी की लंबाई 1 है,

int[] intArray = new int[1];

उसके बाद एकमात्र वैध सूचकांक है:

intArray[0]

सरणी की लंबाई के बराबर या उससे बड़ा कोई भी पूर्णांक: सीमा से बाहर है।

0 से कम कोई भी पूर्णांक: सीमा से बाहर है;

पुनश्च: यदि आप सरणियों की बेहतर समझ रखते हैं और कुछ व्यावहारिक अभ्यास करते हैं, तो यहां एक वीडियो है: जावा में सरणियों पर ट्यूटोरियल

— जॉनी
स्रोत

3

बहुआयामी सरणियों के लिए, यह सुनिश्चित करने के लिए मुश्किल हो सकता है कि आप lengthसही आयाम की संपत्ति का उपयोग कर सकें । उदाहरण के लिए निम्न कोड लें:

int [][][] a  = new int [2][3][4];

for(int i = 0; i < a.length; i++){
    for(int j = 0; j < a[i].length; j++){
        for(int k = 0; k < a[j].length; k++){
            System.out.print(a[i][j][k]);
        }
        System.out.println();
    }
    System.out.println();
}

प्रत्येक आयाम की एक अलग लंबाई होती है, इसलिए सूक्ष्म बग यह है कि मध्य और आंतरिक छोर lengthएक ही आयाम की संपत्ति का उपयोग करते हैं (क्योंकिa[i].length जैसा है a[j].length)।

इसके बजाय, आंतरिक लूप का उपयोग करना चाहिए a[i][j].length(या a[0][0].length, सादगी के लिए)।

— छिपकली का बिल
स्रोत

जब मैं स्थिति (बहुआयामी सरणियों) को बदलता हूं तो मेरे लिए लूप का काम क्यों नहीं करता है, से एक कोड उदाहरण जोड़ा गया ? चूँकि यह प्रश्न ArrayIndexOutOfBoundsException से निपटने वाले किसी भी प्रश्न के लिए एक लक्ष्य के रूप में उपयोग किया जाता है।

— छिपकली

2

सबसे सामान्य मामला जो मैंने रहस्यमय रूप से ArrayIndexOutOfBoundsException के लिए देखा है, यानी जाहिरा तौर पर आपके खुद के सरणी हैंडलिंग कोड के कारण नहीं होता है, यह SimpleDateFormat का समवर्ती उपयोग है। विशेष रूप से एक सर्वलेट या कंट्रोलर में:

public class MyController {
  SimpleDateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy");

  public void handleRequest(ServletRequest req, ServletResponse res) {
    Date date = dateFormat.parse(req.getParameter("date"));
  }
}

यदि दो धागे SimplateDateFormat.parse () विधि में एक साथ प्रवेश करते हैं, तो आप संभवतः एक ArrayIndexOutOfBoundsException देखेंगे। SimpleDateFormat के लिए वर्ग javadoc के सिंक्रनाइज़ेशन अनुभाग पर ध्यान दें ।

सुनिश्चित करें कि आपके कोड में ऐसी कोई जगह नहीं है जो समवर्ती या नियंत्रक जैसे समवर्ती तरीके से SimpleDateFormat जैसे थ्रेड असुरक्षित वर्गों तक पहुँच रहे हैं। संभावित संदिग्धों के लिए अपने सर्वलेट्स और नियंत्रकों के सभी उदाहरण चर देखें।

— क्यारी श्रांतकोस
स्रोत

2

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

इसे रोकने के लिए हमेशा सुनिश्चित करें कि आप किसी ऐसे सूचकांक का अनुरोध नहीं कर रहे हैं जो सरणी में मौजूद नहीं है अर्थात यदि सरणी की लंबाई 10 है तो आपके सूचकांक को 0 से 9 के बीच होना चाहिए

— sgrpwr
स्रोत

2

ArrayIndexOutOfBounds का मतलब है कि आप किसी ऐसे सरणी के भीतर स्थिति को अनुक्रमित करने का प्रयास कर रहे हैं जो आवंटित नहीं है।

इस मामले में:

String[] name = { "tom", "dick", "harry" };
for (int i = 0; i <= name.length; i++) {
    System.out.println(name[i]);
}

name.length 3 है क्योंकि सरणी को 3 स्ट्रिंग वस्तुओं के साथ परिभाषित किया गया है।
किसी ऐरे की सामग्री को एक्सेस करते समय, स्थिति 0. से शुरू होती है क्योंकि 3 आइटम हैं, इसका मतलब होगा नाम [0] = "टॉम", नाम [1] = "डिक" और नाम [2] = "हैरी"
जब आप लूप करते हैं, चूंकि मैं name.length से कम या बराबर हो सकता हूं, तो आप नाम [3] तक पहुंचने की कोशिश कर रहे हैं जो उपलब्ध नहीं है।

इसके आसपास जाने के लिए ...

अपने लूप के लिए, आप i <name.length कर सकते हैं। यह नाम के लिए लूपिंग को रोक देगा [3] और इसके बजाय नाम पर रोक देगा [2]

for(int i = 0; i<name.length; i++)
प्रत्येक लूप के लिए उपयोग करें

String[] name = { "tom", "dick", "harry" }; for(String n : name) { System.out.println(n); }
सूची का उपयोग करें। प्रत्येक (उपभोक्ता कार्रवाई) (Java8 की आवश्यकता है)

String[] name = { "tom", "dick", "harry" }; Arrays.asList(name).forEach(System.out::println);
सरणी को स्ट्रीम में परिवर्तित करें - यह एक अच्छा विकल्प है यदि आप अपने सरणी में अतिरिक्त 'ऑपरेशन' करना चाहते हैं जैसे फ़िल्टर, टेक्स्ट को रूपांतरित करना, मानचित्र में बदलना आदि (Java8 की आवश्यकता है)

String[] name = { "tom", "dick", "harry" }; --- Arrays.asList(name).stream().forEach(System.out::println); --- Stream.of(name).forEach(System.out::println);

— martinywwan
स्रोत

1

ArrayIndexOutOfBoundsExceptionइसका मतलब है कि आप उस सरणी के एक सूचकांक तक पहुँचने का प्रयास कर रहे हैं जो मौजूद नहीं है या इस सरणी के बाउंड से बाहर है। ऐरे इंडेक्स 0 से शुरू होते हैं और लंबाई - 1 पर समाप्त होते हैं ।

आपके मामले में

for(int i = 0; i<=name.length; i++) {
    System.out.print(name[i] +'\n'); // i goes from 0 to length, Not correct
}

ArrayIndexOutOfBoundsExceptionतब होता है जब आप name.length अनुक्रमित तत्व तक पहुंचने का प्रयास कर रहे हैं जो मौजूद नहीं है (सरणी सूचकांक लंबाई -1 पर समाप्त होता है)। बस <= के साथ <इस समस्या को हल करेगा।

for(int i = 0; i < name.length; i++) {
    System.out.print(name[i] +'\n');  // i goes from 0 to length - 1, Correct
}

— adn.911
स्रोत

1

लंबाई n के किसी भी सरणी के लिए, सरणी के तत्वों में 0 से n-1 तक का एक सूचकांक होगा।

यदि आपका प्रोग्राम n-1 से अधिक एरे इंडेक्स वाले किसी भी तत्व (या मेमोरी) को एक्सेस करने की कोशिश कर रहा है, तो जावा ArrayIndexOutOfBoundsException फेंक देगा

तो यहाँ दो समाधान हैं जिनका उपयोग हम एक कार्यक्रम में कर सकते हैं

बनाए रखने की गिनती:

for(int count = 0; count < array.length; count++) {
    System.out.println(array[count]);
}

या कुछ अन्य लूपिंग स्टेटमेंट की तरह

int count = 0;
while(count < array.length) {
    System.out.println(array[count]);
    count++;
}

प्रत्येक लूप के लिए एक बेहतर तरीका है, इस विधि में एक प्रोग्रामर को सरणी में तत्वों की संख्या के बारे में परेशान करने की कोई आवश्यकता नहीं है।
```
for(String str : array) {
    System.out.println(str);
}
```

— मोहित
स्रोत

1

आपके कोड के अनुसार:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i<=name.length; i++) {
  System.out.print(name[i] +'\n');
}

यदि आप System.out.print (name.length) की जांच करते हैं;

आपको 3 मिलेंगे;

इसका मतलब है कि आपके नाम की लंबाई 3 है

आपका लूप 0 से 3 तक चल रहा है, जिसे "0 से 2" या "1 से 3" होना चाहिए

उत्तर

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i<name.length; i++) {
  System.out.print(name[i] +'\n');
}

— अभिषेक अग्रवाल
स्रोत

1

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

IndexOutOfBoundsException को यह इंगित करने के लिए फेंक दिया जाता है कि किसी प्रकार का एक सूचकांक (जैसे कि एक सरणी के लिए, एक स्ट्रिंग के लिए, या एक वेक्टर के लिए) सीमा से बाहर है।

किसी भी सरणी X, [0 से (X.length - 1)] तक पहुँचा जा सकता है

— ZiadM
स्रोत

1

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

— जॉन Czukkermann
स्रोत

1

यदि आप किसी लूप के लिए पुनरावृत्ति को नियंत्रित करने के लिए किसी सरणी की लंबाई का उपयोग करते हैं , तो हमेशा याद रखें कि किसी सरणी में पहले आइटम का सूचकांक 0 है । तो एक सरणी में अंतिम तत्व का सूचकांक सरणी की लंबाई से कम है।

— सचित्र दिलशान
स्रोत

0

ArrayIndexOutOfBoundsException नाम ही बताता है कि यदि आप उस इंडेक्स पर मान को एक्सेस करने का प्रयास कर रहे हैं जो एरे आकार के दायरे से बाहर है तो इस तरह के अपवाद होते हैं।

आपके मामले में, आप लूप के लिए अपने साइन से समान चिह्न हटा सकते हैं।

for(int i = 0; i<name.length; i++)

एक सरणी को पुनरावृत्त करने के लिए बेहतर विकल्प है:

for(String i : name )
      System.out.println(i);

— मधुसूदन शर्मा
स्रोत

0

यह त्रुटि रन लूप ओवरलिमिट समय पर होती है। इस तरह से सरल उदाहरण पर विचार करें,

class demo{
  public static void main(String a[]){

    int[] numberArray={4,8,2,3,89,5};

    int i;

    for(i=0;i<numberArray.length;i++){
        System.out.print(numberArray[i+1]+"  ");
    }
}

सबसे पहले, मैंने 'सरणी' के रूप में एक सरणी शुरू की है। फिर, कुछ सरणी तत्वों को लूप के लिए उपयोग करके मुद्रित किया जाता है। जब लूप 'i' टाइम चल रहा होता है, तो संख्या (संख्याअरे [i + 1] तत्व को प्रिंट करें ((जब मैं मान 1 होता है, तो संख्या [i + 1] तत्व मुद्रित किया जाता है।) .. मान लीजिए कि, जब मैं = (संख्याअरे। लम्बाई -2), सरणी का अंतिम तत्व मुद्रित होता है। जब 'i' मान (नंबरआरे.लिफ्टिंग -1) पर जाता है, मुद्रण के लिए कोई मूल्य नहीं होता है। उस बिंदु पर, 'ArrayIndexOutOfBoundsException' होती है। मुझे आपसे आशा है। idea.thank you!

— GT_hash
स्रोत

0

आप बचने के लिए कार्यात्मक शैली में वैकल्पिक का उपयोग कर सकते हैं NullPointerExceptionऔर ArrayIndexOutOfBoundsException:

String[] array = new String[]{"aaa", null, "ccc"};
for (int i = 0; i < 4; i++) {
    String result = Optional.ofNullable(array.length > i ? array[i] : null)
            .map(x -> x.toUpperCase()) //some operation here
            .orElse("NO_DATA");
    System.out.println(result);
}

आउटपुट:

AAA
NO_DATA
CCC
NO_DATA

— एंड्री लव्रुखिन
स्रोत

-4

आप अपने सरणी की लंबाई से अधिक डेटा को पुनरावृत्त या संग्रहीत नहीं कर सके। इस मामले में आप ऐसा कर सकते हैं:

for (int i = 0; i <= name.length - 1; i++) {
    // ....
}

या यह:

for (int i = 0; i < name.length; i++) {
    // ...
}

— Kevin7
स्रोत