Modul 13: Static and Collection - IvanSholana/Pemrograman-Berbasis-Objek-Sistem-Informasi GitHub Wiki
Kata kunci static digunakan untuk mendefinisikan anggota (variabel, metode, atau blok) yang terikat langsung dengan kelas itu sendiri, bukan dengan objek yang diciptakan dari kelas tersebut. Artinya, semua objek yang dibuat dari kelas yang sama akan berbagi variabel atau metode yang sama jika ditandai sebagai static.
Variabel static hanya ada satu untuk setiap kelas, terlepas dari berapa banyak objek yang dibuat dari kelas itu. Variabel static biasanya digunakan untuk menyimpan nilai yang perlu dibagikan di antara semua instance (objek) kelas tersebut, seperti penghitung atau konstanta umum.
class Karyawan {
static int jumlahKaryawan = 0; // Variabel static
Karyawan() {
jumlahKaryawan++; // Menambah jumlah setiap kali objek baru dibuat
}
static void tampilkanJumlahKaryawan() {
System.out.println("Jumlah karyawan: " + jumlahKaryawan);
}
}
public class Main {
public static void main(String[] args) {
new Karyawan();
new Karyawan();
Karyawan.tampilkanJumlahKaryawan(); // Output: Jumlah karyawan: 2
}
}Di sini, jumlahKaryawan akan terus bertambah setiap kali objek baru Karyawan dibuat, karena variabel tersebut adalah variabel static.
Metode static adalah metode yang bisa dipanggil langsung dari kelas tanpa perlu membuat objek. Metode static hanya bisa mengakses variabel static lain atau metode static lainnya di dalam kelas.
class Matematika {
static int kuadrat(int angka) {
return angka * angka;
}
static int pangkatTiga(int angka) {
return angka * angka * angka;
}
}
public class Main {
public static void main(String[] args) {
int hasilKuadrat = Matematika.kuadrat(4); // Output: 16
int hasilPangkatTiga = Matematika.pangkatTiga(3); // Output: 27
System.out.println("Kuadrat: " + hasilKuadrat);
System.out.println("Pangkat Tiga: " + hasilPangkatTiga);
}
}Dalam contoh ini, metode static kuadrat dan pangkatTiga dapat dipanggil langsung dari kelas Matematika tanpa harus membuat objek baru.
Blok static digunakan untuk melakukan inisialisasi statis. Blok ini dieksekusi satu kali, yaitu saat kelas pertama kali di-load ke dalam JVM, sebelum konstruktor dijalankan.
class Inisialisasi {
static int angka;
static {
angka = 100; // Inisialisasi variabel static
System.out.println("Blok static dijalankan. Angka: " + angka);
}
}
public class Main {
public static void main(String[] args) {
new Inisialisasi(); // Blok static akan dieksekusi sekali sebelum objek dibuat
}
}Java Collection Framework adalah sekumpulan kelas dan antarmuka yang digunakan untuk menyimpan dan mengelola data dalam struktur yang berbeda. Collection menyediakan cara untuk menyimpan, mengakses, memanipulasi, dan mengelola kumpulan objek dengan lebih mudah dan efisien.
List adalah tipe collection yang menyimpan elemen secara berurutan dan memungkinkan duplikasi data. Implementasi populer dari List meliputi ArrayList, LinkedList, dan Vector.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> namaList = new ArrayList<>();
namaList.add("Irfan");
namaList.add("Sholana");
namaList.add("Irfan"); // Duplikasi diperbolehkan
for (String nama : namaList) {
System.out.println(nama);
}
}
}Set adalah tipe collection yang tidak mengizinkan adanya elemen duplikat. Implementasi populer dari Set meliputi HashSet, LinkedHashSet, dan TreeSet.
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Set<String> namaSet = new HashSet<>();
namaSet.add("Irfan");
namaSet.add("Sholana");
namaSet.add("Irfan"); // Elemen ini akan diabaikan karena sudah ada dalam set
for (String nama : namaSet) {
System.out.println(nama); // Output tanpa duplikasi
}
}
}Map adalah tipe collection yang menyimpan pasangan key-value. Setiap key harus unik, tetapi nilai (value) dapat memiliki duplikat. Implementasi populer dari Map meliputi HashMap, LinkedHashMap, dan TreeMap.
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String, Integer> umurMap = new HashMap<>();
umurMap.put("Irfan", 25);
umurMap.put("Sholana", 24);
umurMap.put("Irfan", 26); // Nilai sebelumnya akan diganti dengan 26
for (Map.Entry<String, Integer> entry : umurMap.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}Kita bisa menggabungkan static dengan Collection untuk mengelola data bersama yang berkaitan dengan kelas tertentu. Contoh sederhana berikut adalah untuk menyimpan daftar karyawan yang dikelola secara static.
import java.util.ArrayList;
import java.util.List;
class Karyawan {
private String nama;
private static List<Karyawan> daftarKaryawan = new ArrayList<>(); // Collection static
public Karyawan(String nama) {
this.nama = nama;
daftarKaryawan.add(this); // Menambah karyawan ke daftar saat dibuat
}
public static void tampilkanDaftarKaryawan() {
System.out.println("Daftar Karyawan:");
for (Karyawan karyawan : daftarKaryawan) {
System.out.println(karyawan.nama);
}
}
}
public class Main {
public static void main(String[] args) {
new Karyawan("Irfan");
new Karyawan("Sholana");
Karyawan.tampilkanDaftarKaryawan(); // Output: Daftar karyawan yang dibuat
}
}Filtering adalah proses memilih elemen-elemen dari koleksi yang memenuhi kriteria tertentu. Di Java, kita bisa menggunakan berbagai metode, salah satunya adalah Stream API yang diperkenalkan di Java 8.
Stream memungkinkan kita untuk memproses data secara deklaratif, seperti menggunakan kondisi tertentu untuk memilih elemen dari koleksi. Fungsi filter pada Stream digunakan untuk menyaring elemen berdasarkan kondisi.
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> angkaList = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// Menyaring angka yang lebih besar dari 5
List<Integer> hasilFilter = angkaList.stream()
.filter(angka -> angka > 5)
.collect(Collectors.toList());
System.out.println(hasilFilter); // Output: [6, 7, 8, 9, 10]
}
}Penjelasan:
-
stream(): Mengubah koleksi menjadi stream untuk diproses. -
filter(): Memilih elemen yang memenuhi kondisi yang diberikan (dalam hal ini, angka lebih besar dari 5). -
collect(Collectors.toList()): Mengumpulkan hasil filter menjadi koleksi lagi (List).
Kita juga bisa melakukan filter dengan kondisi lebih kompleks, seperti memfilter objek berdasarkan atributnya.
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;
class Karyawan {
String nama;
int umur;
Karyawan(String nama, int umur) {
this.nama = nama;
this.umur = umur;
}
@Override
public String toString() {
return nama + " (" + umur + " tahun)";
}
}
public class Main {
public static void main(String[] args) {
List<Karyawan> karyawanList = new ArrayList<>();
karyawanList.add(new Karyawan("Irfan", 25));
karyawanList.add(new Karyawan("Sholana", 28));
karyawanList.add(new Karyawan("Rina", 23));
karyawanList.add(new Karyawan("Budi", 30));
// Menyaring karyawan yang berusia lebih dari 25
List<Karyawan> hasilFilter = karyawanList.stream()
.filter(karyawan -> karyawan.umur > 25)
.collect(Collectors.toList());
System.out.println(hasilFilter); // Output: [Sholana (28 tahun), Budi (30 tahun)]
}
}Sorting adalah proses mengurutkan elemen dalam koleksi. Di Java, kita dapat mengurutkan elemen menggunakan Stream API atau dengan menggunakan Collections.sort().
Stream menyediakan metode sorted() yang dapat digunakan untuk mengurutkan elemen dalam koleksi berdasarkan urutan natural atau kriteria yang kita tentukan.
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> angkaList = List.of(9, 4, 2, 7, 5, 1, 8, 3, 6);
// Mengurutkan angka secara ascending
List<Integer> hasilSort = angkaList.stream()
.sorted()
.collect(Collectors.toList());
System.out.println(hasilSort); // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]
}
}Untuk mengurutkan secara descending (dari terbesar ke terkecil), kita bisa menggunakan Comparator.reverseOrder().
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
List<Integer> angkaList = List.of(9, 4, 2, 7, 5, 1, 8, 3, 6);
// Mengurutkan angka secara descending
List<Integer> hasilSort = angkaList.stream()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
System.out.println(hasilSort); // Output: [9, 8, 7, 6, 5, 4, 3, 2, 1]
}
}Kita bisa menggunakan Comparator untuk mengurutkan objek berdasarkan salah satu atau lebih atributnya.
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Comparator;
class Karyawan {
String nama;
int umur;
Karyawan(String nama, int umur) {
this.nama = nama;
this.umur = umur;
}
@Override
public String toString() {
return nama + " (" + umur + " tahun)";
}
}
public class Main {
public static void main(String[] args) {
List<Karyawan> karyawanList = new ArrayList<>();
karyawanList.add(new Karyawan("Irfan", 25));
karyawanList.add(new Karyawan("Sholana", 28));
karyawanList.add(new Karyawan("Rina", 23));
karyawanList.add(new Karyawan("Budi", 30));
// Mengurutkan karyawan berdasarkan umur secara ascending
List<Karyawan> hasilSort = karyawanList.stream()
.sorted(Comparator.comparingInt(karyawan -> karyawan.umur))
.collect(Collectors.toList());
System.out.println(hasilSort); // Output: [Rina (23 tahun), Irfan (25 tahun), Sholana (28 tahun), Budi (30 tahun)]
}
}Kita dapat menggabungkan proses filtering dan sorting dalam satu alur pemrosesan menggunakan Stream.
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Comparator;
class Karyawan {
String nama;
int umur;
Karyawan(String nama, int umur) {
this.nama = nama;
this.umur = umur;
}
@Override
public String toString() {
return nama + " (" + umur + " tahun)";
}
}
public class Main {
public static void main(String[] args) {
List<Karyawan> karyawanList = new ArrayList<>();
karyawanList.add(new Karyawan("Irfan", 25));
karyawanList.add(new Karyawan("Sholana", 28));
karyawanList.add(new Karyawan("Rina", 23));
karyawanList.add(new Karyawan("Budi", 30));
// Menyaring karyawan yang berusia lebih dari 25 dan mengurutkannya berdasarkan umur
List<Karyawan> hasil = karyawanList.stream()
.filter(karyawan -> karyawan.umur > 25)
.sorted(Comparator.comparingInt(karyawan -> karyawan.umur))
.collect(Collectors.toList());
System.out.println(hasil); // Output: [Sholana (28 tahun), Budi (30 tahun)]
}
}Iya, benar! Dalam contoh kode tersebut, angka adalah elemen atau anggota dari list.
Lebih tepatnya, ketika kita menggunakan filter(angka -> angka % 2 == 0), kita sedang melakukan iterasi (penyaringan) terhadap setiap elemen dalam stream yang berasal dari koleksi (dalam hal ini list). Setiap elemen dalam list akan diproses oleh angka -> angka % 2 == 0, yang berarti jika elemen tersebut habis dibagi 2 (angka genap), maka elemen tersebut akan disertakan dalam hasil stream.
Berikut adalah potongan kodenya:
List<Integer> angkaList = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// Menggunakan filter untuk menyaring angka genap
List<Integer> angkaGenap = angkaList.stream()
.filter(angka -> angka % 2 == 0) // "angka" di sini adalah elemen dalam list
.collect(Collectors.toList());
System.out.println(angkaGenap); // Output: [2, 4, 6, 8, 10]-
angka -> angka % 2 == 0adalah ekspresi lambda yang menerima satu parameter (angka), yang dalam hal ini merujuk pada elemen dalam stream, dan memeriksa apakah elemen tersebut adalah angka genap. - Setelah filter diterapkan, hanya angka yang memenuhi kondisi (yaitu angka genap) yang akan disertakan dalam hasil akhir.