android sqlite_wowomnom_Fotolia_85154667

Android SQLite Datenbank Tutorial – Teil 4: Daten in die SQLite Datenbank schreiben und auslesen


In der vierten Lektion unseres mehrteiligen Android SQLite Tutorials werden wir Daten in die SQLite Datenbank schreiben und wieder auslesen.

Zu Beginn werden wir uns mit den Fragen beschäftigen:

  • Wie schreibt man Daten in die SQLite Datenbank?
  • Wie liest man Daten aus der SQLite Datenbank aus?

Anschließend werden wir mit Hilfe unsere Datenquelle ShoppingMemoDataSource Daten in die Datenbank schreiben und auch wieder auslesen.

Die Datenquelle ist unser Data Access Object. Sie unterhält die Datenbankverbindung und unterstützt uns beim Erstellen neuer Datenbankeinträge und auch beim Auslesen der bereits vorhandenen Einträge.

Danach überarbeiten wir die MainActivity-Klasse und werden uns den Inhalt der SQLite Datenbank in dem ListView der MainActivity anzeigen lassen. Dabei werden wir auch erste Datensätze als Testeinträge in die Datenbank speichern.

Am Ende der vierten Lektion des Android SQLite Tutorials werden wir unsere App ausführen und dabei überprüfen, ob die Daten korrekt in die SQLite Datenbank geschrieben werden.

Nun wünschen wir euch viel Spaß bei Teil 4 unseres Android SQLite Datenbank Tutorials. Los geht’s!

1. Daten in die SQLite Datenbank schreiben und auslesen

Auf eine SQLite Datenbank können vier Grundoperationen angewandt werden, die unter dem Akronym CRUD zusammengefasst werden.

Die vier Grundoperatoren sind:

  • Create – Erstellen neuer Datensätze.
  • Read – Auslesen von Datensätzen.
  • Update – Aktualisieren von Datensatzinhalten.
  • Delete – Löschen von Datensätzen.

Alle Grundoperationen können als SQL-String vorgegeben werden und dann mit Hilfe der Methode execSQL() auf dem SQLiteDatabase-Objekt ausgeführt werden.

Es geht aber auch bequemer. Für einfache Datenbankoperationen können die von der SQLDatabase-Klasse zur Verfügung gestellten Methoden verwendet werden. Für diese Basiszugriffe werden keine expliziten SQL-Kommando benötigt.

Wie dabei vorzugehen ist, zeigen wir euch in den folgenden Unterabschnitten. Zuerst werden wir beschreiben wie Daten in die SQLite Datenbank geschrieben werden. Dabei stellen wir die Klasse ContentValues und den Insert-Befehl vor.

Anschließend zeigen wir, wie das Auslesen von Datensätzen aus der SQLite Datenbank abläuft. Dabei zeigen wir was ein Cursor ist und wie er verwendet wird.

Im dritten Unterabschnitt stellen wir die die Hilfsmethode cursorToShoppingMemo vor. Wir verwenden diese Methode, um Datensätze aus der Datenbank in ShoppingMemos umzuwandeln.

1.1 Daten in die SQLite Datenbank schreiben

Datensätze lassen sich in Android sehr einfach in die SQLite Datenbank einfügen.

Wir benötigen dafür ein Hilfsobjekt vom Typ ContentValues, in das wir die einzutragenden Inhalte als Key-Value Pairs (Schlüssel-Wert Paare) ablegen.

Das ContentValues-Objekt können wir dann in die SQLite Datenbank einfügen.

Die Schlüsselnamen (Keys) müssen dabei unbedingt den Spaltennamen der Tabelle entsprechen. Pro Schlüssel kann genau ein Wert zugewiesen werden.

Im unteren Quelltext erzeugen wir ein ContentValues-Objekt und legen darin zwei Schlüssel-Wert Paare ab:


Mit der put() Methode werden die Schlüssel-Wert Paare abgelegt. Dabei entspricht das erste Argument dem Spaltennamen der Tabelle und das zweite Argument übergibt den abzuspeichernden Wert.

Im Quellcode arbeiten wir mit der Hilfsklasse ShoppingMemoDbHelper, die uns die korrekten Spaltennamen als String-Konstanten liefert.

Es muss nicht für jede Spalte der Tabelle ein Wert übergeben werden. Unsere Tabelle besteht aus den Spalten _id, product und quantity. Da wir die Spalte _id mit AUTOINCREMENT definiert haben, wird dieser Wert automatisch vom SQLite Datenbanksystem gesetzt.

Wir dürfen daher keinen Eintrag für die _id-Spalte in dem ContentValues-Objekt einfügen. Die anderen beiden Spalten müssen zwingend mit Werten gefüllt werden, da wir in der Tabellendefinition für die Spalten product und quantity den Zusatz NOT NULL vorgegeben haben.

Um die vorbereiteten Daten in die Datenbank einzutragen, übergeben wir das ContentValues-Objekt der insert() Methode, die wir auf dem SQLiteDatabase-Objekt aufrufen.

Mit der folgenden Anweisung wird ein Datensatz in die Tabelle der SQLite Datenbank eingefügt:


Die Methode insert() erwartet drei Argumente, von denen wir nur das Erste und Letzte verwenden. Mit dem ersten Argument übergeben wir den Namen unserer Tabelle und mit dem dritten Argument schließlich die einzutragenden Werte in Form des vorher befüllten ContentValues-Objekts.

Ist das Einfügen der Werte in die Tabelle der Datenbank erfolgreich gewesen, erhalten wir eine eindeutige ID für den erzeugten Datensatz zurück. Diese ID ist vom Datentyp long und sollte unbedingt gespeichert werden, damit wir später direkt auf den eben eingefügten Datensatz zugreifen können.

Weiterführende Informationen über ContentValues könnt ihr hier finden.

1.2 Daten aus der SQLite Datenbank auslesen

Wir können sehr einfach nach Einträgen in der Android SQLite Datenbank suchen.

Dafür werden Queries (Suchanfragen) verwendet, in denen über bestimmte Suchkriterien die zu liefernden Datensätze beschrieben werden.

Das Verwenden komplexer Suchanfragen ist ein wesentlicher Vorteil von Datenbanken, gegenüber anderen Speicherformen.

Die Klasse SQLiteDatabase stellt uns für diese Zwecke die query() Methode zur Verfügung.

Die Methode ist vierfach überladen und erwartet mindestens 7 Argumente, von denen wir aber nicht alle mit Werten füllen müssen. Als Rückgabewert liefert sie ein Cursor-Objekt zurück, eine Art Zeiger auf eine Zeile der SQLite Tabelle. Man bezeichnet einen Cursor daher auch häufig als Datensatzzeiger.

Mit folgendem Quellcode suchen wir nach einem Datensatz mit einer bestimmten ID:


Folgende Argumente werden von uns beim Aufruf der query() Methode genutzt:

  • Argument 1: Enthält den Namen der zu durchsuchenden Tabelle. Wir nutzen wieder die Hilfsklasse ShoppingMemoDbHelper, die uns den korrekten Tabellennamen als String-Konstante liefert.
  • Argument 2: Enthält den Namen der Tabellenspalten, die von der Suchanfrage zurückgeliefert werden sollen. Bei null werden alle Spalten zurückgeliefert.
  • Argument 3: Enthält den String mit den Suchkriterien. Dieser Such-String enthält den Namen der zu vergleichenden Spalte und testet mit dem = Operator, ob die Werte den vorgegebenen Daten entsprechen. Wenn der Such-String null ist, werden alle Datensätze der Tabelle zurückgeliefert.
  • Argumente 4-7: Diese werden nicht von uns benutzt und tragen den Wert null. Über sie kann die Suche weiter verfeinert werden.

