# Eingabe sortieren



## benniII (29. Jan 2008)

Hallo alle zusammen,
hab ein problem mit meinem Code.
Also hier einen kurze Erklärung zu meinem Problem. Ich will mit meinen Programm eine Spalte aus einer Excel Datei auslesen, inder Namen stehen die auch mehrfach aufgeführt sind, diese Namen sollen gezählt werden und dann letztendlich nach Programm durchlauf ausgegeben werden. (zb: 13xZimmerman, 8xMaier, 18xTobias,etc)
Dies funktioniert bei meinem Programm schon ohne Probleme auch schon die Ausgabe in eine Excel Datei.

So und jetzt zu meinem Problem. ich wil die ausgelesenen Werte mit Namen in eine Reihenfolge bringen, sozusagen das die Namen nach der Anzahl der Vorkommnisse sortiert wird. egal ob absteigend oder aufsteigend. (Die liste der Namen wächst stetig und es kommen auch immer neue Namen dazu, sodass sich die Reihenfolge der eingelesen Namen ändern wird.

Ich habe es schon mit einer JTable probiert aber, aber dann hab ich mir das ganze prog geschossen. Ich habe es auch schon mit Comparator und Comparable ( CompareTo) aus der API komm ich einfach nicht zurecht. Mit einer anderen Sortierung wie 


```
//(v=vorkommnisse, n=name)
if (v1<v2) return -1;
if (v1>v2) return 1;
if (v1==v2{
  return n1.compareTo(n2);
}
```

funktioniert die Namenszuordnung nicht mehr. ^^ 

Also ich hoffe das mir jemand von euch helfen kann und mir evtl sogar schon den verbesserten code posten kann.Ich wäre sehr dankbar dafür.

Die API zum Excel-File auslesen gibts hier: falls ihr sie benötigt http://jexcelapi.sourceforge.net/res...ocs/index.html

die Namensdatei sieht etwa so ausmuss lieder posten da ich den fileupload nicht gefunden habe)

EVANSD
WARNCK
WARNCK
LIVIERI
KAEMPF
WARNCK
KRIST
WARNCK
RÄß
ZOWALLA
SCHROEDER
RÄß
RÄß
RÄß
NESSEN-LAPP
STRAßBURGER
PART
KLAUSF
ADSHEADP
LIVIERI
KLAUSF
ZIMMERMANN
WARNCK
WARNCK
FROEHNER
WARNCK
WARNCK




```
public class NameCounter
{
    private String name;
    private int counter;
 
    /**
     * Konstruktor
     */
    public NameCounter(String name)
    {
        this.name = name;
        this.counter = 1;
    }
 
    /**
     * Erhöht den Namenzähler
     */
    public void setCounterUp()
    {
        this.counter++;
    }
 
    /**
     * Gibt den Namen zurück.
     * 
     * @return {@link String}
     */
    public String getName()
    {
        return name;
    }
 
    /**
     * Gibt die Anzahl der gezählten Namen zurück.
     * 
     * @return {@link Integer}
     */
    public int getCounts()
    {
        return counter;
    }
}






import java.io.File;
import java.io.IOException;
import java.util.Vector;
import java.util.Date;
import jxl.*;
import jxl.write.*;
import jxl.Sheet;
import jxl.Workbook;
import jxl.read.biff.BiffException;
import java.io.*;
import java.lang.*;
import jxl.write.Number;
 
 
public class ExcelTest
{
  // Initialisieren der globalen Variablen
  public String path = "//java/test/namen.xls";
  public Workbook workbook = null;
  public Vector<NameCounter> nameVector = new Vector<NameCounter>();
  //private Vector <NameCounter> nameVector = new Vector();
  /**
   * Programm starten.
   */
  public void start()
  {
    // Abfangen der Exceptions
    try
    {
      // Einlesen der Datei
      this.workbook = Workbook.getWorkbook(new File("//java/test/namen.xls"));
    }
    catch (BiffException e)
    {
      System.out.println("BiffException" + e.getMessage());
    }
    catch (IOException e)
    {
      System.out.println("IOException" + e.getMessage());
    }
    // Tabelle initialisieren
    Sheet sheet = this.workbook.getSheet(0);
    // Erstellen der Zellenobjekte
    String cellText;
    NameCounter nameCounter;
    // Die zu durchsuchende Spalte und Startzeile initialisieren
    int suchSpalte = 4;
    int startZeile = 7;
    // Schleife für Zellenüberprüfung
    for (int i = startZeile; i < sheet.getRows(); i++)
    {
      // Einlesen der Zellen in die String-Variablen
      cellText = sheet.getCell(suchSpalte, i).getContents().trim();
      nameCounter = isNameInVector(cellText);
      if (nameCounter == null)
      {
        if (!cellText.equals(""))
        {
          this.nameVector.add(new NameCounter(cellText));
        }
      }
      else
      {
        nameCounter.setCounterUp();
      }
    }
    try{
      WritableWorkbook workbook1 = Workbook.createWorkbook(new File("//java/test/ausgabe13.xls"));
      WritableSheet sheet1 = workbook1.createSheet("meop2", 2);
       // Schleife für die Konsolenausgabe
     for (int i = 0; i < this.nameVector.size(); i++)
      {
         nameCounter = this.nameVector.elementAt(i);
         System.out.println(nameCounter.getName() + ": "  +" \t "+ nameCounter.getCounts());
         Label label = new Label(3, (i+5),nameCounter.getName() + ": "  );
         sheet1.addCell(label);
         Number number = new Number(6, (i+5), nameCounter.getCounts());
         sheet1.addCell(number);
      }
         workbook1.write();
         workbook1.close();
    }
      catch (Exception e) {
       System.out.println("Exception: " + e.getMessage());
      }
  }
  /**
   * Überprüfen ob der Name bereits im Vector vorhanden ist.
   */
  public NameCounter isNameInVector(String name)
  {
    NameCounter nameCounter = null;
    NameCounter nameCounterTest;
    for (int i = 0; i < nameVector.size(); i++)
    {
      nameCounterTest = nameVector.elementAt(i);
      if (nameCounterTest.getName().equals(name))
      {
        nameCounter = nameCounterTest;
        break;
      }
      else
      {
        nameCounter = null;
      }
    }
    return nameCounter;
  }
 
 
  /**
   * Mainmethode
   */
      public static void main(String[] args)
      {
       new ExcelTest().start();
 
 
      }
}
```





