Datentypen Zahl in String

[ska-ot]

Hi Javalianer,

folgende Aufgabe:
ich lese eine Datei mit vielen zeilen (hunderte) aus. In jeder Zeile stehen 10 komma separierte Werte.
Ich lese Zeile für Zeile ein und splitte den String in ein Array auf. wie kann ich nun den Datentyp des jeweiligen Wertes ermitteln? Die werte landen bei mir erstmal in einem String Array, und dann verwende ich folgende statische methode aus einer kleinen beispiel Klasse:

public static char getAttributeType(String attribute)
    {
        try
        {
            Integer.parseInt(attribute);
        }
        catch(NumberFormatException ex)
        {
            return 'C';
        }
        return 'N';
    }

Falls ich den string Wert in einen Integer parsen kann, gebe ich also N für Numeric ansonsten C für Char wieder zurück.

gibt es da andere(schönere, elegantere, perfomantere Lösungen, bzw. klassen die mir infos zum Datentyp eines Wertes liefern ?)
ich arbeite mit dem jdk6 und netbeans 6.9 nur zur Info

ps: nicht Streng sein, bin neuling

 

[Michael...]

Welche "Datentypen" können den vorkommen? Ist es eventuell nicht so, dass der Typ für eine komplette Spalte vorgegeben ist?
Wenn nein, bleibt nichts anderes übrig als Datum für Datum zu analysieren. Dafür könnte man reguläre Ausdrücke verwenden, aber ob das effektiver ist als auf gut Glück zu parsen...

 

[Simon_Flagg]

wie wärs mit Double(oder Integer).isNaN() is not a number --> schauen ob numeric

lg

 

[ska-ot]

Es gibt Strings und Integer/Double Werte.

Ob in einer ganzen Spalte nur strings oder nur Integer stehen ist nicht vorgegeben.
eine zeile kann so :
10,ABC,123,123,aaa und die nächste dann so:
abc,123,123.323,234 aussehen.

Das ganze klingt recht Sinnfrei, jedoch erzeuge ich dann mit den gewonnen erkenntnissen eine Datei die dann halt diese Infos enthält. (Damit nicht irgendwelche antworten kommen wie:"das ergibt keinen sinn...")

 

[ska-ot]

Double.IsNAN() erwartet einen Double Wert. Ich übergebe aber einen String. Dann müsste ich wieder Parsen ^^...

 

[Michael...]

Wenn's nur darum geht zu bestimmen, um was es sich handelt könnte mit regulären Ausdrücken arbeiten. Man definiert zwei Pattern für Integer und Double, wenn beide nicht passen ist's halt ein String.

 

[Simon_Flagg]

sry mein irrtum... warum gibts dann eig so ne methode?

was ich beim googlen gefunden habe:

if("123".matches("\\d*")){
      System.out.println("number");
    }

von String auf Zahlen überprüfen @ tutorials.de: Tutorials, Forum & Hilfe

lg

 

[ska-ot]

Dank Michael ist mir noch ein Denkfehler meinerseits aufgefallen.
Falls es ein Double wert ist, liefert die Funktion trotzdem 'c' zurück obwohl es ja kein string ist...
Da muss ich mir noch was überlegen...

Gibt es die Möglichkeit die anzahl der ziffern eines Integer , bzw die Anzahl der ziffern eines Doubles jeweils vor und nach dem Komma zu ermitteln ? ausser das ganze in Strings zu packen (den double zusätzlich Splitten) und mit String.Lenght() zu arbeiten ?

 

[bone2]

was passiert wenn N zurück kommt? nochmal parsen? gibts es negative zahlen in der datei? sonst einfach die zahl zurückgeben und bei exception -1 und schon kann man es als string behalten

 

[ska-ot]

mit den werten passiert sonst weiter nichts... ich benötige bloß die infos über den wert um quasi ein Meta-Daten File zu erzeugen. Die regEx Lösung sieht sehr interessant aus, auch wenns meiner Meinung nach komplizierter ist (zumindest wenn man mit RegEx nicht viel zu tun hat/hatte)

 

[alsodenn]

Es gibt int (bzw. auch noch andere, aber unwichtig) als Ganzzahldatentyp und double (bzw. auch hier wieder andere) als Fließkommazahldatentyp. Prinzipiell kann jedes int auch nach double konvertiert werden, ohne "großen" Genauigkeitsverlust. Man könnte also double als Typ aller Zahlen nehmen.

