# Werte aus einer sortierten Liste auslesen



## HansOne (1. Aug 2011)

Hallo,

ich habe ein Problem wo ich einfach keine Idee zur Lösung habe.

Und zwar habe ich eine Liste von doubles die der Größe nach sortiert wird.


```
double[] lengths = new double[] {F, C, E, H, J, A, D, B, G, I};

  Arrays.sort(lengths);

  System.out.print("Sorted double array:\t "); //Sortierte Liste von klein nach groß
  for(int index=0; index < lengths.length ;  index++)
    System.out.print(" " + lengths[index]);
```

momentan starten die sortierte Liste mit dem kleinsten Wert. 
Wie kann man die sortierte Liste von groß nach klein umstellen?

Das eigentliche Problem ist jedoch, dass ich nun ein anderes double habe, z.B. i=6 ...

Nun sollen demnach die größten 6 Werte in der Liste den Wert 1 bekommen und die restlichen 0.
Wenn der Wert größer als die Anzahl der sortierten Elemente ist kriegen weiterhin alle den Wert 1.

Beispiel:

Wert=6

10 --> 1
9 --> 1
8 --> 1
7 --> 1
6 --> 1
5 --> 1
4 -- >0
3 -- >0
2 -- >0
1 -- >0

Sprich den doubles aus der Liste müssen irgendwie die neuen Werte zugeordnet werden (1 oder 0).
Mit den neuen Werten für A bis J will ich dann weiter rechnen.
Ich habe keine Ahnung wie ich das anstellen kann. ???:L

Hoffe jemand kann helfen.

Gruß Hans


----------



## Gast2 (1. Aug 2011)

> momentan starten die sortierte Liste mit dem kleinsten Wert.
> Wie kann man die sortierte Liste von groß nach klein umstellen?


Du kannst Arrays.sort noch einen Comparator übergeben, da kannst du dann festlegen wie sortiert werden soll.



> Sprich den doubles aus der Liste müssen irgendwie die neuen Werte zugeordnet werden (1 oder 0).
> Mit den neuen Werten für A bis J will ich dann weiter rechnen.
> Ich habe keine Ahnung wie ich das anstellen kann.


Nach dem sortieren kannst du nochmal durchs Array gehen und die Werte in eine Map stecken, die ersten x Werte mapst du dann auf 1, den rest auf 0.


----------



## HansOne (1. Aug 2011)

kannst du mir ein Beispiel geben oder sagen wo ich da was konkretes finde?
Bin ein blutiger Anfänger und bastel nur aus Spaß und Interesse ein wenig rum


----------



## Gast2 (1. Aug 2011)

Comparator: Java Sorting: Comparator vs Comparable Tutorial - DigiZol
Infos zur Map: The Map Interface (The Java™ Tutorials > Collections > Interfaces)


----------



## HansOne (1. Aug 2011)

danke für die Antwort.
Auch wenn ich damit leicht überfordert bin.
Muss jetzt erstmal rauskriegen, wie ich die Werte nach dem sortieren in die Map bekomme... ^^


----------



## Gast2 (1. Aug 2011)

Dein fertiger Code könnte dann irgendwie so aussehen:

```
Double[] lengths = new Double[] {3.0, 1.0, 2.0, 7.0, 8.0, 4.0, 5.0, 6.0, 9.0, 10.0};
		
		Arrays.sort(lengths, new Comparator<Double>() {
			@Override
			public int compare(Double o1, Double o2) {
				return (int)(o2 - o1);
			}
		});
		
		Map<Double, Integer> map = new HashMap<Double, Integer>();
		
		int wert = 6;
		
		for (int i = 0; i < lengths.length; i++) {
			int nr = (i < wert) ? 1 : 0;
			map.put(lengths[i], nr);
		}
		
		System.out.println(map);
```
Die Ausgabe von der Map ist jetzt natürlich nichtmehr sortiert.


----------



## HansOne (1. Aug 2011)

vielen Dank, werde mal schauen ob ich damit ans Ziel komme


----------



## Hobbes (1. Aug 2011)

Für die absteigende Sortierung gibt es bereits einen fertigen Comparator


```
import java.util.Arrays;
import java.util.Collections;

public class KSKB {
	public static void main(String[] args) {
		Double[] lengths = new Double[] { 3.0, 1.0, 2.0, 7.0, 8.0, 4.0, 5.0, 6.0, 9.0, 10.0 };
		Arrays.sort(lengths, Collections.reverseOrder()); // absteigend sortieren
		System.out.print("Sorted double array:\t ");
		for (int index = 0; index < lengths.length; index++)
			System.out.print(" " + lengths[index]);
	}
}
```


