Salvataggio di elenchi di array nei database SQLite

Quindi voglio salvare un set ordinato di valori double e voglio poter inserire, recuperare o cancellare qualsiasi valore da questo facilmente. Di conseguenza, sto usando un ArrayList, dove definisco una class chiamata Double per memorizzare i valori double.

Come posso archiviare questo arraylist in un record in un database SQLite? Voglio dire … quale dovrebbe essere il tipo di colonne? Può essere fatto?

Non è ansible inserire ArrayList direttamente in Sqlite. Invece, è ansible utilizzare JSONObject (org.json.JSONObject) per inserire ArrayList. Si prega di controllare sotto snippet, si può provare qualcosa come di seguito ….

Inserire,

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

Inserisci la stringa in db.

Per leggere, leggere la stringa da db as String,

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

Inserire :

 ArrayList inputArray=new ArrayList(); 

//…. Aggiungi valori a inputArray

 Gson gson = new Gson(); String inputString= gson.toJson(inputArray); System.out.println("inputString= " + inputString); use "inputString" to save the value of ArrayList in SQLite Database 

Per recuperare:

Ottieni la stringa da SQLiteDatabse che cosa hai salvato e modificato nel tipo ArrayList come di seguito:

outputarray è una stringa ottenuta da SQLiteDatabase per questo esempio.

 Type type = new TypeToken>() {}.getType(); ArrayList finalOutputString = gson.fromJson(outputarray, type); 

Suggerisco di passare attraverso tutti e 3 i tutorial di Blocco note che si desidera memorizzare i valori memorizzati in una tabella di database. non si archivia l’array attuale direttamente nel database solo i dati. ma in realtà non è necessario utilizzare un array, invece di aggiungere un nuovo elemento all’array, invece di chiamare il metodo db insert

Ho avuto bisogno di fare qualcosa di simile nella mia applicazione, dove ho una class personalizzata (Foo, Bar, ecc.) E ho un ArrayList di foo, bar, ecc. Che continuo a SQL. La mia conoscenza di SQL non è forte, ma spiegherò il mio approccio qui nel caso in cui aiuta. La mia comprensione è che per memorizzare qualsiasi tipo di object, è necessario definire una tabella particolare per quel tipo di object, in cui la tabella ha colonne separate che rappresentano i tipi primitivi all’interno di quell’object. Inoltre, per mantenere e recuperare un ArrayList di tali oggetti, si utilizzerà una riga di tabella per voce ArrayList e si itera su un ciclo per archiviare e recuperare.

Ci sono liste di array di diverse classi personalizzate nella mia applicazione che volevo persistere in DB. Quindi, per rendere le cose in ordine (beh, almeno per me – sono ancora un programmatore Java / Android relativamente recente, quindi prendilo con un pizzico di sale) Ho deciso di implementare una sorta di “SQL Serializable Interface” che il mio Gli oggetti persistibili DB devono essere implementati. Ogni object (Foo, Bar, ecc.) Che può essere conservato su DB deve implementare:

  1. Una stringa TABLE_NAME finale statica pubblica, il nome della tabella del DB SQL utilizzato per questo tipo di object.
  2. Una finale statica pubblica TABLE_CREATE_STRING, un’istruzione SQL completa per creare la tabella per questo object.
  3. Un metodo di costruzione per popolare le sue variabili membro da un object ContentValues.
  4. Un metodo ‘get’ per popolare un ContentValues ​​dalle sue variabili membro.

Quindi, diciamo che ho elenchi di oggetti di oggetti Foo e Bar. Quando il DB viene creato per la prima volta, all’interno della mia class helper DB, chiamo Foo.TABLE_CREATE_STRING, Bar.TABLE_CREATE_STRING, ecc. Per creare le tabelle per tali oggetti.

Per popolare il mio ArrayList, io uso qualcosa come:

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

Nel mio caso era ArrayList delle classi 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; } 

Come dice il manuale, JSONObject supporta solo i seguenti tipi: Oggetto: JSONObject, JSONArray, String, Boolean, Integer, Long, Double, NULL o null. Potrebbe non essere NaN o infinito. Quindi, dovrei interrompere la mia class Note in oggetti supportati.

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

Pack ha creato un array in JSONObject.

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

Crea una stringa.

 String notesList = json.toString(); 

Metti la stringa creata in ContentValues, perché nel mio caso si tratta dell’app Android

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

E quando dovrei leggere i valori dal database SQLite.

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

Crea una class dbHelper che abbia una class interna e più o meno tutto ciò che dice il tutorial del blocco note. La class deve avere un metodo di inserimento simile a questo:

 public long insertRows(ContentValues values, String tableName) { long val = myDatabase.insert(tableName, null, values); return val; } 

Questo metodo aggiungerà quindi i valori nella riga della tabella. Dopodiché puoi chiamare questo metodo dalla tua attività principale e visto che stai usando il cursore credo che chiamerai il metodo in un ciclo for

per (i = 0; list.length (); i ++) o potrebbe essere il suo list.size: P

{

// Chiama il metodo qui

}

e continua ad aggiungere valore nel database chiamando il metodo in ciclo for