Java Code Examples for java.util.Calendar#getFirstDayOfWeek()

public static ArrayList<Calendar> getCurrentMonthCalendar(Calendar c, int offset) {
    ArrayList<Calendar> calendars = new ArrayList<>();
    Calendar currentMonth = (Calendar) c.clone();
    currentMonth.add(Calendar.MONTH, offset);


    Calendar cal = (Calendar) c.clone();
    cal.add(Calendar.MONTH, offset);
    cal.set(Calendar.DAY_OF_MONTH, 1);
    int firstDayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
    int off = cal.getFirstDayOfWeek() - firstDayOfWeek;
    if (off > 0) {
        off -= 7;
    }
    cal.add(Calendar.DATE, off);

    while ((cal.get(MONTH) < currentMonth.get(Calendar.MONTH) + 1 || cal.get(YEAR) < currentMonth.get(Calendar.YEAR)) //
            && cal.get(YEAR) <= currentMonth.get(Calendar.YEAR)) {
        for (int i = 0; i < 7; i++) {
            calendars.add((Calendar) cal.clone());
            cal.add(Calendar.DATE, 1);
            Log.i("aaa", cal.get(Calendar.MONTH) + "--" + cal.get(Calendar.DAY_OF_MONTH));
        }
    }
    return calendars;
}
 

@Override
public StatisticResult generateStatisticResult(final Locale locale, final ICourse course, final long courseRepositoryEntryKey) {
    final DBQuery dbQuery = DBFactory.getInstance().createQuery(
            "select businessPath,day,value from org.olat.data.course.statistic.dayofweek.DayOfWeekStat sv " + "where sv.resId=:resId");
    dbQuery.setLong("resId", courseRepositoryEntryKey);

    final StatisticResult result = new StatisticResult(course, dbQuery.list());

    // now sort by user's preferred firstDayOfWeek
    final Calendar c = Calendar.getInstance(locale);
    final int firstDayOfWeek = c.getFirstDayOfWeek();

    final List<String> columnHeaders = new ArrayList<String>(7);
    for (int i = firstDayOfWeek; i < firstDayOfWeek + 7; i++) {
        int mod = i % 7;
        if (mod == 0) {
            // jdk calendar calculations don't start at 0 - they start at 1
            mod = 7;
        }
        columnHeaders.add(String.valueOf(mod));
    }

    result.setColumnHeaders(columnHeaders);
    return result;
}
 

@Override
public StatisticResult generateStatisticResult(final Locale locale, final ICourse course, final long courseRepositoryEntryKey) {
    final DBQuery dbQuery = DBFactory.getInstance().createQuery(
            "select businessPath,day,value from org.olat.data.course.statistic.dayofweek.DayOfWeekStat sv " + "where sv.resId=:resId");
    dbQuery.setLong("resId", courseRepositoryEntryKey);

    final StatisticResult result = new StatisticResult(course, dbQuery.list());

    // now sort by user's preferred firstDayOfWeek
    final Calendar c = Calendar.getInstance(locale);
    final int firstDayOfWeek = c.getFirstDayOfWeek();

    final List<String> columnHeaders = new ArrayList<String>(7);
    for (int i = firstDayOfWeek; i < firstDayOfWeek + 7; i++) {
        int mod = i % 7;
        if (mod == 0) {
            // jdk calendar calculations don't start at 0 - they start at 1
            mod = 7;
        }
        columnHeaders.add(String.valueOf(mod));
    }

    result.setColumnHeaders(columnHeaders);
    return result;
}
 

public static void main(String[] args) {
    Calendar huCalendar = Calendar.getInstance(new Locale("hu","HU"));
    int hufirstDayOfWeek = huCalendar.getFirstDayOfWeek();
    if (hufirstDayOfWeek != Calendar.MONDAY) {
        throw new RuntimeException();
    }

    Calendar ukCalendar = Calendar.getInstance(new Locale("uk","UA"));
    int ukfirstDayOfWeek = ukCalendar.getFirstDayOfWeek();
    if (ukfirstDayOfWeek != Calendar.MONDAY) {
        throw new RuntimeException();
    }

}
 

