ArrayList in SQLite-Datenbank in Android speichern

Question

Ich habe mit SQLite auf Android gearbeitet und möchte eine Arraylist zu einer Spalte in einer Tabelle hinzufügen, und dann die Daten als Arraylist zurückholen. Die Arraylist ist eine Liste von Longs. Ich habe bemerkt, dass SQL eine Option zum Speichern von BLOBS hat, aber es sieht so aus, als müsste ich die Arraylist zuerst in ein Byte [] konvertieren, bevor ich sie als Blob in meiner SQLite-Datenbank speichern kann.

Wenn jemand eine Lösung zum Speichern von Arraylists in einer SQLite-Datenbank hat, würde das sehr geschätzt werden. Oder gibt es eine andere Option zum Speichern meines Datenarrays, sollte ich darüber nachdenken?

Answer 1

Klingt, als ob Sie die Liste serialisieren möchten. Here is a tutorial/intro an die Java-Serialisierungs-API.

Answer 2

Sie müssen es manuell tun, jedes Element in der Liste gehen und es zu Byte ändern, bevor sie in der Datenbank

for (long l : array<long>){ 
//change to byte here 
//Store in database here 
} 

Answer 3

Bitte verzeihen Sie mir die Speicherung für meine vorherige Antwort auf BLOB vs. VARCHAR for storing arrays in a MySQL table savagely plagiieren. Die anderen Antworten da drüben sind ebenfalls sehr relevant.

Ich denke, Con Ansatz ist wahrscheinlich besser als mit Java-Serialisierung, da Java eingebauten Serialisierung zusätzliche Bytes benötigt, und Non-Java-Anwendungen wird es schwerer haben, mit den Daten umzugehen.

public static void storeInDB(ArrayList<Long> longs) throws IOException, SQLException { 

    ByteArrayOutputStream bout = new ByteArrayOutputStream(); 
    DataOutputStream dout = new DataOutputStream(bout); 
    for (long l : longs) { 
     dout.writeLong(l); 
    } 
    dout.close(); 
    byte[] asBytes = bout.toByteArray(); 

    PreparedStatement stmt = null; // however you get this... 
    stmt.setBytes(1, asBytes); 
    stmt.executeUpdate(); 
    stmt.close(); 
} 

public static ArrayList<Long> readFromDB() throws IOException, SQLException { 

    ArrayList<Long> longs = new ArrayList<Long>(); 
    ResultSet rs = null; // however you get this... 
    while (rs.next()) { 
     byte[] asBytes = rs.getBytes("myLongs"); 
     ByteArrayInputStream bin = new ByteArrayInputStream(asBytes); 
     DataInputStream din = new DataInputStream(bin); 
     for (int i = 0; i < asBytes.length/8; i++) { 
      longs.add(din.readLong()); 
     } 
     return longs; 
    } 

} 

Hinweis: Wenn Sie Ihre Listen manchmal mehr als 31 Long-Positionen enthält (248 Byte), dann müssen Sie BLOB verwenden. Sie können BINARY() oder VARBINARY() nicht in MySQL verwenden. Ich weiß, Sie SQLite sind gefragt, aber im Geiste völlig meine Antwort plagiieren, werde ich so tun, als Sie MySQL sind gefragt:

mysql> CREATE TABLE t (a VARBINARY(2400)) ; 
ERROR 1074 (42000): Column length too big for column 'a' (max = 255); 
use BLOB or TEXT instead 

Answer 4

Ich hatte zwei ArrayList<String>, beide werden Einträge 1000+. Ich betrachtete Blobs und Bytes, aber für mich war die Lösung, um den Prozess zu beschleunigen und nutzbar zu machen, indem man die Einfügemethode änderte und database.insert loswird - Kredit dafür ist here.

private static final String INSERT = "insert into " 
      + YOUR_TABLE_NAME+ " (" + COLUMN_1 + ", " 
      + COLUMN_2 + ") values (?, ?)"; 

public void insertArrayData(ArrayList<String> array1, 
      ArrayList<String> array2) { 

     try { 
      database.open(); 
     } catch (SQLException e) { 
      e.printStackTrace(); 
     } 
     int aSize = array1.size(); 

     database.beginTransaction(); 

     try { 
      SQLiteStatement insert = database.compileStatement(INSERT); 

      for (int i = 0; i < aSize; i++) { 

       insert.bindString(1, array1.get(i)); 
       insert.bindString(2, array2.get(i)); 
       insert.executeInsert(); 

      } 

      database.setTransactionSuccessful(); 
     } catch (SQLException e) { 
      e.printStackTrace(); 
     } finally { 
      database.endTransaction(); 
     } 

     try { 
      database.close(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 

Es ist leicht an Longs und Integer usw. anpassbar und blitzschnell. Glücklicherweise musste ich mich nicht länger über Blobs und Bytes am Kopf kratzen! Ich hoffe es hilft.

Answer 5

einzufügen:

ArrayList<String> inputArray=new ArrayList<String>(); 

//....Add Werte

Gson gson = new Gson(); 

String inputString= gson.toJson(inputArray); 

System.out.println("inputString= " + inputString); 

use "input" inputArray den Wert der Arraylist in SQLite Datenbank

Um retreive zu sparen :

Holen Sie den String aus dem SQLiteDatabase, was Sie gespeichert und in ArrayList geändert Geben Sie wie folgt ein: outputarray ist ein String, der für dieses Beispiel aus SQLiteDatabase abgerufen wird.

Type type = new TypeToken<ArrayList<String>>() {}.getType(); 

ArrayList<String> finalOutputString = gson.fromJson(outputarray, type); 

• In SQLite Verwendung Text als Format der String-Wert zu speichern .....

Answer 6

Es gibt einen einfacheren Weg, der so etwas völlig anders macht. können Sie eine Zeichenfolge erstellen, die aus allen Array-Werten besteht. . dafür ein String machen und die Werte kontinuierlich und offcource mit einem Separator hängen (wie ein Simbole Sie, die Sie nicht in Ihrem Array-Werte verwenden, zum Beispiel virtuelle ‚|‘ in Code zum Beispiel:

double[] mylist = new double[]{23, 554, 55}; 
    StringBuilder str = null; 
    str = new StringBuilder(); 

    for(int i=0;i<mylist.length;i++){ 
     str.append(mylist[i]+"|"); 
    } 

    String result = str.toString(); 

    db.open(); 
    db.insert(result); 
    db.close(); 

.

Wenn Sie sie holen und verwenden Sie die Werte. Holen Sie die Spalte aus der Datenbank rein zu String und mit der splite() -Poration jeder Wert von Array in einer Spalte von Array als Sie einfach verwenden können :)

macht es in Code:

String str = db.getdata(); 
    String[] list = str.split("|"); 

mit einem einfachen konvertieren können Sie sie als doppelt verwenden;

double mydouble = Double.parsDouble(list[1].toString()); 

vielleicht ist es nicht Standard, aber es ist hilfreich, Hoffnung Hilfe;)

Answer 7

ArrayList<String> list = new ArrayList<String>(); 
        list.add("Item 1"); 
        list.add("Item 2"); 
        list.add("Item 3"); 

        String joined = TextUtils.join(",", list); 
        Log.i(TAG, "joined strings: " + joined); 

        String[] array = TextUtils.split(joined, ","); 
        Log.i(TAG, "joined strings: " + array[0] + array[1] + array[2]);