web-dev-qa-db-fra.com

Enregistrement de ArrayLists dans des bases de données SQLite

Je souhaite donc sauvegarder un ensemble ordonné de valeurs doubles et pouvoir insérer, récupérer ou supprimer n'importe quelle valeur facilement. En tant que tel, j'utilise un ArrayList, dans lequel je définis une classe appelée Doubles pour stocker les valeurs doubles.

Comment puis-je stocker cet arraylist dans un enregistrement dans une base de données SQLite? Je veux dire ... quel devrait être le type de colonne? Cela peut-il être fait?

androiddatabasesqlite
15
Achint

Vous ne pouvez pas insérer ArrayList directement dans Sqlite. Au lieu de cela, vous pouvez utiliser JSONObject (org.json.JSONObject) pour insérer la liste de tableaux. S'il vous plaît vérifier ci-dessous extrait, vous pouvez essayer quelque chose comme ci-dessous ....

Insérer,

JSONObject json = new JSONObject();
json.put("uniqueArrays", new JSONArray(items));
String arrayList = json.toString();

Insérez la chaîne dans db.

Pour lire, Lire la chaîne de db sous forme de chaîne, 

 JSONObject json = new JSONObject(stringreadfromsqlite);
  ArrayList items = json.optJSONArray("uniqueArrays");
50
Sukumar

Insérer :

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

//....Add Values ​​to inputArray

Gson gson = new Gson();

String inputString= gson.toJson(inputArray);

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


use "inputString" to save the value of ArrayList<String> in SQLite Database

Retrouver:

Obtenez la chaîne de la SQLiteDatabse ce que vous avez enregistré et changé en type ArrayList comme ci-dessous:

outputarray est une chaîne obtenue de SQLiteDatabase pour cet exemple.

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

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

Dans mon cas, c'était ArrayList des classes POJO. Note

private String mNoteTitle;
private int mFingerIndex;
private Point mNoteCoordinates;

public Note(String noteTitle, int fingerIndex, Point noteCoordinates) {
    this.mNoteTitle = noteTitle;
    this.mFingerIndex = fingerIndex;
    this.mNoteCoordinates = noteCoordinates;
}

Comme le dit le manuel, JSONObject ne prend en charge que les types suivants: Object: un JSONObject, JSONArray, String, Boolean, Integer, Long, Double, NULL ou null. Ne peut être ni NaN ni infini. Donc, je devrais diviser ma classe Note en objets supportés. 

 JSONObject json = new JSONObject();
    JSONArray jsonArray = new JSONArray();

    for(Note note: chordShape.getNotes()){
        JSONObject singleNoteJsonObject = new JSONObject();

        try {
            singleNoteJsonObject.put(SHAPE_NOTE_TITLE, note.getNoteTitle());
            singleNoteJsonObject.put(SHAPE_NOTE_FINGER_INDEX, note.getFingerIndex());
            singleNoteJsonObject.put(SHAPE_NOTE_X, note.getNoteCoordinates().x);
            singleNoteJsonObject.put(SHAPE_NOTE_Y, note.getNoteCoordinates().y);
        } catch (JSONException e){
            e.printStackTrace();
        }

        jsonArray.put(singleNoteJsonObject);

    }

Compressez le tableau créé dans JSONObject.

try {
        json.put(SHAPE_NOTES, jsonArray);
        Log.i(TAG, json.toString());
    } catch (JSONException e){
        e.printStackTrace();
    }

Créer une chaîne.

String notesList = json.toString();

Mettez la chaîne créée dans ContentValues, car dans mon cas c'est une application Android

if(notesList.length() > 0){
        contentValues.put(DatabaseHelper.SHAPE_NOTES_LIST, notesList);
    }

Et quand je devrais lire les valeurs de la base de données SQLite.

