Android Storage

SharedPreferences in Android stores key-value pairs where values must be primitive data types: boolean, float, int, long, and String (or Set). Complex objects like custom classes cannot be directly stored - they must be serialized to primitives first.

The getPreferences() method (called without a name parameter) creates a single preferences file specific to that activity. In contrast, getSharedPreferences() requires a name parameter and can be shared across different activities or components.

Android's built-in database support is SQLite, a lightweight relational database engine. Developers interact with it through Android's SQLite API and SQLiteDatabase class, not through SQLDatabase, Access, or any custom 'android database'.

SharedPreferences stores data as key-value pairs internally. Under the hood, these are saved as XML files in the app's private directory, but the abstraction model is a simple key-value map, not a hash map (the internal implementation detail) or a built-in database.

SharedPreferences and internal storage are private to each application and reside in the app's sandbox, so they require no special permissions. External storage does require permissions (though the exact permissions have changed across Android versions - WRITE_EXTERNAL_STORAGE, READ_EXTERNAL_STORAGE, or scoped storage in newer APIs).

SQLiteOpenHelper is the helper class that manages database creation, version management, and upgrades. It provides onCreate() and onUpgrade() callback methods. The actual database instance is SQLiteDatabase, but SQLiteOpenHelper is the class you extend to implement database management.

SQLite is a relational database engine. It uses SQL (Structured Query Language) for queries, supports tables with defined schemas, relationships between tables through foreign keys, and standard relational database concepts like indexes and views. It is not a network or object-oriented database.

The openFileInput() method returns a FileInputStream (note the specific capitalization with lowercase 'stream'), which is used to read bytes from a file stored in the app's internal storage. It does not return the abstract InputStream or character-based Reader classes.

The openFileOutput() method is used to write data to a file in the app's internal storage. It returns a FileOutputStream. For reading, you would use openFileInput(). These are separate operations - openFileOutput() is specifically for writing, not reading or both.

The external storage directory path varies across devices - different manufacturers use different mount points (e.g., /mnt/sdcard, /sdcard, /storage/emulated/0). Developers should never hardcode paths and should always use the Environment.getExternalStorageDirectory() API or the Storage Access Framework for compatibility.

SQLite in Android does NOT use JDBC, ODBC, or any network connection. Android provides its own SQLite API through SQLiteDatabase and SQLiteOpenHelper classes that directly interact with the database file. This is different from how you'd access SQLite in a Java desktop application using JDBC.

execSQL() in SQLiteDatabase is a general-purpose method for executing single SQL statements that don't return rows - primarily for queries (SELECT). For insert/update operations, Android provides dedicated methods like insert(), update(), delete() which are safer and more convenient.

SQLite is a C-language library, written in ANSI-C for maximum portability across platforms. While Android uses SQLite extensively, SQLite itself was not written in Android or Java - it's a standalone C library that Android incorporates.

The Java File constructor can accept both directory paths and file paths - it represents an abstract path that may refer to either. File objects can be used to check status of both directories (via isDirectory()) and regular files (via isFile()).