wie sortiere ich am besten array ?

H

huhunde

Grünschnabel
Hätte ne frage: Also ich hab zwei arrays..ein double array - val und ein String array - names ! Die länge der beiden Arrays ist jeweils 10. An der Stelle x in val-Array steht der zugehörige Name an der Stelle x im names-Array. Wie sortiere ich das nun am besten ? - Ich will, dass an der Stelle 0 der höchste Wert steht und im names-Array an Stelle 0 der zugehörige Name. An Stelle 9 der kleinste Wert mit zugehörigen Namen.
 
Hallo!

Schau mal hier:
Java: 
/**
 * 
 */
package de.tutorials;

import java.util.Arrays;
import java.util.Set;
import java.util.TreeSet;

/**
 * @author Tom
 * 
 */
public class SortExample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        class KeyValuePair implements Comparable<KeyValuePair> {
            double value;

            String name;

            public KeyValuePair(String name, double value) {
                this.name = name;
                this.value = value;
            }

            public int compareTo(KeyValuePair o) {
                return (int) (o.value - this.value);
            }
            
            public String toString() {
                return this.name + ": " + this.value;
            }
        }

        KeyValuePair[] keyValuePairs = new KeyValuePair[5];
        keyValuePairs[0] = new KeyValuePair("A", 1024.0);
        keyValuePairs[1] = new KeyValuePair("B", 80);
        keyValuePairs[2] = new KeyValuePair("C", 1255);
        keyValuePairs[3] = new KeyValuePair("D", 48);
        keyValuePairs[4] = new KeyValuePair("E", 2);
        
        Arrays.sort(keyValuePairs);
        
        System.out.println(Arrays.toString(keyValuePairs));
        
        Set<KeyValuePair> set = new TreeSet<KeyValuePair>();
        set.add(new KeyValuePair("A", 1024.0));
        set.add(new KeyValuePair("B", 80));
        set.add(new KeyValuePair("C", 1255));
        set.add(new KeyValuePair("D", 48));
        set.add(new KeyValuePair("E", 2));
        System.out.println(set);

    }

}

Gruss Tom
 
Hallo zusammen,
habe im grunde das gleiche problem...

bräuchte die werte nur genau anders herum sortiert...also kleinste Werte zuerst, größte zum schluss.
Diese Werte bräuchte ich dann in einem Array... also der Wert, der an der ersten Stelle stehen sollte, wäre dann der Buchstabe, der den geringsten "Wert" hat.

Bezogen auf dieses Beispiel sollten der Arrayinhalt also so aussehen:
array[0]= "E" //weil E den Wert 2 hat
array[1]= "D" // weil D den Wert 48 hat
etc....

Ich vergleiche Werte eines Bildes mit einem Bilderordnerr und schaue welches Bild aus dem Ordner am wenigsten Differenz zu dem Wert des Bildes hat. Dann werden die Bilder auf einem neuen Frame angezeigt. Ich möchte die Bilder in einer sortierten Reihenfolge an die nächste Methode übergeben, die dann für die Anzeige der Bilder zuständig ist.

Da ich langsam aber sicher verzweifle bin ich für jeden Tipp dankbar!
Viele Grüsse
mel
 
Hallo!

um die Sortierung im Beispiel umukehren genügt es einfach die compareTo Methode leicht abzuändern:
von
Java: 
public int compareTo(KeyValuePair o) {
                return (int) (o.value - this.value);
}

Zu:

Java: 
public int compareTo(KeyValuePair o) {
                return (int) (this.value - o.value);
}

Gruß Tom
 
Hallo,

habe ähnliche Anwendung, muß meinen Code
aber unter Java 1.4 entwickeln.


> class KeyValuePair implements Comparable<KeyValuePair>

bekomme die Meldung, dass generics erst ab Version 1.5 unterstützt werden.
Gibt es da auch ne Möglichkeit, dass unter 1.4 umzusetzen?

Gruß
Thorsten
 
Moin!
Generics einfach weglassen, und dann in der compareTo Methode einfach casten :

Code: 
      /**
   
      *
   
      */
   
   
       
   
      import java.util.Arrays;
   
      import java.util.Set;
   
      import java.util.TreeSet;
   
       
  
      /**
  
      * @author Tom
  
      *
  
      */
  
      public class SortExample {
  
       
  
          /**
  
           * @param args
  
           */
  
          public static void main(String[] args) {
  
              class KeyValuePair implements Comparable {
  
                  double value;
  
       
  
                  String name;
  
       
  
                  public KeyValuePair(String name, double value) {
  
                      this.name = name;
  
                      this.value = value;
  
                  }
  
       
  
                  public int compareTo(Object o) {
  
                      return (int) (this.value - ((KeyValuePair)(o)).value);
  
                  }
  
                 
  
                  public String toString() {
  
                      return this.name + ": " + this.value;
  
                  }
  
              }
  
              
  
              KeyValuePair[] keyValuePairs = new KeyValuePair[5];
  
              keyValuePairs[0] = new KeyValuePair("A", 1024.0);
  
              keyValuePairs[1] = new KeyValuePair("B", 80);
  
             keyValuePairs[2] = new KeyValuePair("C", 1255);
  
              keyValuePairs[3] = new KeyValuePair("D", 48);
  
              keyValuePairs[4] = new KeyValuePair("E", 2);
  
             
  
              Arrays.sort(keyValuePairs);
  
             
  
              System.out.println(Arrays.toString(keyValuePairs));
  
             
  
              Set set = new TreeSet();
  
              set.add(new KeyValuePair("A", 1024.0));
  
              set.add(new KeyValuePair("B", 80));
  
              set.add(new KeyValuePair("C", 1255));
  
              set.add(new KeyValuePair("D", 48));
  
              set.add(new KeyValuePair("E", 2));
  
              System.out.println(set);
  
       
  
         }
  
     
  
      }


*grüssle*
MeinerEiner
 
O.K.
Mit dem Casting geht das soweit.
Sortierung klappt auch.

>System.out.println(Arrays.toString(keyValuePairs));

geht bei mir nicht?

Warum muß ich denn noch den Teil mit

> Set set = new TreeSet();

haben. Kann man nicht direkt auf das sortierte array zugreifen?
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück