Joda Time Localtime de 24:00 fin de journée

Ceci est notre mise en œuvre du TIMEIVALL, utilisant NULL à la date de fin pour la fin de la journée. Il prend en charge les chevauchements () et contient des méthodes () et est également basée sur Joda-Time. Il prend en charge des intervalles de couvrant plusieurs jours.

/**
 * Description: Immutable time interval<br>
 * The start instant is inclusive but the end instant is exclusive.
 * The end is always greater than or equal to the start.
 * The interval is also restricted to just one chronology and time zone.
 * Start can be null (infinite).
 * End can be null and will stay null to let the interval last until end-of-day.
 * It supports intervals spanning multiple days.
 */
public class TimeInterval {

    public static final ReadableInstant INSTANT = null; // null means today
//    public static final ReadableInstant INSTANT = new Instant(0); // this means 1st jan 1970

    private final DateTime start;
    private final DateTime end;

    public TimeInterval() {
        this((LocalTime) null, null);
    }

    /**
     * @param from - null or a time  (null = left unbounded == LocalTime.MIDNIGHT)
     * @param to   - null or a time  (null = right unbounded)
     * @throws IllegalArgumentException if invalid (to is before from)
     */
    public TimeInterval(LocalTime from, LocalTime to) throws IllegalArgumentException {
        this(from == null ? null : from.toDateTime(INSTANT),
                to == null ? null : to.toDateTime(INSTANT));
    }

    /**
     * create interval spanning multiple days possibly.
     *
     * @param start - start distinct time
     * @param end   - end distinct time
     * @throws IllegalArgumentException - if start > end. start must be <= end
     */
    public TimeInterval(DateTime start, DateTime end) throws IllegalArgumentException {
        this.start = start;
        this.end = end;
        if (start != null && end != null && start.isAfter(end))
            throw new IllegalArgumentException("start must be less or equal to end");
    }

    public DateTime getStart() {
        return start;
    }

    public DateTime getEnd() {
        return end;
    }

    public boolean isEndUndefined() {
        return end == null;
    }

    public boolean isStartUndefined() {
        return start == null;
    }

    public boolean isUndefined() {
        return isEndUndefined() && isStartUndefined();
    }

    public boolean overlaps(TimeInterval other) {
        return (start == null || (other.end == null || start.isBefore(other.end))) &&
                (end == null || (other.start == null || other.start.isBefore(end)));
    }

    public boolean contains(TimeInterval other) {
        return ((start != null && other.start != null && !start.isAfter(other.start)) || (start == null)) &&
                ((end != null && other.end != null && !other.end.isAfter(end)) || (end == null));
    }

    public boolean contains(LocalTime other) {
        return contains(other == null ? null : other.toDateTime(INSTANT));
    }

    public boolean containsEnd(DateTime other) {
        if (other == null) {
            return end == null;
        } else {
            return (start == null || !other.isBefore(start)) &&
                    (end == null || !other.isAfter(end));
        }
    }

    public boolean contains(DateTime other) {
        if (other == null) {
            return start == null;
        } else {
            return (start == null || !other.isBefore(start)) &&
                    (end == null || other.isBefore(end));
        }
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("TimeInterval");
        sb.append("{start=").append(start);
        sb.append(", end=").append(end);
        sb.append('}');
        return sb.toString();
    }
}

Par souci d'exhaustivité Ce test échoue:

@Test()
public void testJoda() throws DGConstraintViolatedException {
    DateTimeFormatter simpleTimeFormatter = DateTimeFormat.forPattern("HHmm");
    LocalTime t1 = LocalTime.parse("0000", simpleTimeFormatter);
    LocalTime t2 = LocalTime.MIDNIGHT;
    Assert.assertTrue(t1.isBefore(t2));
}  

Cette question est ancienne, mais beaucoup de ces réponses se concentrent sur Joda Time, et ne répondent que partiellement le vrai problème sous-jacent:

Le modèle dans le code de l'OP ne correspond pas à la réalité, c'est la modélisation.

Malheureusement, puisque vous ne semblez se soucier de la condition limite entre les jours, votre « sinon élégant modèle » est pas un bon match pour le problème que vous modélisez. Vous avez utilisé une paire de valeurs de temps pour représenter des intervalles. Toute tentative de simplifier le modèle vers le bas à une paire de fois simplifie en dessous de la complexité du problème du monde réel . limites de jour existent bien dans la réalité et une paire de fois desserre ce type d'information. Comme toujours, plus de simplification de la complexité des résultats à la suite de restaurer ou compenser les informations manquantes. complexité réelle ne peut être poussé autour d'une partie du code à l'autre.

La complexité de la réalité ne peut être éliminé avec la magie des « cas d'utilisation non pris en charge ».

Votre modèle serait logique dans un espace de problème où l'on ne se souciait pas combien de jours pourraient exister entre les heures de début et de fin. Cet espace de problème ne correspond pas à la plupart des problèmes du monde réel. Par conséquent, il est pas surprenant que Joda Le temps ne supporte pas bien. L'utilisation de 25 valeurs pour les heures lieu (0-24) est une odeur code et habituellement des points de faiblesse dans la conception. Il n'y a que 24 heures dans la journée pour 25 valeurs ne doivent pas être nécessaires!

Notez que puisque vous n'êtes pas capturez la date de chaque fin de LocalInterval , votre classe ne tient pas non plus d'informations suffisantes pour tenir compte de l'heure d'été. [00:30:00 04:00:00 A) est généralement 3,5 heures de temps, mais pourrait aussi être 2,5 ou 4,5 heures.

Vous devriez utiliser soit une date / heure de début et la durée, ou à une date / heure de début et une date / heure de fin (y compris début, à la fin exclusive est un bon choix par défaut ). En utilisant une durée devient difficile si vous avez l'intention d'afficher l'heure de fin à cause de choses comme le temps de l'heure d'été, les années bissextiles et secondes bissextiles. D'autre part en utilisant une date de fin devient aussi difficile si vous vous attendez à afficher la durée. Le stockage à la fois bien sûr est dangereuse car elle viole le principe DRY . Si je devais écrire une telle classe je stocker une date de fin / heure et la logique pour résumer l'obtention de la durée via une méthode sur l'objet. Que les clients à sens unique de la classe de classe ne sont pas tous avec leur propre code pour calculer la durée.

Je coder un exemple, mais il y a une option encore mieux. Utilisez la norme Intervalle classe de temps Joda, qui accepte déjà un instant de début et durée ou fin instantanée. Il sera également et calculer heureusement la durée ou l'heure de fin pour vous. Malheureusement, JSR-310 ne dispose pas d'une classe d'intervalle ou similaire. (Bien que l'on peut utiliser ThreeTenExtra pour compenser cela)

Les gens relativement lumineux à Joda temps et Sun / Oracle ( JSR-310 ) à la fois bien réfléchi à ces problèmes. Vous pourriez être plus intelligent qu'eux. C'est possible. Cependant, même si vous êtes une ampoule lumineuse, votre 1 heure ne va probablement pas accomplir ce qu'ils ont passé des années sur. Sauf si vous êtes quelque part dans un cas limite ésotérique, il est généralement perdre de temps et d'argent à dépenser effort seconde les deviner. (Bien sûr, au moment de l'OP JSR-310 n'a pas été complète ...)

Nous espérons que les gens vont figurant ci-dessus qui trouvent cette question lors de la conception ou la résolution des problèmes similaires.