Als Ergebnis der Suchanfrage erhalten wir ein spezielles Datenzugriffsobjekt (Data Access Object) vom Typ Cursor zurück. Mit diesem Cursor können wir die Datensätze im Suchergebnis durchlaufen und auf ihre inneren Werte zugreifen.

Um zu einem anderen Datensatz zu navigieren, kann der Cursor (Datensatzzeiger) durch Aufrufen der folgenden Methoden explizit an eine andere Stelle (Datensatz) verschoben werden:

  • moveToFirst() – Bewegt den Cursor zum ersten Datensatz.
  • moveToNext() – Bewegt den Cursor zum nächsten Datensatz.
  • moveToPrevious() – Bewegt den Cursor zum vorherigen Datensatz.
  • moveToLast() – Bewegt den Cursor zum letzten Datensatz.
  • moveToPosition(int pos) – Bewegt den Cursor zum Datensatz an einer bestimmten Positon.

Jede Methode liefert als Rückgabewert true oder false zurück und zeigt damit an, ob die Cursor-Verschiebung erfolgreich durchgeführt werden konnte. Die Anzahl der gefundenen Datensätze kann mit der Methode getCount() abgefragt werden.

Die Werte in den Datensätzen können mit den verschiedenen get-Methoden des Cursor-Interfaces ausgelesen werden. Die Methoden getString(), getInt(), getLong() und getFloat() liefern die Spaltenwerte des ausgewählten Datensatzes zurück. Als Argument erwarten sie den Index der Spalte(Column Index), deren Wert ausgelesen werden soll.

Die Indizes der Spalten entsprechen der Erstellungsreihenfolge, nach der die Spalten in die Tabelle angelegt wurden. Die Indizes der Tabellenspalten können auch nach dem Erzeugen der Tabelle mit der Methode getColumnIndex(String columnName) noch ausgelesen werden. Man muss dazu aber den Namen der Spalte wissen. Ist die Spalte nicht vorhanden wird der Wert -1 zurückgeliefert, sonst der Index der Spalte.

Wie das Cursor-Objekt in der Praxis eingesetzt wird und damit Werte aus den Datensätzen der Datenbank ausgelesen werden, beschreiben wir im nächsten Unterabschnitt genauer.

1.3 Die Hilfsmethode cursorToShoppingMemo

In unserer SQLite-App werden wir die Hilfsmethode cursorToShoppingMemo() verwenden, um ein Cursor-Objekt in ein ShoppingMemo-Objekt umzuwandeln.

Dabei benutzen wir vier wichtige Methoden des Cursor-Interfaces, diese sind:

  • getColumnIndex(String columnName) – Durch Angabe des Spaltennamens unserer Tabelle erhalten wir den Index der Spalte zurück.
  • getString(int columnIndex) – Mit dem übergebenen Spaltenindex wird die relevante Spalte gefunden und der darin gespeicherte String-Wert zurückgegebenen.
  • getInt(int columnIndex) – In diesem Fall wird als Rückgabewert ein int-Wert zurückgeliefert.
  • getLong(int columnIndex) – In diesem Fall wird als Rückgabewert ein long-Wert zurückgeliefert.

Mit dem folgenden Quellcode definieren wir die Hilfsmethode cursorToShoppingMemo():


Der Code ist größtenteils selbsterklärend. In den Zeilen 2 bis 4 lesen wir die Indizes unserer Tabellenspalten aus. Anschließend lassen wir uns in den Zeilen 6 bis 8 die Inhalte der Suchanfrage mit den get-Methoden ausgeben. Dazu nutzen wir die vorher erhaltenen Spaltenindizes.

Das Cursor-Objekt zeigt dabei auf einen Datensatz der vorher ausgeführten Suchanfrage. Über die Spaltenindizes kann auf die Zellen des Datensatzes zugegriffen und mit der entsprechenden get-Methode deren Inhalt ausgelesen werden.

In Zeile 10 erzeugen wir schließlich mit den ausgelesenen Daten das ShoppingMemo-Objekt. Dieses können wir nun in unserer Anwendung weiterverwenden, bspw. in einem ListView anzeigen lassen, und geben es daher als Rückgabewert zurück.

Die eben beschriebene Hilfsmethode werden wir in unserer Android SQLite App öfter verwenden. Mit ihrer Hilfe könne sehr einfach und bequem Datensätze in ShoppingMemo-Objekte umgewandelt werden.

Nun haben wir den theoretischen Teil dieser Lektion des Android SQLite Datenbank Tutorials abgeschlossen und können des Erlernte in unserem Android Projekt einsetzen.

Dazu werden wir in dem nächsten Abschnitt den Quellcode unserer Datenquelle, der ShoppingMemoDataSource-Klasse, vervollständigen, so dass wir Daten in unsere SQLite Datenbank schreiben und auch wieder auslesen können.

2. Mit Hilfe unserer Datenquelle Daten in die SQLite Datenbank speichern und auslesen

Jetzt werden wir unsere Datenquelle ausbauen. Dies werden wir durch die drei folgenden Änderungen an dem Quellcode der Klasse ShoppingMemoDataSource verwirklichen:

  1. Einfügen der Import-Anweisungen – Zuerst importieren wir die benötigten Klassen und Interfaces.
  2. Anlegen des Spalten-Arrays – Die Spaltennamen unserer Tabelle speichern wir in einem String-Array.
  3. Definieren der Methoden – Wir definieren drei Methoden, die uns beim Zugreifen auf Datensätze der SQLite Datenbank helfen. Eine Methode wird das Schreiben von Datensätzen in die Datenbank realisieren. Eine andere Methode wird für das Auslesen aller Datensätze aus der SQLite Datenbank zuständig sein. Die dritte Methode ist die bereits weiter oben vorgestellte Hilfsmethode cursorToShoppingMemo().

Am Ende dieses Abschnitts haben wir nochmals den kompletten Quellcode der ShoppingMemoDataSource-Klasse aufgeführt. Falls ihr bei den folgenden drei Schritten durcheinander kommt, könnt ihr ihn zur Kontrolle bzw. Orientierung nutzen.

Nun beginnen wir mit dem ersten Arbeitsschritt.

2.1 Einfügen der Import-Anweisungen

Der erste Schritt geht sehr schnell. Zuerst öffnen wir die Klassendatei ShoppingMemoDataSource.java im Editorfenster von Android Studio über einen Klick auf den entsprechenden Eintrag in der linken Projektleiste.

Anschließend fügen wir den folgenden Quellcode unter den bereits vorhandenen Import-Anweisungen ein:


2.2 Anlegen des Spalten-Arrays

Auch der zweite Arbeitsschritt ist schnell ausgeführt. Den folgenden Quellcode fügen wir direkt unter den bereits angelegten Membervariablen in die Klasse ShoppingMemoDataSource ein:


Den Spalten-Array werden wir später für Suchanfragen verwenden. Er enthält die Namen der drei Spalten unserer Tabelle. Die Namen geben wir nicht selbst ein, sondern nutzen dafür die String-Konstanten der Hilfsklasse ShoppingMemoDbHelper.

2.3 Definieren der Methoden

