「java判断两个时间段」java判断两个时间大小

今天给各位分享java判断两个时间段的知识，其中也会对java判断两个时间大小进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java 我想判断两个时间的比较是否大于30秒怎么写
• 2、java中怎样判断日期处于两个日期中
• 3、JAVA中如何判断两个时间段是否有交集
• 4、java 判断两个时间段是不是有交集
• 5、Java判断两个时间段是否有交集

java 我想判断两个时间的比较是否大于30秒怎么写

public void test() {

try {

SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date now = df.parse("2019-03-26 13:31:40");//当前时间

Date date = df.parse("2004-01-02 11:30:24");//过去

long l = now.getTime() - date.getTime();

long day = l / (24 * 60 * 60 * 1000);

long hour = (l / (60 * 60 * 1000) - day * 24);

long min = ((l / (60 * 1000)) - day * 24 * 60 - hour * 60);

long s = (l / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);

System.out.println("" + day + "天" + hour + "小时" + min + "分" + s + "秒");

} catch (Exception e) {

}

}

java中怎样判断日期处于两个日期中

Date date = new Date();

long time = date.getTime();

time越大时间越往后，不知道你用的什么类但是一般和时间有关的都可以间接得到Date类，然后可以调用getTime方法获得时间戳，也就是这里的time,你只需比较你的time是是否处于那两个日期对应的time之间，也就是判断 if(timetime1timetime2)

JAVA中如何判断两个时间段是否有交集

判断时间段是否有交集，

每个时间段有两个时间

比如A-B 和C-D

判断C或D是否在时间段AB里面，是的话，就有交集

java 判断两个时间段是不是有交集

public class DateKit{

    /**

                    时间段的比较处理 , 如果包含了传来的 时段 了, 就说明 时间冲突了 

    * @return 

    */

    public static boolean isContain(Date[] a, Date[] b) {

        long astatr = a[0].getTime();

        long aend   = a[1].getTime();

        long bstatr = b[0].getTime();

        long bend   = b[1].getTime();

        // a0 包在了 b0 ~ b1 之间

        if( astatr=bstatr  astatr=bend ) return true;

        // b0 包在了 a0 ~ a1 之间

        if( astatr=bstatr  aend=bstatr ) return true;

        return false;

    }

    /**

                时间段的比较处理 , 如果包含了传来的 时段 了, 就说明 时间冲突了 , (允许首尾相等而不包含的情况)

    * @return 

    */

    public static boolean isContainEnd(Date[] a, Date[] b) {

        long astatr = a[0].getTime();

        long aend   = a[1].getTime();

        long bstatr = b[0].getTime();

        long bend   = b[1].getTime();

        // a0 包在了 b0 ~ b1 之间

        if( astatr=bstatr  astatrbend ) return true;

        // b0 包在了 a0 ~ a1 之间

        if( astatr=bstatr  aendbstatr ) return true;

        // 相等

        if( astatr==bstatr  aend==bend )  return true;

        return false;

    }

    // 功能 工具 扩展

        public static boolean isContain(String astatr,String aend, String bstatr,String bend) {

            return isContain(new String[]{astatr , aend}, new String[]{bstatr , bend});

        }

        public static boolean isContain(String[] aStr, String[] bStr) {

            return isContain(aStr, bStr, "yyyy-MM-dd HH:mm:ss");

        }

        public static boolean isContain(String[] aStr, String[] bStr, String pattern) {

            final SimpleDateFormat SF = new SimpleDateFormat(pattern);

            try {

                return isContain(new Date[]{SF.parse(aStr[0]), SF.parse(aStr[1])} , new Date[]{SF.parse(bStr[0]), SF.parse(bStr[1])});

            } catch (Exception e) {

                e.printStackTrace();

            }

            return false;

        }

        public static boolean isContainEnd(String astatr,String aend, String bstatr,String bend) {

            return isContainEnd(new String[]{astatr , aend}, new String[]{bstatr , bend});

        }

        public static boolean isContainEnd(String[] aStr, String[] bStr) {

            return isContainEnd(aStr, bStr, "yyyy-MM-dd HH:mm:ss");

        }

        public static boolean isContainEnd(String[] aStr, String[] bStr, String pattern) {

            final SimpleDateFormat SF = new SimpleDateFormat(pattern);

            try {

                return isContainEnd(new Date[]{SF.parse(aStr[0]), SF.parse(aStr[1])} , new Date[]{SF.parse(bStr[0]), SF.parse(bStr[1])});

            } catch (Exception e) {

                e.printStackTrace();

            }

            return false;

        }

}

