Guardar ArrayLists en bases de datos SQLite

No puede insertar ArrayList directamente en Sqlite. En su lugar, puede utilizar JSONObject (org.json.JSONObject) para insertar ArrayList. Por favor, compruebe debajo del fragmento, puede probar algo como abajo ….

Para insertar,

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

Inserte la cadena en db.

Para leer, lea la cadena de db como String,

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

Para insertar :

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

//….Add Valores para 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 

Para recuperar:

Obtenga la cadena de SQLiteDatabse lo que guardó y cambió al tipo ArrayList como 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); 

Sugiero pasar por los 3 tutoriales de Bloc de notas que desea almacenar los valores de su almacenamiento en una tabla de base de datos. No almacena la matriz real directamente en la base de datos sólo los datos. Pero en realidad no debería utilizar una matriz en absoluto en lugar de agregar un nuevo elemento a la matriz en lugar de llamar a su método de inserción de db

He tenido que hacer algo similar en mi aplicación, donde tengo una clase personalizada (Foo, Bar, etc.) y tengo un ArrayList de foo, barra, etc. que persisto en SQL. Mi conocimiento de SQL no es fuerte, pero voy a explicar mi enfoque aquí en caso de que ayuda. Mi comprensión es que para almacenar cualquier tipo de objeto, es necesario definir una tabla en particular para ese tipo de objeto, donde la tabla tiene columnas separadas que representan los tipos primitivos dentro de ese objeto. Además, para persistir y recuperar un ArrayList de esos objetos, usará una fila de tabla por cada entrada de ArrayList e itera en un bucle para almacenar y recuperar.

Hay ArrayLists de varias clases personalizadas en mi aplicación que quería persistir en DB. Por lo tanto, para hacer las cosas ordenadas (bueno, para mí al menos – todavía soy un relativamente nuevo Java / Android programador, así que tomar esto con una pizca de sal) decidí poner en práctica una especie de "Interfaz Serializable de SQL" que mi Los objetos DB-persistable deben implementar. Cada objeto (Foo, Bar, etc.) que se puede persistir en DB debe implementar:

1. Se trata de una cadena de caracteres STAT_NAME final estática pública, el nombre de la tabla de base de datos SQL utilizada para este tipo de objeto.
2. Una versión final estática pública TABLE_CREATE_STRING, una instrucción SQL completa para crear la tabla para este objeto.
3. Método constructor para rellenar sus variables miembro desde un objeto ContentValues.
4. Un método 'get' para rellenar un ContentValues ​​de sus variables miembro.

Por lo tanto, digamos que tengo ArrayLists de objetos Foo y Bar. Cuando se crea por primera vez el DB, dentro de mi clase auxiliar de DB llamo Foo.TABLE_CREATE_STRING, Bar.TABLE_CREATE_STRING, etc. para crear las tablas de esos objetos.

Para poblar mi ArrayList, uso algo como:

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

En mi caso fue ArrayList de clases POJO Nota

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

Como manual dice JSONObject sólo admite los siguientes tipos: Object: un objeto JSONObject, JSONArray, String, Boolean, Integer, Long, Double, NULL o null. No pueden ser NaNs o infinitos. Por lo tanto, debo romper mi clase de Nota en objetos soportados.

  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 creado array en JSONObject.

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

Crear cadena.

 String notesList = json.toString(); 

Poner String creado en ContentValues, causa en mi caso es la aplicación para Android

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

Y cuando debo leer los valores de la base de datos 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(); 

Crear una clase dbHelper que tiene una clase interna y prácticamente todo lo que el tutorial de bloc de notas dice. La clase debe tener un método de inserción algo así:

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

A continuación, este método añadirá valores a la fila de la tabla. Después de que usted puede llamar a este método de su actividad principal y ya que está utilizando el cursor creo que va a llamar al método en un bucle for

Para (i = 0; list.length (); i ++) o puede ser su lista.size: P

{

// Llame el método aquí

}

Y seguir añadiendo valor en la base de datos llamando al método in for loop