Im letzten Arbeitsschritt werden wir drei Methoden definieren, die uns beim Zugriff auf die SQLite Datenbank unterstützen. Die Hilfsmethode cursorToShoppingMemo haben wir bereits im theoretischen Teil dieser Lektion kennengelernt. Die beiden anderen Methoden sind neu. Wir werden sie daher im Anschluss an den Quelltext ausführlich beschreiben.

Jetzt fügen wir den folgenden Quellcode in den Methodenbereich der ShoppingMemoDataSource-Klasse ein:


Mit der ersten Methode createShoppingMemo() können wir Datensätze in die Tabelle unserer SQLite Datenbank einfügen. In der Methode erzeugen wir in den Zeilen 2 bis 4 ein ContentValues-Objekt, in das wir den Produktnamen und die Menge einfügen.

Anschließend tragen wir diese Werte mit Hilfe des ContentValues-Objekts in die Tabelle ein. Dazu verwenden wir den insert-Befehl in Zeile 6, den wir auf dem SQLiteDatabase-Objekt ausführen. Als Argumente übergeben wir den Namen der Tabelle, null für den ColumnHack und das vorbereitete ContentValues-Objekt. War das Einfügen erfolgreich, dann erhalten wir die ID des erstellten Datensatzes zurück.

Nun lesen wir die eingetragenen Werte zur Kontrolle mit der Anweisung in Zeile 8 bis 10 direkt wieder aus. Als Argumente übergeben wir den Namen der Tabelle, den Spalten-Array (die Suchanfrage soll die Werte für alle Spalten zurückliefern) und den Such-String mit dem wir nach dem eben eingefügten Datensatz suchen. Die restlichen Argumente sind alle null.

Als Ergebnis auf die Suchanfrage erhalten wir ein Cursor-Objekt zurück, das die gefundenen Datensätze enthält. In unserem Fall besteht es aus genau einem Datensatz, dem eben Eingefügten.

Mit der Anweisung in Zeile 12 bewegen wir den Cursor an die Position seines ersten Datensatzes. Anschließend rufen wir die cursorToShoppingMemo() Methode auf und wandeln dadurch den Datensatz des Cursor-Objekts in ein ShoppingMemo-Objekt um.

Das so erzeugte ShoppingMemo-Objekt geben wir an die aufrufende Methode zurück. Doch vorher schließen wir noch das Cursor-Objekt (Zeile 14).

Die zweite Methode cursorToShoppingMemo() haben wir bereits im ersten Kapitel ausführlich besprochen und gehen hier nicht noch einmal darauf ein.

Mit der dritten Methode getAllShoppingMemos() lesen wir alle vorhandenen Datensätze aus der Tabelle unserer SQLite Datenbank aus. Dazu erzeugen wir gleich zu Beginn der Methode in Zeile 34 eine Liste, die ShoppingMemo-Objekt in sich aufnehmen kann.

Anschließend starten wir eine Suchanfrage in Zeile 36 und 37. Diesmal übergeben wir als Argumente nur den Namen der Tabelle und den Spalten-Array. Alle anderen Argumente sind null, d.h. auch der Such-String ist null, wodurch alle in der Tabelle existierenden Datensätze als Ergebnis zurückgeliefert werden.

In den Zeilen 39 und 40 setzen wir das erhaltenen Cursor-Objekt an seine erste Position und deklarieren eine Variable vom Typ ShoppingMemo.

Mit der while-Schleife in den Zeilen 42 bis 47 lesen wir alle Datensätze der Suchanfrage aus, wandeln sie in ShoppingMemo-Objekte um und fügen sie der ShoppingMemo-Liste hinzu. Mit der Log-Meldung können wir später in der Konsole überprüfen, welche Datensätze sich in der Tabelle befinden.

In Zeile 49 schließen wir den Cursor wieder. Dies ist eine ganz wichtige Anweisung und darf nicht vergessen werden! Am Ende der Methode geben wir die erzeugte ShoppingMemo-Liste, die alle Datensätze der Tabelle enthält, an die aufrufende Methode zurück.

2.4 Der komplette Quellcode der ShoppingMemoDataSource-Klasse

Nun haben wir alle Änderungen an der ShoppingMemoDataSource-Klasse vorgenommen und das Erstellen von Datensätzen in die Tabelle der Android SQLite Datenbank vorbereitet. Zudem können wir die eingetragenen Daten auch wieder auslesen.

In dem unten angegebenen Quellcode ist die gesamte ShoppingMemoDataSource-Klasse zur Kontrolle für euch aufgeführt. Die neu eingefügten Zeilen sind gelb markiert.

Der vollständiger Quelltext der Klasse ShoppingMemoDataSource:


In Android Studio sollte die Klasse ShoppingMemoDataSource nun wie folgt aussehen:

android sqlite data source

Die überarbeitete Klasse ShoppingMemoDataSource mit Markierungen

In der oberen Abbildung sind die in den drei Arbeitsschritten vorgenommenen Änderungen mit einem blauen Rahmen markiert.

Die Import-Anweisungen sind mit A markiert. Der Spalten-Array mit B und die drei Methode createShoppingMemo(), cursorToShoppingMemo() und getAllShoppingMemos() mit denen wir in die Tabelle Werte schreiben und aus ihr wieder auslesen sind mit einem blauen C gekennzeichnet.

Mit diesen Änderungen im Quellcode der ShoppingMemoDataSource-Klasse haben wir unsere Datenquelle um zwei sehr nützliche Funktionen erweitert. Wir können jetzt mit ihrer Hilfe Daten in die SQLite Datenbank schreiben und alle vorhandenen Datensätze aus der Datenbank auslesen.

Diese neuen Funktionen werden wir im nächsten Abschnitt nutzen und erstmals Datensätze in unsere Datenbank schreiben. Anschließend werden wir alle vorhandenen Datensätze unserer Datenbank auf dem Android Gerät im ListView der MainActivity ausgeben.

3. Inhalt der SQLite Datenbank im ListView ausgeben

Nun werden wir von der MainActivity aus Daten in die SQLite Datenbank schreiben. Die eingetragenen Daten werden wir anschließend wieder aus der Datenbank auslesen. Für beide Operationen nutzen wir die neuen Funktionen unserer Datenquelle.

Um dies zu realisieren nehmen wir die folgenden drei Änderungen am Quellcode der Klasse MainActivity vor:

  1. Einfügen der Import-Anweisungen – Zuerst importieren wir die benötigten Klassen und Interfaces.
  2. Überarbeiten der onCreate() Methode – Hier fügen wir die Anweisungen für das Schreiben in die Datenbank und das Auslesen aus der Datenbank ein, zusammen mit einigen Log-Meldungen.
  3. Definieren der showAllListEntries() Methode – Diese Methode liest alle Datensätze aus der Tabelle unserer SQLite Datenbank aus und gibt die Einträge in dem ListView der MainActivity auf dem Android Gerät aus.

Am Ende dieses Abschnitts haben wir nochmals den kompletten Quellcode der MainActivity-Klasse aufgeführt. Falls ihr bei den folgenden drei Schritten durcheinander kommt, könnt ihr ihn zur Kontrolle bzw. Orientierung nutzen.

Nun beginnen wir mit dem ersten Arbeitsschritt.

3.1 Einfügen der Import-Anweisungen

Wir öffnen als Erstes die Klassendatei MainActivity.java im Editorfenster von Android Studio über einen Klick auf den entsprechenden Eintrag in der linken Projektleiste.

