如何计算Java中某人的年龄?


147

我想以Java方法的整数形式返回年龄(以年为单位)。我现在所拥有的是getBirthDate()返回一个Date对象(带有出生日期;-)的以下内容:

public int getAge() {
    long ageInMillis = new Date().getTime() - getBirthDate().getTime();

    Date age = new Date(ageInMillis);

    return age.getYear();
}

但是由于不赞成使用getYear(),所以我想知道是否有更好的方法可以做到这一点?我什至不确定这是否能正常工作,因为我还没有进行单元测试。


我改变了主意:另一个问题只是日期之间的近似年份,而不是真正正确的年龄。
cletus

考虑到他要返回一个整数,您能否阐明“正确”年龄的含义?
Brian Agnew

2
日期与日历是一个基本概念,可以从阅读Java文档中了解。我不明白为什么要这么大赞成。
demongolem

@demongolem ??? 日期和日历容易理解吗?一点都不。关于堆栈溢出,这里有不计其数的问题。Joda-Time项目产生了最受欢迎的库之一,以替代那些麻烦的日期时间类。后来,Sun,Oracle和JCP社区接受了JSR 310java.time),承认遗留类不足以望而却步。有关更多信息,请参见Oracle 教程
罗勒·布尔克

Answers:


159

JDK 8使这个变得轻松而优雅:

public class AgeCalculator {

    public static int calculateAge(LocalDate birthDate, LocalDate currentDate) {
        if ((birthDate != null) && (currentDate != null)) {
            return Period.between(birthDate, currentDate).getYears();
        } else {
            return 0;
        }
    }
}

一个JUnit测试以证明其用法:

public class AgeCalculatorTest {

    @Test
    public void testCalculateAge_Success() {
        // setup
        LocalDate birthDate = LocalDate.of(1961, 5, 17);
        // exercise
        int actual = AgeCalculator.calculateAge(birthDate, LocalDate.of(2016, 7, 12));
        // assert
        Assert.assertEquals(55, actual);
    }
}

现在每个人都应该使用JDK 8。所有较早的版本都已终止其支持寿命。


10
在处理leap年时,DAY_OF_YEAR比较可能导致错误的结果。
sinuhepop 2012年

1
变量dateOfBirth必须是Date对象。如何创建带有出生日期的Date对象?
Erick

鉴于我们已经9年了,并且在使用Java 8的情况下,这应该是要使用的解决方案。
nojevive

JDK 9是当前的生产版本。比以往更真实。
duffymo '18

2
@SteveOh我不同意。我宁愿完全不接受nulls,而是使用Objects.requireNonNull
MC Emperor

170

查看Joda,它简化了日期/时间计算(Joda还是新的标准Java日期/时间api的基础,因此您将学习即将成为标准的API)。

编辑:Java 8有一些非常相似的东西,值得一试。

例如

LocalDate birthdate = new LocalDate (1970, 1, 20);
LocalDate now = new LocalDate();
Years age = Years.yearsBetween(birthdate, now);

这就像您想要的那样简单。Java 8之前的版本(您已经确定)有点不直观。


2
@HoàngLong:来自JavaDocs:“此类不代表一天,而是午夜的毫秒级。如果您需要代表一整天的类,则Interval或LocalDate可能更合适。” 我们真的希望在这里表示日期。
乔恩·斯基特

如果要按照@JohnSkeet的建议进行操作,则如下所示:Years age = Years.yearsBetween(new LocalDate(getBirthDate()),new LocalDate());
Fletch 2012年

不知道为什么我使用DateMidnight,现在我注意到它已被弃用。现在更改为使用LocalDate
Brian Agnew

2
@Bor-joda-time.sourceforge.net/ apidocs
Brian Agnew

2
@IgorGanapolsky实际上,主要区别在于:Joda-Time使用构造函数,而Java-8和ThreetenBP使用静态工厂方法。对于Joda-Time计算年龄的方式中的一个细微错误,请查看我的回答,其中概述了不同库的行为。
Meno Hochschild

