# Array füllen



## bluej12 (31. Jan 2011)

Hallo,
ich arbeite an einer einfachen Würfelsimulation, dieein Array vom Typ int beinhaltet, in dem für die sechs möglichen Würfelergebnisse deren Häufigkeit gespeichert werden soll. Das Würfel klappt problemlos, aber der Compiler will nicht als Starthäufigkeit Null zulassen und fordert eine eckige Klammer. 
Wo ist mein Denk-/Schreibfehler?
Vielen Dank für die Hilfe!


```
import java.util.Random;
public class Wuerfel
{
    private int[] haeufigkeit;
    private int wert;

    public Wuerfel()
    {
        int haeufigkeit [] = new int [6];
        int haeufigkeit[0]=0;   //erster problematischer Ausdruck:   ']'expected
        int haeufigkeit[1]=0;
        int haeufigkeit[2]=0;
        int haeufigkeit[3]=0;
        int haeufigkeit[4]=0;
        int haeufigkeit[5]=0;
    }
    
    public int wuerfeleEinmal()
    {
        wert=(int)(Math.random()*6+1);
        return wert;
    }
}
```


----------



## eRaaaa (31. Jan 2011)

```
int haeufigkeit [] = new int [6];
   int haeufigkeit[0]=0;   //erster problematischer Ausdruck:   ']'expected
//....
```

lasse das int in den Zeilen 10-15 weg ! In Zeile 9 sagst du ja schon dass haeufigkeit ein int-Array ist!


----------



## bluej12 (31. Jan 2011)

Ja, ich will aber dass bei jedem Wurf mitgezählt wird, wieoft die Zahl gewürfelt wurde um eine Statistik zu erstellen. Wenn ich das Objekt per BlueJ inspiziere wird aber "null" und nicht "0" angezeigt.


----------



## Marco13 (31. Jan 2011)

*abkürz*

```
import java.util.Random;
public class Wuerfel
{
    private int[] haeufigkeit;
    private int wert;
 
    public Wuerfel()
    {
        haeufigkeit [] = new int [6];
    }
    
    public int wuerfeleEinmal()
    {
        wert=(int)(Math.random()*6+1);
        haeufigkeit[wert]++;
        return wert;
    }
}
[/Java]
```


----------



## bluej12 (31. Jan 2011)

OK, danke so müsste es funktionieren, aber dann kommt die NullPointerException-Meldung!


----------



## Network (31. Jan 2011)

Versuch mal das Array vorher mit 0er zu füllen:

```
Arrays.fill( haeufigkeit, 0 );
```


----------



## bluej12 (31. Jan 2011)

Die Konsole gibt immer noch _java.lang.NullPointerException at Wuerfel.wuerfeleEinmal(Wuerfel.java:17)_ aus. 
Momentaner Quellcode:


```
import java.util.Random;
import java.util.Arrays;
public class Wuerfel
{
    private int[] haeufigkeit;
    private int wert;

    public Wuerfel()
    {
        int haeufigkeit [] = new int [6];
        Arrays.fill( haeufigkeit, 0 );
    }
    
    public int wuerfeleEinmal()
    {
        wert=(int)(Math.random()*6+1);
        haeufigkeit[wert]++;
        return wert;
    }
}
```


----------



## eRaaaa (31. Jan 2011)

Ich hatte oben übersehen, dass du das Array als Instanzvariable auch gespeichert hast(was auch richtig ist) und dass die Klammern und das int bei  
	
	
	
	





```
[B] int haeufigkeit [][/B] = new int [6];
```
 auch weg müssen! Weil sonst erstellst du eine neue lokale Variable. Marco hatte das doch aber schon für dich geändert?  (wobei er auch die Klammern übersehen hat, die müssen weg  )
Und 
	
	
	
	





```
wert=(int)(Math.random()*6+1);
        haeufigkeit[wert]++;
```
 da könnt`s auch krachen !!!


----------



## ARadauer (31. Jan 2011)

Zeig deinenen gesamten Code.. wer instanziert den Wuerfel?


----------



## Marco13 (31. Jan 2011)

Oh, ja...
haeufigkeit[wert-1]++;
Wann baut endlich jemand einen Informatiker-Würfel, der 0 bis 5 Augen hat?


----------



## Andi_CH (1. Feb 2011)

bluej12 hat gesagt.:


> ```
> import java.util.Random;
> import java.util.Arrays;
> public class Wuerfel
> ...



