. .

BAGIAN KE EMPAT : JAVA ARRAY LIST PADA NETBEANS IDE

Posted by CHRISTIANTO D,WIBOWO | D3MI-2016 STMIK BUMI GORA On Sabtu, November 26, 2016 No comments

Sebelum kita meneruskan mempelajari pembelajaran ini, ada baiknya kita baca artikel-artikel sebelumnya yang terhubung dengan langkah-langkah pembelajaran ini (Link) BAHASA PEMROGRAMAN - JAVA.

Berikut ini ada sebuah contoh project yang bisa jadi bahasan pembelajaran kita kali ini. Meskipun kita belum menguasai belum kode-kode yang ada didalamnya, ada baiknya kita lihat dan amati penulisan kode dan hasilnya. Tetapi sebelum kita memulai contoh kode Java ArrayList, kita harus lebih teliti bahwa ketika kita menggunakan Java ArrayList dan Java collections classes lainnya, Java classes sangat mudah kehilangan kontrol atas ukuran collections yang sudah digunakan. Situasi ini dapat mengakibatkan Java menimbulkan masalah yang beragam pada kinerjanya. Hal terbaik yang dapat membantu kita di sini adalah Java profilers dan performance monitoring, reporting tools. Misalnya, NetBeans Profiler untuk menganalisis aplikasi Java ( - -  yang kita gunakan saat ini - -),  WebSphere Studio Profiling Tool.

NetBeans Profiler adalah proyek untuk mengintegrasikan JFluid profiling technoglogy, yang dikembangkan oleh Sun, ke dalam NetBeans IDE. Peng-Alamatan masalah  JFluid profiling technoglogy ini disediakan oleh mekanisme dalam JVM™, yang memungkinkan pengguna untuk mengubah profil dan mematikannya setiap saat, dan, sama pentingnya, untuk profil hanya sebahagian kecil dari kode, bahwa saat ini tertarik. memprofilkan himpunan dari bagian kode dan jenis profiling (CPU, memori, dll) dapat diubah setiap saat pada waktu berjalan. Hal ini dicapai terutama melalui bytecode instrumentasi dinamis -  dynamic bytecode instrumentation. Fitur termasuk profil overhead rendah, dilampirkan ke aplikasi yang sedang berjalan, CPU Performance profiling, memory profiling, memory leak debugging dan task-based profiling.
Heap Analysis Tool (HAT) membantu untuk debug objek retensi yang tidak perlu (kadang-kadang disebut "kebocoran memori") dengan menyediakan sarana yang nyaman untuk browsing topologi objek dalam tumpukan snapshot, yang dihasilkan oleh VM Java. HAT membaca file hprof, kemudian menempatkan dirinya sebagai web server - sehingga memungkinkan kita untuk menjalankan query terhadap tumpukan sampah - heap dump contained yang terdapat dalam file hprof.

HAT kini telah disertakan dengan Java SE. Dimulai dengan Java SE 6, HAT telah diganti dengan jhat, yang disertakan dengan standard Sun distribution. HAT tidak dipertahankan dalam konfigurasi yang berdiri sendiri. Source code untuk jhat tersedia dengan rilis dengan Java SE.

Ketika kita mem-profil (er), kita perlu alat yang paling kuat yang dapat kita dapatkan. Pada saat yang sama, kita tidak ingin menghabiskan waktu untuk belajar bagaimana menggunakan alat ini. JProfiler, sederhana dan kuat pada saat yang sama. Dengan JProfiler kita dapat langsung mengamati profil data aplikasi kita berjalan. CPU, memori dan rangkaian profil views diperbarui secara langsung dan dapat diperiksa tanpa perlu menunggu pengukuran untuk menyelesaikan. Menemukan kebocoran memori dapat menjadi mustahil tanpa alat yang tepat. JProfiler's heap walker menawarkan antarmuka intuitif untuk memecahkan kedua masalah memori sederhana dan kompleks.