Ich stelle mir das jetzt so vor:

        String str = "123, 456, 7.89, abc\n"
                + "987, 65.4, 32.1, dfg";

        String[] split = str.split("[ ,]");

        List<Integer> li = new LinkedList<Integer>();
        List<Double> ld = new LinkedList<Double>();
        List<String> ls = new LinkedList<String>();

        for (String s : split) {
            try {
                li.add(Integer.parseInt(s));
                continue;
            } catch (NumberFormatException nfe) {
            }
            try {
                ld.add(Double.parseDouble(s));
                continue;
            } catch (NumberFormatException nfe) {
            }
            try {
                ls.add(s);
                continue;
            } catch (NumberFormatException nfe) {
            }
        }

        System.out.println("li: " + li);
        System.out.println("ld: " + ld);
        System.out.println("ls: " + ls);

Aber wie sinnvoll das Sammeln solcher Objekte ist, weiß ich auch nicht^^

 

[Antoras]

Ich bin kein Freund von RegEx, deshalb würde ich dazu raten einen vernünftigen Parser zu schreiben:

public class ParserTest {

	public static void main(final String... args) {
		final String str = "10,ABC,123,123,aa,abc,123,123.323,234,?¿";
		final List<Type> types = new ArrayList<Type>();
		for (final String s : str.split(",")) {
			types.add(getType(s));
		}
		System.out.println(types);
	}
	
	enum Type {
		INT, DOUBLE, ALPHA, NIL
	}
	
	static Type getType(final String s) {
		if (isNumeric(s)) {
			return s.contains(".") ? Type.DOUBLE : Type.INT;
		}
		if (isAlpha(s)) {
			return Type.ALPHA;
		}
		return Type.NIL;
	}
	
	static boolean isNumeric(final String s) {
		for (final char c : s.toCharArray()) {
			if (!isNumeric(c)) {
				return false;
			}
		}
		return true;
	}
	
	static boolean isAlpha(final String s) {
		for (final char c : s.toCharArray()) {
			if (!isAlpha(c)) {
				return false;
			}
		}
		return true;
	}
	
	static boolean isNumeric(final char c) {
		return c >= '0' && c <= '9' || c == '.';
	}
	
	static boolean isAlpha(final char c) {
		return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z';
	}
}

Die Sache mit der Unterscheidung zwischen Int und Double ist nicht optimal, aber ausreichend sofern nicht noch andere Typen dazukommen. Statt einer List kann man natürlich auch eine Map nehmen wenn man noch wissen will welcher Typ zu welchem String passt.

Zu Exceptions sage ich immer wieder gerne: Die sind dazu da um auf unvorhersehbare Fehler reagieren zu können. Wenn also schon im voraus prüfbar ist ob es zu einer Exception kommen kann, warum diese dann auftreten lassen?

 

[alsodenn]

Wenn also schon im voraus prüfbar ist ob es zu einer Exception kommen kann, warum diese dann auftreten lassen?

Wenn dein "Parser" wenigsten noch funktionieren würde, würde ich vielleicht etwas anderes als 5 dafür geben - aber schon eine Teilstring mit zwei Punkten würde zu fehlerhaften Typangaben führen, was keine andere Note rechtfertigt. Warum sollte man die API-Methoden nicht verwenden dürfen - gerade dann, wenn man selbst nichts besseres schreiben kann? Warum sollten Exceptions nicht auftreten dürfen? Dafür sind sie da. Sagt deine IDE dir etwa etwas anderes?

 

[Antoras]

Warum sollte man die API-Methoden nicht verwenden dürfen - gerade dann, wenn man selbst nichts besseres schreiben kann? Warum sollten Exceptions nicht auftreten dürfen? Dafür sind sie da. Sagt deine IDE dir etwa etwas anderes?

Ich hab ja extra hingeschrieben, dass die Erkennung bei Nummern nicht optimal ist. Im übrigen hat der TO nirgendwo spezifiziert ob auch fehlerhafte Daten vorliegen können oder was alles für Zeichen vorliegen dürfen (

123 456

oder

+-+-+--242

sind bspw. auch Zahlen und mit denen würde die API auch nicht klarkommen). Wenn dem also so wäre, dann würde dein Lösungsvorschlag genauso wenig funktionieren.

