Enregistrement de liste de tableaux dans la base de données SQLite sous Android

J'ai travaillé avec SQLite sous android et je voudrais ajouter une liste de tableaux à une colonne dans une table, et de récupérer les données en arrière comme une liste de tableaux. La liste de tableaux est une liste de Longs. J'ai remarqué que SQL dispose d'une option pour le stockage d'objets BLOB, cependant, il semble que j'ai besoin de convertir la liste de tableaux à un byte[] d'abord, avant de pouvoir l'enregistrer comme une tache dans ma base de données SQLite.

Si quelqu'un a une solution sur la façon d'enregistrer arraylists dans une base de données SQLite qui serait grandement apprécié. Ou est-il une autre option pour l'enregistrement de mon tableau de données, je dois prendre en compte?

InformationsquelleAutor Mango | 2010-06-29

26

À 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);
```
utiliser "inputString" pour enregistrer la valeur de liste de tableaux dans la Base de données SQLite

À 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 qui est d'obtenir 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 de stockage de la chaîne de Valeur.....
- qu'est-ce que Gson? Il n'y a pas d'option pour imposte cette classe.
- href="https://github.com/google/gson" >github.com/google/gson) est une bibliothèque pour la conversion des objets Java et de JSON à l'aide de réflexion".
- Merci @sandrstar
InformationsquelleAutor Ashok

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 là-bas sont également très pertinent.

Je pense que les inconvénients de l'approche est probablement mieux que d'utiliser la sérialisation java depuis java builtin sérialisation auront besoin de plus d'octets, et non des applications java sera plus difficile de traiter avec 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;
    }

}

Remarque: Si votre liste contient parfois plus de 31 longs (248 octets), alors vous aurez besoin d'utiliser d'objets BLOB. Vous ne pouvez pas utiliser les BINAIRES() ou VARBINARY() de MySQL. Je me rends compte que vous vous dites à propos de SQLite, mais dans l'esprit de complètement plagiat de ma précédente réponse, je vais faire semblant que vous vous dites à propos de 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

InformationsquelleAutor Julius Musseau

J'ai eu deux ArrayList<String>, les deux vont de+ de 1000 entrées. J'ai regardé les blobs et les octets, mais pour moi la solution pour accélérer le processus et de le rendre utilisable était en changeant la méthode d'insertion et de se débarrasser de database.insert - Crédit pour ce qui 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 à de Longs et les Entiers, etc, et de l'éclair rapide. Donc, heureusement, je n'ai pas à le rayer de ma tête plus à propos de gouttes et d'octets! Espérons que cela aide.

InformationsquelleAutor brandall

4

Il y a un moyen plus simple que de faire une telle chose complètement d'une autre manière.
vous pouvez faire une chaîne qui se compose de toutes vos valeurs de tableau.
pour cela faites un StringBuilder et ajouter les valeurs en continu et offcource avec un séparateur (comme un simbole vous que vous ne l'utilisez pas dans votre tableau de valeurs . 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();
```
quand vous voulez les récupérer et utiliser les valeurs. obtenir de la colonne à partir de la base de données de pure en String et avec le splite() opration pur chacune des valeurs du tableau dans une colonne de la matrice de 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 😉

InformationsquelleAutor Mohammad Hadi
2

Sonne comme vous voulez pour sérialiser la Liste. Voici un tutoriel/intro à la Sérialisation Java API.
- le lien est mort...
- lien de java.com/
InformationsquelleAutor matt b
1

Vous devrez le faire manuellement, passez à travers chaque élément de la liste et de le modifier pour l'octet avant de les stocker dans la base de données
```
for (long l : array<long>){
//change to byte here
//Store in database here
}
```
InformationsquelleAutor Con

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

InformationsquelleAutor JamisonMan111

Vous devez vous connecter pour publier un commentaire.