public static void main(String[] args) {
    Calendar huCalendar = Calendar.getInstance(new Locale("hu","HU"));
    int hufirstDayOfWeek = huCalendar.getFirstDayOfWeek();
    if (hufirstDayOfWeek != Calendar.MONDAY) {
        throw new RuntimeException();
    }

    Calendar ukCalendar = Calendar.getInstance(new Locale("uk","UA"));
    int ukfirstDayOfWeek = ukCalendar.getFirstDayOfWeek();
    if (ukfirstDayOfWeek != Calendar.MONDAY) {
        throw new RuntimeException();
    }

}
 

private void drawTitleDays(GC gc) {
	Calendar temp = Calendar.getInstance(mSettings.getLocale());
	// fetch the first day of the week, and draw starting on that day
	int fdow = temp.getFirstDayOfWeek();

	Rectangle bounds = super.getBounds();
	int xStart = mSettings.getDatesLeftMargin() + 5;
	int yStart = bounds.y + mSettings.getHeaderTopMargin() + mSettings.getHeaderHeight() + 1;

	int spacer = 0;
	int letterHeight = 0;

	for (int i = 0; i < 7; i++) {
		Point strWidth = gc.stringExtent(mDayTitles[fdow]);

		int x = xStart + mSettings.getOneDateBoxSize() + spacer - strWidth.x;
		// don't add the string width, as our string width later when
		// drawing days will differ
		mDayXs[i] = xStart + mSettings.getOneDateBoxSize() + spacer;

		gc.drawString(mDayTitles[fdow], x, yStart, true);

		letterHeight = strWidth.y;
		spacer += mSettings.getOneDateBoxSize() + mSettings.getBoxSpacer();

		fdow++;
		if (fdow > 7) {
			fdow = 1;
		}
	}

	int lineStart = yStart + 1 + letterHeight;
	gc.setForeground(mColorManager.getLineColor());
	gc.drawLine(mSettings.getDatesLeftMargin() + 1, lineStart, bounds.width - mSettings.getDatesRightMargin() - 3, lineStart);

	mDatesTopY = lineStart + 3;
}
 

Timeslotter() {
    Calendar now = Calendar.getInstance();
    int month = now.get(Calendar.MONTH);
    int day = now.get(Calendar.DAY_OF_MONTH);
    int offsetWeekStart = (now.get(Calendar.DAY_OF_WEEK) - now.getFirstDayOfWeek() + 7) % 7;
    timeslots.add(new Timeslot(context.getResources().getString(R.string.listview_updated_today), month, day));
    timeslots.add(new Timeslot(context.getResources().getString(R.string.listview_updated_yesterday), month, day - 1));
    timeslots.add(new Timeslot(context.getResources().getString(R.string.listview_updated_this_week), month, day - offsetWeekStart));
    timeslots.add(new Timeslot(context.getResources().getString(R.string.listview_updated_last_week), month, day - offsetWeekStart - 7));
    timeslots.add(new Timeslot(context.getResources().getString(R.string.listview_updated_this_month), month, 1));
    timeslots.add(new Timeslot(context.getResources().getString(R.string.listview_updated_last_month), month - 1, 1));
    lastYear = Calendar.getInstance();
    lastYear.set(now.get(Calendar.YEAR) - 1, 0, 1, 0, 0, 0);
}
 

public static int getLastDayOfWeek(Calendar cal) {
    int dow = cal.getFirstDayOfWeek() - 1;

    if (dow == 0) {
        dow = Calendar.SATURDAY;
    }

    return dow;
}
 

/**
 * @bug 4143951
 * Russian first day of week should be Monday. Confirmed.
 */
public void Test4143951() {
    Calendar cal = Calendar.getInstance(new Locale("ru", "", ""));
    if (cal.getFirstDayOfWeek() != Calendar.MONDAY) {
        errln("Fail: First day of week in Russia should be Monday");
    }
}
 

