Auf Zahlen testen bremst Programm ab



  • Hallo,
    ich habe ein Programm, welches viele Werte einlesen muss. Allerding muss ich testen ob es sich dabei wirklich um eine Zahl handelt. Eine Zahl darf max ein Komma oder einen Punkt enthalten. Tja nun habe ich festgestellt, das dieser Schritt eine ziemliche Performance Bremse darstellt (zumindest meine wahrscheinlich etwas kuenstlerische Implementation dessesn).

    Wie kann ich diesen Code also effektiver schreiben?

    /**
         * public double configureValue( Object o){
         *  
         * checks an item if it's a valid number
         * (separated by ',' or '.') and returns its double value
         * or returns 0.0 if not
         **/
        public double configureValue( Object o){    
    //    	System.out.println("TableDataBurito::configureValue() " + String.valueOf(o));	
        	if( isValidNumber( (String.valueOf(o)).toCharArray())){
    
        	    return Double.parseDouble(checkPoints(o));
    
        	}else{	
        		// not a valid number
        	    return 0.0;
        	}
        }
    
        /**
         * private String checkPoints( Object o){
         * 
         * exchanges oTemp's ',' by '.' if necessary
         **/
        private String checkPoints( Object o){
    //        System.out.println("TableDataBurito::checkPoints()");
            String szTemp = String.valueOf(o);
    
            if(szTemp.contains(",")){
                szTemp = szTemp.replace(",", ".");
            }
    
            return szTemp;
        }
    
        /**
         * private boolean isValidNumber(char[] cArr){
         * 
         * checks a char array if it is empty or a value 
         * 
         * (checks also the occurance of more than one ',' or '.' in the cArr !)
         * 
         * @param cArr
         */
        private boolean isValidNumber(char[] cArr){
    //    	System.out.println("TableDataBurito::isValidNumber()");
        	int iPointComma=0;
        	boolean bNumber = false;
    
        	// cArr was empty
        	if(cArr.length <= 0){
    			return false;
    		}
    
        	// parse digits - only one comma / point is allowed
        	for(int cnt=0; cnt<cArr.length;++cnt){
        		// cArr[cnt] is a valid figure - true
        		if(Character.isDigit(cArr[cnt])){
        			bNumber = true;
    
        		// cArr[cnt] is no figure, but '.' or ','	
        		}else if((cArr[cnt] == '.') || (cArr[cnt] == ',')){
        			++iPointComma;
    
        		// cArr[cnt] is no valid number - false
        		}else{
        			return false;
        		}
        	}
    
        	// more than one '.' or ',' - false
        	if(iPointComma > 1){
        		return false;
        	}
    
        	return bNumber; 
        }
    


  • wieso benutzt du nicht einfach Float.parseFloat() ? falls der string kein float ist, wird eine NumberFormatException geworfen.



  • hm, ist float nicht auch kleiner als double? Ich muss evtl mal abchecken, wie gross die Zahlen (eingang) max sind, dann koennte ich es evtl wohl auch mit float implementieren.

    Das andere Problem, was ich bei der Exception Geschichte sehe ist, was mache ich, wenn die Zahl kommasepariert ist - sicherlich, kann ich dann beim abfangen eine Umwandlung zu einer punktseparierten Zahl vornehmen und muss bei dieser aber wieder checken, ob es ein oder mehr Kommas/punkte sind usw - waere das eine Loesung, die mir etwas Performance bringt? Wieso?



  • dann nim halt Double.parseDouble().
    Performance würd ich sagen, das die leute die die java-api geschrieben haben weitaus mehr ahnung von java haben als ich oder du.
    ausserdem wieso das rad doppelt erfinden? es seih den du willst wissen wie ein parser funktioniert.
    wandel doch , in . um, dann die zahl in float/double. parseXxxx() wirft schon die exception, wenn ein punkt zuviel war.



  • klar 😉

    Jetz wirds interessant - ich hab mir ueberlegt einfach alles so zu implementieren:
    alles Double.parseDouble in try/catch Block, wird exception geworfen, lasse ich meine Funktionen (komma check usw drueberlaufen) ansonsten nicht.

    Deine Loesung waere alles in einem try/catch Block durchparsen nach Kommas, die in Punkte umwandeln und bei gefangener Exception dann die 0.0 setzen. (Wenn ich das richtig verstanden hab?).

    Was waere wohl sinnvoller - ich werde mal beides versuchen? Naja und dann bleibt halt noch das rumkonvertieren...


Log in to reply