Enumerations?

[Sesostris]

Ich benötige zum Testen mancher Methode immer wieder Arrays mit bestimmten Zahlen; also zum Beispiel ungerade Zahlen, gerade Zahlen, nur positive Zahlen, besonders große Zahlen, etc.

Kann man folgendes Beispiel eleganter - eventuell mit Enumerations - lösen?

class Numbers {
	final int ODD = 0, EVEN = 1, BIG = 2; // ... und weitere
	int[][] numbers; 
	
	Numbers(int size) {
		numbers = new int[3][size];
		
		for (int i=0; i<size; i++) {
			numbers[ODD][i] = 2*i;
			numbers[EVEN][i] = 2*i+1;
			numbers[BIG][i] = i*i*i*i;
		}
	}
}

public class Demo {
	public static void main(String[] args) {
		final int ODD = 0, EVEN = 1, BIG = 2;
		Numbers testArray = new Numbers(10);
		
		machEtwasMitZahlen(testArray.numbers[EVEN]); // hier bekäme die Methode ein Array mit geraden Zahlen

		for (int[] x: testArray.numbers)
			machEtwasMitZahlen(x); // und nun nacheinander Arrays mit ungeraden, gerade und großen Zahlen
	}
}

 

[XHelp]

Theoretisch schon. Jedoch wirst du einiges umschreiben müssen, denn enums kannst du nicht als Array-Index einsetzen.
Darüber hinaus ist deine Unterteilung nur bedingt sinnvoll. Gerade/Ungerade lassen sich noch disjunkt betrachten. Große/Kleine (subjektiv) auch. Aber wo ist der Zusammenhang zwischen den beiden Gruppen? Kann eine gerade Zahl nicht groß sein, oder eine kleine Zahl ist zwingend ungerade?
An deiner Stelle würde ich eine Factory schreiben, die pro Methode ein Array von "wasauchimmer" erstellt.

 

[Gast2]

Du könntest ODD EVEN, BIG zu nem enum machen.

Ich würde für die Arrays aber eher statische Factory Methoden nutzen.

public class Numbers {

	public static int[] generateOddNumbers (int size) {
		int[] numbers = new int[size];
		
		for (int i = 0; i < size; i++) {
			numbers[i] = 2*i;
		}
		
		return numbers;
	}
	
	public static int[] generateEvenNumbers (int size) {
		int[] numbers = new int[size];
		
		for (int i = 0; i < size; i++) {
			numbers[i] = 2*i + 1;
		}
		
		return numbers;
	}
}

Hat den Vorteil dass du dir genau das geben lassen kannst was du brauchst.

 

[Sesostris]

Wenn sich enums nicht als Arrayindex benutzen lassen, fällt die Idee sowieso ins Wasser.

@EikeB: Bei dem Code gefällt mir nicht, dass ich dann nicht mehr mit einer foreach-Schleife (wie im Beispiel oben) durch alle Arten von Numbers iterieren kann. Aber es spricht eigentlich nichts gegen eine generateAllNumbers-Methode, die mir ein zweidimensionales Array liefert, bei dem ich das kann. Ich werde das so versuchen.

 

[Gast2]

Finde ich aber besser als bei einem Durchlauf alle Zahlen zu erstellen und davon dann später nur nen drittel zu nutzen

 

[Landei]

@EikeB: Bei dem Code gefällt mir nicht, dass ich dann nicht mehr mit einer foreach-Schleife (wie im Beispiel oben) durch alle Arten von Numbers iterieren kann.

Dann schreib dir doch Iterables:

public class EvenIterable implements Iterable<Integer> {
   private final int size;
   public EvenIterable(int size){ this.size = size }
   public Iterator<Integer> iterator() {
      return new Iterator<Integer>() {
          private int value = 0;
          public boolean hasNext(){
              return value <= size;
          }
          public Integer next(){
              if(! hasNext()) {
                  throw new NoSuchElementException();
              } 
              value += 2;
              return value - 2;
          }
          public void remove() {
             throw new UnsupportedOperationException();
          }
      };   
   } 
}

Dann kannst du schreiben [c]for(Integer i : new EvenIterable(100)){...}[/c]. Die einzelnen Iterables kannst du auch wieder in eine Liste oder so packen, und dann darüber in einer äußeren Schleife iterieren.