Java 如何以YYYYMMDD格式提取星期一或星期四的数据？

我正在尝试以这种格式获取星期一或星期四的日期

YYYYMMDD

对于周一，它应该给我这个-

20130224

（作为一个例子）

对于星期四，它应该给我这个-

20130227

（作为示例）

• 现在，如果我在

  星期四

  之后或

  星期四

  运行我的程序，它应该以

  YYYYMMDD

  格式打印

  星期四

  的日期，可以是

  20130227

  （本周星期四）
• 如果我在

  Monday

  之后或

  Monday

  上运行我的程序，那么它应该以与YYYYMMDD相同的格式打印星期一的日期，格式可以是

  20130224

  （例如，昨天的星期一日期）

在Java中如何实现这一点

以下是我尝试过的-

Calendar cal = Calendar.getInstance();
SimpleDateFormat formatter = new SimpleDateFormat("EEE");
String text = formatter.format(cal.getTime());
System.out.println(text);

// but how do I check if it is Tuesday but less than Thursday
if(text.equalsIgnoreCase("Tue")) {
    // get previous Monday date in YYYYMMDD
} 

// and how do I check if it is thursday or greater than Thursday?
else if(text.equalsIgnoreCase("Thur")) {
 // get previous Thursday date in YYYYMMDD
}

更新：-

在特定的一周中，如果我在周四或周四之后运行我的程序，那么它应该以YYYYMMDD格式返回我在同一周的周四的日期，但是如果我在周一或周一之后运行我的程序，那么它应该以YYYYMMDD格式返回我在同一周的周一的日期

例如，在本周，如果我在周四或周四之后运行我的程序，那么它应该返回周四的日期。但如果我在同一周的星期一、星期二或星期三运行我的程序，那么它应该返回我星期一的日期

代码：-

下面是我的代码-

public static void main(String[] args) {

try {
    Calendar cal = Calendar.getInstance();
    SimpleDateFormat toDateFormat = new SimpleDateFormat("yyyyMMdd");

    int dow = cal.get(Calendar.DAY_OF_WEEK);
    switch (dow) {
    case Calendar.THURSDAY:
    case Calendar.FRIDAY:
    case Calendar.SATURDAY:
    case Calendar.SUNDAY:
    while (cal.get(Calendar.DAY_OF_WEEK) != Calendar.THURSDAY) {
        cal.add(Calendar.DATE, -1);
    }
    break;
    case Calendar.MONDAY:
    case Calendar.TUESDAY:
    case Calendar.WEDNESDAY:
    while (cal.get(Calendar.DAY_OF_WEEK) != Calendar.MONDAY) {
        cal.add(Calendar.DATE, -1);
    }
    break;
    }

    System.out.println(date);
    System.out.println(cal.getTime());
    System.out.println(toDateFormat.format(cal.getTime()));

} catch (ParseException exp) {
    exp.printStackTrace();
}
}

---

什么？转到内容相同的新问题

  String[] weeks = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
  DateFormat df = new SimpleDateFormat("yyyyMMdd");
  Calendar c = Calendar.getInstance();
  c.setTime(new Date()); // Now use today date.
  int dayOfWeek = c.get(Calendar.DAY_OF_WEEK); // Sun=1, Mon=2, ... Sat=7
  System.out.println("Today " + df.format(c.getTime()) + " is " + weeks[dayOfWeek-1]);
  c.add(Calendar.DATE, 7); // Adding 7 days
  System.out.println("Next " + weeks[dayOfWeek-1] + " is " + df.format(c.getTime()));
  // Should display:
  // Today 20140225 is Tuesday
  // Next Tuesday is 20140304

---

首先将文本值解析为

Date

值

String dateText = "20130224";
SimpleDateFormat toDateFormat = new SimpleDateFormat("yyyyMMdd");
Date date = toDateFormat.parse(dateText);

这为您提供了一个起点。接下来，您需要使用

日历

，该日历允许您前后移动，自动为您在内部滚动日期（因此，如果您滚动周、月或年边界）

例如

try {
    String dateText = "20130227";
    SimpleDateFormat toDateFormat = new SimpleDateFormat("yyyyMMdd");
    Date date = toDateFormat.parse(dateText);

    Calendar cal = Calendar.getInstance();
    cal.setTime(date);

    int dow = cal.get(Calendar.DAY_OF_WEEK);
    switch (dow) {
        case Calendar.THURSDAY:
        case Calendar.FRIDAY:
        case Calendar.SATURDAY:
        case Calendar.SUNDAY:
            while (cal.get(Calendar.DAY_OF_WEEK) != Calendar.THURSDAY) {
                cal.add(Calendar.DATE, -1);
            }
            break;
        case Calendar.MONDAY:
        case Calendar.TUESDAY:
        case Calendar.WEDNESDAY:
            while (cal.get(Calendar.DAY_OF_WEEK) != Calendar.MONDAY) {
                cal.add(Calendar.DATE, -1);
            }
            break;
    }

    System.out.println(date);
    System.out.println(cal.getTime());

} catch (ParseException exp) {
    exp.printStackTrace();
}

