【问题标题】：How to determine day of week by passing specific date?如何通过特定日期确定星期几？
【发布时间】：2011-03-11 07:44:24
【问题描述】：

例如，我有日期：“23/2/2010”（2010 年 2 月 23 日）。我想将它传递给一个返回星期几的函数。我该怎么做？

在本例中，函数应返回String“Tue”。

此外，如果只需要日期序号，如何检索？

【问题讨论】：

如果您正在阅读本文，请使用 java.time 的当前方法向前/向下跳至答案！基于日历的答案很好，但现在已经过时了。

标签： java date

【解决方案1】：

是的。根据您的具体情况：

你可以使用java.util.Calendar:

Calendar c = Calendar.getInstance();
c.setTime(yourDate);
int dayOfWeek = c.get(Calendar.DAY_OF_WEEK);

如果您需要输出为 Tue 而不是 3（星期几的索引从 1 开始表示星期日，请参阅 Calendar.SUNDAY），而不是通过日历，只需重新格式化字符串：@ 987654330@（EE 意思是“星期几，短版”）
如果你的输入是字符串，而不是Date，你应该使用SimpleDateFormat来解析它：new SimpleDateFormat("dd/M/yyyy").parse(dateString)
您可以使用 joda-time 的 DateTime 并致电 dateTime.dayOfWeek() 和/或 DateTimeFormat。
编辑：从 Java 8 开始，您现在可以使用 java.time 包而不是 joda-time

【讨论】：

星期几从 1 开始，即星期日，所以我认为 Tue 应该是 3。
在其他需要注意的事情中，如果您使用整数在日历对象中设置日期（而不是通过解析字符串），那么请注意月份编号是从零开始的，所以一月是0 和 12 月是 11。
@RenniePet：很好。您也可以在Calendar 类中使用常量，例如Calendar.SUNDAY 或Calendar.JANUARY。
这个答案在编写时是一个很好的答案。今天，您将想要使用现在已过时的类 Calendar、Date 和 DateTimeFormat（以及 Joda 时间）并使用 Java 8 java.time 类，例如 YearMonth 或 LocalDate。在this answer 中查看更多信息。
仅供参考，麻烦的旧日期时间类，如 java.util.Date、java.util.Calendar 和 java.text.SimpleDateFormat 现在是 legacy，被 Java 8 和 Java 中内置的 java.time 类所取代9. 见Tutorial by Oracle。

【解决方案2】：

  String inputDate = "01/08/2012";
  SimpleDateFormat format1 = new SimpleDateFormat("dd/MM/yyyy");
  Date dt1 = format1.parse(input_date);
  DateFormat format2 = new SimpleDateFormat("EEEE"); 
  String finalDay = format2.format(dt1);

使用此代码从输入日期中查找日期名称。简单且经过良好测试。

【讨论】：

如果使用此方法，请注意日期和月份的顺序。
我认为你需要把它放在一个 try catch 块中
仅供参考，麻烦的旧日期时间类，如 java.util.Date、java.util.Calendar 和 java.text.SimpleDateFormat 现在是 legacy，被 Java 8 和 Java 中内置的 java.time 类所取代9. 见Tutorial by Oracle。
Android 仅在 API 26 之后实现 LocalDate。

【解决方案3】：

只需使用SimpleDateFormat。

SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy", java.util.Locale.ENGLISH);
Date myDate = sdf.parse("28/12/2013");
sdf.applyPattern("EEE, d MMM yyyy");
String sMyDate = sdf.format(myDate);

结果是：2013 年 12 月 28 日，星期六

默认构造函数采用“默认”Locale，因此当您需要特定模式时请小心使用它。

public SimpleDateFormat(String pattern) {
    this(pattern, Locale.getDefault(Locale.Category.FORMAT));
}

【讨论】：

【解决方案4】：

tl;博士

使用java.time…

LocalDate.parse(                               // Generate `LocalDate` object from String input.
             "23/2/2010" ,
             DateTimeFormatter.ofPattern( "d/M/uuuu" ) 
         )                                    
         .getDayOfWeek()                       // Get `DayOfWeek` enum object.
         .getDisplayName(                      // Localize. Generate a String to represent this day-of-week.
             TextStyle.SHORT_STANDALONE ,      // How long or abbreviated. Some languages have an alternate spelling for "standalone" use (not so in English).
             Locale.US                         // Or Locale.CANADA_FRENCH and such. Specify a `Locale` to determine (1) human language for translation, and (2) cultural norms for abbreviation, punctuation, etc.
         )

