Umwandlung string-array zu string und wieder zurück in Java

Ich habe ein array String[] in Java und muss erst codieren/umwandeln in einen String und dann weiter im code verdeckte es wieder auf den String [] - array. Die Sache ist, dass ich jedes Zeichen in einem string in String[] array also ich muss sehr vorsichtig sein bei der Kodierung. Und alle notwendigen Informationen zu Dekodieren, muss es in den endgültigen string zu. Ich kann nicht einen string zurückgeben und einige andere Informationen in einer extra variable.

Mein Algorithmus, den ich entworfen haben, so weit ist es:

Fügen Sie die strings nebeneinander, z.B. so:
String[] a = {"lala", "exe", "a"}
in
String b = "lalaexea"
Anhängen am Ende des Strings die Länge aller strings aus dem String[], getrennt von der Haupt-text durch $ - Zeichen und dann die jeweilige Länge durch ein Komma getrennt, also:

b = "lalaexea$4,3,1"

Dann beim konvertieren es zurück, ich würde Lesen Sie zuerst die Längen von hinten und dann auf Ihnen basieren, die wirkliche strings.

Aber vielleicht gibt es einen einfacheren Weg?

Prost!

Ich finde deine Idee gut!

InformationsquelleAutor Janek | 2012-11-07

Wenn Sie nicht wollen, verbringen so viel Zeit mit string-Operationen, die Sie verwenden könnte, die java-Serialisierung + commons-codecs wie diese:

public void stringArrayTest() throws IOException, ClassNotFoundException, DecoderException {
    String[] strs = new String[] {"test 1", "test 2", "test 3"};
    System.out.println(Arrays.toString(strs));

    //serialize
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    new ObjectOutputStream(out).writeObject(strs);

    //your string
    String yourString = new String(Hex.encodeHex(out.toByteArray()));
    System.out.println(yourString);

    //deserialize
    ByteArrayInputStream in = new ByteArrayInputStream(Hex.decodeHex(yourString.toCharArray()));
    System.out.println(Arrays.toString((String[]) new ObjectInputStream(in).readObject()));
}

Das liefert die folgende Ausgabe:

[test 1, test 2, test 3]
aced0005757200135b4c6a6176612e6c616e672e537472696e673badd256e7e91d7b47020000787000000003740006746573742031740006746573742032740006746573742033
[test 1, test 2, test 3]

Wenn Sie mit maven verwenden, können Sie die folgende Abhängigkeit für die commons-codec:

<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.2</version>
</dependency>

Wie vorgeschlagen mit base64 (zwei Zeilen ändern):

String yourString = new String(Base64.encodeBase64(out.toByteArray()));
ByteArrayInputStream in = new ByteArrayInputStream(Base64.decodeBase64(yourString.getBytes()));

Im Falle der Base64-der Ergebnis-string kürzer ist, für die Sie den code unten ausgesetzt:

[test 1, test 2, test 3]
rO0ABXVyABNbTGphdmEubGFuZy5TdHJpbmc7rdJW5+kde0cCAAB4cAAAAAN0AAZ0ZXN0IDF0AAZ0ZXN0IDJ0AAZ0ZXN0IDM=
[test 1, test 2, test 3]

Bezüglich der Zeiten für die einzelnen Ansätze, führe ich 10^5 Ausführungen, jede Methode und das Ergebnis war wie folgt:

String-manipulation: 156 ms
Hex: 376 ms
Base64: 379 ms

Code verwendet für den test:

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.StringTokenizer;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;


public class StringArrayRepresentationTest {

    public static void main(String[] args) throws IOException, ClassNotFoundException, DecoderException {

        String[] strs = new String[] {"test 1", "test 2", "test 3"};


        long t = System.currentTimeMillis();
        for (int i =0; i < 100000;i++) {
            stringManipulation(strs);
        }
        System.out.println("String manipulation: " + (System.currentTimeMillis() - t));


        t = System.currentTimeMillis();
        for (int i =0; i < 100000;i++) {
            testHex(strs);
        }
        System.out.println("Hex: " + (System.currentTimeMillis() - t));


        t = System.currentTimeMillis();
        for (int i =0; i < 100000;i++) {
            testBase64(strs);
        }
        System.out.println("Base64: " + (System.currentTimeMillis() - t));
    }

    public static void stringManipulation(String[] strs) {
        String result = serialize(strs);
        unserialize(result);
    }

    private static String[] unserialize(String result) {
        int sizesSplitPoint = result.toString().lastIndexOf('$');
        String sizes = result.substring(sizesSplitPoint+1);
        StringTokenizer st = new StringTokenizer(sizes, ";");
        String[] resultArray = new String[st.countTokens()];

        int i = 0;
        int lastPosition = 0;
        while (st.hasMoreTokens()) {
            String stringLengthStr = st.nextToken();
            int stringLength = Integer.parseInt(stringLengthStr);
            resultArray[i++] = result.substring(lastPosition, lastPosition + stringLength);
            lastPosition += stringLength;
        }
        return resultArray;
    }

