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 le calendrier .ajouter la méthode (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);

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 one liner pour cela.

L'API dit:

AddDays(Date date, montant int) : 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.

Java.temps

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

En supposant String entrée et sortie:

import java.time.LocalDate;

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

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 oeil à Joda-Time (http://joda-time.sourceforge.net/).

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 java simple.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 changés de 1 à un autre nombre pour l'incrément approprié.

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

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

Si vous utilisez Java 8, alors le faire comme cela.

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 voulez 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

Depuis Java 1.5 Unité de temps.JOUR.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));

Apache Commons a déjà ce DateUtils.addDays (Date date, montant int) 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 aller avec le JodaTime pour le rendre plus propre.

Il suffit de passer la date dans la 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 la méthode add en toute sécurité. 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()));

Imprimera:

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

En 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 objet java.util.Date comme suit.

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

Vous pouvez formater LocalDate dans une chaîne comme suit.

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

Utiliser le DateFormat API pour convertir la chaîne en objet Date, puis Calendar API à ajouter un jour. Faites-moi savoir si vous voulez des exemples de code spécifiques, et je peux mettre à jour ma réponse.

C'est très simple, en essayant d'expliquer en un mot simple. obtenez la date du jour comme ci-dessous

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

Définissez maintenant un jour à l'avance avec cette date par calendrier.ajouter une méthode qui prend (constante, valeur). Ici constante pourrait être DATE, heures,min, sec etc. et la valeur est la valeur de constante. Comme pour un jour, la constante ahead est le calendrier.La DATE et sa valeur sont 1 parce que nous voulons une valeur d'avance d'un jour.

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

Merci

Si vous utilisez Java 8, java.time.LocalDate et java.time.format.DateTimeFormatter peuvent 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 paquet depuis "org.Apache.commun.lang3.temps":

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

En Java 8, un moyen simple de le faire est:

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

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