Java Generics

  • Array List

    • sumber : http://jagocoding.com/tutorial/1142/Belajar_ArrayList_di_Java%20URL

    - Pakai fitur ini ketika jumlah Data itu tidak bisa Anda tentukan sendiri melainkan dari si User.
    - Contoh program sederhananya seperti program Sequential Searching.

    Pada program Sequential Searching, jumlah Data sebenarnya bisa di modifikasi menjadi 2 pilihan yakni :

    - Jumlah Data ditentukan sendiri oleh si Programmer
    - Jumlah Data di input oleh si User. 

    import java.util.ArrayList;
import java.util.Scanner;

    /**
 * 
 * @author Yudi Setiawan
 * 
 * Input Data dengan ArrayList
 *
 */
    

    public class InputData
{
public static void main(String[] args)
{
//  Buat Objek dari ArrayList
ArrayList arr_data = new ArrayList();
    

    //  Input jumlah Data yang di inginkan oleh User
System.out.print("Input jumlah Data : ");
    
int jlh_data = new Scanner(System.in).nextInt();
    

    //  Input Data dan masukkan ke dalam objek ArrayList yang telah Anda buat
for(int a = 0; a < jlh_data; a++)
{
System.out.print("Masukkan Data ke-"+(a+1)+": ");
arr_data.add(new Scanner(System.in).nextLine());
}
    

    //  Tampilkan nilai yang di simpan di dalam ArrayList
System.out.println("\nTampilkan Data yang di input");
for(Object o : arr_data)
{
System.out.println(o);
}
    

    //  Masukkan Data yang akan dihapus
System.out.print("\nInput Data yang akan dihapus : ");
    
String data_hapus = new Scanner(System.in).nextLine();
    

    //  Lakukan penghapusan Data di dalam ArrayList
arr_data.remove(data_hapus);
    

    //  Tampilkan kembali nilai yang di simpan di dalam ArrayList
System.out.println("\nTampilkan kembali Data yang ada di dalam ArrayList");
for(Object o : arr_data)
System.out.println(o);
    

    }
}

    • 'add' digunakan untuk memasukkan sebuah value ke dalam ArrayList. Sedikit catatan, bahwa pada umumnya ArrayList hanya bisa menyimpan tipe data Object. Namun, Anda bisa mengubahnya sesuai keinginan Anda dengan cara mem-parsing tipe datanya dari object ke tipe data lainnya seperti integer, double dan lainnya. Bisa Anda lihat pada contoh berikutnya.
    • 'remove' digunakan untuk menghapus sebuah value dari daftar ArrayList yang tersedia menggunakan nomor index maupun langsung dari value-nya. Sedikit catatan, bahwa ketika sebuah value dimasukkan ke dalam ArrayList maka, index pertamanya selalu dimulai dari nol(0) dan secara otomatis indexnya akan bertambah dengan sendirinya. Hal inilah yang saya sebut tadi dengan fleksible. Jumlah Datanya tidak terbatas.
    • 'Object o : arr_data' berarti, Anda akan melakukan perulangan sebanyak jumlah Data yang terisi di dalam ArrayList.

    Sequential Program dengan array 
    import java.util.ArrayList;