    private static String serialize(String[] strs) {
        StringBuilder sizes = new StringBuilder("$");
        StringBuilder result = new StringBuilder();

        for (String str : strs) {
            if (sizes.length() != 1) {
                sizes.append(';');
            }
            sizes.append(str.length());
            result.append(str);
        }

        result.append(sizes.toString());
        return result.toString();
    }

    public static void testBase64(String[] strs) throws IOException, ClassNotFoundException, DecoderException {
        //serialize
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        new ObjectOutputStream(out).writeObject(strs);

        //your string
        String yourString = new String(Base64.encodeBase64(out.toByteArray()));

        //deserialize
        ByteArrayInputStream in = new ByteArrayInputStream(Base64.decodeBase64(yourString.getBytes()));
    }

    public static void testHex(String[] strs) throws IOException, ClassNotFoundException, DecoderException {
        //serialize
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        new ObjectOutputStream(out).writeObject(strs);

        //your string
        String yourString = new String(Hex.encodeHex(out.toByteArray()));

        //deserialize
        ByteArrayInputStream in = new ByteArrayInputStream(Hex.decodeHex(yourString.toCharArray()));
    }

}

Dies ist eine sicherere Methode als die vorgeschlagenen. Der overhead ist größer, wenn, mit einer anderen Codierung als hex wie base64 wäre eine gute Idee.
vielen Dank für Ihren Kommentar, den ich gerade kommentiert die änderungen erforderlich, um die Verwendung von base64
Und wie ist die Leistung dieser beiden Lösungen (string-manipulation vs vorgeschlagen, in dieser Antwort)?
Ablassen der Luft über Base64 (beste option IMHO) dauert etwa 17ms auf meinem Rechner für ein Integer-array mit 5. Das aufblasen dauert nur 1ms.

InformationsquelleAutor Francisco Spaeth

1

Verwenden Sie einen Json-parser, wie Jackson zum serialisieren/Deserialisieren eine andere Art von Objekten ebenso wie integer/schwimmt ext in strings und wieder zurück.

InformationsquelleAutor Prakash Nadar

Ich würde das symbol zwischen den Wörtern, um Sie später zu verwenden, die String#split Methode, um den String zurück. In Ihren $ symbol Beispiel, es wäre

public String mergeStrings(String[] ss) {
    StringBuilder sb = new StringBuilder();
    for(String s : ss) {
        sb.append(s);
        sb.append('$');
    }
    return sb.toString();
}

public String[] unmergeStrings(String s) {
    return s.split("\\$");
}

Beachten Sie, dass in diesem Beispiel füge ich ein Doppelzimmer \ vor der $ symbol, da die String#split Methode erhält einen regulären Ausdruck als parameter, und die $ symbol ist ein spezielles Zeichen in regex.

public String processData(String[] ss) {
    String mergedString = mergeStrings(ss);
    //process data...
    //a little example...
    for(int i = 0; i < mergedString.length(); i++) {
        if (mergedString.charAt(i) == '$') {
            System.out.println();
        } else {
            System.out.print(mergedString.charAt(i));
        }
    }
    System.out.println();
    //unmerging the data again
    String[] oldData = unmergeStrings(mergedString);
}

Zur Unterstützung ein Zeichen in Ihrem String[], es wäre besser, nicht ein einzelnes Zeichen als Trenner, sondern stattdessen eine andere String. Die Methoden, die verwandeln würde, in diesem:

public static final String STRING_SEPARATOR = "@|$|@";
public static final String STRING_SEPARATOR_REGEX = "@\\|\\$\\|@";

public String mergeStrings(String[] ss) {
    StringBuilder sb = new StringBuilder();
    for(String s : ss) {
        sb.append(s);
        sb.append(STRING_SEPARATOR);
    }
    return sb.toString();
}

public String[] unmergeStrings(String s) {
    return s.split(STRING_SEPARATOR_REGEX);
}

die OP erklärte, dass er können Sie ein beliebiges Zeichen in einem string in String [] - array, so sollten Sie sich entfliehen Sie dem gewählten separator vor Eintritt, z.B. s.replaceAll("\\$", "\\\\\\$");.
Ich würde lieber die wichtigsten Daten unverändert, stattdessen schlagen vor, ein neues Muster zu trennen, jeder String (und es ist regex, um es zu teilen zurück).
aber es löst nicht das problem, dennoch kann es passieren, dass dieses Muster in einem string in String[]. Eine Idee wäre zum zeichnen immer das Muster, aber dann noch eine Möglichkeit gibt und es nicht zu sein scheinen sehr saubere Lösung.

InformationsquelleAutor Luiggi Mendoza

-1

Nur mit einem bekannten separator (wie @ oder # Anhängen Saiten), dann verwenden Sie yourString.split(yourSeparator), um ein array von es.
- nicht sicher ist, et all, da dieser char-Sequenz vorhanden sein können, auf die saite selbst
- Gut, ich Neige dazu, mit Ihnen zu vereinbaren. Aber man kann immer noch verwenden chars, die sind verboten, irgendwo sonst in Ihre Anwendung, wie jedem char verboten in Datenbanken zum Beispiel. Natürlich @ und # waren Beispiele...
InformationsquelleAutor dounyy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.