----------



## HansOne (1. Aug 2011)

EikeB hat gesagt.:


> Dein fertiger Code könnte dann irgendwie so aussehen:
> 
> ```
> Double[] lengths = new Double[] {3.0, 1.0, 2.0, 7.0, 8.0, 4.0, 5.0, 6.0, 9.0, 10.0};
> ...



Also die Zuordnung der 1 und 0 hat natürlich gepasst...

Aber das Problem ist ja, dass die Ausgabe nun so aussieht:

Anzahl der zu vergebenden 1en: 6.0
{0.1=0, 0.8=1, 0.7=0, 0.9=1, 0.6=1, 0.5=1, 0.6000000000000001=0, 0.4=1, 0.2=0}

Meine 10 Eingangswerte sind in dieser Form:
RPA, RPB, RPC, RPD, RPE, RPF, RPG, RPH, RPI, RPJ
davon hat jedes double einen Zahlenwert.

Nun müsste ich eine Ausgabe in folgender Form haben:

RPA(neu)=1
RPB(neu)=1
RPC(neu)=0
......

weil ich will ja mit den neuen Werten RPA(neu) etc weiterrechnen...
hoffe ich drücke mich verständlich aus ^^


----------



## Landei (1. Aug 2011)

EikeB hat gesagt.:


> ...
> 
> ```
> ...
> ...



Das wird nicht funktionieren. Sei o2 = 0.5 und o1 = 0.3. Differenz ist 0.2. Auf int gecastet gibt 0. Also sind laut Comparator o1 und o2 gleich. Ups!

Besser: [c]return o2.compareTo(o1);[/c]


----------



## Atze (1. Aug 2011)

irgendwie komm ich da ganz durcheinander :/ hast du jetzt doubles als primitive werte, oder hast du ein mapping mit deinen PR... strings?

musst du das mit einem array machen, oder wäre nicht doch eine (hash-,tree-)map angebrachter? irgendwie reden hier alle aneinander vorbei, oder nicht?


----------



## HansOne (1. Aug 2011)

ausgangslage sind zehn double-Werte denen je nach größe 1en und 0en zugeordnet werden sollen.
Die wieviel größten davon den 10 Werten legt ein sich anderweitig ergebender double-wert fest.

So ganz haut oben was mit dem code nicht hin, weil mein der wert der die Anzahl der 1en festlegt ist ein double... und das Schema rechnet ja mit int-Werten...


----------



## Gast2 (1. Aug 2011)

Landei hat gesagt.:
			
		

> Das wird nicht funktionieren. [...]


Beim ganzzahligen Doubles funktionierts problemlos :joke:


----------



## HansOne (1. Aug 2011)

momentan sieht es so aus:


```
double RPA = BMPA-GBMPA; 
  
  double RPB = BMPB-GBMPB;
  
  double RPC = BMPC-GBMPC;
  
  double RPD = BMPD-GBMPD;
  
  double RPE = BMPE-GBMPE;
  
  double RPF = BMPF-GBMPF;
 
  double RPG = BMPG-GBMPG;
  
  double RPH = BMPH-GBMPH;
  
  double RPI = BMPI-GBMPI;
  
  double RPEigene = BMPEigene-GBMPEigene;
  
  int restmandate = (int) RestMandate;
  
  System.out.println(restmandate);
    
  //Sortierung des Prozenteüberschusses

  Double[] lengths = new Double[] {RPA, RPB, RPC, RPD, RPE, RPF, RPG, RPH, RPI, RPEigene};
  
  Arrays.sort(lengths, new Comparator<Double>() {
      @Override
      public int compare(Double o1, Double o2) {
          return (int)(o2 - o1);
      }
  });
  
  Map<Double, Integer> map = new HashMap<Double, Integer>();
  
  int wert = restmandate;
  
  for (int i = 0; i < lengths.length; i++) {
      int nr = (i < wert) ? 1 : 0;
      map.put(lengths[i], nr);
  }
  
  System.out.println(map);
```

Die Console gibt folgendes aus:

{0.1=0, 0.30000000000000004=0, 0.8=1, 0.9=1, 0.7=1, 0.6=0, 0.5=0}

Also da haut was nicht hin


----------



## HansOne (1. Aug 2011)

EikeB hat gesagt.:


> Beim ganzzahligen Doubles funktionierts problemlos :joke:



und sie sind natürlich nicht ganzzahlig!.
Hab ich vielleicht anfangs falsch vermittelt.

Dieser Kniff beachtet das: 

Besser: return o2.compareTo(o1);

?


----------



## Gast2 (1. Aug 2011)

ja


----------



## HansOne (1. Aug 2011)