Meine Variante:

```
import java.util.Arrays;

public class Wuerfel
{
	private int[] haeufigkeit = {0,0,0,0,0,0};
	private int wert;

	public int wuerfeleEinmal() {
		wert=(int)(Math.random()*6+1);
		haeufigkeit[wert-1]++;
		return wert;
	}
	
	@Override
	public String toString() {
		return Arrays.toString(haeufigkeit);
	}

	public static void main(String[] args) {
		Wuerfel meinWuerfel = new Wuerfel();
		for(int i=0; i<100; i++) {
			System.out.println(i + " ter Wurf : " + meinWuerfel.wuerfeleEinmal());
		}
		System.out.println("Statistik : " + meinWuerfel);
	}
}
```

Wenn es zu Übungszwecken ein expliziter Konstruktor sein muss, sieht es halt so aus, aber in diesem Fall ist es unnötig.


```
public class Wuerfel
{
	private int[] haeufigkeit;
	private int wert;
	
	public Wuerfel() {
		haeufigkeit = new int[6];
		Arrays.fill(haeufigkeit, 0);
	}
......
```


----------



## bone2 (1. Feb 2011)

du bekommst:


Marco13 hat gesagt.:


> ```
> public Wuerfel()
> {
> haeufigkeit [] = new int [6];
> ...


daraus... warum?

richtig ist alleridngs:

```
public Wuerfel()
    {
        haeufigkeit = new int [6];
    }
```

und fill muss man auf ein int array auch nicht machen, das ist schon voller 0


----------



## Andi_CH (1. Feb 2011)

bone2 hat gesagt.:


> und fill muss man auf ein int array auch nicht machen, das ist schon voller 0



Hast du schon einmal sicherheitsrelevante SW geschrieben  Es schadet aber auch nichts wenn man es initialisiert und so wenig wie bei Java garantiert ist, wissen wir nicht ob es die übernächste Version auch so macht.

Was mich mehr wundert ist die redundante Information - hab ich alles schon kommentiert.


----------



## eRaaaa (1. Feb 2011)

Andi_CH hat gesagt.:


> Hast du schon einmal sicherheitsrelevante SW geschrieben  Es schadet aber auch nichts wenn man es initialisiert und so wenig wie bei Java garantiert ist, wissen wir nicht ob es die übernächste Version auch so macht.



Mit was sollten sie es denn deiner Meinung nach initialisieren in der nächsten Version? Mit null? Geht nicht und alles andere würde auch einfach keinen Sinn machen, zu dem steht`s auch so in der Java Language Specification, also würde ich davon schon ausgehen!
Falls du so wenig vertrauen hast, kannste ja array[0] abfragen oder glaubst du in der nächsten Version wird das Array beliebig/zufällig gefüllt von –2.147.483.648 ... 2.147.483.647 ?


----------



## Marco13 (1. Feb 2011)

Andi_CH hat gesagt.:


> Es schadet aber auch nichts wenn man es initialisiert und so wenig wie bei Java garantiert ist, wissen wir nicht ob es die übernächste Version auch so macht.



Wenn man eine Liste mit 100000 Einträgen sortiert, "schadet" es auch nicht, wenn man sie _nochmal_ sortiert  Es "schadet" schon, in dem Sinne, dass es überflüssig ist und Zeit kostet. Ein paar Mikrosekunden, ja, aber ... warum sollte man sich die Arbeit machen, etwas hinzuschreiben, was dem Computer Arbeit macht, und nichts bringt? (OK, das mache ich den ganzen Tag, aber da krieg' ich Geld dafür ). Man kann sich übrigens drauf verlassen, dass das auch bei der nächsten Version von Java noch so ist. Die Vehemenz, mit der bei Java Rückwärtskompatibilität gewahrt wird, wurde schon von manchen als Hemmschuh für neue Enwicklungen kritisiert, aber sie hat auch Vorteile ... (wer schonmal ein Visual Studio 6-Projekt mit Qt 3.4 auf VS2010 mit Qt 4.3 hiefen mußte (oder müßte) weiß das zu schätzen....)


----------