周二

看到这个code run live at IdeOne.com（但只有Locale.US在那里工作）。

java.time

查看我上面的示例代码，并查看correct Answer for java.time by Przemek。

序数

如果只需要日期序号，如何检索？

对于序数，请考虑传递 DayOfWeek 枚举对象，而不是 DayOfWeek.TUESDAY。请记住，DayOfWeek 是一个智能对象，而不仅仅是一个字符串或整数。 Using those enum objects 使您的代码更加自我记录，确保有效值，并提供 type-safety。

但如果你坚持，ask DayOfWeek for a number。根据ISO 8601 标准，周一至周日可获得 1-7。

int ordinal = myLocalDate.getDayOfWeek().getValue() ;

乔达时间

更新： Joda-Time 项目现在处于维护模式。团队建议迁移到 java.time 类。 java.time 框架内置于 Java 8（以及 back-ported to Java 6 & 7 和 further adapted to Android）中。

这里是使用Joda-Time 库版本2.4 的示例代码，如accepted answer by Bozho 中所述。 Joda-Time 远优于 Java 捆绑的 java.util.Date/.Calendar 类。

`LocalDate`

Joda-Time 提供 LocalDate 类来表示仅日期，没有任何时间或时区。正是这个问题所要求的。与 Java 捆绑在一起的旧 java.util.Date/.Calendar 类缺少这个概念。

解析

将字符串解析为日期值。

String input = "23/2/2010";
DateTimeFormatter formatter = DateTimeFormat.forPattern( "d/M/yyyy" );
LocalDate localDate = formatter.parseLocalDate( input );

提取

从日期值中提取星期几和名称。

int dayOfWeek = localDate.getDayOfWeek(); // Follows ISO 8601 standard, where Monday = 1, Sunday = 7.
Locale locale = Locale.US;  // Locale specifies the human language to use in determining day-of-week name (Tuesday in English versus Mardi in French).
DateTimeFormatter formatterOutput = DateTimeFormat.forPattern( "E" ).withLocale( locale );
String output = formatterOutput.print( localDate ); // 'E' is code for abbreviation of day-of-week name. See Joda-Time doc.
String outputQuébécois = formatterOutput.withLocale( Locale.CANADA_FRENCH ).print( localDate );

转储

转储到控制台。

System.out.println( "input: " + input );
System.out.println( "localDate: " + localDate ); // Defaults to ISO 8601 formatted strings.
System.out.println( "dayOfWeek: " + dayOfWeek );
System.out.println( "output: " + output );
System.out.println( "outputQuébécois: " + outputQuébécois );

运行

运行时。

input: 23/2/2010
localDate: 2010-02-23
dayOfWeek: 2
output: Tue
outputQuébécois: mar.

关于java.time

java.time 框架内置于 Java 8 及更高版本中。这些类取代了麻烦的旧 legacy 日期时间类，例如 java.util.Date、Calendar 和 SimpleDateFormat。

Joda-Time 项目现在位于maintenance mode，建议迁移到java.time 类。

要了解更多信息，请参阅Oracle Tutorial。并在 Stack Overflow 上搜索许多示例和解释。规格为JSR 310。

从哪里获得 java.time 类？

Java SE 8、Java SE 9 及更高版本
- 内置。
- 标准 Java API 的一部分，带有捆绑实现。
- Java 9 添加了一些小功能和修复。
Java SE 6 和 Java SE 7
- 大部分 java.time 功能都在ThreeTen-Backport 中向后移植到 Java 6 和 7。
Android
- ThreeTenABP 项目专门为 Android 适配 ThreeTen-Backport（如上所述）。
- 见How to use ThreeTenABP…。

ThreeTen-Extra 项目通过附加类扩展了 java.time。该项目是未来可能添加到 java.time 的试验场。您可以在这里找到一些有用的类，例如Interval、YearWeek、YearQuarter 和more。

【讨论】：

【解决方案5】：

java.time

使用 Java 8 及更高版本中内置的java.time 框架。

DayOfWeekenum 可以生成自动本地化为Locale 的人类语言和文化规范的当天名称字符串。指定 TextStyle 表示您需要长格式或缩写名称。

