Werte aus einer sortierten Liste auslesen

H

HansOne

Mitglied
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.

Java: 
  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
 
momentan starten die sortierte Liste mit dem kleinsten Wert.
Wie kann man die sortierte Liste von groß nach klein umstellen?
Zum Vergrößern anklicken....
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.
Zum Vergrößern anklicken....
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.
 
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 😉
 
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... ^^
 
Dein fertiger Code könnte dann irgendwie so aussehen:
Java: 
		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.
 
Für die absteigende Sortierung gibt es bereits einen fertigen Comparator

Java: 
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]);
	}
}
 
EikeB hat gesagt.:
Dein fertiger Code könnte dann irgendwie so aussehen:
Java: 
		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.
Zum Vergrößern anklicken....

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 ^^
 
Zuletzt bearbeitet:
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? 🙂
 
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...
 
momentan sieht es so aus:

Java: 
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 🙁
 
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...
 
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.
 
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.
 
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.
 
Java: 
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...
 
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.
 
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.
 
In deiner zitierten Ausgabe fehlt jene von "restmandate". Sicher dass der Wert >= 1 ist?
Zum Vergrößern anklicken....

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.
Zum Vergrößern anklicken....

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ß
 
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 🙂
 
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...
 
Java: 
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();
	}
	
}
 
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
Java: 
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.
 
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....
 
1.SchrittEingangswerte
Zum Vergrößern anklicken....
Machst Du durch das adden zum SortedSet
2.Schritt: Sortierte Werte
Zum Vergrößern anklicken....
Ist schon erledigt. Die Werte werden beim adden gleich an die richtige Stelle sortiert
3.Schritt: 1en und 0en verteilen
Zum Vergrößern anklicken....
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:
Java: 
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?
 
Zuletzt bearbeitet von einem Moderator:
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 🙂
 
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?)
Zum Vergrößern anklicken....

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 😉
 
Beträgt das double z.B. 5, so sollen die 5 größten Werte eine 1 und die anderen 5 eine 0 bekommen.
Zum Vergrößern anklicken....
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:
Java: 
// 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:
Java: 
// 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
 
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.
 
// Schneidet die Nachkommastellen einfach ab.
// 1.1, 1.7 1.9999 wird alles zu 1
final int anzahlEinsen = dasVariierendeDouble.intValue();
Zum Vergrößern anklicken....

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 😉
 
Java: 
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 + "]";
		}
	}
}
 
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...
 
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.
 
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
 
wie kann ich in einer simplen mathmatischen Rechenoperation auf nen Integer-Wert eines Value-Objektes zugreifen?
Zum Vergrößern anklicken....
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?
 
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.
Zum Vergrößern anklicken....

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.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Schneller Zugriff auf Liste mit sortierten Flaechen..?
Antworten: 7
Frage zum sortierten Ausgeben einer ArrayList!
Antworten: 22
Mouse Events in einer sortierten JTable unterscheiden
Antworten: 18
Linerae Suche in einem sortierten Array
Antworten: 2
MYSQL werte aus liste auslesen und anderen damit updaten
Antworten: 4

Zurück
Oben