Dan oleh sebab itu mengapa kita menggunakan NetBeans Profiler dalam pembelajaran kita mendalami Java, Berikut barisan kode dari contoh project  Java Array List (Buatlah NEW PROJECT untuk contoh ini, dan saya berharap JANGAN MENGHAPUS credit @author originalnya milik Copyright (c) 1998-2005 Jeffrey M. Hunter. All rights reserved. Website :  http://www.idevelopment.info ) :

// -----------------------------------------------------------------------------
// ArrayListExample.java
// -----------------------------------------------------------------------------

/*
 * =============================================================================
 * Copyright (c) 1998-2005 Jeffrey M. Hunter. All rights reserved.
 *
 * All source code and material located at the Internet address of
 * http://www.idevelopment.info is the copyright of Jeffrey M. Hunter, 2005 and
 * is protected under copyright laws of the United States. This source code may
 * not be hosted on any other site without my express, prior, written
 * permission. Application to host any of the material elsewhere can be made by
 * contacting me at jhunter@idevelopment.info.
 *
 * I have made every effort and taken great care in making sure that the source
 * code and other content included on my web site is technically accurate, but I
 * disclaim any and all responsibility for any loss, damage or destruction of
 * data or any other property which may arise from relying on it. I will in no
 * case be liable for any monetary damages arising from such loss, damage or
 * destruction.
 *
 * As with any code, ensure to test this code in a development environment
 * before attempting to run it in production.
 * =============================================================================
 */
package arraylistexample;

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Collections;
import java.util.Random;
/**
 * -----------------------------------------------------------------------------
 * The following class provides an example of storing and retrieving objects
 * from an ArrayList.
 *
 * A List corresponds to an "ordered" group of elements where duplicates are
 * allowed.
 *
 * An ArrayList is a good choice for simple sequences.
 * It is an Array based implementation where elements of the List can be
 * accessed directly through get() and set() methods.
 *
 * ArrayList's give great performance on get() and set() methods, but do not
 * perform well on add() and remove() methods when compared to a LinkedList.
 *
 * @version 1.0
 * @author  Jeffrey M. Hunter  (jhunter@idevelopment.info)
 * @author  http://www.idevelopment.info
 * -----------------------------------------------------------------------------
 */
/**
 *
 * @author Christianto Dharma Wibowo a.k.a GEMBLONG
 */
public class ArrayListExample {

    /**
     * @param args the command line arguments
     */
    public void doArrayListExample() {
        // TODO code application logic here
        final int MAX = 10;
        int counter = 0;

        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Create/Store objects in an ArrayList container.                     |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        List listA = new ArrayList();
        List listB = new ArrayList();

        for (int i = 0; i < MAX; i++) {
            System.out.println("  - Storing Integer(" + i + ")");
            listA.add(new Integer(i));
        }

        System.out.println("  - Storing String(Alex)");
        listA.add("Alex");

        System.out.println("  - Storing String(Melody)");
        listA.add("Melody");

        System.out.println("  - Storing String(Jeff)");
        listA.add("Jeff");

        System.out.println("  - Storing String(Alex)");
        listA.add("Alex");

        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Retrieve objects in an ArrayList container using an Iterator.       |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        Iterator i = listA.iterator();
        while (i.hasNext()) {
            System.out.println(i.next());
        }


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Retrieve objects in an ArrayList container using a ListIterator.    |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        counter = 0;
        ListIterator li = listA.listIterator();
        while (li.hasNext()) {
            System.out.println("Element [" + counter + "] = " + li.next());
            System.out.println("  - hasPrevious    = " + li.hasPrevious());
            System.out.println("  - hasNext        = " + li.hasNext());
            System.out.println("  - previousIndex  = " + li.previousIndex());
            System.out.println("  - nextIndex      = " + li.nextIndex());
            System.out.println();
            counter++;
        }


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Retrieve objects in an ArrayList container using index.             |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        for (int j=0; j < listA.size(); j++) {
            System.out.println("[" + j + "] - " + listA.get(j));
        }


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Search for a particular Object and return its index location.       |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        int locationIndex = listA.indexOf("Jeff");
        System.out.println("Index location of the String \"Jeff\" is: " + locationIndex);


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Search for an object and return the first and last (highest) index. |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("First occurance search for String \"Alex\".  Index =  " + listA.indexOf("Alex"));
        System.out.println("Last Index search for String \"Alex\".       Index =  " + listA.lastIndexOf("Alex"));


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Extract a sublist from the main list, then print the new List.      |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        List listSub = listA.subList(10, listA.size());
        System.out.println("New Sub-List from index 10 to " + listA.size() + ": " + listSub);


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Sort the Sub-List created above.                                    |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("Original List   : " + listSub);
        Collections.sort(listSub);
        System.out.println("New Sorted List : " + listSub);
        System.out.println();


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Reverse the Sub-List created above.                                 |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("Original List     : " + listSub);
        Collections.reverse(listSub);
        System.out.println("New Reversed List : " + listSub);
        System.out.println();


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Check to see if the Lists are empty.                                |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("Is List A empty?   " + listA.isEmpty());
        System.out.println("Is List B empty?   " + listB.isEmpty());
        System.out.println("Is Sub-List empty? " + listSub.isEmpty());


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Clone the initial List.                                             |");
        System.out.println("| NOTE: The contents of the List are object references, so both       |");
        System.out.println("|       of the List's contain the same exact object reference's.      |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("List A   (before) : " + listA);
        System.out.println("List B   (before) : " + listB);
        System.out.println("Sub-List (before) : " + listSub);
        System.out.println();
        System.out.println("Are List's A and B equal? " + listA.equals(listB));
        System.out.println();
        listB = new ArrayList(listA);
        System.out.println("List A   (after)  : " + listA);
        System.out.println("List B   (after)  : " + listB);
        System.out.println("Sub-List (after)  : " + listSub);
        System.out.println();
        System.out.println("Are List's A and B equal? " + listA.equals(listB));


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Shuffle the elements around in some Random order for List A.        |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("List A   (before) : " + listA);
        System.out.println("List B   (before) : " + listB);
        System.out.println("Sub-List (before) : " + listSub);
        System.out.println();
        System.out.println("Are List's A and B equal? " + listA.equals(listB));
        System.out.println();
        Collections.shuffle(listA, new Random());
        System.out.println("List A   (after)  : " + listA);
        System.out.println("List B   (after)  : " + listB);
        System.out.println("Sub-List (after)  : " + listSub);
        System.out.println();
        System.out.println("Are List's A and B equal? " + listA.equals(listB));


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Convert a List to an Array.                                         |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        Object[] objArray = listA.toArray();
        for (int j=0; j < objArray.length; j++) {
            System.out.println("Array Element [" + j + "] = " + objArray[j]);
        }


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Remove (clear) Elements from List A.                                |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("List A   (before) : " + listA);
        System.out.println("List B   (before) : " + listB);
        System.out.println();
        listA.clear();
        System.out.println("List A   (after)  : " + listA);
        System.out.println("List B   (after)  : " + listB);
        System.out.println();

    }


    /**
     * Sole entry point to the class and application.
     * @param args Array of String arguments.
     */
    public static void main(String[] args) {
        ArrayListExample listExample = new ArrayListExample();
        listExample.doArrayListExample();
    }

}

Hasilnya :
run:
+---------------------------------------------------------------------+
| Create/Store objects in an ArrayList container.                     |
+---------------------------------------------------------------------+

  - Storing Integer(0)
  - Storing Integer(1)
  - Storing Integer(2)
  - Storing Integer(3)
  - Storing Integer(4)
  - Storing Integer(5)
  - Storing Integer(6)
  - Storing Integer(7)
  - Storing Integer(8)
  - Storing Integer(9)
  - Storing String(Alex)
  - Storing String(Melody)
  - Storing String(Jeff)
  - Storing String(Alex)

+---------------------------------------------------------------------+
| Retrieve objects in an ArrayList container using an Iterator.       |
+---------------------------------------------------------------------+

0
1
2
3
4
5
6
7
8
9
Alex
Melody
Jeff
Alex

+---------------------------------------------------------------------+
| Retrieve objects in an ArrayList container using a ListIterator.    |
+---------------------------------------------------------------------+

Element [0] = 0
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 0
  - nextIndex      = 1

Element [1] = 1
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 1
  - nextIndex      = 2

Element [2] = 2
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 2
  - nextIndex      = 3

Element [3] = 3
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 3
  - nextIndex      = 4

Element [4] = 4
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 4
  - nextIndex      = 5

Element [5] = 5
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 5
  - nextIndex      = 6

Element [6] = 6
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 6
  - nextIndex      = 7

Element [7] = 7
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 7
  - nextIndex      = 8

Element [8] = 8
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 8
  - nextIndex      = 9

Element [9] = 9
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 9
  - nextIndex      = 10

Element [10] = Alex
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 10
  - nextIndex      = 11

Element [11] = Melody
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 11
  - nextIndex      = 12

Element [12] = Jeff
  - hasPrevious    = true
  - hasNext        = true
  - previousIndex  = 12
  - nextIndex      = 13

Element [13] = Alex
  - hasPrevious    = true
  - hasNext        = false
  - previousIndex  = 13
  - nextIndex      = 14


+---------------------------------------------------------------------+
| Retrieve objects in an ArrayList container using index.             |
+---------------------------------------------------------------------+

[0] - 0
[1] - 1
[2] - 2
[3] - 3
[4] - 4
[5] - 5
[6] - 6
[7] - 7
[8] - 8
[9] - 9
[10] - Alex
[11] - Melody
[12] - Jeff
[13] - Alex

+---------------------------------------------------------------------+
| Search for a particular Object and return its index location.       |
+---------------------------------------------------------------------+

Index location of the String "Jeff" is: 12

+---------------------------------------------------------------------+
| Search for an object and return the first and last (highest) index. |
+---------------------------------------------------------------------+

First occurance search for String "Alex".  Index =  10
Last Index search for String "Alex".       Index =  13

+---------------------------------------------------------------------+
| Extract a sublist from the main list, then print the new List.      |
+---------------------------------------------------------------------+

New Sub-List from index 10 to 14: [Alex, Melody, Jeff, Alex]

+---------------------------------------------------------------------+
| Sort the Sub-List created above.                                    |
+---------------------------------------------------------------------+

Original List   : [Alex, Melody, Jeff, Alex]
New Sorted List : [Alex, Alex, Jeff, Melody]


+---------------------------------------------------------------------+
| Reverse the Sub-List created above.                                 |
+---------------------------------------------------------------------+

Original List     : [Alex, Alex, Jeff, Melody]
New Reversed List : [Melody, Jeff, Alex, Alex]


+---------------------------------------------------------------------+
| Check to see if the Lists are empty.                                |
+---------------------------------------------------------------------+

Is List A empty?   false
Is List B empty?   true
Is Sub-List empty? false

+---------------------------------------------------------------------+
| Clone the initial List.                                             |
| NOTE: The contents of the List are object references, so both       |
|       of the List's contain the same exact object reference's.      |
+---------------------------------------------------------------------+

List A   (before) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Melody, Jeff, Alex, Alex]
List B   (before) : []
Sub-List (before) : [Melody, Jeff, Alex, Alex]

Are List's A and B equal? false

List A   (after)  : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Melody, Jeff, Alex, Alex]
List B   (after)  : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Melody, Jeff, Alex, Alex]
Sub-List (after)  : [Melody, Jeff, Alex, Alex]