Anschließend fügen wir den folgenden Quellcode unter den bereits vorhandenen Import-Anweisungen ein:


3.2 Überarbeiten der onCreate() Methode der MainActivity

Im zweiten Arbeitsschritt überarbeiten wir die onCreate() Methode unserer MainActivity-Klasse. Wir werden von der onCreate() Methode aus Daten in die Datenbank schreiben. Dazu nutzen wir die createShoppingMemo() Methode unserer Datenquelle und fügen über sie einen Testeintrag in die Tabelle der SQLite Datenbank ein.

Anschließend lesen wir den Testeintrag mit der Hilfsmethode showAllListEntries() wieder aus der Datenbank aus. Die Hilfsmethode werden wir im dritten Arbeitsschritt erstellen.

Den gelb markierten Quellcode fügen wir nun in die onCreate() Methode der MainActivity ein:


Mit den drei Log-Anweisungen geben wir Statusmeldungen in der logcat-Konsole von Android Studio aus. Mit diesen Meldungen können wir beim Ausführen unserer SQLite App prüfen, welche Daten in die Datenbank geschrieben werden.

3.3 Definieren der showAllListEntries() Methode

Als letzten Arbeitsschritt definieren wir die Hilfsmethode showAllListEntries() in der MainActivity-Klasse. Diese Methode liest für uns alle vorhandenen Datensätze aus der Tabelle unserer SQLite Datenbank aus und speichert sie in einer Liste als ShoppingMemo-Objekte.

Die Liste übergeben wir an einen ArrayAdapter, der für uns die Verwaltungsarbeit übernimmt. Die ausgelesenen Einträge lassen wir jeweils in einem vordefinierten Standardlayout, dem simple_list_item_multiple_choice, anzeigen.

Damit unsere Datenbankeinträge auch auf dem Android Gerät angezeigt werden, binden wir den ArrayAdapter an den ListView der MainActivity. Was ein ArrayAdapter im Detail macht könnt ihr in unserem anderen Android Tutorial an dieser Stelle nachlesen: Daten mit einem ListView anzeigen.

Jetzt fügen wir den folgenden Quellcode in den Methodenbereich der MainActivity-Klasse ein:


In Zeile 2 rufen wir über unsere Datenquelle die Methode getAllShoppingMemos() auf, die uns alle Datenbankeinträge als Liste zurück liefert. Die Einträge dieser Liste sind vom Typ ShoppingMemo, unserem Datenmodell.

Mit den Zeilen 4 bis 7 erzeugen wir den ArrayAdapter und weisen ihm als Context die Instanz der MainActivity, als Layout für die Einträge das vordefinierte Standardlayout simple_list_item_multiple_choice und als Liste das shoppingMemoList Objekt zu.

Anschließend suchen wir in Zeilen 9 und 10 nach dem ListView des MainActivity-Layouts und binden den ArrayAdapter an das ListView-Objekt, wodurch unsere SQLite Datenbankeinträge auf dem Android Gerät angezeigt werden.

3.4 Der komplette Quellcode der MainActivity-Klasse

Nun haben wir alle Änderungen an der MainActivity-Klasse vorgenommen.

Mit dem eingefügtem Quellcode erstellen wir einen Testeintrag, jedes Mal wenn unsere Activity erzeugt wird. Also auch beim Drehen des Android Geräts. Zudem lesen wir angelegten Datensätze aus der Tabelle der SQLite Datenbank aus und lassen sie im ListView anzeigen.

In dem unten angegebenen Quellcode ist die gesamte MainActivity-Klasse zur Kontrolle für euch aufgeführt. Die neu eingefügten Zeilen sind gelb markiert.

Der vollständiger Quelltext der Klasse MainActivity:


In Android Studio sollte die Klasse MainActivity nun wie folgt aussehen:

android sqlite listview

Die überarbeitete Klasse MainActivity mit Markierungen

In der oberen Abbildung sind die in den drei Arbeitsschritten vorgenommenen Änderungen mit einem blauen Rahmen markiert.

Die Import-Anweisungen sind mit A markiert. Die Änderungen an der onCreate() Methode der MainActivity mit B und die neue Methode showAllListEntries() mit der wir alle Datensätze der Tabelle auslesen und im ListView anzeigen lassen ist mit einem blauen C gekennzeichnet.

Mit diesen Änderungen im Quellcode der MainActivity-Klasse haben wir unsere SQLite App um zwei sehr nützliche Funktionen erweitert. Wir können jetzt Daten in die SQLite Datenbank unter Zuhilfenahme der Datenquelle schreiben und alle vorhandenen Datensätze aus der Datenbank auf dem Android Gerät ausgeben.

Im nächsten Abschnitt werden wir die neuen Funktionen unserer Android App testen und prüfen, ob die Daten korrekt in die Datenbank geschrieben werden.

4. Starten und Testen der Android SQLite App

In diesem Abschnitt werden wir unsere Android App ausführen und überprüfen, ob die Testdaten korrekt in die Tabelle unserer SQLite Datenbank eingetragen werden.

Dazu werden wir zunächst die Anwendung auf einem Android Gerät ausführen und anschließend die zurückgelieferten Log-Meldungen in Android Studio analysieren. Zusätzlich prüfen wir auch, ob die Einträge korrekt im ListView der MainActivity auf dem Android Gerät angezeigt werden.

4.1 Ausführen der Android SQLite-App

Nun wollen wir unsere App ausführen und testen. Dazu installieren wir die Anwendung auf unser angeschlossenes Android Gerät (Smartphone oder Tablet) oder in einer AVD des Android Emulators.

Wie eine Android App installiert wird, könnt ihr in den folgenden beiden Teilen unseres großen Android App Programmieren Tutorials nachlesen:

Hier noch einmal in Kürze die wichtigsten Arbeitsschritte.

Zuerst schließen wir unser Android Gerät an den PC an und stellen eine Verbindung über die ADB (Android Debug Bridge) her. Danach klicken wir auf das Run 'app'-Symbol. Unser Android Projekt wird dadurch neu erstellt und auf dem angeschlossenen Gerät ausgeführt.

Das Run 'app'-Symbol befindet sich in der oberen Menüleiste, siehe folgende Abbildung:

android sqlite app starten

Android App über das Run App-Symbol starten

Nach einigen Momenten öffnet sich der Choose Device-Dialog. In ihm nehmen wir die folgenden Einstellungen vor:

  1. Radio Button Choose a running device aktivieren
  2. Das angeschlossene Android Gerät auswählen
  3. Mit einem Klick auf den OK-Button die Installation unserer App auf das Gerät starten
android choose device

Auswählen des angeschlossenen Android Geräts zum Aufspielen unserer App

Der Dialog schließt sich und unsere Android App wird auf das angeschlossene Gerät übertragen und installiert. Die Installation dauert nur einen kurzen Augenblick und verläuft fast unbemerkt im Hintergrund. Danach wird unsere App automatisch gestartet.

4.2 Überprüfen der Log-Meldungen in Android Studio

Unsere SQLite-App sollte jetzt auf dem Android Gerät gestartet worden sein.

Um die Log-Meldungen zu überprüfen, öffnen wir in Android Studio die Android-Ansicht bei angeschlossenem Android Gerät.

In der unteren Abbildung sind die Log-Meldungen unserer Android App dargestellt. Der in Lektion 2 angelegte Log-Filter ist aktiviert (rote Markierung X). Unsere Meldungen werden im logcat-Textbereich angezeigt und sind von einem blauen Rahmen umschlossen (Markierung 1).

