From 2cdf6f72f35356de2fc40eb1a6c7c593208ec8b2 Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Mon, 28 Mar 2022 20:27:42 +0700 Subject: [PATCH 01/66] docs: Menambahkan Utilitas Repo --- .github/ISSUE_TEMPLATE/lain-lain.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 .github/ISSUE_TEMPLATE/lain-lain.md diff --git a/.github/ISSUE_TEMPLATE/lain-lain.md b/.github/ISSUE_TEMPLATE/lain-lain.md new file mode 100644 index 0000000..11af0e3 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/lain-lain.md @@ -0,0 +1,18 @@ +--- +name: Lain-Lain +about: buat report deskripsi untuk pull request +title: Penambahan Algoritma/Dokumentasi +labels: enhancement +assignees: '' +--- + + +## description + + +## saya menggunakan +OS : ``Linux / Windows / MacOS`` +Java: + +## tambahan lainnya + From 92a452731ead275f80b4966c149103358f7d3e79 Mon Sep 17 00:00:00 2001 From: khaira nabila <75076265+khairanabila@users.noreply.github.com> Date: Wed, 11 May 2022 08:25:19 +0700 Subject: [PATCH 02/66] add: menambahkan program faktor persekutuan terbesar (#107) --- src/main/java/maths/GCD.java | 55 ++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 src/main/java/maths/GCD.java diff --git a/src/main/java/maths/GCD.java b/src/main/java/maths/GCD.java new file mode 100644 index 0000000..f6105ec --- /dev/null +++ b/src/main/java/maths/GCD.java @@ -0,0 +1,55 @@ +package math; + +/* +* program sederhana untuk menghitung faktor +* persekutuan terbesar +*/ + +public class GCD { + /* + * @param angka1 parameter angka pertama + * @param angka2 parameter angka kedua + * @return hasil persekutuan terbesar + */ + + public static int gcd(int angka1, int angka2) { + if (angka1 < 0 || angka2 < 0) { + // cek jika angk minus + throw new ArithmeticException(); + } + + if (angka1 == 0 || angka2 == 0) { + return Math.abs(angka1 - angka2); + } + + while (angka1 % angka2 != 0) { + int reminder = angka1 % angka2; + angka1 = angka2; + angka2 = reminder; + } + + return angka2; + } + + /* + * membuat hasil dari fungsi static fungsi perseketuan + * terbesar + */ + + public static int gcd(int[] angka) { + int hasil = angka[0]; + for (int i = 1; i < angka.length; i++) { + result = gcd(result, angka[i]); + } + + return hasil; + } + + public static void main(String[] args) { + int[] arraySaya = {4, 16, 32}; + + System.out.println(gcd(arraySaya)); + + System.out.println("gcd(40,24)=%d\n",gcd(40, 24)); + } +} From 0564e3cbccb5b715d111f1143dcaab2d9b1782cf Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Wed, 25 May 2022 16:45:12 +0700 Subject: [PATCH 03/66] feat: Memperbaharui Maven Compiler --- pom.xml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pom.xml b/pom.xml index 202a325..7bf7623 100644 --- a/pom.xml +++ b/pom.xml @@ -12,8 +12,8 @@ UTF-8 - 17 - 17 + 18 + 18 @@ -40,12 +40,12 @@ maven-compiler-plugin - 3.8.1 + 3.8.5 maven-surefire-plugin - 2.22.2 + 3.0.0-M6 - \ No newline at end of file + From f29304ae366a729ca492e6328f662476895d0f4b Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Wed, 25 May 2022 16:47:15 +0700 Subject: [PATCH 04/66] feat: Memperbaharui Compiler Java --- .github/workflows/build.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 03d6184..fa92e37 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -6,11 +6,11 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - - name: Set up JDK 17 + - name: Set up JDK 18 uses: actions/setup-java@v2 with: - java-version: 17 + java-version: 18 distribution: 'adopt' - name: build project dengan maven run: mvn --batch-mode --update-snapshots verify - \ No newline at end of file + From 4e50a3543d2b391884779e9d25645d9b4992315b Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Wed, 25 May 2022 16:55:25 +0700 Subject: [PATCH 05/66] feat: Memperbaharaui Maven --- pom.xml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pom.xml b/pom.xml index 7bf7623..16b7af8 100644 --- a/pom.xml +++ b/pom.xml @@ -12,8 +12,8 @@ UTF-8 - 18 - 18 + 17 + 17 @@ -40,11 +40,11 @@ maven-compiler-plugin - 3.8.5 + 3.8.1 maven-surefire-plugin - 3.0.0-M6 + 2.22.2 From 8cabbd3dec65ec13b53a0796ff47071fb21522a5 Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Wed, 25 May 2022 16:59:19 +0700 Subject: [PATCH 06/66] feat: Memperbaharui Maven --- pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 16b7af8..d610f44 100644 --- a/pom.xml +++ b/pom.xml @@ -12,8 +12,8 @@ UTF-8 - 17 - 17 + 18 + 18 From 6ef3e57a9b2623236180c311511821c0610a2b32 Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Thu, 26 May 2022 09:03:35 +0700 Subject: [PATCH 07/66] feat: Memperbaharui Materi Pemrograman --- src/main/java/maths/GCD.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/maths/GCD.java b/src/main/java/maths/GCD.java index f6105ec..f35b5bd 100644 --- a/src/main/java/maths/GCD.java +++ b/src/main/java/maths/GCD.java @@ -50,6 +50,6 @@ public static void main(String[] args) { System.out.println(gcd(arraySaya)); - System.out.println("gcd(40,24)=%d\n",gcd(40, 24)); + System.out.format("gcd(40,24) = %d\n",gcd(40, 24)); } } From baa3a44796713e1f31009de7015d28caced57194 Mon Sep 17 00:00:00 2001 From: Bhimantoro Suryo Admodjo Date: Sat, 11 Jun 2022 20:58:22 -0400 Subject: [PATCH 08/66] fix: Memperbaharui kode program (#109) Co-authored-by: bhimsur --- src/main/java/maths/GCD.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/maths/GCD.java b/src/main/java/maths/GCD.java index f35b5bd..365d139 100644 --- a/src/main/java/maths/GCD.java +++ b/src/main/java/maths/GCD.java @@ -39,7 +39,7 @@ public static int gcd(int angka1, int angka2) { public static int gcd(int[] angka) { int hasil = angka[0]; for (int i = 1; i < angka.length; i++) { - result = gcd(result, angka[i]); + hasil = gcd(hasil, angka[i]); } return hasil; From 3c6118e1de3f72b143f137e5253307df1334e7c4 Mon Sep 17 00:00:00 2001 From: Bhimantoro Suryo Admodjo Date: Sat, 11 Jun 2022 21:32:34 -0400 Subject: [PATCH 09/66] Linearsearch (#110) * fix: Memperbaharui kode program * add: Menambahkan algoritma dan dokumentasi baru Co-authored-by: bhimsur --- .../datastructure/Search/LinearSearch.java | 25 +++++++++++++++++++ .../algorithm/datastructure/Search/README.md | 10 ++++++++ 2 files changed, 35 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Search/LinearSearch.java create mode 100644 src/main/java/algorithm/datastructure/Search/README.md diff --git a/src/main/java/algorithm/datastructure/Search/LinearSearch.java b/src/main/java/algorithm/datastructure/Search/LinearSearch.java new file mode 100644 index 0000000..9d52168 --- /dev/null +++ b/src/main/java/algorithm/datastructure/Search/LinearSearch.java @@ -0,0 +1,25 @@ +package algorithm.datastructure.Search; + +import java.util.Arrays; + +public class LinearSearch { + public static int linearSearch(T[] array, S key) { + for (int i = 0; i < array.length; i++) { + if (array[i] == key) { + return i; + } + } + return -1; + } + + public static void main(String[] args) { + Integer[] arrayInt = {10, 15, 25, 35, 40, 70}; + String[] arrayString = {"Eat", "Sleep", "Repeat"}; + int key1 = 40; + String key2 = "Sleep"; + System.out.println("array to be search: " + Arrays.toString(arrayInt)); + System.out.println(key1 + " is found at index: " + linearSearch(arrayInt, key1)); + System.out.println("array to be search: " + Arrays.toString(arrayString)); + System.out.println(key2 + " is found at index: " + linearSearch(arrayString, key2)); + } +} diff --git a/src/main/java/algorithm/datastructure/Search/README.md b/src/main/java/algorithm/datastructure/Search/README.md new file mode 100644 index 0000000..19bd9ae --- /dev/null +++ b/src/main/java/algorithm/datastructure/Search/README.md @@ -0,0 +1,10 @@ +# Linear Search +_Linear Search_ adalah algoritma pencarian yang sangat sederhana. Dalam jenis pencarian ini, pencarian berurutan dilakukan pada semua item satu per satu. Setiap item diperiksa dan jika kecocokan ditemukan maka item tertentu dikembalikan, jika tidak, pencarian berlanjut hingga akhir pengumpulan data. +## Cara Kerja +- Lakukan perulangan pada _array_ +- Cocokkan elemen kunci dengan elemen pada _array_ +- Jika elemen kunci ditemukan, kembalikan posisi indeks elemen _array_ +- Jika elemen kunci tidak ditemukan, kembalikan nilai -1 + +# Daftar Algoritma Searching +1. [Linear Search](./LinearSearch.java) From 760b51d58cdd3d5031f05744e55e37f21d5a6d98 Mon Sep 17 00:00:00 2001 From: Bhimantoro Suryo Admodjo Date: Sun, 12 Jun 2022 02:20:57 -0400 Subject: [PATCH 10/66] feat: Menambahkan binary search (#111) * fix: Memperbaharui kode program * add: Menambahkan algoritma dan dokumentasi baru * feat: Menambahkan binary search Co-authored-by: bhimsur --- .../datastructure/Search/BinarySearch.java | 28 +++++++++++++++++++ .../algorithm/datastructure/Search/README.md | 8 ++++++ 2 files changed, 36 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Search/BinarySearch.java diff --git a/src/main/java/algorithm/datastructure/Search/BinarySearch.java b/src/main/java/algorithm/datastructure/Search/BinarySearch.java new file mode 100644 index 0000000..04de18a --- /dev/null +++ b/src/main/java/algorithm/datastructure/Search/BinarySearch.java @@ -0,0 +1,28 @@ +package algorithm.datastructure.Search; + +public class BinarySearch { + int binarySearch(int[] array, int key) { + int l = 0; + int r = array.length - 1; + while (l <= r) { + int m = l + (r - l) / 2; + if (array[m] == key) { + return m; + } + if (array[m] < key) { + l = m + 1; + } else { + r = m - 1; + } + } + return -1; + } + + public static void main(String[] args) { + BinarySearch ob = new BinarySearch(); + int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100}; + int key = 40; + int result = ob.binarySearch(array, key); + System.out.println(key + " is in index : " + result); + } +} diff --git a/src/main/java/algorithm/datastructure/Search/README.md b/src/main/java/algorithm/datastructure/Search/README.md index 19bd9ae..33f56dc 100644 --- a/src/main/java/algorithm/datastructure/Search/README.md +++ b/src/main/java/algorithm/datastructure/Search/README.md @@ -6,5 +6,13 @@ _Linear Search_ adalah algoritma pencarian yang sangat sederhana. Dalam jenis pe - Jika elemen kunci ditemukan, kembalikan posisi indeks elemen _array_ - Jika elemen kunci tidak ditemukan, kembalikan nilai -1 +# Binary Search +_Binary Search_ digunakan untuk mencari elemen kunci dari beberapa elemen. Dalam kasus pencarian biner, elemen _array_ harus dalam urutan menaik. Jika Anda memiliki _array_ yang tidak disortir, Anda dapat mengurutkan _array_ menggunakan metode ```Arrays.sort(arr)```. +## Cara Kerja +- Bandingkan x dengan elemen tengah. +- Jika x cocok dengan elemen tengah, akan mengembalikan indeks tengah. +- Jika x lebih besar dari elemen tengah, maka x hanya dapat terletak di setengah _subarray_ kanan setelah elemen tengah. Jadi dilakukan perulangan untuk bagian kanan. +- Jika (x lebih kecil) dilakukan perulangan untuk bagian kiri. # Daftar Algoritma Searching 1. [Linear Search](./LinearSearch.java) +2. [Binary Search](./BinarySearch.java) From 0ae7746aee88d93218ba2b55846bd3bc0c04fb60 Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Mon, 1 Aug 2022 21:08:54 +0700 Subject: [PATCH 11/66] docs: Menutup Visitor Badge sementara karena hilang (#112) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 385ef06..cb9156c 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ ![Java Testing](https://img.shields.io/github/workflow/status/bellshade/Java/build%20java?style=for-the-badge) ![Code Quality](https://camo.githubusercontent.com/4886b1fdb05d416e7ba2339097fa8fe6da5613836b5f76f43fa80bfafcb993a1/68747470733a2f2f696d672e736869656c64732e696f2f6c67746d2f67726164652f707974686f6e2f6769746875622f62656c6c73686164652f507974686f6e416c676f726974686d3f6c6162656c3d436f64652532305175616c697479267374796c653d666f722d7468652d6261646765) ![Code Factor](https://camo.githubusercontent.com/1f727bfd32cd983731b2d87366e39a346f90d90037b3cca39d757e786fa40f9b/68747470733a2f2f696d672e736869656c64732e696f2f636f6465666163746f722f67726164652f6769746875622f62656c6c73686164652f507974686f6e2f6d61696e3f6c6162656c3d636f6465253230666163746f72267374796c653d666f722d7468652d6261646765) -![Visitor Badge](https://visitor-badges.glitch.me?username=bellshade&repo=Java&label=VISITOR&style=for-the-badge&color=%2344CC11&token=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&contentType=svg) + [![Discord](https://img.shields.io/discord/722002048643497994?logo=discord&logoColor=white&style=for-the-badge)](http://discord.gg/S4rrXQU) ![Java](https://raw.githubusercontent.com/github/explore/80688e429a7d4ef2fca1e82350fe8e3517d3494d/topics/java/java.png) From a495a086932810a101a19d454d0c90b8cc342648 Mon Sep 17 00:00:00 2001 From: "Deo Valiandro. M" Date: Wed, 17 Aug 2022 14:57:16 +0800 Subject: [PATCH 12/66] docs: fix alamat URL pada README.md oop_intermediate (#113) --- .../oop_intermediate/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/learn/intermediate/object_oriented_programming/oop_intermediate/README.md b/src/main/java/learn/intermediate/object_oriented_programming/oop_intermediate/README.md index cc415f7..0ca69d4 100644 --- a/src/main/java/learn/intermediate/object_oriented_programming/oop_intermediate/README.md +++ b/src/main/java/learn/intermediate/object_oriented_programming/oop_intermediate/README.md @@ -5,9 +5,9 @@ Selain itu, OOP sendiri adalah dalah suatu metode pemrograman yang berorientasi pada objek. Program-program yang telah ada merupakan gabungan dari beberapa komponen-komponen kecil yang sudah ada sebelumnya. Hal itu dapat mempermudah pekerjaan seorang programmer dalam melakukan pengembangan program. Objek-objek yang saling berkaitan dan disusun kedalam satu kelompok ini disebut dengan class. Nantinya, objek-objek tersebut akan saling berinteraksi untuk menyelesaikan masalah program yang rumit. Jika sebelumnya developer harus berfokus pada logic yang akan dimanipulasi, dengan OOP, developer dapat lebih terfokus pada objeknya saja untuk dimanipulasi. Pendekatan ini menawarkan cara yang mudah untuk menangani kerumitan suatu pemrograman. Tujuan utama OOP adalah untuk mengatasi kelemahan pendekatan pemrograman konvensional. ### Prinsip-Prinsip OOP -1. [Encasulaption *atau* Enkasulapsi](https://github.com/bellshade/Java/tree/main/learn/intermediate/object_oriented_programming/oop_intermediate/Encapsulation) -2. [Abstraction *atau* Abstraksi](https://github.com/bellshade/Java/tree/main/learn/intermediate/object_oriented_programming/oop_intermediate/Abstract) -3. [Inheritance](https://github.com/bellshade/Java/tree/main/learn/intermediate/object_oriented_programming/oop_intermediate/Inheritance) -4. [Polymorphism](https://github.com/bellshade/Java/tree/main/learn/intermediate/object_oriented_programming/oop_intermediate/Polymorphism) +1. [Encasulaption *atau* Enkasulapsi](https://github.com/bellshade/Java/tree/main/src/main/java/learn/intermediate/object_oriented_programming/oop_intermediate/Encapsulation) +2. [Abstraction *atau* Abstraksi](https://github.com/bellshade/Java/tree/main/src/main/java/learn/intermediate/object_oriented_programming/oop_intermediate/Abstract) +3. [Inheritance](https://github.com/bellshade/Java/tree/main/src/main/java/learn/intermediate/object_oriented_programming/oop_intermediate/Inheritance) +4. [Polymorphism](https://github.com/bellshade/Java/tree/main/src/main/java/learn/intermediate/object_oriented_programming/oop_intermediate/Polymorphism) Pada Repo ini, disengajakan untuk materi OOP ditaruh di bagian Intermediate, dikarenakan anda harus memahami terlebih dulu hal-hal dasar dalam mengikuti Pemrograman Berbasis Objek, kamu bisa memahami dan mempelajari terlebih dulu dasar-dasar OOP [disini](https://github.com/bellshade/Java/tree/main/learn/intermediate/object_oriented_programming/oop_basic), atau anda bisa memahami pembelajaran OOP secara melalui video [disini](https://www.youtube.com/playlist?list=PLZS-MHyEIRo6V4_vk1s1NcM2HoW5KFG7i) From ea9b79a976ff74047777c0411f4556b9f465e6b5 Mon Sep 17 00:00:00 2001 From: Malvin Valerian <78136971+malvinval@users.noreply.github.com> Date: Sun, 2 Oct 2022 10:58:31 +0700 Subject: [PATCH 13/66] add: penjelasan Java Currency (#114) --- .../utilities/JavaCurrency/JavaCurrency.java | 24 ++++ .../java/utilities/JavaCurrency/README.md | 107 ++++++++++++++++++ .../JavaCurrency/img/AllCurrencyMethods.png | Bin 0 -> 190950 bytes 3 files changed, 131 insertions(+) create mode 100644 src/main/java/utilities/JavaCurrency/JavaCurrency.java create mode 100644 src/main/java/utilities/JavaCurrency/README.md create mode 100644 src/main/java/utilities/JavaCurrency/img/AllCurrencyMethods.png diff --git a/src/main/java/utilities/JavaCurrency/JavaCurrency.java b/src/main/java/utilities/JavaCurrency/JavaCurrency.java new file mode 100644 index 0000000..b7dc57b --- /dev/null +++ b/src/main/java/utilities/JavaCurrency/JavaCurrency.java @@ -0,0 +1,24 @@ +package utilities.JavaCurrency; + +import java.util.Currency; + +public class JavaCurrency { + public static void main(String[] args) { + + // Menerima instance AUD dan JPY + Currency mataUang1 = Currency.getInstance("AUD"); // AUD + Currency mataUang2 = Currency.getInstance("JPY"); // JPY + + // Mengambil data kode mata uang + System.out.println(mataUang1.getCurrencyCode()); // AUD + System.out.println(mataUang2.getCurrencyCode()); // JPY + + // Mengambil data jumlah digit default mata uang + System.out.println("Digit AUD : " + mataUang1.getDefaultFractionDigits()); // Digit AUD : 2 + System.out.println("Digit JPY : " + mataUang2.getDefaultFractionDigits()); // Digit JPY : 0 + + // Mengambil data nama mata uang + System.out.println(mataUang1.getDisplayName()); // Australian Dollar + System.out.println(mataUang2.getDisplayName()); // Japanese Yen + } +} diff --git a/src/main/java/utilities/JavaCurrency/README.md b/src/main/java/utilities/JavaCurrency/README.md new file mode 100644 index 0000000..20e30d0 --- /dev/null +++ b/src/main/java/utilities/JavaCurrency/README.md @@ -0,0 +1,107 @@ +# Java Currency + +Didalam **JAVA** terdapat sebuah class yang bernama **_Currency_**. Class ini berguna untuk merepresentasikan informasi tentang mata uang yang diidentifikasi __ISO 4217__. Tujuan ISO 4217 adalah menetapkan kode yang diakui secara internasional untuk representasi mata uang. Mata uang dapat direpresentasikan dalam dua cara, yakni dengan tiga huruf kode alfabet dan tiga digit kode numerik. + +Method-method yang bisa dipakai dalam class ini antara lain : + +- ```getCurrencyCode()``` + mengembalikan nilai kode mata uang ISO 4217 berdasarkan argumen mata uang yang diinput. + +- ```getInstance()``` + mengembalikan instance mata uang berdasarkan argumen kode mata uang yang diinput. + +- ```getDefaultFractionDigits()``` + mengembalikan jumlah default digit pecahan mata uang berdasarkan argumen kode negara yang diinput. + +- ```getDisplayName()``` + mengembalikan nilai berupa nama mata uang berdasarkan argumen kode mata uang yang diinput. + +- ```getSymbol()``` + mengembalikan nilai berupa simbol mata uang berdasarkan argumen kode mata uang yang diinput. + +### Contoh penggunaan +[![](https://img.shields.io/static/v1?&label=Lihat%20source%20code&message=%3e&color)](JavaCurrency.java) + +Kita akan mengambil instance dari mata uang negara Australia dan Jepang dengan memanggil method ```getInstance()``` disertai kode alfabet mata uangnya sebagai argumen. + +```Java +Currency mataUang1 = Currency.getInstance("AUD"); // AUD +Currency mataUang2 = Currency.getInstance("JPY"); // JPY + +System.out.println(mataUang1.getCurrencyCode()); +System.out.println(mataUang2.getCurrencyCode()); +``` + +Maka outputnya adalah + +``` +AUD +JPY +``` + +Namun, jika argumen yang dikirim berupa kode alfabet mata uang yang tidak valid maka akan terjadi error. Misal : + +```Java +Currency mataUang3 = Currency.getInstance("USDA"); // Tidak valid + +System.out.println(mataUang3.getCurrencyCode()); +``` + +Maka outputnya adalah + +``` +Exception in thread "main" java.lang.IllegalArgumentException + at java.base/java.util.Currency.getInstance(Currency.java:321) + at java.base/java.util.Currency.getInstance(Currency.java:302) + at JavaCurrency.main(JavaCurrency.java:5) +``` + +Selanjutnya, kita akan coba mengambil data jumlah digit default dari kedua mata uang tersebut dengan menjalankan method ```getDefaultFractionDigits()```. + +```java +System.out.println("Digit AUD : " + mataUang1.getDefaultFractionDigits()); +System.out.println("Digit JPY : " + mataUang2.getDefaultFractionDigits()); +``` + +Maka outputnya adalah + +``` +Digit AUD : 2 +Digit JPY : 0 +``` + +Lalu, bagaimana cara mengambil data nama mata uang beserta simbolnya ? + +Untuk mengambil data nama mata uang, jalankan method ```getDisplayName()```. + +```java +System.out.println(mataUang1.getDisplayName()); +System.out.println(mataUang2.getDisplayName()); +``` + +Maka, outputnya adalah + +``` +Australian Dollar +Japanese Yen +``` + +Sedangkan untuk data simbol mata uang, bisa diambil dengan menjalankan method ```getSymbol()```. + +```java +System.out.println(mataUang1.getSymbol()); +System.out.println(mataUang2.getSymbol()); +``` + +Maka, outputnya adalah + +``` +A$ +? +``` + +### Apakah ada method lain yang bisa digunakan ? + +Ya, ada method-method lain yang bisa digunakan. + +![](img/AllCurrencyMethods.png) \ No newline at end of file diff --git a/src/main/java/utilities/JavaCurrency/img/AllCurrencyMethods.png b/src/main/java/utilities/JavaCurrency/img/AllCurrencyMethods.png new file mode 100644 index 0000000000000000000000000000000000000000..9560467062538ed4397a3ee4ab6057faa9c9672e GIT binary patch literal 190950 zcmc$G04VAJfaHRX`22*ai>mGU z3&T-H*98D@yZ?O<;+b$M0Du~hmH4RPnRc{dY4Boh5jfi&K0=f~ZM~rj33)-xaJ{O} znQ!C8)wF-L`eug?Y-S2!vr*u@UL`<5mU!_i@^V#I$32mmWA~{t0A1pbbL@~WOhjbu zV2RhzBxdKxSua=$)6M+pES=UdusUJN?Z4=i^4clSg3 zI*V^!^>p(l_ZW)!{%P!spXKip z|97(J+1WXEeek=>{8z*PfS>&^s7N*H(Wq+0SncO`J~Acrw%l*p8!7@~-{RFXOm4YR z<3j653Qr+FG`kd0XTcSRKGJ`u!DgDCnBrk?sQ0+Rhzv`?H_5)zra#YEJ1l=Cq`ipJ zu?JR2;aNm%$9f*gIK1|g2i5rXPkL5iUW;n5$J?(=p#te8Sq-pp!`JsG6E!=x=K!KK z+DB#na>Ky{b-?7knUS}x<}YC^M72bpI%pqkk`SG1d2 zq2vA@3z(8eL2*l?twRc-=-O*Cs&CQoW0gVmNNt%O%%aA;dS0I6>2;)arVM|l;O156 zn?tgxfTRTpvA~cP=3qDd&F4<9lFyAInelabTwDEIU3xNU(D-L{5w2bB`%~r1>IIBB zRF0+yz*e&Ks5TUGb9X`@4sXJ{y^#-=n3QDz0NYKz!AVhdd6y`!jwd5fyf!14xvc$D zSqRyk#E3p&76wjXDd)a~I~JbkcU*$0Z+6YL!QnYbN<^Z2?FdkO|NFm~r|9B{fX_%! zY@+#112gdzHDdEGu$i4_P;OB%bxD>|r)qJj@+vGk?QZR9|JvW}e2hUe>uoK1dOQDR z#)(Jef6WH+Y32($(zR z`3HP5vo}l${{9#A_8Gflb=y5uLUEp46~#q{2(Qg3ZUW9Pc1Fl7%Y+=^hwVx90=0)$ zUQT7*j-$;KR5vdxwSf4Yw0Wmn8?dBdjSgch6R+0iFUMANt-XcZ<(L$$BE2k!^)(_& zArGgx9|TBQZP!;*a6y_ASUBX%E)kPEB7pvwd4He2Am!`cCI55t#z7z>Mtg36j4v`& zx6K`9RYM^Oir312#qZAYwxYCNv6y5pS+^PWyOI&FuR*5Tr(2Z7;Nqj{iXSn9jJ7G= zgvko!7Lvg`xb_IK7Q>m_4zs?-dmJ^si%e8XrF@kFFdNm_a8Qzl`AW}|08FO8=qL-- z-A~m;YnV*w1PR#WJ^vH`NeloOOTw3KPe)`UUggCMi}*!Q+$?fVom}Ll=j}#O3B+b- zFOIWpewWf3MaWi99FBCHJs!Y!o0{2tz{~xdI9(_ALXe6514o0qqiZJbO`uL+Mxae~ z@zzw|n89eP(b8*GHc0T!wY{G@Nm=sF`xa|XE(VA*T;~UgX&yu`86tZKt=+ z{?hKgOpR4GGI)t!Vhp}_btio*HYYowXBkCO_+T$@jv~P0bMKw~{j{j1c&XS$z2st& zkVvcLdep#!00=1FI-{>R9!|8Ww`NpYe$ZVdrf>WqWb}8VHPg46xgq^diFoFP>@e8x7kY?rZgmV3W!c~?RL7!{mEnhut zc!3|99o{>>K*Z)iA`t89n3q%_e48<-^@1{rDYu z&ENBI>9%-vL9_UJ@%Oav+*EA!?9*Y>yQOSO4c*G!Z&+{RS9%m&WH&O#UMBhb)_2GP zK*tQd@5StmY+dncj_Y)y`D~)Op-i|DdFX|aBv{M%VMN@1uc| z@5#8}0G##r$i;d@y+9uy&{SM5pn|6@yV6SQ6<=(WT&Pbv8~a|Ie;`7n9-D{#@h&)= z5z=>5b4u4R&{pk4W|@$H9Y8KJ{r{?qJw^1UMJ61yB%rpgZL6mT`Hn)E9&Ye9iYYW- z0QSvN%ut{8673$l74nMG0siLgk(gP$Rl|LuqbaIEw^Nt31KQKJrCFCb70ul=*uf^t zlfMYjrvM)0=TNhEYLk>h?)F&FyYu!4!ZOD1)kZhGJzXRhN!Yq(t$K}N>9DF6U9+2- z9z>Xdn6oSFd-wHxRwcg0W9g2a59((($J6X1;yZ6BL$T?%s7;**e6Pb!fs2+F6mAc~ zRxB~?bvR(wx?MGGxJ!*z0Rfyd(`3`i-|Rt&u&6yRDO2R zHL>x@fswydhfFKC!W4@KH;Y}?j@CJ$-l7ZXNWl(!Y=2`CxEcRh+33MDZ zGhwIE#<=C~>l7^dsa+Op-ei{Sjz!54+&Civ@Ki$W_G3QPX32{eA*yR%>!SJ^_iHVV zVb(**jFMe>%*L5lcUHwq8`{E2zp5@)TERBJtoz@ew)DCLfYjVHLiP zO7d?GZ{>IyaPhlH5o1n|2v)4x{pI`-**Zo{2@_C@)zu5uZ;{L5&A3K(>o2&@jqT3Q zji}6fp^|^zI))fs9buD73#ii?G6x?LY8$OIJ9*pC&c!sIPIo#nEk8&#YrIWZ81p=+ z15^HLxH(iLJ#3yO+J#2?16^N42!pVnr?kU`MGMAk=ckL}QLtFYH*!X>0A`mqb z6E%zei1llNZr$abW5Wn%**&*in0f_%EpCal!THLnN)C>+mmYmHqCRYt8!OnVsGDGa zqx9Qff2U8tYFkqBZg9AN)eUH!ztpvWooe3dJxUPHBOysLtU& zJ?t{6QHIFQ)54S1hY|5XE=zwFiGp2M9(+PQi;|Gb9!(^ZBoFT#+7>fu^IC2v2Zr#1 z`_={t{{c+sjN>j_wfjU360RRu)9>jhBeRqv6>KuxH-^Dgtkeh=&|Gc$iSr7DS`7M@ zRaj^y20*@B7-X7tVA_7CO_8b6xVTbrY-5v=@4xcqAbB?-iWouk7ip2NkNjxBr*hv9 zQjr;`Z?yH*yQuHEjf_^Mkb%!QJRXhT7*7>ULDC2zvcoBTmY%jq0X<*2Tv*y6t>K%g zF=G}LltT5&TXMBe+AZg^!}`Lh0ecU~-t>JvPfjhRkUa77EzjbFK?I->Qk!MKHCBBJ z8JAdNg9n*^s>klQOwRsMkzrNPF{jDpXwv7XnHW>ThY6IfJQidc9?$^+Y}a9b=iC!l zXBIKK-+$5TE-!6#XKW_PoELP8L@9%$X$>F%hn&Kb7ds`Rdp|@Py}p*9cX$pLqnQ$} zis+3^l|N1oZ47W+{YVZ(&;CT?MKeXWKu1+>-|lLHHm8@HD>3A8@WSIyc4|WoPSH6z zJEkbI5tgwI|7aMX(_N~c;(Pw{4MY5{kxWrCJ9KqrsnN(--G{&q%Y)USZ?*bJDq2i| zUic1XW_E?qy;%3T&AT=dt*x$JO3D`}3pN>Kn-Z_Cn3D;1KPLkLXEy{~LNM^xq{-1z zEQYdJ3z?JOYlQp}I9~+3Pv*~K4y39S{+!1pdZ++EdD|`IJA~qfxl8w1<0X`uA zHCwrYEJBFVSqlA5I2$!!;X;+1>3-FRO>EchC0s}AlS0{r4**NVZI+h*jo6#Gid@VH1E` z)COi^EH9e~U$cDgE94Eq)S;kKHp{OKLThWSFaLJWIn85JOkG;jpnanuZhEk8J+h^- z`qLb#s4-uFy!L8KxG+jOo*D+w!8OZs1^^O$D;1V3g&ng~>X~u%P{W3H`?X=2 z)C*}FK22D1Zi?>3?N%)#7eD~%QE)t(+wRg4;JZRTEltls!nzVvDX+>8EjXYtrxun% z$QGb;&E%ij+)_q)jvBH+2if=G43j@`S4&|fMdh0efQs86RyK;H_VC z01374 z(2%ArdO?J!EKynoe!~NIF~+ZRk)*@6Uj&dvfzOWn3Oti-hz6QGG9OtCQGmyQH|P%} znf?jWsrlL~hKSoJiRCsgSwlK{dZJPGBFr&przZ%mS%pFYPhkAof2~y+6iKBxI?PmJ z{p+1)@r${w-qW$6LbEns;f>zPcZdyG2X5Hd!RI<8Tpl^d`8HSSJYeiO6P|i_xAyZy z;){74DWUFEDNW_ypF-2#7IeRH^~z-+*I9bqTkr1mrXd{>n&jUa57EU3)()}CZAmgL z!oS#IV|3~2vyTrWIc}p!h83ECfUL3}$*Y?}m{|Dn5!V29zWSX1U0nODqJv9X%BN(% zKlgSA=03iLNXiHSWM~r70u-2lmF51GfE=5xwcUUy3R-OmZ-W|WgAM@P>{KTVM=#I- zpx0}1xWhMSpS>K`$=ZIP=?F;BzhfWv>A-O20yk}-MCKz042Jz3ng*URU}cR-2<#U- zK8-7B$fy2VtD$Le96suN~eq4GxM8jr%_o_#!QJ0ig4; z<>TFYqFiZNIv3KhU;w10QiXs#7YCqbVt9YbLQ;BMMy7S6gvHWUl>bo?Apre}PU)O& z1~s6(IwnlOO62qK7v?&dpX= zv!h{wjJTfG_Ri(5M|=8i53!#V;tI-8?&{K_Xt997-##PZh$hT-rCi3r8NL%s$lKzO z6LDpde~C3%QaU~9rMrcU9%G5nDy-LEtla*t z3gtb6hEls}304IB3${;f?YqY6Ds9J)a}vS-X*fIuGg2LAP3)T2~ZzT z=IUd_%(si)<|OMPfz-pn3ztbEwI*Gv_7^!kr9y$K*NU_W>BRWpfz#_T2epR zyIU&lYD8~FijRNwJQcn*vJMjxmTKPX9qZNJlTk|Hy~-F+_qXLi4nqTWNPv_GuY2iw zhu&LFgQaJOearXJqPo+pId+Kwz_&ZC#5Y6S%CMvsvjVcmzDiSaHnP06Kv4gJic=M$ zIiLG%JldZ%lA9lduA;@tr8t=n7iZa&o z^-3dyQfrcDO$0!mFAm5116n1ux8oc_p_g_0-_% [![Discord](https://img.shields.io/discord/722002048643497994?logo=discord&logoColor=white&style=for-the-badge)](http://discord.gg/S4rrXQU) -![Java](https://raw.githubusercontent.com/github/explore/80688e429a7d4ef2fca1e82350fe8e3517d3494d/topics/java/java.png) +![Java](https://cdn.discordapp.com/attachments/921736002052161546/1031171653557821440/wp6599900-java-desktop-wallpapers.jpg) ## 🎉🎉 Selamat Datang di Java 🎉🎉 From d3b83bd645d2b2d702618b408b77c2d2fb5ed917 Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Sun, 16 Oct 2022 19:14:39 +0700 Subject: [PATCH 33/66] Dayan (#139) * docs: Memperbaharui Dokumentasi * fix: Memperbaiki Utilitas Repo --- .github/CODEOWNERS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 683f0c5..2706122 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -5,4 +5,4 @@ # the repo. Unless a later match takes precedence, # @global-owner1 and @global-owner2 will be requested for # review when someone opens a pull request. -* @random-prog @nomadkode @slowy07 @sautmanurung1 @bhimsur @fairusatoir +* @random-prog @slowy07 @sautmanurung1 @bhimsur @fairusatoir From 18178738f6076945ae42733e8ecdf9ad0b9e3cdb Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Sun, 16 Oct 2022 20:34:04 +0700 Subject: [PATCH 34/66] fix: Memperbaiki utilitas repo (#140) --- .github/pull_request_template.md | 6 +++--- .github/workflows/prettify.yml | 18 ------------------ 2 files changed, 3 insertions(+), 21 deletions(-) delete mode 100644 .github/workflows/prettify.yml diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 361b900..3a6072a 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -4,10 +4,10 @@ # Checklist: ##### Umum: -- [ ] Saya menambah algoritma terbaru. +- [ ] Saya menambahkan algoritma terbaru. - [ ] Saya memperbaiki algoritma yang sudah ada. -- [ ] Saya memperbaiki dokumentasi. -- [ ] Saya menambah dokumentasi. +- [ ] Saya menambahkan dokumentasi. +- [ ] Saya memperbaiki dokumentasi yang sudah ada. ##### Contributor Requirements (Syarat Kontributor) dan Lain-Lain: - [ ] Saya sudah membaca (I have read) [CONTRIBUTING](https://github.com/bellshade/Java/blob/main/CONTRIBUTING.md) dan sudah menyetujui semua syarat. diff --git a/.github/workflows/prettify.yml b/.github/workflows/prettify.yml deleted file mode 100644 index 90c4fc7..0000000 --- a/.github/workflows/prettify.yml +++ /dev/null @@ -1,18 +0,0 @@ -name: Prettier -on: [push] -jobs: - prettier: - runs-on: ubuntu-latest - steps: - - name: checkout file java - uses: actions/checkout@v2 - with: - ref: ${{ github.head_ref }} - - - name: reformat kode - uses: creyD/prettier_action@v3.3 - with: - prettier_option: --write **/*.java - commit_message: 'reformat kode java' - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} From ab4dcfdd89166e0a91b2ceb5cfc30e89d47ac89b Mon Sep 17 00:00:00 2001 From: Fairus Atoir <36189723+fairusatoir@users.noreply.github.com> Date: Mon, 17 Oct 2022 00:28:36 +0700 Subject: [PATCH 35/66] add: penjelasan generic bounded (#143) --- .../GenericClassBounded/AbstractEntity.java | 24 ++++++ .../GenericClassBounded/DataEntity.java | 37 +++++++++ .../GenericClassBounded/Jaket.java | 27 +++++++ .../MainGenericClassBounded.java | 15 ++++ .../JavaGeneric/GenericClassBounded/README.md | 75 +++++++++++++++++++ 5 files changed, 178 insertions(+) create mode 100644 src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/AbstractEntity.java create mode 100644 src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/DataEntity.java create mode 100644 src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/Jaket.java create mode 100644 src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/MainGenericClassBounded.java create mode 100644 src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/README.md diff --git a/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/AbstractEntity.java b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/AbstractEntity.java new file mode 100644 index 0000000..5c8caf7 --- /dev/null +++ b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/AbstractEntity.java @@ -0,0 +1,24 @@ +package learn.intermediate.JavaGeneric.GenericClassBounded; + +public abstract class AbstractEntity{ + + private ID id; + + private String note; + + public String getNote() { + return note; + } + + public void setNote(String note) { + this.note = note; + } + + public ID getId() { + return id; + } + + public void setId(ID id) { + this.id = id; + } +} diff --git a/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/DataEntity.java b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/DataEntity.java new file mode 100644 index 0000000..6e627b8 --- /dev/null +++ b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/DataEntity.java @@ -0,0 +1,37 @@ +package learn.intermediate.JavaGeneric.GenericClassBounded; + +/** + * Contoh class generic yang paramter type nya memiliki parent class + * hal ini membuat hanya class dari turunan class AbstractEntity yang bisa menggunakan + * class DataEntity + * + * @param paramter type entity + * @param paramter type id + */ +public class DataEntity, ID>{ + + private T data; + + public DataEntity(T jaket) { + + } + + public T getData() { + return data; + } + + public void setData(T data) { + this.data = data; + } + + /** + * Contoh memanggil method dari parent di child jika generic + * karena variabel `data` telah di assign T, maka `data` bisa memanggil method dari parent + * seperti konsep abstraksi pada umumnya + * + * @return getNote() + */ + public String getNoteChild(){ + return this.data.getNote(); + } +} diff --git a/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/Jaket.java b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/Jaket.java new file mode 100644 index 0000000..3794b2d --- /dev/null +++ b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/Jaket.java @@ -0,0 +1,27 @@ +package learn.intermediate.JavaGeneric.GenericClassBounded; + +/** + * harus memiliki parent AbstractEntity + * karena parameter type generic class yang digunakan juga memiliki parent AbstractEntity + */ +public class Jaket extends AbstractEntity{ + + private int panjangLengan; + private int panjang; + + public int getPanjangLengan() { + return panjangLengan; + } + + public void setPanjangLengan(int panjangLengan) { + this.panjangLengan = panjangLengan; + } + + public int getPanjang() { + return panjang; + } + + public void setPanjang(int panjang) { + this.panjang = panjang; + } +} diff --git a/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/MainGenericClassBounded.java b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/MainGenericClassBounded.java new file mode 100644 index 0000000..8a32d6f --- /dev/null +++ b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/MainGenericClassBounded.java @@ -0,0 +1,15 @@ +package learn.intermediate.JavaGeneric.GenericClassBounded; + +/** + * Generic Class Bounded + * + * Membatasi paramater type class generic, + * sehingga hanya dapat dimasukan oleh class yang memiliki parent yang sama + */ +public class MainGenericClassBounded { + public static void main(String[] args) { + + Jaket jaket = new Jaket(); + DataEntity pakaianSatu = new DataEntity(jaket); + } +} diff --git a/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/README.md b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/README.md new file mode 100644 index 0000000..0216aa3 --- /dev/null +++ b/src/main/java/learn/intermediate/JavaGeneric/GenericClassBounded/README.md @@ -0,0 +1,75 @@ +# Java Generic Bounded + +Saat ingin membatasi penggunaan _class generic_ dengan hanya bisa digunakan oleh +class yang terpilih. Dapat menggunakan cara _parameter type_ dari _class generic_ dijadikan +_child class_ dari sebuah _paretn class_. + +## Contoh Kode + +### Contoh class generic +```java +/** + * Contoh class generic yang paramter type nya memiliki parent class + * hal ini membuat hanya class dari turunan class AbstractEntity yang bisa menggunakan + * class DataEntity + * + * @param paramter type entity + * @param paramter type id + */ +public class DataEntity, ID>{ + + private T data; + + public DataEntity(T jaket) { + + } + + public T getData() { + return data; + } + + public void setData(T data) { + this.data = data; + } + + /** + * Contoh memanggil method dari parent di child jika generic + * karena variabel `data` telah di assign T, maka `data` bisa memanggil method dari parent + * seperti konsep abstraksi pada umumnya + * + * @return getNote() + */ + public String getNoteChild(){ + return this.data.getNote(); + } +} +``` +### Contoh class yang memiliki parent yang sama + +```java +/** + * harus memiliki parent AbstractEntity + * karena parameter type generic class yang digunakan juga memiliki parent AbstractEntity + */ +public class Jaket extends AbstractEntity{ + + private int panjangLengan; + private int panjang; + + public int getPanjangLengan() { + return panjangLengan; + } + + public void setPanjangLengan(int panjangLengan) { + this.panjangLengan = panjangLengan; + } + + public int getPanjang() { + return panjang; + } + + public void setPanjang(int panjang) { + this.panjang = panjang; + } +} +``` From b280876e9b3849c2c30c08e6c5dc69daabbb5be6 Mon Sep 17 00:00:00 2001 From: Feri Irawan <57158078+feri-irawan@users.noreply.github.com> Date: Mon, 17 Oct 2022 14:42:25 +0800 Subject: [PATCH 36/66] docs: mengganti base url visitor badge (#144) Mengganti base url untuk visitor badge karna url yang sebelumnya sudah tidak dapat diaktifkan. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 38daf99..eb9ae50 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ ![Java Testing](https://img.shields.io/github/workflow/status/bellshade/Java/build%20java?style=for-the-badge) ![Code Quality](https://camo.githubusercontent.com/4886b1fdb05d416e7ba2339097fa8fe6da5613836b5f76f43fa80bfafcb993a1/68747470733a2f2f696d672e736869656c64732e696f2f6c67746d2f67726164652f707974686f6e2f6769746875622f62656c6c73686164652f507974686f6e416c676f726974686d3f6c6162656c3d436f64652532305175616c697479267374796c653d666f722d7468652d6261646765) ![Code Factor](https://camo.githubusercontent.com/1f727bfd32cd983731b2d87366e39a346f90d90037b3cca39d757e786fa40f9b/68747470733a2f2f696d672e736869656c64732e696f2f636f6465666163746f722f67726164652f6769746875622f62656c6c73686164652f507974686f6e2f6d61696e3f6c6162656c3d636f6465253230666163746f72267374796c653d666f722d7468652d6261646765) - +![Visitor Badge](https://visitor-badge.feriirawann.repl.co?username=bellshade&repo=Java&label=VISITOR&style=for-the-badge&color=%2344CC11&token=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&contentType=svg) [![Discord](https://img.shields.io/discord/722002048643497994?logo=discord&logoColor=white&style=for-the-badge)](http://discord.gg/S4rrXQU) ![Java](https://cdn.discordapp.com/attachments/921736002052161546/1031171653557821440/wp6599900-java-desktop-wallpapers.jpg) From d7d09d548944c22625d7196967580bff03d1da05 Mon Sep 17 00:00:00 2001 From: Bhimantoro Suryo Admodjo Date: Tue, 18 Oct 2022 10:59:45 +0700 Subject: [PATCH 37/66] add: menambahkan java json (#145) Co-authored-by: bhimsur --- pom.xml | 92 ++++++++++--------- .../JavaJSON/JacksonObjectMapper.java | 44 +++++++++ .../learn/intermediate/JavaJSON/README.md | 29 ++++++ 3 files changed, 124 insertions(+), 41 deletions(-) create mode 100644 src/main/java/learn/intermediate/JavaJSON/JacksonObjectMapper.java create mode 100644 src/main/java/learn/intermediate/JavaJSON/README.md diff --git a/pom.xml b/pom.xml index d610f44..5a8d9d7 100644 --- a/pom.xml +++ b/pom.xml @@ -1,51 +1,61 @@ - - 4.0.0 + + 4.0.0 + bellshade + bellshade + 1.0-SNAPSHOT - bellshade - bellshade - 1.0-SNAPSHOT + bellshade + https://github.com/bellshade - bellshade - http://www.example.com + + UTF-8 + 18 + 18 + - - UTF-8 - 18 - 18 - + + + + org.junit + junit-bom + 5.8.2 + pom + import + + + - - - org.junit - junit-bom - 5.8.2 - pom - import - + + org.junit.jupiter + junit-jupiter + test + + + com.fasterxml.jackson.core + jackson-databind + 2.13.4.2 + + + org.projectlombok + lombok + 1.18.24 + - - - - org.junit.jupiter - junit-jupiter - test - - - - - - - maven-compiler-plugin - 3.8.1 - - - maven-surefire-plugin - 2.22.2 - - - + + + + maven-compiler-plugin + 3.8.1 + + + maven-surefire-plugin + 2.22.2 + + + diff --git a/src/main/java/learn/intermediate/JavaJSON/JacksonObjectMapper.java b/src/main/java/learn/intermediate/JavaJSON/JacksonObjectMapper.java new file mode 100644 index 0000000..2c6ce97 --- /dev/null +++ b/src/main/java/learn/intermediate/JavaJSON/JacksonObjectMapper.java @@ -0,0 +1,44 @@ +package learn.intermediate.JavaJSON; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import lombok.*; + +import java.util.List; +import java.util.Map; + +public class JacksonObjectMapper { + public static void main(String[] args) throws JsonProcessingException { + // Inisialisasi ObjectMapper + ObjectMapper objectMapper = new ObjectMapper(); + + // Konversi Obyek Person ke JSON + Person person = new Person("John", 25); + System.out.println("Obyek Person ke JSON => " + objectMapper.writeValueAsString(person)); + + // Membaca JSON ke Person Obyek + String personJson = "{\"name\":\"John Doe\",\"age\":30}"; + Person person2 = objectMapper.readValue(personJson, Person.class); + System.out.println("JSON ke Obyek Person => Name : " + person2.getName() + ", Age : " + person2.getAge()); + + // Membaca JSON ke Java Map + Map personMap = objectMapper.readValue(personJson, new TypeReference>() {}); + System.out.println("JSON ke Map => " + personMap); + + // Membaca JSON List ke Java List + String personJsonList = "[{\"name\":\"John\", \"age\": 25}, {\"name\":\"Jane\", \"age\":23}]"; + List personList = objectMapper.readValue(personJsonList, new TypeReference>() {}); + System.out.println(personList); + } + + @Getter + @Setter + @AllArgsConstructor + @NoArgsConstructor + @ToString + static class Person { + private String name; + private int age; + } +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/JavaJSON/README.md b/src/main/java/learn/intermediate/JavaJSON/README.md new file mode 100644 index 0000000..a834803 --- /dev/null +++ b/src/main/java/learn/intermediate/JavaJSON/README.md @@ -0,0 +1,29 @@ +# Java JSON + +Pada _package_ ini, akan membahas mengenai penanganan JSON pada Java, berfokus pada _library_ Jackson yang sangat populer digunakan. + +## Penambahan _Dependency_ pada file _pom.xml_ + +dimulai dengan menambahkan dependency kedalam file ```pom.xml``` + +```xml + + com.fasterxml.jackson.core + jackson-databind + 2.13.4.2 + +``` +untuk detail versi yang digunakan bisa merujuk pada [_maven central repository_](https://search.maven.org/artifact/com.fasterxml.jackson.core/jackson-databind) + + +## Penggunaan _ObjectMapper_ +penggunaan dapat dimulai dengan inisiasi obyek berikut + +```java +import com.fasterxml.jackson.databind.ObjectMapper; + +class Main { + ObjectMapper objectMapper = new ObjectMapper(); +} +``` +lalu untuk beberapa contoh penggunaan bisa dilihat pada [JacksonObjectMapper.java](JacksonObjectMapper.java) \ No newline at end of file From 626bdd7bc9463bc8611f10ade3ad47f13ae6193b Mon Sep 17 00:00:00 2001 From: Bhimantoro Suryo Admodjo Date: Sat, 22 Oct 2022 22:56:42 +0700 Subject: [PATCH 38/66] add: menambahkan java predicate (#146) * add: menambahkan java json * add: menambahkan java predicate Co-authored-by: bhimsur --- .../JavaPredicate/JavaPredicate.java | 62 +++++++++++++++++++ .../intermediate/JavaPredicate/README.md | 12 ++++ 2 files changed, 74 insertions(+) create mode 100644 src/main/java/learn/intermediate/JavaPredicate/JavaPredicate.java create mode 100644 src/main/java/learn/intermediate/JavaPredicate/README.md diff --git a/src/main/java/learn/intermediate/JavaPredicate/JavaPredicate.java b/src/main/java/learn/intermediate/JavaPredicate/JavaPredicate.java new file mode 100644 index 0000000..0dbeb36 --- /dev/null +++ b/src/main/java/learn/intermediate/JavaPredicate/JavaPredicate.java @@ -0,0 +1,62 @@ +package learn.intermediate.JavaPredicate; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Predicate; + +import static java.util.function.Predicate.not; + +public class JavaPredicate { + + /** + * method not dari {@link Predicate} + * mengembalikan hasil negasi dari predicate yang dibuat + * @param predicate Predicate interface + * @param list List + */ + static void notStartsWith(Predicate predicate, List list) { + System.out.println("Kota dengan awalan bukan huruf 'A'"); + for (int i = 0; i < list.size(); i++) { + T city = list.get(i); + + + if (not(predicate).test(city)) { + System.out.println(city); + } + } + } + + /** + * method test dari {@link Predicate} + * mengevaluasi predicate yang dibuat terhadap parameter yang digunakan + * @param predicate Predicate + * @param list List + */ + static void startsWith(Predicate predicate, List list) { + System.out.println("Kota dengan awalan huruf 'A'"); + for (int i = 0; i < list.size(); i++) { + T city = list.get(i); + if (predicate.test(city)) { + System.out.println(city); + } + } + } + + public static void main(String[] args) { + // membuat predicate untuk string dengan awalan 'A' + Predicate startsWithA = value -> value.startsWith("A"); + + // membuat list untuk nama kota + List cityList = new ArrayList<>(4) { + { + add("Ankara"); + add("Turkey"); + add("Turin"); + add("Paris"); + } + }; + + startsWith(startsWithA, cityList); + notStartsWith(startsWithA, cityList); + } +} diff --git a/src/main/java/learn/intermediate/JavaPredicate/README.md b/src/main/java/learn/intermediate/JavaPredicate/README.md new file mode 100644 index 0000000..4659809 --- /dev/null +++ b/src/main/java/learn/intermediate/JavaPredicate/README.md @@ -0,0 +1,12 @@ +# Java Predicate +Pada _package_ ini, akan membahas salah satu fungsi matematika yang sering digunakan pada Java. Dalam logika matematika, _Predicate_ adalah fungsi yang dapat menerima nilai dan mengembalikan nilai _boolean_. +Pada Java, _Predicate_ merupakan sebuah _functional interface_ dengan spesialisasi menerima masukan _generic_ dan mengembalikan nilai _boolean_. + +## Contoh Penggunaan _Predicate_ +```java +class Main { + Predicate evenNumber = value -> (value % 2 == 0) && (value > 1); + Predicate startsWithA = value -> value.startsWith("A"); +} +``` +Untuk contoh lengkap ada pada kode sumber [JavaPredicate.java](JavaPredicate.java) \ No newline at end of file From cd9516de91bbbd42e29ea0a362322e2d4b0e702f Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Thu, 26 Jan 2023 20:41:40 +0700 Subject: [PATCH 39/66] docs: Mematikan sementara Visitor Badge (#148) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index eb9ae50..75fa1f4 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ ![Java Testing](https://img.shields.io/github/workflow/status/bellshade/Java/build%20java?style=for-the-badge) ![Code Quality](https://camo.githubusercontent.com/4886b1fdb05d416e7ba2339097fa8fe6da5613836b5f76f43fa80bfafcb993a1/68747470733a2f2f696d672e736869656c64732e696f2f6c67746d2f67726164652f707974686f6e2f6769746875622f62656c6c73686164652f507974686f6e416c676f726974686d3f6c6162656c3d436f64652532305175616c697479267374796c653d666f722d7468652d6261646765) ![Code Factor](https://camo.githubusercontent.com/1f727bfd32cd983731b2d87366e39a346f90d90037b3cca39d757e786fa40f9b/68747470733a2f2f696d672e736869656c64732e696f2f636f6465666163746f722f67726164652f6769746875622f62656c6c73686164652f507974686f6e2f6d61696e3f6c6162656c3d636f6465253230666163746f72267374796c653d666f722d7468652d6261646765) -![Visitor Badge](https://visitor-badge.feriirawann.repl.co?username=bellshade&repo=Java&label=VISITOR&style=for-the-badge&color=%2344CC11&token=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&contentType=svg) + [![Discord](https://img.shields.io/discord/722002048643497994?logo=discord&logoColor=white&style=for-the-badge)](http://discord.gg/S4rrXQU) ![Java](https://cdn.discordapp.com/attachments/921736002052161546/1031171653557821440/wp6599900-java-desktop-wallpapers.jpg) From 9e5d2696aa444ac6bd5d0c3a393ccf32c0d53d59 Mon Sep 17 00:00:00 2001 From: socrazz <119017928+socrazz@users.noreply.github.com> Date: Tue, 31 Jan 2023 10:31:23 +0700 Subject: [PATCH 40/66] docs: memperbaiki documentasi (#149) * docs: memperbaiki documentasi * Update README.md --------- Co-authored-by: arfy slowy --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 75fa1f4..5c3ff59 100644 --- a/README.md +++ b/README.md @@ -2,13 +2,13 @@ ![Bellshade](https://github.com/bellshade/PHP/blob/main/assets/images/bellshade-inline.png) +![License](https://img.shields.io/github/license/bellshade/javaAlgorithm?style=for-the-badge) +![Code Factor](https://camo.githubusercontent.com/1f727bfd32cd983731b2d87366e39a346f90d90037b3cca39d757e786fa40f9b/68747470733a2f2f696d672e736869656c64732e696f2f636f6465666163746f722f67726164652f6769746875622f62656c6c73686164652f507974686f6e2f6d61696e3f6c6162656c3d636f6465253230666163746f72267374796c653d666f722d7468652d6261646765) + > Part of Bellshade project. Managed by [WPU Discord Community](http://discord.gg/S4rrXQU).
> WPU Community is the fastest growing software developer forum initiated by [Mr. Sandhika Galih](https://www.youtube.com/webprogrammingunpas). -![License](https://img.shields.io/github/license/bellshade/javaAlgorithm?style=for-the-badge) -![Java Testing](https://img.shields.io/github/workflow/status/bellshade/Java/build%20java?style=for-the-badge) -![Code Quality](https://camo.githubusercontent.com/4886b1fdb05d416e7ba2339097fa8fe6da5613836b5f76f43fa80bfafcb993a1/68747470733a2f2f696d672e736869656c64732e696f2f6c67746d2f67726164652f707974686f6e2f6769746875622f62656c6c73686164652f507974686f6e416c676f726974686d3f6c6162656c3d436f64652532305175616c697479267374796c653d666f722d7468652d6261646765) -![Code Factor](https://camo.githubusercontent.com/1f727bfd32cd983731b2d87366e39a346f90d90037b3cca39d757e786fa40f9b/68747470733a2f2f696d672e736869656c64732e696f2f636f6465666163746f722f67726164652f6769746875622f62656c6c73686164652f507974686f6e2f6d61696e3f6c6162656c3d636f6465253230666163746f72267374796c653d666f722d7468652d6261646765) + [![Discord](https://img.shields.io/discord/722002048643497994?logo=discord&logoColor=white&style=for-the-badge)](http://discord.gg/S4rrXQU) From 3d3e45a1120d19958b0f7d287bf04fbb5488a83a Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Thu, 2 Feb 2023 20:06:09 +0700 Subject: [PATCH 41/66] feat: menambahkan algoritma kombinasi permutasi backtracking (#150) * feat: menambahkan algoritma kombinasi permutasi backtracking Signed-off-by: slowy07 * fix: memperbaiki error pada line 41 Signed-off-by: slowy07 * fix: mencoba memperbaiki kesalahan pada kelas Signed-off-by: slowy07 * fix: memperbaiki error typo pada list ke Signed-off-by: slowy07 * fix: delete directory Signed-off-by: slowy07 --------- Signed-off-by: slowy07 --- .../algorithm/backtracking/Kombinasi.java | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 src/main/java/algorithm/backtracking/Kombinasi.java diff --git a/src/main/java/algorithm/backtracking/Kombinasi.java b/src/main/java/algorithm/backtracking/Kombinasi.java new file mode 100644 index 0000000..9f8fa22 --- /dev/null +++ b/src/main/java/algorithm/backtracking/Kombinasi.java @@ -0,0 +1,60 @@ +package algorithm.backtracking; + +import java.util.*; + +/** + * Menenumkan semua permutasi + * dari array yang diberika + */ +public class Kombinasi { + private static int length; + /** + * Temukan semua kombinasi array yang + * diberikan menggunakan backtracking + * @param arr array + * @param n panjang dari kombinasi + * @param jenis elemen dalam array + * @return daftar semua kombinasi panjang n. Jika n == 0, kembalikan 0 + */ + public static List> combination(T[] arr, int n) { + if (n == 0) { + return null; + } + length = 0; + T[] array = arr.clone(); + Arrays.sort(array); + List> result = new LinkedList<>(); + backtracking(array, 0, new TreeSet(), result); + return result; + } + + /** + * backtrack semua kemungkinan kombinasi dari larik + * yang diberikan + * @param arr array + * @param index indeks + * @param currSet atur yang melacak kombinasi saat ini + * @param result daftar berisi semua kombinasi + * @param jenis elemen dalam array + */ + private static void backtracking( + T[] arr, + int index, + TreeSet currSet, + List> result + ) { + if (index + length - currSet.size() > arr.length) return; + if (length - 1 == currSet.size()) { + for (int i = index; i < arr.length; i++) { + currSet.add(arr[i]); + result.add((TreeSet) currSet.clone()); + currSet.remove(arr[i]); + } + } + for (int i = index; i < arr.length; i++) { + currSet.add(arr[i]); + backtracking(arr, i + 1, currSet, result); + currSet.remove(arr[i]); + } + } +} From 00526788c6f3f5cc3c4ca74fbc5ab915cc293422 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Sat, 11 Feb 2023 07:53:20 +0700 Subject: [PATCH 42/66] feat: menambahkan algoritma queue prioritas (#151) * feat: menambahkan algoritma queue prioritas Signed-off-by: slowy07 * fix: menghapus file permutasi * fix: memperbaiki titik koma pada fungsi ``throw`` * fix: memperbaiki identifier * fix: memperbaiki cannot find symbol java.lang.String --------- Signed-off-by: slowy07 --- .../Queue/SourceCode/PriorityQueue.java | 137 ++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Queue/SourceCode/PriorityQueue.java diff --git a/src/main/java/algorithm/datastructure/Queue/SourceCode/PriorityQueue.java b/src/main/java/algorithm/datastructure/Queue/SourceCode/PriorityQueue.java new file mode 100644 index 0000000..4fcb8bd --- /dev/null +++ b/src/main/java/algorithm/datastructure/Queue/SourceCode/PriorityQueue.java @@ -0,0 +1,137 @@ +package algorithm.datastructure.Queue.SourceCode; + +/** + * priority queue menambahkan elemen ke posisi + * berdasarkan prioritasnya. + * sehigga elemen terpenting ditempatkan di atas. + * dalam contoh ini + * diberikan angka yang lebih besar, prioritas + * lebih tinggi. antrian dalam teori ini adalah tidak ada + * ukuran tetap tetapi kita menggunakan implementasi array + * benar + */ +class PriorityQueue { + private int maxSize; + private int[] queueArray; + private int nItems; + + public PriorityQueue() { + /* jika kapasitas tidak ditentukan, ukuran standar 11 + * akan diguankan + * capacity = max + 1 + * karena kita tidak dapat mengakses elemen ke-0 dari PQ, + * dan ke + * mengakomodir (maks) elemen yang diperlukan kapasitas + * menjadi maks+1 + * induk di posisi k, anak di posisi (k*2, k*2+1),jika + * kita gunakan posisi 0 dalam antrian kita,anaknya akan + * berada di = *(0*2,0*2 + 1) ->(0,0). + * inilah mengapa kita mulai dari posisi 1 + */ + int size = 11; + maxSize = size + 1; + queueArray = new int[maxSize]; + nItems = 0; + } + + /** + * konstruktor dari parmater + * @param size + */ + public PriorityQueue(int size) { + maxSize = size + 1; + queueArray = new int[maxSize]; + nItems = 0; + } + + /* + * fungsi pembantu untuk implementasi PQ max-heap + * fungsi akan membantu menurunkan simpul + * induk ke yang benar + */ + private void swim(int pos) { + while (pos > 1 && (queueArray[pos / 2] < queueArray[pos])) { + int temp = queueArray[pos]; + queueArray[pos] = queueArray[pos / 2]; + queueArray[pos / 2] = temp; + pos = pos / 2; + } + } + + /** + * fungsi pembantu untuk implementasi PQ max-heap + * fungsi akan membantu menurunkan simpul induk + * ke posisi yang benar + */ + private void sink(int pos) { + // periksa apakah posisi simpul adalah simpul induk + while (2 * pos <= nItems) { + int current = 2 * pos; + // lompat ke posisi simpul anak + // bandingkan kedua anaknya dengan anaknya dengan + // yang lebih besar + if (current < nItems && queueArray[current] < queueArray[current + 1]) current++; + // jika node induk lebih besar, operasi sink selesai + // maka kita putuskan lingkarannya + if (queueArray[pos] >= queueArray[current]) break; + // jika tidak menukar + int temp = queueArray[pos]; + queueArray[pos] = queueArray[current]; + queueArray[current] = temp; + pos = current; + // tukarkan posisi induk ke posisi child dalam larik + } + } + + public void insert(int value) { + if (isFull()) { + throw new RuntimeException("queue is penuh"); + } else { + queueArray[++nItems] = value; + swim(nItems); + } + } + + public int remove() { + if (isEmpty()) { + throw new RuntimeException("queue kososng"); + } else { + int max = queueArray[1]; + + // swap max adn last element + int temp = queueArray[1]; + queueArray[1] = queueArray[nItems]; + queueArray[nItems] = temp; + queueArray[nItems--] = 0; + sink(1); + + return max; + } + } + + /** + * memeriksa apayang ada di depan + * antrian + */ + public int peek() { + return queueArray[1]; + } + + /** + * return true jika queue kosong + */ + public boolean isEmpty() { + return (nItems == 0); + } + + /** + * return true jika queue full + */ + public boolean isFull() { + return (nItems == maxSize - 1); + } + + public int getSize() { + return nItems; + } +} From 868e135f9e115964f797e617131e12ebc62a517f Mon Sep 17 00:00:00 2001 From: slowy07 Date: Sun, 12 Feb 2023 19:53:27 +0700 Subject: [PATCH 43/66] feat: menambahkan generic array list queue Signed-off-by: slowy07 --- .../SourceCode/GenericArrayListQueue.java | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Queue/SourceCode/GenericArrayListQueue.java diff --git a/src/main/java/algorithm/datastructure/Queue/SourceCode/GenericArrayListQueue.java b/src/main/java/algorithm/datastructure/Queue/SourceCode/GenericArrayListQueue.java new file mode 100644 index 0000000..7e24d57 --- /dev/null +++ b/src/main/java/algorithm/datastructure/Queue/SourceCode/GenericArrayListQueue.java @@ -0,0 +1,62 @@ +package algorithm.datastructure.Queue.SourceCode; + +import java.util.ArrayList; + +/** + * struktur data GenericArrayListQueue berfungsi sama + * seperti yang lain, antrian yang dibuat khusus + * GenericArrayListQueue menyimpan elemen bertipe + * yang akan ditentukan oleh runtime. elemen yang + * ditambahkan pertama adalah yang pertama + * untuk dihapus (menggunakan FIFO). elemen baru + * ditambahkan ke belakang antrian + */ +public class GenericArrayListQueue { + // array list generik untuk antrian T adalah + // elemen generik + ArrayList _queue = new ArrayList<>(); + + /* + * cek jika queue memiliki elemen (tidak kosong) + */ + private boolean hasElements() { + return !_queue.isEmpty(); + } + + /** + * memeriksa apakah ada di depan antrian + */ + public T peek() { + T result = null; + if (this.hasElements()) { + result = _queue.get(0); + } + return result; + } + + /** + * menyisipkan elemen tipe T ke antrian + */ + public boolean add(T element) { + return _queue.add(element); + } + + /** + * ambil apa yang ada di depan antrian + */ + public T pull() { + T result = null; + if (this.hasElements()) { + result = _queue.remove(0); + } + return result; + } + + public static void main(String[] args) { + GenericArrayListQueue queue = new GenericArrayListQueue<>(); + assert queue.peek() == null; + assert queue.pull() == null; + assert queue.add(1); + assert queue.peek() == 1; + } +} From 3659106c1662207ecc61c556f0b20ecbddf0197a Mon Sep 17 00:00:00 2001 From: Fandi Hasnur Date: Mon, 13 Feb 2023 10:51:38 +0800 Subject: [PATCH 44/66] feat: menambahkan materi exception (#152) * feat: menambahkan materi exception * feat: exclude bin * feat: menghapus bin --- .gitignore | 1 + .../java/learn/basic/Exception/Exception.java | 23 +++++++++++++++++++ src/main/java/learn/basic/Exception/README.md | 21 +++++++++++++++++ 3 files changed, 45 insertions(+) create mode 100644 src/main/java/learn/basic/Exception/Exception.java create mode 100644 src/main/java/learn/basic/Exception/README.md diff --git a/.gitignore b/.gitignore index 531355d..55114ae 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ *.log *.sh out/ +bin/ ### Maven ### target/ diff --git a/src/main/java/learn/basic/Exception/Exception.java b/src/main/java/learn/basic/Exception/Exception.java new file mode 100644 index 0000000..f405f53 --- /dev/null +++ b/src/main/java/learn/basic/Exception/Exception.java @@ -0,0 +1,23 @@ +package learn.basic.Exception; + +import java.io.File; +import java.io.FileNotFoundException; +import java.util.Scanner; + +public class Exception { + public static void main(String[] args) { + // Membuka file dan membacanya baris demi baris + try { + Scanner input = new Scanner(new File("file.txt")); + while(input.hasNextLine()) { + System.out.println(input.nextLine()); + } + // Jika file tidak ditemukan + } catch (FileNotFoundException e) { + System.out.println("File tidak ditemukan."); + // Program selesai + } finally { + System.out.println("Program selesai."); + } + } +} \ No newline at end of file diff --git a/src/main/java/learn/basic/Exception/README.md b/src/main/java/learn/basic/Exception/README.md new file mode 100644 index 0000000..5fd2117 --- /dev/null +++ b/src/main/java/learn/basic/Exception/README.md @@ -0,0 +1,21 @@ +# Exception Handling Java + +**Exception** handling adalah mekanisme yang digunakan pada Java untuk +menangani kegagalan yang mungkin terjadi selama eksekusi program. +Dalam Java, kegagalan dapat terjadi karena berbagai hal, seperti file +yang tidak ditemukan, variabel yang tidak diinisialisasi, atau kesalahan +penulisan kode. + +**Exception** handling memungkinkan kita untuk mengatasi kegagalan dengan +cara menangkap exception yang terjadi dan melakukan tindakan yangg sesuai. +Ini memastikan bahwa program tetap berjalan dengan baik meskipun terjadi +kegagalan. + +Untuk menangani exception pada Java, kita dapat menggunakan blok +`try-catch-finally`. Blok `try` berisi kode yang mungkin menimbulkan +exception. Blok `catch` berisi kode yang akan dieksekusi jika exception +terjadi. Blok `finally` berisi kode yang akan dieksekusi setelah blok +`try` dan `catch` selesai dieksekusi, tidak peduli apakah exception +terjadi atau tidak. + + From 07fdbf736450f0e67765c5f385726441f44ef6eb Mon Sep 17 00:00:00 2001 From: Fandi Hasnur Date: Sun, 5 Mar 2023 22:30:16 +0800 Subject: [PATCH 45/66] feat: menambahkan datetime (#155) --- .../basic/DateTime/Instant/InstantExample.java | 11 +++++++++++ .../basic/DateTime/LocalDate/LocalDateExample.java | 12 ++++++++++++ .../LocalDateTime/LocalDateTimeExample.java | 12 ++++++++++++ src/main/java/learn/basic/DateTime/README.md | 13 +++++++++++++ .../ZonedDateTime/ZonedDateTimeExample.java | 14 ++++++++++++++ 5 files changed, 62 insertions(+) create mode 100644 src/main/java/learn/basic/DateTime/Instant/InstantExample.java create mode 100644 src/main/java/learn/basic/DateTime/LocalDate/LocalDateExample.java create mode 100644 src/main/java/learn/basic/DateTime/LocalDateTime/LocalDateTimeExample.java create mode 100644 src/main/java/learn/basic/DateTime/README.md create mode 100644 src/main/java/learn/basic/DateTime/ZonedDateTime/ZonedDateTimeExample.java diff --git a/src/main/java/learn/basic/DateTime/Instant/InstantExample.java b/src/main/java/learn/basic/DateTime/Instant/InstantExample.java new file mode 100644 index 0000000..fa7a626 --- /dev/null +++ b/src/main/java/learn/basic/DateTime/Instant/InstantExample.java @@ -0,0 +1,11 @@ +package learn.basic.DateTime.Instant; + +import java.time.Instant; + +public class InstantExample { + public static void main(String[] args) { + + Instant currentTimestamp = Instant.now(); + System.out.println("Timestamp saat ini: " + currentTimestamp); + } +} diff --git a/src/main/java/learn/basic/DateTime/LocalDate/LocalDateExample.java b/src/main/java/learn/basic/DateTime/LocalDate/LocalDateExample.java new file mode 100644 index 0000000..31eb1c3 --- /dev/null +++ b/src/main/java/learn/basic/DateTime/LocalDate/LocalDateExample.java @@ -0,0 +1,12 @@ +package learn.basic.DateTime.LocalDate; + +import java.time.LocalDate; + +public class LocalDateExample { + public static void main(String[] args) { + + LocalDate currentDate = LocalDate.now(); + System.out.println("Tanggal saat ini: " + currentDate); + + } +} \ No newline at end of file diff --git a/src/main/java/learn/basic/DateTime/LocalDateTime/LocalDateTimeExample.java b/src/main/java/learn/basic/DateTime/LocalDateTime/LocalDateTimeExample.java new file mode 100644 index 0000000..562d3bd --- /dev/null +++ b/src/main/java/learn/basic/DateTime/LocalDateTime/LocalDateTimeExample.java @@ -0,0 +1,12 @@ +package learn.basic.DateTime.LocalDateTime; + +import java.time.LocalDateTime; + +public class LocalDateTimeExample { + public static void main(String[] args) { + + LocalDateTime currentDateTime = LocalDateTime.now(); + System.out.println("Waktu saat ini: " + currentDateTime); + + } +} diff --git a/src/main/java/learn/basic/DateTime/README.md b/src/main/java/learn/basic/DateTime/README.md new file mode 100644 index 0000000..6ead600 --- /dev/null +++ b/src/main/java/learn/basic/DateTime/README.md @@ -0,0 +1,13 @@ +# DateTime Java + +Jenis-jenis **DateTime** yang sering digunakan tergantung pada kebutuhan aplikasi. Namun, beberapa jenis **DateTime** yang paling sering digunakan adalah: + +1. `java.time.LocalDate`: Jenis ini digunakan untuk merepresentasikan **tanggal tanpa waktu** atau **zona waktu**. Misalnya, ketika Anda hanya perlu menyimpan tanggal dalam sebuah aplikasi atau saat menghitung selisih antara dua tanggal. + +2. `java.time.LocalDateTime`: Jenis ini digunakan untuk merepresentasikan **kombinasi tanggal** dan **waktu tanpa zona waktu**. Misalnya, ketika Anda perlu menghitung durasi antara dua waktu dalam satu zona waktu. + +3. `java.time.ZonedDateTime`: Jenis ini digunakan untuk merepresentasikan **tanggal, waktu,** dan **zona waktu**. Misalnya, ketika Anda perlu menampilkan waktu dalam zona waktu tertentu atau menghitung selisih waktu antara dua zona waktu yang berbeda. + +4. `java.time.Instant`: Jenis ini digunakan untuk merepresentasikan **titik waktu dalam format timestamp UTC**. Misalnya, ketika Anda perlu melakukan perhitungan waktu yang sangat akurat atau ketika Anda bekerja dengan data historis. + +Sementara itu, jenis DateTime seperti ` java.util.Date` dan `java.sql.Timestamp` masih digunakan di beberapa aplikasi lama atau dalam beberapa _framework legacy_. Namun, untuk aplikasi modern yang baru dikembangkan, lebih disarankan untuk menggunakan jenis-jenis **DateTime** yang lebih modern dan lebih aman seperti `java.time.LocalDateTime` atau `java.time.ZonedDateTime`. diff --git a/src/main/java/learn/basic/DateTime/ZonedDateTime/ZonedDateTimeExample.java b/src/main/java/learn/basic/DateTime/ZonedDateTime/ZonedDateTimeExample.java new file mode 100644 index 0000000..51c9403 --- /dev/null +++ b/src/main/java/learn/basic/DateTime/ZonedDateTime/ZonedDateTimeExample.java @@ -0,0 +1,14 @@ +package learn.basic.DateTime.ZonedDateTime; + +import java.time.ZoneId; +import java.time.ZonedDateTime; + +public class ZonedDateTimeExample { + public static void main(String[] args) { + + ZoneId timeZone = ZoneId.of("Asia/Jakarta"); + ZonedDateTime currentDateTimeWithZone = ZonedDateTime.now(timeZone); + System.out.println("Waktu saat ini di Jakarta: " + currentDateTimeWithZone); + + } +} From 49198f570cd4c1cf1228f0f86d1f4729752e6ce2 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Thu, 9 Mar 2023 22:15:01 +0700 Subject: [PATCH 46/66] feat: menambahkan docker container (#156) Signed-off-by: slowy07 --- .devcontainer/Dockerfile | 39 +++++++++++++++++++++++++++ .devcontainer/devcontainer.json | 47 +++++++++++++++++++++++++++++++++ 2 files changed, 86 insertions(+) create mode 100644 .devcontainer/Dockerfile create mode 100644 .devcontainer/devcontainer.json diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000..5f3f540 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,39 @@ +# contoh container docker yang bisa digunakan pada proyek +# bellshade java +# informasi lebih lanjut tentang cara penggunaannya +# bisa cek disini: +# https://github.com/microsoft/vscode-dev-containers/tree/v0.238.0/containers/java/.devcontainer/base.Dockerfile + +# versi java +ARG VARIANT="17-bullseye" +FROM mcr.microsoft.com/vscode/devcontainer/java:-0{VARIANT} + +# install maven +# maven adalah sebuah manajement object model atau POM +# (project object model) manfaat dari maven adalah +# - pembaruan repositori proyek jadi lebih mudah +# - kita bisa mengintegrasikan proyek yang dikerjakan +# juga jadi lebih mudah +ARG INSTALL_MAVEN="false" +ARG MAVEN_VERSION="" + +# install gradle +# gradle adalah sebuah program yang berfungsi untuk melakukan +# build secara otomatis +# tujuan menginstall gradle jika terdapat banyak file java +# dan library yang dipakai kita bisa mengcompilenya dengan +# mudah. disini kita mencoba dengan menggunakan SDKman +ARG INSTALL_GRADLE="false" +ARG GRADLE_VERSION="" +RUN if ["${INSTALL_MAVEN}" = "true"]; then su vscode -c "umask 0002 && ./usr/local/sdkman/bin/sdkman/sdkman-init.sh && sdk install maven \"${MAVEN_VERSION}\""; fi \ + && if ["${INSTAL_GRADLE}" = "true"]; then su vscode -c "umask 0002 && . /usr/local/sdkman/bin/sdkman-init.sh && sdk install gradle \"${GRADLE_VERSION}\""; + +# install node +ARG NODE_VERSION="none" +RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi + +# jika ingin menginstall paket tambahan pada OS +#RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \ +# && apt-get -y install --no-install-recommends + + diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000..3994bec --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,47 @@ +// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at: +// https://github.com/microsoft/vscode-dev-containers/tree/v0.238.0/containers/java +{ + "name": "Java", + "build": { + "dockerfile": "Dockerfile", + "args": { + // Update the VARIANT arg to pick a Java version: 11, 17 + // Append -bullseye or -buster to pin to an OS version. + // Use the -bullseye variants on local arm64/Apple Silicon. + "VARIANT": "17-bullseye", + // Options + "INSTALL_MAVEN": "true", + "INSTALL_GRADLE": "true", + "NODE_VERSION": "lts/*" + } + }, + + // Configure tool-specific properties. + "customizations": { + // Configure properties specific to VS Code. + "vscode": { + // Set *default* container specific settings.json values on container create. + "settings": { + }, + + // Add the IDs of extensions you want installed when the container is created. + "extensions": [ + "vscjava.vscode-java-pack", + "GitHub.copilot", + ] + } + }, + + // Use 'forwardPorts' to make a list of ports inside the container available locally. + // "forwardPorts": [], + + // Use 'postCreateCommand' to run commands after the container is created. + "postCreateCommand": "java -version", + + // Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root. + "remoteUser": "vscode", + "features": { + "git": "os-provided", + "github-cli": "latest" + } +} From d176ff0fa67b3b91808702be4f158317b74b33a8 Mon Sep 17 00:00:00 2001 From: Muhammad Dean Fahreza Date: Fri, 10 Mar 2023 01:39:06 +0700 Subject: [PATCH 47/66] add: Menambahkana Catatan dalam Dependencies (#157) --- .devcontainer/README.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .devcontainer/README.md diff --git a/.devcontainer/README.md b/.devcontainer/README.md new file mode 100644 index 0000000..3a6fc3e --- /dev/null +++ b/.devcontainer/README.md @@ -0,0 +1,2 @@ +# NOTE : +Ini adalah dependencies yang dijalankan menggunakan teknologi `Docker`. Docker merupakan salah satu tools DevOps yang sering digunakan untuk standarisasi kode yang digunakan. Untuk mengetahui apa itu Docker, kalian bisa langsung mengunjungi link Docker [disini](https://www.docker.com/)! From 62c13f7fab810a3eaa4461acbd380d4b37f59ea2 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Sat, 11 Mar 2023 18:09:13 +0700 Subject: [PATCH 48/66] add: menambahkan binarySearch (#158) chore: modifikasi gitignore Signed-off-by: slowy07 --- .gitignore | 2 + .../Tree/BinaryTree/BinaryTree.java | 272 ++++++++++++++++++ 2 files changed, 274 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Tree/BinaryTree/BinaryTree.java diff --git a/.gitignore b/.gitignore index 55114ae..bd4ef7d 100644 --- a/.gitignore +++ b/.gitignore @@ -28,3 +28,5 @@ build/ !**/src/main/**/build/ !**/src/test/**/build +.setting + diff --git a/src/main/java/algorithm/datastructure/Tree/BinaryTree/BinaryTree.java b/src/main/java/algorithm/datastructure/Tree/BinaryTree/BinaryTree.java new file mode 100644 index 0000000..f3c36c9 --- /dev/null +++ b/src/main/java/algorithm/datastructure/Tree/BinaryTree/BinaryTree.java @@ -0,0 +1,272 @@ +package algorithm.datastructure.Tree.BinaryTree; + +import java.util.LinkedList; +import java.util.Queue; + +/** + * seluruh file kelas ini digunakan untuk membangun + * struktur data Binary Tree. ada kelas node dan kelas + * pohon, keduanya akan dijelaskan tiap komentar + */ +public class BinaryTree { + /** + * kelas ini mengimplementasikan node yang akan + * mengarah ke binary tree. mereka terdiri dari data + * di dalamnya, node ke kiri, node ke kanan, dan + * parent dari mana sumber node berasal + */ + static class Node { + // data untuk node + public int data; + // node di sebelah kiri + public Node kiri; + // node di sebelah kanan + public Node kanan; + // parent dari node ini + public Node parent; + + /** + * konstruktor of node + * + * @param nilai untuk dimasukkan ke dalam node + */ + public Node(int value) { + data = value; + kiri = null; + kanan = null; + parent = null; + } + } + + // root dari binary tree + private Node root; + + // konstruktor + public BinaryTree() { root = null; } + + // parameter kontruktor + public BinaryTree(Node root) { this.root = root; } + + /** + * metode untuk menentukan node dengan nilai tertentu + * + * @param key nilai yang sedang dicari + */ + public Node cari(int key) { + Node sekarang = root; + while (sekarang != null) { + if (key < sekarang.data) { + if (sekarang.kiri == null) { + return sekarang; + } + sekarang = sekarang.kiri; + } else if (key > sekarang.data) { + if (sekarang.kanan == null) { + return sekarang; + } + sekarang = sekarang.kanan; + } else { + return sekarang; + } + } + return null; + } + + /** + * memasukkan nilai tertentu ke dalam pohon biner + * + * @param value value yang akan dimasukkan + */ + public void put(int value) { + Node nodeBaru = new Node(value); + if (root == null) { + root = nodeBaru; + } else { + /** + * ini akan mengembalikan segera menjadi induk + * dari nilai yang dimasukkan + */ + Node parent = cari(value); + + if (value < parent.data) { + parent.kiri = nodeBaru; + parent.kanan.parent = parent; + return; + } else { + parent.kanan = nodeBaru; + parent.kanan.parent = parent; + return; + } + } + } + + /** + * menghapus nilai tertentu dari + * binary tree + * + * @param value value untuk dihapus * + */ + public boolean remove(int value) { + Node temp = cari(value); + + // jika value yang dicari tidak ada + if (temp.data != value) { + return false; + } + + if (temp.kanan == null && temp.kiri == null) { + if (temp == root) { + root = null; + } else if (temp.parent.data < temp.data) { + temp.parent.kanan = null; + } else { + temp.parent.kiri = null; + } + return true; + } else if (temp.kiri != null && temp.kanan != null) { + Node sucessor = cariSuccessor(temp); + + // pohon temp yang kiri dijadikan penerus node kiri + sucessor.kiri = temp.kiri; + sucessor.kiri.parent = sucessor; + + // jika successor memiliki child node, maka + // sucessor utama adadalah parent utama + if (sucessor.parent != temp) { + if (sucessor.kanan != temp) { + sucessor.kanan.parent = sucessor.parent; + sucessor.kanan.parent = sucessor.kanan; + sucessor.kanan = temp.kanan; + sucessor.kanan.parent = sucessor; + } else { + sucessor.parent.kiri = null; + sucessor.kanan = temp.kanan; + sucessor.kanan.parent = sucessor; + } + } + if (temp == root) { + sucessor.parent = null; + root = sucessor; + return true; + } else { + // jika tidak mendelete root node + sucessor.parent = temp.parent; + if (temp.parent.data < temp.data) { + temp.parent.kanan = sucessor; + } else { + temp.parent.kiri = sucessor; + } + return true; + } + } else { + // jika memeiliki node child pada sebelah kanan + if (temp.kanan != null) { + if (temp == root) { + root = temp.kanan; + return true; + } + temp.kanan.parent = temp.parent; + + // definisikan temp ke kiri atau ke child yang kanan + if (temp.data < temp.parent.data) { + temp.parent.kiri = temp.kanan; + } else { + temp.parent.kanan = temp.kanan; + } + return true; + } else { + // jika tedapat child node di bagian kiri + if (temp == root) { + root = temp.kiri; + return true; + } + temp.kiri.parent = temp.parent; + + // definisikan temp ke kiri atau ke kanan + if (temp.data < temp.parent.data) { + temp.parent.kiri = temp.kiri; + } else { + temp.parent.kanan = temp.kiri; + } + return true; + } + } + } + + /** + * metode ini menemukan penerus node yang diberikan + * bergerak ke kanan + * meninggalkan pohon sejauh yang bisa + */ + public Node cariSuccessor(Node n) { + if (n.kanan == null) { + return n; + } + Node sekarang = n.kanan; + Node parent = n.kanan; + while (sekarang != null) { + parent = sekarang; + sekarang = sekarang.kiri; + } + return parent; + } + + /* + * menegembalikan nilai dari root binary tree + */ + public Node dapatkanRoot() { return root; } + + /** + * menampilkan child kiri kemudian root lalu child kiri + * + * @param localroot local root darii Binary tree + */ + public void inOrder(Node localRoot) { + if (localRoot != null) { + inOrder(localRoot.kiri); + System.out.print(localRoot.data + " "); + } + } + + /** + * menampilkan aroot kemudian child kiri lalu child kiri + */ + + public void preOrder(Node localRoot) { + if (localRoot != null) { + System.out.print(localRoot.data + " "); + preOrder(localRoot.kiri); + preOrder(localRoot.kanan); + } + } + + /** + * dengan menggunaakan algoritma searching yang bernama bfs(breadth first + * search) + * algoritma ini mirip dengan pre-order traversal, tetapi alih alih ini + * di implementasikan dengan stack atau rekursif, atau diimplementasikan + * dengan antrian atau queue + */ + public void bfs(Node localRoot) { + // membuat queue + Queue queue = new LinkedList(); + + // jika root yang diberikan adalah null, maka kita tidak + // akann menambahkan ke dalam queue + if (localRoot != null) { + queue.add(localRoot); + } + + // lanjutkan ketika queue menjadi kosong + while (!queue.isEmpty()) { + localRoot = queue.remove(); + System.out.print(localRoot.data + " "); + } + if (localRoot.kanan != null) { + queue.add(localRoot.kanan); + } + if (localRoot.kiri != null) { + queue.add(localRoot.kiri); + } + } +} From 4ce25e23a2309d6ab3f31989ea24a7d0549181fd Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Wed, 15 Mar 2023 13:08:54 +0700 Subject: [PATCH 49/66] Dynamic array (#159) * feat: menambahkan contoh sederhana array dinamis Signed-off-by: slowy07 * fix: menambahkan argument pada git ignore Signed-off-by: slowy07 * fix: menghapus modul yang tidak dibutuhkan Signed-off-by: slowy07 --------- Signed-off-by: slowy07 --- .classpath | 44 ++++ .factorypath | 6 + .gitignore | 6 + .project | 34 ++++ .../DynamicArray/DynamicArray.java | 190 ++++++++++++++++++ 5 files changed, 280 insertions(+) create mode 100644 .classpath create mode 100644 .factorypath create mode 100644 .project create mode 100644 src/main/java/algorithm/datastructure/DynamicArray/DynamicArray.java diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..4ae9a46 --- /dev/null +++ b/.classpath @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.factorypath b/.factorypath new file mode 100644 index 0000000..99c5f80 --- /dev/null +++ b/.factorypath @@ -0,0 +1,6 @@ + + + + + + diff --git a/.gitignore b/.gitignore index bd4ef7d..102b6f8 100644 --- a/.gitignore +++ b/.gitignore @@ -29,4 +29,10 @@ build/ !**/src/test/**/build .setting +.settings + +## ignore dari classpath factory path dan project +.classpath +.factorypath +.project diff --git a/.project b/.project new file mode 100644 index 0000000..7666a81 --- /dev/null +++ b/.project @@ -0,0 +1,34 @@ + + + bellshade + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + + + + 1678469568599 + + 30 + + org.eclipse.core.resources.regexFilterMatcher + node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ + + + + diff --git a/src/main/java/algorithm/datastructure/DynamicArray/DynamicArray.java b/src/main/java/algorithm/datastructure/DynamicArray/DynamicArray.java new file mode 100644 index 0000000..a837bc4 --- /dev/null +++ b/src/main/java/algorithm/datastructure/DynamicArray/DynamicArray.java @@ -0,0 +1,190 @@ +/* + * array dynamic adalah sistem array yang bisa + * dan dapat dihapus secara dinamis + */ + +package algorithm.datastructure.DynamicArray; + +import java.util.*; +import java.util.function.Consumer; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +public class DynamicArray implements Iterable { + private static final int KAPASITAS_DEFAULT = 16; + private int kapasitas; + private int ukuran; + private Object[] elemen; + + /** + * konstruktor + * @param kapasitas start panjang dari array diisi + */ + public DynamicArray(final int kapasitas) { + this.ukuran = 0; + this.kapasitas = kapasitas; + this.elemen = new Object[this.kapasitas]; + } + + public DynamicArray() { + this(KAPASITAS_DEFAULT); + } + + /** + * menambahkan elemen ke array jika penuh, + * buat salinan array dua kali ukuran yang sekarang + */ + public void tambah(final E elemen) { + if (this.ukuran == this.elemen.length) { + this.elemen = Arrays.copyOf(this.elemen, kapasitasBaru(2 * this.kapasitas)); + } + this.elemen[this.ukuran] = elemen; + ukuran++; + } + + /** + * fungsi ini untuk menempatkan elemen bertipe pada indeks + * yang diinginkan + * @param indeks indeks untuk elemen yang akan ditempatkan + * @param elemen elemen yang disisipkan + */ + public void masukkan(final int index, E elemen) { + this.elemen[index] = elemen; + } + + /** + * fungsi untuk dapatkan metode pada indeks + * yang diberikan dan mengembalikan nol jika + * indeks yang diberikan kosong + */ + public E dapatIndeks(final int indeks) { + return dapatkanElement(indeks); + } + + /** + * menghapus elemen dari array + */ + public E hapus(final int indeks) { + final E elemenLama = dapatkanElement(indeks); + hapusCepat(this.elemen, indeks); + if (this.kapasitas > KAPASITAS_DEFAULT && ukuran * 4 <= this.kapasitas) { + this.elemen = Arrays.copyOf(this.elemen, kapasitasBaru(this.kapasitas / 2)); + } + return elemenLama; + } + + public E dapatkanElement(final int indeks) { + return (E) this.elemen[indeks]; + } + + public int kapasitasBaru(int kapasitas) { + this.kapasitas = kapasitas; + return this.kapasitas; + } + + public int dapatkanUkuran() { + return this.ukuran; + } + + public boolean kosong() { + return this.ukuran == 0; + } + + public Stream stream() { + return StreamSupport.stream(spliterator(), false); + } + + private void hapusCepat(final Object[] elemen, final int indeks) { + final int ukuranBaru = this.ukuran - 1; + + if (ukuranBaru > indeks) { + System.arraycopy( + elemen, + indeks - 1, + elemen, + indeks, + ukuranBaru - indeks + ); + } + elemen[this.ukuran = ukuranBaru] = null; + } + + /** + * mengembalikan string yang merupakan representai + * dari object itu sendiri + */ + @Override + public String toString() { + return Arrays.toString( + Arrays.stream(this.elemen).filter(Objects::nonNull).toArray() + ); + } + + /** + * membuat dan mengembalikan iterasi dari array dinamis + */ + @Override + public Iterator iterator() { + return new DynamicArrayIterator(); + } + + private class DynamicArrayIterator implements Iterator { + private int kursor; + + @Override + public boolean hasNext() { + return this.kursor != ukuran; + } + + @Override + public E next() { + if (this.kursor > DynamicArray.this.ukuran) { + throw new NoSuchElementException(); + } + if (this.kursor > DynamicArray.this.elemen.length) { + throw new ConcurrentModificationException(); + } + + final E elemen = DynamicArray.this.dapatkanElement(this.kursor); + this.kursor++; + return elemen; + } + + @Override + public void remove() { + if (this.kursor < 0) { + throw new IllegalStateException(); + } + DynamicArray.this.hapus(this.kursor); + this.kursor--; + } + + @Override + public void forEachRemaining(Consumer action) { + Objects.requireNonNull(action); + + for (int i = 1; i < DynamicArray.this.ukuran; i++) { + action.accept(DynamicArray.this.dapatkanElement(i)); + } + } + } + + /** + * test hasil fungsi diatas + */ + public static void main(String[] args) { + DynamicArray nama = new DynamicArray<>(); + nama.tambah("pace"); + nama.tambah("james"); + + for (String namaNama : nama) { + System.out.println(namaNama); + } + + nama.stream().forEach(System.out::println); + System.out.println(nama); + System.out.println(nama.dapatkanUkuran()); + nama.hapus(0); + } +} + From bd95b84ad4493947c17d70bd4b9642ea16e41d4f Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Sat, 18 Mar 2023 12:42:45 +0700 Subject: [PATCH 50/66] feat: menambahkan algoritma binary search tree mode rekursif (#160) Signed-off-by: slowy07 --- .../BinarySearchTreeRekursif.java | 125 ++++++++++++++++++ 1 file changed, 125 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Tree/BinarySearchTree/BinarySearchTreeRekursif.java diff --git a/src/main/java/algorithm/datastructure/Tree/BinarySearchTree/BinarySearchTreeRekursif.java b/src/main/java/algorithm/datastructure/Tree/BinarySearchTree/BinarySearchTreeRekursif.java new file mode 100644 index 0000000..32ee496 --- /dev/null +++ b/src/main/java/algorithm/datastructure/Tree/BinarySearchTree/BinarySearchTreeRekursif.java @@ -0,0 +1,125 @@ +package algorithm.datastructure.Tree.BinarySearchTree; + +/** + * implementasi binary search tree secara rekursif. + */ +public class BinarySearchTreeRekursif { + private Node root; + /** + * konstruktor untuk mengubah value dari Node + * menjadi nul + */ + BinarySearchTreeRekursif() { + root = null; + } + + /** + * class node digunakan untuk membangun binary search tree + */ + private static class Node { + int data; + Node kiri; + Node kanan; + + Node(int d){ + data = d; + kiri = null; + kanan = null; + } + } + + /** + * fungsi ini untuk memasukkan ke dalam binary search tree + * @param node untuk mengecek apakah data bisa dimasukkan dalam subpohon + * @param data data untuk dimasukkan + */ + private Node insert(Node node, int data) { + if (node == null) { + node = new Node(data); + } else if (node.data > data) { + node.kiri = insert(node.kiri, data); + } else if (node.data < data) { + node.kanan = insert(node.kanan, data); + } + return node; + } + + /** + * fungsi ini untuk menghapus data jika data sudah terdapat pada pohon + * @param node node yang ditampilkan yang dicari untuk dihapus + * @param data data yang akan dihapus + */ + private Node hapus(Node node, int data) { + if (node == null) { + System.out.println("tidak ada data tersedia di pohon"); + } else if (node.data > data) { + node.kiri = hapus(node.kiri, data); + } else if (node.data < data) { + node.kanan = hapus(node.kanan, data); + } else { + if (node.kanan == null && node.kiri == null) { + node = null; + } else if (node.kiri == null) { + Node temp = node.kanan; + node.kanan = null; + node = temp; + } else if (node.kanan == null) { + Node temp = node.kiri; + node.kiri = null; + node = temp; + } else { + Node temp = node.kanan; + while (temp.kiri != null) { + temp = temp.kiri; + } + node.data = temp.data; + node.kanan = hapus(node.kanan, temp.data); + } + } + return node; + } + + /** + * cari secara rekursif jika nilai yang diberikan ada + * di pohon atau tidak + */ + + private boolean cari(Node node, int data) { + if (node == null) { + return false; + } else if (node.data == data) { + return true; + } else if (node.data > data) { + return cari(node.kiri, data); + } else { + return cari(node.kanan, data); + } + } + + public void tambah(int data) { + this.root = insert(this.root, data); + } + + public void remove(int data) { + this.root = hapus(this.root, data); + } + + public boolean mencari(int data) { + if (cari(this.root, data)) { + System.out.println(data + " terdapat pada pohon"); + return true; + } + System.out.println(data + " tidak terdapat pada pohon"); + return false; + } + + public static void main(String[] args) { + BinarySearchTreeRekursif pohon = new BinarySearchTreeRekursif(); + pohon.tambah(5); + pohon.tambah(10); + pohon.tambah(9); + assert !pohon.mencari(4) : "4 tidak terdapat dalam pohon"; + assert pohon.mencari(10) : "10 terdapat pada pohon"; + pohon.remove(9); + } +} From 5f2afe205420a4446679192383d59068631f086e Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Thu, 23 Mar 2023 06:59:42 +0700 Subject: [PATCH 51/66] feat: menambahkan contoh dari double linked list (#161) Signed-off-by: slowy07 --- .../SourceCode/DoubleLinkedList.java | 238 ++++++++++++++++++ 1 file changed, 238 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/LinkedList/SourceCode/DoubleLinkedList.java diff --git a/src/main/java/algorithm/datastructure/LinkedList/SourceCode/DoubleLinkedList.java b/src/main/java/algorithm/datastructure/LinkedList/SourceCode/DoubleLinkedList.java new file mode 100644 index 0000000..83ea505 --- /dev/null +++ b/src/main/java/algorithm/datastructure/LinkedList/SourceCode/DoubleLinkedList.java @@ -0,0 +1,238 @@ +package algorithm.datastructure.LinkedList.SourceCode; + +public class DoubleLinkedList { + protected Link head; + private Link tail; + private LinkOperation linkOperations; + private int ukuran; + + public DoubleLinkedList() { + head = null; + tail = null; + ukuran = 0; + } + + // buat list dengan mengandung element dari array + public DoubleLinkedList(int[] array) { + if (array == null) { + throw new NullPointerException(); + } + for (int i : array) { + linkOperations.insertTail(i, this); + } + ukuran = array.length; + } + + // mengembalikaan true jika list kosong + public boolean isEmpty() { + return (head == null); + } + + // print element dalam list + public void display() { + Link current = head; + while (current != null) { + current.displayLink(); + current = current.next; + } + System.out.println(); + } + + // tampilkan element dalam list dalam perintah reverse + public void displayBackward() { + Link current = tail; + while (current != null) { + current.displayLink(); + current = current.previous; + } + System.out.println(); + } +} + +// kelas link digunakan untuk implementasi node dalam linked list +class Link { + public int value; + public Link next; + public Link previous; + + // constructor + public Link(int value) { + this.value = value; + } + + // tampilkan dari node + public void displayLink() { + System.out.println(value + " "); + } + + public static void main(String args[]) { + DoubleLinkedList listSaya = new DoubleLinkedList(); + LinkOperation linkOperations = new LinkOperation(); + linkOperations.insertTail(13, listSaya); + } +} + +// kelas untuk implementasi dari link nodes +class LinkOperation { + private Link head; + private Link tail; + private int ukuran; + + public void insertHead(int x, DoubleLinkedList doubleLinkedList) { + // buat tautan baru dengan nilai yang melekat padanya + Link newLink = new Link(x); + // atur element pertama yang ditambahkan menjadi tail + if (doubleLinkedList.isEmpty()) { + tail = newLink; + } else { + head.previous = newLink; + } + newLink.next = head; + head = newLink; + ++ukuran; + } + + public void insertTail(int x, DoubleLinkedList doubleLinkedList) { + Link newLink = new Link(x); + newLink.next = null; + if (doubleLinkedList.isEmpty()) { + tail = newLink; + head = tail; + } else { + tail.next = newLink; + newLink.previous = tail; + tail = newLink; + } + ++ukuran; + } + + // masukkan element ke dalam index + public void insertElementByIndex ( + int x, + int index, + DoubleLinkedList doubleLinkedList + ) { + if (index > ukuran) { + throw new IndexOutOfBoundsException( + "indeks: " + index + ", ukruan: " + ukuran + ); + } + if (index == 0) { + insertTail(x, doubleLinkedList); + } else { + if (index == ukuran) { + insertTail(x, doubleLinkedList); + } else { + Link newLink = new Link(x); + Link previousLink = head; + for (int i = 1; i < index; i++) { + previousLink = previousLink.next; + } + previousLink.next.previous = newLink; + newLink.next = previousLink.next; + newLink.previous = previousLink; + previousLink.next = newLink; + } + } + ++ukuran; + } + public Link deleteHead() { + Link temp = head; + head = head.next; + + if (head == null) { + tail = null; + } else { + head.previous = null; + } + --ukuran; + return temp; + } + + public Link deleteTail() { + Link temp = tail; + tail = tail.previous; + + if (tail == null) { + head = null; + } else { + tail.next = null; + } + --ukuran; + return temp; + } + + // hapus element data dari list + public void delete(int x) { + Link current = head; + + while (current.value != x) { + if (current != tail) { + current = current.next; + } else { + throw new RuntimeException( + "element yang ingin dihapus tidak ada" + ); + } + } + if (current == head) { + deleteHead(); + } else if (current == tail) { + deleteTail(); + } else { + current.previous.next = current.next; + current.next.previous = current.previous; + } + --ukuran; + } + + public void deleteNode(Link z) { + if (z.next == null) { + deleteTail(); + } else if (z == head) { + deleteHead(); + } else { + z.previous.next = z.next; + z.next.previous = z.previous; + } + --ukuran; + } + + public void removeDuplicate(DoubleLinkedList l) { + Link linkOne = l.head; + while (linkOne.next != null) { + Link linkTwo = linkOne.next; + while (linkTwo.next != null) { + if (linkOne.value == linkTwo.value) { + delete(linkTwo.value); + } + linkTwo = linkTwo.next; + } + linkOne = linkOne.next; + } + } + + public void reverse() { + Link thisHead = this.head; + Link thisTail = this.tail; + + this.head = thisTail; + this.tail = thisHead; + + Link nextLink = thisHead; + while (nextLink != null) { + Link nextLinkNext = nextLink.next; + Link nextLinkPrevious = nextLink.previous; + nextLink.next = nextLinkPrevious; + nextLink.previous = nextLinkNext; + + nextLink = nextLinkNext; + } + } + + public void clearList() { + head = null; + tail = null; + ukuran = 0; + } +} From 5a7b370f968735f5bb99b44d9a302a1d868a8c96 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Fri, 24 Mar 2023 06:53:54 +0700 Subject: [PATCH 52/66] feat: menambahkan contoh dari cursor linked list (#162) Signed-off-by: slowy07 --- .../SourceCode/CursorLinkedList.java | 134 ++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/LinkedList/SourceCode/CursorLinkedList.java diff --git a/src/main/java/algorithm/datastructure/LinkedList/SourceCode/CursorLinkedList.java b/src/main/java/algorithm/datastructure/LinkedList/SourceCode/CursorLinkedList.java new file mode 100644 index 0000000..cd1fff4 --- /dev/null +++ b/src/main/java/algorithm/datastructure/LinkedList/SourceCode/CursorLinkedList.java @@ -0,0 +1,134 @@ +package algorithm.datastructure.LinkedList.SourceCode; + +import java.util.Objects; + +/** + * cursor linked list adalah versi array dari linked list. + * pada dasarnya setiap node memiliki pointer ke node berikutnya + * pada setiap element node dalam array memiliki indeks untuk + * element node berikutnya + */ + +public class CursorLinkedList { + private static class Node { + T element; + int next; + Node(T element, int next) { + this.element = element; + this.next = next; + } + } + + private final int os; + private int head; + private final Node[] cursorSpace; + private int count; + private static final int CURSOR_SPACE_SIZE = 100; + + { + cursorSpace = new Node[CURSOR_SPACE_SIZE]; + for (int i = 0; i < CURSOR_SPACE_SIZE; i++) { + cursorSpace[i] = new Node<>(null, i + 1); + } + cursorSpace[CURSOR_SPACE_SIZE -1].next = 0; + } + + public CursorLinkedList() { + os = 0; + count = 0; + head = -1; + } + + public void printList() { + if (head != -1) { + int start = head; + while (start != -1) { + T element = cursorSpace[start].element; + System.out.println(element.toString()); + start = cursorSpace[start].next; + } + } + } + + public int indexOf(T element) { + Objects.requireNonNull(element); + Node iterator = cursorSpace[head]; + for (int i = 0; i < count; i++) { + if (iterator.element.equals(element)) { + return i; + } + iterator = cursorSpace[iterator.next]; + } + return -1; + } + + public T get(int position) { + if (position >= 0 && position < count) { + int start = head; + int counter = 0; + while (start != -1) { + T element = cursorSpace[start].element; + if (counter == position) { + return element; + } + start = cursorSpace[start].next; + counter++; + } + } + return null; + } + + public void removeByIndex(int index) { + if (index >= 0 && index < count) { + T element = get(index); + remove(element); + } + } + + public void remove(T element) { + Objects.requireNonNull(element); + // jika element terdapat pada head + T temp_element = cursorSpace[head].element; + int temp_next = cursorSpace[head].next; + if (temp_element.equals(element)) { + free(head); + head = temp_next; + } else { + int prev_index = head; + int current_index = cursorSpace[prev_index].next; + + while (current_index != -1) { + T current_element = cursorSpace[current_index].element; + if (current_element.equals(element)) { + cursorSpace[prev_index].next = cursorSpace[current_index].next; + free(current_index); + break; + } + prev_index = current_index; + current_index = cursorSpace[prev_index].next; + } + } + count--; + } + + private void free(int index) { + Node os_node = cursorSpace[os]; + int os_next = os_node.next; + cursorSpace[os].next = index; + cursorSpace[index].element = null; + cursorSpace[index].next = os_next; + } + + private int alloc() { + int availableNodeIndex = cursorSpace[os].next; + if (availableNodeIndex == 0) { + throw new OutOfMemoryError(); + } + + int availableNext = cursorSpace[availableNodeIndex].next; + cursorSpace[os].next = availableNext; + cursorSpace[availableNodeIndex].next = -1; + + return availableNodeIndex; + } +} From 8f7eb9db1941a7c564c7fcdd70c7fda43d822364 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Sat, 25 Mar 2023 10:38:36 +0700 Subject: [PATCH 53/66] feat: menambahkan contoh konversi dari heksadesimal ke biner (#163) Signed-off-by: slowy07 --- .../conversions/HexadecimalToBinary.java | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 src/main/java/algorithm/conversions/HexadecimalToBinary.java diff --git a/src/main/java/algorithm/conversions/HexadecimalToBinary.java b/src/main/java/algorithm/conversions/HexadecimalToBinary.java new file mode 100644 index 0000000..340e0eb --- /dev/null +++ b/src/main/java/algorithm/conversions/HexadecimalToBinary.java @@ -0,0 +1,45 @@ +package algorithm.conversions; + +/** + * program sederhana cara mengubah angka heksadesimal + * menjadi angka biner sebagai contoh + * 7F menjadi 1111111 + */ +class HexadecimalToBinary { + private final int LONG_BIT = 8; + + public String konversi(String angkaHex) { + int conHex = Integer.parseInt(angkaHex, 16); + String binary = Integer.toBinaryString(conHex); + return completeDigits(binary); + } + + public String completeDigits(String angkaBiner) { + for (int i = angkaBiner.length(); i < LONG_BIT; i++) { + angkaBiner = "0" + angkaBiner; + } + return angkaBiner; + } + + public static void main(String[] args) { + String[] angkaHeksadesimal = { + "1", + "A1", + "ef", + "BA", + "AA", + "BB", + "19", + "01", + "02", + "03", + "04", + }; + HexadecimalToBinary objectKonversi = new HexadecimalToBinary(); + for (String angka : angkaHeksadesimal) { + System.out.println(angka + " = " + objectKonversi.konversi(angka)); + } + } +} + + From 2dc3ea8353efdda92ea7e9884d89a87ee1e371cf Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Wed, 29 Mar 2023 13:27:53 +0700 Subject: [PATCH 54/66] feat: menambahkan sorting bitonic (#164) Signed-off-by: slowy07 --- .../datastructure/Sorting/BitonicSorting.java | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Sorting/BitonicSorting.java diff --git a/src/main/java/algorithm/datastructure/Sorting/BitonicSorting.java b/src/main/java/algorithm/datastructure/Sorting/BitonicSorting.java new file mode 100644 index 0000000..399003d --- /dev/null +++ b/src/main/java/algorithm/datastructure/Sorting/BitonicSorting.java @@ -0,0 +1,80 @@ +package algorithm.datastructure.Sorting; + +/** + * bitonic sorting adalah algoritma paralel untuk + * pengurutan. ini juga digunakan sebagai metode + * untuk membangun jaringan pernyortiran. algoritma + * ini dibangun oleh Ken Batcher + */ +public class BitonicSorting{ + /* + * parameter dir menunjukkan arah pengurutan. + * ASCENDING atau DESCENDING + */ + void Swap(int a[], int i, int j, int dir) { + if ((a[i] > a[j] && dir == 1) || (a[i] < a[j] && dir == 0)) { + // swap element + int temp = a[i]; + a[i] = a[j]; + a[j] = temp; + } + } + + /** + * secara rekursif akan mengurutkan bitonic menaik + * urutan, jika dir=1, dan dalam urutan menurun + * maka sebaliknya (dir=0). urutan yang akan diurutkan + * dimulai pada posisi indeks renda, parameter cnt adalah + * angka element yang diurutkan + */ + void bitonicMerge(int a[], int low, int cnt, int dir) { + if (cnt > 1) { + int k = cnt / 2; + for (int i = low; i < low + k; i++) { + Swap(a, i, i + k, dir); + } + bitonicMerge(a, low, k, dir); + bitonicMerge(a, low + k, k, dir); + } + } + + /* + * fungsi ini pertama dalam menghasilkan urutan bitonic + * oleh menyortir dua bagian secara rekursif dalam + * penyortiran yang berlawan + */ + void bitonicSort(int a[], int low, int cnt, int dir) { + if (cnt > 1) { + int k = cnt / 2; + // urutkan dalam urutan menaik karena dir disini + // adalah 1 + bitonicSort(a, low, k, 1); + // urutkan dalam urutan menurun karena dir disini + // adalah 0 + bitonicSort(a, low + k, k, 0); + bitonicMerge(a, low, cnt, dir); + } + } + + void sort(int a[], int N, int up) { + bitonicSort(a, 0, N, up); + } + + // fungsi utilitas untuk mencetak array n + static void printArray(int arr[]) { + int n = arr.length; + for (int i = 0; i < n; ++i) { + System.out.print(arr[i] + " "); + } + System.out.println(); + } + + public static void main(String args[]) { + int a[] = { 3, 7, 4, 8, 6, 2, 1, 5 }; + int up = 1; + BitonicSorting bs = new BitonicSorting(); + bs.sort(a, a.length, up); + System.out.println("\narray yang ke sorting"); + printArray(a); + } +} From db8177c109840dee5263a78708aeb70a2c070bf6 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Sat, 1 Apr 2023 13:27:22 +0700 Subject: [PATCH 55/66] feat: menambahkan contoh dari infix ke postfix (#165) Signed-off-by: slowy07 --- .../datastructure/Stack/BalancedBracket.java | 61 +++++++++++++++++++ .../datastructure/Stack/InfixToPostfix.java | 61 +++++++++++++++++++ 2 files changed, 122 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Stack/BalancedBracket.java create mode 100644 src/main/java/algorithm/datastructure/Stack/InfixToPostfix.java diff --git a/src/main/java/algorithm/datastructure/Stack/BalancedBracket.java b/src/main/java/algorithm/datastructure/Stack/BalancedBracket.java new file mode 100644 index 0000000..44bf9e0 --- /dev/null +++ b/src/main/java/algorithm/datastructure/Stack/BalancedBracket.java @@ -0,0 +1,61 @@ +package algorithm.datastructure.Stack; + +/** + * tanda kurung bersarang adalah problem dimana menentukan + * apakah urutan tanda kurung bersarang dengan benar + * urutan tanda kurung s dianggap benar bersarang + * jika salah satu kondisi berikut + * - S kosong + * - s memiliki bentuk + * (U) atau [U] atau {U} + * dimana U ini adalah string bersarang yang benar + */ +import java.util.Stack; + +class BalancedBracket { + public static boolean telahTersambung(char bracketKiri, char bracketKanan) { + char[][] bracketSambungan = { + {'(', ')'}, + {'[', ']'}, + {'{', '}'}, + {'<', '>'}, + }; + for (char[] bracketTersambung : bracketSambungan) { + if (bracketTersambung[0] == bracketKiri && bracketTersambung[1] == bracketKanan) { + return true; + } + } + return false; + } + + public static boolean bracketSesuai(String brackets) { + if (brackets == null) { + throw new IllegalArgumentException("bracket null"); + } + Stack bracketStack = new Stack<>(); + for (char bracket : brackets.toCharArray()) { + switch (bracket) { + case '(': + case '{': + case '[': + bracketStack.push(bracket); + break; + case ')': + case '}': + case ']': + if (bracketStack.isEmpty() || !telahTersambung(bracketStack.pop(), bracket)) { + return false; + } + break; + default: + return false; + } + } + return bracketStack.isEmpty(); + } + + public static void main(String[] arags) { + assert bracketSesuai("[()]{}{[()()]()}"); + assert !bracketSesuai("[(])"); + } +} diff --git a/src/main/java/algorithm/datastructure/Stack/InfixToPostfix.java b/src/main/java/algorithm/datastructure/Stack/InfixToPostfix.java new file mode 100644 index 0000000..d9f4e27 --- /dev/null +++ b/src/main/java/algorithm/datastructure/Stack/InfixToPostfix.java @@ -0,0 +1,61 @@ +package algorithm.datastructure.Stack; + +/** + * notasi infix adalah notasi dimana operator berada diantara + * operan yang diperlukan. notasi postfix adalah jenis notasi + * dimana operator muncul setelah operan + * + * ekspresi infix -> A + B * C + D + * ke eksprei postfix menjadi -> ABC * + D + + */ +import java.util.Stack; + +public class InfixToPostfix { + + public static String infixToPostfix(String ekspresiInfix) throws Exception { + if (!BalancedBracket.bracketSesuai(ekspresiInfix)) { + throw new Exception("ekspresi salah"); + } + StringBuilder output = new StringBuilder(); + Stack stack = new Stack<>(); + for (char element : ekspresiInfix.toCharArray()) { + if (Character.isLetterOrDigit(element)) { + output.append(element); + } else if (element == '(') { + stack.push(element); + } else if (element == ')') { + while (!stack.isEmpty() && stack.peek() != '(') { + output.append(stack.pop()); + } + stack.pop(); + } else { + while(!stack.isEmpty() && ekspresi(element) <= ekspresi(stack.peek())) { + output.append(stack.pop()); + } + stack.push(element); + } + } + while (!stack.isEmpty()) { + output.append(stack.pop()); + } + return output.toString(); + } + + private static int ekspresi(char operator) { + switch (operator) { + case '+': + case '-': + return 0; + case '*': + case '/': + return 1; + case '^': + return 2; + default: + return -1; + } + } + public static void main(String[] args) throws Exception { + + } +} From 25703b2c15d7aa12d4004aef92d898916dab4606 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Mon, 3 Apr 2023 14:25:48 +0700 Subject: [PATCH 56/66] feat: menambahkan contoh dari quick sorting (#166) --- .../Sorting/AlgoritmaSorting.java | 16 +++++ .../datastructure/Sorting/QuickSort.java | 66 ++++++++++++++++++ .../Sorting/SortingUtilites.java | 67 +++++++++++++++++++ 3 files changed, 149 insertions(+) create mode 100644 src/main/java/algorithm/datastructure/Sorting/AlgoritmaSorting.java create mode 100644 src/main/java/algorithm/datastructure/Sorting/QuickSort.java create mode 100644 src/main/java/algorithm/datastructure/Sorting/SortingUtilites.java diff --git a/src/main/java/algorithm/datastructure/Sorting/AlgoritmaSorting.java b/src/main/java/algorithm/datastructure/Sorting/AlgoritmaSorting.java new file mode 100644 index 0000000..3cf764c --- /dev/null +++ b/src/main/java/algorithm/datastructure/Sorting/AlgoritmaSorting.java @@ -0,0 +1,16 @@ +package algorithm.datastructure.Sorting; + +import java.util.Arrays; +import java.util.List; + +// interface untuk algoritma Sorting +public interface AlgoritmaSorting { + > T[] sorting(T[] tidakTersorting); + + @SuppressWarnings("unchecked") + default > List sorting(List tidakTersorting) { + return Arrays.asList( + sorting(tidakTersorting.toArray((T[]) new Comparable[tidakTersorting.size()])) + ); + } +} diff --git a/src/main/java/algorithm/datastructure/Sorting/QuickSort.java b/src/main/java/algorithm/datastructure/Sorting/QuickSort.java new file mode 100644 index 0000000..fd02588 --- /dev/null +++ b/src/main/java/algorithm/datastructure/Sorting/QuickSort.java @@ -0,0 +1,66 @@ +package algorithm.datastructure.Sorting; + +import static algorithm.datastructure.Sorting.SortingUtilites.*; + +/** + * salah satu algoritma sorting tercepat adalah quick sort + * yaitu dengan cara membagi list dengan menggunakan sebuah pivot. + * algoritma ini dikenal sebagai partition-exchange sort atau sorting + * pergantian pembagi. + * dalam perakteknya adalah yang tercepat dari berbagai algoritma + * pengurutan dengan perbandingan, seperti merge sort atau heap sort + * melakukan proses langsung pada input (in-place) dengan sedikit + * tambahan memori. bekerja dengan baik pada berbagai jenis input + * data (seperti angka dan karakter). + */ + +class QuickSort implements AlgoritmaSorting { + // method untuk implementasi dari generic quick sorting + @Override + public > T[] sorting(T[] array) { + lakukanSorting(array, 0, array.length - 1); + return array; + } + + // fungsi fungsi proses dari sorting + private static > void lakukanSorting(T[] array, int kiri, int kanan) { + if (kiri < kanan) { + int pivot = partisiAcak(array, kiri, kanan); + lakukanSorting(array, kiri, pivot - 1); + lakukanSorting(array, pivot, kanan); + } + } + // acak array untuk menghindari urutan yang pda dasarnya + // sudah di order + private static > int partisiAcak( + T[] array, + int kiri, + int kanan + ) { + int indeksAcak = kiri + (int)(Math.random() * (kanan - kiri + 1)); + swap(array, indeksAcak, kanan); + return partisi(array, kiri, kanan); + } + + private static > int partisi(T[] array, int kiri, int kanan) { + int mid = (kiri + kanan) >>> 1; + T pivot = array[mid]; + + while (kiri <= kanan) { + while (lebihKecil(array[kiri], pivot)) { + ++kiri; + } + while (lebihKecil(pivot, array[kanan])) { + --kanan; + } + if (kiri <= kanan) { + swap(array, kiri, kanan); + ++kiri; + --kanan; + } + } + return kiri; + } +} + + diff --git a/src/main/java/algorithm/datastructure/Sorting/SortingUtilites.java b/src/main/java/algorithm/datastructure/Sorting/SortingUtilites.java new file mode 100644 index 0000000..189ea16 --- /dev/null +++ b/src/main/java/algorithm/datastructure/Sorting/SortingUtilites.java @@ -0,0 +1,67 @@ +package algorithm.datastructure.Sorting; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +final class SortingUtilites { + public static void swap(T[] array, int i, int j) { + T temp = array[i]; + array[i] = array[j]; + array[j] = temp; + } + + // membandingkan dua elemen untuk melihat apakah + // yang pertama lebih kecil daripada yang kedua + public static > boolean lebihKecil(T elemenPertama, T elemenKedua) { + return elemenPertama.compareTo(elemenKedua) < 0; + } + + // membandingkan dua elemen untuk melihat apakah + // yang pertama lebih besar dari yang kedua + public static > boolean lebihBesar(T elemenPertama, T elemenKedua) { + return elemenPertama.compareTo(elemenKedua) > 0; + } + + // membandingkan dua elemen untuk melihat apakah + // elemen pertama lebih besar atau sama dengan + // elemen kedua + static > boolean lebihBesarAtauSama(T elemenPertama, T elemenKedua) { + return elemenPertama.compareTo(elemenKedua) >= 0; + } + + static void print(List listUntukPrint) { + String hasil = listUntukPrint.stream() + .map(Object::toString) + .collect(Collectors.joining(" ")); + System.out.println(hasil); + } + + static void print(T[] array) { + System.out.println(Arrays.toString(array)); + } + + public static > void flip(T[] array, int kiri, int kanan) { + while (kiri <= kanan) { + swap(array, kiri++, kanan++); + } + } + + public static > boolean telahDisorting(T[] array) { + for (int i = 1; i < array.length; i++) { + if (lebihKecil(array[i], array[i - 1])) { + return false; + } + } + return true; + } + + public static > boolean telahDisorting(List list) { + for (int i = 1; i < list.size(); i++) { + if (lebihKecil(list.get(i), list.get(i - 1))) { + return false; + } + } + return true; + } +} From 8472b5d8d55a9c590b9f61c6bdb55d111ed2f102 Mon Sep 17 00:00:00 2001 From: Basith Nurfaizin Date: Tue, 23 May 2023 20:06:47 +0700 Subject: [PATCH 57/66] add: implementasi http client java (#168) Co-authored-by: nurfaizin --- .../javahttpclient/HttpClientMain.java | 25 ++++++++ .../intermediate/javahttpclient/README.md | 58 +++++++++++++++++++ .../javahttpclient/dto/Firmness.java | 9 +++ .../javahttpclient/dto/Flavor.java | 9 +++ .../javahttpclient/dto/FlavorsItem.java | 9 +++ .../intermediate/javahttpclient/dto/Item.java | 9 +++ .../javahttpclient/dto/NaturalGiftType.java | 9 +++ .../dto/PokemonDetailResponse.java | 28 +++++++++ .../services/RestClientService.java | 8 +++ .../services/RestClientServiceImpl.java | 45 ++++++++++++++ 10 files changed, 209 insertions(+) create mode 100644 src/main/java/learn/intermediate/javahttpclient/HttpClientMain.java create mode 100644 src/main/java/learn/intermediate/javahttpclient/README.md create mode 100644 src/main/java/learn/intermediate/javahttpclient/dto/Firmness.java create mode 100644 src/main/java/learn/intermediate/javahttpclient/dto/Flavor.java create mode 100644 src/main/java/learn/intermediate/javahttpclient/dto/FlavorsItem.java create mode 100644 src/main/java/learn/intermediate/javahttpclient/dto/Item.java create mode 100644 src/main/java/learn/intermediate/javahttpclient/dto/NaturalGiftType.java create mode 100644 src/main/java/learn/intermediate/javahttpclient/dto/PokemonDetailResponse.java create mode 100644 src/main/java/learn/intermediate/javahttpclient/services/RestClientService.java create mode 100644 src/main/java/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java diff --git a/src/main/java/learn/intermediate/javahttpclient/HttpClientMain.java b/src/main/java/learn/intermediate/javahttpclient/HttpClientMain.java new file mode 100644 index 0000000..1081ee6 --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/HttpClientMain.java @@ -0,0 +1,25 @@ +package learn.intermediate.javahttpclient; + +import com.fasterxml.jackson.databind.ObjectMapper; +import learn.intermediate.javahttpclient.dto.PokemonDetailResponse; +import learn.intermediate.javahttpclient.services.RestClientService; +import learn.intermediate.javahttpclient.services.RestClientServiceImpl; + +import java.net.http.HttpClient; +import java.util.logging.Logger; + +public class HttpClientMain { + + private static final Logger log = Logger.getLogger(HttpClientMain.class.getName()); + + public static void main(String[] args) { + HttpClient httpClient = HttpClient.newBuilder().build(); + ObjectMapper objectMapper = new ObjectMapper(); + + RestClientService restClientService = new RestClientServiceImpl(httpClient, objectMapper); + + PokemonDetailResponse detailPokemon = restClientService.getDetailPokemon("1"); + + log.info(detailPokemon.toString()); + } +} diff --git a/src/main/java/learn/intermediate/javahttpclient/README.md b/src/main/java/learn/intermediate/javahttpclient/README.md new file mode 100644 index 0000000..8f92c8d --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/README.md @@ -0,0 +1,58 @@ +# Java HttpClient + +Proyek ini menjelaskan cara menggunakan kelas Java `HttpClient` untuk mengirim permintaan HTTP dan memproses responsnya. + +## Persyaratan + +- Java 11 atau yang lebih baru + + +## Notes + +- Kelas HttpClient diperkenalkan pada Java 11 sebagai pengganti kelas HttpURLConnection yang lebih lama. +- Contoh ini menjelaskan permintaan GET sederhana, tetapi Anda dapat mengubahnya untuk mendukung metode HTTP lainnya (misalnya, POST, PUT, DELETE). +- Opsi kustomisasi tambahan, seperti mengatur header permintaan atau mengelola body respons dalam format yang berbeda, dapat ditambahkan sesuai kebutuhan Anda. + + +## Cara Penggunaan +- penggunaan dapat dimulai dengan inisiasi obyek berikut + + ```java + import com.fasterxml.jackson.databind.ObjectMapper; + import java.net.http.HttpClient; + + class Main { + HttpClient httpClient = HttpClient.newBuilder().build(); + ObjectMapper objectMapper = new ObjectMapper(); + } + ``` +- kemudian inisiasi object RestClientService dan masukan dependecies tersebut + ```java + import com.fasterxml.jackson.databind.ObjectMapper; + import java.net.http.HttpClient; + + class Main { + HttpClient httpClient = HttpClient.newBuilder().build(); + ObjectMapper objectMapper = new ObjectMapper(); + + RestClientService restClientService = new RestClientServiceImpl(httpClient, objectMapper); + } + ``` +- pada class RestClientServiceImpl ini terdapat contoh http request get, untuk membuat request tersebut kita perlu inisiasi object request terlebih dahulu + ``` + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create("https://pokeapi.co/api/v2/berry/"+id)) + .build(); + ``` +- setelah itu tinggal execute request dengan http send + ``` + httpClient.send(request, HttpResponse.BodyHandlers.ofString()); + ``` +- untuk request POST kita bisa ubah HttpRequest nya seperti berikut + ``` + HttpRequest postRequest = HttpRequest.newBuilder() + .uri(URI.create("https://api.example.com/endpoint")) + .header("Content-Type", "application/json") + .POST(HttpBodyPublishers.ofString("{\"name\":\"John\",\"age\":30}")) + .build(); + ``` \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javahttpclient/dto/Firmness.java b/src/main/java/learn/intermediate/javahttpclient/dto/Firmness.java new file mode 100644 index 0000000..f3cb9f1 --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/dto/Firmness.java @@ -0,0 +1,9 @@ +package learn.intermediate.javahttpclient.dto; + +import lombok.Data; + +@Data +public class Firmness{ + private String name; + private String url; +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javahttpclient/dto/Flavor.java b/src/main/java/learn/intermediate/javahttpclient/dto/Flavor.java new file mode 100644 index 0000000..2e6b639 --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/dto/Flavor.java @@ -0,0 +1,9 @@ +package learn.intermediate.javahttpclient.dto; + +import lombok.Data; + +@Data +public class Flavor{ + private String name; + private String url; +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javahttpclient/dto/FlavorsItem.java b/src/main/java/learn/intermediate/javahttpclient/dto/FlavorsItem.java new file mode 100644 index 0000000..53b5ad4 --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/dto/FlavorsItem.java @@ -0,0 +1,9 @@ +package learn.intermediate.javahttpclient.dto; + +import lombok.Data; + +@Data +public class FlavorsItem{ + private Flavor flavor; + private int potency; +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javahttpclient/dto/Item.java b/src/main/java/learn/intermediate/javahttpclient/dto/Item.java new file mode 100644 index 0000000..39eea4f --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/dto/Item.java @@ -0,0 +1,9 @@ +package learn.intermediate.javahttpclient.dto; + +import lombok.Data; + +@Data +public class Item{ + private String name; + private String url; +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javahttpclient/dto/NaturalGiftType.java b/src/main/java/learn/intermediate/javahttpclient/dto/NaturalGiftType.java new file mode 100644 index 0000000..e02092d --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/dto/NaturalGiftType.java @@ -0,0 +1,9 @@ +package learn.intermediate.javahttpclient.dto; + +import lombok.Data; + +@Data +public class NaturalGiftType{ + private String name; + private String url; +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javahttpclient/dto/PokemonDetailResponse.java b/src/main/java/learn/intermediate/javahttpclient/dto/PokemonDetailResponse.java new file mode 100644 index 0000000..9bf29af --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/dto/PokemonDetailResponse.java @@ -0,0 +1,28 @@ +package learn.intermediate.javahttpclient.dto; + +import java.util.List; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; + +@Data +public class PokemonDetailResponse { + + private List flavors; + @JsonProperty("natural_gift_type") + private NaturalGiftType naturalGiftType; + private Item item; + private int smoothness; + private int size; + @JsonProperty("natural_gift_power") + private int naturalGiftPower; + private Firmness firmness; + private String name; + @JsonProperty("growth_time") + private int growthTime; + @JsonProperty("soil_dryness") + private int soilDryness; + private int id; + @JsonProperty("max_harvest") + private int maxHarvest; +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javahttpclient/services/RestClientService.java b/src/main/java/learn/intermediate/javahttpclient/services/RestClientService.java new file mode 100644 index 0000000..ab8902e --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/services/RestClientService.java @@ -0,0 +1,8 @@ +package learn.intermediate.javahttpclient.services; + +import learn.intermediate.javahttpclient.dto.PokemonDetailResponse; + +public interface RestClientService { + + PokemonDetailResponse getDetailPokemon(String id); +} diff --git a/src/main/java/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java b/src/main/java/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java new file mode 100644 index 0000000..a6dd88e --- /dev/null +++ b/src/main/java/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java @@ -0,0 +1,45 @@ +package learn.intermediate.javahttpclient.services; + +import com.fasterxml.jackson.databind.ObjectMapper; +import learn.intermediate.javahttpclient.dto.PokemonDetailResponse; + +import java.io.IOException; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.util.logging.Level; +import java.util.logging.Logger; + +public class RestClientServiceImpl implements RestClientService { + + private static final Logger log = Logger.getLogger(RestClientServiceImpl.class.getName()); + private final HttpClient httpClient; + private final ObjectMapper objectMapper; + + public RestClientServiceImpl(HttpClient httpClient, ObjectMapper objectMapper) { + this.httpClient = httpClient; + this.objectMapper = objectMapper; + } + + @Override + public PokemonDetailResponse getDetailPokemon(String id) { + log.info( "get detail pokemon by id "+id); + try { + //create request + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create("https://pokeapi.co/api/v2/berry/"+id)) + .build(); + //send request to server + HttpResponse stringHttpResponse = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); + + //convert string to dto + return objectMapper.readValue(stringHttpResponse.body(), PokemonDetailResponse.class); + } catch (IOException | InterruptedException e) { + e.printStackTrace(); + log.log(Level.SEVERE, "there is an error "); + throw new RuntimeException(); + } + + } +} From 023d02647291bb72bd4293274ff8b352dcc8af78 Mon Sep 17 00:00:00 2001 From: Basith Nurfaizin Date: Wed, 24 May 2023 07:07:00 +0700 Subject: [PATCH 58/66] add: implementasi java record (#169) Co-authored-by: nurfaizin --- .../javahttpclient/HttpClientMain.java | 5 +++ .../dto/PokemonDetailResponse.java | 4 ++ .../services/RestClientService.java | 3 ++ .../services/RestClientServiceImpl.java | 31 +++++++++++++ .../javarecord/JavaRecordMain.java | 23 ++++++++++ .../learn/intermediate/javarecord/README.md | 27 ++++++++++++ .../learn/intermediate/javarecord/User.java | 4 ++ .../javarecord/recorddto/Firmness.java | 13 ++++++ .../javarecord/recorddto/Flavor.java | 13 ++++++ .../javarecord/recorddto/FlavorsItem.java | 13 ++++++ .../javarecord/recorddto/Item.java | 13 ++++++ .../javarecord/recorddto/NaturalGiftType.java | 13 ++++++ .../recorddto/PokemonRecordResponse.java | 44 +++++++++++++++++++ 13 files changed, 206 insertions(+) create mode 100644 src/main/java/learn/intermediate/javarecord/JavaRecordMain.java create mode 100644 src/main/java/learn/intermediate/javarecord/README.md create mode 100644 src/main/java/learn/intermediate/javarecord/User.java create mode 100644 src/main/java/learn/intermediate/javarecord/recorddto/Firmness.java create mode 100644 src/main/java/learn/intermediate/javarecord/recorddto/Flavor.java create mode 100644 src/main/java/learn/intermediate/javarecord/recorddto/FlavorsItem.java create mode 100644 src/main/java/learn/intermediate/javarecord/recorddto/Item.java create mode 100644 src/main/java/learn/intermediate/javarecord/recorddto/NaturalGiftType.java create mode 100644 src/main/java/learn/intermediate/javarecord/recorddto/PokemonRecordResponse.java diff --git a/src/main/java/learn/intermediate/javahttpclient/HttpClientMain.java b/src/main/java/learn/intermediate/javahttpclient/HttpClientMain.java index 1081ee6..19d0880 100644 --- a/src/main/java/learn/intermediate/javahttpclient/HttpClientMain.java +++ b/src/main/java/learn/intermediate/javahttpclient/HttpClientMain.java @@ -4,6 +4,7 @@ import learn.intermediate.javahttpclient.dto.PokemonDetailResponse; import learn.intermediate.javahttpclient.services.RestClientService; import learn.intermediate.javahttpclient.services.RestClientServiceImpl; +import learn.intermediate.javarecord.recorddto.PokemonRecordResponse; import java.net.http.HttpClient; import java.util.logging.Logger; @@ -20,6 +21,10 @@ public static void main(String[] args) { PokemonDetailResponse detailPokemon = restClientService.getDetailPokemon("1"); + PokemonRecordResponse detailRecord = restClientService.getDetailRecord("1"); + log.info(detailPokemon.toString()); + + log.info(detailRecord.toString()); } } diff --git a/src/main/java/learn/intermediate/javahttpclient/dto/PokemonDetailResponse.java b/src/main/java/learn/intermediate/javahttpclient/dto/PokemonDetailResponse.java index 9bf29af..b693ab2 100644 --- a/src/main/java/learn/intermediate/javahttpclient/dto/PokemonDetailResponse.java +++ b/src/main/java/learn/intermediate/javahttpclient/dto/PokemonDetailResponse.java @@ -5,6 +5,10 @@ import com.fasterxml.jackson.annotation.JsonProperty; import lombok.Data; +/** + * ini merupakan class DTO untuk response detail pokemon + * disini tidak menggunakan getter dan setter karna telah menggunakan anotasi @Data dari Lombok + */ @Data public class PokemonDetailResponse { diff --git a/src/main/java/learn/intermediate/javahttpclient/services/RestClientService.java b/src/main/java/learn/intermediate/javahttpclient/services/RestClientService.java index ab8902e..778e71e 100644 --- a/src/main/java/learn/intermediate/javahttpclient/services/RestClientService.java +++ b/src/main/java/learn/intermediate/javahttpclient/services/RestClientService.java @@ -1,8 +1,11 @@ package learn.intermediate.javahttpclient.services; import learn.intermediate.javahttpclient.dto.PokemonDetailResponse; +import learn.intermediate.javarecord.recorddto.PokemonRecordResponse; public interface RestClientService { PokemonDetailResponse getDetailPokemon(String id); + + PokemonRecordResponse getDetailRecord(String id); } diff --git a/src/main/java/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java b/src/main/java/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java index a6dd88e..f3a3944 100644 --- a/src/main/java/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java +++ b/src/main/java/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java @@ -2,6 +2,7 @@ import com.fasterxml.jackson.databind.ObjectMapper; import learn.intermediate.javahttpclient.dto.PokemonDetailResponse; +import learn.intermediate.javarecord.recorddto.PokemonRecordResponse; import java.io.IOException; import java.net.URI; @@ -22,6 +23,11 @@ public RestClientServiceImpl(HttpClient httpClient, ObjectMapper objectMapper) { this.objectMapper = objectMapper; } + /** + * get data pokemon berdasarkan id + * @param id ini merupakan id dari data pokemon + * @return sebuah record {@link PokemonDetailResponse} object class berisi detail info pokemon + */ @Override public PokemonDetailResponse getDetailPokemon(String id) { log.info( "get detail pokemon by id "+id); @@ -42,4 +48,29 @@ public PokemonDetailResponse getDetailPokemon(String id) { } } + + /** + * get data pokemon berdasarkan id + * @param id ini merupakan id dari data pokemon + * @return sebuah record {@link PokemonRecordResponse} object record berisi detail info pokemon + */ + @Override + public PokemonRecordResponse getDetailRecord(String id) { + log.info( "get detail pokemon with record by id "+id); + try { + //create request + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create("https://pokeapi.co/api/v2/berry/"+id)) + .build(); + //send request to server + HttpResponse stringHttpResponse = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); + + //convert string to dto + return objectMapper.readValue(stringHttpResponse.body(), PokemonRecordResponse.class); + } catch (IOException | InterruptedException e) { + e.printStackTrace(); + log.log(Level.SEVERE, "there is an error "); + throw new RuntimeException(); + } + } } diff --git a/src/main/java/learn/intermediate/javarecord/JavaRecordMain.java b/src/main/java/learn/intermediate/javarecord/JavaRecordMain.java new file mode 100644 index 0000000..5520654 --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/JavaRecordMain.java @@ -0,0 +1,23 @@ +package learn.intermediate.javarecord; + +public class JavaRecordMain { + + public static void main(String[] args) { + + // Creating an instance of the record + User user = new User("test user", "test@mail.com", 21); + + // Accessing the record fields + String name = user.name(); + int age = user.age(); + + System.out.println(name); + System.out.println(age); + System.out.println(user); + + User anotherUser = new User("another user", "another@mail.com", 22); + boolean equals = user.equals(anotherUser); + + System.out.println("are they equals "+equals); + } +} diff --git a/src/main/java/learn/intermediate/javarecord/README.md b/src/main/java/learn/intermediate/javarecord/README.md new file mode 100644 index 0000000..4bcb2d4 --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/README.md @@ -0,0 +1,27 @@ +# Java record + +record merupakan fitur baru yang diperkenalkan pada Java 14. Fitur ini menyediakan cara yang ringkas untuk mendefinisikan kelas-kelas yang digunakan untuk menyimpan data yang tidak dapat diubah (immutable). Record menggabungkan fitur-fitur kelas dan data transfer object (DTO) dengan secara otomatis menghasilkan metode-metode standar seperti konstruktor, getter, equals, hashCode, dan toString. + +## Penggunaan record + +seperti yg sudah dijelaskan record ini cocok digunakan untuk data transfer object (DTO) karna data record ini bersifat immutable. +contoh record bisa di lihat disini +```java +package learn.intermediate.javarecord; + +public record User(String name, String email, int age) { +} +``` +kita juga dapat menambahkan method di dalam record +```java +package learn.intermediate.javarecord; + +public record User(String name, String email, int age) { + + public void test() { + System.out.println("hello"); + } +} +``` + +lalu untuk contoh record yg digunakan sebagai DTO bisa dilihat pada [RestClientServiceImpl.java](/learn/intermediate/javahttpclient/services/RestClientServiceImpl.java) di package javahttpclient \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javarecord/User.java b/src/main/java/learn/intermediate/javarecord/User.java new file mode 100644 index 0000000..3d29902 --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/User.java @@ -0,0 +1,4 @@ +package learn.intermediate.javarecord; + +public record User(String name, String email, int age) { +} diff --git a/src/main/java/learn/intermediate/javarecord/recorddto/Firmness.java b/src/main/java/learn/intermediate/javarecord/recorddto/Firmness.java new file mode 100644 index 0000000..d844bf9 --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/recorddto/Firmness.java @@ -0,0 +1,13 @@ +package learn.intermediate.javarecord.recorddto; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record Firmness( + + @JsonProperty("name") + String name, + + @JsonProperty("url") + String url +) { +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javarecord/recorddto/Flavor.java b/src/main/java/learn/intermediate/javarecord/recorddto/Flavor.java new file mode 100644 index 0000000..c3c7c3e --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/recorddto/Flavor.java @@ -0,0 +1,13 @@ +package learn.intermediate.javarecord.recorddto; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record Flavor( + + @JsonProperty("name") + String name, + + @JsonProperty("url") + String url +) { +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javarecord/recorddto/FlavorsItem.java b/src/main/java/learn/intermediate/javarecord/recorddto/FlavorsItem.java new file mode 100644 index 0000000..0b1dc63 --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/recorddto/FlavorsItem.java @@ -0,0 +1,13 @@ +package learn.intermediate.javarecord.recorddto; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record FlavorsItem( + + @JsonProperty("flavor") + Flavor flavor, + + @JsonProperty("potency") + int potency +) { +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javarecord/recorddto/Item.java b/src/main/java/learn/intermediate/javarecord/recorddto/Item.java new file mode 100644 index 0000000..1b8a501 --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/recorddto/Item.java @@ -0,0 +1,13 @@ +package learn.intermediate.javarecord.recorddto; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record Item( + + @JsonProperty("name") + String name, + + @JsonProperty("url") + String url +) { +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javarecord/recorddto/NaturalGiftType.java b/src/main/java/learn/intermediate/javarecord/recorddto/NaturalGiftType.java new file mode 100644 index 0000000..b1a1a2f --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/recorddto/NaturalGiftType.java @@ -0,0 +1,13 @@ +package learn.intermediate.javarecord.recorddto; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record NaturalGiftType( + + @JsonProperty("name") + String name, + + @JsonProperty("url") + String url +) { +} \ No newline at end of file diff --git a/src/main/java/learn/intermediate/javarecord/recorddto/PokemonRecordResponse.java b/src/main/java/learn/intermediate/javarecord/recorddto/PokemonRecordResponse.java new file mode 100644 index 0000000..b129071 --- /dev/null +++ b/src/main/java/learn/intermediate/javarecord/recorddto/PokemonRecordResponse.java @@ -0,0 +1,44 @@ +package learn.intermediate.javarecord.recorddto; + +import java.util.List; +import com.fasterxml.jackson.annotation.JsonProperty; + +public record PokemonRecordResponse( + + @JsonProperty("flavors") + List flavors, + + @JsonProperty("natural_gift_type") + NaturalGiftType naturalGiftType, + + @JsonProperty("item") + Item item, + + @JsonProperty("smoothness") + int smoothness, + + @JsonProperty("size") + int size, + + @JsonProperty("natural_gift_power") + int naturalGiftPower, + + @JsonProperty("firmness") + Firmness firmness, + + @JsonProperty("name") + String name, + + @JsonProperty("growth_time") + int growthTime, + + @JsonProperty("soil_dryness") + int soilDryness, + + @JsonProperty("id") + int id, + + @JsonProperty("max_harvest") + int maxHarvest +) { +} \ No newline at end of file From 08cbd83030c6e3a684438d6b1a7e3f6a37fb9ecb Mon Sep 17 00:00:00 2001 From: Basith Nurfaizin Date: Mon, 29 May 2023 14:05:22 +0700 Subject: [PATCH 59/66] add: implementasi java jdbc (#170) Co-authored-by: nurfaizin --- pom.xml | 8 + .../learn/advanced/javajdbc/MainJdbc.java | 41 +++++ .../java/learn/advanced/javajdbc/README.md | 58 +++++++ .../advanced/javajdbc/config/JdbcConfig.java | 23 +++ .../advanced/javajdbc/dto/PersonRequest.java | 11 ++ .../advanced/javajdbc/dto/PersonResponse.java | 12 ++ .../learn/advanced/javajdbc/model/Person.java | 65 ++++++++ .../advanced/javajdbc/repository/BaseDao.java | 155 ++++++++++++++++++ .../javajdbc/repository/PersonRepository.java | 102 ++++++++++++ .../javajdbc/service/PersonService.java | 18 ++ .../javajdbc/service/PersonServiceImpl.java | 93 +++++++++++ 11 files changed, 586 insertions(+) create mode 100644 src/main/java/learn/advanced/javajdbc/MainJdbc.java create mode 100644 src/main/java/learn/advanced/javajdbc/README.md create mode 100644 src/main/java/learn/advanced/javajdbc/config/JdbcConfig.java create mode 100644 src/main/java/learn/advanced/javajdbc/dto/PersonRequest.java create mode 100644 src/main/java/learn/advanced/javajdbc/dto/PersonResponse.java create mode 100644 src/main/java/learn/advanced/javajdbc/model/Person.java create mode 100644 src/main/java/learn/advanced/javajdbc/repository/BaseDao.java create mode 100644 src/main/java/learn/advanced/javajdbc/repository/PersonRepository.java create mode 100644 src/main/java/learn/advanced/javajdbc/service/PersonService.java create mode 100644 src/main/java/learn/advanced/javajdbc/service/PersonServiceImpl.java diff --git a/pom.xml b/pom.xml index 5a8d9d7..ff07dde 100644 --- a/pom.xml +++ b/pom.xml @@ -44,6 +44,14 @@ lombok 1.18.24 + + + mysql + mysql-connector-java + 8.0.32 + + + diff --git a/src/main/java/learn/advanced/javajdbc/MainJdbc.java b/src/main/java/learn/advanced/javajdbc/MainJdbc.java new file mode 100644 index 0000000..9c9c40e --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/MainJdbc.java @@ -0,0 +1,41 @@ +package learn.advanced.javajdbc; + +import learn.advanced.javajdbc.dto.PersonRequest; +import learn.advanced.javajdbc.dto.PersonResponse; +import learn.advanced.javajdbc.repository.PersonRepository; +import learn.advanced.javajdbc.service.PersonService; +import learn.advanced.javajdbc.service.PersonServiceImpl; + +import java.util.List; + +public class MainJdbc { + + public static void main(String[] args) { + + PersonRepository repository = new PersonRepository(); + + PersonService personService = new PersonServiceImpl(repository); + + PersonRequest personRequest = new PersonRequest( + "test name", + "test", + "test@mail,com", + "test address", + 23 + ); + + PersonResponse createPerson = personService.create(personRequest); + System.out.println(createPerson.toString()); + + PersonResponse personResponse = personService.getById("776187c2-66c5-4e91-89f9-1dbe89c17bba"); + System.out.println(personResponse.toString()); + + PersonResponse personUpdate = personService.update( personRequest,"776187c2-66c5-4e91-89f9-1dbe89c17bba"); + System.out.println(personUpdate.toString()); + + List personResponses = personService.getAll(); + System.out.println(personResponses.size()); + + + } +} diff --git a/src/main/java/learn/advanced/javajdbc/README.md b/src/main/java/learn/advanced/javajdbc/README.md new file mode 100644 index 0000000..42086f0 --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/README.md @@ -0,0 +1,58 @@ +## Java JDBC +### What +Java Database Connectivity, Ini adalah API (Application Programming Interface) Java yang menyediakan serangkaian kelas dan antarmuka untuk menghubungkan aplikasi Java dengan basis data dan menjalankan pernyataan SQL (Structured Query Language). JDBC memungkinkan program Java berinteraksi dengan berbagai jenis basis data relasional, seperti MySQL, Oracle, PostgreSQL, SQL Server, dan lain-lain. + +### How +Untuk kesempatan ini kita menggunakan MySQL sebagain database, pertama kita perlu import driver mysql terlebih dahulu pada file pom.xml +``` + + mysql + mysql-connector-java + 8.0.32 + +``` + +Setelah itu buat class untuk config connection database nya, sesuaikan config database dengan env sendiri +``` +public class JdbcConfig { + + /** + * @return return connection database + */ + public static Connection connection() { + String url = "jdbc:mysql://localhost:3306/identity"; + String username = "root"; + String password = "test123!"; + + try { + return DriverManager.getConnection(url, username, password); + } catch (SQLException e) { + throw new RuntimeException(e); + } + } +} +``` + +abstract Class BaseDao merupakan contoh base class untuk interaksi dengan Database, untuk query nya tinggal disesuaikan di class yg extends class ini. + +contoh class yg extends BaseDao ini adalah [PersonRepository.java](repository/PersonRepository.java) + +untuk contoh penggunaan repository nya bisa di lihat di class [PersonServiceImpl.class](service/PersonServiceImpl.java) + +contoh penambahan table baru , misal table nya user +- pertama bikin class model misal User.java + ``` + public class User { + + private String userName; + private LocalDateTime createdDate; + //getter & setter + } + ``` +- setelah itu bikin class Repository misal UserRepository.java extend BaseDao dan sesuaikan parameter query nya + ``` + public class UserRepository extends BaseDao { + + //implement all method from BaseDao + } + ``` \ No newline at end of file diff --git a/src/main/java/learn/advanced/javajdbc/config/JdbcConfig.java b/src/main/java/learn/advanced/javajdbc/config/JdbcConfig.java new file mode 100644 index 0000000..c451fd0 --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/config/JdbcConfig.java @@ -0,0 +1,23 @@ +package learn.advanced.javajdbc.config; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +public class JdbcConfig { + + /** + * @return return connection database + */ + public static Connection connection() { + String url = "jdbc:mysql://localhost:3306/identity"; + String username = "root"; + String password = "test123!"; + + try { + return DriverManager.getConnection(url, username, password); + } catch (SQLException e) { + throw new RuntimeException(e); + } + } +} diff --git a/src/main/java/learn/advanced/javajdbc/dto/PersonRequest.java b/src/main/java/learn/advanced/javajdbc/dto/PersonRequest.java new file mode 100644 index 0000000..7c9099e --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/dto/PersonRequest.java @@ -0,0 +1,11 @@ +package learn.advanced.javajdbc.dto; + +/** + * @param firstName + * @param lastName + * @param email + * @param address + * @param age + */ +public record PersonRequest(String firstName, String lastName, String email, String address, int age) { +} diff --git a/src/main/java/learn/advanced/javajdbc/dto/PersonResponse.java b/src/main/java/learn/advanced/javajdbc/dto/PersonResponse.java new file mode 100644 index 0000000..19f247c --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/dto/PersonResponse.java @@ -0,0 +1,12 @@ +package learn.advanced.javajdbc.dto; + +/** + * @param id + * @param firstName + * @param lastName + * @param email + * @param address + * @param age + */ +public record PersonResponse(String id,String firstName, String lastName, String email, String address, int age) { +} diff --git a/src/main/java/learn/advanced/javajdbc/model/Person.java b/src/main/java/learn/advanced/javajdbc/model/Person.java new file mode 100644 index 0000000..4e729b8 --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/model/Person.java @@ -0,0 +1,65 @@ +package learn.advanced.javajdbc.model; + +public class Person { + + private String id; + + private String firstName; + + private String lastName; + + private String email; + + private String address; + + private int age; + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public String getLastName() { + return lastName; + } + + public void setLastName(String lastName) { + this.lastName = lastName; + } + + public String getEmail() { + return email; + } + + public void setEmail(String email) { + this.email = email; + } + + public String getAddress() { + return address; + } + + public void setAddress(String address) { + this.address = address; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + +} diff --git a/src/main/java/learn/advanced/javajdbc/repository/BaseDao.java b/src/main/java/learn/advanced/javajdbc/repository/BaseDao.java new file mode 100644 index 0000000..88a5273 --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/repository/BaseDao.java @@ -0,0 +1,155 @@ +package learn.advanced.javajdbc.repository; + +import learn.advanced.javajdbc.config.JdbcConfig; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +public abstract class BaseDao { + + protected abstract String getInsertQuery(); + protected abstract void setInsertParameters(PreparedStatement statement, T object) throws SQLException; + + protected abstract String getUpdateQuery(); + protected abstract void setUpdateParameters(PreparedStatement statement, T object) throws SQLException; + + protected abstract String getGetQuery(); + protected abstract void setGetParameters(PreparedStatement statement, Object id) throws SQLException; + protected abstract T createObjectFromResultSet(ResultSet resultSet) throws SQLException; + + protected abstract String getDeleteQuery(); + protected abstract void setDeleteParameters(PreparedStatement statement, Object id) throws SQLException; + + protected abstract String getGetAllQuery(); + + + public List findAll() { + List resultList = new ArrayList<>(); + Connection connection = null; + PreparedStatement statement = null; + ResultSet resultSet = null; + + try { + connection = JdbcConfig.connection(); + statement = connection.prepareStatement(getGetAllQuery()); + resultSet = statement.executeQuery(); + + while (resultSet.next()) { + T object = createObjectFromResultSet(resultSet); + resultList.add(object); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + closeResources(resultSet, statement, connection); + } + + return resultList; + } + + public void insert(T object) { + + Connection connection = null; + PreparedStatement statement = null; + try { + connection = JdbcConfig.connection(); + statement = connection.prepareStatement(getInsertQuery()); + setInsertParameters(statement, object); + + int rowsAffected = statement.executeUpdate(); + + if (rowsAffected > 0) { + System.out.println("Insertion successful."); + } else { + System.out.println("Insertion failed."); + } + + }catch (SQLException e) { + e.printStackTrace(); + } finally { + closeResources(statement, connection); + } + } + + public void update(T object) { + + Connection connection = null; + PreparedStatement statement = null; + try { + connection = JdbcConfig.connection(); + statement = connection.prepareStatement(getUpdateQuery()); + setUpdateParameters(statement, object); + + int rowsAffected = statement.executeUpdate(); + + if (rowsAffected > 0) { + System.out.println("Insertion successful."); + } else { + System.out.println("Insertion failed."); + } + + }catch (SQLException e) { + e.printStackTrace(); + } finally { + closeResources(statement, connection); + } + } + + public T get(Object id) { + + Connection connection = null; + PreparedStatement statement = null; + try { + connection = JdbcConfig.connection(); + statement = connection.prepareStatement(getGetQuery()); + setGetParameters(statement, id); + ResultSet resultSet = statement.executeQuery(); + + if (resultSet.next()) { + return createObjectFromResultSet(resultSet); + } + + }catch (SQLException e) { + e.printStackTrace(); + } finally { + closeResources(statement, connection); + } + + return null; + } + + public void delete(Object id) { + Connection connection = null; + PreparedStatement statement = null; + try { + connection = JdbcConfig.connection(); + statement = connection.prepareStatement(getDeleteQuery()); + setDeleteParameters(statement, id); + statement.executeQuery(); + + + }catch (SQLException e) { + e.printStackTrace(); + } finally { + closeResources(statement, connection); + } + + } + + private void closeResources(AutoCloseable... resources) { + for (AutoCloseable resource : resources) { + if (resource != null) { + try { + resource.close(); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + } + +} diff --git a/src/main/java/learn/advanced/javajdbc/repository/PersonRepository.java b/src/main/java/learn/advanced/javajdbc/repository/PersonRepository.java new file mode 100644 index 0000000..5061dd5 --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/repository/PersonRepository.java @@ -0,0 +1,102 @@ +package learn.advanced.javajdbc.repository; + +import learn.advanced.javajdbc.model.Person; + +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +public class PersonRepository extends BaseDao { + + /** + * @return string for insert query + */ + @Override + protected String getInsertQuery() { + return "INSERT INTO person(id,first_name,last_name,email,address,age) VALUES (?,?,?,?,?,?)"; + } + + /** + * @param statement prepared statement for save database + * @param object person object for save to database + * @throws SQLException + */ + @Override + protected void setInsertParameters(PreparedStatement statement, Person object) throws SQLException { + statement.setString(1, object.getId()); + statement.setString(2, object.getFirstName()); + statement.setString(3, object.getLastName()); + statement.setString(4, object.getEmail()); + statement.setString(5, object.getAddress()); + statement.setInt(6, object.getAge()); + } + + /** + * @return string query for update + */ + @Override + protected String getUpdateQuery() { + return "UPDATE person set first_name=?, last_name=?, email=?,address=?, age=? where id=?"; + } + + @Override + protected void setUpdateParameters(PreparedStatement statement, Person object) throws SQLException { + statement.setString(1, object.getFirstName()); + statement.setString(2, object.getLastName()); + statement.setString(3, object.getEmail()); + statement.setString(4, object.getAddress()); + statement.setInt(5, object.getAge()); + statement.setString(6, object.getId()); + } + + @Override + protected String getGetQuery() { + return "SELECT id,first_name,last_name,email,address,age from person where id=?"; + } + + @Override + protected void setGetParameters(PreparedStatement statement, Object id) throws SQLException { + statement.setString(1, id.toString()); + } + + /** + * @param resultSet Result from execute query + * @return object person + * @throws SQLException + */ + @Override + protected Person createObjectFromResultSet(ResultSet resultSet) throws SQLException { + Person person = new Person(); + person.setId(resultSet.getString("id")); + person.setFirstName(resultSet.getString("first_name")); + person.setLastName(resultSet.getString("last_name")); + person.setEmail(resultSet.getString("email")); + person.setAddress(resultSet.getString("address")); + person.setAge(resultSet.getInt("age")); + + return person; + } + + /** + * @return query for delete person by id + */ + @Override + protected String getDeleteQuery() { + return "DELETE FROM person where id=?"; + } + + /** + * @param statement add statement for delete + * @param id param string id person + * @throws SQLException + */ + @Override + protected void setDeleteParameters(PreparedStatement statement, Object id) throws SQLException { + statement.setString(1, id.toString()); + } + + @Override + protected String getGetAllQuery() { + return "SELECT id,first_name,last_name,email,address,age FROM person"; + } +} diff --git a/src/main/java/learn/advanced/javajdbc/service/PersonService.java b/src/main/java/learn/advanced/javajdbc/service/PersonService.java new file mode 100644 index 0000000..f198b89 --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/service/PersonService.java @@ -0,0 +1,18 @@ +package learn.advanced.javajdbc.service; + +import learn.advanced.javajdbc.dto.PersonRequest; +import learn.advanced.javajdbc.dto.PersonResponse; + +import java.util.List; + +public interface PersonService { + + List getAll(); + PersonResponse create(PersonRequest request); + + PersonResponse getById(String id); + + PersonResponse update(PersonRequest request, String id); + + void delete(String id); +} diff --git a/src/main/java/learn/advanced/javajdbc/service/PersonServiceImpl.java b/src/main/java/learn/advanced/javajdbc/service/PersonServiceImpl.java new file mode 100644 index 0000000..5ceeb06 --- /dev/null +++ b/src/main/java/learn/advanced/javajdbc/service/PersonServiceImpl.java @@ -0,0 +1,93 @@ +package learn.advanced.javajdbc.service; + +import learn.advanced.javajdbc.dto.PersonRequest; +import learn.advanced.javajdbc.dto.PersonResponse; +import learn.advanced.javajdbc.model.Person; +import learn.advanced.javajdbc.repository.PersonRepository; + +import java.util.List; +import java.util.UUID; +import java.util.stream.Collectors; + +public class PersonServiceImpl implements PersonService { + + private final PersonRepository personRepository; + + public PersonServiceImpl(PersonRepository personRepository) { + this.personRepository = personRepository; + } + + /** + * @return list of PersonResponse + */ + @Override + public List getAll() { + + List personList = personRepository.findAll(); + + return personList.stream() + .map(this::convertToResponse) + .collect(Collectors.toList()); + } + + /** + * @param request a record for dto person + * @return object response + */ + @Override + public PersonResponse create(PersonRequest request) { + + Person person = new Person(); + person.setId(UUID.randomUUID().toString()); + person.setFirstName(request.firstName()); + person.setLastName(request.lastName()); + person.setEmail(request.email()); + person.setAddress(request.address()); + person.setAge(request.age()); + + personRepository.insert(person); + + return convertToResponse(person); + } + + /** + * @param id id of person + * @return object PersonResponse + */ + @Override + public PersonResponse getById(String id) { + Person person = personRepository.get(id); + + return convertToResponse(person); + } + + @Override + public PersonResponse update(PersonRequest request, String id) { + Person person = personRepository.get(id); + person.setFirstName(request.firstName()); + person.setLastName(request.lastName()); + person.setEmail(request.email()); + person.setAddress(request.address()); + person.setAge(request.age()); + + personRepository.update(person); + + return convertToResponse(person); + } + + @Override + public void delete(String id) { + personRepository.delete(id); + } + + private PersonResponse convertToResponse(Person person) { + return new PersonResponse( + person.getId(), + person.getFirstName(), + person.getLastName(), + person.getEmail(), + person.getAddress(), + person.getAge() + ); + } +} From cef8043b157b42a694b5a3e14332ce33b2e349b1 Mon Sep 17 00:00:00 2001 From: Kevin Reynaufal <72794552+kvnrynfl@users.noreply.github.com> Date: Tue, 5 Sep 2023 00:32:28 +0700 Subject: [PATCH 60/66] docs: menambahkan dokumentasi java swing (#171) --- .../learn/advanced/JavaGUI/Swing/README.md | 53 +++++++++++++++---- 1 file changed, 43 insertions(+), 10 deletions(-) diff --git a/src/main/java/learn/advanced/JavaGUI/Swing/README.md b/src/main/java/learn/advanced/JavaGUI/Swing/README.md index 8437576..4a00296 100644 --- a/src/main/java/learn/advanced/JavaGUI/Swing/README.md +++ b/src/main/java/learn/advanced/JavaGUI/Swing/README.md @@ -4,17 +4,50 @@ Pada materi ini berisikan tentang apa-apa saja yang ada di Swing Java ini. Ngomg Swing adalah sebuah GUI Toolkit dalam Java. Toolkit ini adalah bentuk _standard_ dari Java sehingga tidak perlu melakukan penambahan library lagi kalau ingin menggunakan GUI Toolkit ini. Dibandingkan dengan Toolkit lain, Swing mempunyai lebih banyak komponen pendukung untuk membangun sebuah aplikasi yang lengkap untuk keperluan desktop. Swing ini 100 % ditulis dengan bahasa pemrograman Java tanpa adanya sebuah wrapper untuk memanggil rutin-rutin native code via JNI (Java Native Interface). Seluruh komponen yang terdapat pada Swing, semuanya murni digambar sendiri menggunakan API (Application Programming Interface) 2D untuk memanggil rutin-rutin dasar penggambaran komponen-nya. Dengan model seperti ini, memungkinkan sekali aplikasi yang dibangun menggunakan Swing tampak sama persis di berbagai macam Sistem Operasi.Swing juga mempunyai kemampuan untuk berganti-ganti tampilan menggunakan LAF (Look And Feel) atau themes Sayang-nya, jika kita menginginkan tampilan GUI yang native (tampilan-nya sama seperti aplikasi-aplikasi lain pada sistem operasi target) Swing seperti-nya masih terasa kurang smooth terutama dukungan pada font rendering-nya. ### Komponen-Komponen Swing -1. JPanel -JPanel adalah salah satu komponen swing pertama dan dasar dikarenakan JPanel ini lah adalah hasil GUI yang nanti akan dikeluarkan. JPanel memiliki komponen-komponen cabang antara lain JLabel, JButton, JList dan lain-lain yanng berada di bawah ini. +1. JFrame: +JFrame adalah komponen utama dalam aplikasi Swing yang mewakili jendela aplikasi. Ini adalah tempat di mana komponen-komponen lain ditempatkan. Anda dapat mengatur tampilan jendela, judul, ukuran, dan perilaku lainnya. -2. JLabel -JLabel adalah JLabel merupakan komponen yang digunakan untuk menampilkan teks yang pendek. JLabel juga digunakan untuk menampilkan icon (gambar berukuran kecil) atau menampilkan icon dan teks. JLabel merupakan sub kelas dari JFrame +2. JPanel +JPanel adalah wadah atau kontainer yang digunakan untuk mengelompokkan dan mengatur komponen-komponen lain dalam jendela JFrame. Ini sering digunakan untuk mengatur tata letak dalam antarmuka pengguna. -3. JButton -JButton berguna untuk membuat objek tombol yg dapat dilengkapi dengan judul tombol maupun ikon. +3. JButton: +JButton adalah tombol yang dapat diklik oleh pengguna. Ini digunakan untuk memicu tindakan tertentu ketika tombol tersebut ditekan. -4. JCheckbox -JCheckBox digunakan untuk memilih salah satu pilihan di antara dua kemungkinan. +4. JLabel: +JLabel adalah komponen teks non-interaktif yang digunakan untuk menampilkan teks atau gambar sebagai label atau keterangan di antarmuka pengguna. -5. JRadioButton -JRadioButton digunakan untuk menampilkan pilihan yang dimana terdapat ButtonGroup digunakan untuk membuat pemakai hanya bisa memilih salah satu dari sejumlah tombol radio. \ No newline at end of file +5. JTextField: +JTextField adalah komponen input teks yang memungkinkan pengguna untuk memasukkan teks. Ini sering digunakan untuk mengumpulkan data dari pengguna. + +6. JTextArea: +JTextArea adalah komponen input teks yang lebih besar dan multi-baris dibandingkan JTextField. Ini cocok untuk memasukkan teks yang panjang atau beberapa baris. + +7. JComboBox: +JComboBox adalah komponen dropdown yang memungkinkan pengguna memilih satu opsi dari daftar yang disediakan. Ini sering digunakan untuk memilih dari kategori atau daftar pilihan. + +8. JCheckBox: +JCheckBox adalah kotak centang yang digunakan untuk memungkinkan pengguna memilih beberapa pilihan dari sejumlah pilihan yang tersedia. + +9. JRadioButton: +JRadioButton digunakan untuk menampilkan pilihan yang dimana terdapat ButtonGroup digunakan untuk membuat pemakai hanya bisa memilih salah satu dari sejumlah tombol radio. + +10. JList: +JList adalah komponen untuk menampilkan daftar elemen dalam satu atau lebih kolom. Ini sering digunakan untuk menampilkan daftar item yang dapat dipilih. + +11. JSplitPane: +JSplitPane adalah komponen yang memungkinkan pembagian area tampilan menjadi dua panel yang dapat diubah ukurannya. Ini sering digunakan dalam aplikasi yang memerlukan tampilan terbagi. + +12. JScrollPane: +JScrollPanel adalah komponen yang digunakan untuk mengelola komponen-komponen lain, seperti JList atau JTextArea, yang mungkin memerlukan bilah geser jika kontennya terlalu besar untuk ditampilkan sepenuhnya. + +13. JMenuBar: +JMenuBar adalah komponen yang berisi menu dan submenu. Ini digunakan untuk membuat menu bar di bagian atas jendela aplikasi. + +14. JMenu: +JMenu adalah komponen yang berisi daftar pilihan yang muncul saat pengguna mengklik item menu di JMenuBar. + +15. JMenuItem: +JMenuItem adalah item individu dalam JMenu yang mewakili tindakan yang dapat diambil oleh pengguna. + +16. JDialog: +JDialog adalah jendela dialog yang muncul di atas JFrame. Ini digunakan untuk menampilkan pesan atau mengumpulkan masukan dari pengguna. From 7dcd22246cb1e13416c1c5ba062c2a769660ca08 Mon Sep 17 00:00:00 2001 From: Kevin Reynaufal <72794552+kvnrynfl@users.noreply.github.com> Date: Tue, 5 Sep 2023 18:17:32 +0700 Subject: [PATCH 61/66] add: menambahkan program JTextField with JPanel (#172) --- .../JTextFieldJPanel.java | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 src/main/java/learn/advanced/JavaGUI/Swing/JPanelWithJTextField/JTextFieldJPanel.java diff --git a/src/main/java/learn/advanced/JavaGUI/Swing/JPanelWithJTextField/JTextFieldJPanel.java b/src/main/java/learn/advanced/JavaGUI/Swing/JPanelWithJTextField/JTextFieldJPanel.java new file mode 100644 index 0000000..9daf7ee --- /dev/null +++ b/src/main/java/learn/advanced/JavaGUI/Swing/JPanelWithJTextField/JTextFieldJPanel.java @@ -0,0 +1,41 @@ +package learn.advanced.JavaGUI.Swing.JPanelWithJTextField; + +import javax.swing.*; +import java.awt.*; + +public class JTextFieldJPanel { + public static void main(String[] args) { + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + createAndShowGUI(); + } + }); + } + + private static void createAndShowGUI() { + // Membuat sebuah JFrame (jendela aplikasi) + JFrame frame = new JFrame("Ini adalah JFrame"); + // Mengatur operasi default ketika tombol X di jendela diklik + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + // Mengatur posisi dan ukuran jendela + frame.setBounds(20, 30, 300, 100); + // Menggunakan layout null untuk mengatur posisi elemen secara bebas + frame.setLayout(null); + + // Membuat JTextField (form input teks) + JTextField textField = new JTextField(); + // Mengatur jenis font, style, dan ukuran teks di dalam JTextField + textField.setFont(new Font("Arial", Font.BOLD, 18)); + // Memungkinkan pengeditan teks di dalam JTextField + textField.setEditable(true); + // Mengatur teks yang dimasukkan ke dalam JTextField akan muncul di sebelah kanan + textField.setHorizontalAlignment(JTextField.RIGHT); + // Mengatur posisi dan ukuran JTextField + textField.setBounds(20, 20, 200, 20); + // Menambahkan JTextField ke dalam konten pane jendela + frame.getContentPane().add(textField); + // Menampilkan jendela + frame.setVisible(true); + } +} \ No newline at end of file From d87f7c9629a2e4bd836b2f6ff8953a1e3212614b Mon Sep 17 00:00:00 2001 From: Fajar Susilo Date: Tue, 21 Nov 2023 12:30:22 +0700 Subject: [PATCH 62/66] docs: perbaiki salah ketik (#173) memperbaiki salah ketik dari keil ke kecil --- src/main/java/learn/basic/TipeData/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/learn/basic/TipeData/README.md b/src/main/java/learn/basic/TipeData/README.md index 3557fdf..10c0577 100644 --- a/src/main/java/learn/basic/TipeData/README.md +++ b/src/main/java/learn/basic/TipeData/README.md @@ -17,7 +17,7 @@ tipe data adalah value dengan jenis tertentu yang sangat berguna mempermudah dal - byte - byte adalah tipe data integer yang memiliki panjang value dari ``-128`` sampai ``127``. penggunaan byte bisa untuk nilai2 yang keil dikarenakan lebih hemat pada penggunanaan memori. + byte adalah tipe data integer yang memiliki panjang value dari ``-128`` sampai ``127``. penggunaan byte bisa untuk nilai2 yang kecil dikarenakan lebih hemat pada penggunanaan memori. - short From 76530be61adae14521f5975b2920f4ea792cb10e Mon Sep 17 00:00:00 2001 From: Saut Manurung <68042498+sautmanurung1@users.noreply.github.com> Date: Sun, 3 Mar 2024 22:42:06 +0700 Subject: [PATCH 63/66] Update CODEOWNERS --- .github/CODEOWNERS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 2706122..b705270 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -5,4 +5,4 @@ # the repo. Unless a later match takes precedence, # @global-owner1 and @global-owner2 will be requested for # review when someone opens a pull request. -* @random-prog @slowy07 @sautmanurung1 @bhimsur @fairusatoir +* @dean-fahreza @slowy07 @sautmanurung1 @bhimsur @fairusatoir From 5cb1d2041356826c48dcf618803360f2a5258596 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Tue, 1 Oct 2024 02:38:49 +0700 Subject: [PATCH 64/66] fix: merubah model dari konversi biner ke bilangan desimal (#175) fix ini juga mengandung - penambahan formatter - menghapus classpath dan factorypath Signed-off-by: slowy07 --- .classpath | 44 ------------------- .factorypath | 6 --- .github/workflows/formatter.yml | 17 +++++++ .gitignore | 2 + .../conversions/BinaryToDecimal.java | 44 +++++++++++-------- .../conversion/BinaryToDecimalTest.java | 29 ++++++++++++ 6 files changed, 73 insertions(+), 69 deletions(-) delete mode 100644 .classpath delete mode 100644 .factorypath create mode 100644 .github/workflows/formatter.yml create mode 100644 src/test/java/algorithm/conversion/BinaryToDecimalTest.java diff --git a/.classpath b/.classpath deleted file mode 100644 index 4ae9a46..0000000 --- a/.classpath +++ /dev/null @@ -1,44 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/.factorypath b/.factorypath deleted file mode 100644 index 99c5f80..0000000 --- a/.factorypath +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - diff --git a/.github/workflows/formatter.yml b/.github/workflows/formatter.yml new file mode 100644 index 0000000..d339970 --- /dev/null +++ b/.github/workflows/formatter.yml @@ -0,0 +1,17 @@ +name: formatter java + +on: [push, pull_request] + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - name: setting action + uses: actions/checkout@v4 + - name: using formatter dari clang + uses: DoozyX/clang-format-lint-action@v0.18 + with: + source: './src' + extensions: 'java' + clangFormatVersion: 16 \ No newline at end of file diff --git a/.gitignore b/.gitignore index 102b6f8..118441a 100644 --- a/.gitignore +++ b/.gitignore @@ -36,3 +36,5 @@ build/ .factorypath .project +*.classpath +*.factorypath diff --git a/src/main/java/algorithm/conversions/BinaryToDecimal.java b/src/main/java/algorithm/conversions/BinaryToDecimal.java index 9fa9e65..f896042 100644 --- a/src/main/java/algorithm/conversions/BinaryToDecimal.java +++ b/src/main/java/algorithm/conversions/BinaryToDecimal.java @@ -1,26 +1,32 @@ package algorithm.conversions; -// memanggil modul input -import java.util.Scanner; - public class BinaryToDecimal{ - public static void main(String[] args){ - // membuat input - Scanner input = new Scanner(System.in); - int BinaryNumber, BinCopy, d, s = 0, power = 0; - - System.out.print("masukkan angka biner: "); - BinaryNumber = input.nextInt(); + private static final int BASE_BINER = 2; + + private BinaryToDecimal() { + + } + + /** + * fungsi mengubah angka biner ke angka desimal + * + * @param angkaBiner angka biner yang akan dikonversikan + * @return hasil dari konversi angka biner ke angka desimal + * @throws IllegalArgumentException ini terjadi jika angka biner tidak terdapat angka 0 atau 1 + */ - // copy angka biner ke variabel baru - BinCopy = BinaryNumber; + public static long binerKeDesimal(long angkaBiner) { + long valueDesimal = 0; + long pangkat = 0; - while(BinCopy != 0){ - // BinCopy % 10 / 2 - d = BinCopy % 10; - s += d * (int) Math.pow(2, power++); - BinCopy /= 10; + while (angkaBiner != 0) { + long digit = angkaBiner % 10; + if (digit > 1) { + throw new IllegalArgumentException("angka biner tidak benar: " + digit); + } + valueDesimal += (long) (digit * Math.pow(BASE_BINER, pangkat++)); + angkaBiner /= 10; } - System.out.println("desimalnya: " + s); - } + return valueDesimal; + } } diff --git a/src/test/java/algorithm/conversion/BinaryToDecimalTest.java b/src/test/java/algorithm/conversion/BinaryToDecimalTest.java new file mode 100644 index 0000000..de26b85 --- /dev/null +++ b/src/test/java/algorithm/conversion/BinaryToDecimalTest.java @@ -0,0 +1,29 @@ +package algorithm.conversion; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import algorithm.conversions.BinaryToDecimal; + +public class BinaryToDecimalTest { + @Test + public void testBinaryToDecimal() { + assertEquals(0, BinaryToDecimal.binerKeDesimal(0)); + assertEquals(512,BinaryToDecimal.binerKeDesimal(1000000000)); + } + + @Test + public void testAngkaNegatif() { + assertEquals(-1, BinaryToDecimal.binerKeDesimal(-1)); + } + + @ParameterizedTest + @CsvSource({"2", "1234", "11112", "101021"}) + void testAngkaBinerSalah(long angkaBiner) { + assertThrows(IllegalArgumentException.class, () -> BinaryToDecimal.binerKeDesimal(angkaBiner)); + } +} From 8ecf90ed1b3d1d1df2f381ec2e9e9afea39b0f15 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Tue, 1 Oct 2024 12:57:59 +0700 Subject: [PATCH 65/66] feat: menambahkan contoh angka armstrong (#176) Signed-off-by: slowy07 --- pom.xml | 6 ++++ src/main/java/maths/AngkaArmstrong.java | 31 +++++++++++++++++++++ src/test/java/maths/AngkaArmstrongTest.java | 14 ++++++++++ 3 files changed, 51 insertions(+) create mode 100644 src/main/java/maths/AngkaArmstrong.java create mode 100644 src/test/java/maths/AngkaArmstrongTest.java diff --git a/pom.xml b/pom.xml index ff07dde..f72638f 100644 --- a/pom.xml +++ b/pom.xml @@ -38,6 +38,12 @@ com.fasterxml.jackson.core jackson-databind 2.13.4.2 + + + org.assertj + assertj-core + 3.11.1 + test org.projectlombok diff --git a/src/main/java/maths/AngkaArmstrong.java b/src/main/java/maths/AngkaArmstrong.java new file mode 100644 index 0000000..19816fc --- /dev/null +++ b/src/main/java/maths/AngkaArmstrong.java @@ -0,0 +1,31 @@ +package maths; + +public class AngkaArmstrong { + /** + * Mengecek angka yang dimana angka tersebut angka itu armstrong atau tidak + * + * @param angka angka yang di cek + * @return {@code true} jika nilai yang diberikan adalah angka amstrong + */ + public boolean adalahArmstrong(int angka) { + long hasil = 0; + String temp = Integer.toString(angka); + int pangkat = temp.length(); + long angkaOriginal = angka; + + // perulangan akan berjalan selama angkaOriginal lebih besar dari 0 + while (angkaOriginal > 0) { + // mengambil digit terakhir dari angkaOriginal + long digit = angkaOriginal % 10; + // menambahkan hasil pangkat dari digit ke variabel 'hasil' + // Math.pow() digunakan ini untuk menghitung digit pangkat + hasil += (long) Math.pow(digit, pangkat); + // menghapus digit terakhir dari angkaOriginal + angkaOriginal /= 10; + } + + // membandingkan hasil dengan angka asli + // jika sama maka angka adalah bilangan armstrong + return hasil == angka; + } +} diff --git a/src/test/java/maths/AngkaArmstrongTest.java b/src/test/java/maths/AngkaArmstrongTest.java new file mode 100644 index 0000000..e838ef8 --- /dev/null +++ b/src/test/java/maths/AngkaArmstrongTest.java @@ -0,0 +1,14 @@ +package maths; + +import static org.assertj.core.api.Assertions.assertThat; +import org.junit.jupiter.api.Test; + +class AngkaArmstrongTest { + @Test + void testAdalahAngkaArmstrong() { + AngkaArmstrong armstrong = new AngkaArmstrong(); + assertThat(armstrong.adalahArmstrong(0)).isTrue(); + assertThat(armstrong.adalahArmstrong(200)).isFalse(); + assertThat(armstrong.adalahArmstrong(371)).isTrue(); + } +} From 5fea89dde0c562a46bc70a7430c10d6e384a63e5 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Sat, 5 Oct 2024 10:26:46 +0700 Subject: [PATCH 66/66] feat: menambahkan algoritma Konvolusi (#177) Signed-off-by: slowy07 --- src/main/java/algorithm/math/Konvolusi.java | 30 +++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 src/main/java/algorithm/math/Konvolusi.java diff --git a/src/main/java/algorithm/math/Konvolusi.java b/src/main/java/algorithm/math/Konvolusi.java new file mode 100644 index 0000000..349b3cb --- /dev/null +++ b/src/main/java/algorithm/math/Konvolusi.java @@ -0,0 +1,30 @@ +package algorithm.math; + +/** + * @brief contoh implementasi dari dua diskret sinyal + */ +public final class Konvolusi { + private Konvolusi() {} + + /** + * @brief fungsi konvolusi yang memberikan dua input sinyal + * @param angkaPertama nilai diskret sinyal pertama + * @param angkaKedua nilai diskret sinyal kedua + * @return sinyal konvolusi + */ + public static double[] konvolusi(double[] angkaPertama, double[] angkaKedua) { + double[] konvolu = new double[angkaPertama.length + angkaKedua.length - 1]; + + for (int i = 0; i < konvolu.length; i++) { + konvolu[i] = 0; + int k = Math.max(i - angkaKedua.length + 1, 0); + + while (k < i + 1 && k < angkaPertama.length) { + konvolu[i] += angkaPertama[k] * angkaKedua[i - k]; + k++; + } + } + + return konvolu; + } +}