teilen Sie ein Array in zwei gleich große Arrays

Question

Ich arbeite an einem Programm in Eclipse, um ein Array in zwei Arrays von gleicher Größe zu teilen. Mein Programm kompiliert, aber wenn ich es benutze ich die folgende Fehlermeldung:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10000 bei mergeArrays.main (mergeArrays.java:28)

Wenn Sie irgendwelche Vorschläge haben, warum ich diesen Fehler bekomme, würde es sehr geschätzt werden. Danke im Voraus!

ist hier mein Code:

import java.util.Scanner; 
import java.util.Random; 

public class mergeArrays { 

    public static void main(String[] args) { 
     Scanner input = new Scanner(System.in); 
     //System.out.print("Enter an upper limit: "); 
     //int lim = input.nextInt(); 
     int lim = 10000; 
     int halfLim; 
     halfLim = lim/2; 
     //int data[]; 
     //data = new int[lim]; 

     double[] data = new double[lim]; 
     for (int i = 0; i < lim; i++) { 
      data[i] = Math.random(); 
     } 

     double[] a = new double[halfLim]; 

     for (int i = 0; i < halfLim; i++) { 
      a[i] = data[i]; 
     } 

     double[] b = new double[halfLim]; 
     for (int i = halfLim; i < lim; i++) { 
      b[i] = data[i]; 
     } 

     System.out.print(a); 
    } 
} 

Answer 1

Ihr letzter Iterator

Verwendung falsch ist dies:

for(int i = 0; i < lim ; ++i) { 
    b[i] = data[i+halfLim]; 
} 

statt:

for(int i = 0 ; i < halfLim ; ++i) { 
    b[i] = data[i+halfLim]; 
} 

Ein optimaler Weg ist, beide Schleifen kombinieren:

for(int i = 0; i < halfLim ; ++i) { 
    a[i] = data[i]; 
    b[i] = data[i+halfLim]; 
} 

Answer 2

Seit lim>halfLim Sie aus gebundenen Elemente zuzugreifen, ist

double[] b = new double[halfLim]; // your promise of halfLim 
for(int i = halfLim ; i < lim ; ++i) { 
    b[i] = data[i+halfLim]; // did you betray? 
} 

Answer 3

Ausgabe in der folgenden Schleife:

for(int i = halfLim ; i < lim ; ++i) { 
    b[i] = data[i+halfLim]; 
} 

Es data[i] und nicht data[i+halfLim] sein sollte. Dies liegt daran, dass Sie die Variable i bereits auf den Wert halfLim initialisiert haben. Beginnen Sie daher die zweite Hälfte von diesem Wert bis < lim.

Answer 4

for(int i = halfLim ; i < lim ; ++i) { 
     b[i] = data[i+halfLim]; 
} 

In Ihrem letzten for loop, in der ersten Iteration dieser Schleife, halflim = 5000 und i = 500, so dass i+halflim = 10000 macht, also wenn Sie tun

b[i] = data[i+halfLim]; 

Sie versuchen 10000 ten Index der Array zuzugreifen data Das besteht aus Index von 0 bis 9999, daher erhalten Sie ArrayIndexOutOfBoundsException.

Ein weiterer Grund für ArrayIndexOutOfBoundsException in Ihrem Code ist, dass Größe des Arrays b5000 ist und in Ihrem letzten for loop Sie i zu halflim initialisiert wird, die zu 5000 gleich ist, so dass b[i] = b[5000] macht die seit Größe von b ungültig ist 5000, was bedeutet, dass es einen Index von 0 bis 4999 enthält.

Answer 5

Es gibt zwei Probleme zu lösen.

Zuerst wird b[i] nicht in etwas erfolgreich indizieren. b ist mit der Größe 5000 definiert, aber Sie legen es bereits auf die Hälfte der ursprünglichen Größe des Arrays fest.Dies führt zu einem ArrayIndexOutOfBoundsException allein.

Zweitens müssen Sie sicherstellen, dass Sie nur die Hälfte der Elemente zu Ihrem anderen Array hinzufügen. Die Startposition unterscheidet sich durch Ihren Offset i + halfLim, aber die letzte Iteration muss immer noch die Hälfte Ihrer maximalen Größe erreichen.

So müssen Sie zwei Änderungen vornehmen:

• i bei 0 beginnen muß, und
• die Schleife bei halfLim beenden muß.

Der Code zu tun, ist wie folgt:

for(int i = 0; i < halfLim ; ++i) { 
    b[i] = data[i+halfLim]; 
} 

auch sicher, dass import java.util.Arrays; an der Spitze zu schreiben, und Arrays.toString(a) verwenden, wenn Sie a ausdrucken möchten, oder Sie werden nur eine bekommen Objektstring-Referenz.

Answer 6

Es gibt einige Probleme in Ihrem zweiten for-Schleife:

• Sie b Array mit einer Größe von Halb Grenze initialisiert, ist 5000
• Anfangswert von i-halfLim(5000) gesetzt ist, einfach dieser Index doesn ‚t existieren, weil sie zu groß
• data[i + halfLim] - wenn Anfangswert von i auf halfLim gesetzt, Sie versuchen, das Element an index 5000 + 5000 zuzugreifen, kann dies auch von Datenfeld aus gebunden ist

Answer 7

b[i] ist eigentlich b[5000], die dieser aus bound.Try ist:

double[] b = new double[halfLim]; 
    for(int i = 0 ; i < (lim/2) ; i++) {//i should be 0 to start inserting data at index zero 
     b[i] = data[halfLim];//Start collecting data from where you stopped 
     halfLim++;//increment halfLim to pick next data 
    } 

    System.out.println(Arrays.toString(data)); 
    System.out.println(Arrays.toString(a)); 
    System.out.println(Arrays.toString(b)); 

Answer 8

Anstatt Ihre eigenen Loops zu schreiben, sollten Sie die Java-Bibliothek verwenden, insbesondere die Arrays.copyOfRange(double[] original, int from, int to) Methode.

Beispiel

double[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 

int half = (data.length + 1)/2; // Make first half larger if odd sized 
double[] a = Arrays.copyOfRange(data, 0, half); 
double[] b = Arrays.copyOfRange(data, half, data.length); 

System.out.println(Arrays.toString(a)); 
System.out.println(Arrays.toString(b)); 

Ausgabe

[1.0, 2.0, 3.0, 4.0, 5.0] 
[6.0, 7.0, 8.0, 9.0]