Develop Reference

UNIX Time to Date and Time Conversion Problem Java

IMPORTANT: external libraries, Date and Instant class are not allowed
You may not use any library routines for manipulation of time or
dates, such as converting UNIX time to a date string or for formatting
date strings in general. All calculations for determining year, month,
day, and time must appear in your source.
I wrote this program to convert from UNIX time (time in seconds since 12:00 AM January 1, 1970) to normal date and time. At first glance it seems to work fine, but in some tests it was off by exactly one day. The hours, minutes, months, and years are always correct, but the days are one too few.
For example, when using UNIX time 1234567890 the program produces 11:31 PM 02/13/2009, which is correct! However when inputing 1111111111 (10 1's), the program produces 1:58 AM 03/17/2005, where it should output 01:58 AM 03/18/2005. 64075132196 produces 7:49 AM 06/17/4000 (correct) but 95632040996 produces 7:49 AM 06/16/5000, where it should be the 17th day instead of the 16th.
In order to check my program, I entered a date and time into https://www.unixtimestamp.com/ and entered the resulting UNIX time into my program. (This is how I managed to get exact UNIX codes in the troubleshooting above).
I would appreciate help finding this error and additionally implementing a more efficient solution to this problem altogether.
import java.util.*;
class Main {
public static void main(String[] args) {
System.out.println("\nEnter UNIX time");
Scanner scan = new Scanner(System.in);
int[] monthDays = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int[] leapYearMonthDays = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
long unix = scan.nextLong();
int years = 0, months = 0, days = 0, hours = 0, minutes = 0;
boolean leapYear = false;
String AMPM = "AM";
while (unix >= 60) {
unix -= 60;
minutes++;
if (minutes >= 60) {
minutes -= 60;
hours++;
}
if (hours >= 24) {
hours -= 24;
days++;
}
if (leapYear) {
if (days >= leapYearMonthDays[months]) {
days -= leapYearMonthDays[months];
months++;
}
}
else {
if (days >= monthDays[months]) {
days -= monthDays[months];
months++;
}
}
if (months >= 12) {
if (isLeapYear(1970 + years)) leapYear = true; else leapYear = false;
months -= 12;
years++;
}
}
if (hours > 12) {
AMPM = "PM";
hours -= 12;
}
if (days == 0) days = 1;
String daysString = String.valueOf(days);
if (daysString.length() == 1) daysString = "0" + daysString;
String monthsString = String.valueOf(months + 1);
if (monthsString.length() == 1) monthsString = "0" + monthsString;
String minutesString = String.valueOf(minutes);
if (minutesString.length() == 1) minutesString = "0" + minutesString;
if (hours == 0) hours = 12;
System.out.println("\n" + hours + ":" + minutesString + " " + AMPM + " " + monthsString + "/" + daysString + "/" + (years + 1970));
}
public static boolean isLeapYear (int year) {
if (year % 4 == 0) {
if (year % 100 == 0) {
if (year % 400 == 0) {
return true;
}
else return false;
}
else return true;
}
return false;
}
}

You created your own code. That probably was the intent of the homework.
Now pinpoint the problem.
For that you can actually create a loop generating different Unix time values.
For each of these values calculate the date using your code, in parallel calculate the date using java.util.Date or java.util.Instant. Compare the dates and print results suitable so you can pinpoint the situations where your code produces deviations. Try to understand the deviations and improve your code.
With that you would not only exercise coding date calculations but also automated testing or test driven development.

Given
UNIX time (time in seconds since 12:00 AM January 1, 1970)
Assume if we convert 0 as integer timestmap in unix-epoch format to a java.util.Date we solved it.
Using java.util.Date (prior to Java 8)
long unixTimeInMilliseconds = 0;
Date convertedDate = new java.util.Date(unixTimeInMilliseconds);
System.out.println(convertedDate);
Prints:
Thu Jan 01 00:00:00 GMT 1970
Using java.time.Instant or suitable Java 8 class
You can also use the Java Date/Time API introduced since Java 8 in a similar manner:
long unixTimeInMilliseconds = 0; // 0 ms
Instant timestamp = Instant.ofEpochMilli(unixTimeInMilliseconds);
System.out.println(timestamp);
Prints:
1970-01-01T00:00:00Z
See also
Unix epoch time to Java Date object

I am trying to figure out the difference in days between two dates manually

I have used these two websites to measure how close my code gets.
Difference
Days
since year
zero
I use days since year zero to normalise the two entered dates, then I find the difference between those dates.
import java.util.Scanner;
public class DateDiff {
private static final int[] monthsDay = {31,28,31,30,31,30,31,31,30,31,30,31};
public static String dateChecker() {
boolean b = true;
int dateC = 0;
String date = "";
do {
Scanner scanner = new Scanner(System.in);
date = scanner.nextLine();
try {
if (date.charAt(2) == '/' && date.charAt(5) == '/') {
date = date.replace("/", "");
dateC = Integer.parseInt(date);
b = false;
} else {
System.out.println("Reenter date in the dd/mm/yyyy format");
}
} catch (Exception e) {
System.out.println("Reenter date in the dd/mm/yyyy format");
}
} while (b);
return date;
}
public static int daysForMonth(int months, int year) {
int days = 0;
for (int i = 0; i < months; i++)
if (i == 1)
days += ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)
? monthsDay[i] + 1
: monthsDay[i];
else
days += monthsDay[i];
return days;
}
public static int daysForYears(int year) {
int days = 0;
for (int i = 0; i < year; i++)
if ((i % 4 == 0 && (i % 100 != 0)) || (i % 400 == 0))
days += 366;
else
days += 365;
return days;
}
public static int daysSinceYearZero(String date) {
int day = Integer.parseInt(date.substring(0,2));
int month = Integer.parseInt(date.substring(2,4));
int year = Integer.parseInt(date.substring(4,8));
int daysMonth = daysForMonth(month-1, year);
int daysYear = daysForYears(year);
return day + daysMonth + daysYear;
}
public static void main(String[] args) {
System.out.println("Enter first date");
String date1 = dateChecker();
System.out.println("Enter second date");
String date2 = dateChecker();
int firstDate = daysSinceYearZero(date1);
int secondDate = daysSinceYearZero(date2);
System.out.println("First Date days since Year Zero: " + firstDate);
System.out.println("Second Date days since Year Zero: " + secondDate);
System.out.println("Difference: " + Math.abs(firstDate-secondDate));
}
}
My code gets close, but always seems to miss by a few days and I can't figure out why. I have confirmed the days and daysMonth are correct, but do not understand where I am going wrong in calculating the number of days since year zero using years (the daysYear variable)
Edit: No libraries are allowed to be used. Scanner is fine however as that is just for user input.