Are List's A and B equal? true

+---------------------------------------------------------------------+
| Shuffle the elements around in some Random order for List A.        |
+---------------------------------------------------------------------+

List A   (before) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Melody, Jeff, Alex, Alex]
List B   (before) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Melody, Jeff, Alex, Alex]
Sub-List (before) : [Melody, Jeff, Alex, Alex]

Are List's A and B equal? true

List A   (after)  : [3, Alex, Jeff, 0, 7, 5, 4, Alex, 9, 2, 1, 8, Melody, 6]
List B   (after)  : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Melody, Jeff, Alex, Alex]
Sub-List (after)  : [1, 8, Melody, 6]

Are List's A and B equal? false

+---------------------------------------------------------------------+
| Convert a List to an Array.                                         |
+---------------------------------------------------------------------+

Array Element [0] = 3
Array Element [1] = Alex
Array Element [2] = Jeff
Array Element [3] = 0
Array Element [4] = 7
Array Element [5] = 5
Array Element [6] = 4
Array Element [7] = Alex
Array Element [8] = 9
Array Element [9] = 2
Array Element [10] = 1
Array Element [11] = 8
Array Element [12] = Melody
Array Element [13] = 6

+---------------------------------------------------------------------+
| Remove (clear) Elements from List A.                                |
+---------------------------------------------------------------------+

