Java

Logo Java

Tous mes trucs et astuces pour utiliser Java

Ajouter / retrancher 1 année à une date en JAVA

package fr.quennec.date.custom;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;	

public class customDate {

	public static void dateMoinsUneAnnee(){

		GregorianCalendar calStr1 = new GregorianCalendar(); // Création d'un nouveau calendrier
		calStr1.setTime(new Date()); // Initialisation du calendrier avec la date du jour
		calStr1.add(GregorianCalendar.YEAR, -1); // On retranche 1 année
		String formatDate = "yyyy"; // Création du format pour afficher l'année sur 4 chiffres
		SimpleDateFormat sdf = new SimpleDateFormat(formatDate); // Initialisation du format de l'année sur 4 chiffres
		System.out.println(sdf.format(calStr1.getTime())); // Affichage du résultat

	}

}
Avec cette méthode, il est également possible d'ajouter une année au lieu de la retrancher :
calStr1.add(GregorianCalendar.YEAR, +1);
Il est également possible de manipuler les jours :
calStr1.add(GregorianCalendar.DAY_OF_YEAR, +1);
Et les mois :
calStr1.add(GregorianCalendar.MONTH, +1);
etc, etc ...
Etiquettes: 

Calculer l'écart entre 2 dates

Ce code calcul l'écart en années / mois / jours  (complets) entre 2 dates :

Ajouter les imports suivants :

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class ecartDate {

    static int UN = 1;
    static int DOUZE = 12;

    public static void main(String[] args) {
  
        Calendar calStr1 = Calendar.getInstance();
        Calendar calStr2 = Calendar.getInstance();
        Calendar calStr0 = Calendar.getInstance();
  
        Date date1 = null;
        Date date2 = null;
   
        int nbMois = 0;
        int nbAnnees = 0;
        long nbJours = 0;
   
        try {
                date1 = new SimpleDateFormat("dd/MM/yyyy").parse("25/01/2006");
        } catch (ParseException e) {
                e.printStackTrace();
        }
        try {
                date2 = new SimpleDateFormat("dd/MM/yyyy").parse("11/02/2014");
        } catch (ParseException e) {
                e.printStackTrace();
        }

        if (date1.equals(date2)) {
                return;
        }

        calStr1.setTime(date1);
        calStr2.setTime(date2);

        nbMois = 0;
        while (calStr1.before(calStr2)) {
                calStr1.add(GregorianCalendar.MONTH, UN);
                if (calStr1.before(calStr2) || calStr1.equals(calStr2)) {
                        nbMois++;
                }
        }
        nbAnnees = (nbMois / DOUZE);
        nbMois = (nbMois - (nbAnnees * DOUZE));

        calStr0 = Calendar.getInstance();
        calStr0.setTime(date1);
        calStr0.add(GregorianCalendar.YEAR, nbAnnees);
        calStr0.add(GregorianCalendar.MONTH, nbMois);
        nbJours = (calStr2.getTimeInMillis() - calStr0.getTimeInMillis()) / 86400000;

        System.out.print("Nb Annees : "+nbAnnees+"\n");
        System.out.print("Nb Mois : "+nbMois+"\n");
        System.out.print("Nb Jours : "+nbJours+"\n");

        }
}
Nb Annees : 8
Nb Mois : 0
Nb Jours : 17
Etiquettes: 

Décompiler des classes JAVA

Java Decompiler

Java Decompiler est un programme sous Windows / Linux / Mac qui permet de décompiler des classes JAVA.

Java Decompiler

Télécharger la version Windows

Télécharger la version Linux

 

Java: Connaitre la version de java utilisée pour la compilation d'une classe

Pour connaitre la version de java utilisée pour la compilation d'une classe, il suffit d'utiliser la commande javap présente dans le répertoire bin de java.

$ javap -verbose maclasse.class | grep version
  minor version: 0
  major version: 46

