मैं जावा में किसी की उम्र की गणना कैसे करूं?

Question

मैं एक जावा विधि में एक इंट के रूप में वर्षों में एक उम्र वापस करना चाहता हूं। मेरे पास अब निम्नलिखित है जहां getBirthDate () जन्म तिथि (; जन्म तिथि ;-)) के साथ एक दिनांक ऑब्जेक्ट लौटाता है:

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

    Date age = new Date(ageInMillis);

    return age.getYear();
}

लेकिन जब से getyear () पदावनत किया जाता है मैं सोच रहा हूं कि क्या ऐसा करने का कोई बेहतर तरीका है? मुझे यकीन भी नहीं है कि यह सही ढंग से काम करता है, क्योंकि मेरे पास कोई इकाई परीक्षण नहीं है (अभी तक)।

Comments

इस बारे में मेरा विचार बदल गया है: दूसरे प्रश्न में केवल तारीखों के बीच वर्षों का अनुमान है, सही मायने में सही उम्र नहीं।

— cletus

यह देखते हुए कि वह एक इंट में लौट रहा है, क्या आप स्पष्ट कर सकते हैं कि 'सही' उम्र से आपका क्या मतलब है?

— ब्रायन एग्न्यू

दिनांक बनाम कैलेंडर एक मूलभूत अवधारणा है जिसे जावा प्रलेखन पढ़ने से चमकाया जा सकता है। मुझे समझ नहीं आ रहा है कि यह इतना अधिक क्यों होगा।

— डेमोन्गोलम

@demongolem ??? तारीख और कैलेंडर आसानी से समझ में आ रहे हैं ?! नहीं, कदापि नहीं। स्टैक ओवरफ्लो पर इस विषय पर एक ज़िलिन प्रश्न हैं। जोडा-टाइम परियोजना ने सबसे अधिक लोकप्रिय पुस्तकालयों में से एक का निर्माण किया, जो उन कष्टप्रद तारीख-समय वर्गों के विकल्प के लिए था। बाद में, सन, ओरेकल, और जेसीपी समुदाय ने JSR 310 ( java.time ) को स्वीकार किया, यह स्वीकार करते हुए कि विरासत कक्षाएं निराशाजनक रूप से अपर्याप्त थीं। अधिक जानकारी के लिए, Oracle द्वारा ट्यूटोरियल देखें ।

— तुलसी बोर्क

Answer 1

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);
    }
}

हर किसी को अब तक जेडीके 8 का उपयोग करना चाहिए। पहले के सभी संस्करणों ने अपने समर्थन जीवन का अंत कर दिया है।

Comments

DAY_OF_YEAR की तुलना में लीप वर्ष के साथ काम करने पर गलत परिणाम हो सकता है।

— sinuhepop

चर dateOfBirth को दिनांक ऑब्जेक्ट होना चाहिए। मैं जन्म तिथि के साथ दिनांक वस्तु कैसे बना सकता हूं?

— एरिक

इस तथ्य के मद्देनजर कि हम 9 साल के हैं, और यदि जावा 8 का उपयोग किया जाता है, तो इसका उपयोग किया जाना चाहिए।

— संजीवनी

JDK 9 वर्तमान उत्पादन संस्करण है। पहले से ज्यादा सच।

— duffymo

@SteveOh मैं असहमत हूं। मैं इसके बजाय nulls को बिल्कुल स्वीकार नहीं करूंगा , बल्कि उपयोग करना चाहिए Objects.requireNonNull।

— एम सी सम्राट

Answer 2

जोडा की जाँच करें , जो दिनांक / समय की गणना को सरल करता है (Joda नए मानक Java date / time apis का आधार भी है, इसलिए आप जल्द ही एक मानक API सीखेंगे)।

संपादित करें: जावा 8 में बहुत कुछ समान है और बाहर की जाँच के लायक है।

जैसे

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

जो आप चाहते हैं के रूप में सरल है। प्री-जावा 8 सामान है (जैसा आपने पहचाना है) कुछ अनजाने में।

Comments

@ HoàngLong: JavaDocs से: "यह वर्ग एक दिन का प्रतिनिधित्व नहीं करता है, लेकिन आधी रात को मिलीसेकंड। यदि आपको एक ऐसे वर्ग की आवश्यकता है जो पूरे दिन का प्रतिनिधित्व करता है, तो एक अंतराल या लोकलडेट अधिक उपयुक्त हो सकता है।" हम वास्तव में यहां एक तारीख का प्रतिनिधित्व करना चाहते हैं।