List A   (before) : [3, Alex, Jeff, 0, 7, 5, 4, Alex, 9, 2, 1, 8, Melody, 6]
List B   (before) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Melody, Jeff, Alex, Alex]

List A   (after)  : []
List B   (after)  : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Melody, Jeff, Alex, Alex]

BUILD SUCCESSFUL (total time: 0 seconds)

Rumit dan Jelimet,  itu pasti, tetapi disinilah yang perlu kita pelajari dan membuat kita jadi tidak rumit dan tidak jelimet.

Jika kita tidak tahu berapa banyak barang yang akan diadakan dalam sebuah array, akan lebih baik menggunakan sesuatu yang disebut ArrayListArrayList adalah struktur data dinamis - dynamic data structure, yang berarti item dapat ditambahkan dan dihapus langsung dari daftar. Sebuah array normal dalam java adalah struktur data statis, karena kita terjebak dengan ukuran awal sebuah array.
Untuk mendirikan sebuah ArrayList, pertama kita harus mengimpor paket dari java.util library:
     import java.util.ArrayList;     
Dan kemudian kita dapat membuat ArrayList object yang baru :
     ArrayList listTest = new ArrayList( );     
Perhatikan saat ini kita tidak membutuhkan tanda kurung kurawa. Kita hanya butuh ArrayList objects yang baru, dan kita bisa menambahkan eleman ke ArrayList objects dengan menambahkan metode :
listTest.add( "first item" );
listTest.add( "second item" );
listTest.add( "third item" );
listTest.add( 7 );
Di antara kurung bulat ada isi/nilai yang kita tambahkan, kita bisa menempatkan apa yang kita ingin tambahkan kedalam ArrayList. Kita hanya dapat menambahkan objek, namun. tiga item pertama yang telah ditambahkan ke daftar di atas adalah String objek. Item keempat adalah angka - numeric. Tapi ini AKAN menjadi objek sejumlah jenis Integer, dan bukan lagi tipe data int primitif.
Item dalam daftar dapat direferensikan oleh nomor Index, dan dengan menggunakan get method:
     listTest.get( 3 )     
