JAVA-日期类（Date、SimpleDateFormat）

已于 2023-04-05 17:34:33 修改
阅读量322 收藏 1
点赞数
分类专栏： java 蓝桥杯 文章标签： java
于 2023-03-18 21:35:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RGHLY21/article/details/129642704
版权

目录

1、Date类

2、Calendar类

java.util.Date日期类
java.text.SimpleDateFormat日期转换类

 SimpleDateFormat：实现String和Date之间的转换

1、 日期转字符串

import java.io.*;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)1e4 + 10;
    static math math_bag = new math();
    static int fa[] = new int[N];


    public static void main(String[] args ) throws IOException, ParseException
    {
        // 创建日期对象（日期、时间）
        Date d = new Date();
        // 创建日期格式对象
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        // 日期转换为字符串
        String str = s.format(d);
        pw.println(str);
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

2、字符串转换为日期(用的少)

import java.io.*;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)1e4 + 10;
    static math math_bag = new math();
    static int fa[] = new int[N];


    public static void main(String[] args ) throws IOException, ParseException
    {
        String t = "2023年12月20日";
        SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日"); // 需要和上边的字符串的日期格式相同
        Date e = sd.parse(t);
        pw.println(e);
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

1、Date类

说明：Date日期类通常用于日期的计算
说明：Date中存储的是距离一个历史时间点(1970年)的毫秒数。

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd")：创造一个日期格式，给Date来用

Date date = simpleDateFormat.parse("2000-1-1")：上面创建的日期格式后就可以给Date类型赋值了

long t = date.getTime()：获取时间，单位是毫秒

import java.io.*;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)1e4 + 10;
    static math math_bag = new math();
    static int fa[] = new int[N];


    public static void main(String[] args ) throws IOException, ParseException
    {
        Date d = new Date();
        long t = d.getTime();
        pw.println(t);
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

计算两天后的日期：

import java.io.*;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)1e4 + 10;
    static math math_bag = new math();
    static int fa[] = new int[N];


    public static void main(String[] args ) throws IOException, ParseException
    {
        // 2天后的日期
        Date date = new Date();
        date.setTime(date.getTime() + 2L * 24 * 60 * 60 * 1000);
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        pw.println(s.format(date));
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

Date的使用例子：

标题：第几天

2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？

注意：需要提交的是一个整数，不要填写任何多余内容。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)500 + 10;
    static long a[][] = new long[N][N];
    static long s[][] = new long[N][N];

    public static void main(String[] args ) throws IOException, ParseException
    {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

        Date date1 = simpleDateFormat.parse("2000-1-1");
        Date date2 = simpleDateFormat.parse("2000-5-4");

        long t1 = date1.getTime();
        long t2 = date2.getTime();

        pw.println((t2 - t1) / (24*60*60*1000) + 1);
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException  { return reader.readLine(); }

    static String next() throws IOException
    {
        while (!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException  { return Integer.parseInt(next()); }

    static double nextDouble() throws IOException { return Double.parseDouble(next()); }

    static long nextLong() throws IOException  { return Long.parseLong(next());}

    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class PII
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
}

2、Calendar类

创建Calendar对象的API：

getInstance（）

修改时间的API：

set()：可以改变年、月、日、星期几

add()：add方法会产生其他相关时间属性的连动变化

实战：

//set()方法：两个参数【设置的项，设置的值】
calendar.set(Calendar.YEAR, year); // 存年
calendar.set(Calendar.MONTH, 11); // 存月，MONTH字段是从0月开始计数的，与数组类似，所以要想存12月，传参数11，
calendar.set(Calendar.DAY_OF_MONTH, 31); //设置日期  31号

calendar的使用例子：

1、世纪末的星期

标题: 世纪末的星期

    曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。

    还有人称今后的某个世纪末的12月31日，如果是星期一则会....

    有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!!

    于是，“谣言制造商”又修改为星期日......

    1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？

    请回答该年份（只写这个4位整数，不要写12月31等多余信息）

答案：2299

代码：（此题使用java中的日历类）

import javax.print.DocFlavor;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
 
public class Main
{
    static Scanner sc = new Scanner(System.in);
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int) 1e5 + 10;
    static PII a[] = new PII[N];
    static Set<Integer> set = new HashSet<>();
 
    public static void main(String[] args) throws IOException
    {
        Calendar calendar = Calendar.getInstance(); //获取Calendar类的实例,这样才能用
        for(int year=1999;year<10000;year+=100)//题目要求必须是xx99年 也就是每次加一百年
        {
            //set()方法：两个参数【设置的项，设置的值】
            calendar.set(Calendar.YEAR, year); // 存年
            calendar.set(Calendar.MONTH, 11); // 存月，MONTH字段是从0月开始计数的，与数组类似，所以要想存12月，传参数11，
            calendar.set(Calendar.DAY_OF_MONTH, 31); //设置日期  31号
            if (calendar.get(Calendar.DAY_OF_WEEK) == 1)  //get()方法获取值; DAY_OF_WEEK一周中的第几天，星期日是第一天
            { // 国外星期天对应的是1 星期一对应的是2 以此类推
                pw.println(year);
                break;
            }
        }
        pw.flush();
    }
}
 
class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");
 
    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}
 
