Java: gewusst Wie: konvertieren einer Zeichenfolge (HH:MM:SS) Dauer?

will ich konvertieren eine Zeichenfolge im format HH:MM:SS oder MM:SS oder SS in einen Datentyp von Dauer.

Lösung:

    private ArrayList<Duration> myCdDuration = new ArrayList<Duration>();

        private void convert(String aDuration) {

            chooseNewDuration(stringToInt(splitDuration(aDuration))); //stringToInt() returns an int[] and splitDuration() returns a String[]
        }

        private void chooseNewDuration(int[] array) {
            int elements = array.length;
            switch (elements) {
            case 1:
                myCdDuration.add(newDuration(true, 0, 0, 0, 0, 0, array[0]));
                break;
            case 2:
                myCdDuration.add(newDuration(true, 0, 0, 0, 0, array[0], array[1]));
                break;
            case 3:
                myCdDuration.add(newDuration(true, 0, 0, 0, array[0], array[1],
                        array[2]));
                break;
            }
        }

danke für die Hilfe ... ein einfacher Weg, dies zu tun ? -> erstellen Sie Ihre eigenen Klasse Dauer:

public class Duration {
        private int intSongDuration;
        private String printSongDuration;

        public String getPrintSongDuration() {
            return printSongDuration;
        }

        public void setPrintSongDuration(int songDuration) {
            printSongDuration = intToStringDuration(songDuration);
        }

        public int getIntSongDuration() {
            return intSongDuration;
        }

        public void setIntSongDuration(int songDuration) {
            intSongDuration = songDuration;
        }