dennoch stimmt wie ich oben nochmal gezeigt habe die Ausgabe nicht


----------



## Gast2 (1. Aug 2011)

und "stimmt nicht" heißt was?


----------



## HansOne (1. Aug 2011)

Die Console gibt folgendes aus:

5
{0.0=0, 0.03=0, 0.495=1, 0.8999999999999999=1, 0.050000000000000044=0, 0.575=1, 0.25=0, 0.3=0}

Also müsste auf 10 Werte 5 mal die 1 verteilt werden.

In der Cosole wird jedoch nur für 8 Werte eine Zuordnung angezeigt... irgendwas stimmt da noch nicht 
Ich werde mir die Eingangswerte nochmal von der Cosnole anzeigen lassen um zu schauen wos vielleicht haken kann...


----------



## HansOne (1. Aug 2011)

Also folgendes hab ich mir mal anzeigen lassen:

Eingangswerte:

RPA:0.5
RPB:0.6000000000000001
RPC:0.55
RPD:0.43
RPE:0.6
RPF:0.5
RPG:0.2
RPH:0.3
RPI:0.7
RPEigene:0.9

Anzahl der nötigen 1en: 5

{0.55=1, 0.5=0, 0.6=1, 0.7=1, 0.9=1, 0.43=0, 0.6000000000000001=1, 0.2=0, 0.3=0}

Es wurden unten diesmal die 1en richtig auf die größten Werte verteilt.
Jedoch taucht nur einmal die 0.5 auf, obwohl es sie eigentlich 2mal geben müsste siehe Eingangswerte.


----------



## HansOne (1. Aug 2011)

nochmal mit anderen Werten:

Eingangswerte:

RPA:0.45
RPB:0.48
RPC:0.165
RPD:0.12899999999999998
RPE:0.18600000000000003
RPF:0.15
RPG:0.36
RPH:0.54
RPI:0.21
RPEigene:0.27

Anzahl der nötigen 1en: 3

{0.54=1, 0.18600000000000003=0, 0.27=0, 0.12899999999999998=0, 0.36=0, 0.165=0, 0.21=0, 0.48=1, 0.15=0, 0.45=1}

--> Man sieht, dass wenn die Eingangswerte unterschiedlich sind, sie unten auch alle angezeigt werden. Sobald sich aber z.B. drei Eingangswerte den selben Wert haben, werden sie einfach als ein Wert zusammengefasst. 

Würde konkret bedeuten:

Typ A = 0.53
Typ B = 0.53

Dann würde in der Console einmal 0.53 = 1(z.B.) auftauchen... müsste aber zweimal auftauchen.


----------



## HansOne (2. Aug 2011)

weiß jemand weiter?


----------



## njans (2. Aug 2011)

Wenn du so nett wärst, einmal den jetzigen Code zu zeigen, kann man sich das noch mal angucken, denn ich habe den Thread nicht verfolgt und da sind einige Änderungen wohl geschehen.


----------



## HansOne (2. Aug 2011)

```
double RPA = BMPA-GBMPA;
  System.out.println("RPA:" + RPA);
  
  double RPB = BMPB-GBMPB;
  System.out.println("RPB:" + RPB);
  
  double RPC = BMPC-GBMPC;
  System.out.println("RPC:" + RPC);
  
  double RPD = BMPD-GBMPD;
  System.out.println("RPD:" + RPD);
  
  double RPE = BMPE-GBMPE;
  System.out.println("RPE:" + RPE);
  
  double RPF = BMPF-GBMPF;
  System.out.println("RPF:" + RPF);
 
  double RPG = BMPG-GBMPG;
  System.out.println("RPG:" + RPG);
  
  double RPH = BMPH-GBMPH;
  System.out.println("RPH:" + RPH);
  
  double RPI = BMPI-GBMPI;
  System.out.println("RPI:" + RPI);
  
  double RPEigene = BMPEigene-GBMPEigene;
  System.out.println("RPEigene:" + RPEigene);
  
  int restmandate = (int) RestMandate;
  
  System.out.println(restmandate);
    
  //Sortierung des Prozenteüberschusses

  Double[] lengths = new Double[] {RPA, RPB, RPC, RPD, RPE, RPF, RPG, RPH, RPI, RPEigene};
  
  Arrays.sort(lengths, new Comparator<Double>() {
      @Override
      public int compare(Double o1, Double o2) {
    	  return o2.compareTo(o1);                   //fehler!?
      }
  });
  
  Map<Double, Integer> map = new HashMap<Double, Integer>();
  
  int wert = restmandate;
  
  for (int i = 0; i < lengths.length; i++) {
      int nr = (i < wert) ? 1 : 0;
      map.put(lengths[i], nr);
  }
  
  System.out.println(map);
```

