Abrufen der Länge eines Arrays in einer Methode funktioniert nicht

Question

Ich bin relativ neu in Java, also stellen Sie sich vor, dass ich 5 Jahre alt bin und eine Antwort für einen Fünfjährigen benötigen.

Zuerst ein paar Informationen: Ich versuche ein "Dynamic Array" zu erstellen, das bei Bedarf wächst und schrumpft. Ich kenne arraylists, der Zweck davon ist, dass ich in der Lage sein muss, das selbst zu tun und gleichzeitig zu lernen, seit ich annehme, dass das so ist, wie ArrayList s sowieso arbeiten.

Das Problem: Ich möchte einige ausgefallene Methoden aus dem Grund hinzufügen, von denen einer den Mittelwert des gesamten Array zu berechnen ist. wenn ich versuche, die Länge zu bekommen (varible.length) so funktioniert es nicht, während es in einigen anderen Methoden es tut!

Dies ist die Methode, die nicht funktioniert:

public double meanValue() { 
    double meanDiv = 0; 
    int div = x.length; 

    for (int i = 0 ; i < div ; i++) { 
     meanDiv += x[i]; 
     System.out.println("Testing"); 
    } 
    meanDiv = meanDiv/x.length; 
    return meanDiv; 
} 

Es Rückkehr NaN (keine Zahl), aber wenn man die Dividierteil überspringen es 0 zurückgibt, ist es absolut nicht x.length lesen.

Worst Teil? Einige Methoden arbeiten, diesmal zum Beispiel die letzte Position zurück:

public long last() { 
    long pepe = -1; 
    if (x.length==0) { 
     System.out.println("Nothing in the array! Returning -1"); 
    } 
    else { 
     pepe = x[x.length-1]; 
    } 
    return pepe; 
}  

Ich habe versucht, zu viele Dinge, andere Art von Variablen, während statt für usw.

Hier werden die ganze Klasse, wenn sie benötigt wird:

public class dynamicArray { 
    private long[] x; 
    private int size = 0; 

    public dynamicArray() { 
     x = new long[size]; 
    }           // CREATES THE ARRAY 

    public long grab(int x) { 
     if (x < this.x.length) { 
      return this.x[x]; 
     } 
     else { 
      System.out.println("(GET) Out of bounds"); 
      return -1; 
     } 
    } 
    public void add(long value) { 
     dynamicInAction(); 
     x[size] = value; 
     size++; 
    }         // ADD A NUMBER TO THE ARRAY 
    public void remove(int position) { 

    }        // REMOVES A SPECIFIC ARRAY POSITION---------------- 
    public long last() { 
     long pepe = -1; 
     if (x.length==0) { 
      System.out.println("Nothing in the array! Returning -1"); 
     } 
     else { 
      pepe = x[x.length-1]; 
     } 
     return pepe; 
    }           // RETURNS THE VALUE IN THE LAST POSITION 
    public long first() { 
     long pepe = -1; 
     if (x.length==0) { 
      System.out.println("Nothing in the array! Returning -1"); 
     } 
     else { 
      pepe = x[0]; 
     } 
     return pepe; 
    }           // RETURNS THE VALUE IN THE FIRST POSITION 
    public void modify(int position, int value) { 
     if (position < x.length && position >= 0) { 
      x[position] = value; 
     } 
     else { 
      System.out.println("This position does not exist"); 
     } 
    }     // MODIFIES A SPECIFIC POSITION TO THE ASSIGNED VALUE 
    public int size() { 
     return x.length; 
    }            // RETURNS THE CURRENT ARRAY SIZE 
    public double meanValue() { 
     double meanDiv = 0; 
     int div = x.length; 

     for (int i = 0 ; i < div ; i++) { 
      meanDiv += x[i]; 
      System.out.println("Testing"); 
     } 
     meanDiv = meanDiv/x.length; 
     return meanDiv; 
    }          // RETURNS THE MEAN VALUE OF THE WHOLE ARRAY------------- 
    public long median() { 
     return -1; 
    }           // RETURNS THE MEDIAN VALUE OF THE WHOLE ARRAY------------- 
    private void dynamicInAction() { 
     if (x.length == size) { 
      long[] temp = new long[x.length]; 
      for (int i = 0; i<x.length ; i++) { 
       temp[i] = x[i]; 
      } 
      x = null; 
      //System.gc(); // Might be unnecessary 
      x = new long[size+1]; 
      for (int i = 0; i<temp.length ; i++) { 
       x[i] = temp[i]; 
      } 
     } 
    }        // ENSURES THE ARRAY GROWS WHEN NEEDED 
    public void reverse() { 

    }           // REVERSING ALL POSITIONS IN THE ARRAY------------------ 
    public void clear() {                           
     x = null; 
     size = 0; 
     x = new long[size]; 
    }           // CLEARS THE ARRAY 



} 