import java.time.LocalDate
import java.time.format.DateTimeFormatter
import java.time.format.TextStyle
import java.util.Locale
import java.time.DayOfWeek;

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("d/M/yyyy");
LocalDate date = LocalDate.parse("23/2/2010", formatter); // LocalDate = 2010-02-23
DayOfWeek dow = date.getDayOfWeek();  // Extracts a `DayOfWeek` enum object.
String output = dow.getDisplayName(TextStyle.SHORT, Locale.US); // String = Tue

【讨论】：

这个只能在奥利奥及以上的api中使用。
@codepeaker 大多数 java.time 功能在ThreeTen-Backport 项目中向后移植到 Java 6 和 Java 7。进一步适用于ThreeTenABP 中的早期 Android (How to use ThreeTenABP…。

【解决方案6】：

对于 Java 8 或更高版本，Localdate 更可取

import java.time.LocalDate;

public static String findDay(int month, int day, int year) {

    LocalDate localDate = LocalDate.of(year, month, day);

    java.time.DayOfWeek dayOfWeek = localDate.getDayOfWeek();
    System.out.println(dayOfWeek);

    return dayOfWeek.toString();
}

注意：如果输入是字符串/用户定义的，那么你应该把它解析成int。

【讨论】：

【解决方案7】：

你可以试试下面的代码：

import java.time.*;

public class Test{
   public static void main(String[] args) {
      DayOfWeek dow = LocalDate.of(2010,Month.FEBRUARY,23).getDayOfWeek();
      String s = String.valueOf(dow);
      System.out.println(String.format("%.3s",s));
   }
}

【讨论】：

这个答案如何比使用LocalDate 的两个或三个先前的答案增加价值？你在发帖前读过这些吗？
这是一个很好的答案，它与以前的所有答案都不同。它使用 LocalDate.of() API 来构造日期，并且它比大多数其他答案短得多（有时简短的答案比长的好）...

【解决方案8】：

public class TryDateFormats {
    public static void main(String[] args) throws ParseException {
        String month = "08";
        String day = "05";
        String year = "2015";
        String inputDateStr = String.format("%s/%s/%s", day, month, year);
        Date inputDate = new SimpleDateFormat("dd/MM/yyyy").parse(inputDateStr);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(inputDate);
        String dayOfWeek = calendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, Locale.US).toUpperCase();
        System.out.println(dayOfWeek);
    }
}

【讨论】：

不错的解决方案，我正在寻找这种类型的解决方案，我需要的行解决了我的问题。 String dayOfWeek = calendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, Locale.US).toUpperCase();

【解决方案9】：

...
import java.time.LocalDate;
...
//String month = in.next();
int mm = in.nextInt();
//String day = in.next();
int dd = in.nextInt();
//String year = in.next();
int yy = in.nextInt();
in.close();
LocalDate dt = LocalDate.of(yy, mm, dd);
System.out.print(dt.getDayOfWeek());

【讨论】：

【解决方案10】：

另一种“有趣”的方式是使用Doomsday algorithm。这是一种更长的方法，但如果您不需要创建具有给定日期的 Calendar 对象，它也会更快。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 *
 * @author alain.janinmanificat
 */
public class Doomsday {