thx benni


----------



## SlaterB (29. Jan 2008)

ganz wichtiger Tipp: trenne dein Programm in Teile auf,
da hast du einen Teil, der etwas aus Excel liest, in eine String-Liste oder so,
und am Ende die Ergebnisse wegschreibt,

das zweite Programm, was die Strings entgegennimmt und sortiert usw.
hat gar nichts mit Excel zu tun,
im Moment ist die Trennung noch nicht so leicht, weil du jeden String aus dem Excel direkt sortierend verarbeitest,
aber wenn du wie gesagt aus Excel nur ein großes String-Array/ Liste einliest und diese dann verarbeitest,
dann ist die Trennung klar,

dann könntest du auch testweise eine Test-Liste "a","b","c" übergeben und am Ende mit System.out.println ausgeben,
ohne in dieser Testphase je mit Excel in Berührung zu kommen,
das Forum müsste auch rein gar nix von Excel erfahren, deine Frage hat nix Excel nichts zu tun,

da du den Code aber so vermischt hast, kann fast niemand deinen Code ausprobieren

--------

zu deiner Frage: ja, das mit dem Comparator sieht gut aus, oder NameCounter Comparable implementieren lassen,
du musst natürlich dafür sorgen, dass bei doppelten Namen nicht zwei NameCounter-Objekte erzeugt werden, sondern beim ersten der count erhöht wird,

am besten hast du eine Map String -> NameCounter,
für jeden String schaust du dann nach, ob schon ein 
NameCounter-Objekt vorhanden ist,
wenn nein, dann neues anlegen, sonst count erhöhen,
falls dir Map zu hoch ist funktioniert es mit dem Vector auch,
einfach darin nachschauen ob schon ein NameCounter vorhanden

-----------

wenn dir grundsätzlich Comparable/ Comparator nicht klar ist,
dann würde ich das ein einem klitze-kleinen 10 Zeilen-PRogramm (+ NameCounter-Klasse) testen,
nicht inmitten deines Hauptprogrammes, wo noch anderes zu testen ist,


main() {
// Vector erstellen
// zwei Elemente anlegen
// sortieren
// Ergebnis prüfen
}


was soll man jetzt zu Comparable sagen? 'implements Comparable' an die Klasse ranschreiben
und die zugehörige Operation implementieren,
Beispiele gibts in Lehrbüchern
http://www.galileocomputing.de/open...12_004.htm#mjaf8d671aa3283d042df48c24f0c0c87b


----------



## Gast (30. Jan 2008)

ok danke werd ich gleich mal testen und evtl meinen code noch ein bisschen besser sortieren 
weil es stimmt schon, wenn man als aussenstehender über das prog drüber schaut, dass man dann gleich ein bisschen erschrickt, wieviel schmarrn ein einzelnern machen kann


----------