class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}
 
class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

2、 跑步锻炼

AC代码1：（）

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)2e5 + 10;


    public static void main(String[] args ) throws IOException
    {
        int res = 0;
        Calendar c = Calendar.getInstance(); //建一个Calendar
        c.set(2000,0,1); // 把开始时间丢到Calendar里面去，注意月从0开始

        while (true)
        {
            int day_of_month = c.get(Calendar.DAY_OF_MONTH); // 得到该天是该月的第几天（得到该时间的日）
            int daya_of_week = c.get(Calendar.DAY_OF_WEEK); // 得到该天是该周的第几天
            int year = c.get(Calendar.YEAR); //得到该时间的年
            int month = c.get(Calendar.MONTH); // 得到该时间的月

            if(day_of_month == 1 || daya_of_week == 2)  res += 2;
            else  res += 1;

            if(year == 2020 && month == 9 && day_of_month==1)
            {
                pw.println(res);
                pw.flush();
                return;
            }
            c.add(Calendar.DATE,1); //时间增加一天
        }
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

class Line implements Comparable<Line>
{
    double k; // 斜率
    double b; // 截距

    public Line(double k, double b)
    {
        this.k = k;
        this.b = b;
    }

    @Override
    public int compareTo(Line o)
    {
        if (this.k > o.k) return 1;
        if (this.k == o.k)
        {
            if (this.b > o.b) return 1;
            return -1;
        }
        return -1;
    }
}

class mqm
{
    int fa[] = new int[1005];
    void init()
    {
        for(int i = 1 ; i <= 1000 ; i ++)  fa[i] = i;
    }
    void merge(int x, int y) { fa[find(x)] = find(y); }
    int find(int x)
    {
        if(x != fa[x])  fa[x] = find(fa[x]);
        return fa[x];
    }
    boolean query(int x, int y) { return find(x) == find(y); }
}

AC代码2：（LocalDate真的优美！！！）

import java.time.LocalDate;

public class Main 
{
    public static void main(String[] args) 
    {
        LocalDate startTime = LocalDate.of(2000, 1, 1); // 设置开始时间
        LocalDate endtTime = LocalDate.of(2020, 10, 1); // 设置结束时间
        int allKM = 0;
        while(!startTime.isAfter(endtTime)) // 开始时间不等于最终时间
        {
            if(startTime.getDayOfWeek().getValue() == 1 || startTime.getDayOfMonth() == 1)  allKM += 2; // 周一或者每个月的一号，跑两千米
            else  allKM += 1; 
            startTime = startTime.plusDays(1); // 时间+1
        }
        System.out.println(allKM); // 输出总公里数
    }
}

3、

代码：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)3000 + 10;

    public static void main(String[] args ) throws IOException, ParseException
    {
        Calendar calendar = Calendar.getInstance();

        calendar.set(2022,0,1);
        int cnt = 0;
        while(true)
        {
            int year = calendar.get(Calendar.YEAR);
            int month = calendar.get(Calendar.MONTH);
            int day_of_month = calendar.get(Calendar.DAY_OF_MONTH);
            int day_of_week = calendar.get(Calendar.DAY_OF_WEEK);

            if(day_of_week == 7 || day_of_week == 1 || day_of_month == 1 || day_of_month == 11 || day_of_month == 21 || day_of_month == 31)  cnt ++;

            if(year == 2022 && month == 11 && day_of_month == 31)
            {
                pw.println(cnt);
                pw.flush();
                return;
            }

            calendar.add(Calendar.DATE,1);
        }

//         Calendar calendar = Calendar.getInstance();
//
//         calendar.set(2000,0,1);
//         int year = calendar.get(Calendar.YEAR);
//         int month = calendar.get(Calendar.MONTH);
//         int day_of_month = calendar.get(Calendar.DAY_OF_MONTH);
//         int day_of_week = calendar.get(Calendar.DAY_OF_WEEK);
//
//         pw.println(year);
//         pw.println(month);
//         pw.println(day_of_month);
//         pw.println(day_of_week);
//         pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException  { return reader.readLine(); }

    static String next() throws IOException
    {
        while (!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException  { return Integer.parseInt(next()); }

    static double nextDouble() throws IOException { return Double.parseDouble(next()); }

    static long nextLong() throws IOException  { return Long.parseLong(next());}

    static BigInteger nextBigInteger() throws IOException { return new BigInteger(rd.nextLine()); }
}

class PII
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
}

21RGHLY
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java日期格式化：DateFormat类和SimpleDateFormat类详解
GIS地图技术分享(GIS入门、Openlayers教程、Leaflet教程)，做最好的GIS地图开发教程
04-23 2392
前言 格式化日期表示将日期/时间格式转换为预先定义的日期/时间格式。 例如将日期“Fri May 18 15:46:24 CST2016” 格式转换为 “2016-5-18 15:46:24 星期五”的格式。 在 Java 中，可以使用 DateFormat 和 SimpleDateFormat 这两个类来格式化日期，下面详细介绍这两个格式化日期类的使用。 DateFormat 类 DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如
【Java 基础篇】Java 日期类详解
繁依Fanyi的博客
06-25 3292
本文介绍了 Java 日期类的概念、用法和常见操作。我们了解了Date类及其问题，并介绍了 Java 8 中引入的java.time包，其中包括LocalDateLocalTime和等类，用于处理日期、时间、时区等相关操作。此外，我们还介绍了如何使用类进行日期和时间的格式化和解析操作。通过合理地使用日期类和相关操作，我们可以更加方便地处理和操作日期、时间和时区信息。希望本文对你理解和使用 Java 日期类有所帮助。如果你对日期类还有更多疑问，可以查阅 Java 官方文档或参考相关书籍进行深入学习。
Java常用类-----日期类
m0_56688298的博客
05-08 600
Java常用类----日期类一.JAVA----日期类1.Date2.Calendar3.SimpleDateFormat二.JAVA8+ ----日期类1.LocalDate2.LocalTime3.时区4.Period5.DateTimeFormat 一.JAVA----日期类 1.Date 2.Calendar 3.SimpleDateFormat 二.JAVA8+ ----日期类 1.LocalDate 2.LocalTime 3.时区 4.Period 5.DateTimeFormat ...
Java 日期时间
weixin_30847271的博客
08-15 776
java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。 第一个构造函数使用当前日期和时间来初始化对象。 Date( ) 第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。 Date(long millisec) D...
【Java 基础篇】Java日期和时间格式化与解析指南：SimpleDateFormat详解
最新发布
繁依Fanyi的博客
09-08 1万+
是 Java 中的一个类，它属于java.text包，用于格式化和解析日期和时间。它允许你将日期和时间对象转换成字符串表示，或者将字符串解析成日期和时间对象。的灵活性和可定制性使得它成为处理日期和时间的强大工具。允许你使用不同的模式字母来自定义日期时间格式，包括星期几、上午/下午、时区等信息。是 Java 中处理日期和时间的重要工具，它允许你将日期时间对象格式化成字符串，也可以将字符串解析成日期时间对象。通过了解日期时间格式字符串和模式字母的用法，你可以创建自定义的日期时间格式。但要注意，
Java 日期和时间类的基本使用
09-07
Java日期和时间类是Java编程中不可或缺的一部分，它们用于处理和操作日期、时间以及日期时间。在Java 8之前，主要依赖`java.util.Date`和`java.text.SimpleDateFormat`这两个类来处理日期和时间，但它们的设计被认为...
详解Java中格式化日期的DateFormat与SimpleDateFormat类
09-02
DateFormat其本身是一个抽象类,SimpleDateFormat 类是DateFormat类的子类,一般情况下来讲DateFormat类很少会直接使用,而都使用SimpleDateFormat类完成,下面我们具体来看一下两个类的用法:
JAVA使用SimpleDateFormat类表示时间代码实例
08-19
JAVA 中的日期和时间处理可以使用 Date 类和 SimpleDateFormat 类来实现，通过 format() 方法和 parse() 方法可以实现日期和文本之间的转换。 在实际开发中，我们可以根据需要选择不同的日期格式和解析方式，例如...
Java多线程环境下SimpleDateFormat类安全转换
08-25
SimpleDateFormat类是Java中常用的日期格式化类，可以用来将日期字符串解析成Date对象，也可以用来将Date对象格式化成指定的日期字符串格式。SimpleDateFormat类的使用非常广泛，可以应用于各种Java应用程序中。 7....
Java-Date 类的学习总结.docx
12-18
Java Date 类是 Java 语言中用于处理日期和时间的类，可以用来计算某一月份的最大天数、将字符串转化为日期、格式化输出日期时间等。本文将对 Java Date 类的常用方法进行总结。 1. 计算某一月份的最大天数 使用 ...
【JavaSE】日期类
兮动人
03-23 413
日期类 【知道怎么查，怎么用即可，不用每个方法都背】 1. 第一代日期类 Date：精确到毫秒，代表特定的瞬间 SimpleDateFormat：格式和解析日期的类。SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化(日期->文本)、解析(文本->日期)和规范化。 应用实例 ...
救救，捞捞。
weixin_69562572的博客
09-07 342
JAVA定义一个日期类My Date，至少具有私有成员变量： year、month 、day，以及成员方法 set Year、get Year 等（具体隐藏实现方法，用于设置、获取成员变量） 、is Runyear（boolean型，判断当前对象保存的年是否为闰年）、print（打印日期对象的年 月 日信息）。（1）在main方法，要求方法中通过“My Date d1=new My Date();My Date d2=new My Date(2009,4,1);”分别新建年月日为1999年1月1日的日期对
Java定义一个点日期MyDate，包含三个成员变量year、month、day 表示年、月、日，每个属性对应get和set方法，最后printDate()方法，按照“yyy~mm~dd”的形式输出
weixin_46302837的博客
05-17 7962
public class MiDiXi { //方法一：main方法中调用输出方法printDate() int year; int month; int day; void getYear(int y,int m,int d){ year=y; month=m; day=d; System.out.println("输入日期"); } void setYear(){ MiDiXi year=new MiDiXi(); MiDiXi month=new MiDi..
Java菜鸟笔记：Java中的Date类以及时间日期格式化
怪力乌龟的博客
05-07 939
一、 Date类 java.util.Date类对象的创建： 1、创建当前时间的Date对象 直接new对象就是创建代表系统当前日期的Date对象 Date d = new Date(); System.out.println(d); //Thu May 07 22:35:17 CST 2020 2、创建指定的时间的Date对象： 如果我们想创建一个代表2020年5月7日的Date对象， D...
Java Date 对象详解
兴趣是最好的老师，勤能补拙
05-16 9035
本文介绍了 Java Date 对象及时间格式化。Java Date 类表示日期和时间，可以存储从 1970 年 1 月 1 日零时开始累计的毫秒数，在多线程环境下可能会发生并发问题，并且易混淆和不支持国际化。Java 提供了 SimpleDateFormat 类来格式化和解析日期和时间，存在线程安全、易混淆和不支持国际化等问题。Java 8 引入了新的时间日期 API（Java Time API），提供了更加易于理解和使用的类和方法，并且克服了存在的许多问题。
JAVA中Date和SimpleDateFormat类的应用
white_free的博客
02-06 204
JAVA中Date和SimpleDateFormat类的应用 ###14.16_常见对象(Date类的概述和方法使用)(掌握) A:Date类的概述 类 Date 表示特定的瞬间，精确到毫秒。 B:构造方法 public Date() public Date(long date) C:成员方法 public long getTime() public void setTime(long time) import java.util.Date; public class Demo6_D
java中的日期时间类详解(Date/DateFormat/Calendar)
h______1的博客
06-11 995
类表示特定的瞬间，精确到毫秒。Date类的构造函数可以把毫秒值转成日期对象。
java 中Date日期类型
热门推荐
yloveyzcl的博客
08-07 5万+
4 日期相关 把1970年1月1日当做了时间原点,以毫秒值为单位 4.1 获得当前时间 System.currentTimeMillis() public class DateTest {     public static void main(String[] args) {        Date date=new Date();        //当前日期的毫秒值      ...
Java语言中自定义Date类
qq_44640357的博客
11-01 3090
判断自定义的Date中的年月日是否合法，Switch case语句，重写toString()和equals()方法
7-3 jmu-java-日期类的基本使用
03-23
日期类是 Java 中非常常用的类，可以用来表示日期和时间。在使用日期类之前，我们需要先导入 java.util 包。下面是一个简单的例子，展示了如何使用日期类来获取当前日期和时间： import java.util.Date; public ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

21RGHLY

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值