Guardar ArrayLists en bases de datos SQLite

Question

Así que quiero guardar un conjunto ordenado de valores dobles, y quiero poder insertar, recuperar o borrar cualquier valor de esta fácilmente. Como tal, estoy usando un ArrayList, donde defino una clase llamada Dobles para almacenar los valores dobles.

¿Cómo guardo esta lista de arrays en un registro en una base de datos SQLite? Quiero decir ... ¿qué tipo de columnas debería ser? Se puede hacer?

Answer 1

No puede insertar ArrayList directamente en Sqlite. En su lugar, puede usar JSONObject (org.json.JSONObject) para insertar ArrayList. Por favor marque abajo, fragmento, se puede intentar algo como a continuación ....

Para insertar,

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

insertar la cadena en dB.

para leer, leer la cadena de db como secuencia,

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

Answer 2

Sugiero pasar por todos los 3 Notepad tutorials 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 solo los datos. pero en realidad no debería necesitar usar una matriz en lugar de agregar un nuevo elemento a la matriz. Llame a su método insert db

Answer 3

crear una clase dbHelper que tiene una clase interna y más o menos lo dice el tutorial bloc de notas. La clase debe tener un método de inserción algo como esto: -

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

Este método continuación, agregar valores en la fila de la tabla. Después de eso puede llamar a este método desde su actividad principal y dado que está utilizando el cursor, creo que llamará al método en un ciclo for

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

{

// llamar al método aquí

}

y seguir añadiendo valor en la base de datos mediante una llamada al método en el bucle for

Answer 4

He necesitado hacer algo similar en mi aplicación, donde tengo una clase personalizada (Foo, Bar, etc.) y tengo un ArrayList de foo, bar, etc. que persisto en SQL. Mi conocimiento de SQL no es fuerte, pero explicaré mi enfoque aquí en caso de que me ayude. Según entiendo, para almacenar cualquier tipo de objeto, debe definir una tabla particular para ese tipo de objeto, donde la tabla tiene columnas separadas que representan los tipos primitivos dentro de ese objeto. Además, para conservar y recuperar una ArrayList de esos objetos, usará una fila de la tabla por cada entrada de ArrayList e iterará en un bucle para almacenar y recuperar.

Hay ArrayLists de varias clases personalizadas en mi aplicación que quería mantener en DB. Por lo tanto, para que todo esté ordenado (bueno, al menos para mí, todavía soy un programador de Java/Android relativamente nuevo, así que tómenlo con una pizca de sal) Decidí implementar una especie de "interfaz serializable SQL" que mi Los objetos con persistencia DB deben implementarse. Cada objeto (Foo, Bar, etc.) que puede persistir para que DB implemente:

1. Cadena final TABLE_NAME estática pública, el nombre de la tabla SQL DB utilizada para este tipo de objeto.
2. A static final público TABLE_CREATE_STRING, una instrucción SQL completa para crear la tabla para este objeto.
3. Método de constructor para rellenar sus variables miembro de un objeto ContentValues.
4. Un método "get" para rellenar un ContentValues ​​a partir de sus variables miembro.

Entonces, di que tengo ArrayLists of objects Foo and Bar. Cuando se crea el DB por primera vez, dentro de mi clase de ayuda DB llamo a Foo.TABLE_CREATE_STRING, Bar.TABLE_CREATE_STRING, etc. para crear las tablas para esos objetos.

Para llenar mi ArrayList, utilizo 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()); 

Answer 5

insertar:

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

Valores

//....Add a 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 

es posible recuperar :

Obtén la Str desde SQLiteDatabse lo que ha guardado y cambiado a tipo ArrayList como se muestra 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); 

Answer 6

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 siguientes tipos: Referencia: a JSONObject, JSONArray, String, Boolean, Integer, Long, doble, NULL, o nulo. Puede que no sean NaNs o infinitos. Por lo tanto, debería dividir mi clase Note en objetos compatibles.

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

    } 

Paquete creado matriz en JSONObject.

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

Crear cadena.

String notesList = json.toString(); 

Put cadena creada en ContentValues, porque en mi caso se trata de la aplicación para Android

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

Y cuando yo debería leer los valores de 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();