Warum sollte man die API-Methoden nicht verwenden dürfen

Darf man das nicht? Hab ich nirgendwo behauptet.

Warum sollten Exceptions nicht auftreten dürfen? Dafür sind sie da. Sagt deine IDE dir etwa etwas anderes?

Exceptions sind für die Fehlerbehandlung da und nicht um für fehlende Programmlogik einzuspringen. Meine IDE sagt dazu übrigens gar nichts. Warum auch? Programmierkonzepte interessieren meine IDE herzlich wenig.

 

[alsodenn]

Wenn dem also so wäre, dann würde dein Lösungsvorschlag genauso wenig funktionieren.

Falsch! Schlauberger und Troll, deshalb wird das auch mein letzter Post sein. Der Code oben kann sehr wohl mit derlei Eingaben umgehen.

Exceptions sind für die Fehlerbehandlung da und nicht um für fehlende Programmlogik einzuspringen. Meine IDE sagt dazu übrigens gar nichts. Warum auch? Programmierkonzepte interessieren meine IDE herzlich wenig.

Ich ging doch tatsächlich von der Annahme aus, dass du mit Meldungen der IDE die Richtigkeit deiner Aussagen beweisen wolltest. Dass keine Meldung kommt - umso besser.

 

[Andi_CH]

Es kann gar keine fehlerhaften Daten geben.

Entweder es handelt sich um eine Zahl (welcher Art auch immer) oder einen String.
Demzufolge ist --5 halt ein String.

Regexp ist ziemlich kompliziert und sehr schlecht verständlich.

Falls das Ganze nicht zeitkritisch ist würde ich mit Exceptions arbeiten - versuchen als int zu parsen und wenns eine Exception gibt, ist es halt was anderes. Exceptions sind einfach relativ zeitaufwändig... (igitt - ich werde mich erst in 100 Jahren an das "ä" gewöhnt haben)

 

[ska-ot]

ich habe mir 2 dummy funktionen gebaut, einmal mit den Exceptions und einmal mit regex und versucht die ausführzeit zu messen in dem ich endzeit in milisekunden minus startzeit in milisekunden gerechnet habe und jede funktion in einer schleife mit 1000000~durchläufen aufgerufen habe.(jaja ich weis... sowas kann und wird niemals genau sein..)
aber folgendes ist aufgefallen: wenn der geprüfute wert ein string ist, ist die regex methode schneller (regex breicht bei int sowie auch string werden ungefähr die selbe zeit) die methode mit den Exception ist bei integer werten allerdings um einiges Schneller...

Da in den Dateien überwiegent Integer/double werte sind, werde ich mich vermutlich für die Exception methode entscheiden
ich danke trotzdem allen für ihre ideen und ihre Hilfe

 

[xehpuk]

Exceptions sind einfach relativ zeitaufwändig... (igitt - ich werde mich erst in 100 Jahren an das "ä" gewöhnt haben)

Dann schreib es doch selbst mit 'e', ist schließlich nicht falsch.

 

[Antoras]

Deine Ergebnisse deines Benchmarks mit Integer-Werten kann ich so nicht bestätigen:

9: regex normal elapsed: 81.563897ms
9: regex compiled elapsed: 28.642246ms
9: exception elapsed: 300.545742ms
9: parser elapsed: 2.440725ms

Der Parser ist wie erwartet was Geschwindigkeit anbelangt unschlagbar. Bei den RegEx kann man die Unterschiede was vorkompilierte Expression anbelangt auch sehr gut beobachten. Falls dir die Geschwindigkeit also wichtig ist oder du mehrere MB oder gar GB an Daten hast wirst du um einen eigenen Parser nicht herumkommen. Diesen musst du nicht einmal selbst schreiben, es gibt genug Parsergeneratoren, die das für dich übernehmen.

Der Code:

import java.util.regex.Pattern;

public class TestInJ {
  
  static final Pattern p = Pattern.compile("\\d*");