import java.util.Scanner;

    /**
 * 
 * @author Yudi Setiawan
 * 
 * Contoh Program Sequential Searching dengan fitur ArrayList
 *
 */
    

    public class SequentialSearchingArrayList
{
public static void main(String[] args)
{
//  Buat Objek ArrayList dan set datanya menjadi integer
ArrayList<Integer> arr_data = new ArrayList();
    

    //  Buat Objek Scanner
Scanner scan = new Scanner(System.in);
    

    //  Input jumlah Data yang di inginkan oleh User
System.out.print("Input jumlah Data : ");
    
int jlh_data = scan.nextInt();
    

    //  Input tiap nilai dan masukkan ke dalam ArrayList
System.out.println("\nInput nilai Data");
for(int a = 0; a < jlh_data; a++)
{
System.out.print("Data ke-"+(a+1)+" : ");
int value = scan.nextInt();     //  Membaca inputan dari si User
    

    //  Masukkan ke dalam ArrayList
arr_data.add(value);
}
    

    //  Tampilkan Data hasil inputan
System.out.println("\nData yang ada di dalam ArrayList");
int posisi = 1;
for(Integer i : arr_data)
{
System.out.println("-->Data ke-"+posisi+" : "+i);
posisi++;
}
    

    //  Input Data yang akan dicari
System.out.print("\nInput Data yang akan dicari : ");
    
int cari = scan.nextInt();
    

    //  Proses Pencarian di dalam ArrayList
int iterasi = 1;
boolean temu = false;
for(Integer i : arr_data)
{
if(i == cari)
{
System.out.println("Iterasi ke-"+iterasi);
System.out.println(i+" == "+cari);
temu = true;
break;
}
else
{
System.out.println("Iterasi ke-"+iterasi);
System.out.println(i+" != "+cari);
}
iterasi++;
System.out.println();
}
    

    if(temu == true)
System.out.println("\nData ditemukan pada iterasi ke-"+iterasi);
    

    else
System.out.println("\nData tidak ditemukan");
    

    }
}
    basic array list :

    import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    ArrayList<String> cars = new ArrayList<String>();
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");
    cars.add("Mazda");
    System.out.println(cars);

cars.get(0);
    cars.set(0, "Opel");
    cars.remove(0);
    cars.size();
    
for (int i = 0; i < cars.size(); i++) {
      System.out.println(cars.get(i));
    }
    for (String i : cars) {
      System.out.println(i);
    }

cars.clear();


  }
}

github pak Ardhi :
  • List : 
    • package oop.java.list;

    import java.util.ArrayList;
import java.util.List;
    

    // https://www.geeksforgeeks.org/list-interface-java-examples/
// demo list di Java
public class ListDemo {
public static void main(String[] args) {
// membuat list
// Creating a list
List<Integer> l1 = new ArrayList<Integer>();
    

    // menambahkan element list
// Adds 1 at 0 index
l1.add(0, 1);
    

    // Adds 2 at 1 index
l1.add(1, 2);
System.out.println("list l1: "+l1);
    

    // Creating another list
List<Integer> l2 = new ArrayList<Integer>();
    

    l2.add(1);
l2.add(2);
l2.add(3);
    

    // menambahkan list l2 ke l1 di index 1
// Will add list l2 from 1 index
l1.addAll(1, l2);
System.out.println("list l1 after l2 added: "+l1);
    

    // menghapus element l1 di index 1
// Removes element from index 1
l1.remove(1);
System.out.println("list l1 after 1 removed: "+l1);
    

    // menampilkan element l1 di index 3
// Prints element at index 3
System.out.println("element of l1 at index 3: "+l1.get(3));
    

    // mengganti element l1 di index 0 dengan nilai 5
// Replace 0th element with 5
l1.set(0, 5);
System.out.println("list l1 after 0th element replaced with 5: "+l1);
}
}

  • List 2 :
    • package oop.java.list;

    import java.util.ArrayList;
import java.util.List;
    

    public class ListDemo2 {
// creating ArrayList
List<String> al = new ArrayList<>();
    

    // add ArrayList elements
void addToList() {
al.add("S1");
al.add("UNS");
    

    // menambahkan element di index 1
al.add(1, "Informatika");
    

    // print ArrayList
System.out.println(al);
}
    

    void changeListElement() {
// print ArrayList sebelum diubah
System.out.println("Initial ArrayList " + al);
    

    // ubah element index 2
al.set(2, "Universitas Sebelas Maret");
    

    // print ArrayList setelah diubah
System.out.println("Updated ArrayList " + al);
}
    

    void iterateListELement() {
// Using the Get method and the
// for loop
for (int i = 0; i < al.size(); i++) {
System.out.print(al.get(i) + " ");
}
    

    System.out.println();
    

    // Using the for each loop
for (String str : al)
System.out.print(str + " ");
}
    

    void removingListElement() {
// print list awal
System.out.println("Initial ArrayList " + al);
    

    // hapus list element index 1
al.remove(1);
    

    // print list
System.out.println("After the 1st Index Removal " + al);
    

    // hapus element S1
al.remove("S1");
    

    // print list
System.out.println("After the Object Removal " + al);
}
    

    public static void main(String[] args) {
ListDemo2 ld2 = new ListDemo2();
ld2.addToList();
ld2.changeListElement();
ld2.iterateListELement();
ld2.removingListElement();
}
}

  • Vector :
    • package oop.java.list;

    import java.util.List;