CONSOLE:

RPA:0.5
RPB:0.6
RPC:0.9
RPD:0.8
RPE:0.4
RPF:0.5
RPG:0.3
RPH:0.5
RPI:0.6
RPEigene:0.4

Anzahl der zu vergebenden 1en = 6

{0.8=1, 0.5=0, 0.6=1, 0.9=1, 0.4=0, 0.3=0}

Anmerkung:

Man sieht, dass er nicht alle Werte in der Console ausgibt... und die Vergabe der 1en klappt auch nicht immer in der richtigen Anzahl...

Wenn das dann mal klappen sollte, muss ich irgendwie mit den neuen Werten (1 oder0) RPAneu, PRBneu etc als doubles weiter rechnen können...


----------



## HoaX (2. Aug 2011)

Du verwendest lengths_ als Key für die Map, und dort kommen Werte doppelt vor, und das geht in einer Map nicht.
Lengths würde ich mal umbenennen, ist so völlig unaussagekräftig.
In deiner zitierten Ausgabe fehlt jene von "restmandate". Sicher dass der Wert >= 1 ist?

Poste doch am Besten mal ein KSKB wo deine Methode mit statischen Werten aufgerufen wird._


----------



## njans (2. Aug 2011)

0.9
0.8
0.6
0.6
0.5
0.5
-
0.5
0.4
0.4
0.3

Also so sieht die sortierte Liste aus (sollte invertiert zu der Liste sein, die lengths nach dem sort steckt).

So, hierbei stellt sich dann bei dir folgendes Problem:
Du Kannst in einer Map keine 2 Werte auf den selben Key legen. Somit überschreibst du 0.5 und 0.4 und 0.6 und es bleibt der Wert, den du als letztes hinzugefügt hast, dabei sind die Wert okay, bis auf 0.5, da der 6te Wert mit "1" belegt wird, aber danach der Siebte (wieder 0.5) dann "0" erhält. Damit überschreibst du deine Eins.


----------



## HansOne (2. Aug 2011)

> In deiner zitierten Ausgabe fehlt jene von "restmandate". Sicher dass der Wert >= 1 ist?



Dies sind die Restmandate  Definitiv größer 1!

Was sollte man statt "lenghts" nehmen?



> Poste doch am Besten mal ein KSKB wo deine Methode mit statischen Werten aufgerufen wird.



Du meinst den gesamten code mit andere es testen können? (sry sagt mir nichts^^)

@njans: Wie kann ich das Problem umgehen? Bin wirklich eher nichtwissend... wollte nur ein kleines Applet zu einem Browsergame machen 

Gruß


----------



## njans (2. Aug 2011)

Du könntest 2 Listen machen: 
Eine Liste für die, die deine Bedingung erfüllen (die 6 größten) und eine, für die restlichen Elemente


----------



## HansOne (2. Aug 2011)

ok, muss ich mal schaun ob ich das hinbekomme....^^

krieg ich am ende die Werte RPAneu, RPBneu etc mit ihren neuen Werten (1 oder0) als double irgendwie wieder raus? muss ja mit denen weiter rechnen...


----------



## nillehammer (2. Aug 2011)

```
package spielwiese;

import java.util.*;

public final class Test {

	private static final SortedSet<Double> MY_DOUBLES_NATURAL = new TreeSet<Double>(
			Arrays.asList(0.1D, 0.2D, 0.3D, 0.4D, 0.5D, 0.6D, 0.7D));

	private static final SortedSet<Double> MY_DOUBLES_REVERSE = new TreeSet<Double>(
			Collections.reverseOrder());
	static {
		MY_DOUBLES_REVERSE.addAll(MY_DOUBLES_NATURAL);
	}

	/**
	 * @param args
	 */
	public static void main(String[] args ) throws Throwable {

		System.out.println("MY_DOUBLES_NATURAL: " + MY_DOUBLES_NATURAL);

		System.out.println("MY_DOUBLES_REVERSE: " + MY_DOUBLES_REVERSE);

		System.out.println("naturalllySortedToArray: "
				+ Arrays.deepToString(naturalllySortedToArray()));

		System.out.println("reverseSortedToArray: "
				+ Arrays.deepToString(reverseSortedToArray()));

		System.out.println("countElementsGreaterEqual(0)="
				+ countElementsGreaterEqual(0D)); // sollte 7 ergeben

		System.out.println("countElementsGreaterEqual(0.55)="
				+ countElementsGreaterEqual(0.55D)); // sollte 2 ergeben

		System.out.println("countElementsGreaterEqual(0.7D)="
				+ countElementsGreaterEqual(0.7D)); // sollte 1 ergeben

		System.out.println("countElementsGreaterEqual(0.8)="
				+ countElementsGreaterEqual(0.8D)); // sollte 0 ergeben
	}

	private static final Double[] naturalllySortedToArray() {

		return MY_DOUBLES_NATURAL.toArray(new Double[MY_DOUBLES_NATURAL.size()]);
	}

	private static final Double[] reverseSortedToArray() {

		return MY_DOUBLES_REVERSE.toArray(new Double[MY_DOUBLES_REVERSE.size()]);
	}

	private static final int countElementsGreaterEqual(final double value ) {

		return MY_DOUBLES_NATURAL.tailSet(value).size();
	}
	
}
```


