1. Introduction

Android applications often need to store structured information such as student records, user details, product information, and transaction history.

Android provides SQLite as a built-in relational database engine. Developers can interact with SQLite directly using classes such as SQLiteOpenHelper, SQLiteDatabase, and Cursor.

However, Android also provides the Room Persistence Library, which makes database operations easier by adding an abstraction layer over SQLite.

In this tutorial, you will learn:

• What SQLite Database is.

• What Room Persistence Library is.

• How Room works internally.

• The main differences between SQLite and Room.

• Important Room components.

• How to create a Room Database using Java.

• When to use SQLite and when to use Room.

2. What Is SQLite Database?

SQLite is a lightweight relational database engine that is available on Android devices.

It stores structured information in tables containing rows and columns.

For example, a Student Database can contain:

• Student ID

• Student Name

• Student Email

Example SQL table:

CREATE TABLE students (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT,
    email TEXT
);

Android provides SQLite APIs that allow developers to create tables, insert records, retrieve information, update records, and delete records.

Important SQLite Classes

SQLiteOpenHelper

This class helps create and upgrade an SQLite database.

Important methods:

• onCreate() – Creates database tables.

• onUpgrade() – Handles database version changes.

• getWritableDatabase() – Opens a database for writing.

• getReadableDatabase() – Opens a database for reading.

SQLiteDatabase

This class provides methods to execute database operations.

Examples:

db.insert();
db.query();
db.update();
db.delete();

ContentValues

ContentValues stores column names and their corresponding values.

Cursor

Cursor is used to read records returned by a database query.

Example: Insert Data Using SQLite

SQLiteDatabase db = dbHelper.getWritableDatabase();

ContentValues values = new ContentValues();

values.put("name", "Rahul");
values.put("email", "rahul@gmail.com");

long result = db.insert(
        "students",
        null,
        values
);

This code inserts a new student record into the students table.

3. What Is Room Database?

Room is an Android persistence library that provides an abstraction layer over SQLite.

It allows developers to work with database records using Java or Kotlin objects instead of writing repetitive low-level database code.

Room uses SQLite internally to store information on the device.

It provides several important benefits:

1. Compile-time verification of SQL queries.

2. Less repetitive database code.

3. Easier mapping between Java objects and database tables.

4. Structured database access through DAO interfaces.

5. Support for database migrations.

6. Integration with Android architecture components.

For these reasons, Android recommends Room instead of directly using low-level SQLite APIs for many new applications.

4. How Room Database Works

Room has three main components:

1. Entity

An Entity represents a database table.

For example, a Student entity defines the structure of the students table.

2. DAO (Data Access Object)

DAO is an interface that defines methods for database operations.

It can contain methods for:

• Insert

• Select

• Update

• Delete

3. RoomDatabase

RoomDatabase is the main database class.

It connects the application with the database and provides access to DAO interfaces.

Room Architecture

The basic data flow looks like this:

       Android Activity
              |
              v
          RoomDatabase
              |
              v
             DAO
              |
              v
           SQLite
              |
              v
        Local Database

Room generates the required database implementation during compilation using its annotation processor.

5. SQLite vs Room Database

Both SQLite and Room are used for local structured data storage, but they provide different ways to interact with the database.

Main Differences

SQLite

• A database engine.

• Uses low-level Android database APIs.

• Requires more manual database code.

• Uses SQLiteOpenHelper for basic database creation and upgrades.

• Uses ContentValues and Cursor for common operations.

• SQL errors in manually written queries may appear at runtime.

Room

• An abstraction layer over SQLite.

• Uses Entity, DAO, and RoomDatabase.

• Reduces repetitive database code.

• Maps database rows to Java or Kotlin objects.

• Checks supported SQL queries at compile time.

• Provides structured migration support.

Important Concept

SQLite and Room are not two completely different database engines.

Room uses SQLite underneath. The main difference is how developers interact with the database.

6. When Should You Use SQLite?

SQLite can be useful in situations where you need direct access to the database APIs.

Consider SQLite when:

1. You are learning SQL and database fundamentals.

2. You want to understand how Android database operations work internally.

3. You are maintaining an existing application that already uses SQLiteOpenHelper.

4. You need direct control over low-level SQLite operations.

5. You are working with a small educational project that specifically requires native SQLite APIs.

Example Projects Using SQLite

• Simple Student Database App.

• Basic Contact Management App.

• Small offline record management application.

• SQL learning and practice projects.

7. When Should You Use Room?

Room is generally a better choice for new Android applications that store structured local data.

Consider Room when:

1. Your application has multiple database tables.

2. You want to reduce repetitive database code.

3. You want SQL queries checked during compilation.

4. You need a cleaner database architecture.

5. You want easier database migration management.

6. You want to integrate database operations with LiveData or other supported observable data types.

Example Projects Using Room

• Student Management App.

• Expense Tracker App.

• Inventory Management App.

• Notes Application.