android sqlite logcat

Ausführen der SQLite-App – Überprüfen der Log-Meldungen in Android Studio mit aktivem Log-Filter

Uns werden die folgenden Log-Meldungen ausgegeben:

01: MainActivity﹕ Inhalt der Testmemo: 5 x Birnen
02: ShoppingMemoDataSource﹕ Unsere DataSource erzeugt jetzt den dbHelper.
03: ShoppingMemoDbHelper﹕ DbHelper hat die Datenbank: shopping_list.db erzeugt.
04: MainActivity﹕ Die Datenquelle wird geöffnet.
05: ShoppingMemoDataSource﹕ Eine Referenz auf die Datenbank wird jetzt angefragt.
06: ShoppingMemoDataSource﹕ Datenbank-Referenz erhalten. Pfad zur Datenbank: /data/data/de.programmierenlernenhq.shoppinglisthq/databases/shopping_list.db
07: MainActivity﹕ Es wurde der folgende Eintrag in die Datenbank geschrieben:
08: MainActivity﹕ ID: 1, Inhalt: 2 x Testprodukt
09: MainActivity﹕ Folgende Einträge sind in der Datenbank vorhanden:
10: ShoppingMemoDataSource﹕ ID: 1, Inhalt: 2 x Testprodukt
11: MainActivity﹕ Die Datenquelle wird geschlossen.
12: ShoppingMemoDataSource﹕ Datenbank mit Hilfe des DbHelpers geschlossen.

Die sechs ersten Log-Meldungen haben wir bereits in der vorherigen Lektion überprüft, ebenso wie die letzten beiden Meldungen. Neu hinzugekommen sind die Meldungen 7 bis 10.

Die Meldung 8 informiert uns über die ID und den Inhalt des eben eingetragenen Datensatzes. Die ausgegebenen Werte entsprechen den Werten in der Tabelle unserer SQLite Datenbank, da wir sie nach dem Eintragen in die Tabelle sofort wieder ausgelesen und mit den ausgelesenen Werten das ShoppingMemo-Objekt erstellt haben.

Mit den Meldungen 9 und 10 geben wir den Inhalt unserer SQLite Datenbank aus. Momentan ist nur ein Datensatz in der Tabelle der Datenbank vorhanden, daher wird auch nur ein Eintrag zurückgeliefert. Dies werden wir nun ändern.

Wir erzeugen nun weitere Datenbankeinträge, indem wir die MainActivity zerstören und neu erstellen lassen. Dabei wird jedes Mal die onCreate() Methode der MainActivity-Klasse aufgerufen und somit jeweils ein Testeintrag in die SQLite Datenbank geschrieben.

Die MainActivity können wir durch Drehen des Android Devices zerstören und neu erstellen, das liegt an dem Activity Lifecycle vom Android System. Welche Zustände eine Activity in ihrem Leben durchläuft solltet ihr unbedingt hier: Der Activity und Fragment Lifecycle in Android nachlesen.

Wir könnten aber auch die SQLite App mittels Back-Button vollständig beenden und anschließend neu starten. Egal welchen Weg wir wählen, es wird dabei immer beim Erzeugen der MainActivity ein Eintrag in die SQLite Datenbank erstellt.

Nach mehrfachem Drehen des Android Geräts werden uns die folgenden Log-Meldungen ausgegeben:

android sqlite logcat meldung

Erneutes Ausführen der SQLite-App – Überprüfen der Log-Meldungen in Android Studio mit aktivem Log-Filter

Diesmal werden uns die folgenden Log-Meldungen ausgegeben:

01: MainActivity﹕ Inhalt der Testmemo: 5 x Birnen
02: ShoppingMemoDataSource﹕ Unsere DataSource erzeugt jetzt den dbHelper.
03: ShoppingMemoDbHelper﹕ DbHelper hat die Datenbank: shopping_list.db erzeugt.
04: MainActivity﹕ Die Datenquelle wird geöffnet.
05: ShoppingMemoDataSource﹕ Eine Referenz auf die Datenbank wird jetzt angefragt.
06: ShoppingMemoDataSource﹕ Datenbank-Referenz erhalten. Pfad zur Datenbank: /data/data/de.programmierenlernenhq.shoppinglisthq/databases/shopping_list.db
07: MainActivity﹕ Es wurde der folgende Eintrag in die Datenbank geschrieben:
08: MainActivity﹕ ID: 5, Inhalt: 2 x Testprodukt
09: MainActivity﹕ Folgende Einträge sind in der Datenbank vorhanden:
10: ShoppingMemoDataSource﹕ ID: 1, Inhalt: 2 x Testprodukt
11: ShoppingMemoDataSource﹕ ID: 2, Inhalt: 2 x Testprodukt
12: ShoppingMemoDataSource﹕ ID: 3, Inhalt: 2 x Testprodukt
13: ShoppingMemoDataSource﹕ ID: 4, Inhalt: 2 x Testprodukt
14: ShoppingMemoDataSource﹕ ID: 5, Inhalt: 2 x Testprodukt
15: MainActivity﹕ Die Datenquelle wird geschlossen.
16: ShoppingMemoDataSource﹕ Datenbank mit Hilfe des DbHelpers geschlossen.

Es hat sich nicht viel gegenüber dem vorherigen Output geändert. Neu hinzugekommen sind Log-Meldungen 11 bis 14, die uns über den Inhalt der Datenbank informieren.

Anhand der ausgegebenen Meldungen können wir feststellen, dass unsere App die Testeinträge korrekt in die Datenbank schreibt und wieder aus ihr ausliest. Auch die ID wird als laufende Nummer automatisch bei jedem neuen Datensatz um 1 erhöht, so wie es sein soll.

Die Log-Meldungen helfen uns dabei die Korrektheit unseres Quellcodes sicherzustellen, sie sind jedoch für unsere Anwender nicht sichtbar. Wir werden nun die grafische Oberfläche unserer SQLite App testen und überprüfen welche Daten unseren Nutzern auf dem Display ausgegeben werden.

android sqlite database app

Unsere SQLite App zeigt den Inhalt der ihrer Datenbank an

Auf der linken Seite ist das User Interface unsere SQLite App auf einem Android Gerät zu sehen.

Die Datensätze in der Tabelle unserer SQLite Datenbank werden im ListView der MainActivity angezeigt.

Durch Drehen des Smartphone oder Tablets lassen wir automatisch einen neuen Testeintrag in die Datenbank erstellen.

Diese Funktion werden wir in der nächsten Lektion durch eine, für die Nutzer, sinnvolle Funktion ersetzen. Momentan dient sie uns aber sehr gut zu Testzwecken.

Die einzelnen Listeneinträge können zwar angeklickt werden, reagieren aber nicht darauf. Auch der + Button reagiert noch nicht auf Benutzereingaben.

Daher werden wir in der nächsten Lektion das User Interface auf Benutzereingaben reagieren lassen, so dass es möglich ist eigene echte Einträge in die Datenbank der Einkaufslisten-App zu schreiben.

Wenn bei euch die gleichen Log-Meldungen ausgegeben werden und ihr die Einträge der Datenbank auch auf dem Display eures Android Geräts oder dem Android Emulator angezeigt bekommt, habt ihr alle Arbeitsschritte korrekt umgesetzt.

Eure App speichert dann die Daten korrekt in die Tabelle der SQLite Datenbank ab. In der nächsten Lektion des Android SQLite Tutorials können wir nun die grafische Benutzeroberfläche mit Funktionalität füllen.