Dalam baris kode ini, akan mengambil item pada posisi indek 3 dalam daftar. dan nomor indeks dimulai dari 0, jadi item-nya ada 4. Kita juga bisa menghilangkan item dari ArrayList. Juga kita bisa menggunakan nomor indeks :
     listTest.remove(2);     
Atau kita juga bisa menggunakan nilai dari ArrayList : 
     listTest.remove( "second item" );     
Menghapus item akan mengubah ukuran ArrayList, sehingga kita harus berhati-hati ketika mencoba untuk mendapatkan item pada daftar pada saat menggunakan nomor Index. Jika kita telah menghapus item nomor 2, maka daftar di atas hanya akan berisi 3 item. Mencoba untuk mendapatkan item dengan Indeks angka 3 maka akan menghasilkan kesalahan - error.

Untuk memproses melalui setiap item dalam ArrayList kita, kita dapat mengatur sesuatu yang disebut Iterator. Class ini juga dapat ditemukan di java.util library:
     import java.util.Iterator;     
Kemudian kita dapat melampirkan ArrayList ke objek Iterator baru:
    Iterator it = listTest.iterator( );      
Hal ini akan membuat sebuah objek Iterator baru yang dapat digunakan untuk memproses melalui item dalam ArrayList disebut listTest. Alasan untuk menggunakan sebuah objek Iterator adalah karena memiliki metode yang disebut berikutnya dan hasNext. Kita dapat menggunakannya dalam satu lingkaran - loop:
while ( it.hasNext( ) ) {
System.out.println( it.next( ) );
}
Metode hasNext mengembalikan nilai Boolean. nilai akan false jika tidak ada item lainnya di ArrayList. Metode selanjutnya dapat digunakan untuk memproses melalui semua item dalam daftar.
Untuk pembuktiannya, cobalah kode berikut:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package arraylisttest;

/**
 *
 * @author Christianto Dharma Wibowo a.k.a GEMBLONG
 */
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayllstTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        ArrayList listTest = new ArrayList();
        listTest.add("first item");
        listTest.add("second item");
        listTest.add("third item");
        listTest.add("7");
     
        Iterator it = listTest.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        //MENGHILANGKAN ITEM DARI ARRAYLIST
        listTest.remove("second item");
     
        //MENCETAK LIST BARU
        System.out.println("Whole list=" + listTest);
     
        //MENGAMBIL ITEM DARI POSISI INDEKS
        System.out.println("Position 1=" +listTest.get(1));
        }
     
    }

Hasilnya :
run:
first item
second item
third item
7
Whole list=[first item, third item, 7]
Position 1=third item
BUILD SUCCESSFUL (total time: 1 second)

KETERANGAN :
first item  ➽ Hasil dari while (it.hasNext()) {
                            System.out.println(it.next());  // Posisi-1 dengan Nomor Indeks 0
second item   ➽ Hasil dari   listTest.remove("second item");  //Menghilang isi array dengan value "second item" yang berada posisi-2 dengan nomor indeks 1
first item
third item  
7
Whole list=[first item, third item, 7] ➽ Hasil dari System.out.println("Whole list=" + listTest); // akibat "second item" sudah di remove
Position 1=third item ➽ Hasil dari System.out.println("Position 1=" +listTest.get(1)); // karena "second item" sudah diremove, maka Posisi 1= "third item" dengan Nomor Indeks 1 (Nomor Indeks 0 = "first item")


Perhatikan baris kode yang mencetak seluruh list :
      System.out.println( "Whole list=" + listTest );     
Baris kode itu memberikan kita cara cepat untuk seluruh item dalam list yang tersisa.
Singkatnya, menggunakan ArrayList ketika kita tidak yakin berapa banyak elemen yang akan berada di daftar item.
Baiklah, selanjutnya kita akan membahas : JAVA STRINGS

0 komentar:

Posting Komentar