# Vector mit Objekten sortieren



## JavaJay (20. Jul 2007)

Hallo

Also irgendwie komme ich mit dem Sortieren von Objekten in einem Vector nicht klar.

Also folgendes:

Ich habe einen Vector der Objekte speichert. Ein Objekt besteht aus 6 verschiedenen Strings.
Objekt:
String frima, name, vorname, tel, fax... usw.

So wie bekomme ich diesen Vektor jetzt sortiert? Ich bekomme es einfach nicht hin.

Hier mal mein Codeauszug


```
...
public int compareTo(contactObj a, contactObj b){
    return ((String) a.getFirma()).compareTo(((String) b.getFirma()));
  }

  public void sortActionPerformed(ActionEvent evt) {
    for (int i = 0; i < v.size(); i++){
      contactObj ai = (contactObj) v.get(i);
      for(int j = 0; j < v.size() - 1; j++){
        contactObj aj = (contactObj) v.get(j);
        compareTo(ai, aj);
        Collections.sort(v, compareTo());
      }
    }
 }
...
```

Hab auch schon die Suche benutzt. Steig bei vielem aber auch nicht wirklich durch.

Bitte um Hilfe


----------



## SlaterB (20. Jul 2007)

wenn du einen Comparator benutzen willst:
Collections.sort(v, Comparator);
nur ein Aufruf, ohne Schleife

schaffst du es, Comparator aus Lehrbüchern kennenzulernen?
http://www.galileocomputing.de/open...11_004.htm#mj44ce45c0a85db33fa30b3315d63024d5

insbesondere
Listing 11.7    com/javatutor/insel/util/ClubComparatorDemo.java

-----

mit zwei Schleifen Bubblesort oder ähnliches nachzubauen wollen wir mal gar nicht erst versuchen


----------



## JavaJay (20. Jul 2007)

Ach so ich benötige da garkeine Schleife!?

Hmm ok dann hab ich etwas falsch gedacht.

OK ich probiere mich mal. Danke schonmal für die Hilfe

Melde mich wenn es nicht klappt.


----------



## Guest (20. Jul 2007)

Super vielen Dank für deine Hilfe

Ich hab es hinbekommen.

Hab also einfach nur das mit der Schleife und dem Comarator falsch verstanden.


----------



## André Uhres (20. Jul 2007)

Nur so ne Idee: was haltet ihr von einer SortKey?
Das hat natürlich den Nachteil, daß es mehr Speicherplatz braucht, aber ich find's irgendwie übersichtlicher 
und der Comparator wird ja dann auch unabhängiger vom Objekt (als Beispiel hier die Person):

```
...
        Collections.sort(vector, new Comparator<Person>() {
            public int compare(Person p1, Person p2) {
                return p1.getSortKey().compareTo(p2.getSortKey());
            }
        });
...
class Person{
    private String vorn, name, firm, sKey;
    final private String SP = "                              ";
    public Person(final String vornP, final String nameP, final String firmP){
        if(vornP==null || nameP==null || firmP==null) 
            throw new NullPointerException();
        if(vornP.length()>SP.length() || nameP.length()>SP.length() || firmP.length()>SP.length())
            throw new IllegalArgumentException();
        vorn = vornP;
        name = nameP;
        firm = firmP;
        sKey = buildSortKey();
    }
    public String getFirma()   {return firm;}
    public String getName()    {return name;}
    public String getVorname() {return vorn;}
    public String getSortKey() {return sKey;}
    public String toString()   {return firm+"_"+name+"_"+vorn;}
    private String buildSortKey() {
        StringBuilder buildKey = new StringBuilder();
        buildKey.append(firm);
        buildKey.append(SP.substring(firm.length()));
        buildKey.append(name);
        buildKey.append(SP.substring(name.length()));
        buildKey.append(vorn);
        buildKey.append(SP.substring(vorn.length()));
        return buildKey.toString();
    }
}
```


----------



## Guest (20. Jul 2007)

André Uhres hat gesagt.:
			
		

> Nur so ne Idee: was haltet ihr von einer SortKey?
> Das hat natürlich den Nachteil, daß es mehr Speicherplatz braucht, aber ich find's irgendwie übersichtlicher
> und der Comparator wird ja dann auch unabhängiger vom Objekt (als Beispiel hier die Person):


