Apa yang dimaksud dengan ArrayIndexOutOfBoundsException
berarti dan bagaimana saya menyingkirkan itu?
Berikut ini adalah contoh kode yang memicu pengecualian:
String[] name = { "tom", "dick", "harry" };
for (int i = 0; i <= name.length; i++) {
System.out.println(name[i]);
}
Pelabuhan pertama yang harus dokumentasi yang menjelaskan hal itu cukup jelas:
Dilemparkan untuk menunjukkan bahwa array yang telah diakses dengan ilegal indeks. Indeks ini baik negatif atau lebih besar dari atau sama dengan ukuran dari array.
Jadi misalnya:
int[] array = new int[5];
int boom = array[10]; // Throws the exception
Adapun cara untuk menghindari itu... um, don't melakukan itu. Hati-hati dengan indeks array.
Salah satu masalah orang-orang kadang-kadang mengalami berpikir bahwa array 1-diindeks, misalnya
int[] array = new int[5];
// ... populate the array here ...
for (int index = 1; index <= array.length; index++)
{
System.out.println(array[index]);
}
Yang akan kehilangan elemen pertama (index 0) dan melempar pengecualian ketika indeks 5. Berlaku indeks berikut ini adalah 0-4 inklusif. Yang benar, idiomatik untuk
pernyataan di sini akan sama:
for (int index = 0; index < array.length; index++)
(Yang's dengan asumsi anda perlu indeks, tentu saja. Jika anda dapat menggunakan ditingkatkan untuk loop sebaliknya, jangan begitu.)
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];
}
Update: sesuai kode snippet,
for (int i = 0; i<=name.length; i++) {
Indeks ini termasuk array's panjang. Ini adalah di luar batas. Anda perlu mengganti <=
by <
.
for (int i = 0; i < name.length; i++) {
Dari artikel ini sangat baik: ArrayIndexOutOfBoundsException untuk loop
Untuk menempatkan ini secara singkat:
Di akhir iterasi
for (int i = 0; i <= name.length; i++) {
aku
akan sama dengan nama.panjang
yang ilegal indeks karena indeks array adalah berbasis nol.
Kode anda harus baca
for (int i = 0; i < name.length; i++)
^
Itu berarti bahwa anda sedang mencoba untuk mengakses index array yang tidak valid karena tidak di antara batas.
Untuk contoh ini akan menginisialisasi primitif integer array dengan batas atas 4.
int intArray[] = new int[5];
Programmer menghitung dari nol. Jadi, ini misalnya akan membuang ArrayIndexOutOfBoundsException
sebagai batas atas adalah 4 dan 5.
intArray[5];
Apa yang menyebabkan ArrayIndexOutOfBoundsException
?
Jika anda berpikir dari sebuah variabel sebagai "kotak" di mana anda dapat menempatkan sebuah nilai, maka array adalah serangkaian kotak yang ditempatkan di samping satu sama lain, di mana jumlah kotak yang terbatas dan eksplisit integer.
Membuat array seperti ini:
final int[] myArray = new int[5]
menciptakan deretan 5 kotak, masing-masing memegang sebuah int
. Masing-masing kotak memiliki indeks, posisi di seri kotak. Indeks dimulai dari 0, dan berakhir pada N-1, dimana N adalah ukuran dari array (jumlah kotak).
Untuk mengambil salah satu dari nilai-nilai dari seri ini dari kotak, anda bisa lihat melalui indeks, seperti ini:
myArray[3]
Yang akan memberikan anda nilai dari 4 kotak di seri (karena kotak pertama memiliki indeks 0).
Sebuah ArrayIndexOutOfBoundsException
disebabkan oleh mencoba untuk retrive "kotak" yang tidak ada, dengan melewati sebuah indeks yang lebih tinggi dari indeks terakhir "kotak", atau negatif.
Dengan menjalankan contoh, cuplikan kode ini akan menghasilkan seperti pengecualian:
myArray[5] //tries to retrieve the 6th "box" when there is only 5
myArray[-1] //just makes no sense
myArray[1337] //waay to high
Cara menghindari ArrayIndexOutOfBoundsException
Dalam rangka untuk mencegah ArrayIndexOutOfBoundsException
, ada beberapa poin-poin penting untuk mempertimbangkan:
Perulangan
Ketika perulangan melalui array, selalu pastikan bahwa indeks anda mengambil lebih ketat lebih kecil dari panjang array (jumlah kotak). Misalnya:
for (int i = 0; i < myArray.length; i++) {
Melihat <
, tidak pernah mencampur =
di sana..
Anda mungkin ingin tergoda untuk melakukan sesuatu seperti ini:
for (int i = 1; i <= myArray.length; i++) {
final int someint = myArray[i - 1]
Hanya don't. Tongkat untuk salah satu di atas (jika anda perlu untuk menggunakan indeks) dan itu akan menghemat banyak sakit.
Mana mungkin, gunakan foreach:
for (int value : myArray) {
Dengan cara ini anda tidak't harus berpikir tentang indeks sama sekali.
Ketika perulangan, apa pun yang anda lakukan, tidak PERNAH mengubah nilai dari loop iterator (di sini: aku
). Satu-satunya tempat ini harus mengubah nilai ini adalah untuk menjaga loop terjadi. Perubahan itu tidak hanya mempertaruhkan pengecualian, dan dalam kebanyakan kasus tidak diperlukan.
Pengambilan/update
Ketika mengambil sewenang-wenang elemen dari array, selalu periksa bahwa itu adalah sebuah indeks yang valid terhadap panjang array:
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];
}
Untuk menghindari indeks array keluar batas pengecualian, salah satu harus menggunakan ditingkatkan-untuk
pernyataan di mana dan kapan mereka dapat.
Motivasi utama (dan use case) adalah ketika anda iterasi dan anda tidak memerlukan rumit iterasi langkah-langkah. Anda akan tidak dapat menggunakan ditingkatkanuntuk
bergerak mundur dalam array atau hanya iterate pada setiap elemen lain.
Anda're dijamin tidak akan kehabisan elemen untuk iterate atas ketika melakukan hal ini, dan anda [diperbaiki] contoh mudah dikonversi.
Kode di bawah ini:
String[] name = {"tom", "dick", "harry"};
for(int i = 0; i< name.length; i++) {
System.out.print(name[i] + "\n");
}
...setara dengan ini:
String[] name = {"tom", "dick", "harry"};
for(String firstName : name) {
System.out.println(firstName + "\n");
}
Dalam kode anda anda telah mengakses unsur-unsur dari indeks 0 sampai dengan panjang dari string array. nama.panjang
memberikan nomor dari objek string dalam array dari objek string yaitu 3, tetapi anda dapat mengakses hanya sampai ke indeks 2 nama[2]
,
karena array dapat diakses dari indeks 0 sampai nama.panjang - 1
di mana anda mendapatkan nama.panjang
jumlah benda.
Bahkan saat menggunakan untuk
loop anda sudah mulai dengan indeks nol dan anda harus berakhir dengan nama.panjang - 1
. Dalam array a[n] anda dapat mengakses formulir a[0] a[n-1].
Misalnya:
String[] a={"str1", "str2", "str3" ..., "strn"};
for(int i=0;i<a.length()i++)
System.out.println(a[i]);
Dalam kasus anda:
String[] name = {"tom", "dick", "harry"};
for(int i = 0; i<=name.length; i++) {
System.out.print(name[i] +'\n');
}
Untuk anda yang diberikan array panjang array adalah 3(yaitu nama.panjang = 3). Tapi karena menyimpan elemen mulai dari indeks 0, max indeks 2.
Jadi, bukan 'i<=nama.panjang' anda harus menulis 'i<nama.panjang' untuk menghindari 'ArrayIndexOutOfBoundsException'.
Begitu banyak pertanyaan sederhana ini, tapi saya hanya ingin menyoroti fitur baru di Jawa yang akan menghindari semua kebingungan di sekitar pengindeksan dalam array bahkan untuk pemula. Jawa-8 telah disarikan tugas iterasi untuk anda.
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]); })
Apa's manfaatnya? Nah, satu hal yang dibaca seperti dalam bahasa inggris. Kedua, anda tidak perlu khawatir tentang ArrayIndexOutOfBoundsException
Anda mendapatkan ArrayIndexOutOfBoundsException
karena i<=nama.panjang
bagian. nama.panjang
mengembalikan panjang string nama
, yaitu 3. Oleh karena itu ketika anda mencoba untuk mengakses nama[3]
, it's ilegal dan melempar pengecualian.
Diselesaikan kode:
String[] name = {"tom", "dick", "harry"};
for(int i = 0; i < name.length; i++) { //use < insteadof <=
System.out.print(name[i] +'\n');
}
It's didefinisikan dalam bahasa Jawa spesifikasi:
publik final
lapanganpanjang
, yang berisi jumlah dari komponen-komponen array.length
bisa positif atau nol.
Yang's bagaimana jenis pengecualian terlihat ketika dilemparkan ke dalam Eclipse. Jumlah warna merah menandakan indeks anda mencoba untuk mengakses. Sehingga kode akan terlihat seperti ini:
myArray[5]
Kesalahan dilemparkan ketika anda mencoba untuk mengakses indeks yang doesn't ada dalam array. Jika sebuah array yang memiliki panjang 3,
int[] intArray = new int[3];
maka hanya berlaku indeks adalah:
intArray[0]
intArray[1]
intArray[2]
Jika suatu array memiliki panjang 1,
int[] intArray = new int[1];
maka satu-satunya indeks yang valid adalah:
intArray[0]
Setiap bilangan bulat sama dengan panjang dari array, atau lebih besar dari itu: di luar batas.
Setiap bilangan bulat kurang dari 0: keluar dari batas-batas;
P. S.: Jika anda melihat untuk memiliki pemahaman yang lebih baik dari array dan melakukan beberapa latihan praktis, ada's video berikut: [tutorial tentang array di Java][2]
Untuk array multidimensi, hal ini dapat menjadi rumit untuk memastikan anda mengakses panjang
milik dari dimensi yang tepat. Mengambil kode berikut sebagai contoh:
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();
}
Masing-masing dimensi memiliki panjang yang berbeda, sehingga bug halus adalah bahwa tengah dan dalam loop menggunakan panjang
milik dari dimensi yang sama (karena a[i].panjang
adalah sama dengan a[j].panjang
).
Sebaliknya, loop batin harus menggunakan a[i][j].panjang
(atau a[0][0].panjang
, untuk kesederhanaan).
ArrayIndexOutOfBounds berarti anda sedang mencoba untuk naik posisi dalam array yang tidak dialokasikan.
Dalam hal ini:
String[] name = { "tom", "dick", "harry" };
for (int i = 0; i <= name.length; i++) {
System.out.println(name[i]);
}
Untuk mendapatkan sekitar ini...
for(int i = 0; i<nama.length; i++)
String[] nama = { "tom", "anu", "harry" }; untuk(String n : nama) { Sistem.keluar.println(n); }
String[] nama = { "tom", "anu", "harry" }; Array.sebagai daftar(nama).forEach(Sistem.keluar::println);
String[] nama = { "tom", "anu", "harry" }; --- Array.sebagai daftar(nama).stream().forEach(Sistem.keluar::println); --- Stream.(nama).forEach(Sistem.keluar::println);
ArrayIndexOutOfBoundsException setiap kali pengecualian ini akan datang itu berarti anda sedang mencoba untuk menggunakan indeks dari array yang keluar dari batas atau berbaring pria syarat anda meminta lebih daripada yang telah dijalankan.
Untuk mencegah hal ini, selalu pastikan bahwa anda tidak meminta index yang tidak hadir dalam array yaitu jika panjang array adalah 10 maka indeks harus berkisar antara 0 sampai 9
Kasus yang paling umum I've melihat yang tampaknya misterius ArrayIndexOutOfBoundsExceptions, yaitu tampaknya tidak disebabkan oleh anda sendiri array penanganan kode, adalah penggunaan bersamaan SimpleDateFormat. Terutama dalam servlet atau controller:
public class MyController {
SimpleDateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy");
public void handleRequest(ServletRequest req, ServletResponse res) {
Date date = dateFormat.parse(req.getParameter("date"));
}
}
Jika dua benang masukkan SimplateDateFormat.parse() metode bersama-sama anda mungkin akan melihat sebuah ArrayIndexOutOfBoundsException. Catatan sinkronisasi bagian dari kelas javadoc untuk SimpleDateFormat.
Pastikan tidak ada tempat di dalam kode anda yang mengakses thread kelas yang tidak aman seperti SimpleDateFormat dalam bersamaan dengan cara seperti di servlet atau controller. Periksa semua variabel instance dari servlet dan pengendali untuk kemungkinan tersangka.
ArrayIndexOutOfBoundsException
berarti bahwa anda sedang mencoba untuk mengakses index array yang tidak ada atau keluar dari bound array ini. Indeks Array dimulai dari 0 dan berakhir pada suhu udara - 1.
Dalam kasus anda
for(int i = 0; i<=name.length; i++) {
System.out.print(name[i] +'\n'); // i goes from 0 to length, Not correct
}
ArrayIndexOutOfBoundsException
terjadi ketika anda mencoba untuk mengakses
nama.panjang diindeks elemen yang tidak ada (indeks array berakhir pada suhu udara turun menjadi -1). hanya mengganti <= dengan < akan memecahkan masalah ini.
for(int i = 0; i < name.length; i++) {
System.out.print(name[i] +'\n'); // i goes from 0 to length - 1, Correct
}
Untuk setiap array yang panjangnya n, elemen array akan memiliki indeks dari 0 sampai n-1.
Jika program anda mencoba untuk mengakses setiap elemen (atau memori) memiliki indeks array yang lebih besar dari n-1, maka Jawa akan membuang ArrayIndexOutOfBoundsException
Jadi di sini adalah dua solusi yang dapat kita gunakan dalam program
for(int count = 0; count < array.panjang; count++) { Sistem.keluar.println(array[count]); }
Atau beberapa lainnya perulangan pernyataan seperti
int hitung = 0; sementara(hitung < array.length) { Sistem.keluar.println(array[count]); count++; }
untuk(String str : array) { Sistem.keluar.println(str); }
Saya melihat semua jawaban di sini menjelaskan bagaimana untuk bekerja dengan array dan bagaimana untuk menghindari indeks di luar batas pengecualian. Saya pribadi menghindari array di semua biaya. Saya menggunakan Koleksi kelas, yang menghindari semua kekonyolan harus berurusan dengan array indeks sepenuhnya. Perulangan konstruksi bekerja indah dengan koleksi mendukung kode yang lebih mudah untuk menulis, memahami dan mempertahankan.
Setiap item dalam array disebut elemen, dan setiap elemen diakses dengan indeks numerik. Seperti yang ditunjukkan dalam ilustrasi sebelumnya, penomoran dimulai dengan 0. 9 elemen, misalnya, karena itu akan dapat diakses pada indeks 8.
IndexOutOfBoundsException dilemparkan untuk menunjukkan bahwa indeks dari beberapa macam (seperti array, string, atau vektor) adalah di luar jangkauan.
Setiap array X, dapat diakses dari [0 untuk (X. length - 1)]
Jika anda menggunakan sebuah array's panjang untuk mengontrol iterasi a untuk loop, selalu ingat bahwa indeks dari item pertama dalam array adalah 0. Jadi indeks elemen terakhir dalam array adalah salah satu kurang dari array's panjang.