Android Data Storage: SharedPreferences

In Android app development, data storage is a critical component. As user input increases, efficiently managing and storing data becomes increasingly important. In this chapter, we’ll focus on SharedPreferences—a lightweight key-value storage mechanism ideal for saving simple data such as user preferences and application settings.

What Is SharedPreferences?

SharedPreferences is an Android-provided mechanism for persisting simple key-value pairs. It’s well-suited for storing small amounts of data—such as user settings, app state, and other lightweight information. Compared to using a full database, SharedPreferences is more concise and efficient—especially when your data volume is small.

Common Use Cases

• Storing user login status
• Saving user preferences (e.g., theme selection, sound toggle)
• Recording application configuration parameters

Creating and Using SharedPreferences

1. Obtaining a SharedPreferences Instance

To use SharedPreferences, you first need to obtain an instance. You can do so via the getSharedPreferences() method:

SharedPreferences sharedPreferences = getSharedPreferences("example_prefs", MODE_PRIVATE);

In the code above, "example_prefs" is the name of the underlying XML file used to store the data. When sharing preferences across processes or components, be sure to specify appropriate access modes—such as MODE_PRIVATE (default, app-private) or MODE_MULTI_PROCESS (deprecated; avoid in new code).

2. Writing Data

Use a SharedPreferences.Editor object to write data conveniently. Here's a simple example:

SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("username", "john_doe");
editor.putBoolean("isLoggedIn", true);
editor.apply(); // Asynchronous commit

Here, putString() and putBoolean() store the key-value pairs "username" and "isLoggedIn". Finally, apply() asynchronously commits the changes to disk.

✅ Note: Prefer apply() over commit() unless you need immediate synchronous confirmation—the former is more efficient and avoids blocking the UI thread.

3. Reading Data

Reading data is equally straightforward—use methods like getString() and getBoolean():

String username = sharedPreferences.getString("username", "default_user");
boolean isLoggedIn = sharedPreferences.getBoolean("isLoggedIn", false);

If the specified key doesn’t exist, these methods return the provided default values ("default_user" and false, respectively).

4. Removing a Key-Value Pair

To delete a specific entry, use remove():

editor.remove("username");
editor.apply(); // Commit the change

5. Clearing All Data

To erase all stored data in the SharedPreferences file, call clear():

editor.clear();
editor.apply(); // Commit the change

Practical Example

Suppose we’re building a simple app where users can select a theme color—and we want the app to remember and apply their last choice upon relaunch. Here’s how to implement it:

Step 1: Save the User’s Theme Selection

After the user selects a theme (e.g., dark mode), save it:

String selectedTheme = "dark"; // Assume user chose dark theme
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("appTheme", selectedTheme);
editor.apply();

Step 2: Retrieve and Apply the Saved Theme

At app startup, retrieve and apply the saved preference:

String appTheme = sharedPreferences.getString("appTheme", "light"); // Default: light theme
if ("dark".equals(appTheme)) {
    // Apply dark theme
} else {
    // Apply light theme
}

This example illustrates how SharedPreferences simplifies persistent user configuration management.

Important Considerations

1. Data Security: SharedPreferences stores data in plain text. For sensitive information (e.g., tokens, passwords), consider encrypting values before storage—or better yet, use the Android Keystore System or EncryptedSharedPreferences.
2. Data Volume: Avoid storing large datasets in SharedPreferences. If your app requires structured, relational, or voluminous data, prefer SQLite (or Room, its modern abstraction layer).

Summary

This chapter introduced the fundamentals of SharedPreferences: its purpose, core operations (read/write/remove/clear), common use cases, and practical implementation patterns. As a lightweight, fast, and easy-to-use storage option, SharedPreferences is an essential tool for every Android developer.

In the next chapter, we’ll dive into SQLite—and later, the Room persistence library—to explore robust, scalable solutions for complex data storage and management. With both approaches in your toolkit, you’ll be able to confidently choose the right storage strategy based on your app’s specific needs.