Dann doch lieber Comparable implementieren (gleicher Aufwand, ohne die Datenmenge zu verdoppeln). 
Möchte man aber nach verschiedenen Kriterien sortieren, sind Comparatoren ausserhalb der Klasse besser.


----------



## André Uhres (21. Jul 2007)

Anonymous hat gesagt.:
			
		

> ..Möchte man aber nach verschiedenen Kriterien sortieren, sind Comparatoren ausserhalb der Klasse besser.


Man kann ja auch verschiedene SortKeys anlegen.


----------



## semi (21. Jul 2007)

André Uhres hat gesagt.:
			
		

> Anonymous hat gesagt.:
> 
> 
> 
> ...


Hallo,

genauso könnte man mehrere Comparatoren implementieren. Der Aufwand bleibt gleich, die Datenmenge 
wird aber nicht verlielfacht, nur für den Fall, dass man irgendwo Vergleichmöglichkeiten braucht. 
Ich persönlich würde es lieber trennen.

PS: Ich war der Gast da oben.

Gruß,
Michael


----------



## André Uhres (21. Jul 2007)

semi hat gesagt.:
			
		

> ..Der Aufwand bleibt gleich..


Je mehr ich darüber nachdenke, desto mehr schwinden die "Vorteile" einer einer SortKey   
An Performanz gewinnt man wahrscheinlich auch nichts.
Naja, die Väter von Java haben sich das schon gut ausgedacht


----------



## semi (21. Jul 2007)

André Uhres hat gesagt.:
			
		

> semi hat gesagt.:
> 
> 
> 
> ...


Wer sagt, dass es Väter waren? 

Übrigens, man könnte es auch per Reflection machen (sieht aber sch... aus )

Verwendung
	
	
	
	





```
Collections.sort(personList, new GenericComparator( Person.class, new String[] { "nachname", "vorname" }));
Collections.sort(adressList, new GenericComparator( Adresse.class, new String[] { "ort", "strasse" }));
```

Implementierung (so auf die Schnelle zusammengetippt, Fehler nicht ausgeschlossen und Code potthässlich  :wink: )
	
	
	
	





```
class GenericComparator<TValueType> implements Comparator<TValueType>
   {
      private Method getterList[];
      
      public GenericComparator(Class<TValueType> clazz, String properties[])
      {
         getterList = new Method[properties.length];
         try
         {
            // TODO: Code zu hässlich
            BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
            PropertyDescriptor props[] = beanInfo.getPropertyDescriptors();
            int i=0;
            for(String property : properties)
            {
               for(PropertyDescriptor descriptor : props)
               {
                  if(descriptor.getName().equals(property))
                  {
                     getterList[i++] = descriptor.getReadMethod();
                     break;
                  }
               }
               // TODO: Wenn Property nicht gefunden wird, laut schreien
            }
         }
         catch (IntrospectionException e)
         {
            // TODO: e.printStackTrace() ist keine Fehlerbehandlung 
            e.printStackTrace();
         }
      }

      @SuppressWarnings("unchecked")
      public int compare(TValueType v1, TValueType v2)
      {
         int result = 0;
         
         for(Method getter : getterList)
         {
            try
            {
               // TODO: ACHTUNG! Hier gehe ich davon aus, dass alles Comparable ist und nicht null!
               result = ((Comparable)getter.invoke(v1, (Object[])null)).compareTo(getter.invoke(v2, (Object[])null));
            }
            catch (IllegalArgumentException e)
            {
               // TODO: e.printStackTrace() ist keine Fehlerbehandlung
               e.printStackTrace();
            }
            catch (IllegalAccessException e)
            {
               // TODO: e.printStackTrace() ist keine Fehlerbehandlung               
               e.printStackTrace();
            }
            catch (InvocationTargetException e)
            {
               // TODO: e.printStackTrace() ist keine Fehlerbehandlung               
               e.printStackTrace();
            }
            
            if(result != 0)
            {
               break;
            }
         }
         
         return result;
      }
   }
```


----------



## André Uhres (21. Jul 2007)

semi hat gesagt.:
			
		

> Wer sagt, dass es Väter waren?


Hast recht, sagen wir die Eltern, obwohl der, der oft als Hauptperson bezeichnet wird, James Gosling, ein Mann ist


----------

