কী কারণে জাভা.এল.আরআইইন্ডেক্স আউটঅফফাউন্ডস এক্সসেপশন হয় এবং আমি কীভাবে এটি প্রতিরোধ করব?

298

এর ArrayIndexOutOfBoundsExceptionঅর্থ কী এবং আমি কীভাবে এ থেকে মুক্তি পাব?

এখানে একটি কোড নমুনা যা ব্যতিক্রম ট্রিগার করে:

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

— হারুন
সূত্র

1

শেষ প্রশ্নের প্রসঙ্গে, কোড সহায়ক হবে be আপনি কি কোনও পরিচিত সূচক সহ অ্যারে অ্যাক্সেস করছেন, বা ত্রুটি দেখা দিলে সূচকটি কীভাবে গণনা করা হয় তা নির্ধারণের জন্য আপনাকে ডিবাগিং শুরু করতে হবে?

— 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

লুপের জন্য অ্যারেআইন্ডেক্সআউটআউটবাউন্ডগুলি দেখুন ।

— আইয়ুব

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 সূচক হয় তখন একটি ব্যতিক্রম ছুঁড়ে দেয় here এখানে বৈধ সূচকগুলি 0-4 অন্তর্ভুক্ত। এখানে সঠিক, মূর্খ forবক্তব্য হবে:

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

(এটি ধরে নিয়েছে যে আপনার সূচকের অবশ্যই প্রয়োজন instead আপনি যদি পরিবর্তে লুপের জন্য বর্ধিত ব্যবহার করতে পারেন তবে তা করুন))

— জন স্কিটি
সূত্র

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

এই চমৎকার নিবন্ধ থেকে: অ্যারেআইন্ডেক্সআউটঅফফাউন্ডস এক্সপোশন ইন লুপ

সংক্ষেপে এটি করা:

এর শেষ পুনরাবৃত্তিতে

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");
}

— Makoto
সূত্র

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, এখানে কয়েকটি মূল বিষয় বিবেচনা করতে হবে:

looping

অ্যারের মাধ্যমে লুপিংয়ের সময় সর্বদা নিশ্চিত হয়ে নিন যে আপনি যে সূচকটি পুনরুদ্ধার করছেন সেটি অ্যারের দৈর্ঘ্যের (বাক্সের সংখ্যা) এর চেয়ে কঠোরভাবে ছোট। এই ক্ষেত্রে:

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। একটি অ্যারেতে একটি [এন] আপনি একটি [0] থেকে একটি [এন -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 (যেমন নাম. দৈর্ঘ্য = 3)। তবে এটি সূচক 0 থেকে শুরু করে উপাদান সংরক্ষণ করে, এর সর্বোচ্চ সূচক 2 রয়েছে।

সুতরাং, 'আই ** <= নেমলেথ' এর পরিবর্তে 'অ্যারেআইএনডেক্সআউটআউটবাউন্ডসেক্সেশন' এড়ানোর জন্য আপনার 'আই <** নাম.লেন্থ' লেখা উচিত ।

— নিখিল
সূত্র

3

এই সাধারণ প্রশ্নের জন্য এতটুকু, তবে আমি জাভাতে একটি নতুন বৈশিষ্ট্য হাইলাইট করতে চেয়েছিলাম যা প্রাথমিকভাবে এমনকি অ্যারেগুলিতে সূচকের চারপাশে সমস্ত বিভ্রান্তি এড়াতে পারে। জাভা -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 Hence তাই আপনি যখন অ্যাক্সেস করার চেষ্টা করবেন তখন 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, সরলতার জন্য)।

— টিকটিকিকে বিল দাও
সূত্র

একটি কোড উদাহরণ যোগ করা হয়েছে যখন আমি শর্তটি পরিবর্তন করি তখন আমার জন্য লুপটি কেন কাজ করে না (বহুমাত্রিক অ্যারে)? যেহেতু এই প্রশ্নটি অ্যারেআইন্ডেক্সআউটআউটফাউন্ডসএক্সসেপশন সম্পর্কিত কোনও প্রশ্নের জন্য ডুপ টার্গেট হিসাবে ব্যবহৃত হয়।

— টিকটিকিটি

2

আপাতদৃষ্টিতে রহস্যজনক অ্যারেআইন্ডেক্সআউটঅফফাউন্ডস এক্সেক্সসেশনগুলির জন্য আমি যে সর্বাধিক সাধারণ ঘটনাটি দেখেছি তা হ'ল দৃশ্যত আপনার নিজের অ্যারে হ্যান্ডলিং কোড দ্বারা সৃষ্ট নয়, এটি সিম্পলডেট ফরমেটের একযোগে ব্যবহার। বিশেষত একটি সার্লেট বা নিয়ামক:

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

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

