在Java中获取日期范围内的所有星期五

我最近遇到一个任务，我必须把所有的星期五都安排在一个日期范围内。我写了一小段代码，并惊讶地看到一些奇怪的行为

下面是我的代码：

public class Friday {
    public static void main(String[]args){
        String start = "01/01/2009";
        String end = "12/09/2013";
        String[] startTokens = start.split("/");
        String[] endTokens = end.split("/");
        Calendar  startCal = new GregorianCalendar(Integer.parseInt(startTokens[2]),Integer.parseInt(startTokens[1])-1,Integer.parseInt(startTokens[0]));
        Calendar endCal = new GregorianCalendar(Integer.parseInt(endTokens[2]),Integer.parseInt(endTokens[1])-1, Integer.parseInt(endTokens[0]));

        int startYear = Integer.parseInt(startTokens[2]);
        int endYear = Integer.parseInt(endTokens[2]); 


        int startWeek = startCal.get(Calendar.WEEK_OF_YEAR);
        int endWeek = endCal.get(Calendar.WEEK_OF_YEAR);

        Calendar cal = new GregorianCalendar();
        cal.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
    //  cal.setMinimalDaysInFirstWeek(7);
        ArrayList<String> main = new ArrayList<String>();
        while(startYear <= endYear ){
               cal.set(Calendar.YEAR, startYear);
               System.out.println(cal.getMinimalDaysInFirstWeek());
                if(startYear == endYear){
                    main.addAll(getFridays(startWeek, endWeek, cal));
                }
                else{
                    main.addAll(getFridays(startWeek, 52, cal));
                    startWeek = 1;
                }
                startYear =startYear +1;
        }

        for(String s: main){
            System.err.println(s);
        }
    }
    public static ArrayList<String> getFridays(int startWeek, int endWeek, Calendar cal){
        ArrayList<String> fridays = new ArrayList<String>();
        while(startWeek <= endWeek){
            cal.set(Calendar.WEEK_OF_YEAR, startWeek);
            fridays.add(cal.getTime().toString());
            startWeek = startWeek+1;
        }
        return fridays;
    }
}

