. .

TUGAS & LATIHAN:  Bahasa Pemrograman JAVA Netbeans IDE MengKonversi JAVA STRING dengan 5 Cara Berbeda 

Posted by CHRISTIANTO D,WIBOWO | D3MI-2016 STMIK BUMI GORA On Kamis, Desember 08, 2016 No comments

07 December 2016, Kita mendapat tugas bagaimana mengkonversi String yang diberikan kedalam case yang berbeda menggunakan looping sederhana dan metode dari kelas String dan kelas Character. 
Pertama, kita jelas menentukan apa kasus-kasus yang berbeda tersebut. Kemudian, kita melanjutkan untuk melihat metode yang berbeda dari karakter dan kelas String yang akan kita gunakan,
Kedua, kita lanjutkan ke algoritma. 
Ketiga, kita menyajikan program yang lengkap yang membutuhkan masukan String dan output dalam lima kasus yang berbeda.
1. Upper Case :
Sebuah String diubah menjadi Upper Case dengan memanfaatkan masing-masing huruf. Huruf yang sudah dikapitalisasi dibiarkan sebagaimana adanya. Non huruf seperti angka dan karakter khusus tidak diubah.
2. Lower Case :
Konversi String ke Lower Case mirip dengan Upper Case kecuali bahwa kita mengubah masing-masing huruf kepada bentuk kasus yang lebih rendah - Lower Case.
3. Toggle Case :

huruf kecil a-z dikonversi ke huruf A-Z dan sebaliknya.
4. Camel Case:
Dalam Camel Case, huruf pertama dari setiap kata dikapitalisasi.
5. Sentence Case:
Huruf mulai dari kata pertama dari setiap kalimat dikapitalisasi.
Ini adalah contoh yang menggambarkan konversi dari String ke lima kasus yang berbeda yang disebutkan di atas.
Masukkan String Kalimat : gemBLOnG LaGi huNTINg ceWE, yANG canTIK dAN jUGa bAIK, taPI GaK lEBay !
MENGKONVERSI STRING DENGAN 5 CARA BERBEDA
-----------------------------------------
Upper Case  : GEMBLONG LAGI HUNTING CEWE, YANG CANTIK DAN JUGA BAIK, TAPI GAK LEBAY !
Lower Case  : gemblong lagi hunting cewe, yang cantik dan juga baik, tapi gak lebay !
Toggle Case : GEMbloNg lAgI HUntinG CEwe, Yang CANtik Dan JugA Baik, TApi gAk LebAY !
Camel Case  : Gemblong Lagi Hunting Cewe, Yang Cantik Dan Juga Baik, Tapi Gak Lebay !
Title Case     : Gemblong lagi hunting cewe, yang cantik dan juga baik, tapi gak lebay !
Methods of String and Character classes 
Kita akan menggunakan metode length() dan charAt(int) dari kelas String. Metode length() mengembalikan jumlah karakter yang berisi String. Metode charAt(int) mengambil argumen integer dan mengembalikan karakter yang terdapat pada indeks integer. Perlu dicatat bahwa indeks mulai dari 0,  contoh potongan kode berikut menggambarkan penggunaan dua metode ini.
String s = "Java";
int len = s.length(); // len = 4
char c0 = s.charAt(0); // c0 = 'J'
char c2 = s.charAt(2); // c2 = 'v'
Kelas Karakter berisi sejumlah metode statis yang dapat digunakan untuk menguji apakah karakter adalah huruf besar atau huruf kecil (upper case or lower case) dan juga mengkonversi antara dua bentuk tersebut. Kedua metode UpperCase (char) dan LowerCase (char) mengambil karakter sebagai argumen dan mengembalikan nilai boolean yang menunjukkan apakah argumen berlalu merupakan char upper case atas atau char lower case. Metode toUpperCase (char) dan toLowerCase (char) mengambil argumen char dan kembali char yang merupakan bentuk huruf besar dan bentuk huruf kecil dari char masing-masing. Jika karakter yang dilalui/proses bukan huruf, nilai akan kembali dan akan sama dengan karakter yang dilalui/proses. Berikut ini adalah contoh potongan kode yang menggambarkan penggunaan metode tersebut di atas.
boolean a = Character.isUpperCase('A'); // true
boolean b = Character.isLowerCase('A'); // false
boolean c = Character.isUpperCase('<'); // false
boolean d = Character.isLowerCase('<'); // false
char e = Character.toLowerCase('A'); // 'a'
char f = Character.toUpperCase('a'); // 'A'
char g = Character.toLowerCase('<'); // '<'
char h = Character.toLowerCase('a'); // 'a'
Converting a String to Upper Case 
Untuk mengkonversi String ke Upper Case, kita menggunakan loop yang mengkounter,  berjalan dari 0 hingga panjang String (-1). Sebuah String variabel 'result' yang dijalankan dengan String kosong. Dalam loop, kita mengekstrak karakter pada posisi i, mengubahnya menjadi huruf besar menggunakan metode toUpperCase () dan menambahkan char kembali ke hasilnya. Pada akhir loop, hasilnya berisi input string dengan semua karakter diubah menjadi huruf besar.
Source Code Clip :
public static String toUpperCase(String inputString) {
       System.out.println("MENGKONVERSI STRING DENGAN 5 CARA BERBEDA");
       System.out.println("-----------------------------------------");
       String result = "";
       for (int i = 0; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           char currentCharToUpperCase = Character.toUpperCase(currentChar);
           result = result + currentCharToUpperCase;
       }
       return result;
   }