• Offline Task Management App.

• Product Management Application.

8. Set Up Room Database in Android Studio Using Java

Now let's understand how to create a Room Database using Java.

We will create a simple Student Database with these fields:

• ID

• Name

• Email

Step 1: Create a New Project

1. Open Android Studio.

2. Click New Project.

3. Select Empty Views Activity.

4. Enter the project name: RoomDatabaseApp.

5. Select Java as the programming language.

6. Choose the Minimum SDK.

7. Click Finish.

Wait for the project to finish loading.

Step 2: Add Room Dependencies

Open the app-level build.gradle file.

Add these dependencies inside the dependencies block:

Groovy DSL:

def room_version = "2.8.5"

implementation "androidx.room:room-runtime:$room_version"

annotationProcessor "androidx.room:room-compiler:$room_version"

Kotlin DSL:

val roomVersion = "2.8.5"

implementation("androidx.room:room-runtime:$roomVersion")

annotationProcessor("androidx.room:room-compiler:$roomVersion")

Click Sync Now.

Important: This example uses Room 2.8.5 with Java annotation processing. Room 3.0 has a different setup and Kotlin-based code generation, so this Java tutorial uses the Room 2.x API.

9. Create a Student Entity

Create a Java class named:

Student.java

Add the following code:

package com.example.roomdatabaseapp;

import androidx.room.Entity;
import androidx.room.PrimaryKey;

@Entity(tableName = "students")
public class Student {

    @PrimaryKey(autoGenerate = true)
    private int id;

    private String name;

    private String email;

    public Student(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Understanding the Entity Code

@Entity

@Entity(tableName = "students")

This annotation tells Room that the Student class represents a database table named students.

@PrimaryKey

@PrimaryKey(autoGenerate = true)
private int id;

This creates an automatically generated primary key.

Name and Email

These fields become columns in the students table.

Room uses the class structure to generate the required table mapping.

10. Create the Student DAO Interface

Create a Java interface named:

StudentDao.java

Add this code:

package com.example.roomdatabaseapp;

import androidx.room.Dao;
import androidx.room.Delete;
import androidx.room.Insert;
import androidx.room.Query;
import androidx.room.Update;

import java.util.List;

@Dao
public interface StudentDao {

    @Insert
    void insertStudent(Student student);

    @Query("SELECT * FROM students")
    List<Student> getAllStudents();

    @Update
    void updateStudent(Student student);

    @Delete
    void deleteStudent(Student student);

    @Query("SELECT * FROM students WHERE id = :studentId")
    Student getStudentById(int studentId);
}

Understanding DAO Annotations

@Dao

Marks the interface as a Data Access Object.

@Insert

Inserts a new Student object into the database.

@Query

Executes a custom SQL query.

@Update

Updates an existing Student record using its primary key.

@Delete

Deletes the supplied Student record.

The :studentId in the query is a named parameter. Room binds the method argument to that parameter.

11. Create the Room Database Class

Create a Java class named:

AppDatabase.java

Add the following code:

package com.example.roomdatabaseapp;

import android.content.Context;

import androidx.room.Database;
import androidx.room.Room;
import androidx.room.RoomDatabase;

@Database(
        entities = {Student.class},
        version = 1,
        exportSchema = false
)
public abstract class AppDatabase extends RoomDatabase {

    private static volatile AppDatabase INSTANCE;

    public abstract StudentDao studentDao();

    public static AppDatabase getDatabase(Context context) {

        if (INSTANCE == null) {

            synchronized (AppDatabase.class) {

                if (INSTANCE == null) {

                    INSTANCE = Room.databaseBuilder(
                            context.getApplicationContext(),
                            AppDatabase.class,
                            "StudentDatabase"
                    ).build();
                }
            }
        }

        return INSTANCE;
    }
}

Understanding the Database Class

@Database

@Database(
    entities = {Student.class},
    version = 1,
    exportSchema = false
)

This annotation defines the database configuration.

• entities identifies the database tables.

• version defines the database schema version.

• exportSchema controls whether Room exports the database schema.

RoomDatabase

public abstract class AppDatabase extends RoomDatabase

This class extends RoomDatabase and acts as the main access point.

studentDao()

This abstract method provides access to the StudentDao interface.

databaseBuilder()

This creates the Room database instance.

The singleton pattern ensures that the application normally uses one shared database instance instead of creating multiple expensive instances.

12. Use Room Database in MainActivity

Now open:

MainActivity.java

For this example, we will demonstrate how to insert and read student records.

package com.example.roomdatabaseapp;

import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MainActivity extends AppCompatActivity {

    EditText etName, etEmail;

    Button btnSave, btnView;

    TextView tvResult;

    AppDatabase database;

    ExecutorService executorService =
            Executors.newSingleThreadExecutor();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        etName = findViewById(R.id.etName);
        etEmail = findViewById(R.id.etEmail);

        btnSave = findViewById(R.id.btnSave);
        btnView = findViewById(R.id.btnView);

        tvResult = findViewById(R.id.tvResult);

        database = AppDatabase.getDatabase(this);

        // INSERT STUDENT
        btnSave.setOnClickListener(v -> {

            String name = etName.getText().toString().trim();

            String email = etEmail.getText().toString().trim();

            if (name.isEmpty() || email.isEmpty()) {

                Toast.makeText(this,
                        "Enter Name and Email",
                        Toast.LENGTH_SHORT).show();

                return;
            }

            Student student = new Student(name, email);

            executorService.execute(() -> {

                database.studentDao().insertStudent(student);

                runOnUiThread(() -> {

                    Toast.makeText(this,
                            "Student Saved Successfully",
                            Toast.LENGTH_SHORT).show();

                    etName.setText("");
                    etEmail.setText("");
                });
            });
        });

        // READ STUDENTS
        btnView.setOnClickListener(v -> {

            executorService.execute(() -> {

                List<Student> students =
                        database.studentDao().getAllStudents();

                StringBuilder result = new StringBuilder();

                for (Student student : students) {

                    result.append("ID: ")
                            .append(student.getId())
                            .append("\n");

                    result.append("Name: ")
                            .append(student.getName())
                            .append("\n");

                    result.append("Email: ")
                            .append(student.getEmail())
                            .append("\n");

                    result.append("------------------\n");
                }

                if (students.isEmpty()) {
                    result.append("No Student Records Found");
                }

                runOnUiThread(() ->
                        tvResult.setText(result.toString()));
            });
        });
    }

    @Override
    protected void onDestroy() {

        executorService.shutdown();

        super.onDestroy();
    }
}

Why Do We Use ExecutorService?

Room does not allow ordinary blocking database queries on the main UI thread by default.

The ExecutorService runs database operations on a background thread.

This helps prevent database work from blocking the user interface.

The runOnUiThread() method is used to update the screen after the background operation finishes.

13. Create the Main Activity XML Layout

Open:

activity_main.xml

Add this layout:

<?xml version="1.0" encoding="utf-8"?>

<ScrollView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:padding="20dp">

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Room Database App"
            android:textSize="24sp"
            android:textStyle="bold"
            android:gravity="center"
            android:padding="15dp" />