----------



## HansOne (2. Aug 2011)

danke!

Nur wie kriege ich da jetzt meine doubles rein?



> private static final SortedSet<Double> MY_DOUBLES_NATURAL = new TreeSet<Double>(
> Arrays.asList(0.1D, 0.2D, 0.3D, 0.4D, 0.5D, 0.6D, 0.7D));


----------



## nillehammer (2. Aug 2011)

Also ich hab die Sets gleich mit Werten vorbelegt, damit Du durch Aufruf von main sehen kannst, dass es geht. Du kannst sie natürlich auch leer erzeugen und die add()-Methoden auf den Sets aufrufen

```
private static final SortedSet<Double> MY_DOUBLES_NATURAL = new TreeSet<Double>();
 
private static final SortedSet<Double> MY_DOUBLES_REVERSE = new TreeSet<Double>(Collections.reverseOrder());

public static void main(String[] args ) throws Throwable {
  MY_DOUBLES_NATURAL.add(0.2D);
  MY_DOUBLES_REVERSE.add(0.2D);
}
```

Wenn du sicher stellen willst, dass Deine Doubles immer in beiden Sets landen, schreibst Du Dir eine Methode, die immer beide adds macht.


----------



## HansOne (2. Aug 2011)

ok, diese Möglichkeiten sind ja ganz nett... aber weiß nicht wie ich da mit meinem Problem weiter komme... 

Zumal gleiche Einträge nachwievor ja nicht getrennt angezeigt werden.

Ich werde mein problem nochmal verdeutlichen, vielleicht drücke ich mich nur verkehrt aus ...

1.SchrittEingangswerte:   
(doubles)                                                             

A = 0.956                              
B = 0.638                              
C = 0.263                            
D = 0.638                             
....
(10 Werte)

2.Schritt: Sortierte Werte

0.956    
0.728                          
0.638                              
0.263 
......
......

3.Schritt: 1en und 0en verteilen
-->Die Anzahl der 1en wird durch ein anderes varrierendes double bestimmt.

z.B. Anzahl = 3

0.956 = 1    
0.728 = 1                         
0.638 = 1                             
0.263 = 0
......
......

4.Schritt: Neue Doubles als Ausgangswerte

A.neu = 1
B.neu = 1
C.neu = 0
D.neu = 1
......
......

--> mit den neuen Doublewerten will ich dann weiterrechnen....


----------



## HansOne (3. Aug 2011)

bin für Ideen offen


----------



## HansOne (3. Aug 2011)

keiner ne Idee?


----------



## nillehammer (3. Aug 2011)

> 1.SchrittEingangswerte


Machst Du durch das adden zum SortedSet


> 2.Schritt: Sortierte Werte


 Ist schon erledigt. Die Werte werden beim adden gleich an die richtige Stelle sortiert


> 3.Schritt: 1en und 0en verteilen


 Hab ich so verstanden, dass Dein variierendes Double der Grenzwert ist. Alle Elemente, die größer/gleich sind, sollen eine 1 bekommen, alle Werte die kleiner sind, eine 0 (Richtig?)
Das macht die Zeile hier: 
	
	
	
	





```
return MY_DOUBLES_NATURAL.tailSet(value).size();
```
Genau genommen zählst Du damit die Anzahl der Elemente die größer/gleich Deinem Grenzwert sind.Um jetzt eine neue Menge zu bilden, rechnest Du:
- Gesamtanzahl - Anzahl der Elemente größer/gleich Grenzwert = Anzahl der Nullen
- Anzahl der Elemente größer/gleich Grenzwert = Anzahl der Einsen.
Wobei "Menge" hier eigentlich Liste oder Array meint, weil in einer Menge(engl. Set) Werte nicht doppelt vorkommen.
Was fehlt jetzt noch?


----------



## njans (3. Aug 2011)