Since you didn't explain any requirements or limitations you can do it like this.
LocalDate earliest = LocalDate.parse("2012-05-17");
LocalDate latest = LocalDate.parse("2022-06-22");
System.out.println(latest.toEpochDay()-earliest.toEpochDay());
prints
3688 (exclusive of the latest date day)
However, here is one way to home grow it. I used lambdas to facilitate the process. And no loops were required in the calculation. So this runs in constant time.
First I created an IntTrinaryOperator interface.
interface IntTrinaryOperator {
public int applyAsInt(int a, int b, int c);
}
Then an array of month days was created (leap years are handled later) the first cell is ignored but required for the following operation.
int daysPerMonth[] =
{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int monthSums[] = daysPerMonth.clone();
// this creates a running sum
// looks like [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]
// the last cell is not used.
Arrays.parallelPrefix(monthSums, (a, b) -> a + b);
A leap year function
Function<Integer, Boolean> isLeapYear =
a -> a % 400 == 0 || (a % 100 != 0 && a % 4 == 0);
And the defined Trinary to be used for the actual calculation.
(y-1)*365-(y-1)/100+(y-1)/4 +(y-1)/400 - computes total leap years starting from previous year.
first total days using 365 days per year
then subtract century years
then add years divisible by 400 back in.
monthSums[m-1]+d - adds days for this year
((m > 2) && isLeapYear.apply(y) ? 1 : 0) - 1 - adds one more day if after February but subtracts 1 to exclude current day (as in most ranges in Java)
IntTrinaryOperator daysToEpoch = (y, m, d) -> (y - 1) * 365
- (y - 1) / 100 + (y - 1) / 4 + (y - 1) / 400 +
+ monthSums[m - 1] + d
+ ((m > 2) && isLeapYear.apply(y) ? 1 : 0) - 1;
Testing
generate some dates. Dates are not chronological so the days could be negative, hence the Math.abs()
Random r = new Random();
for (int i = 0; i < 10; i++) {
int eYear = r.nextInt(2022) + 1;
int eMonth = r.nextInt(12) + 1;
int eDay = r.nextInt(daysPerMonth[eMonth])
+ (eMonth == 2 && isLeapYear.apply(eYear) ? 1 :
0);
int sYear = r.nextInt(2022) + 1;
int sMonth = r.nextInt(12) + 1;
int sDay = r.nextInt(daysPerMonth[sMonth])
+ (sMonth == 2 && isLeapYear.apply(sYear) ? 1 :
0);
int eDaysToEpoch =
daysToEpoch.applyAsInt(eYear, eMonth, eDay);
int sDaysToEpoch =
daysToEpoch.applyAsInt(sYear, sMonth, sDay);
System.out.printf("%02d/%02d/%04d - %02d/%02d/%04d - %,9d total days%n",
eMonth, eDay, eYear, sMonth, sDay, sYear, Math.abs(eDaysToEpoch-sDaysToEpoch));
}
And the original dates
System.out.println(daysToEpoch.applyAsInt(2022, 6, 22)-
daysToEpoch.applyAsInt(2012, 5, 17));
prints something like.
04/10/1377 - 12/03/1486 - 40,048 total days
02/12/0727 - 03/27/0196 - 193,899 total days
11/26/0457 - 12/09/0307 - 54,775 total days
02/25/0691 - 10/23/1596 - 330,785 total days
03/28/0404 - 01/16/1567 - 424,705 total days
10/18/0372 - 01/15/1316 - 344,512 total days
08/01/1374 - 01/23/1484 - 39,986 total days
03/21/0622 - 07/24/0495 - 46,260 total days
02/05/1167 - 08/05/1558 - 142,991 total days
12/02/1824 - 07/21/0976 - 309,859 total days
3688
This has been tested using the API method first shown above. With over 1M random tests there were no discrepancies.
Here is a date validation method. It checks for leap years and days against months. It also allows single digits for month and day. It does not produce detailed error messages. I continues to re-prompt until a valid date is entered. Otherwise the day, month, and year are returned in an array.
public static int[] getDate(Scanner scanner) {
String stringDate = "\\d\\d?/\\d\\d?/\\d{4}";
while (true) {
System.out.println(
"Please enter date in dd/mm/yyyy format.");
String date = scanner.nextLine();
if (date.matches(stringDate)) {
int[] dmy = Arrays.stream(date.split("/"))
.mapToInt(Integer::parseInt).toArray();
System.out.println(Arrays.toString(dmy));
int d = dmy[0];
int m = dmy[1];
int y = dmy[2];
if (d > 0 && m > 0 && m < 13 && y > 0) {
boolean isLeap = isLeapYear.apply(y);
if (isLeap && d <= 29 && m == 2) {
return dmy;
}
if (d <= daysPerMonth[m]) {
return dmy;
}
}
}
System.out.print("Illegal date: ");
}
}

There are date libraries to do this. I am not very sure about the necessity of writing this code. In any case if you want to completely code the solution without using any libraries then here is the code to do that.
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class DateDiff {
private static final Map<Integer, Integer> monthsMap = new HashMap<>();
static {
monthsMap.put(0, 0);
monthsMap.put(1, 31);
monthsMap.put(2, 28);
monthsMap.put(3, 31);
monthsMap.put(4, 30);
monthsMap.put(5, 31);
monthsMap.put(6, 30);
monthsMap.put(7, 31);
monthsMap.put(8, 31);
monthsMap.put(9, 30);
monthsMap.put(10, 31);
monthsMap.put(11, 30);
monthsMap.put(12, 31);
}
public static String dateChecker() {
boolean incorrectDateFormat =false;
String date;
do {
Scanner scanner = new Scanner(System.in);
date = scanner.nextLine();
if (date.charAt(2) != '/' || date.charAt(5) != '/') {
System.out.println("Re-enter date in the dd/mm/yyyy format");
incorrectDateFormat =true;
} else {
incorrectDateFormat = false;
}
} while(incorrectDateFormat);
return date;
}
public static int daysSinceYearZero(String dateStr) {
int year = Integer.parseInt(dateStr.substring(dateStr.lastIndexOf("/")+1));
int totalNumberOfCompleteYearsSinceYear0 = year; //As year zero is also a complete year, so completed number of years will be equal given year in the date.
int leapYearCount = 0;
for(int i=1; i<=totalNumberOfCompleteYearsSinceYear0; i++) { //year zero is not a leap year. so starting the loop from 4 as year 4 is the first leap year.
if((i % 4 == 0 && (i % 100 != 0)) || (i % 400 == 0)) {
leapYearCount++;
}
}
int totalNumberOfDaysInCompletedYears = totalNumberOfCompleteYearsSinceYear0*365 + leapYearCount;
int monthFromGivenDate = Integer.parseInt(dateStr.substring(dateStr.indexOf("/")+1,dateStr.lastIndexOf("/")));
int completedMonth = monthFromGivenDate - 1;
int daysForCompletedMonthsOfCurrentYear = 0;
for(int i=0; i<=completedMonth;i++) {
daysForCompletedMonthsOfCurrentYear = daysForCompletedMonthsOfCurrentYear + monthsMap.get(i);
if(i==2 && year%4==0) {
daysForCompletedMonthsOfCurrentYear++;
}
}
int numberOfDaysCompletedInCurrentMonth = Integer.parseInt(dateStr.substring(0,dateStr.indexOf("/")));
int totalNumberOfDaysTillGivenDate = totalNumberOfDaysInCompletedYears + daysForCompletedMonthsOfCurrentYear + numberOfDaysCompletedInCurrentMonth;
return totalNumberOfDaysTillGivenDate;
}
public static void main(String[] args) {
System.out.println("Enter first date");
String date1 = dateChecker();
System.out.println("Enter second date");
String date2 = dateChecker();
int firstDate = daysSinceYearZero(date1);
int secondDate = daysSinceYearZero(date2);
System.out.println("First Date days since Year Zero: " + firstDate);
System.out.println("Second Date days since Year Zero: " + secondDate);
System.out.println("Difference: " + Math.abs(firstDate-secondDate));
}
}

How to handle invalid input

Can anyone suggest an example on how to handle invalid inputs, I have got the logic wrong for input from the keyboard. So, I need !myScanner.hasNextInt() or to put that loop in a method which I can reuse for ever.
package dayoftheyear;
import java.util.Scanner;
/**
*
* #author abdal
*/
public class DayOfTheYear {
/**
* Ask the user to enter a month, day, and year as integers
* separated by spaces then display the number of the days since the
* beginning of the year.
* Don’t forget about leap year.
* Sample: user inputs ‘3 1 2000’, output is ‘61’.
* #param args Unused.
*/
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
String enter = "A-z";
int a=31;
int b=1;
boolean dateCheck;
int month;
int day;
int year;
do {
System.out.print("Enter a valid month day year separated by spaces");
if (s.hasNextInt()) {
month= s.nextInt();
day=s.nextInt();
year=s.nextInt();
if (month >= b && month <= a || day>=b && day<=a || year>=b) {
int numberOfDay = countDays(month, day, year);
System.out.println(+ month + "/" + day + "/" + year + " is a day number "
+ numberOfDay + " of that year");
dateCheck = true;
} else {
System.out.println("Enter a valid month day year separated by spaces");
dateCheck = false;
}
} else {
System.out.println("Not a date");
month = 0;
day=0;
year=0;
s.next();
dateCheck = false;
}
} while (!dateCheck);
/**
* Get the number of days since the start of the year.
* Declare a 12 element array and initialize it with the number of
* days in each month.
* #param month Month to count from.
* #param day Day of the month to count to.
* #param year The year to count from.
* #return Days since the start of the given year.
*/
} public static int countDays(int month, int day, int year) {
int monthLength[] = {
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
int days = 0;
if (isLeapYear(year) && month > 2)
days += 1;
for (int i = 0; i < month - 1; i++)
days += monthLength[i];
return days += day;
}
/**
* Check if a year is a leap year.
* #param year Year to check.
* #return True if the year is a leap year.
*/
public static boolean isLeapYear(int year) {
if (year % 4 != 0) return false;
else if (year % 100 != 0) return true;
else return year % 400 == 0;
}
}

Replace
if (month >= b && month <= a || day>=b && day<=a || year>=b)
with
if (month >= 1 && month <= 12 && day >= 1 && day <= 31 && year >= 1)
A sample run after this change:
Enter a valid month day year separated by spaces: 13 1 2000
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 3 32 2000
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 3 1 2
3/1/2 is a day number 60 of that year
Update1: the following condition will hold good also for February
if ((month == 2 && day >= 1 && day <= 28 && year >= 1 && !isLeapYear(year))
|| (month == 2 && day >= 1 && day <= 29 && year >= 1 && isLeapYear(year))
|| (month != 2 && month >= 1 && month <= 12 && day >= 1 && day <= 31 && year >= 1))
A sample run:
Enter a valid month day year separated by spaces: 2 29 2001
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 13 2 2001
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 1 32 2001
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 1 2 3
1/2/3 is a day number 2 of that year
Update2: the following code addresses all the issues raised in the comments
int monthLength[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
if ((month == 2 && day >= 1 && day <= 28 && year >= 1 && !isLeapYear(year))
|| (month == 2 && day >= 1 && day <= 29 && year >= 1 && isLeapYear(year))
|| (month != 2 && month >= 1 && month <= 12 && day >= 1 && day <= monthLength[month-1] && year >= 1))
A sample run:
Enter a valid month day year separated by spaces: 2 29 2001
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 13 2 2001
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 1 32 2001
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 6 31 2020
Enter a valid month day year separated by spaces
Enter a valid month day year separated by spaces: 7 31 2020
7/31/2020 is a day number 213 of that year

Since date format is not subject to change in real world, it should be appropriate to use some hard coding. Dividing the problem into several methods is always recommended.
You could add following methods to your class:
private static boolean validDate(int month, int day, int year) {
if (year < 1) {
return false; // no B.C.
}
if (month > 1 && month < 13) {
if (month == 2) { // handle February
return validFeb(day, year);
} else if (month % 2 == 1 && month < 8
|| month % 2 == 0 && month >= 8) { // 31-day months
return valid31(day);
} else { // 30 day months
return valid30(day);
}
}
return false;
}
Validate 30-day months:
private static boolean valid30(int day) {
if (day > 1 && day < 31) {
return true;
}
return false;
}
Validate 31-day months
private static boolean valid31(int day) {
if (day > 1 && day < 32) {
return true;
}
return false;
}
Validate February
private static boolean validFeb(int day, int year) {
if (isLeapYear(year)) {
if (day > 1 && day < 30) {
return true;
}
} else {
if (day > 1 && day < 29) {
return true;
}
}
return false;
}
Then your do-while loop should look something like so:
do {
System.out.print("Enter a valid month day year separated by spaces\n");
if (s.hasNextInt()) month = s.nextInt();
else s.next();
if (s.hasNextInt()) day = s.nextInt();
else s.next();
if (s.hasNextInt()) year = s.nextInt();
else s.next();
int numberOfDaysSinceStart = 0;
if (validDate(month, day, year)) {
dateCheck = true;
numberOfDaysSinceStart = countDays(month, day, year);
System.out.println(month + "/" + day + "/" + year + " is a day number "
+ numberOfDaysSinceStart + " of that year");
} else {
dateCheck = false;
}
} while (!dateCheck);

You can add edge cases forever. There is a reason why time-related calculations are nightmare outsourced to libraries written by some poor souls that are paid to try to cover them all. Java has such built in, take a look at java.util.Calendar (Gregorian implementation).
You set it to year/month/day, and it will puke out an exception if anything is wrong while trying to get the result.
Calendar c = Calendar.getInstance();
c.set(year, month, day);
try {
c.getTime();
} catch (Exception e) {
// wrong date format
}

I think the code below can help you, comment if you have any questions.
while(true) {
try{
System.out.print("Enter a valid month day year separated by spaces");
month= s.nextInt();
day=s.nextInt();
year=s.nextInt();
if (month >= 1 && month <= 12 || day>=1 && day<=31 || year>=1) {
System.out.println(+ month + "/" + day + "/" + year + " is a day number "+ " of that year");
break;
} else {
System.out.println("Enter a valid month day year separated by spaces");
}
} catch(InputMismatchException e) {
System.out.println("Enter a valid month day year separated by spaces");
}
s.next();
}

thanks I updated my program and it is working;
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int year = 0;
int month = 0;
int day = 0;
boolean dateCheck;
do {
System.out.print("Enter a valid month day year separated by spaces\n");
if (s.hasNextInt()) month = s.nextInt();
else s.next();
if (s.hasNextInt()) day = s.nextInt();
else s.next();
if (s.hasNextInt()) year = s.nextInt();
else s.next();
int numberOfDaysSinceStart = 0;
if (month >= 1 && month <= 12 && day >= 1 && day <= 31 && year >= 1) {
dateCheck = true;
numberOfDaysSinceStart = countDays(month, day, year);
System.out.println(month + "/" + day + "/" + year + " is a day number "
+ numberOfDaysSinceStart + " of that year");
} else {
dateCheck = false;
}
} while (!dateCheck);
/**
* Get the number of days since the start of the year.
* Declare a 12 element array and initialize it with the number of
* days in each month.
* #param month Month to count from.
* #param day Day of the month to count to.
* #param year The year to count from.
* #return Days since the start of the given year.
*/
} public static int countDays(int month, int day, int year) {
int monthLength[] = {
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
int days = 0;
if (isLeapYear(year) && month > 2)
days += 1;
for (int i = 0; i < month - 1; i++)
days += monthLength[i];
return days += day;
}
/**
* Check if a year is a leap year.
* #param year Year to check.
* #return True if the year is a leap year.
*/
public static boolean isLeapYear(int year) {
if (year % 4 != 0) return false;
else if (year % 100 != 0) return true;
else return year % 400 == 0;
}
}

Date calculator: Tell what day of the week a certain date is

I am trying to write a program in Java (this is a school assignment that tells you what day of the week a certain date is. (The date should be written on the form yyyy-mm-dd.) I thought I had come up with a solution with the code below, but then I found an error.
When you run the code, and type in 1999-12-31 in the dialog, the program tells you that the entered date (1999-12-31) is a Friday. But when you type in the date 2000-01-01 (which is one day after 1999-12-31), the program tells you that the day is a Sunday! What happened with Saturday? A similar problem happens when you type in 2000-02-29 and 2000-03-01, they both give Wednesday as an answer!
What I have yet noticed, this error appears only when you enter a date between 2000-01-01 and 2000-02-29. I would be very grateful if someone could please help me to find the cause of the error and to solve the problem!
import static javax.swing.JOptionPane.*;
import static java.lang.Math.*;
public class DateCalc {
// Here, between the DateCalc class declaration and the main method, several methods used in the program are
// constructed.
// The method isLeapYear tests whether the entered year is a leap year or not.
private static boolean isALeapYear(int year) {
// If the year is a multiple of 4 and not a multiple of 100, or a multiple of 400, then it is a leap year.
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
return true;
}
else {
return false;
}
}
// A method that tests whether a given string is written as a valid date.
private static boolean isAValidDate(int year, int month, int day) {
int maxValidYear = 9999;
int minValidYear = 1754;
if (year > maxValidYear || year < minValidYear) {
return false;
}
if (month < 1 || month > 12) {
return false;
}
if (day < 1 || day > 31) {
return false;
}
// Handle the February Month
if (month == 2) {
if (isALeapYear(year)) {
return (day <= 29); // This statement is true if the value of the day is less than or equal to 29 if the month is February within a leap year.
// Otherwise the statement is false and the method will return the boolean value false.
}
else {
return (day <= 28); // This statement is true if the value of the day is less than or equal to 28 if the month is February within a non-leap year.
// Otherwise the statement is false and the method will return the boolean value false.
}
}
// Month of April, June, September and November must have number of days less than or equal to 30.
if (month == 4 || month == 6 || month == 9 || month == 11) {
return (day <= 30);
}
return true;
}
// A method that calculates the day number within the year.
private static int dayNumberWithinYear(int year, int month, int day) {
// An array which stores the number of days in the different months (when the year is not a leap year).
// (Index 0 is the number of days in January, index 1 is the number of days in February, etc.)
int[] monthStructure = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
// If the entered year is a leap year, then the monthStructure array will be initialized with an extra day in February, i.e the leap day.
if (isALeapYear(year)) {
monthStructure[1] = 29;
}
int sumDaysInPreviousMonths = 0;
int daysInTheCurrentMonth = day;
int dayNumber = 0;
// Loops through all the months (index 0 is January, index 1 is February, etc.).
for (int i = 0; i < month - 1; i++) {
sumDaysInPreviousMonths += monthStructure[i];
}
dayNumber = sumDaysInPreviousMonths + daysInTheCurrentMonth;
return dayNumber;
}
// A method that decides the day of the week of an entered date.
private static void weekDay(int year, int month, int day) {
// The number of days that have passed since January 1, 1754, excluding the days of the entered year and
// excluding the leap days.
int sumDaysInOrdinaryYears = (year - 1754) * 365;
int sumLeapDaysInLeapYears = 0;
// Suppose the entered year is n. The for-loop goes through all the years from year n-1 to year 1754, and
// checks if the current year in the loop is a leap year. The number of leap years between year 1754 and n-1
// is equal to the number of days that will get added (beside from the days in ordinary years) to the total
// days from January 1, 1754 to the entered date.
for (; year > 1754; year -= 1) {
if (isALeapYear(year)) {
sumLeapDaysInLeapYears += 1;
}
}
// The sum of all days from year 1754 to year n-1 (if the entered year is n), is equal to the sum of days in
// the ordinary years and the leap days in the years.
int sumDaysInEveryYearExcludingTheEntered = sumDaysInOrdinaryYears + sumLeapDaysInLeapYears;
int sumDaysInTotalYears = sumDaysInEveryYearExcludingTheEntered + dayNumberWithinYear(year, month, day);
int weekDay = sumDaysInTotalYears % 7;
if (weekDay == 0) {
showMessageDialog(null, "The date is a monday.");
}
else if (weekDay == 1) {
showMessageDialog(null, "The date is a tuesday.");
}
else if (weekDay == 2) {
showMessageDialog(null, "The date is a wednesday.");
}
else if (weekDay == 3) {
showMessageDialog(null, "The date is a thursday.");
}
else if (weekDay == 4) {
showMessageDialog(null, "The date is a friday.");
}
else if (weekDay == 5) {
showMessageDialog(null, "The date is a saturday.");
}
// If weekDay == 6
else {
showMessageDialog(null, "The date is a sunday.");
}
}
public static void main(String[] args) {
// This is step 3 in the laboratory instruction.
while (true) {
String date = showInputDialog("Please, enter a date on the form yyyy-mm-dd");
// If the user clicks 'Cancel' or clicks 'OK' when the dialog box is empty, the program will exit.
if (date == null || date.length() == 0) {
break;
}
int y = Integer.parseInt(date.substring(0,4));
int m = Integer.parseInt(date.substring(5,7));
int d = Integer.parseInt(date.substring(8));
if (!isAValidDate(y, m, d)) {
showMessageDialog(null, "Error! The entered date is invalid. " +
" Please enter a valid date on the form yyyy-mm-dd");
}
else {
weekDay(y, m, d);
}
}
}
}

Instead of asking us to debug through your entire code, perhaps consider LocalDate to get the desired result:
LocalDate ldt = LocalDate.parse("1999-12-31");
System.out.println(ldt.getDayOfWeek());
LocalDate ldt2 = LocalDate.parse("2000-01-01");
System.out.println(ldt2.getDayOfWeek());
Output:
FRIDAY
SATURDAY

The Problem is with finding the number of leap year. Your logic is counting the year 2000 also. The number of leap years should be same for 1999-12-31 and 2000-01-01. You need to consider year 2000 only if the month is greater than February. Increment the sumLeapDaysInLeapYears only if the input date is greater than Feb 28th

Week day Finder in Java

I'm doing a project that consists on: 'Write a program that prompts for a date (month, day, year) and reports the day of the week for that date. It might be
helpful to know that January 1, 1601 was a Monday.'. This is an exercise of 'Building Java Programs - A Back to Basics Approach, 2nd Edition', a book which I bought to teach myself Java. Any feedback is highly appreciated, but I do ask that you explain why you would do something another/a certain way. Thanks!
So, my problem is that while for the dates nearer to 1600's it's giving the correct day (I believe), the same is not true for more recent days, with them having an offset of three days (at least the ones I checked). Why does this happen and how do I fix it? Thanks!
My code:
// finds the day of the week of the given date
public static String dayFinder(int month, int day, int year) {
// handle invalid input
if (month > 12 || month < 1 || day > 31 || day < 1) {
throw new IllegalArgumentException("Month must be between "
+ "1 and 12 and Day must be between 1 and 31.");
}
// convert to "absolute" day, covering day and month
int absoluteDay = monthToDay(month, day, year);
// convert year to days and add to "absolute" day
absoluteDay += yearToDay(year);
if (absoluteDay % 7 == 1) {
return "Monday";
} else if (absoluteDay % 7 == 2) {
return "Tuesday";
} else if (absoluteDay % 7 == 3) {
return "Wednesday";
} else if (absoluteDay % 7 == 4) {
return "Thursday";
} else if (absoluteDay % 7 == 5) {
return "Friday";
} else if (absoluteDay % 7 == 6) {
return "Saturday";
} else { // absoluteDay % 7 == 0
return "Sunday";
}
}
// calculates the number of days present in a given
// date since the beginning of the year
public static int monthToDay(int month, int day, int year) {
// convert to "absolute" day
int absoluteDay = 0, daysTo31 = 0;
// iterate through months
for (int i = 0, loopMonth = month; i < month; i++) {
if (loopMonth == 1 || loopMonth == 3 || loopMonth == 5
|| loopMonth == 7 || loopMonth == 8 || loopMonth == 10
|| loopMonth == 12) {
absoluteDay += 31;
daysTo31 = 0;
} else if (loopMonth == 2) {
if (year % 4 != 0) {
absoluteDay += 28;
daysTo31 = 3;
} else { // leap year
absoluteDay += 29;
daysTo31 = 2;
}
} else { // month = 4, 6, 9 or 10
absoluteDay += 30;
daysTo31 = 1;
}
loopMonth--;
}
// adjust to specific day
absoluteDay -= (31 - day - daysTo31);
return absoluteDay;
}
// calculates the number of days between
// (the beginning of) the given year and
// (the beginning of) the reference year 1601
public static int yearToDay(int year) {
// convert to "absolute" day
int absoluteDay = 0;
year -= 1601;
// iterate through years
for (int i = 0, loopYear = year; i < year; i++) {
if (loopYear % 4 != 0) {
absoluteDay += 365;
} else { // leap year
absoluteDay += 366;
}
loopYear--;
}
return absoluteDay;
}
// Year 1604 (MDCIV) was a leap year starting on Thursday

Your problem is probably connected with the leap years.
Due to Wikipedia:
Every year that is exactly divisible by four is a leap year, except for years that are exactly divisible by 100; the centurial years that are exactly divisible by 400 are still leap years. For example, the year 1900 is not a leap year; the year 2000 is a leap year. [link]
It's the reason why you have three day too much (1700, 1800, 1900).

Java.util date/calendar functionality is fraught with craziness. I think Java7 has improved it a bit (I've heard, but not investigated), but I recommend a 3rd party library Joda-Time. To do what you're trying to do with Joda would be:
DateTime anyDateTime = new DateTime(
1800, //year
4, //month
19, //day
0, //hour
0); // minutes
System.out.println("DOW = " + anyDateTime.dayOfWeek().getAsText());
prints "DOW = Saturday"
I realize your goal is to learn Java, but it's not always necessary to reinvent the wheel.

tl;dr
int dayOfWeekNumber =
LocalDate.of( 2016 , 12 , 22 ) // A date-only object, no time-of-day nor time zone.
.getDayOfWeek() // `DayOfWeek` enum object.
.getValue() ; // 1-7 for Monday-Sunday.
java.time
The Question is really about algorithm. But FYI, this functionality is built into Java with the java.time classes.
LocalDate
The LocalDate class represents a date-only value without time-of-day and without time zone.
LocalDate ld = LocalDate.of( 2016 , 12 , 22 );
DayOfWeek
The DayOfWeek enum defines seven objects for each day of the week.
DayOfWeek dow = ld.getDayOfWeek() ;
Generally best to use the DayOfWeek object. But if you absolutely need an integer number, you can ask for one. Numbered 1-7 for Monday-Sunday per ISO 8601.
int dowNumber = dow.getValue();
About java.time
The java.time framework is built into Java 8 and later. These classes supplant the troublesome old date-time classes such as java.util.Date, .Calendar, & java.text.SimpleDateFormat.
The Joda-Time project, now in maintenance mode, advises migration to java.time.
To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations.
Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport and further adapted to Android in ThreeTenABP (see How to use…).
The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval, YearWeek, YearQuarter, and more.

import java.util.*;
This code is working for any date.
Maybe it will help someone.
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner console = new Scanner(System.in);
System.out.println("Give me a special date !!!");
System.out.print("Month: ");
int month = console.nextInt();
System.out.print("Day: ");
int day = console.nextInt();
System.out.print("Year:");
int year = console.nextInt();
String date = dayFinder(month, day, year);
System.out.println("It is the date " + month + "/" + date + "/" + year);
console.close();
}
public static String dayFinder(int month, int day, int year) {
// handle invalid input
if (month > 12 || month < 1 || day > 31 || day < 1) {
throw new IllegalArgumentException("Month must be between "
+ "1 and 12 and day must be between 1 and 31");
} else {
// convert to "absolute" day, covering day and month
int absoluteDay = monthToDay(month, day, year);
// convert year to days and add to "absolute" day
absoluteDay += yearToDay(year);
if (absoluteDay % 7 == 2) {
return "Monday";
} else if (absoluteDay % 7 == 3) {
return "Tuesday";
} else if (absoluteDay % 7 == 4) {
return "Wednesday";
} else if (absoluteDay % 7 == 5) {
return "Thursday";
} else if (absoluteDay % 7 == 6) {
return "Friday";
} else if (absoluteDay % 7 == 0) {
return "Saturday";
} else { // absoluteDay % 7 == 1
return "Sunday";
}
}
}
// calculates the number of days between
// (the beginning of) the given year
// (the beginning of) the reference year 1601;
public static int yearToDay(int years) {
// covert to "absolute" day;
int absoluteDay = 0;
int leapYears = 0;
// iterate through years;
for (int i = 0; i < years; i++) {
if (((i % 4) == 0) && ((i % 100) != 0)) {
leapYears +=1;
} else if (i % 400 == 0) {
leapYears ++;
}
}
absoluteDay = (leapYears * 366) + (((years - 1) - leapYears) * 365);
return absoluteDay;
}
// Calculates the numbers of days present in a given
// date since the beginning of the year;
public static int monthToDay (int month, int day, int year) {
// convert to absolute day;
int absoluteDay = 0;
// iterate through months
for (int i = 1; i < month; i++) {
if ((i == 4) || (i == 6) || (i == 9) || (i == 11)) { // 30 day
absoluteDay += 30;
} else if (i == 2) {
if ((year % 4 == 0) && (year % 100 != 0)) {
absoluteDay += 29;
} else if (year % 400 == 0) {
absoluteDay += 29;
} else {
absoluteDay += 28;
}
} else {
absoluteDay += 31; // 1,3,5,7,8,10,12 months
}
}
return absoluteDay + day;
}
}