— जॉन स्कीट

यदि आप इसे करना चाहते हैं तो जिस तरह @JohnSkeet सुझाव देता है, वह इस तरह है: वर्षों की आयु = Years.yearsBetween (नया लोकलडेट (getBirthDate ()), नया लोकलडेट ());

— फ्लेच

पता नहीं क्यों मैं DateMidnight का इस्तेमाल किया, और मैं अब यह पदावनत है ध्यान दें। अब लोकलडेट का उपयोग करने के लिए बदल गया

— ब्रायन एग्न्यू

@ बोर - joda-time.sourceforge.net/apidocs/org/joda/time/…

— ब्रायन एग्न्यू

@IgorGanapolsky वास्तव में मुख्य अंतर है: Joda-time उपयोग करने वाले निर्माणकर्ता जबकि Java-8 और ThreetenBP स्थैतिक कारखाने के तरीकों का उपयोग करते हैं। जिस तरह से Joda-Time उम्र की गणना करता है, उसमें एक सूक्ष्म बग के लिए, कृपया मेरे उत्तर को देखें जहां मैंने विभिन्न पुस्तकालयों के व्यवहार के बारे में अवलोकन दिया है।

— मेनो होच्स्चिल्ड

Answer 3

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

Comments

हाँ, कैलेंडर वर्ग भयानक है। दुर्भाग्य से, काम पर कभी-कभी मुझे इसका उपयोग करना पड़ता है: /। इसे पोस्ट करने के लिए धन्यवाद Cletus

— स्टीव

कैलेंडर को बदलें।

— MONTH और Calendar .AY_OF_MONTH को

@ टोबेबे यदि आप 1 मार्च को एक लीप वर्ष में पैदा होते हैं, तो आपका जन्मदिन 1 मार्च को अगले वर्ष में होता है, दूसरा नहीं। DAY_OF_YEAR काम नहीं करेगा।

— एयरसोर्स लिमिटेड

Answer 4

आधुनिक उत्तर और अवलोकन

क) जावा -8 (जावा-टाइम-पैकेज)

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) जोडा-टाइम

कृपया ध्यान दें कि प्रस्तावित और स्वीकृत जोडा-टाइम-सॉल्यूशन उपरोक्त तिथियों (एक दुर्लभ मामला) के लिए एक अलग संगणना परिणाम देता है, अर्थात्:

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

मैं इसे एक छोटी बग के रूप में मानता हूं लेकिन इस अजीब व्यवहार पर जोडा-टीम का एक अलग दृष्टिकोण है और इसे ठीक नहीं करना चाहते हैं (अजीब है क्योंकि अंतिम तिथि का दिन महीने की शुरुआत की तारीख से छोटा है इसलिए वर्ष होना चाहिए एक कम)। इस बंद मुद्दे को भी देखें ।

c) java.util.Calendar आदि।

तुलना के लिए विभिन्न अन्य उत्तर देखें। मैं इन पुरानी कक्षाओं का उपयोग करने की सिफारिश नहीं करूंगा क्योंकि परिणामी कोड अभी भी कुछ विदेशी मामलों में त्रुटिपूर्ण है और / या इस तरह से इस तथ्य को देखते हुए भी जटिल है कि मूल प्रश्न इतना सरल लगता है। वर्ष 2015 में हमारे पास वास्तव में बेहतर पुस्तकालय हैं।

d) Date4J के बारे में:

प्रस्तावित समाधान सरल है, लेकिन कभी-कभी लीप वर्षों के मामले में विफल हो जाएगा। बस साल के दिन का मूल्यांकन विश्वसनीय नहीं है।

ई) मेरी अपनी लाइब्रेरी Time4J :

यह Java-8-solution के समान काम करता है। बस LocalDateद्वारा PlainDateऔर ChronoUnit.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

Comments

जावा 8 संस्करण के लिए धन्यवाद! मुझे कुछ समय बचा लिया :) अब मुझे केवल यह पता लगाना है कि आने वाले महीनों को कैसे निकालना है। जैसे 1 साल और 1 महीना। :)

— thomas77