Also es wäre wohl möglich anstelle des Doubles ein Objekt zu nehmen, dass zwei doubles hält. 
Da du dann immer eine Referenz auf das jeweilige Objekt hast, kannst du da werte verändern oder hinzufügen


----------



## HansOne (3. Aug 2011)

> Hab ich so verstanden, dass Dein variierendes Double der Grenzwert ist. Alle Elemente, die größer/gleich sind, sollen eine 1 bekommen, alle Werte die kleiner sind, eine 0 (Richtig?)



Nein  das varriierende double ist kein Grenzwert in dem Sinne. Beträgt das double z.B. 5, so sollen die 5 größten Werte eine 1 und die anderen 5 eine 0 bekommen. 

Beträgt es 3, so eben nur die größten 3


----------



## nillehammer (4. Aug 2011)

> Beträgt das double z.B. 5, so sollen die 5 größten Werte eine 1 und die anderen 5 eine 0 bekommen.


Da hab ich mich von dem Gleitkommatyp "Double" auf den Holzweg führen lassen. Für die Anforderung wäre ja ein ganzzahliges Argument (also int) nötig. Auf jeden Fall musst Du das Double in eine ganze Zahl umwandeln:

```
// Schneidet die Nachkommastellen einfach ab.
// 1.1, 1.7 1.9999 wird alles zu 1
final int anzahlEinsen = dasVariierendeDouble.intValue();
```
Und so geht's dann weiter:

```
// Wir wissen jetzt, wieviele Elemente am oberen Ende 1 werden sollen.
// Wie viele Elemente 0 werden sollen ist dann die Differenz aus size und anzahlEinsen
final int anzahlNullen = MY_DOUBLES_NATURAL.size() - anzahlEinsen;
```
Ab hier kommst Du mit SortedSets nicht weiter. In Sets (also auch SortedSets) kommt jedes Element nur einmal vor. Du kannst also nicht ein neues Set aufmachen und 5 mal 0 und 5 mal 1 adden. Dann hättest Du am Ende ein SortedSet mit genau zwei Elementen, erst die 0 und dann die 1. Wir müssen also ab hier auf einen Typ wechseln, der das Unterstützt, z.B. List, wenns eine (flexiblere) Collection sein soll oder ein Array. Sag, was Du lieber hättest. Dann machen wir weiter


----------



## nillehammer (4. Aug 2011)

Was ich mich bei der ganzen Chose gerade frage: Warum überhaupt der ganze Kram mit sortierten Doubles am Anfang? Nachdem Dein variierendesDouble ja garkein Grenzwert ist, sondern nur eine Anzahl. Eine Liste mit Nullen und Einsen könntest Du ja auch direkt erzeugen.


----------



## HansOne (4. Aug 2011)

> // Schneidet die Nachkommastellen einfach ab.
> // 1.1, 1.7 1.9999 wird alles zu 1
> final int anzahlEinsen = dasVariierendeDouble.intValue();



Also das ist meiner Meinung nach nicht der richtige Ansatz für meinen Fall.
Ich will ja nicht gerundete Werte haben. Auch ein Wert wie 0.3452 kann in meinem Fall zu einer 1 werden.

Ich versuchs nochmal zu erklären:

Ich habe 10 Eingangswerte, alle unter 1!

mein variierendes double soll z.b. 7 betragen

A = 0,3745 --> 1
B = 0,7483 --> 1
C = 0,4325 --> 1
D = 0,2349 --> 0
E = 0,3245 --> 0
F = 0,8435 --> 1
G = 0,5832 --> 1
H = 0,3249 --> 1
I = 0,2349 --> 0
J = 0,5293 --> 1

Die 7 größten Werte haben somit eine 1 bekommen.

Die neuen double-Werte sollen nun heißen:

Aneu = 1
Bneu = 1
Cneu = 1
Dneu = 0
Eneu = 0
Fneu = 1
Gneu = 1
Hneu = 1
Ineu  = 0
Jneu = 1

Ich hoffe das erklärt ganz gut was ich im Endeffekt am Ende bewerkstelligen will


----------



## Gast2 (4. Aug 2011)

