Je travaille avec une date dans ce format: yyyy-mm-dd .

Comment incrémenter cette date d'un jour?

Quelque chose comme ça devrait faire l'affaire:

String dt = "2008-01-01";  // Start date
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance();
c.setTime(sdf.parse(dt));
c.add(Calendar.DATE, 1);  // number of days to add
dt = sdf.format(c.getTime());  // dt is now the new date

Java semble être bien derrière le huit-ball par rapport à C #. Cette méthode utilitaire montre la façon de faire dans Java SE 6 en utilisant la méthode Calendar.add (probablement le seul moyen facile).

public class DateUtil
{
    public static Date addDays(Date date, int days)
    {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.DATE, days); //minus number would decrement the days
        return cal.getTime();
    }
}

Pour ajouter un jour, selon la question posée, appelez-le comme suit:

String sourceDate = "2012-02-29";
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Date myDate = format.parse(sourceDate);
myDate = DateUtil.addDays(myDate, 1);

java.time

Sur Java 8 et versions ultérieures, le package java.time rend cela à peu près automatique. ( Tutoriel )

En supposant une Stringentrée et une sortie:

import java.time.LocalDate;

public class DateIncrementer {
  static public String addOneDay(String date) {
    return LocalDate.parse(date).plusDays(1).toString();
  }
}

Je préfère utiliser DateUtils d'Apache. Vérifiez ceci http://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/time/DateUtils.html . C'est pratique surtout lorsque vous devez l'utiliser à plusieurs endroits dans votre projet et que vous ne voudriez pas écrire votre méthode de doublure pour cela.

L'API dit:

addDays (Date date, int amount): Ajoute un nombre de jours à une date renvoyant un nouvel objet.

Notez qu'il renvoie un nouvel objet Date et ne modifie pas le précédent lui-même.

SimpleDateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd" );
Calendar cal = Calendar.getInstance();
cal.setTime( dateFormat.parse( inputString ) );
cal.add( Calendar.DATE, 1 );

Construisez un objet Calendar et utilisez la méthode add (Calendar.DATE, 1);

Jetez un œil à Joda-Time ( https://www.joda.org/joda-time/ ).

DateTimeFormatter parser = ISODateTimeFormat.date();

DateTime date = parser.parseDateTime(dateString);

String nextDay = parser.print(date.plusDays(1));

Veuillez noter que cette ligne ajoute 24 heures:

d1.getTime() + 1 * 24 * 60 * 60 * 1000

mais cette ligne ajoute un jour

cal.add( Calendar.DATE, 1 );

Les jours avec un changement d'heure d'été (25 ou 23 heures), vous obtiendrez des résultats différents!

Java 8 a ajouté une nouvelle API pour travailler avec les dates et les heures.

Avec Java 8, vous pouvez utiliser les lignes de code suivantes:

// parse date from yyyy-mm-dd pattern
LocalDate januaryFirst = LocalDate.parse("2014-01-01");

// add one day
LocalDate januarySecond = januaryFirst.plusDays(1);

vous pouvez utiliser Simple java.util lib

Calendar cal = Calendar.getInstance(); 
cal.setTime(yourDate); 
cal.add(Calendar.DATE, 1);
yourDate = cal.getTime();

Date today = new Date();               
SimpleDateFormat formattedDate = new SimpleDateFormat("yyyyMMdd");            
Calendar c = Calendar.getInstance();        
c.add(Calendar.DATE, 1);  // number of days to add      
String tomorrow = (String)(formattedDate.format(c.getTime()));
System.out.println("Tomorrows date is " + tomorrow);

Cela donnera la date de demain. c.add(...)les paramètres peuvent être modifiés de 1 à un autre nombre pour un incrément approprié.

Si vous utilisez Java 8 , faites-le comme ceci.

LocalDate sourceDate = LocalDate.of(2017, Month.MAY, 27);  // Source Date
LocalDate destDate = sourceDate.plusDays(1); // Adding a day to source date.

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); // Setting date format

String destDate = destDate.format(formatter));  // End date

Si vous souhaitez utiliser SimpleDateFormat , faites-le comme ceci.

String sourceDate = "2017-05-27";  // Start date

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

Calendar calendar = Calendar.getInstance();
calendar.setTime(sdf.parse(sourceDate)); // parsed date and setting to calendar

calendar.add(Calendar.DATE, 1);  // number of days to add
String destDate = sdf.format(calendar.getTime());  // End date

long timeadj = 24*60*60*1000;
Date newDate = new Date (oldDate.getTime ()+timeadj);

Cela prend le nombre de millisecondes depuis l'époque de oldDate et ajoute 1 jour de millisecondes, puis utilise le constructeur public Date () pour créer une date en utilisant la nouvelle valeur. Cette méthode vous permet d'ajouter 1 jour, ou n'importe quel nombre d'heures / minutes, pas seulement des jours entiers.

Depuis Java 1.5 TimeUnit.DAYS.toMillis (1) me semble plus propre.

SimpleDateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd" );
Date day = dateFormat.parse(string);
// add the day
Date dayAfter = new Date(day.getTime() + TimeUnit.DAYS.toMillis(1));

En Java 8, la manière la plus simple de procéder est:

Date.from(Instant.now().plusSeconds(SECONDS_PER_DAY))

Dans java 8, vous pouvez utiliser java.time.LocalDate

LocalDate parsedDate = LocalDate.parse("2015-10-30"); //Parse date from String
LocalDate addedDate = parsedDate.plusDays(1);   //Add one to the day field

Vous pouvez convertir en java.util.Dateobjet comme suit.

Date date = Date.from(addedDate.atStartOfDay(ZoneId.systemDefault()).toInstant());

Vous pouvez formater LocalDateen une chaîne comme suit.

String str = addedDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));