import java.util.Vector;
    

    // https://www.geeksforgeeks.org/list-interface-java-examples/
// contoh Vector
// Vector adalah class yang mengimplements interface List
/*
 * Vector is a class which is implemented in the collection framework implements a growable array of objects. 
 * Vector implements a dynamic array that means it can grow or shrink as required. 
 * Like an array, it contains components that can be accessed using an integer index. */
public class VectorDemo {
public static void main(String[] args) {
// Size of the vector 
int n = 5; 
    

    // Declaring the List with initial size n 
List<Integer> v = new Vector<Integer>(n); 
    

    // Appending the new elements 
// at the end of the list 
for (int i = 1; i <= n; i++) 
v.add(i); 
    

    // Printing elements 
System.out.println(v); 
    

    // Remove element at index 3 
v.remove(3); 
    

    // Displaying the list after deletion 
System.out.println(v); 
    

    // Printing elements one by one 
for (int i = 0; i < v.size(); i++) 
System.out.print(v.get(i) + " "); 
}
}

  • Stack :
    • package oop.java.list;

    import java.util.List;
import java.util.Stack;
    

    // https://www.geeksforgeeks.org/list-interface-java-examples/
// class ini menunjukkan contoh implementasi Stack
// https://www.geeksforgeeks.org/stack-class-in-java
/
 * Stack is a class which is implemented in the collection framework and extends the vector class models 
 * and implements the Stack data structure. 
 * The class is based on the basic principle of last-in-first-out. 
 * In addition to the basic push and pop operations, the class provides three more functions of empty, search and peek./
public class StackDemo {
// Declaring the List
List<Integer> s = new Stack<Integer>();
    

    void createStack() {
// Size of the stack
int n = 5;
    

    // Appending the new elements
// at the end of the list
for (int i = 1; i <= n; i++)
((Stack<Integer>) s).push(i);
    

    // Printing elements
System.out.println(s);
}
    

    void searchStack() {
System.out.println("Does the stack contains '5'? " + ((Stack<Integer>) s).search(5));
    

    // Checking for the element "4"
System.out.println("Does the stack contains '1'? " + ((Stack<Integer>) s).search(1));
// Checking for the element "Hello"
System.out.println("Does the stack contains 'Hello'? " + ((Stack<Integer>) s).search("Hello"));
}
    

    void printStack() {
// Printing elements one by one
for (int i = 0; i < s.size(); i++)
System.out.print(s.get(i) + " ");
}
    

    public static void main(String[] args) {
StackDemo sd = new StackDemo();
sd.createStack();
sd.searchStack();
sd.printStack();
}
}

  • Linked List :
    • package oop.java.list;

    import java.util.LinkedList;
import java.util.List;
    

    // https://www.geeksforgeeks.org/list-interface-java-examples/
// class ini menunjukkan contoh implementasi LinkedList
/* https://www.geeksforgeeks.org/data-structures/linked-list
 *  LinkedList is a class which is implemented in the collection framework which inherently 
 *  implements the linked list data structure. 
 *  It is a linear data structure where the elements are not stored in contiguous locations 
 *  and every element is a separate object with a data part and address part. 
 *  The elements are linked using pointers and addresses. 
 *  Each element is known as a node. Due to the dynamicity and ease of insertions and deletions, 
 *  they are preferred over the arrays*/ 
public class LinkedListDemo {
public static void main(String[] args) {
// Size of the LinkedList 
int n = 5; 
    

    // Declaring the List with initial size n 
List<Integer> ll = new LinkedList<Integer>(); 
    

    // Appending the new elements 
// at the end of the list 
for (int i = 1; i <= n; i++) 
ll.add(i); 
    

    // Printing elements 
System.out.println(ll); 
    

    // Remove element at index 3 
ll.remove(3); 
    

    // Displaying the list after deletion 
System.out.println(ll); 
    

    // Printing elements one by one 
for (int i = 0; i < ll.size(); i++) 
System.out.print(ll.get(i) + " "); 
}
}