```
public class Main {
	public static void main(String[] args) {
		Value a = new Value(0.3745);
		Value b = new Value(0.7483);
		Value c = new Value(0.4325);
		Value d = new Value(0.2349);
		Value e = new Value(0.3245);
		Value f = new Value(0.8435);
		Value g = new Value(0.8435);
		Value h = new Value(0.5832);
		Value i = new Value(0.2349);
		Value j = new Value(0.5293);
		
		Value[] values = new Value[]{a,b,c,d,e,f,g,h,i,j};
		
		Arrays.sort(values, new Comparator<Value>() {
			@Override
			public int compare(Value o1, Value o2) {
				return o2.getVal().compareTo(o1.getVal());
			}
		});
		
		int numberOfOnes = 7;
		
		for (int z = 0; z < values.length; z++) {
			values[z].setMapped(z < numberOfOnes ? 1 : 0);
		}
		
		System.out.println(Arrays.toString(values));
	}
	
	private static class Value {
		private double val;
		private int mapped;
		
		public Value(double val) {
			this.val = val;
		}
		
		public int getMapped() {
			return mapped;
		}
		public void setMapped(int mapped) {
			this.mapped = mapped;
		}
		public Double getVal() {
			return val;
		}
		
		@Override
		public String toString() {
			return "[" + val + " => " + mapped + "]";
		}
	}
}
```


----------



## HansOne (4. Aug 2011)

verdammt Eike, genau das trifft es :toll:

Wie kann man nun die neuen Werte als double ansprechen?
Brauch ja noch die neuen double Aneu, Bneu etc.... die natürlich noch zu den Ausgangswerten A, B, C passen müssen...


----------



## Gast2 (4. Aug 2011)

Welche neuen double werte? an denen ändert sich doch nichts.
Jedes Value-Objekt hat einen double wert und einen integer, entweder 0 oder 1. Per getter kannst du darauf zugreifen.


----------



## HansOne (4. Aug 2011)

wo kann ich mich da mal schlau machen?


----------



## Gast2 (4. Aug 2011)

Zu gettern/settern?
Galileo Computing :: Java ist auch eine Insel – 6.2 Privatsphäre und Sichtbarkeit


----------



## HansOne (6. Aug 2011)

ja irgendwie steh ich da auf dem Schlauch...

wie kann ich in einer simplen mathmatischen Rechenoperation auf nen Integer-Wert eines Value-Objektes zugreifen?

Z.B. X + Y = "int"

Muss jetzt nurnoch ein Schritt bewältigen, dann sollte ich fertig mit dem Applet sein.
Wäre schön wenn mir da nochmal einer aushelfen kann 

Gruß Hans


----------



## Gast2 (6. Aug 2011)

> wie kann ich in einer simplen mathmatischen Rechenoperation auf nen Integer-Wert eines Value-Objektes zugreifen?


Hää ???:L
Sorry, ich versteh nicht wirklich was du da meinst. Beziehst du dich auf meine Value Klasse von oben? Was hat das mit mathematischen operationen zu tun?


----------



## HansOne (6. Aug 2011)

Also wie ich ja schon mehrmals erwähnt habe, muss ich mit den neuen Werten (1 oder 0) weitere mathematische Operationen durchführen. 



> Jedes Value-Objekt hat einen double wert und einen integer, entweder 0 oder 1. Per getter kannst du darauf zugreifen.



Wenn ich das richtig verstanden habe muss ich dafür ja auf die Integer-Werte zugreifen.

Wie stell ich das an, wenn ich z.B. folgenden mathematischen Ausdruck habe:

X +Y = "int"  <-- wobei "int" für einen Integerwert  (1 oder 0) steht.


----------



## HansOne (7. Aug 2011)

kann mir da jemand nochmal auf die Sprünge helfen?


----------



## Landei (7. Aug 2011)

Anscheinend versteht dich hier keiner. Was soll X und Y sein? Was genau willst du berechnen?


----------



## HansOne (8. Aug 2011)

X und Y sind normale double. Und die will ich gleich einem Intwert setzen, den ich aus einem Valueobjekt auslesen will.

Also z.B. in der Form:

X + Y = "int"

Das ich den intwert erst in einen double.wert umwandeln muss ist mir dabei klar.
Nur bei dem auslesen haperts bei mir 

Gruß


----------



## Landei (8. Aug 2011)

"Gleichsetzen" gibt es in Java nicht, es gibt Zuweisungen (das links vom = bekommt den Wert von rechts) oder Vergleiche (a == b). 

Willst du die [c]double[/c]s dem [c]int[/c] zuweisen? 

```
double x = ...
double y = ...
Value value = ...
value.setMapped((int)(x + y));

//oder mit Zwischenschritt...

double x = ...
double y = ...
Value value = ...
int z = (int)(x + y);
value.setMapped(z);
```

Wobei da abgerundet wird, es gibt noch [c]Math.round[/c] für die normalen Rundungsregeln.


----------



## HansOne (8. Aug 2011)

ich will folgendes:

das int von RPA beträgt meinetwegen "1"

dann will ich z.b.

int RPAneu = 1

int X = 4

X + 1 ausrechen, also stinknormal ne Addition durchführen und das Ergebnis dann z.b. ausgeben