        <EditText
            android:id="@+id/etName"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Enter Student Name"
            android:inputType="textPersonName" />

        <EditText
            android:id="@+id/etEmail"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Enter Student Email"
            android:inputType="textEmailAddress" />

        <Button
            android:id="@+id/btnSave"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Save Student" />

        <Button
            android:id="@+id/btnView"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="View Students" />

        <TextView
            android:id="@+id/tvResult"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Student Records"
            android:textSize="16sp"
            android:padding="15dp" />

    </LinearLayout>

</ScrollView>

14. How to Test the Room Database App

Now run the application on an emulator or a real Android phone.

Follow these steps:

1. Enter a student name.

2. Enter a student email.

3. Click Save Student.

4. Enter another student record.

5. Click View Students.

6. Check the saved records displayed on the screen.

Example records:

ID: 1
Name: Rahul
Email: rahul@gmail.com
------------------

ID: 2
Name: Amit
Email: amit@gmail.com
------------------

The records are stored locally using Room and SQLite.

15. Important Room Database Best Practices

Follow these practices when developing applications with Room:

1. Keep Entity classes focused on database table structures.

2. Keep database operations inside DAO interfaces.

3. Use a shared database instance for a single-process application.

4. Perform blocking database operations on background threads.

5. Use proper migrations when changing the database structure.

6. Avoid destructive migrations when existing user data must be preserved.

7. Validate user input before inserting records.

8. Use appropriate indexes for frequently searched columns.

9. Close database resources when the application no longer needs them.

16. Room Database vs SQLite: Which One Should You Choose?

The correct choice depends on your project requirements.

Choose SQLite when:

• You want to learn low-level SQL operations.

• You need direct access to SQLite APIs.

• You are maintaining an existing SQLiteOpenHelper project.

• Your educational project specifically requires native SQLite.

Choose Room when:

• You are starting a new Android application.

• You want less repetitive database code.

• You want compile-time SQL query verification.

• You need a structured database architecture.

• You want easier integration with Android development libraries.

For most new Android applications that require local structured data, Room is the recommended starting point.

17. Conclusion

In this tutorial, you learned the differences between SQLite and Room Database in Android.

You discovered that SQLite is the underlying database engine, while Room provides a higher-level abstraction for accessing SQLite.

You also learned about Entity, DAO, RoomDatabase, database dependencies, and how to create a Room Database using Java.

Understanding both technologies is important for Android developers. SQLite helps you understand the fundamentals of database operations, while Room helps you build cleaner and more maintainable applications.

Practice Task: Create a Student Management App using Room Database. Add student records, display them in RecyclerView, update existing records, and delete selected records.