How to Work With SharedPreferences In Kotlin?

10 minutes read

SharedPreferences is a key-value storage system that allows you to store primitive data types persistently on the device in Android. It is commonly used to store small amounts of data, such as user preferences or app settings. Here's how you can work with SharedPreferences in Kotlin:

  1. Access the SharedPreferences instance: You can retrieve an instance of SharedPreferences using the getSharedPreferences(name, mode) function. The name parameter represents the file name for the preferences, and the mode parameter specifies the access mode.
1
val sharedPreferences = context.getSharedPreferences("MyPrefs", Context.MODE_PRIVATE)


  1. Write data to SharedPreferences: To store data, you can use the SharedPreferences editor, which provides methods like putBoolean(), putString(), putInt(), etc., to store specific data types. To begin editing the SharedPreferences, call the edit() method on the SharedPreferences instance.
1
2
3
4
5
val editor = sharedPreferences.edit()
editor.putBoolean("isFirstLaunch", false)
editor.putString("username", "John Doe")
editor.putInt("age", 25)
editor.apply() // Save the changes asynchronously


  1. Read data from SharedPreferences: To retrieve data from SharedPreferences, you can use the appropriate getter methods (getBoolean(), getString(), getInt(), etc.) on the SharedPreferences instance.
1
2
3
val isFirstLaunch = sharedPreferences.getBoolean("isFirstLaunch", true)
val username = sharedPreferences.getString("username", "")
val age = sharedPreferences.getInt("age", 0)


  1. Remove data from SharedPreferences: To remove a specific data entry, you can use the remove(key) method on the editor.
1
2
editor.remove("age")
editor.apply() // Save the changes asynchronously


  1. Clear all data from SharedPreferences: To clear all data stored in SharedPreferences, you can use the clear() method on the editor.
1
2
editor.clear()
editor.apply() // Save the changes asynchronously


Remember to apply the changes (apply()) or commit them (commit()) on the editor after making modifications to the SharedPreferences. Applying the changes is more efficient if you don't need to know the result of the operation immediately.


By using SharedPreferences, you can easily store and retrieve small amounts of data persistently in your Kotlin Android applications.

Best Kotlin Books to Read in 2024

1
Atomic Kotlin

Rating is 5 out of 5

Atomic Kotlin

2
Kotlin in Action

Rating is 4.9 out of 5

Kotlin in Action

3
Head First Kotlin: A Brain-Friendly Guide

Rating is 4.8 out of 5

Head First Kotlin: A Brain-Friendly Guide

4
Kotlin Programming: The Big Nerd Ranch Guide (Big Nerd Ranch Guides)

Rating is 4.7 out of 5

Kotlin Programming: The Big Nerd Ranch Guide (Big Nerd Ranch Guides)

5
Kotlin Cookbook: A Problem-Focused Approach

Rating is 4.6 out of 5

Kotlin Cookbook: A Problem-Focused Approach

6
Java to Kotlin: A Refactoring Guidebook

Rating is 4.5 out of 5

Java to Kotlin: A Refactoring Guidebook

7
Programming Kotlin: Create Elegant, Expressive, and Performant JVM and Android Applications

Rating is 4.4 out of 5

Programming Kotlin: Create Elegant, Expressive, and Performant JVM and Android Applications

8
Advanced Kotlin (Kotlin for Developers Book 4)

Rating is 4.3 out of 5

Advanced Kotlin (Kotlin for Developers Book 4)


How to check if a key exists in SharedPreferences in Kotlin?

To check if a key exists in SharedPreferences in Kotlin, you can use the contains() method. Here's an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
val sharedPreferences = context.getSharedPreferences("your_preferences_name", Context.MODE_PRIVATE)
val key = "your_key"

if(sharedPreferences.contains(key)) {
    // Key exists in SharedPreferences
    // do something
} else {
    // Key doesn't exist in SharedPreferences
    // do something else
}


In this example, context represents the current context where you're accessing the SharedPreferences. Replace "your_preferences_name" with the actual name of your SharedPreferences file, and "your_key" with the key you want to check. contains() returns true if the key exists in SharedPreferences, and false otherwise.


How to retrieve data from SharedPreferences in Kotlin?

To retrieve data from SharedPreferences in Kotlin, you can use the following approach:

  1. Initialize an instance of SharedPreferences by calling getSharedPreferences() method with the desired name and mode.
1
val sharedPreferences = context.getSharedPreferences("mySharedPreferences", Context.MODE_PRIVATE)


  1. To retrieve a value, use the appropriate getter method on SharedPreferences based on the data type of the stored value. Here are some examples:
  • Retrieving a String value:
1
val stringValue = sharedPreferences.getString("keyString", "default")


  • Retrieving an Integer value:
1
val intValue = sharedPreferences.getInt("keyInt", -1)


  • Retrieving a Boolean value:
1
val boolValue = sharedPreferences.getBoolean("keyBool", false)


  • Retrieving a Float value:
1
val floatValue = sharedPreferences.getFloat("keyFloat", 0.0f)


  • Retrieving a Long value:
1
val longValue = sharedPreferences.getLong("keyLong", 0L)


Note: The second parameter of each getter method is the default value, which will be returned if the preference with the specified key doesn't exist.

  1. Use the retrieved values as needed in your code.


That's it! You can now retrieve data from SharedPreferences in Kotlin using the mentioned approach.


What is the purpose of SharedPreferences.Editor.remove() in Android?

The purpose of SharedPreferences.Editor.remove() in Android is to remove a preference value identified by a specific key. When you use SharedPreferences.Editor.remove(), it allows you to remove a specific preference value that has been previously stored using SharedPreferences.Editor.putString(), SharedPreferences.Editor.putInt(), or other similar methods. This can be useful when you want to remove or clear a specific preference value from the SharedPreferences file.


How to save data using SharedPreferences in Kotlin?

To save data using SharedPreferences in Kotlin, you can follow these steps:


Step 1: Initialize the SharedPreferences object

1
val sharedPreferences = getSharedPreferences("MySharedPref", Context.MODE_PRIVATE)


Step 2: Create an Editor object for modifying preferences

1
val editor = sharedPreferences.edit()


Step 3: Use the editor to store key-value pairs in SharedPreferences

1
2
3
4
5
editor.putString("key", "value") // Example: saving a string
editor.putInt("key", 123) // Example: saving an int
editor.putBoolean("key", true) // Example: saving a boolean
editor.putFloat("key", 1.23f) // Example: saving a float
editor.putLong("key", 1234567890L) // Example: saving a long


Step 4: Apply the changes using the editor

1
editor.apply()


That's it! You have successfully saved the data using SharedPreferences in Kotlin. You can retrieve the saved data using the same key-value pairs you saved before.


What is SharedPreferences.Editor.putStringSet() used for in Android?

In Android, SharedPreferences.Editor.putStringSet() is used to save a set of strings to the SharedPreferences. A set is an unordered collection of unique elements.


By using this method, you can store multiple string values under a single key. This allows you to save and retrieve multiple string sets efficiently, without having to create separate keys for each value in the set.


Here's an example of how to use putStringSet():

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// Get the SharedPreferences object
SharedPreferences sharedPreferences = getSharedPreferences("myPreferences", Context.MODE_PRIVATE);

// Obtain the SharedPreferences.Editor
SharedPreferences.Editor editor = sharedPreferences.edit();

// Create a set of strings
Set<String> stringSet = new HashSet<>();
stringSet.add("Apple");
stringSet.add("Banana");
stringSet.add("Orange");

// Save the set to SharedPreferences using the putStringSet() method
editor.putStringSet("fruits", stringSet);

// Commit the changes
editor.apply();


Later, you can retrieve the string set stored in SharedPreferences using getStringSet():

1
2
3
4
5
6
Set<String> retrievedSet = sharedPreferences.getStringSet("fruits", null);
if (retrievedSet != null) {
    for (String fruit : retrievedSet) {
        Log.d("FRUIT", fruit);
    }
}


In this example, the set of strings "Apple", "Banana", and "Orange" is stored under the key "fruits". You can then retrieve and process the set of strings as needed.


What is the default file name for SharedPreferences in Android?

The default file name for SharedPreferences in Android is "com.example.shared_preferences.xml", where "com.example" is the package name of your Android application.

Facebook Twitter LinkedIn Whatsapp Pocket

Related Posts:

Kotlin reflection allows you to inspect and manipulate code at runtime. Although Kotlin is fully compatible with Java, accessing Kotlin&#39;s reflection API from Java requires some extra steps.To use Kotlin reflection in Java, you need to follow these steps:Im...
The Kotlin Standard Library functions are a set of utility functions that come built-in with the Kotlin programming language. These functions provide convenient ways to perform common tasks when working with different types of data.To use the Kotlin Standard L...
Reading a file in Kotlin involves several steps. Here is a simple explanation of how you can read a file in Kotlin:Import the required classes: To read a file, you need to import the necessary classes. In Kotlin, you can use the java.io.File and kotlin.io.read...