        public Duration(int songDuration) {

            setIntSongDuration(songDuration);
        }

Wandelt den int-Wert in einen String für die Ausgabe/drucken:

private String intToStringDuration(int aDuration) {
    String result = "";

    int hours = 0, minutes = 0, seconds = 0;

    hours = aDuration / 3600;
    minutes = (aDuration - hours * 3600) / 60;
    seconds = (aDuration - (hours * 3600 + minutes * 60));

    result = String.format("%02d:%02d:%02d", hours, minutes, seconds);
    return result;
}

InformationsquelleAutor der Frage Frank | 2011-11-24

2
1. Ihre myCdDuration ist verwirrend. Wollen Sie eine Duration Objekt entspricht, was angegeben wurde, im string oder eine Liste von Duration Objekte, bei denen der erste enthält die Stunden, die zweiten die Minuten usw?
2. Können Sie nicht nur werfen ein String in einem anderen Objekt zu. Sie sollte analysieren, den Wert in einen numerischen Typ, und verwenden Sie DataTypeFactory zu konstruieren, die Duration Objekt.
InformationsquelleAutor der Antwort andri
17

Ich gehe davon aus, was Sie letztlich versuchen, zu erreichen, ist die Berechnung der Dauer der CD in Sekunden.

Gibt es mehrere Möglichkeiten, dies zu tun, aber ich denke, das einfachste ist, einfach aufteilen auf : zu bekommen, die Stunden -, Minuten-und Sekunden-Feldern, dann berechnen Sie die Dauer manuell:
```
String timestampStr = "14:35:06";
String[] tokens = timestampStr.split(":");
int hours = Integer.parseInt(tokens[0]);
int minutes = Integer.parseInt(tokens[1]);
int seconds = Integer.parseInt(tokens[2]);
int duration = 3600 * hours + 60 * minutes + seconds;
```
InformationsquelleAutor der Antwort Mansoor Siddiqui
15

tl;dr

Keine Notwendigkeit, zu definieren, Ihre eigenen Duration Klasse, wie Java bietet.
```
Duration.between (                  //Represent a span of time of hours, minutes, seconds. 
    LocalTime.MIN ,                 //00:00:00
    LocalTime.parse ( "08:30:00" )  //Parse text as a time-of-day. 
)                                   //Returns a `Duration` object, a span-of-time. 
.toString()                         //Generate a `String` with text in standard ISO 8601 format. 
```
PT8H30M

Und analysieren standard ISO-8601 formatierte text.
```
Duration.parse( "PT8H30M" )   //Parse standard ISO 8601 text yo get a `Duration` object. 
```
Vermeiden HH:MM:SS format

Wenn der string 08:30:00 du meinst "acht und eine halbe Stunde" Zeit eher als eine Zeit-of-day "halb acht in der früh", dann vermeiden Sie, dass das format der HH:MM:SS. Das format mehrdeutig, erscheint ein time-of-Tag. Verwenden Sie stattdessen die standard-ISO-8601-format werden unten diskutiert.

Dauer-und Zeit-of-day sind zwei sehr unterschiedliche Konzepte. Ihnen muss klar sein, jeder sollte deutlich in Ihrem Geist. Mit der mehrdeutige format:HH: MM:SS macht diese Unterscheidung noch schwieriger (so vermeiden Sie, dass das format!).

java.Zeit

Die moderne Art, die mit der java.Zeit-Klassen.

LocalTime

Ersten parse den string als LocalTime. Diese Klasse stellt eine Uhrzeit ohne Datum und ohne Uhrzeit zone. Ohne Zeit-zone bedeutet, dass diese Objekte basieren auf einem generischen 24-Stunden-Uhr, die ohne Rücksicht auf Anomalien wie Daylight Saving Time (DST).

Wir nicht wirklich wollen, eine LocalTime wie Ihre input-string stellt einen Zeitraum von Zeit, anstatt eine time-of-Tag. Aber das ist nur der erste Schritt.
```
LocalTime lt = LocalTime.parse ( "08:30:00" );
```
Duration

Zur Darstellung der gewünschten span-Zeit möchten wir, dass die Dauer Klasse. Diese Klasse ist für Zeitspannen nicht an die timeline. Wir können durch die Umwandlung, die LocalTime immer über die Menge der Zeit, die seit Beginn der Zeit-of-day clock, die 00:00:00.0 oder LocalTime.MINund die lt wir nur instanziiert werden.
```
Duration d = Duration.between ( LocalTime.MIN , lt );
```
Bearbeitung der input-string

Den Ansatz oben mit LocalTime funktioniert nur, wenn Sie Ihre Eingabe-strings repräsentieren eine Dauer von weniger als 24 Stunden. Wenn mehr als 24 Stunden, werden Sie Parsen der input-string selbst.

Etwas wie den folgenden code. Natürlich die eigentliche Analyse richtet sich auf die Lösung der Mehrdeutigkeit des jeweiligen input-string. Ist 50:00 gemeint fünfzig Stunden oder fünfzig Minuten? (Diese Doppeldeutigkeit ist ein starker Grund, dies zu vermeiden verwirrend format, Wann immer möglich, und stick mit ISO-8601-Formate.)
```
String input = "50:00";  //Or "50:00:00" (fifty hours, either way)

String[] parts = input.split ( ":" );
Duration d = Duration.ZERO;
if ( parts.length == 3 ) {
    int hours = Integer.parseInt ( parts[ 0 ] );
    int minutes = Integer.parseInt ( parts[ 1 ] );
    int seconds = Integer.parseInt ( parts[ 2 ] );
    d = d.plusHours ( hours ).plusMinutes ( minutes ).plusSeconds ( seconds );
} else if ( parts.length == 2 ) {
    int hours = Integer.parseInt ( parts[ 0 ] );
    int minutes = Integer.parseInt ( parts[ 1 ] );
    d = d.plusHours ( hours ).plusMinutes ( minutes );
} else {
    System.out.println ( "ERROR - Unexpected input." );
}
```
ISO 8601

Können wir das Ergebnis sehen durch die Erzeugung eines String in standard ISO-8601-format für die Dauer einfach durch Aufruf Dauer::toString. Die java.Zeit-Klassen verwenden ISO-8601 standardmäßig beim Parsen/generieren von strings. Für die Dauer, die das standard-format ist PnYnMnDTnHnMnS wo die P markiert den Anfang und das T trennt den Jahren-Monaten-Tagen Teil aus den Stunden-Minuten-Sekunden-Teil. So, unsere acht-und-ein-halb Stunden, wird angezeigt, wie PT8H30M.

System.aus.println ( "d....toString(): "+ d );

d.toString(): PT8H30M

Sammeln Duration Objekte

Können Sie eine List holding-Elemente des Typs Duration.
```
List<Duration> durations = new ArrayList<>( 3 );  //Initial capacity of 3 elements.
durations.add( d ) ;
durations.add( Duration.between ( LocalTime.MIN , LocalTime.parse ( "03:00:00" ) ) ) ;
durations.add( Duration.between ( LocalTime.MIN , LocalTime.parse ( "01:15:00" ) ) ) ;
```
Dauer.toString(): [PT8H30M, PT3H, PT1H15M]

Denken Sie daran, dass die Zeichenfolgen, die Sie finden in dieser Ausgabe wie PT8H30M sind nur, dass: Ausgabe des generierten strings. Die Duration Typ ist nicht eine einfache Zeichenfolge, sondern eher generiert ein String-Objekt durch seine toString Methode.

Wenn man sich an die ISO 8601-Formate, können Sie leicht analysieren sowie erzeugen solcher strings. Keine Notwendigkeit zu gehen durch die LocalTime Konvertierung rigamarole wir führten oben in dieser Antwort.
```
Duration d = Duration.parse( "PT8H30M" );
```
Diesem Beispiel sehen code live in IdeOne.com.

Über java.Zeit

Den java.Zeit framework ist in Java 8 und höher. Diese Klassen verdrängen die lästige alte Vermächtnis Datum-Zeit-Klassen wie java.util.DateCalendar& " = SimpleDateFormat.

Den Joda-Time Projekt, jetzt in Wartungsmodusrät der migration auf die java.Zeit Klassen.

Um mehr zu erfahren, siehe die Oracle Tutorial. Und die Suche Stack Overflow für viele Beispiele und Erklärungen. Spezifikation JSR 310.

Wo erhalten Sie die java.Zeit-Klassen?
- Java SE 8 und SE 9 und später
  - Eingebaut.
  - Teil der standard-Java-API mit einer gebündelten Umsetzung.
  - Java 9 fügt einige kleine features und behebt.
- Java SE 6 und SE 7
  - Viel von java.Funktionalität ist zurück-portiert auf Java 6 & 7 in ThreeTen-Backport.
- Android
  - Die ThreeTenABP Projekt passt ThreeTen-Backport (oben erwähnt) für Android-spezifisch.
  - Sehen die How to use ThreeTenABP....
Den ThreeTen-Extra Projekt erweitert die java.mal mit zusätzlicher Klassen. Dieses Projekt ist ein Testgelände für mögliche künftige Erweiterungen zu java.Zeit. Sie finden möglicherweise einige nützliche Klassen, die hier wie IntervalYearWeekYearQuarterund mehr.

InformationsquelleAutor der Antwort Basil Bourque

Ich geschrieben habe, diese Methode in meiner utils-Klasse zu analysieren, verschiedene Arten von Dauer-strings. Es ist Recht flexibel :

public static int getSecondsFromFormattedDuration(String duration){
        if(duration==null)
            return 0;
        try{

            Pattern patternDuration = Pattern.compile("\\d+(?::\\d+){0,2}");

            int hours = 0;
            int minutes = 0;
            int seconds = 0;
            if(patternDuration.matcher(duration).matches()){
                String[] tokens = duration.split(":");
                if(tokens.length==1){
                    seconds = Integer.parseInt(tokens[0]);
                }else if(tokens.length == 2){
                    minutes = Integer.parseInt(tokens[0]);
                    seconds = Integer.parseInt(tokens[1]);
                }else{
                    hours = Integer.parseInt(tokens[0]);
                    minutes = Integer.parseInt(tokens[1]);
                    seconds = Integer.parseInt(tokens[2]);
                }

                return 3600 * hours + 60 * minutes + seconds;
            }else
                return 0;

        }catch (NumberFormatException ignored){
            return 0;
        }

}

Dies ist, wie es analysiert die genannten Zeiträume :

"1"   -->  1
"10"  -->  10
"10:"   -->  0  (not a valid duration)
"10:07"   -->  607
"06:08"   -->  368
"7:22"   -->  442
":22"   -->  0  (not a valid duration)
"10:32:33"   -->  37953
"2:33:22"   -->  9202
"2:2:02"   -->  7322
"2:33:43:32"   -->  0  (not a valid duration)
"33ff"   -->  0  (not a valid duration)
"2d:33"   -->  0  (not a valid duration)

InformationsquelleAutor der Antwort Rahul Verma

1

Ich würde vorschlagen nicht Verwendung javax.xml.datatype.Durationals seine im Zusammenhang mit der XML-Java-API und es ist verwirrend, um zu verwenden, wenn Sie nicht den Umgang mit XML. Darüber hinaus ist es eine abstrakte Klasse, und es gibt keine nicht-abstrakte dokumentiert die Umsetzung in Java SE, so müssten Sie entweder Ihre eigenen, nicht-abstrakte Implementierung oder erhalten eine Instanz irgendwie (wahrscheinlich, das Spiel mit der XML-API).

Verwalten Sie Zeit und Daten, die in Java mit der Date und Calendar Klassen. Konvertieren Strings zu Date/Calendar Sie verwenden DateFormat oder SimpleDateFormat. Lassen Sie führen Sie Ihre Dauer rechnen, obwohl das nicht 100% schön.

Mansoor bietet eine Möglichkeit, um Dinge zu tun, die manuell mit String-manipulation und Handhabung dauern als numerische Werte - wenn Sie nur einfache Sachen, könnte es einfacher sein, das zu tun.

Wenn Sie führen mehr komplexe Dinge, vielleicht möchten Sie sich in http://joda-time.sourceforge.net/

InformationsquelleAutor der Antwort alex

Mit Java 8 und Java.Zeit.Dauer Sie können dies tun, gegeben, dass die Zeichenfolge im format HH:MM:SS oder MM:SS oder SS

Duration.ofSeconds(Arrays.stream(runtime.split(":"))
                  .mapToInt(n -> Integer.parseInt(n))
                  .reduce(0, (n, m) -> n * 60 + m));

InformationsquelleAutor der Antwort Asthor

0

Beispiel, Konvertieren Sie die Aktuellen DateTime Duration in Java 7.
```
DatatypeFactory.newInstance().newDuration(Calendar.getInstance().getTimeInMillis())
```
Ausgabe -

P48Y5M13DT19H59M24.658S

InformationsquelleAutor der Antwort Ajay

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Java: gewusst Wie: konvertieren einer Zeichenfolge (HH:MM:SS) Dauer?

tl;dr

Vermeiden `HH:MM:SS` format

java.Zeit

`LocalTime`

`Duration`

Bearbeitung der input-string

ISO 8601

Sammeln `Duration` Objekte

Über java.Zeit

tl;dr

Vermeiden HH:MM:SS format