Aide Java pour débutant - Page 1

import java.text.SimpleDateFormat ;


public interface StringUtility
{
   /**
    * Test if the String is empty or null
    * @param input The String to test
    * 
    * @return true if String is empty or null, else false.
    */
   public boolean isEmpty( String input ) ;





   /**
    * Test if the String is a representation of an Integer
    * @param input The String to test
    * 
    * @return true if this is an Integer, else false
    */

   public boolean isInteger( String input ) ;





   /**
    * Test if the String is a representation of a Float value
    * Integer are float.
    *
    * @input The String to test
    *
    * @return true if this is an Integer, else false
    */
   public boolean isNumeric( String input ) ;





   /**
    * Test if the String is a valid representation of a email.
    * @param input The String to test
    *
    * @return true if it's an email.
    */
   public boolean isEmail( String input ) ;





   /**
    * Test if the String is a representation of a boolean.
    * Accepted values are : TRUE, true, FALSE, false, 0, 1
    *
    * @param input The String to test
    *
    * @return true if it is a boolean
    */
   public boolean isBoolean( String input ) ;





   /**
    * Check if the String contains a representation of a Date according
    * to the giving pattern.
    *
    * @see SimpleDateFormat for the possibles patterns.
    * @param pattern the pattern the input must be conform
    * @param input the String to Test
    *
    * @return
    */
   public boolean isDate( String pattern, String input ) ;





   /**
    * Remove SQL for preventing code and data injection in server Side.
    * @param input a Suspicious String.
    *
    * @return a clear String.
    */
   public String removeSQL( String input ) ;





   /**
    * Remove Javascript for preventing code injection in client side.
    * @param input a Suspicious String.
    *
    * @return a clear String.
    */
   public String removeJavascript( String input ) ;





   /**
    * Remove all Xml Tags
    * @param input The String to parse.
    *
    * @return a copy of the String without tags.
    */
   public String removeXmlTags( String input ) ;

   // /** * Remove tags from the same kind.
   // * * @param tag, The kind of tag to remove * @param input The String to
   // parse. * @return a copy of the String without tags. */
   // public String removeXmlTags(String /**
   // * remove accents and special char
   // create a readable ascii string. - Accents letters are binded to
   // (ie é=>e, à=>a ...) - specials chars (spaces, tabs,
   // tag, String input);
   // from a String to their ascii representation ... ) are replaced
   // width the _ symbol. @param input The String to parse.
   // @return the normalized String public String normalize(String input);
}

Integer are float.

Pen^2 (./3) :
Remove Javascript for preventing code injection in client side.

Pen^2 (./3) :
* Remove Javascript for preventing code injection in client side.

Pen^2 (./3) :
create a readable ascii string. - Accents letters are binded to // (ie é=>e, à=>a ...)

Zerosquare (./7) :
Pour les IsMachin(), il y a la méthode TryParse en .NET, j'imagine qu'il doit y avoir un équivalent en Java.

public EPIC isInt(string machin) {
    try {
        int result = Integer.decode(machin);
        return EPIC.WIN;
    } catch(NumberFormatException e) {
        return EPIC.FAIL;
    }
}

Pen^2 (./8) :
(PS : urgent pour quand ?)

squalyl (./11) :
pas que je connaisse, même si je peux toujours me tromper. On utilise très souvent les exceptions pour signaler des cas d'erreurs en java, et puis pourquoi dupliquer le code si decode() fait déja le job?

public interface StringUtility 
{ 
	public boolean isEmpty( String input ) {
		if(input==null) return true;
		return input.length==0;
	}
	
	public boolean isInteger( String input ) {
		if(input==null) return false;
		try {
			long john = Long.parseLong(input);
			return true;
		} catch(NumberFormatException e) {
			return false;
		}
	}
	
	public boolean isNumeric( String input ) {
		if(input==null) return false;
		try {
			double v = Double.parseDouble(input);
			return true;
		} catch(NumberFormatException e) {
			return false;
		}
	}
	
	public boolean isEmail( String input ) {
		
	}
	
	public boolean isBoolean( String input ) {
		if(input==null) return false;
		if(input.equalsIgnoreCase("true")) return true;
		if(input.equalsIgnoreCase("false")) return true;
		if(input.equals("0") || input.equals("1") return true;
		return false;
	}
	
	public boolean isDate( String pattern, String input ) {
		//TODO
	}
	
	public String removeSQL( String input ) {
		//TODO
	}
	
	public String removeJavascript( String input ) {
		//TODO
	}
	
	public String removeXmlTags( String input ) {
		//TODO
	}
	
	public String normalize(String input) {
		return input.replace('é','e').replace('è','e').replace('à','a').exetera;
	}
}

squalyl (./14) :
je vois pas trop de quoi tu parles

Brunni (./20) :
C'est pas une bonne pratique de lancer des exceptions à tout va.

Brunni (./21) :
En théorie déjà parce qu'une exception dénote un cas exceptionnel, qui n'est pas censé arriver (s'il arrive alors c'est que ton appli a PLANTE

Brunni (./21) :
si bien que certains langages ou libs (comme celle de Objective-C il me semble) ne te garantissent même pas que le programme pourra continuer proprement après une exception

Brunni (./21) :
si tu es cantonné dans ton monde Java tu ne peux pas comprendre

Brunni (./21) :
[NSString stringWithContentsOfURL:@"http://caca.com" error:&errorDetailsIfNeeded]

iwannabeamaki (./17) :
En C# les méthodes ".TryParse" ont précisément pour objectif d'éviter de lancer des exceptions, parceque lancer des exceptions c'est lent et que quand c'est pour la catcher 2 lignes plus bas, on évite (mais bon, je veux bien croire que les performances en Java, c'est une notion assez vague #troll#)

Zerosquare (./25) :
Vous pensez que c'est vraiment le bon endroit pour troller sur le Java ?

MSDN:
Consider the TryParse pattern for members that may throw exceptions in common scenarios to avoid performance problems related to exceptions.

String token = fichier.nextToken();
if (classePourrie.isInteger(token))
    recordSet.addField(Integer.parseInt(token));
else if (classePourrie.isFloat(token))
    ...

Brunni (./29) :
Et si mon client a justement un recordset de même 10'000 lignes, ben l'exception catchée à chaque 'if' je vais la sentir passer.

250 ms pour 50 000 exceptions