@ thomas77 उत्तर, संयुक्त वर्षों और महीनों (और शायद दिनों) के लिए धन्यवाद जावा -8 में `java.time.Period 'का उपयोग करके किया जा सकता है। यदि आप भी घंटों जैसी अन्य इकाइयों को ध्यान में रखना चाहते हैं तो जावा -8 समाधान की पेशकश नहीं करता है।

— मेनो होच्स्चिल्ड

फिर से धन्यवाद (और त्वरित प्रतिक्रिया के लिए) :)

— thomas77

मैं सुझाव देता हूं कि उपयोग करते समय एक समय क्षेत्र निर्दिष्ट करें LocalDate.now। यदि छोड़ा गया तो JVM का वर्तमान डिफ़ॉल्ट समय क्षेत्र अंतर्निहित रूप से लागू होता है। वह डिफ़ॉल्ट मशीनों / OSes / सेटिंग्स के बीच बदल सकता है, और किसी भी समय किसी भी कॉलिंग द्वारा रनटाइम के दौरान कर सकता है setDefault। मैं विशिष्ट होने की सलाह देता हूं, जैसेLocalDate.now( ZoneId.for( "America/Montreal" ) )

— तुलसी बोर्क

@GoCrafter_LP हां, आप ऐसे पुराने Android संस्करणों के लिए Java-8, या Joda-Time-Android (D. Lew से) या मेरे lib Time4A का अनुकरण करते हुए ThreetenABP लागू कर सकते हैं।

— मेनो होच्स्चिल्ड

Answer 5

/**
 * 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;
}

Comments

जाँच का उद्देश्य क्या है (birthDate.get(Calendar.DAY_OF_YEAR) - today.get(Calendar.DAY_OF_YEAR) > 3)? यह महीने और दिन के समय की तुलना के अस्तित्व के साथ व्यर्थ लगता है।

— जैद शहाफ

Answer 6

मैं अपने लाभ के लिए लगातार एक वर्ष में मिलीसेकंड का उपयोग करता हूं:

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

Comments

यह है सही जवाब नहीं ... साल नहीं 3.156e + 10 लेकिन 3.15576e + 10 (तिमाही दिन!)

— माहेर Abuthraa

यह काम नहीं करता है, कुछ साल लीप वर्ष होते हैं और एक अलग एमएसईसी मूल्य होता है

— ग्रेग

Answer 7

यदि आप 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;
}

Answer 8

JodaTime का उपयोग कर सही उत्तर है:

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

यदि आप चाहें तो आप इसे एक पंक्ति में भी छोटा कर सकते हैं। मैंने ब्रायनएग्नेव के उत्तर से विचार की नकल की , लेकिन मेरा मानना ​​है कि यह अधिक सही है क्योंकि आप वहां टिप्पणियों से देखते हैं (और यह प्रश्न का सटीक उत्तर देता है)।

Answer 9

साथ date4j पुस्तकालय:

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

Answer 10

यह ऊपर दिए गए एक उन्नत संस्करण है ... यह देखते हुए कि आप चाहते हैं कि उम्र एक 'इंट' हो। क्योंकि कभी-कभी आप पुस्तकालयों के एक समूह के साथ अपने कार्यक्रम को भरना नहीं चाहते हैं।

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;
}

Answer 11

यह शायद आश्चर्य की बात है कि आपको यह जानने की आवश्यकता नहीं है कि एक वर्ष में कितने दिन या महीने हैं या उन महीनों में कितने दिन हैं, इसी तरह, आपको लीप वर्ष, लीप सेकंड, या किसी भी बारे में जानने की आवश्यकता नहीं है उस सामान का उपयोग करके इस सरल, 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;
}

Comments

मैं जावा 6 और 5 के समाधान की तलाश में हूं। यह अभी तक सरल है।

— जेजे टिबियो

Answer 12

अपने कोड में इस एक को कॉपी करने का प्रयास करें, फिर आयु प्राप्त करने के लिए विधि का उपयोग करें।

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;
}

Comments

कोड केवल उत्तर हतोत्साहित किया जाता है। यह स्पष्ट करना बेहतर होगा कि यह कोड ओपी प्रश्न को क्यों संबोधित कर सकता है।

— рüффп

यह वास्तव में एक दिमाग नहीं है .. लेकिन आपकी चिंता को दूर करने के लिए अपडेट होगा

— केविन

Answer 13

मैं उम्र की गणना के लिए कोड के इस टुकड़े का उपयोग करता हूं, आशा है कि यह मदद करता है .. उपयोग किए गए पुस्तकालयों

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 ;
}

Answer 14

क्षेत्र जन्म और प्रभाव दोनों तिथि क्षेत्र हैं:

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);

यह मूल रूप से मूल्यह्रास विधियों का उपयोग किए बिना जॉन ओ के समाधान का एक संशोधन है। मैंने अपने कोड को अपने कोड में काम करने के लिए काफी समय बिताया। शायद यह उस समय दूसरों को बचाएगा।

Comments

क्या आप इसे थोड़ा बेहतर समझा सकते हैं? यह उम्र की गणना कैसे करता है

— जोनाथन एस। फिशर

Answer 15

और इसका क्या?

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;
}

Comments

यह वास्तव में प्यारा सुझाव है (जब आप जोडा का उपयोग नहीं कर रहे हैं और जावा 8 का उपयोग नहीं कर सकते हैं) हालांकि एल्गोरिथ्म थोड़ा गलत है, क्योंकि आप 0 पहले वर्ष के पूरे होने तक हैं। इसलिए आपको लूप शुरू करने से पहले तारीख में एक साल जोड़ना होगा।

— Dagmar

Answer 16

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के वर्ष होंगे।

Answer 17

सुरुचिपूर्ण, प्रतीत होता है सही है , यारोन रोनेन समाधान का टाइमस्टैम्प अंतर आधारित संस्करण।

मैं यह साबित करने के लिए कि कब और क्यों यह सही नहीं है , एक इकाई परीक्षण शामिल है । किसी भी टाइमस्टैम्प अंतर में छलांग के दिनों (और सेकंड) के कारण (संभवतः) यह असंभव है। इस एल्गोरिथ्म के लिए विसंगति अधिकतम + -1 दिन (और एक सेकंड) होनी चाहिए, टेस्ट 2 () देखें, जबकि यारों रॉन समाधान पूरी तरह से निरंतर धारणा पर आधारित हैtimeDiff / MILLI_SECONDS_YEAR 40 वें वर्ष की उम्र के लिए 10 दिन भिन्न हो सकते हैं, फिर भी यह संस्करण गलत भी है।

यह मुश्किल है, क्योंकि यह सुधरा हुआ संस्करण है, सूत्र का उपयोग करते हुए diffAsCalendar.get(Calendar.YEAR) - 1970, अधिकांश समय सही परिणाम देता है, जैसे कि दो वर्षों के बीच औसतन लीप वर्ष की संख्या।

/**
 * 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));
    }
}

Answer 18

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;

}

Answer 19

/**
 * 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; 
}

Comments

यह सुनिश्चित नहीं है कि आपने वास्तव में इस एक का परीक्षण किया है या नहीं, लेकिन दूसरों के लिए, इस पद्धति का एक दोष है। यदि आज वही महीना है जो आपकी जन्मतिथि है और आज <जन्मदिन है, तो यह अभी भी वास्तविक आयु + 1 को दर्शाता है, उदाहरण के लिए, जैसे कि यदि आपका दिन 7 सितंबर 1986 है, और आज 1 सितंबर 2013 है, तो यह आपको 27 की जगह दिखाएगा का 26.

— srahul07

यह सच नहीं हो सकता क्योंकि एक वर्ष में मिलीसेकंड की संख्या बहुत बड़ी नहीं है। लीप वर्ष में एक दिन अधिक होता है, फिर बहुत अधिक मिलीसेकंड होता है। एक 40 साल के व्यक्ति के लिए आपका एल्गोरिथ्म जन्मदिन की रिपोर्ट कर सकता है 9 - 10 दिन पहले तो यह वास्तव में है! लीप सेकंड भी हैं।

— एस्पिनोसा

Answer 20

यहाँ वर्ष, महीने और दिनों में आयु की गणना करने के लिए जावा कोड है।

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);
}

Answer 21

बिना किसी पुस्तकालय के सबसे आसान तरीका:

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

Comments

इस कोड में पुरानी डेट-टाइम क्लासेस का उपयोग किया गया है, जो अब विरासत हैं। इसके बजाय, जावा में निर्मित आधुनिक कक्षाओं का उपयोग करें ChronoUnit.YEARS.between( LocalDate.of( 1968 , Month.MARCH , 23 ) , LocalDate.now() ):। सही उत्तर

— तुलसी बोर्ल

DateUtilsएक पुस्तकालय है

— टेरान

Answer 22

जावा 8 के साथ, हम कोड की एक पंक्ति के साथ एक व्यक्ति की आयु की गणना कर सकते हैं:

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

Comments

वर्ष में या महीने में उम्र? महीने में बच्चे के बारे में कैसे?

— गुमराह

Answer 23

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;
}

Comments

जैसा कि @sinuhepop ने देखा "DAY_OF_YEAR की तुलना में लीप वर्षों से निपटने पर गलत परिणाम हो सकते हैं"

— Krzysztof Kot

Answer 24

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("");
        }
    }
}

Answer 25

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;
}

Comments

नोट: तिथि प्रारूप है: yyyy-MM-dd। यह एक सामान्य कोड है जिसे jdk7 में परीक्षण किया गया है ...

— झोंकी

यदि आप कुछ टिप्पणी प्रदान करते हैं या इस कोड का उपयोग करने का तरीका बताते हैं तो यह मदद करेगा। बस कोड डंपिंग को आमतौर पर हतोत्साहित किया जाता है, और सवाल पूछने वाला आपकी पसंद को नहीं समझ सकता है कि आपने इस तरीके को अपने तरीके से कोड करने का फैसला क्यों किया।

— रायरेंग सेंग

@rayryeng: Jhonie ने पहले ही कोड में टिप्पणियां जोड़ दी हैं। यह समझने के लिए पर्याप्त है। कृपया ऐसी टिप्पणी देने से पहले सोचें और पढ़ें।

— अक्षय

@ अक्षय जो मेरे लिए स्पष्ट नहीं थे। दृष्टिबाधित में ऐसा लग रहा था जैसे उसने कोड डंप किया हो। मैं आमतौर पर टिप्पणियाँ नहीं पढ़ता। यह अच्छा होगा अगर उन लोगों को शरीर से निकाल दिया जाए और उन्हें स्पष्टीकरण के रूप में अलग रखा जाए। हालांकि यह मेरी प्राथमिकता है और हम यहां असहमत होने के लिए सहमत हो सकते हैं .... यह कहा जा रहा है, मैं भूल गया था मैंने यह टिप्पणी भी लिखी थी क्योंकि यह लगभग दो साल पहले थी।

— रेय्यरेंग

@rayryeng: इस टिप्पणी के पीछे का कारण था, नकारात्मक टिप्पणियाँ लिखना इस तरह के अच्छे मंच का उपयोग करने से लोगों को हतोत्साहित करता है। इसलिए हमें सकारात्मक टिप्पणी देकर उन्हें प्रोत्साहित करना चाहिए। Bdw, कोई अपराध नहीं। चीयर्स !!!

— अक्षय

Answer 26

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.
}

Comments

StackOverflow में भाग लेने के लिए धन्यवाद। आपके लिए कुछ सुझाव। [A] कृपया अपने उत्तर के साथ कुछ चर्चा शामिल करें। StackOverflow.com का मतलब सिर्फ एक कोड स्निपेट संग्रह से बहुत अधिक है। उदाहरण के लिए, ध्यान दें कि आपका कोड नए java.time फ्रेमवर्क का उपयोग कैसे कर रहा है जबकि अधिकांश अन्य जवाब java.util.Date और Joda-Time का उपयोग कर रहे हैं। [ख] मेनो होच्स्चिल्ड द्वारा इसी तरह के उत्तर के साथ अपने उत्तर के विपरीत कृपया जो जावा का उपयोग करता है। बताएं कि आपकी समस्या कैसे बेहतर है या समस्या पर एक अलग कोण पर हमला करता है। या बेहतर नहीं है तो तुम्हारा वापस लेना।

— बेसिल बोर्क

Answer 27

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;
}

Answer 28

मैं सभी सही उत्तरों की सराहना करता हूं लेकिन यह उसी प्रश्न के लिए कोटलिन उत्तर है

मुझे उम्मीद है कि कोटलिन डेवलपर्स के लिए उपयोगी होगा

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()
    }

Comments

ऐसा लगता है कि मूर्खतापूर्ण इस तरह के गणित कर रहे हैं जब हमारे पास हमारे निपटान में उद्योग की अग्रणी java.time कक्षाएं हैं।

— बेसिल बॉर्क

जावा में ओपी अनुरोध।

— टेरान