Sauvegarde de ArrayList dans la base de données SQLite sur Android

À Insérer :

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

//....Ajouter des valeurs à inputArray

Gson gson = new Gson();

String inputString= gson.toJson(inputArray);

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

utilisez "inputString" pour sauvegarder la valeur de ArrayList dans la base de données SQLite

Pour récupérer:

Obtenir la Chaîne de caractères à partir de la SQLiteDatabse ce que vous avez enregistré et converti en ArrayList type comme ci-dessous: outputarray est une chaîne de caractères issue de SQLiteDatabase pour cet exemple.

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

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

• dans SQLite utiliser le texte comme format pour stocker la chaîne Valeur.....

s'il vous Plaît pardonnez-moi pour sauvagement plagier ma réponse précédente à BLOB vs. VARCHAR pour stocker des tableaux dans une table MySQL. Les autres réponses sont également très pertinentes.

je pense que L'approche de Con est probablement meilleure que d'utiliser la sérialisation java puisque la sérialisation intégrée de java nécessitera des octets supplémentaires, et les applications non-java auront plus de difficulté à traiter les données.

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

}

Note: Si vos listes contiennent parfois plus de 31 longs (248 octets), alors vous aurez besoin d'utiliser BLOB. Vous ne pouvez pas utiliser binaire() ou VARBINARY() dans MySQL. Je me rends compte que vous posez des questions sur SQLite, mais dans l'esprit de plagier complètement ma réponse précédente, je vais prétendre que vous posez des questions sur 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

j'ai eu deux ArrayList<String>, les deux seront plus de 1000 entrées. J'ai regardé les blobs et les bytes, mais pour moi la solution pour accélérer le processus et le rendre utilisable était en changeant la méthode insert et se débarrasser de database.insert - le crédit pour ceci est ici.

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

il est facilement adaptable à des longueurs et des entiers etc et la foudre rapide. Donc heureusement je n'ai pas eu à me gratter la tête plus longtemps au sujet des blobs et des bytes! Espérons que cela aide.

il y a une façon plus facile de faire une telle chose d'une façon complètement différente. vous pouvez faire une chaîne qui se compose de toutes vos valeurs de tableau. pour cela faites un StringBuilder et ajoutez les valeurs en continu et offcource avec un séparateur (comme un simbole you que vous n'utiliserez pas dans vos valeurs de tableau . par exemple virtuel '|' . dans le code, par exemple :

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

lorsque vous souhaitez récupérer et utiliser les valeurs. obtenir la colonne de la base de données pure il à la chaîne et avec la splite() opration pure chaque valeur de tableau dans une colonne de tableau Que u peut facilement l'utiliser:)

permet de le faire dans le code :

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

avec un simple convertir vous pouvez les utiliser comme double;

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

peut-être que ce n'est pas la norme, mais il est utile, l'espoir de l'aide ;)

on dirait que vous voulez sérialiser la liste. Voici un tutoriel/intro à L'API de sérialisation Java.

vous devrez le faire manuellement, passer en revue chaque élément de la liste et le modifier en byte avant de le stocker dans la base de données

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

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