ArrayList<Note> notes = new ArrayList<>();
    while(cursor.moveToNext()){
        JSONObject jsonNotes = null;
        try {
           jsonNotes = new JSONObject(cursor.getString(cursor.getColumnIndex(DatabaseHelper.SHAPE_NOTES_LIST)));
        } catch (JSONException e){
            e.printStackTrace();
        }

        if(jsonNotes != null){
            Log.i(TAG, jsonNotes.toString());
            JSONArray jsonArray = jsonNotes.optJSONArray(SHAPE_NOTES);
            for(int i = 0; i < jsonArray.length(); i++){
                Note note = null;
                JSONObject arrayObject = null;

                try {
                    arrayObject = jsonArray.getJSONObject(i);
                } catch (JSONException e){
                    e.printStackTrace();
                }

                if(arrayObject != null){
                    try {
                        note = new Note(
                            arrayObject.getString(SHAPE_NOTE_TITLE),
                                arrayObject.getInt(SHAPE_NOTE_FINGER_INDEX),
                                new Point(
                                        arrayObject.getInt(SHAPE_NOTE_X),
                                        arrayObject.getInt(SHAPE_NOTE_Y)
                                )
                        );
                    } catch (JSONException e){
                        e.printStackTrace();
                    }
                }


                if(note != null){
                    notes.add(note);
                }
            }
        }
    }
    cursor.close();
1
Volodimir Shalashenko

Je suggère de parcourir tous les tutoriels 3 du Bloc-notes vous souhaitez stocker les valeurs que vous stockez dans une table de base de données. vous ne stockez pas le tableau réel directement dans la base de données, mais uniquement les données. mais vous ne devriez pas vraiment avoir besoin d'utiliser un tableau du tout au lieu d'ajouter un nouvel élément au tableau plutôt d'appeler votre méthode d'insertion de base de données

0
wired00

J'ai eu besoin de faire quelque chose de similaire dans mon application, où j'ai une classe personnalisée (Foo, Bar, etc.) et un ArrayList de foo, bar, etc. que je persiste en SQL. Ma connaissance de SQL n'est pas solide, mais je vais expliquer mon approche ici au cas où cela aiderait. D'après ce que je comprends, pour stocker n'importe quel type d'objet, vous devez définir une table particulière pour ce type d'objet. La table comporte des colonnes distinctes représentant les types primitifs de cet objet. En outre, pour conserver et récupérer une liste de tableaux de ces objets, vous utiliserez une ligne de tableau par entrée de liste de tableaux et effectuerez une itération dans une boucle pour le stockage et la récupération. 

Il y a des ArrayLists de plusieurs classes personnalisées dans mon application que je voulais conserver dans la base de données. Donc, pour mettre les choses en ordre (enfin, du moins pour moi - je suis toujours un programmeur Java/Android relativement nouveau, prenez donc cela avec une pincée de sel), j'ai décidé de mettre en œuvre une sorte d '"interface sérialisable SQL" qui Les objets persistants dans la base de données doivent être implémentés. Chaque objet (Foo, Bar, etc.) pouvant être conservé dans la base de données doit implémenter:

  1. Une chaîne publique statique finale TABLE_NAME, nom de la table de base de données SQL utilisée pour ce type d'objet.
  2. Publique statique final TABLE_CREATE_STRING, une instruction SQL complète pour créer la table pour cet objet.
  3. Une méthode constructeur pour renseigner ses variables membres à partir d'un objet ContentValues. 
  4. Une méthode 'get' pour renseigner une ContentValues ​​à partir de ses variables membres.

Alors, disons que j'ai ArrayLists d'objets Foo et Bar. Lorsque la base de données est créée pour la première fois, dans ma classe d'assistance de base de données, j'appelle Foo.TABLE_CREATE_STRING, Bar.TABLE_CREATE_STRING, etc. pour créer les tables pour ces objets. 

Pour remplir mon ArrayList, j'utilise quelque chose comme:

cursor = dbh.retrieve(Foo.TABLE_NAME);
if(!cursor.moveToFirst()){
  return false
}
do{
  DatabaseUtils.cursorRowToContentValues(cursor, vales);
  FooArrayList.add( new Foo(values) );
} while( cursor.moveToNext() );
0
Trevor