  public static void main(final String[] args) {
    final int n = 200000;
    final String str = "214748364x";
    System.out.println("testing methods ('false' is expected)...");
    System.out.println("regex normal: " + regexNormal(str));
    System.out.println("regex compiled: " + regexCompiled(str));
    System.out.println("exception: " + exception(str));
    System.out.println("parser: " + parser(str));
    
    System.out.println("\nwarmup...");
    for (int i = 0; i < n * 10; i++) {
      exception(str);
      parser(str);
    }
    
    System.out.println("\nstarting benchmark...");
    for (int j = 0; j < 10; j++) {
      {
        System.out.print(j + ": regex normal ");
        final long s = System.nanoTime();
        for (int i = 0; i < n; i++) {
          regexNormal(str);
        }
        System.out.println("elapsed: " + (System.nanoTime() - s) / 1e6 + "ms");
      }
      {
        System.out.print(j + ": regex compiled ");
        final long s = System.nanoTime();
        for (int i = 0; i < n; i++) {
          regexCompiled(str);
        }
        System.out.println("elapsed: " + (System.nanoTime() - s) / 1e6 + "ms");
      }
      {
        System.out.print(j + ": exception ");
        final long s = System.nanoTime();
        for (int i = 0; i < n; i++) {
          exception(str);
        }
        System.out.println("elapsed: " + (System.nanoTime() - s) / 1e6 + "ms");
      }
      {
        System.out.print(j + ": parser ");
        final long s = System.nanoTime();
        for (int i = 0; i < n; i++) {
          parser(str);
        }
        System.out.println("elapsed: " + (System.nanoTime() - s) / 1e6 + "ms");
      }
      System.out.println();
    }
  }
  
  static boolean regexCompiled(final String str) {
    return p.matcher(str).matches();
  }
  
  static boolean regexNormal(final String str) {
    return str.matches("\\d*");
  }
  
  static boolean exception(final String str) {
    try {
      Integer.parseInt(str);
    } catch (final NumberFormatException e) {
      return false;
    }
    return true;
  }
  
  static boolean parser(final String str) {
    return isNumeric(str);
  }
  
  static boolean isNumeric(final String str) {
    int i = 0;
    while (i < str.length()) {
      if (!isNumeric(str.charAt(i))) {
        return false;
      }
      ++i;
    }
    return true;
  }
  
  static boolean isNumeric(final char c) {
    return c >= '0' && c <= '9';
  }
}

 

[ska-ot]

dein program bestätigt meine Aussage doch :

9: regex normal elapsed: 135.694756ms
9: regex compiled elapsed: 78.492994ms
9: exception elapsed: 24.013217ms
9: parser elapsed: 12.660743ms

Falls es ein Int ist, ist die exception schneller, aber genauso stimmt auch das ein eigener Parser wohl die eleganteste und schnellste Variante ist

ich glaube du hast mich mit deinem Parser überzeugt ! ^^

 

[alsodenn]

Nö, seine Aussagen stimmen nicht:

Deine Ergebnisse deines Benchmarks mit Integer-Werten kann ich so nicht bestätigen:

Mir wäre ein etwas langsameres Programm allemal lieber als eins, das nicht funktioniert.

 

[ska-ot]

Wo liegen denn deine Bedenken in seiner Lösung?

Die Daten die vorliegen haben keine speziellen sonderzeichen wie --++ etc. und es kommen auch keine 2 oder mehr punkte in den Double werten vor. es sind entweder normale (psoitive) Integer, double oder eben strings.

und es kommen durch aus auch dateien vor die mehrere GB groß sind. somit ist performance kein unwichtiger faktor.