    public static HashMap<Integer, ArrayList<Integer>> anchorDaysMap = new HashMap<>();
    public static HashMap<Integer, Integer> doomsdayDate = new HashMap<>();
    public static String weekdays[] = new DateFormatSymbols(Locale.FRENCH).getWeekdays();

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws ParseException, ParseException {

        // Map is fed manually but we can use this to calculate it : http://en.wikipedia.org/wiki/Doomsday_rule#Finding_a_century.27s_anchor_day
        anchorDaysMap.put(Integer.valueOf(0), new ArrayList<Integer>() {
            {
                add(Integer.valueOf(1700));
                add(Integer.valueOf(2100));
                add(Integer.valueOf(2500));
            }
        });

        anchorDaysMap.put(Integer.valueOf(2), new ArrayList<Integer>() {
            {
                add(Integer.valueOf(1600));
                add(Integer.valueOf(2000));
                add(Integer.valueOf(2400));
            }
        });

        anchorDaysMap.put(Integer.valueOf(3), new ArrayList<Integer>() {
            {
                add(Integer.valueOf(1500));
                add(Integer.valueOf(1900));
                add(Integer.valueOf(2300));
            }
        });

        anchorDaysMap.put(Integer.valueOf(5), new ArrayList<Integer>() {
            {
                add(Integer.valueOf(1800));
                add(Integer.valueOf(2200));
                add(Integer.valueOf(2600));
            }
        });

        //Some reference date that always land on Doomsday
        doomsdayDate.put(Integer.valueOf(1), Integer.valueOf(3));
        doomsdayDate.put(Integer.valueOf(2), Integer.valueOf(14));
        doomsdayDate.put(Integer.valueOf(3), Integer.valueOf(14));
        doomsdayDate.put(Integer.valueOf(4), Integer.valueOf(4));
        doomsdayDate.put(Integer.valueOf(5), Integer.valueOf(9));
        doomsdayDate.put(Integer.valueOf(6), Integer.valueOf(6));
        doomsdayDate.put(Integer.valueOf(7), Integer.valueOf(4));
        doomsdayDate.put(Integer.valueOf(8), Integer.valueOf(8));
        doomsdayDate.put(Integer.valueOf(9), Integer.valueOf(5));
        doomsdayDate.put(Integer.valueOf(10), Integer.valueOf(10));
        doomsdayDate.put(Integer.valueOf(11), Integer.valueOf(7));
        doomsdayDate.put(Integer.valueOf(12), Integer.valueOf(12));

        long time = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {

            //Get a random date
            int year = 1583 + new Random().nextInt(500);
            int month = 1 + new Random().nextInt(12);
            int day = 1 + new Random().nextInt(7);

            //Get anchor day and DoomsDay for current date
            int twoDigitsYear = (year % 100);
            int century = year - twoDigitsYear;
            int adForCentury = getADCentury(century);
            int dd = ((int) twoDigitsYear / 12) + twoDigitsYear % 12 + (int) ((twoDigitsYear % 12) / 4);

            //Get the gap between current date and a reference DoomsDay date
            int referenceDay = doomsdayDate.get(month);
            int gap = (day - referenceDay) % 7;

            int result = (gap + adForCentury + dd) % 7;

            if(result<0){
                result*=-1;
            }
            String dayDate= weekdays[(result + 1) % 8];
            //System.out.println("day:" + dayDate);
        }
        System.out.println("time (ms) : " + (System.currentTimeMillis() - time)); //time (ms) : 80

         time = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            Calendar c = Calendar.getInstance();
            //I should have used random date here too, but it's already slower this way
            c.setTime(new SimpleDateFormat("dd/MM/yyyy").parse("12/04/1861"));
//            System.out.println(new SimpleDateFormat("EE").format(c.getTime()));
            int result2 = c.get(Calendar.DAY_OF_WEEK);
//            System.out.println("day idx :"+ result2);
        }
        System.out.println("time (ms) : " + (System.currentTimeMillis() - time)); //time (ms) : 884
    }

    public static int getADCentury(int century) {
        for (Map.Entry<Integer, ArrayList<Integer>> entry : anchorDaysMap.entrySet()) {
            if (entry.getValue().contains(Integer.valueOf(century))) {
                return entry.getKey();
            }
        }
        return 0;
    }
}

【讨论】：

【解决方案11】：

可以使用以下代码 sn-p 进行输入，例如 (day = "08", month = "05", year = "2015"，输出将是 "WEDNESDAY")

Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.DAY_OF_MONTH, Integer.parseInt(day));
calendar.set(Calendar.MONTH, (Integer.parseInt(month)-1));
calendar.set(Calendar.YEAR, Integer.parseInt(year));
String dayOfWeek = calendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, Locale.US).toUpperCase();

【讨论】：

这个答案是不明智的，使用现在遗留的麻烦的旧日期时间，被现代 java.time 类取代。
这是在 Hackerrank 上提出的问题。

【解决方案12】：

一行答案：

return LocalDate.parse("06/02/2018",DateTimeFormatter.ofPattern("dd/MM/yyyy")).getDayOfWeek().name();

用法示例：

public static String getDayOfWeek(String date){
  return LocalDate.parse(date, DateTimeFormatter.ofPattern("dd/MM/yyyy")).getDayOfWeek().name();
}

