Guardando ArrayList en la base de datos SQLite en Android

Question

He estado trabajando con SQLite en android y me gustaría agregar una lista de arrays a una columna en una tabla, y luego recuperar los datos como una lista de arrays. El arraylist es una lista de Longs. Me he dado cuenta de que SQL tiene una opción para almacenar BLOBS, sin embargo, parece que necesito convertir el arraylist a un byte [] antes de poder almacenarlo como un blob en mi base de datos SQLite.

Si alguien tiene una solución sobre cómo guardar listas de arreglos en una base de datos SQLite que sería muy apreciada. ¿O hay alguna otra opción para guardar mi matriz de datos, debería considerar?

Answer 1

Parece que desea serializar la lista. Here is a tutorial/intro a la API de serialización de Java.

Answer 2

Vas a tener que hacerlo de forma manual, a través de cada elemento de la lista y el cambio a byte antes de almacenarlos en la base de datos

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

Answer 3

Por favor, perdóname por plagiar salvajemente mi respuesta anterior a BLOB vs. VARCHAR for storing arrays in a MySQL table. Las otras respuestas de allí también son muy pertinentes.

Creo que el enfoque de Con es probablemente mejor que usar la serialización de Java, ya que la serialización integrada de Java necesitará bytes adicionales, y las aplicaciones que no son de Java tendrán más dificultades para manejar los datos.

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; 
    } 

} 

Nota: Si sus listas a veces contendrán más de 31 largos (248 bytes), entonces usted tendrá que utilizar BLOB. No puede usar BINARY() o VARBINARY() en MySQL. Me doy cuenta de que estás preguntando por SQLite, pero en el espíritu de plagio por completo mi respuesta anterior, voy a fingir que estás preguntando sobre MySQL:

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

tenía dos ArrayList<String>, tanto las entradas será de 1000. Miré blobs y bytes, pero para mí la solución para acelerar el proceso y hacerlo utilizable fue cambiando el método de insertar y deshacerse de database.insert - Crédito para esto es 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(); 
     } 
    } 

Se adapta fácilmente a Longs, Integers, etc. y aligera rápidamente. Así que afortunadamente ya no tuve que volver a rascarme la cabeza por las manchas y los bytes. Espero eso ayude.

Answer 5

insertar:

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

Valores //....Add a inputArray

Gson gson = new Gson(); 

String inputString= gson.toJson(inputArray); 

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

uso "inputString" para guardar el valor de ArrayList en la base de datos SQLite

Para recuperar :

Obtenga la cadena de SQLiteDatabse lo que guardó y cambió en ArrayList escriba como se muestra a continuación: outputarray es una cadena que se obtiene de SQLiteDatabase para este ejemplo.

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

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

• En el uso de texto en formato SQLite para almacenar el valor de cadena .....

Answer 6

Hay una manera más fácil de hacerlo de otra manera. puede hacer una cadena que conste de todos sus valores de matriz. . para que crea un StringBuilder y añadir los valores de forma continua y offcource con un separador (como un simbole que el que no va a utilizar en sus valores de matriz, por ejemplo virtual '|' en el código, por ejemplo:

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(); 

.

cuando desee recuperarlos y usar los valores. Obtenga la columna de la base de datos pura en String y con la opración splite() purifica cada valor de matriz en una columna de matriz que puede usar fácilmente :)

permite hacerlo en código:

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

con un simple convertido, puede usarlos como dobles;

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

tal vez no es estándar, pero es útil, ayuda esperanza;)

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]);