Java 生成随机出生日期

我正试图使用Java程序在我的数据库中为人们生成一个随机的出生日期。我该怎么做呢？

java.util.Date

有一个从纪元开始接受毫秒的值，而

java.util.Random

有一个可以给你随机毫秒数的值。您需要根据所需的DOB范围设置随机值的范围，但这些应该可以做到这一点

非常大致如下：

Random  rnd;
Date    dt;
long    ms;

// Get a new random instance, seeded from the clock
rnd = new Random();

// Get an Epoch value roughly between 1940 and 2010
// -946771200000L = January 1, 1940
// Add up to 70 years to it (using modulus on the next long)
ms = -946771200000L + (Math.abs(rnd.nextLong()) % (70L * 365 * 24 * 60 * 60 * 1000));

// Construct a date
dt = new Date(ms);

---

你需要定义一个随机日期，对吗

一种简单的方法是使用

long

（）生成一个新的

Date

对象，并减去一个随机

long

：

new Date(Math.abs(System.currentTimeMillis() - RandomUtils.nextLong()));

（摘自Apache Commons Lang）

当然，这远不是一个真正的随机日期（例如，你不会在1970年之前得到日期），但我认为这将足以满足你的需要

否则，您可以使用类创建自己的日期：

---

生成随机出生日期：

import java.util.Calendar;

public class Main {
  public static void main(String[] args) {
    for (int i = 0; i < 100; i++) {
        System.out.println(randomDOB());
    }
  }

  public static String randomDOB() {

    int yyyy = random(1900, 2013);
    int mm = random(1, 12);
    int dd = 0; // will set it later depending on year and month

    switch(mm) {
      case 2:
        if (isLeapYear(yyyy)) {
          dd = random(1, 29);
        } else {
          dd = random(1, 28);
        }
        break;

      case 1:
      case 3:
      case 5:
      case 7:
      case 8:
      case 10:
      case 12:
        dd = random(1, 31);
        break;

      default:
        dd = random(1, 30);
      break;
    }

    String year = Integer.toString(yyyy);
    String month = Integer.toString(mm);
    String day = Integer.toString(dd);

    if (mm < 10) {
        month = "0" + mm;
    }

    if (dd < 10) {
        day = "0" + dd;
    }

    return day + '/' + month + '/' + year;
  }

  public static int random(int lowerBound, int upperBound) {
    return (lowerBound + (int) Math.round(Math.random()
            * (upperBound - lowerBound)));
  }

  public static boolean isLeapYear(int year) {
    Calendar calendar = Calendar.getInstance();
    calendar.set(Calendar.YEAR, year);
    int noOfDays = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);

    if (noOfDays > 365) {
        return true;
    }

    return false;
  }
}

import java.util.Calendar；
公共班机{
公共静态void main（字符串[]args）{
对于（int i=0；i<100；i++）{
System.out.println（randomDOB（））；
}
}
公共静态字符串randomb（）{
int yyyy=随机（1900年，2013年）；
int mm=随机（1,12）；
int dd=0；//将在以后根据年份和月份进行设置
开关（毫米）{
案例2：
如果（年（yyyy））{
dd=随机（1,29）；
}否则{
dd=随机（1,28）；
}
打破
案例1：
案例3：
案例5：
案例7：
案例8：
案例10：
案例12：
dd=随机（1,31）；
打破
违约：
dd=随机（1,30）；
打破
}
字符串year=Integer.toString（yyyy）；
字符串月份=整数。toString（mm）；
String day=Integer.toString（dd）；
如果（毫米<10）{
月份=“0”+mm；
}
如果（dd<10）{
day=“0”+dd；
}
返回日+'/'+月+'/'+年；
}
公共静态int随机（int下限，int上限）{
return（lowerBound+（int）Math.round（Math.random（））
*（上界-下界））；
}
公共静态布尔值isLeapYear（整数年）{
日历=Calendar.getInstance（）；
calendar.set（calendar.YEAR，YEAR）；
int noOfDays=calendar.getActualMaximum（calendar.DAY/年）；
如果（中午>365）{
返回true；
}
返回false；
}
}

我正在学习Scala，最后在谷歌上搜索Java解决方案，在范围之间选择一个随机日期。我发现这篇文章非常有用，这是我的最终解决方案。希望它能帮助未来的Scala和Java程序员

import java.sql.Timestamp

def date_rand(ts_start_str:String = "2012-01-01 00:00:00", ts_end_str:String = "2015-01-01 00:00:00"): String = {
    val ts_start = Timestamp.valueOf(ts_start_str).getTime()
    val ts_end = Timestamp.valueOf(ts_end_str).getTime()
    val diff = ts_end - ts_start
    println(diff)
    val ts_rand = new Timestamp(ts_start + (Random.nextFloat() * diff).toLong)
    return ts_rand.toString
}                                         //> date_rand: (ts_start_str: String, ts_end_str: String)String

println(date_rand())                      //> 94694400000
                                              //| 2012-10-28 18:21:13.216

println(date_rand("2001-01-01 00:00:00", "2001-01-01 00:00:00"))
                                              //> 0
                                              //| 2001-01-01 00:00:00.0
println(date_rand("2001-01-01 00:00:00", "2010-01-01 00:00:00"))
                                              //> 283996800000
                                              //| 2008-02-16 23:15:48.864                    //> 2013-12-21 08:32:16.384

---

基于Java 8的解决方案的代码段：

Random random = new Random();
int minDay = (int) LocalDate.of(1900, 1, 1).toEpochDay();
int maxDay = (int) LocalDate.of(2015, 1, 1).toEpochDay();
long randomDay = minDay + random.nextInt(maxDay - minDay);

LocalDate randomBirthDate = LocalDate.ofEpochDay(randomDay);

System.out.println(randomBirthDate);

注意：这会生成1900年1月1日（含）到2015年1月1日（不含）之间的随机日期

注意：它基于，即相对于1970年1月1日的天数（）-历元后的积极意义，历元前的消极意义

---

您还可以创建一个小型实用程序类：

public class RandomDate {
    private final LocalDate minDate;
    private final LocalDate maxDate;
    private final Random random;

    public RandomDate(LocalDate minDate, LocalDate maxDate) {
        this.minDate = minDate;
        this.maxDate = maxDate;
        this.random = new Random();
    }

    public LocalDate nextDate() {
        int minDay = (int) minDate.toEpochDay();
        int maxDay = (int) maxDate.toEpochDay();
        long randomDay = minDay + random.nextInt(maxDay - minDay);
        return LocalDate.ofEpochDay(randomDay);
    }

    @Override
    public String toString() {
        return "RandomDate{" +
                "maxDate=" + maxDate +
                ", minDate=" + minDate +
                '}';
    }
}

然后像这样使用它：

RandomDate rd = new RandomDate(LocalDate.of(1900, 1, 1), LocalDate.of(2010, 1, 1));
System.out.println(rd.nextDate());
System.out.println(rd.nextDate()); // birthdays ad infinitum

您可以签出以生成随机数据。此库有助于从给定的模型类创建随机数据。签出下面的示例代码

public class Person {

    @DateValue( from = "01 Jan 1990",to = "31 Dec 2002" , customFormat = "dd MMM yyyy")
    String dateOfBirth;

}

//Generate random 100 Person(Model Class) object 
Generator<Person> generator = new Generator<>(Person.class);  
List<Person> persons = generator.generate(100);                          

公共类人物{
@日期值（从“1990年1月1日”到“2002年12月31日”，customFormat=“dd MMM yyyy”）
出生日期字符串；
}
//生成随机100人（模型类）对象
发电机=新发电机（人员等级）；
列表人员=生成器生成（100）；

由于有许多内置数据生成器可以使用注释进行访问，所以您也可以构建自定义数据生成器。我建议您阅读库页面上提供的文档

看看这个方法：

public static Date dateRandom(int initialYear, int lastYear) {
    if (initialYear > lastYear) {
        int year = lastYear;
        lastYear = initialYear;
        initialYear = year;
    }

    Calendar cInitialYear = Calendar.getInstance();
    cInitialYear.set(Calendar.YEAR, 2015);
    long offset = cInitialYear.getTimeInMillis();

    Calendar cLastYear = Calendar.getInstance();
    cLastYear.set(Calendar.YEAR, 2016);
    long end = cLastYear.getTimeInMillis();

    long diff = end - offset + 1;
    Timestamp timestamp = new Timestamp(offset + (long) (Math.random() * diff));
    return new Date(timestamp.getTime());
}

---

如果您不介意在代码中添加新库，您可以使用（免责声明：我是作者之一）

---

对于Java8->假设出生数据必须在当天之前：

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Period;
import java.time.temporal.ChronoUnit;
import java.util.Random;

public class RandomDate {

    public static LocalDate randomBirthday() {
        return LocalDate.now().minus(Period.ofDays((new Random().nextInt(365 * 70))));
    }

    public static void main(String[] args) {
        System.out.println("randomDate: " + randomBirthday());
    }
}

---

我认为这会起作用：

public static void main(String[] args) {
    Date now = new Date();
    long sixMonthsAgo = (now.getTime() - 15552000000l);
    long today = now.getTime();

    for(int i=0; i<10; i++) {
        long ms = ThreadLocalRandom.current().nextLong(sixMonthsAgo, today);

        Date date = new Date(ms);

        System.out.println(date.toString());
    }

}

publicstaticvoidmain（字符串[]args）{
现在日期=新日期（）；
long sixMonthsAgo=（now.getTime（）-1555200000l）；
long today=now.getTime（）；
对于（int i=0；i，如果您不介意使用第三方库，那么该库具有一个生成随机java.util.Dates以及java 8中的所有日期、时间、实例和持续时间的

它位于Maven中央存储库中，位于：

<dependency>
  <groupId>com.github.rkumsher</groupId>
  <artifactId>utils</artifactId>
  <version>1.3</version>
</dependency>


com.github.rkumsher
乌提尔斯
1.3
最简单的方法：

public static LocalDate randomDateOfBirth() {
    final int maxAge = 100 * 12 * 31;
    return LocalDate.now().minusDays(new Random().nextInt(maxAge));
}

int num=0；
char[]a={'a'，'b'，'c'，'d'，'e'，'f'}；
字符串错误=null；
试一试{
num=Integer.parseInt（request.getParameter（“num”）；
随机r=新随机（）；
long currentDate=新日期（）.getTime（）；
ArrayList=新建ArrayList（）；
for（int i=0；i
请不要使用谜语首字母缩写；）这不是一个统一的分布，因为例如在2月份，应该会有更少的人。@lbalazscs-的确。我更新了这个示例，现在应该更好一些。为了完整性，您应该通过
日历
类使用访问常量（
Calendar.YEAR
，
Calendar.DAY\u OF u YEAR
）不是通过实例
gc
。这个答案很旧，但月份是从0开始计算的。因此一月的结果是0。要打印实际日期，必须打印
（gc.get（gc.month）+1）
@Maze-即使几年过去了，有些答案仍然有用，而且相关，但你的观察是完全准确的。修复了它。这正是我开始思考的
public static void main(String[] args) {
    Date now = new Date();
    long sixMonthsAgo = (now.getTime() - 15552000000l);
    long today = now.getTime();

    for(int i=0; i<10; i++) {
        long ms = ThreadLocalRandom.current().nextLong(sixMonthsAgo, today);

        Date date = new Date(ms);

        System.out.println(date.toString());
    }

}

LocalDate birthDate = RandomDateUtils.randomPastLocalDate();
LocalDate today = LocalDate.now();
LocalDate under18YearsOld = RandomDateUtils.randomLocalDate(today.minus(18, YEARS), today);
LocalDate over18YearsOld = RandomDateUtils.randomLocalDateBefore(today.minus(18, YEARS));

<dependency>
  <groupId>com.github.rkumsher</groupId>
  <artifactId>utils</artifactId>
  <version>1.3</version>
</dependency>

public static LocalDate randomDateOfBirth() {
    final int maxAge = 100 * 12 * 31;
    return LocalDate.now().minusDays(new Random().nextInt(maxAge));
}

int num = 0;
char[] a={'a','b','c','d','e','f'};
String error = null;
try {
    num = Integer.parseInt(request.getParameter("num"));
    Random r = new Random();
    long currentDate = new Date().getTime();
    ArrayList<Student> list = new ArrayList<>();
    for (int i = 0; i < num; i++) {
        String name = "";
        for (int j = 0; j < 6; j++) {
            name += a[r.nextInt(5)];
        }

        list.add(new Student(i + 1, name, r.nextBoolean(), new Date(Math.abs(r.nextLong() % currentDate))));
    }

    request.setAttribute("list", list);
    request.setAttribute("num", num);
    request.getRequestDispatcher("student.jsp").forward(request, response);
} catch (NumberFormatException e) {
    error = "Please enter interger number";
    request.setAttribute("error", error);
    request.getRequestDispatcher("student.jsp").forward(request, response);
}