public static void callerMethod(){
   System.out.println(getDayOfWeek("06/02/2018")); //TUESDAY
}

【讨论】：

成功了，我只需要将 .name() 替换为 getDisplayName(TextStyle.FULL,Locale.US)

【解决方案13】：

private String getDay(Date date){

    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEEE");
    //System.out.println("DAY "+simpleDateFormat.format(date).toUpperCase());                       
    return simpleDateFormat.format(date).toUpperCase();
}

private String getDay(String dateStr){
    //dateStr must be in DD-MM-YYYY Formate
    Date date = null;
    String day=null;

    try {
        date = new SimpleDateFormat("DD-MM-YYYY").parse(dateStr);

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEEE");
        //System.out.println("DAY "+simpleDateFormat.format(date).toUpperCase());
        day = simpleDateFormat.format(date).toUpperCase();


    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }


    return day;
}

【讨论】：

【解决方案14】：

程序通过使用java.util.scanner 包为用户输入日期月份和年份来查找星期几：

import java.util.Scanner;

public class Calender {
    public static String getDay(String day, String month, String year) {

        int ym, yp, d, ay, a = 0;
        int by = 20;
        int[] y = new int[]{6, 4, 2, 0};
        int[] m = new int []{0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5};

        String[] wd = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

        int gd = Integer.parseInt(day);
        int gm = Integer.parseInt(month);
        int gy = Integer.parseInt(year);

        ym = gy % 100;
        yp = ym / 4;
        ay = gy / 100;

        while (ay != by) {
            by = by + 1;
            a = a + 1;

            if(a == 4) {
                a = 0;
            }
        }

        if ((ym % 4 == 0) && (gm == 2)) {
            d = (gd + m[gm - 1] + ym + yp + y[a] - 1) % 7;
        } else
            d = (gd + m[gm - 1] + ym + yp + y[a]) % 7;

        return wd[d];
    }

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        String day = in.next();
        String month = in.next();
        String year = in.next();

        System.out.println(getDay(day, month, year));
    }
}

【讨论】：

仅供参考，麻烦的旧日期时间类，如 java.util.Date、java.util.Calendar 和 java.text.SimpleDateFormat 现在是 legacy，被 Java 8 和 Java 中内置的 java.time 类所取代9. 见Tutorial by Oracle。
@Dave 这真的很好读吗？ if ((ym%4==0) && (gm==2)){ d=(gd+m[gm-1]+ym+yp+y[a]-1)%7;

【解决方案15】：

Calendar 类具有内置的 displayName 功能：

Calendar.getInstance().getDisplayName(Calendar.DAY_OF_WEEK, Calendar.SHORT, Locale.getDefault()); // Thu   

Calendar.SHORT -> Thu
Calendar.LONG_FORMAT -> Thursday

自 Java 1.6 起可用。另见Oracle documentation

【讨论】：

迄今为止最好的答案！谢谢！
简单明了

【解决方案16】：

hackerrankJava Date and Time 有一个挑战

就个人而言，我更喜欢 LocalDate 类。

导入 java.time.LocalDate
使用“of”方法检索 localDate，该方法接受 3 个参数 “int”格式。
最后，使用“getDayOfWeek”方法获取当天的名称。

有一个关于这个挑战的视频。

Java Date and Time Hackerrank solution

我希望它会有所帮助:)

【讨论】：

如果有其他人来这里获取 HackerRank Java 日期和时间并希望使用 Calendar 类，请注意日历中的 set 方法从 0 开始需要几个月。即 0 for January .谢谢！

【解决方案17】：

添加另一种完全符合 OP 要求的方式，而不使用最新的内置方法：