公共课周五{
公共静态void main（字符串[]args）{
字符串start=“01/01/2009”；
字符串end=“12/09/2013”；
字符串[]startTokens=start.split（“/”）；
字符串[]endTokens=end.split（“/”）；
日历startCal=new GregorianCalendar（Integer.parseInt（startTokens[2]），Integer.parseInt（startTokens[1]）-1，Integer.parseInt（startTokens[0]）；
日历endCal=new gregoriacalendar（Integer.parseInt（endTokens[2]），Integer.parseInt（endTokens[1]）-1，Integer.parseInt（endTokens[0]）；
int startYear=Integer.parseInt（startTokens[2]）；
int endYear=Integer.parseInt（endTokens[2]）；
int startWeek=startCal.get（日历周/年）；
int endWeek=endCal.get（日历，每年的一周）；
Calendar cal=新的Gregorianalendar（）；
cal.set（Calendar.DAY/周，Calendar.FRIDAY）；
//cal.设置第一周的最低天数（7）；
ArrayList main=新的ArrayList（）；
而（startYear首先，我不会为周而烦恼。将日历设置为区间的开始，并计算出道琼斯指数是哪一个，然后递增到下一个周五，然后简单地循环增加7天，直到区间结束

事实上，因为你总是在前进，所以应该是这样的：

int daysToAdd = FridayDOW - currentDOW;
if (daysToAdd < 0) daysToAdd += 7; 
Date startDate = currentDate.add(Calendar.DAYS, daysToAdd);

int daysToAdd=FridayDOW-currentDOW；
如果（daysToAdd<0）daysToAdd+=7；
Date startDate=currentDate.add（Calendar.DAYS，daysToAdd）；

是的，就像那样

好的，实际上，对于kicks，这里是Java8：

@Test
public void canFindAllFridaysInRange(){
    start = LocalDate.of(2013, 5, 10);
    end = LocalDate.of(2013, 8,30);

    DayOfWeek dowOfStart = start.getDayOfWeek();
    int difference = DayOfWeek.FRIDAY.getValue() - dowOfStart.getValue();
    if (difference < 0) difference += 7;

    List<LocalDate> fridaysInRange = new ArrayList<LocalDate>();

    LocalDate currentFriday = start.plusDays(difference);
    do {
        fridaysInRange.add(currentFriday);
        currentFriday = currentFriday.plusDays(7);
    } while (currentFriday.isBefore(end));

    System.out.println("Fridays in range: " + fridaysInRange);
}

@测试
public void canFindAllFridaysInRange（）{
开始=本地日期（2013年5月10日）；
结束=2013年8月30日的本地日期；
DayOfWeek-dowOfStart=start.getDayOfWeek（）；
int difference=DayOfWeek.FRIDAY.getValue（）-dowOfStart.getValue（）；
如果（差值<0）差值+=7；
List fridaysInRange=new ArrayList（）；
LocalDate currentFriday=开始.plusDays（差异）；
做{
添加（当前星期五）；
currentFriday=currentFriday.plusday（7）；
}while（currentFriday.isBefore（end））；
System.out.println（“范围内的星期五：+范围内的星期五”）；
}

我喜欢上了新的约会课程！！当然lambda会进一步浓缩这一点。
这里有一个更简单的方法，使用精彩的库：

String start=“01/01/2009”；
字符串end=“12/09/2013”；
DateTimeFormatter模式=DateTimeFormat.forPattern（“dd/MM/yyyy”）；
DateTime startDate=pattern.parseDateTime（开始）；
DateTime endDate=pattern.parseDateTime（end）；
列表星期五=新的ArrayList（）；
while（startDate.isBefore（endDate））{
if（startDate.getDayOfWeek（）==DateTimeConstants.FRIDAY）{
星期五。添加（开始日期）；
}
startDate=startDate.plusDays（1）；
}

最后，在fridays数组中有fridays。简单吗

或者，如果你想加快速度，一旦你有了一个星期五，你可以从使用天数切换到使用星期：

String start = "01/01/2009";
String end = "12/09/2013";
DateTimeFormatter pattern = DateTimeFormat.forPattern("dd/MM/yyyy");
DateTime startDate = pattern.parseDateTime(start);
DateTime endDate = pattern.parseDateTime(end);

List<DateTime> fridays = new ArrayList<>();
boolean reachedAFriday = false;
while (startDate.isBefore(endDate)){
    if ( startDate.getDayOfWeek() == DateTimeConstants.FRIDAY ){
        fridays.add(startDate);
        reachedAFriday = true;
    }
    if ( reachedAFriday ){
        startDate = startDate.plusWeeks(1);
    } else {
        startDate = startDate.plusDays(1);
    }
}

String start=“01/01/2009”；
字符串end=“12/09/2013”；
DateTimeFormatter模式=DateTimeFormat.forPattern（“dd/MM/yyyy”）；
DateTime startDate=pattern.parseDateTime（开始）；
DateTime endDate=pattern.parseDateTime（end）；
列表星期五=新的ArrayList（）；
布尔值reachedAFriday=false；
while（startDate.isBefore（endDate））{
if（startDate.getDayOfWeek（）==DateTimeConstants.FRIDAY）{
星期五。添加（开始日期）；
reachedAFriday=true；
}
如果（到达日期）{
startDate=startDate.plusWeeks（1）；
}否则{
startDate=startDate.plusDays（1）；
}
}
此代码将打印星期五之前的所有日期

public class Friday {
   public static void main(String[] args) throws ParseException {
     String start = "01/01/2013";
     String end = "12/01/2013";
     SimpleDateFormat dateFormat=new SimpleDateFormat("dd/MM/yyyy");
     Calendar scal=Calendar.getInstance();
     scal.setTime(dateFormat.parse(start));
     Calendar ecal=Calendar.getInstance();
     ecal.setTime(dateFormat.parse(end));

     ArrayList<Date> fridayDates=new ArrayList<>();

     while(!scal.equals(ecal)){
         scal.add(Calendar.DATE, 1);
         if(scal.get(Calendar.DAY_OF_WEEK)==Calendar.FRIDAY){
             fridayDates.add(scal.getTime());
         }
     }

     System.out.println(fridayDates);
 }
}

公共课周五{
公共静态void main（字符串[]args）引发异常{
字符串start=“01/01/2013”；
字符串end=“12/01/2013”；
SimpleDataFormat dateFormat=新的SimpleDataFormat（“dd/MM/yyyy”）；
Calendar scal=Calendar.getInstance（）；
setTime（dateFormat.parse（start））；
Calendar ecal=Calendar.getInstance（）；
ecal.setTime（dateFormat.parse（end））；
ArrayList fridayDates=新建ArrayList（）；
而（！scal.equals（ecal））{
添加比例（日历日期，1）；
if（scal.get（Calendar.DAY\u OF_WEEK）=Calendar.FRIDAY）{
添加（scal.getTime（））；
}
}
系统输出打印LN（星期五日期）；
}
}
带有：

List fridays=Dates.from（2015,12,1）.to（2016,1,1）.byWeek（）.on（DayOfWeek.FRIDAY）.build（）；
日期（星期五：星期五）{
系统输出打印（星期五）；
}
tl；dr
java.time
其他答案已经过时。旧的java.util.Date/.Calendar类在java 8和更高版本中已经被新的框架所取代。Joda时间库非常优秀，继续得到维护，甚至受到java.Time的启发。但是Joda时间团队建议在方便的情况下尽快转到java.Time

LocalDate
time类包含一个只包含日期的值，不包含一天中的时间或时区。请参阅

首先解析输入字符串以获取
LocalDate
对象

String inputStart = "01/01/2009";
String inputStop = "12/09/2013";  // 258 Fridays.
// String inputStop = "01/01/2009";  // 0 Friday.
// String inputStop = "01/02/2009";  // 1 Friday.

DateTimeFormatter formatter = DateTimeFormatter.ofPattern ( "MM/dd/yyyy" );

LocalDate start = LocalDate.parse ( inputStart , formatter );
LocalDate stop = LocalDate.parse ( inputStop , formatter );

在您自己的代码中，如果输入错误，请尝试捕获异常。并验证
stop
确实与
start
相同或更晚

临时调整器
java.time框架包括该接口，用于转换日期-时间值。例如，对于任何特定日期。在开始日期，从类调用并传递
临时调整器的预定义实现（注意复数
s
）。请参阅

从：2009-01-01到：2013-12-09是258个星期五：[2009-01-02，2009-01-09，2009-01-16，2009-01-23，2009-01-30，2009-02-06，2009-02-13，2009-02-20，2009-02-27，2009-03-06，2009-03-13，2009-03-20，2009-03-27，2009-04-03，2009-04-03，2009-04-10，2009-04-17，2009-04-24，2009-05-01，2009-01
List<Date> fridays = Dates.from(2015, 12, 1).to(2016, 1, 1).byWeek().on(DayOfWeek.FRIDAY).build();
for (Date friday: fridays) {
    System.out.println(friday);
}

someLocalDate.with(                                      // Date-only value without time-of-day and without time zone, represented by `LocalDate` class.
    TemporalAdjusters.nextOrSame ( DayOfWeek.FRIDAY ) )  // Moving from one `LocalDate` object to another, to find the next Friday unless the starting date is already a Friday.
)                                                        // Return a `LocalDate` object.

String inputStart = "01/01/2009";
String inputStop = "12/09/2013";  // 258 Fridays.
// String inputStop = "01/01/2009";  // 0 Friday.
// String inputStop = "01/02/2009";  // 1 Friday.

DateTimeFormatter formatter = DateTimeFormatter.ofPattern ( "MM/dd/yyyy" );

LocalDate start = LocalDate.parse ( inputStart , formatter );
LocalDate stop = LocalDate.parse ( inputStop , formatter );

List<LocalDate> fridays = new ArrayList<> ();  // Collect each Friday found.
LocalDate nextOrSameFriday = start.with ( TemporalAdjusters.nextOrSame ( DayOfWeek.FRIDAY ) );
// Loop while we have a friday in hand (non-null) AND that friday is not after our stop date (isBefore or isEqual the stop date).
while ( ( null != nextOrSameFriday ) & (  ! nextOrSameFriday.isAfter ( stop ) ) ) {
    fridays.add ( nextOrSameFriday );  //  Remember this friday.
    nextOrSameFriday = nextOrSameFriday.plusWeeks ( 1 );  // Move to the next Friday, setting up for next iteration of this loop.
}

System.out.println ( "From: " + start + " to: " + stop + " are " + fridays.size () + " Fridays: " + fridays );

String start = "01/01/2009";
String end = "12/09/2013";

ChronoFormatter<PlainDate> f =
    ChronoFormatter.ofDatePattern("dd/MM/yyyy", PatternType.CLDR, Locale.ROOT);

PlainDate startDate =
    f.parse(start).with(PlainDate.DAY_OF_WEEK.setToNextOrSame(Weekday.FRIDAY));
PlainDate endDate = f.parse(end);

Stream<PlainDate> fridays =
    DateInterval.stream(Duration.of(1, CalendarUnit.WEEKS), startDate, endDate);

fridays.forEachOrdered(System.out::println);

// output
2009-01-02 
2009-01-09 
... 
2013-08-30 
2013-09-06

// other example: list of fridays in ISO-8601-format
List<String> result =
  DateInterval.between(startDate, endDate)
    .stream(Duration.of(1, CalendarUnit.WEEKS))
    .map((date) -> date.toString()) // or maybe use dd/MM/yyyy => f.format(date)
    .collect(Collectors.toList());

public static List<Date> getWeekNumberList(Date currentMonthDate) {
    List<Date> dates = new ArrayList<>(10);
    Calendar startCalendar = Calendar.getInstance();
    startCalendar.setTime(currentMonthDate);
    startCalendar.set(Calendar.DAY_OF_MONTH,
            startCalendar.getActualMinimum(Calendar.DAY_OF_MONTH));
    Calendar endCalendar = Calendar.getInstance();
    endCalendar.setTime(currentMonthDate);
    endCalendar.set(Calendar.DAY_OF_MONTH,
            endCalendar.getActualMaximum(Calendar.DAY_OF_MONTH));

    Date enddate = endCalendar.getTime();
    while (startCalendar.getTime().before(enddate)) {
        if (startCalendar.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) {
            Date result = startCalendar.getTime();
            dates.add(result);
            startCalendar.add(Calendar.WEEK_OF_MONTH, 1);
        } else {

            startCalendar.add(Calendar.DAY_OF_MONTH, 1);
        }
    }
    return dates;
}