Die Stelle wo es hakt ist markiert mit "Hier" und "BIS HIER"


```
double RPA = BMPA-GBMPA; //Restmandate Partei A
  
  double RPB = BMPB-GBMPB;
  
  double RPC = BMPC-GBMPC;
  
  double RPD = BMPD-GBMPD;
  
  double RPE = BMPE-GBMPE;
 
  double RPF = BMPF-GBMPF;
  
  double RPG = BMPG-GBMPG;
  
  double RPH = BMPH-GBMPH;
 
  double RPI = BMPI-GBMPI;
 
  double RPEigene = BMPEigene-GBMPEigene;
  
  // Umwandlung double Restmandate in Integer
  
  int restmandate = (int)RestMandate;
  

  //Sortierung + Bewertung der Prozenteüberschusse

 
	    
	        Value a = new Value(RPA);
	        Value b = new Value(RPB);
	        Value c = new Value(RPC);
	        Value d = new Value(RPD);
	        Value e = new Value(RPE);
	        Value f = new Value(RPF);
	        Value g = new Value(RPG);
	        Value h = new Value(RPH);
	        Value i = new Value(RPI);
	        Value j = new Value(RPEigene);
	        
	        Value[] values = new Value[]{a,b,c,d,e,f,g,h,i,j};
	        
	        Arrays.sort(values, new Comparator<Value>() {
	            @Override
	            public int compare(Value o1, Value o2) {
	                return o2.getVal().compareTo(o1.getVal());
	            }
	        });
	        
	        int numberOfOnes = restmandate;
	        
	        for (int z = 0; z < values.length; z++) {
	            values[z].setMapped(z < numberOfOnes ? 1 : 0);
	        }
	        
	        System.out.println(Arrays.toString(values));
	        
	        double PRAneu;                                         <---- HIER
	        
	        Value value = a;
	        
	        value.setMapped((int)RPAneu);
	        
	        double gerundet;
	        double gesamt = gerundet + RPAneu;
	        
	        System.out.println(gesamt);                        <--- BIS HIER
	        
	        
	        	                              
	    }
	    
	    private static class Value {
	        private double val;
	        private int mapped;
	        
	        public Value(double val) {
	            this.val = val;
	        }
	        
	        public String getInt() {
				// TODO Auto-generated method stub
				return null;
			}

			public String getText() {
				// TODO Auto-generated method stub
				return null;
			}

			public int getMapped() {
	            return mapped;
	        }
	        public void setMapped(int mapped) {
	            this.mapped = mapped;
	        }
	        public Double getVal() {
	            return val;
	        }
	        
	        @Override
	        public String toString() {
	            return "[" + val + " => " + mapped + "]";
	        }
```


----------



## HansOne (11. Aug 2011)

versteht einer was ich will? ???:L


----------



## HansOne (12. Aug 2011)

ich will die Werte nicht in einer Console ausgeben. Ich will mit den Werten weiterrechnen.
Jetzt haben die double RPA, RPB etc zwar alle ihre 0 oder 1, aber ich habe keine Ahnung wie ich jetzt mit den 0en und 1en weiter arbeiten kann.

Wenn man double-werte in eine array "reinbekommt" muss man sie doch "neubewertet" (0 oder 1) auch wieder rausbekommen....

Wäre echt dankbar wenn da nochmal einer nachhelfen kann!

Gruß Hans


----------



## tuttle64 (12. Aug 2011)

HansOne hat gesagt.:


> ok, diese Möglichkeiten sind ja ganz nett... aber weiß nicht wie ich da mit meinem Problem weiter komme...
> 
> Zumal gleiche Einträge nachwievor ja nicht getrennt angezeigt werden.
> 
> ...



Schreibe eine Methode, welche eine Liste von Doubles sowie ein "varrierendes double" übergeben werden kann und eine Liste von neuen Doubles zurückliefert. Die zurückgelieferte Liste kannst Du dann wiederum als Eingabeliste verwenden. Das kannst Du so oft wiederholen, wie nötig. Kannst Du auch erläutern, für was die ganze "Neubewertung" gut sein soll?


----------



## HansOne (13. Aug 2011)

es geht dabei um die Vergabe von Mandatsplätzen.
Die "0.3628" etc sind der jeweilige Überschuss der Parteien. Die mit den größten Überschuss sollen eben die restlichen verfügbaren Mandate bekommen.

Also allein bekomme ich das nicht hin. Entweder jemand ist so nett und hilft mir dabei oder ich muss die ganze Sache ruhen lassen.

Gruß Hans


----------



## HansOne (17. Aug 2011)

kannst du mir da mal aushelfen tuttle64?


----------