public static String getDay(String inputDate) {
    String dayOfWeek = null;
    String[] days = new String[]{"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};

    try {
        SimpleDateFormat format1 = new SimpleDateFormat("dd/MM/yyyy");
        Date dt1 = format1.parse(inputDate);
        dayOfWeek = days[dt1.getDay() - 1];
    } catch(Exception e) {
        System.out.println(e);
    }

    return dayOfWeek;
}

【讨论】：

虽然此代码可能会回答问题，但提供有关此代码为何和/或如何回答问题的额外上下文可提高其长期价值。
这不仅仅是一种不鼓励的方式。您的代码无法编译。您不应该使用早已过时且设计不佳的类SimpleDateFormat 和Date。特别是你不应该使用已弃用的getDay 方法，它不可靠。而且你不应该使用if-else 在 7 个值中进行选择，这是我们有 switch 的，或者你可以使用一个数组。总而言之，你的代码比它需要的更长更复杂。
并使用内置的月份缩写而不是提供您自己的缩写。更简单，更不容易出错。
这里使用的麻烦类在几年前被 java.time 类所取代。建议在 2018 年使用它们是糟糕的建议。

【解决方案18】：

import java.text.SimpleDateFormat;
import java.util.Scanner;

class DayFromDate {

    public static void main(String args[]) {

        System.out.println("Enter the date(dd/mm/yyyy):");
        Scanner scan = new Scanner(System.in);
        String Date = scan.nextLine();

        try {
            boolean dateValid = dateValidate(Date);

            if(dateValid == true) {
                SimpleDateFormat df = new SimpleDateFormat( "dd/MM/yy" );  
                java.util.Date date = df.parse( Date );   
                df.applyPattern( "EEE" );  
                String day= df.format( date ); 

                if(day.compareTo("Sat") == 0 || day.compareTo("Sun") == 0) {
                    System.out.println(day + ": Weekend");
                } else {
                    System.out.println(day + ": Weekday");
                }
            } else {
                System.out.println("Invalid Date!!!");
            }
        } catch(Exception e) {
            System.out.println("Invalid Date Formats!!!");
        }
     }

    static public boolean dateValidate(String d) {

        String dateArray[] = d.split("/");
        int day = Integer.parseInt(dateArray[0]);
        int month = Integer.parseInt(dateArray[1]);
        int year = Integer.parseInt(dateArray[2]);
        System.out.print(day + "\n" + month + "\n" + year + "\n");
        boolean leapYear = false;

        if((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0)) {
            leapYear = true;
        }

        if(year > 2099 || year < 1900)
            return false;

        if(month < 13) {
            if(month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
                if(day > 31)
                    return false;
            } else if(month == 4 || month == 6 || month == 9 || month == 11) {
                if(day > 30)
                    return false;
            } else if(leapYear == true && month == 2) {
                if(day > 29)
                    return false;
            } else if(leapYear == false && month == 2) {
                if(day > 28)
                    return false;
            }

            return true;    
        } else return false;
    }
}

【讨论】：

【解决方案19】：

下面的方法在 Kotlin 中检索 7 天并在 List Array 中返回天的短名称，您可以将其重新格式化为 Java 格式，只是展示日历如何返回短名称的想法

private fun getDayDisplayName():List<String>{
        val calendar = Calendar.getInstance()
        val dates= mutableListOf<String>()
        dates.clear()
        val s=   calendar.getDisplayName(DAY_OF_WEEK, SHORT, Locale.US)
        dates.add(s)
        for(i in 0..5){
            calendar.roll( Calendar.DATE, -1)
            dates.add(calendar.getDisplayName(DAY_OF_WEEK, SHORT, Locale.US))
        }
        return dates.toList()
    }

输出结果如

I/System.out: Wed
    Tue
    Mon
    Sun
I/System.out: Sat
    Fri
    Thu

【讨论】：

如果 OP 询问 Java，那么最好用 Java 回应。
我们没有理由要在 2019 年使用 Calendar 类。它的设计很糟糕而且已经过时了。相反，我推荐来自java.time, the modern Java date and time API 的LocalDate 和DayOfWeek。

【解决方案20】：

Calendar cal = Calendar.getInstance(desired date);
cal.setTimeInMillis(System.currentTimeMillis());
int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);

通过提供当前时间戳来获取日期值。

【讨论】：

【解决方案21】：

LocalDate date=LocalDate.now();

System.out.println(date.getDayOfWeek());//prints THURSDAY
System.out.println(date.getDayOfWeek().getDisplayName(TextStyle.SHORT, Locale.US) );  //prints Thu   
java.time.DayOfWeek is a enum which returns the singleton instance for the day-of-week of the weekday of the date.

【讨论】：

@Ayarnush 您的回答如何增加上个月发布的the Answer by Przemek 之外的任何价值？

【解决方案22】：

//to get day of any date

import java.util.Scanner; 
import java.util.Calendar; 
import java.util.Date;

public class Show {