所以，根据这个例子，它将输出

Wed Feb 27 00:00:00 EST 2013
Mon Feb 25 00:00:00 EST 2013

对于

20130224

（周日），它将给出

Sun Feb 24 00:00:00 EST 2013
Thu Feb 21 00:00:00 EST 2013

---

我还应该补充一点，使用JodaTime可能有一种更简单的方法，但这正是我能够快速消除的。是的，我知道

case

语句有点冗长，但是

SUNDAY

等于

0

，这有点烦人；）

我会使用日历上课日来获取一周中的哪一天。Calendar.DAY\u OF_WEEK函数返回1-7，表示星期日-星期六。通过这种方式，您可以进行数字比较，而不必在工作日对字符串进行比较（如果您的应用程序需要支持多种语言，这将是一个混乱）

见：

---

如果我明白你的意思，那么这应该行得通

private static final java.text.SimpleDateFormat sdf = 
  new java.text.SimpleDateFormat("yyyyMMdd");
public static String calculateCorrectDate(
    java.util.Date d) {
  java.util.Calendar cal = java.util.Calendar
      .getInstance();
  cal.setTime(d);
  int dayOfWeek = cal
      .get(java.util.Calendar.DAY_OF_WEEK);
  if (dayOfWeek >= java.util.Calendar.MONDAY
      && dayOfWeek < java.util.Calendar.THURSDAY) {
    cal.set(java.util.Calendar.DAY_OF_WEEK,
        java.util.Calendar.MONDAY);
  } else {
    cal.set(java.util.Calendar.DAY_OF_WEEK,
        java.util.Calendar.THURSDAY);
  }
  return sdf.format(cal.getTime());
}
public static void main(String[] args) {
  java.util.List<java.util.Date> dates = new java.util.ArrayList<java.util.Date>();
  java.util.Calendar cal = java.util.Calendar
      .getInstance();
  String today = sdf.format(cal.getTime());

  cal.add(java.util.Calendar.DAY_OF_WEEK, -10);
  for (int i = 0; i < 20; i++) {
    dates.add(cal.getTime());
    cal.add(java.util.Calendar.DAY_OF_WEEK, 1);
  }
  for (java.util.Date d : dates) {
    if (sdf.format(d).equals(today)) {
      System.out.println("TODAY!");
    }
    System.out.println(calculateCorrectDate(d));
  }
}

或有少量进口

然后你可以用

public static String calculateCorrectDate(Date d) {
  Calendar cal = Calendar.getInstance();
  cal.setTime(d);
  // By using import static this remains concise and correct.
  int dayOfWeek = cal.get(DAY_OF_WEEK);
  if (dayOfWeek >= MONDAY && dayOfWeek < THURSDAY) {
    cal.set(DAY_OF_WEEK, MONDAY);
  } else {
    cal.set(DAY_OF_WEEK, THURSDAY);
  }
  return sdf.format(cal.getTime());
}

公共静态字符串calculateCorrectDate（日期d）{
Calendar cal=Calendar.getInstance（）；
校准设定时间（d）；
//通过使用import static，这将保持简洁和正确。
int dayOfWeek=cal.get（每周的第几天）；
如果（星期一>=星期一和星期二<星期四）{
校准设置（每周的第二天，星期一）；
}否则{
校准设置（每周的第二天，星期四）；
}
返回sdf.format（cal.getTime（））；
}

Joda时间

---

更新：项目现在开始，团队建议迁移到类。这个答案作为历史保留下来。请看

---

是的，这就是解决办法

或者Java8中的新java.time包。灵感来源于乔达时代，但重新设计。由JSR310定义

下周一/周四 搜索StackOverflow以获取一周的第一天或最后一天。这会告诉你下周一或周四怎么去。我不会在这里讨论你问题的那一部分

每周测试日 如果您碰巧在英语不是默认语言环境的地方运行，那么使用英语单词进行星期几的测试很容易中断。相反，按数字获取一周中的某一天。Joda Time使用作为其默认值，因此周一=1，周日=7。常数是提供的，所以你不需要记住数字

没有时间的日期 如果您真的不关心时间，只关心日期，那么我们可以使用

LocalDate

而不是

DateTime