private int getFocusedIndex() {
	Calendar bc = getCalendar(baseDate);
	Calendar fc = getCalendar(focusDate);
	bc.set(Calendar.DAY_OF_MONTH, 1);
	int skipBefore = bc.get(Calendar.DAY_OF_WEEK) - bc.getFirstDayOfWeek();
	if (skipBefore < 0)
		skipBefore = 7 + skipBefore;
	int selDay = fc.get(Calendar.DAY_OF_MONTH);
	int maxDay = bc.getActualMaximum(Calendar.DAY_OF_MONTH);
	if (selDay > maxDay)
		selDay = maxDay;
	return skipBefore + selDay - 1;
}
 

/**
 * @bug 4143951
 * Russian first day of week should be Monday. Confirmed.
 */
public void Test4143951() {
    Calendar cal = Calendar.getInstance(new Locale("ru", "", ""));
    if (cal.getFirstDayOfWeek() != Calendar.MONDAY) {
        errln("Fail: First day of week in Russia should be Monday");
    }
}
 

public static void main(String[] args) {
    Calendar huCalendar = Calendar.getInstance(new Locale("hu","HU"));
    int hufirstDayOfWeek = huCalendar.getFirstDayOfWeek();
    if (hufirstDayOfWeek != Calendar.MONDAY) {
        throw new RuntimeException();
    }

    Calendar ukCalendar = Calendar.getInstance(new Locale("uk","UA"));
    int ukfirstDayOfWeek = ukCalendar.getFirstDayOfWeek();
    if (ukfirstDayOfWeek != Calendar.MONDAY) {
        throw new RuntimeException();
    }

}
 

@Override
public Date adjustRight(Date baseDate) {
  Calendar c = myCalendarFactory.newCalendar();
  do {
    baseDate = myDayFramer.adjustRight(baseDate);
    c.setTime(baseDate);
  } while (c.get(Calendar.DAY_OF_WEEK) != c.getFirstDayOfWeek());
  return c.getTime();
}
 

/**
 * @bug 4143951
 * Russian first day of week should be Monday. Confirmed.
 */
public void Test4143951() {
    Calendar cal = Calendar.getInstance(new Locale("ru", "", ""));
    if (cal.getFirstDayOfWeek() != Calendar.MONDAY) {
        errln("Fail: First day of week in Russia should be Monday");
    }
}
 

/**
 * @bug 4143951
 * Russian first day of week should be Monday. Confirmed.
 */
public void Test4143951() {
    Calendar cal = Calendar.getInstance(new Locale("ru", "", ""));
    if (cal.getFirstDayOfWeek() != Calendar.MONDAY) {
        errln("Fail: First day of week in Russia should be Monday");
    }
}
 

/**
 * 4080631: Calendar.hashCode is amazingly bad
 */
public void Test4080631() {
    Calendar cal = Calendar.getInstance();
    int h1 = cal.hashCode();
    cal.add(SECOND, +1);
    int h2 = cal.hashCode();
    Calendar cal2 = (Calendar) cal.clone();
    cal.add(MILLISECOND, +1);
    int h3 = cal.hashCode();
    logln("hash code: h1=" + h1 + ", h2=" + h2 + ", h3=" + h3);
    if (h1 == h2 || h1 == h3 || h2 == h3) {
        errln("hash code is poor: hashCode=" + h1);
    }
    h2 = cal2.hashCode();
    cal.add(MILLISECOND, -1);
    int h4 = cal.hashCode();
    logln("hash code: h2=" + h2 + ", h4=" + h4);
    if (cal.equals(cal2) && h2 != h4) {
        errln("broken hash code: h2=" + h2 + ", h4=" + h4);
    }
    int x = cal.getFirstDayOfWeek() + 3;
    if (x > SATURDAY) {
        x -= 7;
    }
    cal.setFirstDayOfWeek(x);
    int h5 = cal.hashCode();
    logln("hash code: h4=" + h4 + ", h5=" + h5);
    if (h4 == h5) {
        errln("has code is poor with first day of week param: hashCode=" + h4);
    }
}
 

