Java incrementation

Bonjour,

je voudrai savoir comment peut on faire une auto implementation sur un nombre en java qui s'afiche sous la forme : "0001"
puis : "0002"
puis : "0003"

merci
Configuration: Windows XP Internet Explorer 6.0

7 réponses

  1. Sous forme de classe :

    
    /**
     * Compteur positif 
     * @author esco93
     * @version 1.0
     */
    public class Compteur {
    
    	private Integer Compteur = null;
    
    	/**
    	 *  Constructeur
    	 */
    
    	public Compteur() {
    		this.Compteur = 0;
    	}
    	
    
    	/**
    	 * Contucteur d'un compteur initialisé à une valeur donnée
    	 * @param compteur valeur de départ du compteur (devrait être supérieure à 0)
    	 */
    	public Compteur(Integer compteur) {
    		if(this.Compteur > 0)
    			this.Compteur = compteur;
    		else this.Compteur = 0;
    	}
    
    
    	/**
    	 * Incrémente le compteur
    	 */
    	public void increment(){
    		this.Compteur = this.Compteur + 1;
    	}
    	
    	/**
    	 * Décrémente le compteur
    	 */
    	public void decrement(){
    		if(this.Compteur > 0)
    			this.Compteur = this.Compteur  - 1;
    	}
    	
    	/**
    	 * Remet à zéro le compteur
    	 */
    	public void reset(){
    		this.Compteur = 0;
    	}
    
    	/**
    	 * Compare la valeur de deux compteurs
    	 * @param obj compteur à comparer
    	 * @return true si les compteur on la même valeur ou false sinon
    	 */
    	@Override
    	public boolean equals(Object obj) {
    		if (null == obj) return false;
    		if (!(obj instanceof Compteur)) return false;
    		else {
    			Compteur compteur = (Compteur) obj;
    			if(this.Compteur == compteur.getCompteur())
    				return true;
    			else return false;
    		}
    	}
    	
    	/**
    	 * A implémenter
    	 * @see java.lang.Object#hashCode()
    	 */
    	@Override
    	public int hashCode() {
    		// TODO implémenter le code
    		return super.hashCode();
    	}
    
    	/** 
    	 * Converti le compteur en String
    	 * @return une string représentant le compteur sous la forme : ####; 
    	 */
    	@Override
    	public String toString() {
    		StringBuilder sb = new StringBuilder();
    		if(this.Compteur < 10)
    			sb.append("000");
    		else if(this.Compteur < 100)
    			sb.append("00");
    		else if(this.Compteur < 1000)
    			sb.append("0");			
    		sb.append(this.Compteur);
    		return sb.toString();			
    	}
    
    	/**
    	 * Récupération du compteur
    	 * @return le compteur en Interger
    	 */
    	public Integer getCompteur() {
    		return Compteur;
    	}
    
    	/**
    	 * Initialise le compteur à une valeur précise
    	 * @param compteur la valeur d'initialisation
    	 */
    	public void setCompteur(Integer compteur) {
    		Compteur = compteur;
    	}	
    }
    
    
    4
    1. PS,

      Ici: Au delà sur 5 digits pour les valeurs de 10000 à 10999, puis sur 6 pour les valeurs de 100000 à 100999 etc...
      C'est bien entendu: Au delà sur 5 digits pour les valeurs de 10000 à 99999, puis sur 6 pour les valeurs de 100000 à 999999 etc... qu'il faut lire !!!
      Dan
      0
      1. Salut,

        Avec la méthode suivante (static ou non en fonction de l'endroit d'où elle est appelée):
        public static void increment()
              {
                nombreS = (nombre<1000?"0":"") + (nombre<100?"0":"") + (nombre<10?"0":"") + nombre;
                nombre++;
              }


        nous obtenons nombreS sur 4 digits pour les valeurs de 1 à 9999.

        Au delà sur 5 digits pour les valeurs de 10000 à 10999, puis sur 6 pour les valeurs de 100000 à 100999 etc...

        nombre et nombreS sont à déclarer au niveau global.

        Appel de la méthode:
                 
                 int nbreDebut = 0; // ou toute autre valeur
                 nombre = nbreDebut;
                 
                 increment();
                 System.out.println("nombreS = \"" + nombreS + "\"");
        Cordialement,

        Dan
        0
        1. Salut,

          int nombre = 1;
          String nombreS = ""; // S comme String
          //Si je veux obtenir "0001" dans nombreS, je peux écrire:
          nombreS = (nombre<1000?"0":"") + (nombre<100?"0":"") + (nombre<10?"0":"") + nombre;
          System.out.println("nombreS = \"" + nombreS + "\"");

          // vérifions avec les nombres 1, 10, 100, 1000:
          System.out.println("\n// verifions avec les nombres 1, 10, 100, 1000:\n");
          for (int i = 0; i <4; i++)
          {
          nombreS = (nombre<1000?"0":"") + (nombre<100?"0":"") + (nombre<10?"0":"") + nombre;
          System.out.println("nombreS = \"" + nombreS + "\"");
          nombre*=10;
          }

          Si tu as besoin d'infos supplémentaires n'hésite pas...

          Cordialement,

          Dan
          0
          1. Bonjour Achir

            La réponse que te donne mel21lio ne me paraît pas très sûre.
            Il y a en plus une erreur, on ne peut pas affecter un nombre de type int à une String (la ligne String toto=i ne marche pas en java)
            Ceci dit, c'est sympa de sa part d'apporter une réponse, même si elle est perfectible :=)
            Je te donne le code d'une fonction qui marche pour formater le code comme tu le demandes :
            Cette méthode fonctionne dès les version1.4 du jdk (et peut être avant, je ne sais plus)
            A partir du jdk 1.5, tu as aussi la classe java.util.Formater qui permet de formater à la manière du printf de C/C++
              /**
               * Méthode simple qui formate n'importe quel entier
               * sur 4 caractères en complétant à gauche par des zéros.
               * Si plus de 4 digits, tronque la partie gauche.
               * fonctionne pour des jdk  partir de 1.4
               * @param nombre
               * @return
               */
              public String formateSurQuatreCar(int nombre)
              {
                final int nbdigits = 4;
                NumberFormat nbf = NumberFormat.getNumberInstance();
                // Oblige à compléter les nombre de moins de 4 digits
                nbf.setMinimumIntegerDigits(nbdigits);
                // pas de séparateur par groupe de 3 digits
                nbf.setGroupingUsed(false);
                // redémarre la séquence à 0 si plus de 4 digits
                nbf.setMaximumIntegerDigits(nbdigits);
                String sformatee = nbf.format(nombre);
                return sformatee;
              }
            
            1
            1. code aproximatif a coriger

              int x=4; //dans ton cas
              for (int i=0;i=99;i++){
              String toto=i;
              while (toto.length<x-1){
              toto=toto+"0";
              }
              System.out.println(toto);
              }

              tu vérifira si le x-1 est nécessaire je fais toujours sa au débuger je me rappelle jamais

              voici un bout de code dont je me sert régulièrement donc qui marche bien

              for (int i = 0; i < date.length; i++) {
              calendar.add(Calendar.DAY_OF_MONTH, -1); // jours precedent
              YYYY = (calendar.get(Calendar.YEAR) + "");
              MM = ((calendar.get(Calendar.MONTH) + 1) + ""); // compte de 0 a
              DD = (calendar.get(Calendar.DAY_OF_MONTH) + "");
              if (MM.length() == 1) {
              MM = "0" + MM;
              }
              if (DD.length() == 1) {
              DD = "0" + DD;
              }
              date[i] = YYYY + "-" + MM + "-" + DD;
              date2[i] = YYYY + "_" + MM + "_" + DD;
              dateTS[i] = TimeStamp.getTimeStamp(i);// 0 pour jours courant
              }
              0