La version majeure permet de connaitre la version de java ayant compilé le fichier .class

Java 1.2 uses major version 46
Java 1.3 uses major version 47
Java 1.4 uses major version 48
Java 5 uses major version 49
Java 6 uses major version 50
Java 7 uses major version 51
Java 8 uses major version 52
Java 9 uses major version 53
Java 10 uses major version 54
Java 11 uses major version 55

Etiquettes: 

Java: Trier une ArrayList suivant les attributs d'un objet

Exemple avec l'objet personnalisé suivant

class Personne {
    
    String Nom;
    String Prenom;
    int Age;
    char Sexe;
    
    public Personne(String Nom, String Prenom, int Age, char Sexe) {
        this.Nom = Nom;
        this.Prenom = Prenom;
        this.Age = Age;
        this.Sexe = Sexe;
    }
    
    public boolean equals(Object o) {
        if (o instanceof Personne) {
            Personne tocompare = (Personne) o;
            if (tocompare.Nom.equals(this.Nom) && tocompare.Prenom.equals(this.Prenom)) {
                return true;
            }
        }
        return false;
    }
    
    public String toString(){
        return String.format("Nom: %-15sPrénom: %-15sAge: %-4dSexe: %1s", this.Nom, this.Prenom, this.Age, this.Sexe);
    }

    public String getNom() {
        return Nom;
    }

    public void setNom(String nom) {
        Nom = nom;
    }

    public String getPrenom() {
        return Prenom;
    }

    public void setPrenom(String prenom) {
        Prenom = prenom;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        Age = age;
    }

    public char getSexe() {
        return Sexe;
    }

    public void setSexe(char sexe) {
        Sexe = sexe;
    }

}

Je vais maintenant créer 10 objets "Personne" et les ajouter dans une ArrayList.

import java.util.ArrayList;

public class TriPersoPersonne {

    public static void main(String[] args) {
        ArrayList<Personne> Personnes = new ArrayList<Personne>();
        Personnes.add(new Personne("Martine", "Merle", 38, 'F'));
        Personnes.add(new Personne("Martine", "Boutin", 22, 'M'));
        Personnes.add(new Personne("Claire", "Lombard", 28, 'M'));
        Personnes.add(new Personne("Eugène", "Faivre", 53, 'F'));
        Personnes.add(new Personne("Susanne", "Gérard", 91, 'F'));
        Personnes.add(new Personne("Zoé", "Lefebvre", 47, 'F'));
        Personnes.add(new Personne("Julien", "Ollivier", 86, 'M'));
        Personnes.add(new Personne("Thomas", "Lambert", 38, 'M'));
        Personnes.add(new Personne("Michel", "Gay", 69, 'M'));
        Personnes.add(new Personne("Bernadette", "Clément", 15, 'F'));
        for (Personne personne : Personnes) {
            System.out.println(personne);
        }
    }

}

Voici la sortie du System.out:

Nom: Martine        Prénom: Merle          Age: 38  Sexe: F
Nom: Martine        Prénom: Boutin         Age: 22  Sexe: M
Nom: Claire         Prénom: Lombard        Age: 28  Sexe: M
Nom: Eugène         Prénom: Faivre         Age: 53  Sexe: F
Nom: Susanne        Prénom: Gérard         Age: 91  Sexe: F
Nom: Zoé            Prénom: Lefebvre       Age: 47  Sexe: F
Nom: Julien         Prénom: Ollivier       Age: 86  Sexe: M
Nom: Thomas         Prénom: Lambert        Age: 38  Sexe: M
Nom: Michel         Prénom: Gay            Age: 69  Sexe: M
Nom: Bernadette     Prénom: Clément        Age: 15  Sexe: F

J'aimerais maintenant trier mon ArrayList en fonction de l'age et du sexe de la personne et mettre la priorité sur le sexe "F" en cas d'égalité de l'age.

import java.util.Comparator;

class TriParAgeEtSexe implements Comparator<Personne> {
    
    public int compare(Personne a, Personne b) {
        int compA = a.Age * 10 + sexeToInt(a.Sexe);
        int compB = b.Age * 10 + sexeToInt(b.Sexe);
        return compA - compB;
    }
    
    public static int sexeToInt(char sexe) {
        if (sexe == 'F') return 0;
        return 1;
    }
    
}

Exécutons maintenant le tri de l'ArrayList avec mon tri personnalisé.

import java.util.ArrayList;
import java.util.Collections;

public class TriPersoPersonne {

    public static void main(String[] args) {
        ArrayList<Personne> Personnes = new ArrayList<Personne>();
        Personnes.add(new Personne("Martine", "Merle", 38, 'F'));
        Personnes.add(new Personne("Martine", "Boutin", 22, 'M'));
        Personnes.add(new Personne("Claire", "Lombard", 28, 'M'));
        Personnes.add(new Personne("Eugène", "Faivre", 53, 'F'));
        Personnes.add(new Personne("Susanne", "Gérard", 91, 'F'));
        Personnes.add(new Personne("Zoé", "Lefebvre", 47, 'F'));
        Personnes.add(new Personne("Julien", "Ollivier", 86, 'M'));
        Personnes.add(new Personne("Thomas", "Lambert", 38, 'M'));
        Personnes.add(new Personne("Michel", "Gay", 69, 'M'));
        Personnes.add(new Personne("Bernadette", "Clément", 15, 'F'));
        for (Personne personne : Personnes) {
            System.out.println(personne);
        }
        System.out.println("\nAprès le tri par age et sexe\n");
        Collections.sort(Personnes, new TriParAgeEtSexe());
        for (Personne personne : Personnes) {
            System.out.println(personne);
        }
    }

}

Ce qui donne ceci:

Nom: Martine        Prénom: Merle          Age: 38  Sexe: F
Nom: Martine        Prénom: Boutin         Age: 22  Sexe: M
Nom: Claire         Prénom: Lombard        Age: 28  Sexe: M
Nom: Eugène         Prénom: Faivre         Age: 53  Sexe: F
Nom: Susanne        Prénom: Gérard         Age: 91  Sexe: F
Nom: Zoé            Prénom: Lefebvre       Age: 47  Sexe: F
Nom: Julien         Prénom: Ollivier       Age: 86  Sexe: M
Nom: Thomas         Prénom: Lambert        Age: 38  Sexe: M
Nom: Michel         Prénom: Gay            Age: 69  Sexe: M
Nom: Bernadette     Prénom: Clément        Age: 15  Sexe: F

Après le tri par age et sexe

Nom: Bernadette     Prénom: Clément        Age: 15  Sexe: F
Nom: Martine        Prénom: Boutin         Age: 22  Sexe: M
Nom: Claire         Prénom: Lombard        Age: 28  Sexe: M
Nom: Martine        Prénom: Merle          Age: 38  Sexe: F
Nom: Thomas         Prénom: Lambert        Age: 38  Sexe: M
Nom: Zoé            Prénom: Lefebvre       Age: 47  Sexe: F
Nom: Eugène         Prénom: Faivre         Age: 53  Sexe: F
Nom: Michel         Prénom: Gay            Age: 69  Sexe: M
Nom: Julien         Prénom: Ollivier       Age: 86  Sexe: M
Nom: Susanne        Prénom: Gérard         Age: 91  Sexe: F

Le résultat est parfait.
L'ArrayList est triée par age croissant et si égalité, alors le sexe "F"  est positionné avant le sexe "M".

Et pour un tri décroissant, il suffit de modifier le "return" de la méthode "compare" de la classe "TriParAgeEtSexe" par:

return compB - compA;

Pour info, la méthode "equals" de la classe "Personne" permet d'utiliser la méthode "contains" de la classe "ArrayList" afin de vérifier si un objet "Personne" n'est pas déjà dans la liste avant de l'ajouter afin d'éviter les doublons.

 

