> For the complete documentation index, see [llms.txt](https://polinema.gitbook.io/jti-modul-praktikum-algoritma-dan-struktur-data/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://polinema.gitbook.io/jti-modul-praktikum-algoritma-dan-struktur-data/struktur-data-linier/job-sheet-5-stack/praktikum-1.md).

# Praktikum 1

## Pengantar

Pada percobaan ini, kita akan membuat program yang mengilustrasikan tumpukan pakaian yang disimpan ke dalam stack. Karena sebuah pakaian mempunyai beberapa informasi, maka implementasi Stack dilakukan dengan menggunakan array of object untuk mewakili setiap elemennya.

Untuk kebutuhan praktikum, perhatikan class diagram `Pakaian` dan `Stack` berikut ini. `Pakaian` merupakan representasi dari objek pakaian yang akan disusun dengan menggunakan konsep `Stack`.

<figure><img src="/files/rK1NSgI5ZAb3QqF6n4B5" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/AGGFiuzZv0aBdjoID2Tb" alt=""><figcaption></figcaption></figure>

## Langkah Percobaan

* Buatlah proyek dengan nama `Praktikum1`. Kemudian buatlah class nama `Pakaian` sesuai dengan class diagram yang telah dijelaskan sebelumnya.

```java
public class Pakaian {
    String jenis, warna, merek, ukuran;
    Double harga;

    Pakaian(String jenis, String warna, String merek, String ukuran, Double harga) {
        this.jenis = jenis;
        this.warna = warna;
        this.merek = merek;
        this.ukuran = ukuran;
        this.harga = harga;
    }
}
```

* Selanjutnya, buatlah class `Stack` sesuai dengan class diagram yang telah dijelaskan sebelumnya. Tambahkan atribut dan konstrutornya.

**Keterangan**: Tipe data pada variabel data menyesuaikan dengan data yang akan akan disimpan di dalam `Stack`. Pada praktikum ini, data yang akan disimpan merupakan array of object dari `Pakaian`, sehingga tipe data yang digunakan adalah `Pakaian`.

```java
int size;
int top;
Pakaian data[];

public Stack(int size) {
    this.size = size;
    data = new Pakaian[size];
    top = -1;
}
```

* Tambahkan method `isEmpty()`.

```java
public boolean isEmpty() {
    if(top == -1) {
        return true;
    } else {
        return false;
    }
}
```

* Selanjutnya buat method `isFull()`.

```java
public boolean isFull() {
    if(top == size -1) {
        return true;
    } else {
        return false;
    }
}
```

* Buat method `push()` bertipe void untuk menambahkan isi elemen stack dengan parameter `pkn` yang berupa objek `Pakaian`.

```java
public void push(Pakaian pkn) {
    if(!isFull()){
        top++;
        data[top] = pkn;
    } else {
        System.out.println("Isi stack penuh!");
    }
}
```

* Buat method `pop()` bertipe void untuk mengeluarkan isi elemen stack. Hal ini dikarenakan satu elemen stack terdiri dari beberapa informasi (jenis, warna, merk, ukuran, dan harga), maka ketika mencetak data juga perlu ditampilkan semua informasi tersebut.

{% code overflow="wrap" %}

```java
public void pop() {
    if(!isEmpty()){
        Pakaian x = data[top];
        top--;
        System.out.println("Data yang keluar: " + x.jenis + " " + x.warna + " " + x.merk + " " + x.ukuran + " " + x.harga);
    } else {
        System.out.println("Stack masih kosong");
    }
}
```

{% endcode %}

* Buat method `peek()` bertipe void untuk memeriksa elemen stack pada posisi paling atas.

{% code overflow="wrap" %}

```java
public void peek() {
    System.out.println("Elemen teratas: " + data[top].jenis + " " + data[top].warna + " " + data[top].merk + " " + data[top].ukuran + " " + data[top].harga); 
}
```

{% endcode %}

* Buat method `print()` bertipe void untuk menampilkan seluruh elemen pada stack.

{% code overflow="wrap" %}

```java
public void print() {
    System.out.println("Isi stack: ");
    for(int i = top; i >=0; i--) {
        System.out.println("Elemen teratas: " + data[i].jenis + " " + data[i].warna + " " + data[i].merk + " " + data[i].ukuran + " " + data[i].harga + " ");
    }
    System.out.println("");
}
```

{% endcode %}

* Buat method `clear()` bertipe void untuk menghapus seluruh isi stack.

{% code overflow="wrap" %}

```java
public void clear() {
    if(!isEmpty()) {
        for(int i = top; i >= 0; i--) {
            top--;
        }
        System.out.println("Stack sudah dikosongkan");
    } else {
        System.out.println("Stack masih kosong");
    }
}
```

{% endcode %}

* Selanjutnya, buat class baru dengan nama `StackMain`. Buat fungsi main, kemudian lakukan instansiasi objek dari class `Stack` dengan nama `stk` dan nilai parameternya adalah 5.

```java
Stack stk = new Stack(5)
```

* Deklarasikan objek `Scanner` dengan nama `sc`.
* Tambahkan kode berikut ini untuk menerima input data `Pakaian`, kemudian semua informasi

  tersebut dimasukkan ke dalam stack.

{% code overflow="wrap" lineNumbers="true" %}

```java
char pilih;
do {
    System.out.print("Jenis: ");
    String jenis = sc.nextLine();
    System.out.print("Warna: ");
    String warna = sc.nextLine();
    System.out.print("Merk: ");
    String merk = sc.nextLine();
    System.out.print("Ukuran: ");
    String ukuran = sc.nextLine();
    System.out.print("Harga: ");
    double harga = sc.nextDouble();
    
    Pakaian p = new Pakaian(jenis, warna, merk, ukuran, harga);
    System.out.print("Apakah Anda akan menambahkan data baru ke stack (y/n)? ");
    pilih = sc.next().charAt(0);
    sc.nextLine();
    stk.push(p);
} while (pilih == 'y');
```

{% endcode %}

**Catatan**: sintaks sc.nextLine() sebelum sintaks st.push(p) digunakan untuk mengabaikan karakter new line.

* Lakukan pemanggilan method `print()`, method `pop()`, dan method `peek()` dengan urutan sebagai berikut.

```java
stk.print();
stk.pop();
stk.peek();
stk.print();
```

* Compile dan jalankan class `StackMain`, kemudian amati hasilnya.

<figure><img src="/files/8g9UizzRSgQy6mOn53kP" alt=""><figcaption></figcaption></figure>

## Pertanyaan

1. Berapa banyak data pakaian yang dapat ditampung di dalam stack? Tunjukkan potongan kode program untuk mendukung jawaban Anda tersebut!
2. Perhatikan class `StackMain`, pada saat memanggil fungsi `push()` (line 18), parameter yang dikirimkan adalah **p**. Data apa yang tersimpan pada variabel **p** tersebut?&#x20;
3. Apakah fungsi penggunaan **do-while** yang terdapat pada class `StackMain`?
4. Modifikasi kode program pada class `StackMain` sehingga pengguna dapat memilih operasi- operasi pada stack (push, pop, peek, atau print) melalui pilihan menu program dengan

   memanfaatkan kondisi IF-ELSE atau SWITCH-CASE!


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://polinema.gitbook.io/jti-modul-praktikum-algoritma-dan-struktur-data/struktur-data-linier/job-sheet-5-stack/praktikum-1.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.