Vérification de la validité des codes siret et siren

Commenter

Contenu du snippet

Après plusieurs recherches sur internet, je n'ai pas trouvé d'exemple en java pour tester la validité d'un code SIRET ou SIREN.
Je poste donc une petite class "SiretSiren.java" ainsi qu'une class de test pour ceux qui comme moi cherchent encore ;-), vos commentaires sont les bienvenues.

Je me suis inspiré du code javascript de "cgone" présent sur ce site à l'adresse "http://www.javascriptfr.com/codes/VERIFICATION-VALIDITE-CODES-SIRET-SIREN-ALGO-LUHN_16330.aspx"
et de la définition du CNRS que vous trouverez à l'adresse suivante "http://www.dsi.cnrs.fr/bureau_qualite/admindonnees/documents/siren.pdf"

Source / Exemple : 


package com.compufirst.util;

/**


     
  •  @author COL - 27/05/2007

    •  
  •  

    •  
  •  numéro SIREN

    •  
  •  Il est composé de 8 chiffres, plus un chiffre de contrôle qui permet de vérifier la validité du numéro.

    •  
  •  La clé de contrôle utilisée pour vérifier de l'exactitude d'un identifiant est une clé "1-2". Le principe est

    •  
  •  le suivant : on multiplie les chiffres de rang impair à partir de la droite par 1, ceux de rang pair par 2 ; la

    •  
  •  somme des chiffres obtenus doit être un multiple de 10.

    •  
  •  exemple : soit le SIREN 732 829 320

    •  
  •  pour vérifier :   7 3 2 8 2 9 3 2 0

    •  
  •  rang pair x 2 :     6  16  18   4

    •  
  •  rang impair x 1 : 7   2   2   3   0

    •  
  •  ----------------------

    •  
  •  somme : 7+6+2+1+6+2+1+8+3+4+0 = 40

    •  
  •  Le numéro est exact.

 *


     
  •  numéro SIRET

    •  
  •  Le numéro d'identité d'établissement est articulé en deux parties : la première est le n° SIREN de la

    •  
  •  personne à laquelle appartient l'unité SIRET ; la seconde est un numéro d'ordre à 4 chiffres attribué à

    •  
  •  l'établissement suivi d'un chiffre de contrôle, qui permet de vérifier la validité de l'ensemble du numéro

    •  
  •  SIRET. Cette seconde partie est habituellement appelée NIC (numéro interne de classement).

    •  
  •  Méthode de vérification :

    •  
  •  Un SIRET est le résultat de la concaténation d'un numéro SIREN à 9 chiffres (dont la clé doit être

    •  
  •  vérifiée à part) et d'un numéro interne de classement (NIC) complété éventuellement à gauche par des

    •  
  •  zéros de façon que sa longueur soit de 4 chiffres. Le dernier et 14ème chiffre est une clé (1-2) qui

    •  
  •  porte sur les 13 premiers chiffres.

    •  
  •  On multiplie les chiffres de rang impair à partir de la droite par 1, ceux de rang pair par 2 ; la somme

    •  
  •  des chiffres obtenus est un multiple de 10.

    •  
  •  Exemple :

    •  
  •  pour vérifier :   7 3 2 8 2 9 3 2 0 0 0 0 7 4

    •  
  •  rang pair x 2 :  14   4   4   6   0   0  14

    •  
  •  rang impair x 1 :   3   8   9   2   0   0   4

    •  
  •  -----------------------------------

    •  
  •  somme : 1+4+3+4+8+4+9+6+2+0+0+0+0+1+4+4=50

    •  
  •  Le numéro est exact. Il correspond au SIRET du 7ème établissement immatriculé par l'entreprise.

 *


     
  • /


public class SiretSiren {
	
	public static final String SIREN = "SIREN";
	public static final String SIRET = "SIRET";
	public static final String WRONGNUMBER = "WRONGNUMBER";
	public static final String NOTANUMBER = "NOTANUMBER";
	
	private String siretsiren;
	private String type;

	public SiretSiren(){
	}
	
	public SiretSiren(String siretsiren){
		this.setSiretsiren(siretsiren);
	}
	
	private boolean isSirenSyntaxValide(String siren){
		int total = 0;
		int digit = 0;
		
		for (int i = 0; i<siren.length(); i++) {
			/** Recherche les positions paires : 2ème, 4ème, 6ème et 8ème chiffre que l'on multiplie par 2


    			 
  •  petite différence avec la définition ci-dessus car ici on travail de gauche à droite */

			if ((i % 2) == 1) {
				digit = Integer.parseInt(String.valueOf(siren.charAt(i))) * 2;
				/** si le résultat est >9 alors il est composé de deux digits tous les digits devant 


    				 
  •  s'additionner et ne pouvant être >19 le calcule devient : 1 + (digit -10) ou : digit - 9 */

				if (digit > 9) digit -= 9;
			}
			else digit = Integer.parseInt(String.valueOf(siren.charAt(i)));
			total += digit;
		}

		/** Si la somme est un multiple de 10 alors le SIREN est valide */
		if ((total % 10) == 0) return true;
		else return false;
	}
	
	private boolean isSiretSyntaxValide(String siret){
		int total = 0;
		int digit = 0;
		
		for (int i = 0; i<siret.length(); i++) {
			/** Recherche les positions impaires : 1er, 3è, 5è, etc... que l'on multiplie par 2


    			 
  •  petite différence avec la définition ci-dessus car ici on travail de gauche à droite */

			if ((i % 2) == 0) {
				digit = Integer.parseInt(String.valueOf(siret.charAt(i))) * 2;
				/** si le résultat est >9 alors il est composé de deux digits tous les digits devant 


    				 
  •  s'additionner et ne pouvant être >19 le calcule devient : 1 + (digit -10) ou : digit - 9 */

				if (digit > 9) digit -= 9;
			}
			else digit = Integer.parseInt(String.valueOf(siret.charAt(i)));
			total += digit;
		}
		/** Si la somme est un multiple de 10 alors le SIRET est valide */
		if ((total % 10) == 0) return true;
		else return false;
	}
	
	/**


    	 
  •  Méthode qui vérifie si la chaine passée est un nombre.

    • 	 
  •  Si le parse réussi alors c'est un nombre sinon une exception est levée

    • 	 
  •   

    • 	 
  •  @param aString

    • 	 
  •  @return true si c'est un chiffre, false dans le cas contraire

    • 	 
  • /

	private boolean isNumber(String aString){
		try{
			Long.parseLong(aString);
			return true;
		}
		catch(NumberFormatException nfe){
			return false;
		}
	}

	public boolean isEqualTo(String siretsiren){
		if(this.siretsiren.equals(siretsiren)) return true;
		else return false;
	}
	
	public boolean isEqualTo(SiretSiren siretsiren){
		if(this.siretsiren.equals(siretsiren.getSiretsiren())) return true;
		else return false;
	}
	
	@Override
	public int hashCode() {
		return this.getSiretsiren().hashCode();
	}

	public String getSiretsiren() {
		return siretsiren;
	}

	/** 


    	 
  •  Vérifie si le SIREN/SIRET passé, est un numérique à 9 ou 14 chiffres 

    • 	 
  •  Identifie si le num passé est un SIREN ou un SIRET

    • 	 
  •  @param siretsiren (String)

    • 	 
  •  */

	public void setSiretsiren(String siretsiren) {
		this.siretsiren = siretsiren;
		
		if(!this.isNumber(siretsiren)){
			this.type = SiretSiren.NOTANUMBER;
		}
		else{
			if(siretsiren.length()!=9 || siretsiren.length()!=14) this.type=SiretSiren.WRONGNUMBER;
			if(siretsiren.length()==9) {
				if(isSirenSyntaxValide(siretsiren))this.type = SiretSiren.SIREN;
				else this.type=SiretSiren.WRONGNUMBER;
			}
			if(siretsiren.length()==14){
				if(isSiretSyntaxValide(siretsiren)) this.type = SiretSiren.SIRET;
				else this.type=SiretSiren.WRONGNUMBER;
			}
		}
	}

	public String getType() {
		return type;
	}

	private void setType(String type) {
		this.type = type;
	}
}

/********************************************************************/
/** class de test ***************************************************/
/********************************************************************/

package com.compufirst.util;

public class TestSirenSiret {

	public static void main(String[] args) {

		SiretSiren siretSiren  = new SiretSiren("732829320");
		String type = siretSiren.getType();
		System.out.println("SiretSiren = 732829320 getType ="+ type);
		
		SiretSiren siretSiren2 = new SiretSiren();
		siretSiren2.setSiretsiren("35152822900088");
		String type2 = siretSiren2.getType();
		System.out.println("SiretSiren = 35152822900088 getType ="+ type2);
		
		boolean bool = siretSiren.isEqualTo(siretSiren2);
		boolean bool1 = siretSiren.isEqualTo(siretSiren2.getSiretsiren());
		boolean bool2 = siretSiren.isEqualTo("732829320");
		System.out.println("siretSiren = siretSiren2 ? :"+ bool);
		System.out.println("siretSiren = siretSiren2 ? :"+ bool1);
		System.out.println("siretSiren = siretSiren2 ? :"+ bool2);
		
	}

}

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.