Zusammenfassung

In dieser Lektion unseres Android SQLite Tutorials haben wir Datensätze in die Tabelle der SQLite Datenbank geschrieben. Die Datensätze haben wir anschließend wieder ausgelesen und im ListView der MainActivity ausgegeben. Um dies zu erreichen, haben wir die folgenden beiden Klassen unseres Android Projekts überarbeitet:

  • ShoppingMemoDataSource – Wir benutzen diese Klasse als Datenquelle, die eine Verbindung zur SQLite Datenbank aufrecht hält und für alle Lese- und Schreib-Zugriffe verantwortlich ist. In dieser Lektion haben wir ihr drei Methoden hinzugefügt, mit denen wir nun Daten in die Datenbank schreiben und aus ihr wieder auslesen können.
  • MainActivity – Mit unserer Hauptklasse steuern wir die Datenbankzugriffe und verwalten die Elemente der grafischen Benutzeroberfläche unserer SQLite App. In dieser Lektion haben wir von der MainActivity aus Daten in die SQLite Datenbank schreiben und aus ihr auslesen lassen, unter Zuhilfenahme unserer Datenquelle.

Abschließend haben wir die neuen Funktionen unserer Android SQLite App überprüft und dadurch sichergestellt, dass die Datensätze korrekt in die Datenbank geschrieben werden.

Wir sind nun bei der Entwicklung unserer Android SQLite App einen großen Schritt weiter gekommen. Unsere Einkaufslisten-App kann jetzt Daten in die Datenbank schreiben, diese auslesen und auf dem Display ausgeben. Bisher aber nur Testdaten.

Daher werden wir in der nächsten Lektion unseres SQLite Tutorials die Bedienelemente unserer Android App so überarbeiten, dass sie auf Eingaben der User reagieren. Dadurch wird unsere SQLite App in der Lage sein echte Daten in die Datenbank zu schreiben und somit erstmals sinnvoll nutzbar sein.