43
Calendar now = Calendar.getInstance();
Calendar dob = Calendar.getInstance();
dob.setTime(...);
if (dob.after(now)) {
  throw new IllegalArgumentException("Can't be born in the future");
}
int year1 = now.get(Calendar.YEAR);
int year2 = dob.get(Calendar.YEAR);
int age = year1 - year2;
int month1 = now.get(Calendar.MONTH);
int month2 = dob.get(Calendar.MONTH);
if (month2 > month1) {
  age--;
} else if (month1 == month2) {
  int day1 = now.get(Calendar.DAY_OF_MONTH);
  int day2 = dob.get(Calendar.DAY_OF_MONTH);
  if (day2 > day1) {
    age--;
  }
}
// age is now correct

是的,日历班很糟糕。不幸的是,有时在工作中我必须使用它:/。感谢Cletus发布此消息
Steve

1
将Calendar.MONTH和Calendar.DAY_OF_MONTH替换为Calendar.DAY_OF_YEAR,这样至少会更清洁
Tobbbe

@Tobbbe如果您在a年的3月1日出生,那么您的生日是在第二年的3月1日,而不是第二年。DAY_OF_YEAR无法使用。
Airsource Ltd

42

现代答案和概述

a)Java-8(java.time-package)

LocalDate start = LocalDate.of(1996, 2, 29);
LocalDate end = LocalDate.of(2014, 2, 28); // use for age-calculation: LocalDate.now()
long years = ChronoUnit.YEARS.between(start, end);
System.out.println(years); // 17

请注意,该表达式LocalDate.now()与系统时区隐式相关(用户经常忽略它)。为了清楚起见,通常最好使用重载方法now(ZoneId.of("Europe/Paris"))指定一个明确的时区(此处以“欧洲/巴黎”为例)。如果请求系统时区,那么我个人的喜好是写信LocalDate.now(ZoneId.systemDefault())以使与系统时区的关系更清晰。这会花费更多的精力,但会使阅读更容易。

b)乔达时代

请注意,对于上面显示的日期,建议的和接受的Joda-Time-solution产生不同的计算结果(一种罕见的情况),即:

LocalDate birthdate = new LocalDate(1996, 2, 29);
LocalDate now = new LocalDate(2014, 2, 28); // test, in real world without args
Years age = Years.yearsBetween(birthdate, now);
System.out.println(age.getYears()); // 18

我认为这是一个小错误,但Joda小组对此怪异的行为持有不同的看法,并且不想解决此问题(这很奇怪,因为结束日期的月日小于开始日期,因此年份应为少一个)。另请参阅此已解决的问题

c)java.util.Calendar等

为了进行比较,请参见其他答案。我根本不建议使用这些过时的类,因为考虑到原始问题听起来很简单,在某些特殊情况下,结果代码仍然容易出错和/或过于复杂。在2015年,我们的图书馆确实更好。

d)关于Date4J:

所提出的解决方案很简单,但是在leap年的情况下有时会失败。仅评估一年中的日期是不可靠的。

e)我自己的图书馆Time4J

这类似于Java-8解决方案。只需更换LocalDatePlainDateChronoUnit.YEARS通过CalendarUnit.YEARS。但是,“今天”需要明确的时区参考。

PlainDate start = PlainDate.of(1996, 2, 29);
PlainDate end = PlainDate.of(2014, 2, 28);
// use for age-calculation (today): 
// => end = SystemClock.inZonalView(EUROPE.PARIS).today();
// or in system timezone: end = SystemClock.inLocalView().today();
long years = CalendarUnit.YEARS.between(start, end);
System.out.println(years); // 17

1
感谢您使用Java 8版本!为我节省了一些时间:)现在,我只需要弄清楚如何提取剩余的几个月。例如1年零1个月。:)
thomas77