Converting a String to Lower Case
Tugas ini akan sama dengan di atas,  kita menggunakan metode toLowerCase () untuk mengubah karakter untuk bentuk kasus mereka lebih rendah.
Source Code Clip :
public static String toLowerCase(String inputString) {
       String result = "";
       for (int i = 0; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           char currentCharToLowerCase = Character.toLowerCase(currentChar);
           result = result + currentCharToLowerCase;
       }
       return result;
   }
Converting a String to Toggle Case
Untuk mengkonversi String ke bentuk beralih - toggle form, kita ekstrak masing-masing karakter seperti yang telah kita lakukan untuk konversi huruf besar dan kecil - upper case conversion.. Kita kemudian menggunakan sebuah pernyataan jika pengambilan keputusan lain untuk memeriksa apakah karakter diekstraksi adalah huruf besar atau huruf kecil. Jika karakter adalah huruf besar, kami mengubahnya menjadi huruf kecil dan menambahkan ke hasilnya. Jika tidak, bentuk huruf dari karakter ditambahkan ke hasilnya. Lihat kode di bagian bawah, kita tidak dapat menggunakan if else if statement untuk membuat keputusan pernyataan seperti yang ditunjukkan di bawah ini.
if (Character.isUpperCase(currentChar)) {
   ...
} else if (Character.isLowerCase(currentChar)) {
   ...
Hal ini karena ada kemungkinan untuk karakter menjadi tidak huruf besar atau huruf kecil - angka dan simbol-simbol khusus seperti <,> dll Jika pengambilan keputusan pernyataan seperti yang ditunjukkan di atas digunakan, karakter ini akan diabaikan.
Tentu saja, bentuk modifikasi dari kode di atas dapat digunakan di mana kita harus pertama kali memeriksa apakah karakter adalah karakter huruf. Kemudian kita memeriksa apakah itu adalah karakter huruf kecil. Dan akhirnya, jika karakter bukan merupakan karakter huruf besar atau karakter huruf kecil, kita hanya menambahkan ke hasil tanpa konversi.
if (Character.isUpperCase(currentChar)) { // Upper Case
   char currentCharToLowerCase = Character.toLowerCase(currentChar);
   result = result + currentCharToLowerCase;
} else if (Character.isLowerCase(currentChar)) { // Lower Case
   char currentCharToUpperCase = Character.toUpperCase(currentChar);
   result = result + currentCharToUpperCase;
} else { // Not a letter
   result = result + currentChar;
}
Source Code Clip :
public static String toToggleCase(String inputString) {
       String result = "";
       for (int i = 0; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           if (Character.isUpperCase(currentChar)) {
               char currentCharToLowerCase = Character.toLowerCase(currentChar);
               result = result + currentCharToLowerCase;
           } else {
               char currentCharToUpperCase = Character.toUpperCase(currentChar);
               result = result + currentCharToUpperCase;
           }
       }
       return result;
   }
Converting a String to Camel Case
Seperti yang sudah dikatakan, dalam camel case, kita memanfaatkan huruf pertama dari setiap kata. Untuk melakukannya, kita menggunakan loop mirip dengan apa yang telah kita digunakan dalam konversi sebelumnya. Dalam loop, kita memeriksa apakah karakter pada indeks i-1 adalah spasi. Jika sudah demikian, kita memanfaatkan karakter saat pada indeks i dan menambahkan ke hasilnya. Jika tidak, kita mengubah char saat ini untuk menurunkan kasus dan menambahkannya.
Namun, kita akan mengalami masalah ketika loop tabel memiliki nilai nol sebagai akses karakter pada indeks (0-1) akan menghasilkan pengecualian. Untuk menghindari hal ini, sebelum loop, kita periksa jika panjang string masukan adalah nol. Jika sudah demikian, kita hanya mengembalikan String kosong. Jika tidak, kita menginisialisasinya hasilnya dengan versi dikapitalisasi karakter pada indeks nol dan kemudian mulai loop dari i = 1.
Source Code Clip :
public static String toCamelCase(String inputString) {
       String result = "";
       if (inputString.length() == 0) {
           return result;
       }
       char firstChar = inputString.charAt(0);
       char firstCharToUpperCase = Character.toUpperCase(firstChar);
       result = result + firstCharToUpperCase;
       for (int i = 1; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           char previousChar = inputString.charAt(i - 1);
           if (previousChar == ' ') {
               char currentCharToUpperCase = Character.toUpperCase(currentChar);
               result = result + currentCharToUpperCase;
           } else {
               char currentCharToLowerCase = Character.toLowerCase(currentChar);
               result = result + currentCharToLowerCase;
           }
       }
       return result;
   }
Converting a String to Sentence Case
Dalam  sentence case, huruf pertama dari setiap kalimat dikapitalisasi. konversi ini tidak dapat diselesaikan dengan cara yang mirip dengan masalah camel case, menggantikan ruang dengan periode. Alasannya adalah bahwa kalimat tidak selalu berakhir dalam suatu periode. Kalimat juga diakhiri dengan tanda tanya dan tanda seru. Alasan kedua adalah bahwa huruf pertama kalimat tidak selalu segera mengikuti periode. Dalam kebanyakan kasus, ada spasi antara dua kata.

Untuk mengatasi masalah di atas, kita mempertahankan sebuah array karakter terminal - karakter dengan yang kalimat berakhir seperti periode, tanda seru dan tanda tanya. Kita juga akan menggunakan variabel boolean 'terminalCharacterEncountered' yang akan diatur ke benar setiap kali salah satu karakter terminal ditemui. Dalam loop, pertama kita mengekstrak karakter, jika bendera/flags terminalCharacterEncountered adalah false/salah, kita menambahkan karakter ke String output. Jika bendera/flags terminalCharacterEncountered adalah true/benar, karakter saat dikapitalisasi dan ditambahkan ke hasilnya. Dan kemudian, bendera/flags reset ke false. Setelah melakukan tugas di atas, kita memeriksa apakah karakter saat ini adalah salah satu karakter terminal. Jika demikian, bendera/flags diatur ke benar lagi sehingga karakter pertama dari kalimat berikutnya akan dikapitalisasi.
Source Code Clip :
public static String toSentenceCase(String inputString) {
       String result = "";
       if (inputString.length() == 0) {
           return result;
       }
       char firstChar = inputString.charAt(0);
       char firstCharToUpperCase = Character.toUpperCase(firstChar);
       result = result + firstCharToUpperCase;
       boolean terminalCharacterEncountered = false;
       char[] terminalCharacters = {'.', '?', '!'};
       for (int i = 1; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           if (terminalCharacterEncountered) {
               if (currentChar == ' ') {
                   result = result + currentChar;
               } else {
                   char currentCharToUpperCase = Character.toUpperCase(currentChar);
                   result = result + currentCharToUpperCase;
                   terminalCharacterEncountered = false;
               }
           } else {
               char currentCharToLowerCase = Character.toLowerCase(currentChar);
               result = result + currentCharToLowerCase;
           }
           for (int j = 0; j < terminalCharacters.length; j++) {
               if (currentChar == terminalCharacters[j]) {
                   terminalCharacterEncountered = true;
                   break;
               }
           }
       }
       return result;
   }


Berikut adalah source code program java yang mengambil String input dari user, dan ➽ mengubahnya/konversi menjadi 5 case yang berbeda dan menampilkannya pada konsol.
//@uthor Christianto "GEMBLONG" Dharma Wibowo
package casemanipulation;
import java.util.Scanner;
public class CaseManipulation {
public static String toUpperCase(String inputString) {
       System.out.println("MENGKONVERSI STRING DENGAN 5 CARA BERBEDA");
       System.out.println("-----------------------------------------");
       String result = "";
       for (int i = 0; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           char currentCharToUpperCase = Character.toUpperCase(currentChar);
           result = result + currentCharToUpperCase;
       }
       return result;
   }

   public static String toLowerCase(String inputString) {
       String result = "";
       for (int i = 0; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           char currentCharToLowerCase = Character.toLowerCase(currentChar);
           result = result + currentCharToLowerCase;
       }
       return result;
   }

   public static String toToggleCase(String inputString) {
       String result = "";
       for (int i = 0; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           if (Character.isUpperCase(currentChar)) {
               char currentCharToLowerCase = Character.toLowerCase(currentChar);
               result = result + currentCharToLowerCase;
           } else {
               char currentCharToUpperCase = Character.toUpperCase(currentChar);
               result = result + currentCharToUpperCase;
           }
       }
       return result;
   }

   public static String toCamelCase(String inputString) {
       String result = "";
       if (inputString.length() == 0) {
           return result;
       }
       char firstChar = inputString.charAt(0);
       char firstCharToUpperCase = Character.toUpperCase(firstChar);
       result = result + firstCharToUpperCase;
       for (int i = 1; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           char previousChar = inputString.charAt(i - 1);
           if (previousChar == ' ') {
               char currentCharToUpperCase = Character.toUpperCase(currentChar);
               result = result + currentCharToUpperCase;
           } else {
               char currentCharToLowerCase = Character.toLowerCase(currentChar);
               result = result + currentCharToLowerCase;
           }
       }
       return result;
   }

   public static String toSentenceCase(String inputString) {
       String result = "";
       if (inputString.length() == 0) {
           return result;
       }
       char firstChar = inputString.charAt(0);
       char firstCharToUpperCase = Character.toUpperCase(firstChar);
       result = result + firstCharToUpperCase;
       boolean terminalCharacterEncountered = false;
       char[] terminalCharacters = {'.', '?', '!'};
       for (int i = 1; i < inputString.length(); i++) {
           char currentChar = inputString.charAt(i);
           if (terminalCharacterEncountered) {
               if (currentChar == ' ') {
                   result = result + currentChar;
               } else {
                   char currentCharToUpperCase = Character.toUpperCase(currentChar);
                   result = result + currentCharToUpperCase;
                   terminalCharacterEncountered = false;
               }
           } else {
               char currentCharToLowerCase = Character.toLowerCase(currentChar);
               result = result + currentCharToLowerCase;
           }
           for (int j = 0; j < terminalCharacters.length; j++) {
               if (currentChar == terminalCharacters[j]) {
                   terminalCharacterEncountered = true;
                   break;
               }
           }
       }
       return result;
   }

   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       System.out.print("Masukkan String Kalimat : ");
       String inputString = scanner.nextLine();
       System.out.println("Upper Case  : " + toUpperCase(inputString));
       System.out.println("Lower Case  : " + toLowerCase(inputString));
       System.out.println("Toggle Case : " + toToggleCase(inputString));
       System.out.println("Camel Case  : " + toCamelCase(inputString));
       System.out.println("Title Case  : " + toSentenceCase(inputString));
   }
}

Selesai dengan stress
- TAMPIASIH -

0 komentar:

Posting Komentar