C'est très simple, essayer d'expliquer en un mot simple. obtenez la date d'aujourd'hui comme ci-dessous

Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());// print today's date
calendar.add(Calendar.DATE, 1);

Maintenant, définissez un jour à l'avance avec cette date par la méthode calendar.add qui prend (constante, valeur). Ici, la constante peut être DATE, heures, min, sec, etc. et la valeur est la valeur de constante. Comme pour un jour, la constante à venir est Calendar.DATE et sa valeur est 1 car nous voulons une valeur à un jour.

System.out.println(calendar.getTime());// print modified date which is la date de demain

Merci

Apache Commons a déjà ce DateUtils.addDays (Date date, int entier) http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/time/DateUtils.html#addDays%28java .util.Date,% 20int% 29 que vous utilisez ou vous pouvez utiliser le JodaTime pour le rendre plus propre.

Il suffit de passer la date en chaîne et le nombre de jours suivants

 private String getNextDate(String givenDate,int noOfDays) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        String nextDaysDate = null;
    try {
        cal.setTime(dateFormat.parse(givenDate));
        cal.add(Calendar.DATE, noOfDays);

       nextDaysDate = dateFormat.format(cal.getTime());

    } catch (ParseException ex) {
        Logger.getLogger(GR_TravelRepublic.class.getName()).log(Level.SEVERE, null, ex);
    }finally{
    dateFormat = null;
    cal = null;
    }

    return nextDaysDate;

}

Si vous souhaitez ajouter une seule unité de temps et que vous vous attendez à ce que d'autres champs soient également incrémentés, vous pouvez utiliser en toute sécurité la méthode add. Voir l'exemple ci-dessous:

SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.set(1970,Calendar.DECEMBER,31);
System.out.println(simpleDateFormat1.format(cal.getTime()));
cal.add(Calendar.DATE, 1);
System.out.println(simpleDateFormat1.format(cal.getTime()));
cal.add(Calendar.DATE, -1);
System.out.println(simpleDateFormat1.format(cal.getTime()));

Imprime:

1970-12-31
1971-01-01
1970-12-31

startCalendar.add(Calendar.DATE, 1); //Add 1 Day to the current Calender

Si vous utilisez Java SE 8 ou supérieur, vous devez utiliser la nouvelle API Date / Heure

 int days = 7;       
 LocalDate dateRedeemed = LocalDate.now();
 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/YYYY");

 String newDate = dateRedeemed.plusDays(days).format(formatter);   
 System.out.println(newDate);

Si vous devez convertir de java.util.Dateà java.time.LocalDate, vous pouvez utiliser cette méthode.

  public LocalDate asLocalDate(Date date) {
      Instant instant = date.toInstant();
      ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());
      return zdt.toLocalDate();
  }

Si vous utilisez une version antérieure à Java SE 8, je vous conseille d'utiliser Joda-Time

Joda-Time fournit un remplacement de qualité pour les classes de date et d'heure Java et est la bibliothèque standard de facto de date et d'heure pour Java avant Java SE 8

   int days = 7;       
   DateTime dateRedeemed = DateTime.now();
   DateTimeFormatter formatter = DateTimeFormat.forPattern("dd/MM/uuuu");

   String newDate = dateRedeemed.plusDays(days).toString(formatter);   
   System.out.println(newDate);

Utilisez l' DateFormatAPI pour convertir la chaîne en un objet Date, puis utilisez l' CalendarAPI pour en ajouter un jour. Faites-moi savoir si vous voulez des exemples de code spécifiques, et je pourrai mettre à jour ma réponse.

Si vous utilisez Java 8 java.time.LocalDateet java.time.format.DateTimeFormatterpouvez rendre ce travail assez simple.

public String nextDate(String date){
      LocalDate parsedDate = LocalDate.parse(date);
      LocalDate addedDate = parsedDate.plusDays(1);
      DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-mm-dd");
      return addedDate.format(formatter); 
}

Vous pouvez utiliser ce package à partir de "org.apache.commons.lang3.time":

 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 Date myNewDate = DateUtils.addDays(myDate, 4);
 Date yesterday = DateUtils.addDays(myDate, -1);
 String formatedDate = sdf.format(myNewDate);  

C'est simple en fait. Un jour contient 86400000 milliSecondes. Donc, vous obtenez d'abord l'heure actuelle en millisecondes du système en utilisant System.currentTimeMillis()puis ajoutez les 84000000 milliSecondes et utilisez la Dateclasse pour générer un format de date pour les millisecondes.

Exemple

String Today = new Date(System.currentTimeMillis()).toString();

La chaîne aujourd'hui sera 2019-05-9

String Tommorow = new Date(System.currentTimeMillis() + 86400000).toString();

String Tommorow sera le 2019-05-10

String DayAfterTommorow = new Date(System.currentTimeMillis() + (2 * 86400000)).toString();

String DayAfterTommorow aura lieu le 2019-05-11

Clarifions le cas d'utilisation: vous voulez faire l'arithmétique du calendrier et commencer / terminer avec un java.util.Date .

Quelques approches:

1. Convertir en chaîne et revenir avec SimpleDateFormat : il s'agit d'une solution inefficace.
2. Convertir en LocalDate : vous toutes les informations de l'heure.
3. Convertir en LocalDateTime : cela implique plus d'étapes et vous devez vous soucier du fuseau horaire.
4. Convertir à l'époque avec Date.getTime () : c'est efficace mais vous calculez en millisecondes.

Pensez à utiliser java.time.Instant :

Date _now = new Date();
Instant _instant = _now.toInstant().minus(5, ChronoUnit.DAYS);
Date _newDate = Date.from(_instant);

Date newDate = new Date();
newDate.setDate(newDate.getDate()+1);
System.out.println(newDate);