在java中Calendar和Data使用before或after比较为什么总为false

在Java中，Calendar和Date类的before和after方法用于比较两个日期的先后顺序。如果一个日期在另一个日期之前，则before方法返回true，而after方法返回false。如果两个日期相同，则before和after方法都返回false。

如果你在使用before或after方法时总是得到false的结果，可能是因为你没有正确设置日期或时间。请确保使用的日期对象中包含正确的年份、月份、日期和时间信息。此外，还需要注意，Calendar和Date类的时间值是以毫秒为单位表示的，因此在比较日期时，需要对毫秒进行精确的比较。

以下是一个示例，演示如何使用Calendar类的before和after方法比较两个日期的先后顺序：

Calendar cal1 = Calendar.getInstance();
cal1.set(2021, 9, 1); //设置日期为2021年10月1日

Calendar cal2 = Calendar.getInstance();
cal2.set(2021, 10, 1); //设置日期为2021年11月1日

if (cal1.before(cal2)) {
    System.out.println("cal1 在 cal2之前");
} else {
    System.out.println("cal1 在 cal2之后");
}

输出结果应该为：“cal1 在 cal2之前”。

相关问题

private final CharSequence getSmallTime() { Context context = getContext(); boolean is24 = DateFormat.is24HourFormat(context); LocaleData d = LocaleData.get(context.getResources().getConfiguration().locale); final char MAGIC1 = '\uEF00'; final char MAGIC2 = '\uEF01'; SimpleDateFormat sdf; String format = is24 ? d.timeFormat24 : d.timeFormat12; // Add seconds to the format string format += ":ss"; if (!format.equals(mClockFormatString)) { /* * Search for an unquoted "a" in the format string, so we can * add dummy characters around it to let us find it again after * formatting and change its size. */ if (AM_PM_STYLE != AM_PM_STYLE_NORMAL) { int a = -1; boolean quoted = false; for (int i = 0; i < format.length(); i++) { char c = format.charAt(i); if (c == ''') { quoted = !quoted; } if (!quoted && c == 'a') { a = i; break; } } if (a >= 0) { // Move a back so any whitespace before AM/PM is also in the alternate size. final int b = a; while (a > 0 && Character.isWhitespace(format.charAt(a-1))) { a--; } format = format.substring(0, a) + MAGIC1 + format.substring(a, b) + "a" + MAGIC2 + format.substring(b + 1); } } mClockFormat = sdf = new SimpleDateFormat(format); mClockFormatString = format; } else { sdf = mClockFormat; } String result = sdf.format(mCalendar.getTime()); if (AM_PM_STYLE != AM_PM_STYLE_NORMAL) { int magic1 = result.indexOf(MAGIC1); int magic2 = result.indexOf(MAGIC2); if (magic1 >= 0 && magic2 > magic1) { SpannableStringBuilder formatted = new SpannableStringBuilder(result); if (AM_PM_STYLE == AM_PM_STYLE_GONE) { formatted.delete(magic1, magic2+1); } else { if (AM_PM_STYLE == AM_PM_STYLE_SMALL) { CharacterStyle style = new RelativeSizeSpan(0.7f); formatted.setSpan(style, magic1, magic2, Spannable.SPAN_EXCLUSIVE_INCLUSIVE); } formatted.delete(magic2, magic2 + 1); formatted.delete(magic1, magic1 + 1); } return formatted; } } return result;}如何实时更新秒

可以通过使用定时器或者Handler来实现每秒更新一次秒数。具体实现方法如下：

1.在构造函数或onCreate()方法中初始化定时器或Handler。

2.定时器或Handler中的回调方法中，调用invalidate()方法刷新UI界面。

示例代码如下：

private final CharSequence getSmallTime() {
    Context context = getContext();
    boolean is24 = DateFormat.is24HourFormat(context);
    LocaleData d = LocaleData.get(context.getResources().getConfiguration().locale);

    final char MAGIC1 = '\uEF00';
    final char MAGIC2 = '\uEF01';

    SimpleDateFormat sdf;
    String format = is24 ? d.timeFormat24 : d.timeFormat12;

    // Add seconds to the format string
    format += ":ss";

    if (!format.equals(mClockFormatString)) {
        /*
         * Search for an unquoted "a" in the format string, so we can
         * add dummy characters around it to let us find it again after
         * formatting and change its size.
         */
        if (AM_PM_STYLE != AM_PM_STYLE_NORMAL) {
            int a = -1;
            boolean quoted = false;
            for (int i = 0; i < format.length(); i++) {
                char c = format.charAt(i);
                if (c == ''') {
                    quoted = !quoted;
                }
                if (!quoted && c == 'a') {
                    a = i;
                    break;
                }
            }
            if (a >= 0) {
                // Move a back so any whitespace before AM/PM is also in the alternate size.
                final int b = a;
                while (a > 0 && Character.isWhitespace(format.charAt(a-1))) {
                    a--;
                }
                format = format.substring(0, a) + MAGIC1 + format.substring(a, b) + "a" + MAGIC2 + format.substring(b + 1);
            }
        }
        mClockFormat = sdf = new SimpleDateFormat(format);
        mClockFormatString = format;
    } else {
        sdf = mClockFormat;
    }

    mCalendar.setTimeInMillis(System.currentTimeMillis()); // 更新Calendar对象

    String result = sdf.format(mCalendar.getTime());

    if (AM_PM_STYLE != AM_PM_STYLE_NORMAL) {
        int magic1 = result.indexOf(MAGIC1);
        int magic2 = result.indexOf(MAGIC2);
        if (magic1 >= 0 && magic2 > magic1) {
            SpannableStringBuilder formatted = new SpannableStringBuilder(result);
            if (AM_PM_STYLE == AM_PM_STYLE_GONE) {
                formatted.delete(magic1, magic2+1);
            } else {
                if (AM_PM_STYLE == AM_PM_STYLE_SMALL) {
                    CharacterStyle style = new RelativeSizeSpan(0.7f);
                    formatted.setSpan(style, magic1, magic2, Spannable.SPAN_EXCLUSIVE_INCLUSIVE);
                }
                formatted.delete(magic2, magic2 + 1);
                formatted.delete(magic1, magic1 + 1);
            }
            return formatted;
        }
    }
    return result;
}

在构造函数或onCreate()方法中添加以下代码：

// 定义Handler
private Handler mHandler = new Handler();

// 定义Runnable
private Runnable mRunnable = new Runnable() {
    @Override
    public void run() {
        invalidate(); // 刷新UI界面
        mHandler.postDelayed(mRunnable, 1000); // 每秒执行一次
    }
};

// 在构造函数或onCreate()方法中启动定时器
mHandler.postDelayed(mRunnable, 1000);

这样就可以实现每秒更新秒数了。

java定时任务，每天凌晨三点，迁移数据，然后将30天之前的数据del属性改为10，删除del为10的数据，核对数据是否正确

以下是Java代码实现：

import java.time.LocalTime;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.Calendar;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.transaction.Transactional;

public class DailyDataMigrationJob {

    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public void migrateData() {
        // 获取当前时间
        LocalDateTime now = LocalDateTime.now();
        // 获取今天凌晨三点的时间
        LocalDateTime migrateTime = LocalDateTime.of(LocalDate.now(), LocalTime.of(3, 0));
        // 如果当前时间在凌晨三点之前，则需要将迁移时间设置为昨天的凌晨三点
        if (now.isBefore(migrateTime)) {
            migrateTime = migrateTime.minusDays(1);
        }
        // 获取迁移时间的日期
        LocalDate migrateDate = migrateTime.toLocalDate();
        // 获取迁移时间的前一天日期
        LocalDate previousDate = migrateDate.minusDays(1);
        // 获取迁移时间的前30天日期
        LocalDate thirtyDaysAgo = migrateDate.minusDays(30);
        // 获取迁移时间的当天凌晨时间
        LocalDateTime migrateDateTime = LocalDateTime.of(migrateDate, LocalTime.of(0, 0));
        // 获取迁移时间的前一天晚上11点59分59秒的时间
        LocalDateTime previousDateTime = LocalDateTime.of(previousDate, LocalTime.of(23, 59, 59));
        // 获取迁移时间的前30天凌晨时间
        LocalDateTime thirtyDaysAgoDateTime = LocalDateTime.of(thirtyDaysAgo, LocalTime.of(0, 0));
        // 获取迁移时间的前30天晚上11点59分59秒的时间
        LocalDateTime thirtyDaysAgoEndDateTime = LocalDateTime.of(thirtyDaysAgo, LocalTime.of(23, 59, 59));
        // 如果当前时间在迁移时间之前，直接返回
        if (now.isBefore(migrateDateTime)) {
            return;
        }
        // 如果当前时间在迁移时间到前一天晚上11点59分59秒之间，执行迁移操作
        if (now.isBefore(previousDateTime)) {
            // 查询需要迁移的数据
            List<Data> dataToMigrate = entityManager.createQuery("SELECT d FROM Data d WHERE d.createTime >= :thirtyDaysAgo AND d.createTime <= :previousDateTime", Data.class)
                    .setParameter("thirtyDaysAgo", Date.from(thirtyDaysAgoDateTime.atZone(ZoneId.systemDefault()).toInstant()))
                    .setParameter("previousDateTime", Date.from(previousDateTime.atZone(ZoneId.systemDefault()).toInstant()))
                    .getResultList();
            // 修改30天之前的数据的del属性为10
            for (Data data : dataToMigrate) {
                data.setDel(10);
            }
            // 删除del为10的数据
            entityManager.createQuery("DELETE FROM Data d WHERE d.del = 10")
                    .executeUpdate();
            // 提交事务
            entityManager.flush();
            entityManager.clear();
            // 核对数据是否正确
            long migratedDataCount = entityManager.createQuery("SELECT COUNT(d) FROM Data d WHERE d.del = 10", Long.class)
                    .getSingleResult();
            if (migratedDataCount == dataToMigrate.size()) {
                System.out.println("数据迁移成功，共迁移了 " + migratedDataCount + " 条数据");
            } else {
                System.out.println("数据迁移失败，实际迁移了 " + migratedDataCount + " 条数据，期望迁移 " + dataToMigrate.size() + " 条数据");
            }
        }
        // 如果当前时间在前一天晚上11点59分59秒之后，执行删除操作
        if (now.isAfter(previousDateTime)) {
            // 删除del为10的数据
            int deletedCount = entityManager.createQuery("DELETE FROM Data d WHERE d.del = 10")
                    .executeUpdate();
            // 提交事务
            entityManager.flush();
            entityManager.clear();
            // 核对数据是否正确
            long remainingDataCount = entityManager.createQuery("SELECT COUNT(d) FROM Data d", Long.class)
                    .getSingleResult();
            if (remainingDataCount == deletedCount) {
                System.out.println("数据删除成功，共删除了 " + deletedCount + " 条数据");
            } else {
                System.out.println("数据删除失败，实际删除了 " + deletedCount + " 条数据，期望删除 " + remainingDataCount + " 条数据");
            }
        }
    }

}

以上代码中，假设需要迁移的数据实体类为`Data`，其中包含一个名为`del`的属性表示是否删除，初始值为0表示未删除，10表示已删除。`Data`类的代码如下：

import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Data {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private int del;

    private Date createTime;

    // 省略getter和setter方法

}

在以上代码中，`@PersistenceContext`注解表示通过依赖注入获取`EntityManager`对象，`@Transactional`注解表示该方法需要在事务中执行。在`migrateData()`方法中，首先获取当前时间和需要迁移的时间，然后判断当前时间是否在迁移时间之前，如果是，则直接返回；如果不是，则判断当前时间是否在迁移时间到前一天晚上11点59分59秒之间，如果是，则执行迁移操作；否则执行删除操作。在迁移操作中，首先查询需要迁移的数据，然后修改30天之前的数据的del属性为10，删除del为10的数据，最后提交事务并核对数据是否正确。在删除操作中，直接删除del为10的数据，最后提交事务并核对数据是否正确。如果数据核对正确，则输出操作成功的信息，否则输出操作失败的信息。