যদি দুটি থ্রেড একসাথে সিম্পলেটডেট ফরমেট.পার্স () পদ্ধতিতে প্রবেশ করে আপনি সম্ভবত একটি অ্যারেআইন্ডেক্সআউটআউটবাউন্ডসেক্সপশন দেখতে পাবেন। সিম্পলডেটফর্ম্যাট জন্য ক্লাস জাভাদোকের সিঙ্ক্রোনাইজেশন বিভাগটি নোট করুন ।

আপনার কোডে এমন কোনও জায়গা নেই যা সরলডেট ফরমেটের মতো থ্রেড অনিরাপদ ক্লাসগুলিতে সার্ভলেট বা নিয়ামকের মতো একযোগে পদ্ধতিতে অ্যাক্সেস করছে Make আপনার সন্দেহভাজনদের জন্য আপনার সার্লেলেট এবং নিয়ন্ত্রকদের সমস্ত উদাহরণ ভেরিয়েবল পরীক্ষা করুন।

— কিরি সারানতাকোস
সূত্র

2

অ্যারেআইন্ডেক্সআউটআউটবাউন্ডসেক্সপশন যখনই এই ব্যতিক্রমটি আসবে এর অর্থ আপনি অ্যারেটির একটি সূচক ব্যবহার করার চেষ্টা করছেন যা এর সীমা ছাড়িয়েছে বা আপনি যে শর্তাবলী শুরু করেছেন তার চেয়ে বেশি অনুরোধ করছেন আপনি যে বিন্যাসের বাইরে রয়েছেন।

এটি প্রতিরোধের জন্য সর্বদা নিশ্চিত হয়ে নিন যে আপনি এমন একটি সূচকের অনুরোধ করছেন না যা অ্যারেতে উপস্থিত নেই অর্থাৎ অ্যারের দৈর্ঘ্য যদি 10 হয় তবে আপনার সূচকটি 0 থেকে 9 এর মধ্যে হতে হবে

— sgrpwr
সূত্র

2

অ্যারেআইন্ডেক্সআউটআউটবাউন্ডস মানে আপনি বরাদ্দ নয় এমন অ্যারের মধ্যে এমন একটি অবস্থানকে সূচীকরণের চেষ্টা করছেন।

এক্ষেত্রে:

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

name.length 3 হ'ল অ্যারে 3 স্ট্রিং অবজেক্টের সাথে সংজ্ঞায়িত করা হয়েছে।
অ্যারের সামগ্রীতে অ্যাক্সেস করার সময়, অবস্থানটি 0 থেকে শুরু হয় Since যেহেতু 3 টি আইটেম রয়েছে তাই এর অর্থ হবে নাম [0] = "টম", নাম [1] = "ডিক" এবং নাম [2] = "হ্যারি
যখন আপনি লুপ করেন, যেহেতু আমি নামের চেয়ে কম বা সমান হতে পারি, আপনি নামটি অ্যাক্সেস করার চেষ্টা করছেন [3] যা উপলভ্য নয়।

এটি কাছাকাছি পেতে ...

আপনার লুপের জন্য, আমি <name = দৈর্ঘ্য করতে পারেন। এটি নামটিতে লুপিং রোধ করবে [3] এবং পরিবর্তে নামটি বন্ধ করবে [2]

for(int i = 0; i<name.length; i++)
প্রতিটি লুপের জন্য একটি ব্যবহার করুন

String[] name = { "tom", "dick", "harry" }; for(String n : name) { System.out.println(n); }
List.forEach (গ্রাহক পদক্ষেপ) ব্যবহার করুন (জাভা 8 প্রয়োজন)

