Java LocalDate.equals方法代码示例

import java.time.LocalDate; //导入方法依赖的package包/类
public TreasureHuntEventSession getTreasureHuntEventSession(Long activePersonaId) {
	TreasureHuntEntity treasureHuntEntity = treasureHuntDao.findById(activePersonaId);
	if(treasureHuntEntity == null) {
		driverPersonaBo.createThInformation(personaDao.findById(activePersonaId));
		return getTreasureHuntEventSession(activePersonaId);
	}
	
	LocalDate thDate = treasureHuntEntity.getThDate();
	LocalDate nowDate = LocalDate.now();
	if(!thDate.equals(nowDate)) {
		Integer days = (int) ChronoUnit.DAYS.between(thDate, nowDate);
		if(days >= 2 || treasureHuntEntity.getCoinsCollected() != 32767) {
			return createNewTreasureHunt(treasureHuntEntity, true);
		} else {
			return createNewTreasureHunt(treasureHuntEntity, false);
		}
	}
	
	TreasureHuntEventSession treasureHuntEventSession = new TreasureHuntEventSession();
	treasureHuntEventSession.setCoinsCollected(treasureHuntEntity.getCoinsCollected());
	treasureHuntEventSession.setIsStreakBroken(treasureHuntEntity.getIsStreakBroken());
	treasureHuntEventSession.setNumCoins(treasureHuntEntity.getNumCoins());
	treasureHuntEventSession.setSeed(treasureHuntEntity.getSeed());
	treasureHuntEventSession.setStreak(treasureHuntEntity.getStreak());
	return treasureHuntEventSession;
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
/**
 * Creates a node for a given day. Styling should be done via CSS, but
 * appropriate CSS classes are assigned to each node.
 * @param date A given date the node is associated with.
 * @return A node that displays the day of month.
 */
private Node renderDayItem(LocalDate date) {
    Label lblDate = new Label(""+date.getDayOfMonth());
    lblDate.getStyleClass().add("daychooser-day");
    if(date.getDayOfWeek() == DayOfWeek.SATURDAY
            || date.getDayOfWeek() == DayOfWeek.SUNDAY) {
        lblDate.getStyleClass().add("daychooser-weekend");
    } else {
        lblDate.getStyleClass().add("daychooser-weekday");
    }
    if(date.equals(selectedDateProperty.get())) {
        lblDate.getStyleClass().add("daychooser-selected-day");
    }
    if(date.equals(LocalDate.now())) {
        lblDate.getStyleClass().add("daychooser-current-day");
    }

    return lblDate;
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
private void updateStyleClasses() {
    LocalDate date = getDate();
    if (date.equals(getToday())) {
        if (!getStyleClass().contains(DAY_VIEW_TODAY)) {
            getStyleClass().add(DAY_VIEW_TODAY);
        }
    } else {
        getStyleClass().remove(DAY_VIEW_TODAY);
    }

    if (getWeekendDays().contains(date.getDayOfWeek())) {
        if (!getStyleClass().contains(DAY_VIEW_WEEKEND_DAY)) {
            getStyleClass().add(DAY_VIEW_WEEKEND_DAY);
        }
    } else {
        getStyleClass().remove(DAY_VIEW_WEEKEND_DAY);
    }
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
@Override
protected boolean validate() {
    LocalDate start = date.getValue();
    LocalDate end = endDate.getValue();

    if (name.getText().isEmpty()) {
        MessageHelper.showErrorAlertMessage("The Name is missing.");
        name.requestFocus();
        return false;
    } else if (start == null) {
        MessageHelper.showErrorAlertMessage("Startdate has to be set.");
        date.requestFocus();
        return false;
    } else if (end == null) {
        MessageHelper.showErrorAlertMessage("Enddate has to be set.");
        endDate.requestFocus();
        return false;
    } else if (start.isAfter(end) || start.equals(end)) {
        MessageHelper.showErrorAlertMessage("Enddate has to be after the startdate.");
        return false;
    } else if (musicalWorks == null || musicalWorks.isEmpty()) {
        MessageHelper.showErrorAlertMessage("A musical work has to be selected.");
        return false;
    }
    return true;
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
/**
 * Creates a nicely formatted text that contains the start and end time of
 * the given entry. The text can also be something like "full day" if the entry
 * is a full-day entry.
 *
 * @param entry the entry for which the text will be created
 * @return a text showing the start and end times of the entry
 */
protected String getTimeText(Entry<?> entry) {
    if (entry.isFullDay()) {
        return Messages.getString("AgendaEntryCell.ALL_DAY");//$NON-NLS-1$
    }

    LocalDate startDate = entry.getStartDate();
    LocalDate endDate = entry.getEndDate();

    String text;

    if (startDate.equals(endDate)) {
        text = MessageFormat.format(Messages.getString("AgendaEntryCell.ENTRY_TIME_RANGE"), //$NON-NLS-1$
                timeFormatter.format(entry.getStartTime()), timeFormatter.format(entry.getEndTime()));
    } else {
        text = MessageFormat.format(Messages.getString("AgendaEntryCell.ENTRY_TIME_RANGE_WITH_DATE"), //$NON-NLS-1$
                shortDateFormatter.format(entry.getStartDate()), timeFormatter.format(entry.getStartTime()), shortDateFormatter.format(entry.getEndDate()),
                timeFormatter.format(entry.getEndTime()));
    }

    return text;
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
@Test
public void now_ZoneId() {
    ZoneId zone = ZoneId.of("UTC+01:02:03");
    LocalDate expected = LocalDate.now(Clock.system(zone));
    LocalDate test = LocalDate.now(zone);
    for (int i = 0; i < 100; i++) {
        if (expected.equals(test)) {
            return;
        }
        expected = LocalDate.now(Clock.system(zone));
        test = LocalDate.now(zone);
    }
    assertEquals(test, expected);
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
public Node createSingleDayHeader(LocalDate date) {
    final Label lblWeekday = new Label(date.getDayOfWeek().getDisplayName(TextStyle.FULL, Locale.getDefault()));
    lblWeekday.getStyleClass().add("header-weekday");
    final Label lblDate = new Label(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT).format(date));
    lblDate.getStyleClass().add("header-date");
    VBox container = new VBox(lblDate, lblWeekday);
    container.getStyleClass().add("header-container");
    if(date.equals(LocalDate.now())) {
        container.getStyleClass().add("header-container-today");
    }
    container.setAlignment(Pos.TOP_CENTER);
    return container;
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
/**
 * Verifie qu'une date est inclue dans un intervalle
 * 
 * @param dateToCompare
 * @return true si la date est incluse dans un interval
 */
public static Boolean isDateIncludeInInterval(LocalDate dateToCompare, LocalDate dateDebut, LocalDate dateFin) {
	if (dateToCompare == null) {
		/* Si la date est null, c'est ok! */
		return true;
	} else if ((dateToCompare.equals(dateDebut) || dateToCompare.isAfter(dateDebut))
			&& (dateToCompare.equals(dateFin) || dateToCompare.isBefore(dateFin))) {
		return true;
	}
	return false;
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
public SingleDateRangeSelector(DateSelectionModel model) {
    super(model);

    List<LocalDate> selection = new ArrayList<>();
    selection.addAll(model.selectedDates);

    if (!selection.isEmpty()) {
        Collections.sort(selection);

        boolean valid = true;
        for (int i = 0; i < selection.size() - 1; i++) {
            if (i == selection.size() - 1) {
                break;
            }

            LocalDate pivot = selection.get(i);
            LocalDate next = selection.get(i + 1);

            if (!next.equals(pivot.plusDays(1))) {
                valid = false;
                break;
            }
        }

        if (!valid) {
            clear();
        } else {
            rangeStart = selection.get(0);
            rangeEnd = selection.get(selection.size() - 1);
            model.lastSelected = rangeEnd;
        }
    }
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
@Test
public void now() {
    LocalDate expected = LocalDate.now(Clock.systemDefaultZone());
    LocalDate test = LocalDate.now();
    for (int i = 0; i < 100; i++) {
        if (expected.equals(test)) {
            return;
        }
        expected = LocalDate.now(Clock.systemDefaultZone());
        test = LocalDate.now();
    }
    assertEquals(test, expected);
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
/**
 * Constructs a new time interval with the given start and end dates / times
 * and time zone.
 *
 * @param startDate the start date (e.g. Oct. 3rd, 2015)
 * @param startTime the start time (e.g. 10:45am)
 * @param endDate   the end date
 * @param endTime   the end time
 * @param zoneId    the time zone
 */
public Interval(LocalDate startDate, LocalTime startTime, LocalDate endDate, LocalTime endTime, ZoneId zoneId) {
    this.startDate = requireNonNull(startDate);
    this.startTime = requireNonNull(startTime);
    this.endDate = requireNonNull(endDate);
    this.endTime = requireNonNull(endTime);
    this.zoneId = requireNonNull(zoneId);

    if (startDate.isAfter(endDate)) {
        throw new IllegalArgumentException("the start date can never be after the end date");
    }

    /*
     * Now we know that the start date is either earlier than the end date or
     * on the same date.
     */

    if (startDate.equals(endDate)) {

        /*
         * If the start date and the end date are on the same date then we have to make sure that the
         * start time is not after the end time.
         */
        if (getStartTime().isAfter(getEndTime())) {
            throw new IllegalArgumentException("the start time can not be after the end time if both are on the same date");
        }
    }
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
private void updateRegion(Region region, int day) {
    final AllDayView view = getSkinnable();

    LocalDate startDate = view.getDate();

    if (view.isAdjustToFirstDayOfWeek()) {
        startDate = Util.adjustToFirstDayOfWeek(view.getDate(), view.getFirstDayOfWeek());
    }

    LocalDate date = getDate(startDate, day);

    if (view.isShowToday() && date.equals(view.getToday())) {
        if (!region.getStyleClass().contains(ALL_DAY_BACKGROUND_REGION_TODAY)) {
            region.getStyleClass().add(ALL_DAY_BACKGROUND_REGION_TODAY);
        }
    } else {
        region.getStyleClass().remove(ALL_DAY_BACKGROUND_REGION_TODAY);
    }

    if (view.getWeekendDays().contains(date.getDayOfWeek())) {
        if (!region.getStyleClass().contains(ALL_DAY_BACKGROUND_REGION_WEEKEND)) {
            region.getStyleClass().add(ALL_DAY_BACKGROUND_REGION_WEEKEND);
        }
    } else {
        region.getStyleClass().remove(ALL_DAY_BACKGROUND_REGION_WEEKEND);
    }
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
public static boolean intersect(LocalDate aStart, LocalDate aEnd,
                                LocalDate bStart, LocalDate bEnd) {

    // Same start time or same end time?
    if (aStart.equals(bStart) || aEnd.equals(bEnd)) {
        return true;
    }

    return aStart.isBefore(bEnd) && aEnd.isAfter(bStart);

}
 

import java.time.LocalDate; //导入方法依赖的package包/类
private JapaneseDate with(LocalDate newDate) {
    return (newDate.equals(isoDate) ? this : new JapaneseDate(newDate));
}
 

import java.time.LocalDate; //导入方法依赖的package包/类
public final void requestStartDate(LocalDate date) {
    if (date == null) {
        return;
    }

    switch (getViewType()) {
        case DAY_VIEW:
            if (date.equals(getToday())) {
                startField.setValue(TimeRangeField.TimeRangeFieldValue.TODAY);
                endField.setValue(TimeRangeField.TimeRangeFieldValue.TODAY);
            } else if (date.equals(getTomorrow())) {
                startField.setValue(TimeRangeField.TimeRangeFieldValue.TOMORROW);
                endField.setValue(TimeRangeField.TimeRangeFieldValue.TOMORROW);
            } else {
                startField.setValue(TimeRangeField.TimeRangeFieldValue.ON_DATE);
                startField.setOnDate(date);
                endField.setValue(TimeRangeField.TimeRangeFieldValue.ON_DATE);
                endField.setOnDate(date);
            }
            break;

        case WEEK_VIEW:
            if (date.equals(getThisWeekDate())) {
                startField.setValue(TimeRangeField.TimeRangeFieldValue.THIS_WEEK);
                endField.setValue(TimeRangeField.TimeRangeFieldValue.THIS_WEEK);
            } else if (date.equals(getNextWeekDate())) {
                startField.setValue(TimeRangeField.TimeRangeFieldValue.NEXT_WEEK);
                endField.setValue(TimeRangeField.TimeRangeFieldValue.NEXT_WEEK);
            } else {
                startField.setValue(TimeRangeField.TimeRangeFieldValue.ON_DATE);
                startField.setOnDate(date);
                endField.setValue(TimeRangeField.TimeRangeFieldValue.ON_DATE);
                endField.setOnDate(date);
            }
            break;

        case MONTH_VIEW:
            if (date.equals(getThisMonthDate())) {
                startField.setValue(TimeRangeField.TimeRangeFieldValue.THIS_MONTH);
                endField.setValue(TimeRangeField.TimeRangeFieldValue.THIS_MONTH);
            } else if (date.equals(getNextMonthDate())) {
                startField.setValue(TimeRangeField.TimeRangeFieldValue.NEXT_MONTH);
                endField.setValue(TimeRangeField.TimeRangeFieldValue.NEXT_MONTH);
            } else {
                TimeRangeField.TimeRangeFieldValue month = TimeRangeField.TimeRangeFieldValue.getFromMonth(date.getMonth());
                int year = date.getYear();
                endField.setValue(month);
                endField.setMonthYear(year);
                startField.setValue(month);
                startField.setMonthYear(year);
            }
            break;

        default:
            throw new UnsupportedOperationException("Not supported yet!: " + getViewType());
    }
}