Integer aus String

[Gast]

Morgen,

die Umwandlung von einen hexString in einen Integer, kann man die optimieren.
momentan habe ich folgenden Code:

Integer.valueOf(hexString1 + hexString2, 16);

diese Zeile möchte ich optimieren, lässt sich da noch was machen?
schönen Tag noch,

 

[foobar]

Was willste da optimieren? Ist das der Flaschenhals deiner Anwendung? Wohl kaum oder?

 

[FArt]

More computing sins are committed in the name of efficiency (without necessarily achieving it) than for any other single reason - including blind stupidity.

William Allan Wulf

So viel zu dem Thema ...

 

[Guest]

Integer.valueOf(hexString1 + hexString2, 16);

diese Zeile möchte ich optimieren, lässt sich da noch was machen?

Zunächst einmal benötigst Du wahrscheinlich gar keinen Integer (Referenztyp), sondern einen int (primitiver Typ). Ersetze valueOf durch parseInt:

public static int parse1(String hexString1, String hexString2)
{
    return Integer.parseInt(hexString1 + hexString2, 16);
}

Falls die beiden Strings immer jeweils vier Zeichen lang sind, dann kannst Du Dir die Stringkonkatenation sparen und einfach beide Strings parsen und dann das Ergebnis passed zusammenbauen:

public static int parse2(String hexString1, String hexString2)
{
    return Integer.parseInt(hexString1, 16) << 16
         | Integer.parseInt(hexString2, 16);
}

Du kannst auch manuell parsen (wie gesagt unter der Voraussetzung, dass beide Strings immer genau vier Zeichen lang sind):

public static int parse3(String hexString1, String hexString2)
{
    return Character.digit(hexString1.charAt(0), 16) << 28
         | Character.digit(hexString1.charAt(1), 16) << 24
         | Character.digit(hexString1.charAt(2), 16) << 20
         | Character.digit(hexString1.charAt(3), 16) << 16
         | Character.digit(hexString2.charAt(0), 16) << 12
         | Character.digit(hexString2.charAt(1), 16) << 8
         | Character.digit(hexString2.charAt(2), 16) << 4
         | Character.digit(hexString2.charAt(3), 16);
}

Dazu noch ein kleines Testprogramm, um zu schauen, dass wir keinen Blödsinn programmiert haben:

public static void test(String hexString1, String hexString2)
{
	System.out.println(parse1(hexString1, hexString2));
	System.out.println(parse2(hexString1, hexString2));
	System.out.println(parse3(hexString1, hexString2));
}

public static void main(String[] args)
{
	test("1337", "BABE");
}

Fred

 

[Marco13]

FALLS das wirklich der Bottleneck deiner Anwendung ist, kannst du das optimieren. Wie seht, hängt immer davon ab, wie genau du die Eingabedaten kennst. FALLS es immer ein gültiger Hex-String (mit Großbuchstaben) ist, kannst du sowas machen wie

class HexToIntTest
{
    static String hexStrings[] = new String[]
    {
        "12AB34CD",
        "BADBAD",
        "123456",
        "FAB123",
    };

    public static void main(String args[])
    {
        for (int n=1000; n<=100000000; n*=10)
        {
            test1(n);
            test2(n);
        }
    }


    public static void test1(int n)
    {
        long before = System.nanoTime();
        int sum = 0;
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<hexStrings.length; j++)
            {
                sum += Integer.valueOf(hexStrings[j], 16);
            }
        }
        long after = System.nanoTime();
        System.out.println(sum+" test1 "+(after-before)/1000000);
    }

    public static void test2(int n)
    {
        long before = System.nanoTime();
        int sum = 0;
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<hexStrings.length; j++)
            {
                sum += hexToInt(hexStrings[j]);
            }
        }
        long after = System.nanoTime();
        System.out.println(sum+" test2 "+(after-before)/1000000);
    }

    private static int hexToInt(String s)
    {
        int n = s.length()-1;
        int result = 0;
        int shift = 0;
        for (int i=n; i>=0; i--)
        {
            char c = s.charAt(i);
            int f = (c >= 'A'? c-'A'+10:c-'0');
            result |= (f << shift);
            shift+=4;
        }
        return result;
    }
}

(schon wieder einer dieser unrepräsentativen Microbenchmarks, die suggerieren, dass die "häßliche" Lösung 3x so schnell ist wie die "normale")

Aber ob sich das lohnt, ist fraglich.