String[] name = { "tom", "dick", "harry" }; Arrays.asList(name).forEach(System.out::println);
অ্যারেটিকে স্ট্রিমে রূপান্তর করুন - আপনি যদি আপনার অ্যারে যেমন অতিরিক্ত 'ক্রিয়াকলাপ' সম্পাদন করতে চান তবে এটি একটি ভাল বিকল্প যেমন ফিল্টার, পাঠ্যকে রূপান্তর করতে, মানচিত্রে রূপান্তর করা (জাভা 8 প্রয়োজন)

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আপনি যখন নাম. দৈর্ঘ্যের সূচকযুক্ত উপাদান অ্যাক্সেস করার চেষ্টা করছেন যা ঘটে না (অ্যারে সূচক দৈর্ঘ্য -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

দৈর্ঘ্যের যে কোনও অ্যারের জন্য, অ্যারের উপাদানগুলির 0 থেকে এন -1 পর্যন্ত একটি সূচক থাকবে।

যদি আপনার প্রোগ্রামটি এন -1 এর চেয়ে বড় অ্যারে সূচকযুক্ত কোনও উপাদান (বা মেমরি) অ্যাক্সেস করার চেষ্টা করছে তবে জাভা অ্যারেআইন্ডেক্সআউটআউটবাউন্ডসেক্সপশনটি ফেলে দেবে

সুতরাং এখানে দুটি সমাধান যা আমরা একটি প্রোগ্রামে ব্যবহার করতে পারি

গণনা বজায় রাখা:

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 এ অ্যাক্সেস করা হবে।

ইনডেক্সআউট অফফাউন্ডস এক্সসেপশনটি কোনও ধরণের সূচকের সূচি (যেমন একটি অ্যারে, একটি স্ট্রিং বা কোনও ভেক্টরের কাছে) সীমা ছাড়িয়েছে তা বোঝাতে নিক্ষেপ করা হয়।

যে কোনও অ্যারে এক্স, [0 থেকে (এক্স দৈর্ঘ্য - 1)] অ্যাক্সেস করা যায়

— ZiadM
সূত্র

1

আমি এখানে সমস্ত উত্তর দেখি যে অ্যারেগুলির সাথে কীভাবে কাজ করতে হয় এবং সীমানা ব্যতিক্রমের বাইরে সূচিটি কীভাবে এড়ানো যায় expla আমি ব্যক্তিগতভাবে যেকোন মূল্যে অ্যারে এড়িয়ে চলি। আমি সংগ্রহ ক্লাস ব্যবহার করি, যা অ্যারে সূচকগুলি সম্পূর্ণরূপে মোকাবেলা করার সমস্ত বোকামি এড়িয়ে চলে। লুপিং কনস্ট্রাক্টসগুলি সংগ্রহে সমর্থনকারী কোডটি সুন্দরভাবে কাজ করে যা লেখার, বোঝার এবং বজায় রাখা উভয়ই সহজ।

— জন সিজুক্কার্মান
সূত্র

1

আপনি যদি লুপের জন্য পুনরাবৃত্তিকে নিয়ন্ত্রণ করতে একটি অ্যারের দৈর্ঘ্য ব্যবহার করেন তবে সর্বদা মনে রাখবেন যে অ্যারের প্রথম আইটেমের সূচক 0 হয় । সুতরাং একটি অ্যারেতে শেষ উপাদানটির সূচক অ্যারের দৈর্ঘ্যের চেয়ে কম less

— সচিথর দিলশান
সূত্র

0

ArrayIndexOutOfBoundsException নাম নিজেই ব্যাখ্যা করে যে আপনি যদি সূচকের মানটিকে অ্যারির আকারের বাইরে রাখার চেষ্টা করতে চান তবে এই জাতীয় ব্যতিক্রম ঘটে exception

আপনার ক্ষেত্রে, আপনি লুপের জন্য কেবল সমান চিহ্নটি সরাতে পারেন।

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

আরও ভাল বিকল্পটি একটি অ্যারের পুনরাবৃত্তি করা হয়:

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

— মধুসূদন শর্মা
সূত্র

0

এই ত্রুটিটি রান লুপ ওভারলিমিট সময়ে ঘটে থাকে's এর মতো সাধারণ উদাহরণ বিবেচনা করুন,

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 + 1] উপাদানটি মুদ্রণ করুন .. (যখন আমার মান 1 হয়, সংখ্যাআরাই [i + 1] উপাদানটি মুদ্রিত হয়।) .. ধরুন, যখন আমি = (সংখ্যাআরাই)। দৈর্ঘ্য -২), অ্যারের শেষ উপাদানটি মুদ্রিত হয় ... যখন 'আমি' মানটি (সংখ্যাআরয়ে দৈর্ঘ্য -১) যায়, মুদ্রণের জন্য কোনও মানই হয় না ... সেই বিন্দুতে, 'অ্যারেআইএনডেক্সআউটআউটবাউন্ডসেক্সপশন' ঘটে যায়।আমি আশা করি আপনি পেতে পারেন ধারণা। ধন্যবাদ!

— GT_hash
সূত্র

0

আপনি এড়াতে ক্রিয়ামূলক শৈলীতে ptionচ্ছিক ব্যবহার করতে পারেন 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
সূত্র