测试:

 public static void main(String[] args) throws ParseException {

        final SimpleDateFormat SF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date[] a = {SF.parse("2017-07-06 11:53:00"), SF.parse("2017-07-06 14:52:00")};

        Date[] b = {SF.parse("2017-07-06 14:52:00"), SF.parse("2017-07-06 16:52:00")};

        System.out.println("您好, 智能的电脑! 请问:");

        for (Date date : a) {

            System.out.print(date.toString() + " ~  ");

        }

        System.out.println("包含:");

        for (Date date : b) {

            System.out.print(date.toString() + " ~  ");

        }

        System.out.println("吗?");

        boolean ret = DateKit.isContain(a, b);

        System.out.println("o(∩_∩)o 哈哈 ~ 我猜是: " + ret);

        ret = DateKit.isContainEnd(a, b);

        System.out.println("o(∩_∩)o 哈哈 ~ 允许首尾相等 我猜是: " + ret);

    }

找了半天, 没见写的好的. 自己动手写个, 问题是 两个时段,, 大部分人给的是 两个时间点..

Java判断两个时间段是否有交集

public class DateKit{

    /**

                    时间段的比较处理 , 如果包含了传来的 时段 了, 就说明 时间冲突了 

    * @return 

    */

    public static boolean isContain(Date[] a, Date[] b) {

        long astatr = a[0].getTime();

        long aend   = a[1].getTime();

        long bstatr = b[0].getTime();

        long bend   = b[1].getTime();

        // a0 包在了 b0 ~ b1 之间

        if( astatr=bstatr  astatr=bend ) return true;

        // b0 包在了 a0 ~ a1 之间

        if( astatr=bstatr  aend=bstatr ) return true;

        return false;

    }

    /**

                时间段的比较处理 , 如果包含了传来的 时段 了, 就说明 时间冲突了 , (允许首尾相等而不包含的情况)

    * @return 

    */

    public static boolean isContainEnd(Date[] a, Date[] b) {

        long astatr = a[0].getTime();

        long aend   = a[1].getTime();

        long bstatr = b[0].getTime();

        long bend   = b[1].getTime();

        // a0 包在了 b0 ~ b1 之间

        if( astatr=bstatr  astatrbend ) return true;

        // b0 包在了 a0 ~ a1 之间

        if( astatr=bstatr  aendbstatr ) return true;

        // 相等

        if( astatr==bstatr  aend==bend )  return true;

        return false;

    }

    // 功能 工具 扩展

        public static boolean isContain(String astatr,String aend, String bstatr,String bend) {

            return isContain(new String[]{astatr , aend}, new String[]{bstatr , bend});

        }

        public static boolean isContain(String[] aStr, String[] bStr) {

            return isContain(aStr, bStr, "yyyy-MM-dd HH:mm:ss");

        }

        public static boolean isContain(String[] aStr, String[] bStr, String pattern) {

            final SimpleDateFormat SF = new SimpleDateFormat(pattern);

            try {

                return isContain(new Date[]{SF.parse(aStr[0]), SF.parse(aStr[1])} , new Date[]{SF.parse(bStr[0]), SF.parse(bStr[1])});

            } catch (Exception e) {

                e.printStackTrace();

            }

            return false;

        }

        public static boolean isContainEnd(String astatr,String aend, String bstatr,String bend) {

            return isContainEnd(new String[]{astatr , aend}, new String[]{bstatr , bend});

        }

        public static boolean isContainEnd(String[] aStr, String[] bStr) {

            return isContainEnd(aStr, bStr, "yyyy-MM-dd HH:mm:ss");

        }

        public static boolean isContainEnd(String[] aStr, String[] bStr, String pattern) {

            final SimpleDateFormat SF = new SimpleDateFormat(pattern);

            try {

                return isContainEnd(new Date[]{SF.parse(aStr[0]), SF.parse(aStr[1])} , new Date[]{SF.parse(bStr[0]), SF.parse(bStr[1])});

            } catch (Exception e) {

                e.printStackTrace();

            }

            return false;

        }

}

public static void main(String[] args) throws ParseException {        final SimpleDateFormat SF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date[] a = {SF.parse("2017-07-06 11:53:00"), SF.parse("2017-07-06 14:52:00")};

        Date[] b = {SF.parse("2017-07-06 14:52:00"), SF.parse("2017-07-06 16:52:00")};

        System.out.println("您好, 智能的电脑! 请问:");

        for (Date date : a) {

            System.out.print(date.toString() + " ~  ");

        }

        System.out.println("包含:");

        for (Date date : b) {

            System.out.print(date.toString() + " ~  ");

        }

        System.out.println("吗?");

        boolean ret = DateKit.isContain(a, b);

        System.out.println("o(∩_∩)o 哈哈 ~ 我猜是: " + ret);

        ret = DateKit.isContainEnd(a, b);

        System.out.println("o(∩_∩)o 哈哈 ~ 允许首尾相等 我猜是: " + ret);

    }

分享~

关于java判断两个时间段和java判断两个时间大小的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。