Calendar establish(Calendar cal) {
    boolean weekDate = isSet(WEEK_YEAR)
                        && field[WEEK_YEAR] > field[YEAR];
    if (weekDate && !cal.isWeekDateSupported()) {
        // Use YEAR instead
        if (!isSet(YEAR)) {
            set(YEAR, field[MAX_FIELD + WEEK_YEAR]);
        }
        weekDate = false;
    }

    cal.clear();
    // Set the fields from the min stamp to the max stamp so that
    // the field resolution works in the Calendar.
    for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
        for (int index = 0; index <= maxFieldIndex; index++) {
            if (field[index] == stamp) {
                cal.set(index, field[MAX_FIELD + index]);
                break;
            }
        }
    }

    if (weekDate) {
        int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
        int dayOfWeek = isSet(DAY_OF_WEEK) ?
                            field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
        if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
            if (dayOfWeek >= 8) {
                dayOfWeek--;
                weekOfYear += dayOfWeek / 7;
                dayOfWeek = (dayOfWeek % 7) + 1;
            } else {
                while (dayOfWeek <= 0) {
                    dayOfWeek += 7;
                    weekOfYear--;
                }
            }
            dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
        }
        cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);
    }
    return cal;
}
 

Calendar establish(Calendar cal) {
    boolean weekDate = isSet(WEEK_YEAR)
                        && field[WEEK_YEAR] > field[YEAR];
    if (weekDate && !cal.isWeekDateSupported()) {
        // Use YEAR instead
        if (!isSet(YEAR)) {
            set(YEAR, field[MAX_FIELD + WEEK_YEAR]);
        }
        weekDate = false;
    }

    cal.clear();
    // Set the fields from the min stamp to the max stamp so that
    // the field resolution works in the Calendar.
    for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
        for (int index = 0; index <= maxFieldIndex; index++) {
            if (field[index] == stamp) {
                cal.set(index, field[MAX_FIELD + index]);
                break;
            }
        }
    }

    if (weekDate) {
        int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
        int dayOfWeek = isSet(DAY_OF_WEEK) ?
                            field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
        if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
            if (dayOfWeek >= 8) {
                dayOfWeek--;
                weekOfYear += dayOfWeek / 7;
                dayOfWeek = (dayOfWeek % 7) + 1;
            } else {
                while (dayOfWeek <= 0) {
                    dayOfWeek += 7;
                    weekOfYear--;
                }
            }
            dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
        }
        cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);
    }
    return cal;
}
 

Calendar establish(Calendar cal) {
    boolean weekDate = isSet(WEEK_YEAR)
                        && field[WEEK_YEAR] > field[YEAR];
    if (weekDate && !cal.isWeekDateSupported()) {
        // Use YEAR instead
        if (!isSet(YEAR)) {
            set(YEAR, field[MAX_FIELD + WEEK_YEAR]);
        }
        weekDate = false;
    }

    cal.clear();
    // Set the fields from the min stamp to the max stamp so that
    // the field resolution works in the Calendar.
    for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
        for (int index = 0; index <= maxFieldIndex; index++) {
            if (field[index] == stamp) {
                cal.set(index, field[MAX_FIELD + index]);
                break;
            }
        }
    }

    if (weekDate) {
        int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
        int dayOfWeek = isSet(DAY_OF_WEEK) ?
                            field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
        if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
            if (dayOfWeek >= 8) {
                dayOfWeek--;
                weekOfYear += dayOfWeek / 7;
                dayOfWeek = (dayOfWeek % 7) + 1;
            } else {
                while (dayOfWeek <= 0) {
                    dayOfWeek += 7;
                    weekOfYear--;
                }
            }
            dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
        }
        cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);
    }
    return cal;
}
 

/**
 * <p>
 *     Configuration method which set start of a week
 *     which will be used during DateRange.getStart and DateRange.getEnd calculations
 *     from passed locale instance
 * </p>
 * <p>
 *     NOTE: This method and {@link #set(Integer)} will overwrite each other
 *     so configuration which was set later will be used.
 * </p>
 * <p>
 *     NOTE: this method only will take effect if expression is in fact date range expression like "WEEK".
 * </p>
 * @param locale locale to calculate DateRange.getStart and DateRange.getEnd for expressions like "WEEK"
 * @return this instance of DateRangeBuilder
 */
public DateRangeBuilder set(Locale locale) {
	Calendar cal = Calendar.getInstance(locale);
	this.weekStartDay = cal.getFirstDayOfWeek();

	return this;
}