da ich aber neuling in Java bin, (vorher php, und ein wenig c#)
lasse ich mich gerne in die Tiefen der Java welt einweihen und mich eines besseren Belehren ^^.

wobei einige posts von einigen leuten durch asympathie zu anderen leuten geprägt sind... was die Entscheidung nicht gerade erleichtert ;D

 

[ska-ot]

ich habe dreister Weise die Ideen von Antoras aufgegriffen und folgendes gebastelt

class AttributeInfo
{
    static char getAttributeType(String attribute)
    {
        for(int i =0;i<attribute.length();i++)
        {
            if(attribute.charAt(i)!='.')
                if(!(attribute.charAt(i) >= '0' && attribute.charAt(i) <= '9'))
                    return 'C';
        }
        return 'N';
    }
}

klein, schnell und funktioniert, wie ich es haben will ;D

 

[ska-ot]

hat jemand eine idee wie ich die Länge des übermittelten wertes erfassen kann ?
wichtig ist , das ich bei einem double jeweils die länge vor dem Komma(.) und nach dem Komma bekomme... meine ideen führen irgendwie ins nichts ^^

    static Integer[] getAttributeLength(String attribute)throws Exception
    {
        String[] test2 = attribute.split(".");
        Integer[] returnLength = new Integer[2];
        returnLength[0]=0;
        returnLength[1]=0;
        if(attribute.contains("."))
        {
            test2 = attribute.split(".");
            returnLength[0] = test2[0].length();
            returnLength[1] = test2[1].length();
        }
        else
            returnLength[0] = attribute.length();
        return returnLength;
    }

edit: String.Split() macht ja was ganz anderes als erwaret

 

[Michael...]

Die Methode erwartet reguläre Ausdrücke, da wird Dir

split(".")

nicht viel liefern.
Der Punkt ist in RegEx ein Metazeichen und steht für ein beliebiges Zeichen. Wenn man nach einem Punkt sucht muss man dieses Zeichen maskieren (und in Java gleich doppelt):

split("\\.")

 

[ska-ot]

ja, das ist mir aufgefallen, aber ich glaube ich versuchs mal mit attribute.lastIndexOf("."); für die länger vor und dann halt attribute.Lenght ()- attribute.lastIndexOf("."); für die länge nach dem komma oder so

 

[ska-ot]

class AttributeInfo
{
    static char getAttributeType(String attribute)
    {
        Integer points=0;
        for(int i =0;i<attribute.length();i++)
        {
            if((attribute.charAt(i)!='.')){
                if(!(attribute.charAt(i) >= '0' && attribute.charAt(i) <= '9'))
                    return 'C';}
            else{
                points++;
                if(points >1)
                    return 'C';
            }
        }
        return 'N';
    }

    static int getAttributeLength(String attribute)
    {
        return attribute.length();
    }

    static int getAttributeLengthADP(String attribute)
    {
        return attribute.length()-attribute.lastIndexOf(".")-1;
    }

    static int getAttributeLengthBDP(String attribute)
    {
        return attribute.lastIndexOf(".");
    }
}

das wäre dann meine Klasse.
Auf Verbesserungsvorschläge freue ich mich nat. ^^

Kann man eigendlich auf threads die als erledigt markiert wurden noch antworten ? ._.

 

[Blakh]

Ja (Brauchst mir nicht für die Hilfe danken :lol: )

 

[alsodenn]

Wo liegen denn deine Bedenken in seiner Lösung?

betitelt er die Lösung als unvernünftig, obwohl sie übersichtlich ist funktioniert. Das sind doch schon mal aus der Luft gegriffene behauptungen...

Die Daten die vorliegen haben keine speziellen sonderzeichen wie --++ etc. und es kommen auch keine 2 oder mehr punkte in den Double werten vor. es sind entweder normale (psoitive) Integer, double oder eben strings.

und es kommen durch aus auch dateien vor die mehrere GB groß sind. somit ist performance kein unwichtiger faktor.

da ich aber neuling in Java bin, (vorher php, und ein wenig c#)
lasse ich mich gerne in die Tiefen der Java welt einweihen und mich eines besseren Belehren ^^.

Das sind ganz spezielle Anforderungen, die vorher noch nicht klar waren. Klar, kann man eine maßgeschneiderte effizientere Lösung schrieben, aber warum, wenn die API bereits Implementierungen bereithält, die zu den Anforderungen passen??

Ohnehin ist der Flaschenhals bei den Mengen an Daten nicht das Prüfen, ob int/double/String, sondern das Lesen und Schreiben in das Dateisystem. Hier wäre man mit C schneller, systemnaher unterwegs.

Aber gut:

    public static String classify(String str) {
        if (str.length() == 0
                || str.charAt(0) < '0' || str.charAt(0) > '9') {
            return "String";
        }

        for (int i = 1; i < str.length() - 1; i++) {
            if (str.charAt(i) == '.') {
                for (i = i + 1; i < str.length(); i++   /*uebel*/) {
                    if (str.charAt(i) < '0' || str.charAt(i) > '9') {
                        return "String";
                    }
                }
                return "double";
            } else if (str.charAt(i) < '0' || str.charAt(i) > '9') {
                return "String";
            }
        }

        if (str.charAt(str.length() - 1) < '0' || str.charAt(str.length() - 1) > '9') {
            return "String";
        }

        return "int";
    }

Furchtbar unübersichtlich, dürfte performancetechnisch aber nicht zu schlagen sein. Wenn man sich darauf einigen könnte, dass keine Zeichenketten mit Länge 0 vorkommen, dann ginge es noch schneller. Aufruf erfolgt mit:

        String[] cstrings = {"123", "456", "7.89", "abc", "987", "65.4", "32.1", "dfg"};
        Map<String, String> cmap = new HashMap<String, String>();
        for (String s : cstrings) {
            cmap.put(s, classify(s));
        }
        System.out.println(cmap);

 

[alsodenn]

Überhaupt sind solche Methoden irrelevant, denn der zu klassifizierende Zeichensalat liegt als Zeichenwurst vor und sollte dementsprechend auch verarbeitet werden.
Schon die Erstellung eines String pro Zeile kostet Zeitressourcen, die anschließende Aufspaltung in subStrings kostet noch mehr. Es muss ein Objekt erstellt werden und alle Zeichen müssen dabei jedes mal kopiert werden.
Ein schnellerer Algorithmus nimmt beliebig lange Zeichenwürste als Eingabe und gibt die Anfangs- und Endpunkte der in der Wurst enthalten klassifizierbaren Teile sowie deren Klassifizierung aus.
ska-ot weiß aber nicht, dass das Laden der Zeichenwurst immer länger dauert als die Verarbeitung im guten OOStil derselben.
Mir ist aber immer noch nicht ganz klar, wofür das ganze gebraucht wird...Also was soll letztlich eingelesen werden (am besten mit Beispiel) und was soll hinterher in eine Datei geschrieben werden (mit wieder am besten einer auf die Beispieleingabe bezogenen Ausgabe)...

Schön OOmäßig ist es so:

    public static String classify(String str) {
        try {
            Integer.parseInt(str);
            return "int";
        } catch (NumberFormatException ignore) {
        }
        try {
            Double.parseDouble(str);
            return "double";
        } catch (NumberFormatException ignore) {
        }
        return "String";
    }

    public static void main(String[] args) {
        for (String s : new String[]{"123", "456.", ".7.89", "abc", "987", "65.4", "32.1", "dfg"}) {
            System.out.println(s + " -> " + classify(s));
        }
    }

classify(String) erklärt sich so fast wie von selbst. Man kann sicherlich auch noch enum damit verwenden.

Einzelne Zeilen, die man durch BufferedReader.readLine() erhält, kann man "sehr schnell" mit Pattern und Matcher in einzelne Strings aufteilen - eine Alternative zu String.split(Stringregex) .

 

[despikyxd]

@TO
du hast dir deine antwort schon selbst gegeben

... komma separierte namen ...

gut und warum googlest du dann nich mal nach sowas wie "java csv" und suchst dir ne lib die die csv-strings erstmal in einzelne objekte zerlegt ? ... dann einfach die oben genannten methoden drauf anwenden

 

[ska-ot]

phu! erstmal die antworten von also denn geistig verarbeiten...

... desweiteren: das hauptproblem lag ja nur daran (wie auch im startpost zu lesen) das ich Wissen wollte, wie man ermittelt ob ein wert eine Zahl oder ein String ist...

aber wenn ich noch einiges über das einlesen und verarbeiten von datein lerne um so besser ^^...

zu alsodenn's frage wegen der Eingabedaten... die eingabe daten sehen z.B. so aus:

attr_name1,Attr_name2,Attr_name3,Attr_name4
Stringwert1,Stringwert2,4953,2323.234
Stringwert3,Stringwert4,23423,2342.2223
etc.

Ausgabe ist:

attr_name1,typ:(Aplhanumeric oder Numeric),länge,nachkomma(bei komma zahlen)
attr_name2,typ:(Aplhanumeric oder Numeric),länge,nachkomma(bei komma zahlen)
etc

Die Anzahl der Atribute in einer Zeile ist von datei zu datei unterschidlich. Derzeit versuche ich mich am Buffered Reader und splitte dann den kram aus...