示例代码 使用Joda Time 2.3，一些代码可以帮助您开始

String input = "20130224";
DateTimeFormatter formatterInput = DateTimeFormat.forPattern( "yyyyMMdd" );
LocalDate localDate = formatterInput.parseLocalDate( input );
int dayOfWeek = localDate.getDayOfWeek();
boolean isMonday = ( localDate.getDayOfWeek() == DateTimeConstants.MONDAY );
boolean isThursday = ( localDate.getDayOfWeek() == DateTimeConstants.THURSDAY );

转储到控制台

System.out.println( "localDate: " + localDate );
System.out.println( "dayOfWeek: " + dayOfWeek );
System.out.println( "isMonday: " + isMonday );
System.out.println( "isThursday: " + isThursday );

当运行时

localDate:2013-02-24
星期五：7
伊斯蒙代：错
isThursday:错误

tl；博士 如果：

…然后，应用：

 TemporalAdjusters.previousOrSame( DayOfWeek.MONDAY )    // Adjust into an earlier `LocalDate` that is a Monday, unless today already is Monday.

…其他情况适用于：

 TemporalAdjusters.previousOrSame( DayOfWeek.THURSDAY )  // Otherwise move to a Thursday.

java.time 现代方法使用java.time类。解决这个问题容易多了

LocalDate

该类表示一个仅限日期的值，不包含一天中的时间和时区

时区对于确定日期至关重要。在任何一个特定的时刻，世界各地的日期都因地区而异。例如，中午夜后几分钟是新的一天，而中仍然是“昨天”

如果未指定时区，JVM将隐式应用其当前默认时区。该默认值可能随时更改，因此您的结果可能会有所不同。最好将所需/预期时区明确指定为参数

以

大陆/地区

的格式指定，例如，或

太平洋/奥克兰

。切勿使用3-4个字母的缩写，如

EST

或

IST

，因为它们不是真正的时区，也不是标准化的，甚至不是唯一的（！）

如果要使用JVM的当前默认时区，请请求它并将其作为参数传递。如果省略，则隐式应用JVM的当前默认值。最好是直言不讳

ZoneId z = ZoneId.systemDefault() ;  // Get JVM’s current default time zone.

或者指定一个日期。你可以用一个数字来设置月份，1-12月的数字为1-12

LocalDate ld = LocalDate.of( 1986 , 2 , 23 ) ;  // Years use sane direct numbering (1986 means year 1986). Months use sane numbering, 1-12 for January-December.

或者，最好使用预定义的枚举对象，一年中每个月一个。提示：在整个代码库中使用这些

Month

对象，而不仅仅是一个整数，这样可以使代码更加自我记录，确保有效值，并提供更高的可用性

DayOfWeek

enum

DayOfWeek

enum

 TemporalAdjusters.previousOrSame( DayOfWeek.THURSDAY )  // Otherwise move to a Thursday.

ZoneId z = ZoneId.of( "America/Montreal" ) ;  
LocalDate today = LocalDate.now( z ) ;

ZoneId z = ZoneId.systemDefault() ;  // Get JVM’s current default time zone.

LocalDate ld = LocalDate.of( 1986 , 2 , 23 ) ;  // Years use sane direct numbering (1986 means year 1986). Months use sane numbering, 1-12 for January-December.

LocalDate ld = LocalDate.of( 1986 , Month.FEBRUARY , 23 ) ;

Set < DayOfWeek > mondayDays = EnumSet.range( DayOfWeek.MONDAY , DayOfWeek.WEDNESDAY );  // Monday, Tuesday, & Wednesday.
Set < DayOfWeek > thursdayDays = EnumSet.range( DayOfWeek.THURSDAY , DayOfWeek.SUNDAY );  // Thursday, Friday, Saturday, Sunday.

LocalDate ld = LocalDate.now( ZoneId.of( "Africa/Tunis" ) ) ;  // Get today’s current date in a particular time zone.
DayOfWeek dow = ld.getDayOfWeek();
LocalDate target = LocalDate.EPOCH;  // Or null. The `LocalDate.EPOCH` is first moment of 1970 in UTC, 1970-01-01T00:00:00Z.

if ( mondayDays.contains( dow ) )
{
    target = ld.with( TemporalAdjusters.previousOrSame( DayOfWeek.MONDAY ) );
} else if ( thursdayDays.contains( dow ) )
{
    target = ld.with( TemporalAdjusters.previousOrSame( DayOfWeek.THURSDAY ) );
} else
{
    System.out.println( "ERROR - Unexpectedly reached IF-ELSE. " );
}

String output = target.format( DateTimeFormatter.BASIC_ISO_DATE ) ;  // YYYY-MM-DD