Comments 52

  1. Pingback: Android SQLite Tutorial - Teil 2: SQLite Datenbank integrieren

  2. Marcel

    Hallo Chris,

    vielen Dank für deine großartigen Tutorials!
    Super gestaltet, übersichtlich und einfach zu verstehen. So machen die ersten Schritte in der Android-Programmierung wirklich Spaß.

    Ich freue mich schon auf Teil 5! :)

    Gruß Marcel

    1. Post
      Author
  3. Dennis

    Hallo Chris,

    ein wirklich tolles und hilfreiches Tutorial!
    Ich bin seit etwa 4 Jahren eine Lotus Notes Programmierer und wollte nun mal anfangen mir anzuschauen, wie man Android Apps programmiert, da ich daran großes Interesse habe.
    Deine Tutorials sind mir dabei eine große Hilfe gut in dieses Thema einsteigen zu können.
    Ich freue mich schon auf deine weiteren Anleitungen!

    Viele Grüße

    Dennis

    PS: Gibt es einen Newsletter um benachrichtigt zu werden sobald es etwas neues gibt und weißt du schon wann du etwa mit diesem Tutorial durch bist?

    1. Post
      Author
      Chris

      Hallo Dennis,

      danke für das Lob! Ja, Android ist ein sehr spannendes Thema und der Einstieg lohnt sich.

      Einen Newsletter gibt es momentan nicht. Für dieses Tutorial erstelle ich gerade Teil 5 und weitere Teile befinden sich noch in der Planungsphase. Der fünfte Teil wird wahrscheinlich innerhalb der nächsten zwei Wochen erscheinen.

      Viele Grüße, Chris

  4. kerona

    Sehr schöne Tutorials!
    Danke – dass Du Dir die Mühe machst, Android-Einsteigern wie mir Grundlagen und Zusammenhänge so detailliert zu erklären – ein ganz großes Lob!

    1. Post
      Author
      Chris

      Hallo Kerona,

      es freut mich sehr, wenn die Tutorials verständlich und hilfreich sind. Danke für das Lob!

      Viele Grüße, Chris

  5. Pingback: Android SQLite Tutorial - Teil 1: SQLite Projekt anlegen

  6. Sergej

    Hallo Chris,

    danke sehr für diese Tutorial!
    Eine Frage Noch:
    Wenn ich MainActivity.java von AppCompatActivity ableite und dazu “import android.support.v7.app.AppCompatActivity;” importiere, beschweret sich AndroidStudio und bitet an “Find JAR on Web”. Wenn ich das auswähle, dann kriege ich eine Meldung “no libraries found for …”
    Weist du zufällig woran das liegen kann?

    Gruß
    Sergej

  7. Sergej

    Beim Starten des Apps bekommt _id den Wert “-1″:
    java.lang.RuntimeException: Unable to start activity ComponentInfo{de.xxxxx.shoppinglist/de.xxxxxx.shoppinglist.MainActivity}: android.database.sqlite.SQLiteException: no such table: shopping_list (code 1): , while compiling: SELECT _id, product, quantity FROM shopping_list WHERE _id=-1

    1. Sergej

      Gefixt: in class ShoppingMemoDataSource schließe ich sicherheitshalber dbHelper for dem Öffnen ->

      public void open() {
      /* Workaround wegen folgenden Fehler:
      ‘android.database.sqlite.sqliteexception no such table (code 1) while compiling…’ */
      dbHelper.close();

      Log.d(LOG_TAG, “Eine Referenz auf die Datenbank wird jetzt angefragt.”);
      database = dbHelper.getWritableDatabase();
      Log.d(LOG_TAG, “Datenbank-Referenz erhalten. Pfad zur Datenbank: ” + database.getPath());
      }

      1. Post
        Author
  8. Sergej

    Hmm,
    heute habe ich das Programm neu gestartet und bekomme wieder diesen Fehler:

    no such table: shopping_list (code 1): , while compiling: SELECT _id, product, quantity FROM shopping_list WHERE _id=-1

    Hat jemand eine Idee woran das liegt?

    1. Post
      Author
      Chris

      Hallo Sergej,

      du kannst dir mal die SQLite Datenbank ansehen und schauen wie die Tabelle auf dem Android Gerät tatsächlich erstellt wurde. Hier wird erklärt wie man die Datenbank betrachten kann:

      https://www.quora.com/How-do-I-see-database-tables-in-Android-Studio

      Vielleicht hat sich auch ein Tippfehler in deinen Befehle SQL_CREATE eingeschlichen und es fehlt ein Leerzeichen.

      Wenn du die Datenbank neu erzeugen möchtest, musst du vorher die App von deinem Android Gerät deinstallieren und anschließend die App neu aufspielen.

      Viele Grüße, Chris

  9. Anonymus108

    Hallo und vielen Dank für das schöne Tutorial !
    Bei mir klappt auch alles soweit nach Anleitung.

    Allerdings stehe ich nun vor folgendem Hindernis.
    Ich habe eine Main_activity.class welche ein Fragment hat (Main_activity_fragment.class)
    In diesem Fragment befindet sich aktuell ein custom List view.
    Mit dem im Tutorial angezeigten Code für die Main_activity, welche bei mir ins Fragment muss, klappt das Befüllen des ListViews leider nicht. Jemand ne Idee?

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    ShoppingMemo testMemo = new ShoppingMemo(“Birnen”, 5, 102);
    Log.d(LOG_TAG, “Inhalt der Testmemo: ” + testMemo.toString());

    dataSource = new ShoppingMemoDataSource(this);

    Log.d(LOG_TAG, “Die Datenquelle wird geöffnet.”);
    dataSource.open();

    ShoppingMemo shoppingMemo = dataSource.createShoppingMemo(“Testprodukt”, 2);
    Log.d(LOG_TAG, “Es wurde der folgende Eintrag in die Datenbank geschrieben:”);
    Log.d(LOG_TAG, “ID: ” + shoppingMemo.getId() + “, Inhalt: ” + shoppingMemo.toString());

    Log.d(LOG_TAG, “Folgende Einträge sind in der Datenbank vorhanden:”);
    showAllListEntries();

    Log.d(LOG_TAG, “Die Datenquelle wird geschlossen.”);
    dataSource.close();
    }

    private void showAllListEntries () {
    List shoppingMemoList = dataSource.getAllShoppingMemos();

    ArrayAdapter shoppingMemoArrayAdapter = new ArrayAdapter (
    this,
    android.R.layout.simple_list_item_multiple_choice,
    shoppingMemoList);

    ListView shoppingMemosListView = (ListView) findViewById(R.id.listview_shopping_memos);
    shoppingMemosListView.setAdapter(shoppingMemoArrayAdapter);
    }

  10. Simon

    Hallo : )

    zuerst einmal Danke für dieses tolle Tutorial!

    Ich habe es auf meine Bedürfnisse umgeschrieben und möchte statt der Anzahl der Produkte eine Telefonnummer weitergeben. Jedoch bricht bei mir, jedes mal wenn ich die Daten speichern möchte, das App ab.

    Was habe ich falsch gemacht? Liegt es an zu vielen Zahlen, die mitgegeben werden ?

    Lg

    1. Post
      Author
      Chris

      Hallo Simon,

      danke für das Lob!

      Die Anzahl des Produkts wird als Integer-Datentyp gespeichert. Es kann sein, dass die Telefonnummern eine zu große Integer-Zahl repräsentieren oder dass Sonderzeichen (Leertaste, Schrägstrich) in ihnen enthalten sind und diese natürlich nicht in einer Integer-Variable gespeichert werden können.

      Die größte Integer Zahl ist übrigens 2147483647. Siehe folgender Link: http://www.java2s.com/Tutorial/Java/0040__Data-Type/IntegerMAXMINVALUE.htm

      Viele Grüße, Chris

  11. Barbara

    Hallo,
    Vielen Dank, dein Tutorial hat mir sehr beim Einstieg in Android Studio geholfen.
    Ich möchte allerdings in meiner DB boolean und Date verwenden.
    Das kann der Coursor nicht auslesen. gibt es da einen Trick, dass er das doch kann oder muss ich doch wieder mit Resultset arbeiten. ;(

    1. Post
      Author
      Chris

      Hallo Barbara,

      danke für Dein Lob!

      Bei boolean kann man leicht mit einer Abfrage prüfen, ob der DB-Wert 0 oder 1 ist und ihn dann entsprechend umwandeln. Etwa so:

      Bei dem Date-Datentyp kann man mit folgendem Beispiel-Quellcode arbeiten:

      Viele Grüße, Chris

      1. Barbara

        Danke für die Antwort.
        Ich habe das genauso als Experiment programmiert. Muss es noch testen.
        Macht mir jetzt Hoffnung, dass das wirklich funktioniert. :)

  12. Melissa

    Hallo,
    Tolles Tutorial!
    Stehe leider vor dem Problem, dass meine ListView es sehr seltsam ausgibt.
    Habe dieses Tutorial auf meine Highscore Liste angewendet, allerdings sieht meine Ausgabe pro Zeile dann zum Beispiel so aus: Highscore{id=9, name=”xx”, Lvl1=120, ….}
    Woran könnte es liegen?
    Lg

    1. Post
      Author
      Chris

      Hallo Melissa,

      danke für Dein Lob!

      Es könnte an der fehlenden toString() Methode in Deiner Highscore-Klasse liegen. In der Object-Klasse ist die toString()-Methode standardmäßig implementiert. Da sich alle Klassen von der Object-Klasse ableiten, ist diese Methode daher auch bei Deiner Highscore-Klasse vorhanden. Du kannst die toString() Methode nach Deinen Anforderungen implementieren, dann sollte auch der ListView die übergebenen Elemente sinnvoll darstellen. Der ListView nutzt nämlich automatisch die toString() Methode der übergebenen Listen-Objekte bei der textuellen Darstellung.

      Ich hoffe, meine Ausführungen waren hilfreich und verständlich.

      Viele Grüße, Chris

  13. David

    Hallo Chris,

    vielen Dank für dein ausführliches Tutorial. Es hat mir den Einstieg in die Arbeit mit Datenbanken sehr vereinfacht. Leider stehe ich vor dem Problem anstatt aller Spalten nur eine in dem Listview anzeigen zu lassen. Ich denke, dass es ziemlich einfach ist, aber ich komme einfach nicht drauf. Hier der Quellcode, den ich versucht habe:

    Kannst du mir einen Tipp geben oder sagen, was ich falsch mache?

    Viele Grüße,
    David

    1. Post
      Author
      Chris

      Hallo David,

      es wird wohl an dem String-Array name liegen, den Du in den Zeilen 1 bis 5 definierst. Und zwar, muss darin zuerst die Spalten-ID und anschließend der Spalten-NAME angegeben werden. Etwa so:

      Dann sollte es hoffentlich funktionieren. Falls der Hinweis das Problem nicht löst, kannst Du mir auch den Quellcode Deines Projekts als ZIP-Datei schicken und ich werde mal drüber schauen. Die E-Mail Adresse ist im Impressum angegeben.

      Viele Grüße und viel Erfolg beim Debugging, Chris

  14. Yannick

    Hallo Chris,

    erstmal vielen Dank für dieses tolle Tutorial. Hat mir wirklich sehr geholfen.
    Ich habe dennoch das Problem, dass ich gerne meine erstellten Einträge in einer anderen Activity übergeben möchte und dort anzeigen will. Leider hat bis jetzt nichts geklappt wie ich es versucht habe. Vielleicht könnte mir jemand helfen.

    Beste Grüße

    1. Post
      Author
      Chris

      Hallo Yannick,

      danke für Dein Lob!

      Eine andere Activity kann mit Hilfe eines Intents gestartet werden. Der neuen Activity können beim Starten beliebige Inhalte übergeben werden, die diese dann selbst auslesen und weiterverarbeiten kann.

      Wir haben in folgendem Beitrag Activities und Intents ausführlich beschrieben. Darin zeigen wir auch wie eine Activity mittels expliziten Intent gestartet wird und ihr dabei die Daten des ListView-Eintrags übergeben werden.

      Ich hoffe das hilft Dir etwas weiter.

      Viele Grüße, Chris

      1. Yannick

        Hallo Chris,

        vielen Dank für den Hinweis. Leider konnte ich mein Problem trotzdem nicht lösen :(.
        Mir ist nicht ganz klar wie ich die Liste dem Intent hinzufügen kann….
        Mein Gedanke war, das ich beim Aufruf der ShowAllListEntries(); Methode, einen Intent erzeuge und dort die Liste übergebe. Leider konnte ich noch keinen richtigen Lösungsanstatz hinbekommen. Vielleicht hat du noch einen Tipp wie man die Liste dem Intent hinzufügt ?

        Besten Dank für deine Mühe.

          1. Post
            Author
  15. JimJupiter

    Cursor wirft eine “CursorIndexOutOfBoundsException” ???

    was nu? woran kann es liegen?

    1. Post
      Author
      Chris

      Hallo JimJupiter,

      es sieht aus, als ob auf ein nicht existierendes Objekt zugegriffen wird. Kannst Du den gesamten Stacktrace (Fehlermeldung beim Programmabsturz) einmal posten, dann kann man die Absturzursache meist rekonstruieren.

      Viele Grüße, Chris

  16. JimJupiter

    Hab das Einfügen in ein Switch onclick eingefügt –

    Die Sache ist die, dass in der Datenbank _id immer null ist :(

    1. Post
      Author
      Chris

      Hallo JimJupiter,

      ich bin aus dem Stacktrace leider nicht schlau geworden und kann die Fehlerursache leider auch nicht rekonstruieren.

      Vielleicht hat ein Leser eine Idee woran es liegen könnte? Vielleicht stimmt etwas mit dem SQL_CREATE String nicht?

      Viele Grüße, Chris

  17. Niklas

    Eines der besten Tutorials, das ich je gesehen habe. Sehr gut erklärt, einfach verständlich und genau richtig ausführlich.
    Vielen Dank für’s zur Verfügung stellen, das hat mir wirklich sehr geholfen!

    1. Post
      Author
  18. Zaskar

    Hallo,

    ich habe jetzt soweit alles “nachgebaut” allerdings wird bei mir beim Drehen des Smartphones kein neuer Eintrag in die Datenbank geschrieben! Woran kann das liegen? Im Monitor im Android Studio kann ich auch sehen, dass da nichts passiert.

    Hat jemand eine Idee was das sein kann?

    Gruß,
    Zaskar

    1. Post
      Author
      Chris

      Hallo Zaskar,

      schwierig zu sagen woran es liegt.

      Wenn Du möchtest, kannst Du mir Deine Projektdateien (den ganzen Android Studio Projektordner) als ZIP per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Ich schaue dann mal, ob ich etwas herausfinden kann. Sollte die Zip-Datei zu groß sein, dann schicke nur die Quellcode-Dateien.

      Viele Grüße, Chris

  19. Albert

    Zitat:
    “Nun wünschen wir euch viel Spaß bei Teil 5 unseres Android SQLite Datenbank Tutorials. Los geht’s!”

    Ist nur leider der vierte Teil, ich wollte es nur anmerken.
    Der Satz steht vor der ersten Lektion.

    Bitte

    1. Post
      Author
  20. Carsten

    Hi, ich hab ein Problem.
    Wenn ich die App ausführe bringt er mir immer die Meldung:

    android.database.sqlite.SQLiteException: no such table: shopping_list (code 1): , while compiling: SELECT _id, product, quantity FROM shopping_list WHERE _id=-1

    Android 6
    Sony Xperia Z2

    Hab schon alle Codebeispiele in mein Projket kopiert, geht auch nicht.
    Könntest du das komplette Projekt irgendwo hochladen?

    Schon mal vielen dank!

    1. Post
      Author
      Chris

      Hallo Carsten,

      die Tabelle scheint nicht existent zu sein. Ich würde mir deinen Quellcode gerne mal genauer anschauen und suchen woran es liegt. Dafür benötige ich deine Projektdateien als Zip per E-Mail. Bitte vor dem Packen die beiden build Ordner löschen, die werden nicht benötigt und die Datei wird dadurch viel kleiner. Meine E-Mail Adresse findest du im Impressum.

      Viele Grüße, Chris

  21. Pia

    Hallo,

    bin recht erfreut über das gesamte Tutorial. Es funktioniert auch alles, aber das ListView wird nicht angezeigt. Ich hatte als Test ein eigenes ListView implementiert, hier kann ich ein Array anzeigen, sobald ich aber versuche, nur den Adapter zu ändern, klappt es nicht mehr. Es müßte ja eigentlich das gleiche sein. Ich wollte gerne um den gesamten Quellcode bitten. Die in einem anderen Kommentar oben beschriebenen Zeilen mit dem FragmentManager finde ich hier nirgends in Zusammenhang mit diesem Thema. Es wäre für mich wirklich hilfreich, wenn Du den Quellcode für diese Teil 4 zum Download anbieten könntest. Vielen Dank! Ansonsten der Datenbankteil ist top, mit Programmierkenntnissen in anderen Sprachen, konnte ich das alles sofort auf meine eigenen Belange umsetzen, wirklich toll, aber der Adapter ärgert mich…

    1. Post
      Author
      Chris

      Hallo Pia,

      es sollte eigentlich problemlos funktionieren. Ich habe dir eine E-Mail mit dem kompletten Projekt geschickt. Leider nicht Teil 4 sondern bis zu Teil 8. Ich hoffe, dass es dir weiterhilft.

      Viele Grüße, Chris

  22. sabbelschlaeppchen

    Hallo,

    erst einmal vielen Dank für das gute Tutorial! Ich sitze gerade daran es umzusetzen und ich weiß nicht, in welche Klasse ich den Quelltext aus Teil 4 – 1.1 einsetzen muss. Außerdem wird die Methode put der Klasse ContentValues nicht erkannt. Wahrscheinlich eine simple Anfängerfrage, aber ich bin auch Anfänger.

    Vielen Dank schon einmal für die Antwort.

    sabbelschlaeppchen

    1. sabbelschlaeppchen

      Okay, dieses Problem hat sich erledigt. Ich hatte noch nicht weitergelesen. ;-) Aber auf jeden Fall: Super Tutorial!

      1. Post
        Author
  23. Katja

    Hallo zusammen,

    ich habe folgendes Problem: die Activity startet nicht – Fehlermeldung: java.lang.RuntimeException: Unable to start activity ComponentInfo{com.example.katjarummler.hundeschulebennemann/com.example.katjarummler.hundeschulebennemann.hundeschule}: java.lang.IllegalStateException: Couldn’t read row 0, col -1 from CursorWindow. Make sure the Cursor is initialized correctly before accessing data from it.
    at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:3254)

    Ich weiß nicht, wo und was ich ändern muss oder was ich vergessen habe.
    Kann mir jemand helfen?

    Viele Grüße, Katja

    1. Post
      Author
  24. Henrik

    Hallo Zusammen,

    erstmal vorab super Tutorial!

    Nun zu meinem Problem/Frage:

    Ich möchte einen von Hand gefüllten Array in einer Applikation durch eine Datenbank/Tabelle ersetzen. Ziel ist es also mit einer Zählvariablen genauso durch die Datenbank zu navigieren und die Werte auszulesen wie aus einem “normalen” Array.

    final int anweisungsbilderReihe2[][]={
    {R.drawable.ag1_1_2},
    {0},
    {0},
    {0},
    {R.drawable.ag1_5_2},
    {0},
    {R.drawable.ag1_7_2},
    {R.drawable.ag1_8_2},
    {0},
    };
    ——————————————-
    agZeichnung1.setImageResource(anweisungsbilderReihe1[ag1_nr][0]);

    //ag1_nr ist die Laufvariable zur navigation.
    ——————————————————————
    Wie schaffe ich es das mir von der Datenbank nur ein expliziter Wert ausgegeben wird(Kein Datensatz den ich einem Listview anzeigen muss)? Und wie navigiere ich dann?

    Ich hoffe mein Problem ist klar geworden und ich freue mich auf Rückmeldung!
    Danke

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *