BAB 14

Bekerja dengan File

Apa yang akan kita bahas:

• Pengenalan file I/O Android

• Penyimpanan internal vs. eksternal

• Cara menggunakan penyimpanan internal

Saat Anda perlu bekerja dengan video, audio, json, atau hanya file teks biasa, Anda dapat
menggunakan file Java I/O untuk file lokal. Anda akan menggunakan File, InputStream,
dan OutputWriter, dan I/O di Java—jika Anda pernah menggunakannya sebelumnya. Yang
akan berbeda di Android adalah tempat Anda menyimpannya. Dalam aplikasi desktop Java,
Anda dapat meletakkan file Anda secara praktis di mana pun Anda inginkan. Itu tidak terjadi
di Android. Sama seperti di aplikasi web Java, aplikasi Android tidak gratis untuk membuat
dan membaca file di mana saja. Ada tempat tertentu di mana aplikasi Anda memiliki akses
baca dan tulis.

Penyimpanan Internal dan Eksternal

Android membedakan penyimpanan internal dan eksternal. Penyimpanan internal mengacu
pada bagian flash drive yang digunakan bersama di antara semua aplikasi yang diinstal.
Penyimpanan eksternal mengacu pada ruang penyimpanan yang dapat dipasang oleh
pengguna—biasanya berupa kartu sd, tetapi tidak harus demikian. Selama pengguna dapat
memasangnya, itu bisa apa saja; bahkan bisa menjadi bagian dari flash drive internal.
Setiap opsi memiliki pro dan kontra, jadi Anda perlu mempertimbangkan kebutuhan
aplikasi Anda dan batasan setiap opsi. Daftar berikut menunjukkan beberapa pro dan
kontra ini.

https://doi.org/10.1007/978-1-4842-5937-
5_14
© Ted Hagos 2020
T. Hagos, Pelajari Android Studio 4,
181
 Chapter Working With
14 Files
Penyimpanan internal
• Memori selalu tersedia untuk aplikasi Anda. Tidak ada bahaya pengguna
melepas sdcard atau perangkat apa pun. Dijamin selalu ada.
• Ruang penyimpanan akan berukuran lebih kecil daripada penyimpanan
eksternal karena aplikasi Anda hanya akan dialokasikan sebagian dari
penyimpanan flash yang digunakan bersama oleh semua aplikasi lain.
Ini menjadi perhatian di versi Android sebelumnya, tetapi sekarang
tidak terlalu mengkhawatirkan. Menurut Definisi Kompatibilitas
Android, pada Android 6.0, ponsel atau tablet Android harus memiliki
setidaknya 1,5 GB ruang non-volatil yang disediakan untuk ruang
pengguna (partisi /data). Ruang ini seharusnya cukup untuk sebagian
besar
aplikasi. Anda dapat membaca definisi kompatibilitas di sini: https://bit.ly/
android6compatibilitydefinition.

• Saat aplikasi Anda membuat file di ruang ini, hanya aplikasi Anda
yang dapat mengaksesnya; kecuali ketika ponsel di-root, tetapi
sebagian besar pengguna tidak melakukan root pada ponsel mereka,
jadi umumnya hal itu tidak menjadi masalah.
• Saat Anda mencopot pemasangan aplikasi, semua file yang dibuatnya akan dihapus.

Penyimpanan eksternal

• Biasanya memiliki lebih banyak ruang daripada penyimpanan internal.

• Ini mungkin tidak selalu tersedia, misalnya, saat pengguna melepas

kartu sd atau dipasang sebagai drive USB.
• Semua file di sini dapat dilihat oleh semua aplikasi dan pengguna. Siapa
saja dan aplikasi apa pun dapat membuat dan menyimpan file di sini.
Mereka juga dapat menghapus file.
• Saat aplikasi membuat file di ruang ini, itu bisa hidup lebih lama dari
aplikasi; saat Anda mencopot pemasangan aplikasi, file yang dibuatnya
tidak akan dihapus.

Direktori Cache
 Chapter Working With
Apakah Anda memilih penyimpanan internal atau eksternal, Anda 14 mungkin masih harus
Files
membuat satu keputusan lagi tentang lokasi file. Anda dapat meletakkan file Anda di
direktori cache atau di tempat yang lebih permanen. OS Android atau aplikasi pihak
ketiga dapat mengklaim kembali file dalam direktori cache jika diperlukan ruang. Semua
file yang tidak ada di direktori cache cukup aman
 Chapter Working With
14 Files
kecuali Anda menghapusnya secara manual. Dalam bab ini, kami tidak akan bekerja
dengan direktori cache atau penyimpanan eksternal. Kami hanya akan menggunakan
penyimpanan internal, dan kami akan meletakkan file di lokasi standar.

Cara Bekerja dengan Penyimpanan

Internal
Seperti yang dikatakan sebelumnya, bekerja dengan penyimpanan file di Android seperti
bekerja dengan kelas-kelas biasa di Java I/O. Ada beberapa opsi untuk digunakan seperti
openFileInput() dan openFileOutput()
atau cara lain untuk menggunakan InputStreams dan OutputStreams. Anda hanya perlu
mengingat bahwa panggilan ini tidak akan membiarkan Anda menentukan jalur file. Anda
hanya dapat memberikan nama file; jika Anda tidak peduli dengan itu, lanjutkan dan
gunakan itu—itulah yang akan kita gunakan dalam bab ini. Sebaliknya, jika Anda
membutuhkan lebih banyak fleksibilitas, Anda dapat menggunakan getFilesDir() atau
getCacheDir() untuk mendapatkan File yang menunjuk ke akar lokasi file Anda—
gunakan getCacheDir() jika Anda ingin bekerja dengan cache direktori penyimpanan
internal.
Ketika Anda memiliki File , Anda dapat membuat direktori dan struktur file dari sana.
Itulah letak umum wilayah dalam hal penyimpanan file Android. Sekali lagi, dalam bab
ini, kita hanya akan bekerja dengan penyimpanan internal di lokasi standar (bukan cache).
Menulis ke file memerlukan beberapa langkah sederhana. Anda perlu

1. memutuskan nama file

2. Dapatkan objek FileOutputStream

3. Konversi konten Anda ke ByteArray

4. Tulis ByteArray menggunakan FileOutputStream

5. Jangan lupa untuk menutup file

Daftar 14-1 menunjukkan cuplikan kode beranotasi tentang cara menyimpan data String ke
file.

Daftar 14-1. Menyimpan data String ke file

String nama file = "myfile.txt"; str
 Chapter Working With
14
= "Rubah coklat cepat melompati kepala"; FileOutputStream Files

out = openFileOutput(nama file, Context.MODE_PRIVATE))

{ out.write
(str.getBytes()); catch
 Chapter Working With
14 Files
(IOException e)
{ e.printStackTrace();
}

Pilih nama file.

string yang ingin kita simpan ke file. di aplikasi nyata, Anda mungkin
mendapatkan ini dari konten komponen edittext.
openFileOutput () mengembalikan Fileoutputstream; kita membutuhkan
objek ini sehingga kita dapat menulis ke file. parameter panggilan
pertama adalah nama file yang ingin Anda buat. parameter kedua adalah
mode Konteks. Kami menggunakan MODE_PRIVATE karena kami
ingin file menjadi pribadi untuk aplikasi. Kami menggunakan blok coba-
dengan-sumber daya di sini; dengan cara ini, kita tidak perlu repot
menutup file. Ketika blok keluar, itu akan menutup objek file untuk kita
secara otomatis.
. metode tulis mengharapkan Bytearrayjadi, kita perlu mengubah string
menjadi array byte. metode getBytes() harus melakukannya dengan
baik.

Membaca dari file melibatkan lebih banyak langkah daripada menulisnya. Anda
biasanya perlu melakukan hal berikut:
1. Dapatkan FileInputStream.

2. Baca dari aliran, satu byte pada satu waktu.

3. Teruslah membaca sampai tidak ada lagi yang bisa dibaca. Anda akan
tahu saat berada di akhir file jika nilai byte terakhir yang Anda baca
adalah -1. Saatnya untuk berhenti saat itu.

4. Saat Anda bekerja sampai akhir file, Anda perlu menyimpan byte
yang Anda ambil dari aliran ke dalam wadah sementara.
StringBuilder atau StringBuffer harus melakukan triknya.
Membangun objek String menggunakan operator plus adalah
pemborosan dan tidak efisien karena String tidak dapat diubah.
Setiap kali Anda menggunakan plus , itu membuat objek String
baru; jika file Anda memiliki 2000 karakter, Anda akan membuat
2000 objek String. Ini akan
 Chapter Working With
terjadi jika Anda membaca file teks. Jika Anda membaca14sesuatu Files
yang lain seperti file audio atau video, Anda akan menggunakan
struktur data yang berbeda.
 Chapter Working With
14 Files
5. Saat Anda mencapai akhir file, berhenti membaca. Lakukan apa
yang perlu Anda lakukan dengan apa yang telah Anda baca, dan
jangan lupa untuk menutupnya.
Daftar 14-2 menunjukkan cuplikan kode beranotasi tentang cara membaca data String dari
file.

Daftar 14-2. Membaca dari sebuah file

String nama file = "myfile.txt";
StringBuilder sb = new StringBuilder();
Keluaran string = "";
coba (FileInputStream in = openFileInput(nama file)) { int
read = 0;
while ((baca = in.read()) != -1) { sb.append
((char) read); sb.toString

}
(); Log.e
}

catch(IOException yaitu) {
(TAG, yaitu.getMessage());

Kami tidak akan dapat membaca seluruh file dalam satu gerakan. Kami akan
membacanya dengan potongan. saat kita mendapatkan beberapa
potongan, kita akan menyimpannya di dalam objek stringBuilder.
openFileInput () mengembalikan Fileinputstream; ini adalah objek yang perlu
kita baca dari file. satu-satunya parameter yang diperlukan adalah nama
file yang akan dibaca. Menggunakan try-with-resources di sini membuat
kita tidak perlu menulis kode boilerplate untuk menutup file.
metode satu read() byte data dari aliran input dan mengembalikannya sebagai
bilangan bulat. Kita perlu terus membaca dari aliran satu byte pada satu
waktu sampai kita mencapai penanda akhir file (eoF). Ketika tidak ada lagi
byte untuk dibaca dari aliran, eoF ditandai sebagai -1. Kami akan
 Chapter Working With
menggunakan ini sebagai kondisi untuk loop sementara.
14 Sampai
Filesmetode
read() tidak mengembalikan -1, kami terus membaca.
metode mengembalikan read() sebuah int; ini adalah nilai asCii dari setiap
huruf dalam file, yang dikembalikan sebagai bilangan bulat. Kita harus
melemparkannya ke char sebelum kita bisa memasukkannya ke dalam
stringBuilder.
. Ketika kita kehabisan byte untuk membaca, kita akan keluar dari loop
dan mengeluarkan string dari stringBuildersekarang, Anda dapat
bekerja dengan konten file sebagai string.
 Chapter Working With
14 Files
Mari kita buat proyek kecil untuk menyatukan semua ini. Buat proyek dengan
Aktivitas kosong. Aplikasi kecil kita akan memiliki komponen View berikut:
• EditText—Ini akan memungkinkan kita untuk memasukkan beberapa teks.

• TextView—Saat kita membaca data dari sebuah file, kita akan

menampilkan isinya menggunakan komponen ini.

• Tombol—Ini akan memicu tindakan pengguna untuk menyimpan

konten EditText ke file.
Edit /app/res/layout/activity_main.xml agar sesuai dengan konten Listing 14-3.

Daftar 14-3. app/res/layout/activity_main.xml

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

<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk
/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<Tombol
android:id="@+id
/btn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginBottom="13dp"
android:layout_marginStart="17dp"
android:text="save"
app:layout_constraintBottom_toBottomOf="induk"
app:layout_toStartOfStart_ parent"
tools:ignore="MissingConstraints" />
<EditText
android:id="@+id/txtinput"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginTop="80dp"
 Chapter Working With
14 Files
android:ems=" 10"
android:inputType="textMultiLine"
aplikasi:layout_constraintEnd_toEndOf="induk"
aplikasi:layout_constraintHorizontal_bias="0.
0"
aplikasi:layout_constraintStart_toStartOf="in
duk"
aplikasi:layout_constraintTop_toTopOf="induk"
/>
<TextView android:id="@+id
txtoutput"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginTop="372dp"
android:inputType="textMultiLin e"
android:text="TextView"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.0"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintLayout.Constraintwid> Next.Constraintlayout
. , edit MainActivity agar sesuai dengan konten Listing 14-4.

Daftar 14-4. MainActivity

mengimpor
android.content.Context; impor
android.os.Bundle; impor
android.util.Log;
impor android.view.View; impor
android.widget.Button; impor
android.widget.EditText; impor
android.widget.TextView;
MainActivity kelas publik memperluas
AppCompatActivity { private Button btn; keluaran txt
TextView pribadi;
input txt EditText pribadi;
 Chapter Working With
14 Files
nama file String pribadi = "file
saya.txt"; private String TAG =
getClass().getName();
@Override

protected void onCreate(Bundle terakhir

disimpanInstanceState)
{ super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
txtoutput = findViewById(R.id.txtoutput); txtinput

= findViewById(R.id.txtinput);

btn = findViewById(R.id.btn);
btn.setOnClickListener(new View.OnClickListener() {
public @Override
void onClick(View v) {
// ini adalah tempat kita memicu penyimpanan data

}
});
}
}

edittext , textView, variabel nama file, dan variabel tag sebagai anggota
kelas; kita akan merujuk mereka nanti.
. menginisialisasi variabel textView dan edittext di dalam callback onCreate()
Ikat Tombol ke objek pendengar. Ketika Tombol diklik, kita akan memanggil
metode yang akan berisi kode-kode untuk menyimpan isi txtinput ke sebuah
file.

Selanjutnya, tambahkan metode ke MainActivity dan beri nama saveData(). Edit

agar sesuai dengan kode, seperti yang ditunjukkan pada Listing 14-5. Ini sebagian besar
adalah kode yang sama seperti pada Listing 14-1; satu-satunya perbedaan adalah kita
membaca konten String dari komponen EditText (txtinput).
 Chapter Working With
14 Files
Daftar 14-5. saveData()
private void saveData() {

String str = txtinput.getText().toString();

try (FileOutputStream out = openFileOutput(nama file,
Context.MODE_ PRIVATE)) {
out.write(str.getBytes());
memuatData();
} catch (IOException e)
{ Log.e(TAG,
e.getMessage());
}
}

Selanjutnya, tambahkan metode lain ke MainActivity dan beri nama loadData(); kode-
kode tersebut
ditunjukkan pada Listing 14-6. Ini adalah kode yang sama seperti pada Listing 14-2, tapi
kali ini, kita mengatur teks txtinput dan txtoutput ke isi file yang baru saja kita baca.

Daftar 14-6. loadData()

private void loadData() {

StringBuilder sb = new StringBuilder();

coba (FileInputStream in = openFileInput(nama file))
{ int read = 0;
while ((read = in.read()) != -1) {
sb.append((char) read);
}
txtoutput.setText(sb.toString());
txtinput.setText(sb.toString());
}

catch(IOException yaitu) {
Log.e(TAG, mis.getMessage());

}
}

Kami ingin konten "myfile.txt" ditampilkan saat aplikasi dibuka. Kita dapat melakukan
 Chapter Working With
ini dengan memanggil loadData() di dalam onResume() dari 14
MainActivity.Files
Ganti
onResume() dan panggil metode loadData() , seperti yang ditunjukkan pada Listing 14-7.
 Chapter Working With
14 Files
Daftar 14-7. onResume()
@Override

protected void onResume() {

super.onResume();
memuatData();
}

Pada titik ini, kita sudah cukup banyak selesai. Gambar 14-1 menunjukkan aplikasi kita
berjalan di
emulator.

Gambar 14-1. Aplikasi kami yang telah selesai

Anda dapat melihat konten file lokal menggunakan Device Explorer. Dari bilah menu
utama, pilih Lihat Alat Windows Penjelajah Perangkat. Jendela alat Device Explorer
muncul di IDE, seperti yang ditunjukkan pada Gambar 14-2.
 Chapter Working With
14 Files

Gambar 14-2. Device Explorer

ke data Telusuri data nama paket aplikasi file ). Anda dapat melihat
konten file dengan mengklik dua kali; Android Studio akan menampilkan
isinya.

Ringkasan
• Anda dapat menyimpan file Anda baik di
penyimpanan internal yang selalu tersedia tetapi
terbatas atau di penyimpanan eksternal yang lebih
besar tetapi mungkin dilepas.
• Panggilan Java I/O melempar Pengecualian; menangani mereka
dengan tepat.