Answer 1

Sie erstellen ein Array mit einer Größe von 0 im Konstruktor. Das bedeutet, dass Sie immer 0 Elemente haben, wenn Sie X keinem anderen Array zuweisen. Versuchen Sie, in der Größe im Konstruktor wie folgt:

public DynamicArray(int size){ 
    this.size = size; 
    this.x = new long[size]; 
} 

Auch in Java-Klassennamen haben Großbuchstaben für jedes Wort (Hinweis Dynamic nicht Dynamic).

Answer 2

Ihr Projekt funktioniert. Hier ist der Code

public class HelloWorld{ 

    public static void main(String []args){ 
     dynamicArray s = new dynamicArray(); 
     s.add(1); 
     s.add(3); 

     System.out.println(s.meanValue()); 
    } 
} 

Ergebnis:

2.0 

So müssen Sie mindestens 1 Element hinzufügen, bevor "Meanvalue()"

Answer 3

Diese beiden Methoden in der Klasse Meanvalue und letzte Aufruf gearbeitete gut, wenn ich sie lief. Dies sind die SYSOUT, die sie mir gezeigt:

Testing 
Testing 
Testing 
Testing 
mean 3.25 
last 5 

Der Code, den ich verwendet Objekt Ihrer Klasse zu erstellen und nutzen.

public static void main(String ...args) { 
     DynamicArray myArr = new DynamicArray(); 
     myArr.add(1); 
     myArr.add(2); 
     myArr.add(5); 
     myArr.add(5); 
     System.out.println("mean " + myArr.meanValue()); 
     System.out.println("last " + myArr.last()); 
    } 

Answer 4

Vorherige Antworten sind richtig, dass Sie die Größe auf 0 initialisiert Aber das ist nicht Ihr eigentliches Problem.

Sie haben zwei Hauptprobleme:

1) In Ihrem dynamicInAction -Sie nie in dieser Methode die Größe des Arrays erhöhen! Sie erstellen einfach ein temp-Array derselben Größe, kopieren x-Inhalte in die temp-Datei und weisen x dann temp zu, ohne die Größe zu erhöhen. Sie benötigen eine geringfügige Anpassung, um die Größe zu erhöhen, während Sie das neue temporäre Array erstellen. Ich bin ‚pre-Inkrementierung‘ Größe verwendet, um den neuen Wert zu haben, wenn die neue temporäre Array zu erstellen:

private void dynamicInAction() { 
    if (x.length == size) { 
     long[] temp = new long[++size]; 
     for (int i = 0; i<x.length ; i++) { 
      temp[i] = x[i]; 
     } 

     //Just assign x to temp 
     x = temp; 

     //x = null; Unnecessary 
     //System.gc(); // Unnecessary 
     //Dont create another array, you already have temp..just assign it 
     //x = new long[size+1]; 
     //for (int i = 0; i<temp.length ; i++) { 
     // x[i] = temp[i]; 
     //} 
    } 
}  

2) Zweitens jetzt Sie keine Größe in der Add-Methode erhöhen müssen, nur um den Wert festgelegt:

public void add(long value) { 
    dynamicInAction(); 
    x[size-1] = value; 
    //size++; Unnecessary 
}