    public static String getDay(String day,String month, String year){


            String input_date = month+"/"+day+"/"+year;

            Date now = new Date(input_date);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(now);
            int final_day = (calendar.get(Calendar.DAY_OF_WEEK));

            String finalDay[]={"SUNDAY","MONDAY","TUESDAY","WEDNESDAY","THURSDAY","FRIDAY","SATURDAY"};

            System.out.println(finalDay[final_day-1]);

    }

    public static void main(String[] args) { 
            Scanner in = new Scanner(System.in); 
            String month = in.next(); 
        String day = in.next();
            String year = in.next();

            getDay(day, month, year);
    }

}

【讨论】：

添加一些对答案的解释以补充代码会很有用。

【解决方案23】：

这可以正常工作...

java.time.LocalDate; //package related to time and date

它提供了内置方法 getDayOfWeek() 来获取特定星期的日期：

int t;
Scanner s = new Scanner(System.in);
t = s.nextInt();
s.nextLine();
 while(t-->0) { 
    int d, m, y;
    String ss = s.nextLine();
    String []sss = ss.split(" ");
    d=Integer.parseInt(sss[0]);
    m = Integer.parseInt(sss[1]);
    y = Integer.parseInt(sss[2]);

    LocalDate l = LocalDate.of(y, m, d); //method to get the localdate instance
    System.out.println(l.getDayOfWeek()); //this returns the enum DayOfWeek

要将枚举l.getDayOfWeek() 的值分配给字符串，您可能可以使用名为name() 的枚举方法，它返回枚举对象的值。

【讨论】：

关于 Stack Overflow 的答案如果包含一些解释和代码 sn-p 会更好。
@David，我一直在寻找我的编辑和你的不同之处，但我找不到。很高兴获得如何编辑的信息。
@OrdinaryDraft 您在答案中添加了listHolidays.add(LocalDate.of(year, 1, 1));。如果你想改进答案，你应该添加你自己的。希望有帮助
是的，我后来检查了我的编辑以与您的版本进行比较。看来我错误地复制了那行。

【解决方案24】：

您可以使用以下方法通过传递特定日期来获取星期几，

这里是Calendar类的set方法，Tricky部分是月份参数的索引会从0开始。

public static String getDay(int day, int month, int year) {

        Calendar cal = Calendar.getInstance();

        if(month==1){
            cal.set(year,0,day);
        }else{
            cal.set(year,month-1,day);
        }

        int dow = cal.get(Calendar.DAY_OF_WEEK);

        switch (dow) {
        case 1:
            return "SUNDAY";
        case 2:
            return "MONDAY";
        case 3:
            return "TUESDAY";
        case 4:
            return "WEDNESDAY";
        case 5:
            return "THURSDAY";
        case 6:
            return "FRIDAY";
        case 7:
            return "SATURDAY";
        default:
            System.out.println("GO To Hell....");
        }

        return null;
    }

【讨论】：

这个答案是不明智的，使用可怕的旧日期时间类，这些类现在是遗留的，被 java.time 类取代。此外，在将日期时间类笨拙地应用于仅日期问题之后，此代码忽略了时区的关键问题。相反，请参阅correct Answer for java.time by Przemek。

【解决方案25】：

获取今天的日期，然后从中查找星期几。

    LocalDate d = java.time.LocalDate.now();
    System.out.println(java.time.LocalDate.now()); 
    
    Calendar c = Calendar.getInstance();
    int dayOfWeek = c.get(Calendar.DAY_OF_WEEK);
    System.out.println(dayOfWeek);

【讨论】：

它并没有真正回答 上下文中的问题，例如我有日期：“23/2/2010”（2010 年 2 月 23 日）。不要使用Calendar。它的设计很差，而且已经过时了。由于您可以使用现代 Java 日期和时间 API java.time 中的LocalDate，因此只需使用其getDayOfWeek 方法。

【解决方案26】：

下面是两行 sn-p 使用 Java 1.8 Time API 来满足您的需求。

LocalDate localDate = LocalDate.of(Integer.valueOf(year),Integer.valueOf(month),Integer.valueOf(day));
String dayOfWeek = String.valueOf(localDate.getDayOfWeek());

【讨论】：

这里显示的方法已经在很久以前发布的至少 4 个好的答案中得到了介绍。我认为这个副本没有增加任何价值。