2
@ thomas77感谢您的答复,可以在Java-8中使用`java.time.Period'完成数年和数月(甚至数天)的合并。如果您还希望考虑小时数等其他单位,那么Java-8不会提供解决方案。
Meno Hochschild 2015年

再次感谢您(以及快速响应):)
thomas77

1
我建议在使用时指定一个时区LocalDate.now。如果省略,则隐式应用JVM的当前默认时区。该默认值可以在机器/操作系统/设置之间更改,也可以在运行时的任何时候通过任何代码调用来更改setDefault。我建议您具体说明,例如LocalDate.now( ZoneId.for( "America/Montreal" ) )
Basil Bourque

1
@GoCrafter_LP是的,对于此类较旧的Android版本,您可以应用ThreetenABP模拟Java-8或Joda-Time-Android(来自D. Lew)或我的lib Time4A。
Meno Hochschild

17
/**
 * This Method is unit tested properly for very different cases , 
 * taking care of Leap Year days difference in a year, 
 * and date cases month and Year boundary cases (12/31/1980, 01/01/1980 etc)
**/

public static int getAge(Date dateOfBirth) {

    Calendar today = Calendar.getInstance();
    Calendar birthDate = Calendar.getInstance();

    int age = 0;

    birthDate.setTime(dateOfBirth);
    if (birthDate.after(today)) {
        throw new IllegalArgumentException("Can't be born in the future");
    }

    age = today.get(Calendar.YEAR) - birthDate.get(Calendar.YEAR);

    // If birth date is greater than todays date (after 2 days adjustment of leap year) then decrement age one year   
    if ( (birthDate.get(Calendar.DAY_OF_YEAR) - today.get(Calendar.DAY_OF_YEAR) > 3) ||
            (birthDate.get(Calendar.MONTH) > today.get(Calendar.MONTH ))){
        age--;

     // If birth date and todays date are of same month and birth day of month is greater than todays day of month then decrement age
    }else if ((birthDate.get(Calendar.MONTH) == today.get(Calendar.MONTH )) &&
              (birthDate.get(Calendar.DAY_OF_MONTH) > today.get(Calendar.DAY_OF_MONTH ))){
        age--;
    }

    return age;
}

2
检查的目的是(birthDate.get(Calendar.DAY_OF_YEAR) - today.get(Calendar.DAY_OF_YEAR) > 3)什么?月和日比较的存在似乎毫无意义。
杰德·沙夫

13

我只是使用一年常数中的毫秒数来发挥自己的优势:

Date now = new Date();
long timeBetween = now.getTime() - age.getTime();
double yearsBetween = timeBetween / 3.15576e+10;
int age = (int) Math.floor(yearsBetween);

2
这是不准确的答案...年不是3.156e + 10,而是3.15576e + 10(四分之一天!)
Maher Abuthraa

1
这不起作用,某些年份是leap年,并且具有不同的毫秒值
Greg Ennis,

12

如果使用的是GWT,则只能使用java.util.Date,这是一种将日期作为整数,但仍使用java.util.Date的方法:

public int getAge(int year, int month, int day) {
    Date now = new Date();
    int nowMonth = now.getMonth()+1;
    int nowYear = now.getYear()+1900;
    int result = nowYear - year;

    if (month > nowMonth) {
        result--;
    }
    else if (month == nowMonth) {
        int nowDay = now.getDate();

        if (day > nowDay) {
            result--;
        }
    }
    return result;
}

5

使用JodaTime的正确答案是:

public int getAge() {
    Years years = Years.yearsBetween(new LocalDate(getBirthDate()), new LocalDate());
    return years.getYears();
}

如果愿意,您甚至可以将其缩短为一行。我从BrianAgnew的答案中复制了这个想法,但我相信从您那里的评论中可以看到,这是更正确的(它可以准确地回答问题)。


4

使用date4j库:

int age = today.getYear() - birthdate.getYear();
if(today.getDayOfYear() < birthdate.getDayOfYear()){
  age = age - 1; 
}

4

这是上述版本的改进版本...考虑到您希望年龄为“ int”。因为有时您不想用一堆库填充程序。

public int getAge(Date dateOfBirth) {
    int age = 0;
    Calendar born = Calendar.getInstance();
    Calendar now = Calendar.getInstance();
    if(dateOfBirth!= null) {
        now.setTime(new Date());
        born.setTime(dateOfBirth);  
        if(born.after(now)) {
            throw new IllegalArgumentException("Can't be born in the future");
        }
        age = now.get(Calendar.YEAR) - born.get(Calendar.YEAR);             
        if(now.get(Calendar.DAY_OF_YEAR) < born.get(Calendar.DAY_OF_YEAR))  {
            age-=1;
        }
    }  
    return age;
}

4

也许令人惊讶地注意到,您不需要知道一年中有多少天或几个月,或者那些月份中有多少天,同样,您也不需要知道leap年,leap秒或任何其他信息。使用这种简单,100%准确的方法对这些东西进行处理:

public static int age(Date birthday, Date date) {
    DateFormat formatter = new SimpleDateFormat("yyyyMMdd");
    int d1 = Integer.parseInt(formatter.format(birthday));
    int d2 = Integer.parseInt(formatter.format(date));
    int age = (d2-d1)/10000;
    return age;
}

我正在寻找Java 6和5的解决方案。这很简单但很准确。
Jj Tuibeo

3

尝试将其复制到您的代码中,然后使用该方法获取年龄。

public static int getAge(Date birthday)
{
    GregorianCalendar today = new GregorianCalendar();
    GregorianCalendar bday = new GregorianCalendar();
    GregorianCalendar bdayThisYear = new GregorianCalendar();

    bday.setTime(birthday);
    bdayThisYear.setTime(birthday);
    bdayThisYear.set(Calendar.YEAR, today.get(Calendar.YEAR));

    int age = today.get(Calendar.YEAR) - bday.get(Calendar.YEAR);

    if(today.getTimeInMillis() < bdayThisYear.getTimeInMillis())
        age--;

    return age;
}

不鼓励仅使用代码的答案。最好解释一下为什么此代码可以解决OP问题。
рüффп

实际上,这没什么大不了的..但是它只会更新以解决您的问题
凯文(Kevin)

3

我将这段代码用于年龄计算,希望这对您有所帮助。

private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());

public static int calculateAge(String date) {

    int age = 0;
    try {
        Date date1 = dateFormat.parse(date);
        Calendar now = Calendar.getInstance();
        Calendar dob = Calendar.getInstance();
        dob.setTime(date1);
        if (dob.after(now)) {
            throw new IllegalArgumentException("Can't be born in the future");
        }
        int year1 = now.get(Calendar.YEAR);
        int year2 = dob.get(Calendar.YEAR);
        age = year1 - year2;
        int month1 = now.get(Calendar.MONTH);
        int month2 = dob.get(Calendar.MONTH);
        if (month2 > month1) {
            age--;
        } else if (month1 == month2) {
            int day1 = now.get(Calendar.DAY_OF_MONTH);
            int day2 = dob.get(Calendar.DAY_OF_MONTH);
            if (day2 > day1) {
                age--;
            }
        }
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return age ;
}

2

字段出生和影响都是日期字段:

Calendar bir = Calendar.getInstance();
bir.setTime(birth);
int birthNm = bir.get(Calendar.DAY_OF_YEAR);
int birthYear = bir.get(Calendar.YEAR);
Calendar eff = Calendar.getInstance();
eff.setTime(effect);

这基本上是对John O解决方案的修改,而没有使用折旧方法。我花了很多时间试图让他的代码在我的代码中工作。也许这样可以节省其他人的时间。


2
你能解释得更好一点吗?这如何计算年龄?
乔纳森·费舍尔

1

这个如何?

public Integer calculateAge(Date date) {
    if (date == null) {
        return null;
    }
    Calendar cal1 = Calendar.getInstance();
    cal1.setTime(date);
    Calendar cal2 = Calendar.getInstance();
    int i = 0;
    while (cal1.before(cal2)) {
        cal1.add(Calendar.YEAR, 1);
        i += 1;
    }
    return i;
}

这是一个非常可爱的建议(当您不使用Joda且不能使用Java 8时),但是该算法略有错误,因为直到第一年过去您都为0。因此,您需要在开始while循环之前为日期添加一年。
达格玛'18

1

String dateofbirth有出生日期。和格式是什么(在以下行中定义):

org.joda.time.format.DateTimeFormatter formatter =  org.joda.time.format.DateTimeFormat.forPattern("mm/dd/yyyy");

这是格式化方法:

org.joda.time.DateTime birthdateDate = formatter.parseDateTime(dateofbirth );
org.joda.time.DateMidnight birthdate = new         org.joda.time.DateMidnight(birthdateDate.getYear(), birthdateDate.getMonthOfYear(), birthdateDate.getDayOfMonth() );
org.joda.time.DateTime now = new org.joda.time.DateTime();
org.joda.time.Years age = org.joda.time.Years.yearsBetween(birthdate, now);
java.lang.String ageStr = java.lang.String.valueOf (age.getYears());

变量ageStr将具有年份。


1

基于Yaron Ronen解决方案的优雅,看似正确,基于时间戳差异的变体。

我包括一个单元测试,以证明何时以及为什么它是不正确的。由于任何时间戳差异,(天(和秒)的数量不同(是可能的),这是不可能的。对于该算法,差异应为最大+ -1天(和一秒),请参见test2(),而基于完全恒定假设的Yaron Ronen解决方案timeDiff / MILLI_SECONDS_YEAR对于40岁的孩子可能会相差10天,但是,此变体也不正确。

这很棘手,因为此改进的变体使用Formula diffAsCalendar.get(Calendar.YEAR) - 1970大部分时间返回正确的结果,因为two年的数量在两个日期之间平均相同。

/**
 * Compute person's age based on timestamp difference between birth date and given date
 * and prove it is INCORRECT approach.
 */
public class AgeUsingTimestamps {

public int getAge(Date today, Date dateOfBirth) {
    long diffAsLong = today.getTime() - dateOfBirth.getTime();
    Calendar diffAsCalendar = Calendar.getInstance();
    diffAsCalendar.setTimeInMillis(diffAsLong);
    return diffAsCalendar.get(Calendar.YEAR) - 1970; // base time where timestamp=0, precisely 1/1/1970 00:00:00 
}

    final static DateFormat df = new SimpleDateFormat("dd.MM.yyy HH:mm:ss");

    @Test
    public void test1() throws Exception {
        Date dateOfBirth = df.parse("10.1.2000 00:00:00");
        assertEquals(87, getAge(df.parse("08.1.2088 23:59:59"), dateOfBirth));
        assertEquals(87, getAge(df.parse("09.1.2088 23:59:59"), dateOfBirth));
        assertEquals(88, getAge(df.parse("10.1.2088 00:00:01"), dateOfBirth));
    }

    @Test
    public void test2() throws Exception {
        // between 2000 and 2021 was 6 leap days
        // but between 1970 (base time) and 1991 there was only 5 leap days
        // therefore age is switched one day earlier
            // See http://www.onlineconversion.com/leapyear.htm
        Date dateOfBirth = df.parse("10.1.2000 00:00:00");
        assertEquals(20, getAge(df.parse("08.1.2021 23:59:59"), dateOfBirth));
        assertEquals(20, getAge(df.parse("09.1.2021 23:59:59"), dateOfBirth)); // ERROR! returns incorrect age=21 here
        assertEquals(21, getAge(df.parse("10.1.2021 00:00:01"), dateOfBirth));
    }
}

1
public class CalculateAge { 

private int age;

private void setAge(int age){

    this.age=age;

}
public void calculateAge(Date date){

    Calendar calendar=Calendar.getInstance();

    Calendar calendarnow=Calendar.getInstance();    

    calendarnow.getTimeZone();

    calendar.setTime(date);

    int getmonth= calendar.get(calendar.MONTH);

    int getyears= calendar.get(calendar.YEAR);

    int currentmonth= calendarnow.get(calendarnow.MONTH);

    int currentyear= calendarnow.get(calendarnow.YEAR);

    int age = ((currentyear*12+currentmonth)-(getyears*12+getmonth))/12;

    setAge(age);
}
public int getAge(){

    return this.age;

}

0
/**
 * Compute from string date in the format of yyyy-MM-dd HH:mm:ss the age of a person.
 * @author Yaron Ronen
 * @date 04/06/2012  
 */
private int computeAge(String sDate)
{
    // Initial variables.
    Date dbDate = null;
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");      

    // Parse sDate.
    try
    {
        dbDate = (Date)dateFormat.parse(sDate);
    }
    catch(ParseException e)
    {
        Log.e("MyApplication","Can not compute age from date:"+sDate,e);
        return ILLEGAL_DATE; // Const = -2
    }

    // Compute age.
    long timeDiff = System.currentTimeMillis() - dbDate.getTime();      
    int age = (int)(timeDiff / MILLI_SECONDS_YEAR);  // MILLI_SECONDS_YEAR = 31558464000L;

    return age; 
}

不确定是否真的测试过此方法,但对于其他人,此方法有一个缺陷。如果今天是您生日的同一月,而今天<生日,则仍显示实际年龄+ 1,例如,如果您的生日是1986年9月7日,今天是2013年9月1日,则显示的是27岁26.
srahul07

2
这可能不正确,因为一年中的毫秒数不是恒定的。years年多一天,比其他年份多毫秒。对于40岁的人,您的算法可能会比生日提前9-10天报告生日!还有leap秒。
Espinosa

0

这是用于计算年,月和日的年龄的Java代码。

public static AgeModel calculateAge(long birthDate) {
    int years = 0;
    int months = 0;
    int days = 0;

    if (birthDate != 0) {
        //create calendar object for birth day
        Calendar birthDay = Calendar.getInstance();
        birthDay.setTimeInMillis(birthDate);

        //create calendar object for current day
        Calendar now = Calendar.getInstance();
        Calendar current = Calendar.getInstance();
        //Get difference between years
        years = now.get(Calendar.YEAR) - birthDay.get(Calendar.YEAR);

        //get months
        int currMonth = now.get(Calendar.MONTH) + 1;
        int birthMonth = birthDay.get(Calendar.MONTH) + 1;

        //Get difference between months
        months = currMonth - birthMonth;

        //if month difference is in negative then reduce years by one and calculate the number of months.
        if (months < 0) {
            years--;
            months = 12 - birthMonth + currMonth;
        } else if (months == 0 && now.get(Calendar.DATE) < birthDay.get(Calendar.DATE)) {
            years--;
            months = 11;
        }

        //Calculate the days
        if (now.get(Calendar.DATE) > birthDay.get(Calendar.DATE))
            days = now.get(Calendar.DATE) - birthDay.get(Calendar.DATE);
        else if (now.get(Calendar.DATE) < birthDay.get(Calendar.DATE)) {
            int today = now.get(Calendar.DAY_OF_MONTH);
            now.add(Calendar.MONTH, -1);
            days = now.getActualMaximum(Calendar.DAY_OF_MONTH) - birthDay.get(Calendar.DAY_OF_MONTH) + today;
        } else {
            days = 0;
            if (months == 12) {
                years++;
                months = 0;
            }
        }
    }

    //Create new Age object
    return new AgeModel(days, months, years);
}

0

没有任何库的最简单方法:

    long today = new Date().getTime();
    long diff = today - birth;
    long age = diff / DateUtils.YEAR_IN_MILLIS;

1
该代码使用麻烦的旧日期时间类,这些类现在已被遗留,由java.time类取代。而是使用Java:中内置的现代类ChronoUnit.YEARS.between( LocalDate.of( 1968 , Month.MARCH , 23 ) , LocalDate.now() )。看到正确的答案
Basil Bourque

DateUtils是图书馆
Terran

0

使用Java 8,我们可以用一行代码来计算一个人的年龄:

public int calCAge(int year, int month,int days){             
    return LocalDate.now().minus(Period.of(year, month, days)).getYear();         
}

年或月的年龄?那个月的宝宝怎么样?
gumuruh

-1
public int getAge(Date dateOfBirth) 
{
    Calendar now = Calendar.getInstance();
    Calendar dob = Calendar.getInstance();

    dob.setTime(dateOfBirth);

    if (dob.after(now)) 
    {
        throw new IllegalArgumentException("Can't be born in the future");
    }

    int age = now.get(Calendar.YEAR) - dob.get(Calendar.YEAR);

    if (now.get(Calendar.DAY_OF_YEAR) < dob.get(Calendar.DAY_OF_YEAR)) 
    {
        age--;
    }

    return age;
}

@sinuhepop注意到“在处理leap年时,DAY_OF_YEAR比较可能导致错误的结果”
Krzysztof Kot

-1
import java.io.*;

class AgeCalculator
{
    public static void main(String args[])
    {
        InputStreamReader ins=new InputStreamReader(System.in);
        BufferedReader hey=new BufferedReader(ins);

        try
        {
            System.out.println("Please enter your name: ");
            String name=hey.readLine();

            System.out.println("Please enter your birth date: ");
            String date=hey.readLine();

            System.out.println("please enter your birth month:");
            String month=hey.readLine();

            System.out.println("please enter your birth year:");
            String year=hey.readLine();

            System.out.println("please enter current year:");
            String cYear=hey.readLine();

            int bDate = Integer.parseInt(date);
            int bMonth = Integer.parseInt(month);
            int bYear = Integer.parseInt(year);
            int ccYear=Integer.parseInt(cYear);

            int age;

            age = ccYear-bYear;
            int totalMonth=12;
            int yourMonth=totalMonth-bMonth;

            System.out.println(" Hi " + name + " your are " + age + " years " + yourMonth + " months old ");
        }
        catch(IOException err)
        {
            System.out.println("");
        }
    }
}

-1
public int getAge(String birthdate, String today){
    // birthdate = "1986-02-22"
    // today = "2014-09-16"

    // String class has a split method for splitting a string
    // split(<delimiter>)
    // birth[0] = 1986 as string
    // birth[1] = 02 as string
    // birth[2] = 22 as string
    // now[0] = 2014 as string
    // now[1] = 09 as string
    // now[2] = 16 as string
    // **birth** and **now** arrays are automatically contains 3 elements 
    // split method here returns 3 elements because of yyyy-MM-dd value
    String birth[] = birthdate.split("-");
    String now[] = today.split("-");
    int age = 0;

    // let us convert string values into integer values
    // with the use of Integer.parseInt(<string>)
    int ybirth = Integer.parseInt(birth[0]);
    int mbirth = Integer.parseInt(birth[1]);
    int dbirth = Integer.parseInt(birth[2]);

    int ynow = Integer.parseInt(now[0]);
    int mnow = Integer.parseInt(now[1]);
    int dnow = Integer.parseInt(now[2]);

    if(ybirth < ynow){ // has age if birth year is lesser than current year
        age = ynow - ybirth; // let us get the interval of birth year and current year
        if(mbirth == mnow){ // when birth month comes, it's ok to have age = ynow - ybirth if
            if(dbirth > dnow) // birth day is coming. need to subtract 1 from age. not yet a bday
                age--;
        }else if(mbirth > mnow){ age--; } // birth month is comming. need to subtract 1 from age            
    }

    return age;
}

注意:日期格式为:yyyy-MM-dd。这是在jdk7中测试过的通用代码...
Jhonie

1
如果您提供了一些注释或解释了如何正确使用此代码,将有所帮助。通常,通常不鼓励代码转储,而问问题的人可能不理解您为什么决定以这种方式编写方法的原因。
rayryeng 2014年

@rayryeng:Jhonie已经在代码中添加了注释。这足以理解。在进行此类评论之前,请先思考并阅读。
akshay

@Akshay对我来说并不明显。事后看来,他似乎已放弃了代码。我通常不阅读评论。如果将它们从身体中取出并分开放置作为解释会很好。不过,这是我的偏爱,我们可以同意在这里不同意……。话虽如此,我忘了我甚至在两年前就写了此评论。
rayryeng '16

@rayryeng:发表此评论的原因是,发表负面评论会阻止人们使用如此好的论坛。因此,我们应该通过积极评价来鼓励他们。宝马,没有冒犯。干杯!!!
akshay

-1
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.Period;

public class AgeCalculator1 {

    public static void main(String args[]) {
        LocalDate start = LocalDate.of(1970, 2, 23);
        LocalDate end = LocalDate.now(ZoneId.systemDefault());

        Period p = Period.between(start, end);
        //The output of the program is :
        //45 years 6 months and 6 days.
        System.out.print(p.getYears() + " year" + (p.getYears() > 1 ? "s " : " ") );
        System.out.print(p.getMonths() + " month" + (p.getMonths() > 1 ? "s and " : " and ") );
        System.out.print(p.getDays() + " day" + (p.getDays() > 1 ? "s.\n" : ".\n") );
    }//method main ends here.
}

3
感谢您参与StackOverflow。给您一些建议。[A]请在您的答案中包含一些讨论。StackOverflow.com的意义不只是代码片段集合。例如,请注意您的代码如何使用新的java.time框架,而其他大多数答案都使用java.util.Date和Joda-Time。[B]请把您的答案与Meno Hochschild 的类似答案作比较,后者也使用java.time。说明您的状况如何更好,或以不同的角度对待问题。或收回您的,如果不是更好。
罗勒·布尔克

-1
public int getAge(Date birthDate) {
    Calendar a = Calendar.getInstance(Locale.US);
    a.setTime(date);
    Calendar b = Calendar.getInstance(Locale.US);
    int age = b.get(YEAR) - a.get(YEAR);
    if (a.get(MONTH) > b.get(MONTH) || (a.get(MONTH) == b.get(MONTH) && a.get(DATE) > b.get(DATE))) {
        age--;
    }
    return age;
}

-1

我感谢所有正确的答案,但这是同一问题的科特琳答案

希望对Kotlin开发人员有所帮助

fun calculateAge(birthDate: Date): Int {
        val now = Date()
        val timeBetween = now.getTime() - birthDate.getTime();
        val yearsBetween = timeBetween / 3.15576e+10;
        return Math.floor(yearsBetween).toInt()
    }

当我们拥有业界领先的java.time类时,进行这样的数学运算似乎很愚蠢。
罗勒·布尔克

Java中的OP请求。
Terran
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.