Remplacer les caractères accentués d'une chaine par des caractères simples

Exemple d'une méthode permettant de remplacer tous les caractères accentués d'une chaine (String) par des caractères simples :

public static String translate(String src) {
        StringBuffer result = new StringBuffer();
        if(src!=null && src.length()!=0) {
            int index = -1;
            char c = (char)0;
            String chars= "àâäéèêëîïôöùûüç";
            String replace= "aaaeeeeiioouuuc";
            for(int i=0; i<src.length(); i++) {
                c = src.charAt(i);
                if( (index=chars.indexOf(c))!=-1 )
                    result.append(replace.charAt(index));
                else
                    result.append(c);
            }
        }
        return result.toString();
    }
Etiquettes: 

Tester si un nombre est un Double

1 - Créer une classe "Char.java" contenant les différentes variables utilisées :

public class Char {

    public static final char SPACE = (char)32;

    public static final char LOWER_N = (char)110;

    public static final char LOWER_U = (char)117;

    public static final char LOWER_L = (char)108;

    public static final char DOT = (char)46;

    public static final char COMMA = (char)44;

    public static final int DIGIT_BEGIN = 48;

    public static final int DIGIT_END = 57;

}
2 - Créer une classe "TestUtil.java" contenant les différentes fonctions utilisées :
public class TestUtil {

    public static boolean isNull(String s) {
        if (s == null) {
            return true;
        }

        int counter = 0;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (c == Char.SPACE) {
                continue;
            }
            else if (counter > 3) {
                return false;
            }

            if (counter == 0) {
                if (c != Char.LOWER_N) {
                    return false;
                }
            }
            else if (counter == 1) {
                if (c != Char.LOWER_U) {
                    return false;
                }
            }
            else if ((counter == 2) || (counter == 3)) {
                if (c != Char.LOWER_L) {
                    return false;
                }
            }

            counter++;
        }

        if ((counter == 0) || (counter == 4)) {
            return true;
        }

        return false;
    }
    
    public static boolean isDouble(String number){
        
//        On test si la valeur est nulle
        if (isNull(number)) {
            return false;
        }
        
//        On remplace les virgules par les points (séparateur décimal)
        number = number.replace(Char.COMMA, Char.DOT);
        
        boolean firstDot = true;
        
        
//        On test chaque caractère
//        Si le caractère est un chiffre on test le suivant
//        Si le caractère est un "point" on initialise la variable "firstDot" à "false" et on test le suivant
//        Si le caractère n'est pas un chiffre ou un autre "point" on retourne "false"
//        Sinon, la valeur est un "Double" et on retourne "true"
        for (char c : number.toCharArray()) {
            if (!isDigit(c)) {
                if (c == Char.SPACE) {
                    continue;
                }
                if(c == Char.DOT && firstDot){
                    firstDot = false;
                    continue;
                } else {
                    return false;
                }
            }
        }
        
        return true;
    }
    
    public static boolean isDigit(char c) {
        int x = c;

        if ((x >= Char.DIGIT_BEGIN) && (x <= Char.DIGIT_END)) {
            return true;
        }

        return false;
    }
}

3 - Créer une classe "testDouble.java" afin de tester les différentes fonctions :

public class testDouble {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        String s = "12,5689";
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi true
        
        s = "12.56456456";
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi true
        
        s = null;
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi false
        
        s = "a56456.5646";
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi false
        
        s = "23156.86798,546";
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi false
        
        s = "etet.ert47d6t";
            
        System.out.println(TestUtil.isDouble(s));    // Renvoi false
        
        s = "8989797";
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi true
        
        s = "8989 797";
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi true
        
        s = "89 897.97";
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi true
        
        s = "89 897,97";
        
        System.out.println(TestUtil.isDouble(s));    // Renvoi true
        
    }

}
Etiquettes: