Datentypen Date-Array sortieren - Text mitnehmen?

[FRI3ND]

Hallo,
ich schreibe momentan ein Programm, bei dem es essenziel ist, eine Liste mit verschiedenen Zeitpunkten zu sortieren. Allerdings besteht der zu sortierende Text nicht nur aus einem Datum; es ist auch ein kleiner Text dabei. Bisher habe ich es nur geschafft, das Datum ohne den Text zu sortieren, doch das bringt mir leider wenig und ich schaffe es nciht, den Text mitzunehmen.
Daher bitte ich nun euch um Hilfe; hier ist ein kleines Test-Programm, mit dem ich es versucht habe:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;

public class Test {

    public static void main(String[] args) {
        String[] test =
            {
                "01.01.2002,17:53,Ich", "01.01.2001,16:38,bin",
                "02.01.2001,13:42,ein", "01.01.2001,16:39,sehr",
                "01.01.2003,15:35,kreativer", "01.01.1999,13:45,Text"
            };

        test = sortiere(test);
        System.err.println("Sortiert:");
        for (String s : test) {
            System.err.println(s);
        }
    }

    public static String[] sortiere(String[] liste) {
        ArrayList<String> list = new ArrayList();
        list.addAll(Arrays.asList(liste));
        ArrayList<Date> date = new ArrayList<>();
        SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy,HH:mm");
        Date dt;
        String[] splitted;
        String[] datum;
        String[] uhrzeit;
        for (String s : list) {
            try {
                splitted = s.split(",");
                s = splitted[0] + "," + splitted[1] /* + "," + splitted[2] */;
                dt = sdf.parse(s);
                date.add(dt);
            } catch (ParseException ignore) {
            }
        }
        date.sort((d1, d2) -> d1.compareTo(d2));
        list.clear();
        for (Date d : date) {
            list.add(sdf.format(d));
        }
        for (int i = 0; i < liste.length; i++) {
            liste[i] = list.get(i);
        }
        return liste;
    }
}

 

[mrBrown]

Nutz für die Daten eine sinnvolle Datenstruktur, und nicht nur Strings

 

[Flown]

Mal eine Anregung:

/**
 * This class represents a log entry in format: dd.MM.yyyy,HH:mm,{@literal text*}.
 */
public class LogEntry implements Comparable<LogEntry> {
  private static Pattern LOG_ENTRY = Pattern.compile("^(?<datetime>.*?,.*?),(?<text>.*)$");
  private static DateTimeFormatter LOG_DATE_TIME = DateTimeFormatter.ofPattern("dd.MM.yyyy,HH:mm");
 
  private final LocalDateTime datetime;
  private final String text;
 
  private LogEntry(LocalDateTime datetime, String text) {
    this.datetime = datetime;
    this.text = text;
  }
 
  /**
   * Tries to parse the given string to a {@link LogEntry}
   *
   * @param s input string
   * @return {@code null}, if input is {@code null} or does not conform to {@link LogEntry}'s pattern,
   * else a {@link LogEntry}
   */
  public static LogEntry parse(String s) {
    if (s == null) {
      return null;
    }
    Matcher matcher = LOG_ENTRY.matcher(s);
    if (!matcher.matches()) {
      return null;
    }
    LocalDateTime datetime = LOG_DATE_TIME.parse(matcher.group("datetime"), LocalDateTime::from);
    String text = matcher.group("text");
   
    return new LogEntry(datetime, text);
  }
 
  /**
   * Sorting order is:
   * <ol>
   *   <li>datetime</li>
   *   <li>text</li>
   * </ol>
   * <p>
   * {@inheritDoc}
   */
  @Override
  public int compareTo(LogEntry o) {
    int cmp = datetime.compareTo(o.datetime);
    if (cmp == 0) {
      return text.compareTo(o.text);
    }
    return cmp;
  }
 
  /**
   *
   * @return {@link LogEntry}'s string representation
   */
  @Override
  public String toString() {
    return LOG_DATE_TIME.format(datetime) + "," + text;
  }
}

Dann kann man das laufen lassen mit:

String[] test = {"01.01.2002,17:53,Ich", "01.01.2001,16:38,bin", "02.01.2001,13:42,ein", "01.01.2001,16:39,sehr",
    "01.01.2003,15:35,kreativer", "01.01.1999,13:45,Text", "01.01.1999,13:45,Aext"};
List<String> sortedLogs = Arrays.stream(test).map(LogEntry::parse).sorted().map(Objects::toString).collect(Collectors.toList());
System.out.println(sortedLogs);

 

[MoxxiManagarm]

Ich stimme grundsätzlich mit der Sinnvollen Datenstruktur überein. Ich würde daher die Vorgänger Vorschläge dringend empfehlen. Aber es würde auch so gehen:

package javaforum.org.friend;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;


public class ArraySorter {
    public static void main(String[] args) {
        String[] test =
            {
                "01.01.2002,17:53,Ich", "01.01.2001,16:38,bin",
                "02.01.2001,13:42,ein", "01.01.2001,16:39,sehr",
                "01.01.2003,15:35,kreativer", "01.01.1999,13:45,Text"
            };
      
        System.out.println(Arrays.toString(test));

        Arrays.sort(test, (s1, s2) -> {
                String sub1 = s1.substring(0,16);
                String sub2 = s2.substring(0,16);
              
                SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy,HH:mm");
              
                try {
                    return sdf.parse(sub1).compareTo(sdf.parse(sub2));
                } catch (ParseException ex) {
                    return 0;
                }
            }
        );
      
        System.out.println(Arrays.toString(test));
    }
}

Blöd ist hier speziell, dass man in der Compare-Methode eigentlich nicht parsen sollte. Das Exception-Handling ist hier unpassend. außerdem wird hier potenziell mehrmals das gleich

 

[mihe7]

Das geht noch hässlicher:

    public static String[] sortiere(String[] liste) {
        SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy,HH:mm");
        Object[][] records = new Object[liste.length][];
        int i = 0;
        for (String s : liste) {
            try {
                String[] splitted = s.split(",");
                records[i] = new Object[2];
                records[i][0] = sdf.parse(splitted[0] + "," + splitted[1]);
                records[i][1] = s;
                i++;
            } catch (ParseException ignore) {
            }
        }
        Arrays.sort(records, (r1, r2) -> ((Date) r1[0]).compareTo((Date)r2[0]));
        for (i = 0; i < liste.length; i++) {
            liste[i] = (String) records[i][1];
        }
        return liste;
    }

 

[FRI3ND]

Nutz für die Daten eine sinnvolle Datenstruktur, und nicht nur Strings

Mir ist schon klar, dass andere Datentypen möglicherweise besser wären. Allerdings lese ich mein Array eben aus einer Text-Datei und da kommen eben Strings raus...
Danke für die vielen Antworten; ich werde den Codevorschlag von MoxxiManagarm umsetzen...

 

[mrBrown]

Mir ist schon klar, dass andere Datentypen möglicherweise besser wären. Allerdings lese ich mein Array eben aus einer Text-Datei und da kommen eben Strings raus...

Schon klar - aber sinnvoller weise wandelt man das genau an der Schnittstelle in sinnvolle Datenstrukturen um

 

[L0oNY]

Datenstruktur ist nicht gleich Datentyp