Ekspresi Reguler Pada Java - Java Regular Exspressions - Java NetBeans

Java menyediakan paket java.util.regex untuk pencocokan pola dengan ekspresi reguler. ekspresi reguler Java sangat mirip dengan bahasa pemrograman Perl dan sangat mudah untuk dipelajari.

Sebuah ekspresi reguler adalah urutan khusus karakter yang membantu kita mencocokkan atau menemukan string lain atau set string, menggunakan sintaks khusus yang diselenggarakan pada sebuah pola. Mereka dapat digunakan untuk mencari, mengedit, atau memanipulasi teks dan data.

Paket java.util.regex utama terdiri dari tiga kelas yaitu:

• Pattern Class: Sebuah pattern object adalah kompilasi representasi dari ekspresi reguler. Pattern class tidak memberikan konstruktor publik, untuk membuat pattern kita harus terlebih dahulu memanggil public static compile() methods yang kemudian akan dikembalikan pada pattern object. Method ini menerima ekpresi reguler pada argumen pertama.
• Matcher Class: Matcher object adalah mesin yang menafsirkan pola dan melakukan operasi persamaan (match) dari string yang di input. Seperti pattern class, matcher tidak memiliki konstruktor publik, kita dapat menggunakan object matcher dengan menerapkan matcher() method pada object pattern.
• PatternSyntaxException: PatternSyntaxException adalah eksepsi yang tidak dikonfirm yang mununjukkan kesalahan syntax dalam pola ekspresi reguler.

Menangkap Group

Kita dapat menangkap sekelompok karakter atau beberapa karakter sebagai satu kesatuan.

Mereka diciptakan dengan menempatkan karakter dikelompokkan dalam satu set tanda kurung (). Sebagai contoh, ekspresi reguler (kucing) membuat grup yang berisi huruf "k", "u", "c", "i", "n", "g".

Menangkap kelompok dengan memberikan penomoran dan menghitung kurung pembukaan mereka dari kiri ke kanan. Dalam ekspresi ((A) (B (C))), misalnya terdapat empat kelompok seperti:

• ((A) (B (C)))
• (A)
• (B (C))
• (C)

Untuk mengetahui berapa banyak kelompok yang hadir dalam ekspresi kita dapat memanggil method groupCount pada object matcher. Method groupCount mengembalikan sebuah int yang akan menunjukkan jumlah kelompok yang hadir pada pola matcher ini.

Ada juga kelompok khusus, group 0, yang mewakili seluruh ekspresi. Kelompok ini tidak termasuk dalam total yang dilansir groupCount.

Contoh :

Berikut adalah contoh menggambarkan bagaimana menemukan string digit dari string alfanumerik yang diberikan.

Bukalah NetBeans kalian buatlah class baru bernama PersamaanRegex lalu tuliskan kode berikut.

import java.util.regex.*;

public class RegexMatches
{
    public static void main( String args[] ){

      // String yang akan discan untuk dicari polanya.
      String line = "Mencoba mencari persamaan dengan bantuan M4A1 vs M200";
      String pattern = "(.*)(\\d+)(.*)";

      // Membat sebuah pattern object
      Pattern r = Pattern.compile(pattern);

      // Membuat matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Nilai ditemukan: " + m.group(0) );
         System.out.println("Nilai ditemukan: " + m.group(1) );
         System.out.println("Nilai ditemukan: " + m.group(2) );
      } else {
         System.out.println("TIDAK SAMA");
      }
   }
}

Berikut adalah hasil dari kode diatas.

Nilai ditemukan: Mencoba mencari persamaan dengan bantuan M4A1 vs M200
Nilai ditemukan: Mencoba mencari persamaan dengan bantuan M4A1 vs M20
Nilai ditemukan: 0

Syntax Ekspresi Reguler

Berikut daftar urutan semua ekspresi reguler metakarakter yang tersedia di Java:

subexpression	Korek api
^	Awal baris matches.
$	Akhir baris matches.
.	Matches dengan karakter tunggal kecuali baris baru.Menggunakan opsi m memungkinkan untuk mencocokkan baris baru juga.
[...]	Matches dengan karakter tunggal dalam tanda kurung.
[^ ...]	Matches dengan satu karakter apapun tidak dalam kurung
\A	Awal seluruh string
\z	Akhir seluruh string
\Z	Akhir seluruh string kecuali diijinkan garis akhir terminator.
re*	Matches 0 atau lebih kejadian dari sebelumnya ekspresi.
re+	Matches 1 atau lebih dari sebelumnya
re?	Matches 0 atau 1 terjadinya sebelumnya ekspresi.
re{n}	Matches sama persis n jumlah kemunculan sebelumnya ekspresi.
re{n,}	Matches n atau lebih kejadian dari sebelumnya ekspresi.
re {n, m}	Matches setidaknya n dan paling banyak kejadian m dari sebelumnya ekspresi.
a| b	Matches baik a atau b.
(re)	Grup ekspresi reguler dan mengingat matches teks.
(?: re)	Kelompok ekspresi reguler tanpa mengingat teks yang matches.
(?> re)	Matches dengan independent pattern tanpa backtracking.
\w	Matches karakter kata.
\W	Matches karakter bukan kata.
\s	Matches spasi. Setara dengan [\t\n\r\f].
\S	Matches bukan spasi.
\d	Matches digit. Setara dengan [0-9].
\D	Matches nondigits.
\A	Matches dimulai string.
\Z	Matches akhir string. Jika baris baru ada, matches sebelum baris baru.
\z	Matches akhir string.
\G	Matches titik di mana match terakhir selesai.
\n	Kembali-referensi untuk menangkap kelompok nomor "n"
\b	Matches batas kata ketika kurung luar. Matches backspace (0x08) saat berada di dalam kurung.
\B	Matches batas bukan kata.
\n, \t, dll	Matches baris, tombol kembali, tab, dll
\Q	Escape (kutipan) semua karakter sampai dengan \E
\E	Berakhir mengutip dimulai dengan \Q

Method Matcher Class

Berikut adalah daftar instance method yang sangat berguna:

Method Indeks:

Method indeks memberikan nilai indeks yang berfungsi menunjukkan tepat dimana match itu ditemukan dalam string masukan:

No	Metode dengan Deskripsi
1	public int start() Mengembalikan index awal match sebelumnya.
2	public int start(int group) Mengembalikan index awal subsequence ditangkap oleh kelompok diberikan selama operasi match sebelumnya.
3	public int end() Mengembalikan offset setelah karakter terakhir cocok.
4	public int end(int group) Mengembalikan offset setelah karakter terakhir dari subsequence ditangkap oleh kelompok diberikan selama operasi match sebelumnya.

Methods Studi:

Method studi adalah metode yang meninjau input string dan mengembalikan boolean yang menunjukkan apakah pattern ditemukan atau tidak.

No	Metode dengan Deskripsi
1	public boolean lookingAt() Upaya untuk mencocokkan urutan masukan, mulai dari awal, terhadap pattern.
2	public boolean find() Upaya untuk menemukan subsequence berikutnya dari urutan input yang cocok pada pola.
3	public boolean find(int start) Mengulang matcher kemudian mencoba untuk menemukan subsequence berikutnya dari urutan input yang cocok pada pola, dimulai dari indeks tertentu.
4	public boolean matches() Upaya untuk mencocokkan seluruh wilayah terhadap pola.

Replacement  Methods:

Metode pengganti yang berguna untuk mengganti teks dalam string yang dimaksukkan.

No	Metode dengan Deskripsi
1	public Matcher appendReplacement (StringBuffer sb, String replacement) Menerapkan non-terminal append-dan-ganti langkah.
2	public StringBuffer appendTail(StringBuffer sb) Mengimplementasikan terminal menambahkan-dan-ganti langkah.
3	public String replaceAll(String replacement) Menggantikan setiap berikutnya dari urutan masukan yang cocok dengan pola string pengganti yang diberikan.
4	public String replaceFirst(String replacement) Menggantikan subsequence pertama dari urutan input yang cocok dengan pola dengan string pengganti yang diberikan.
5	public static String quoteReplacement(String s) Mengembalikan String pengganti literal untuk String yang ditentukan. Metode ini menghasilkan sebuah String yang akan bekerja sebagai s pengganti literal dalam metode appendReplacement kelas Matcher.

Start dan End Method:

Berikut adalah contoh yang bermaksud menghitung berapa kali kata "ibu" muncul dalam string yang ditentukan.

import java.util.regex.*;

public class RegexMatches
{
    private static final String REGEX = "\\bibu\\b";
    private static final String INPUT =
                                    "ibu ibu ibu ibubui ibu";

    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // mendapatkan matcher object
       int count = 0;

       while(m.find()) {
         count++;
         System.out.println("Nomor match"+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Berikut adalah hasil dari kode diatas.

Nomor match1
start(): 0
end(): 3
Nomor match2
start(): 4
end(): 7
Nomor match3
start(): 8
end(): 11
Nomor match4
start(): 19
end(): 22

Anda dapat melihat bahwa contoh ini menggunakan batas kata untuk memastikan bahwa huruf "i" "b" "u" yang bukan hanya substring dalam kata lagi. Hal ini juga memberikan beberapa informasi yang berguna tentang dimana dalam string masukan match telah terjadi.

Metode start mengembalikan indeks awal subsequence ditangkap oleh kelompok diberikan selama operasi match sebelumnya, dan akhirnya mengembalikan indeks dari karakter terakhir yang cocok, ditambah satu.

Matches Dan lookingAt Methods:

Pertandingan dan metode lookingAt baik upaya untuk mencocokkan urutan masukan terhadap pattern. Perbedaannya, bagaimanapun, adalah bahwa matches membutuhkan seluruh urutan masukan untuk dicocokkan, sementara lookingAt tidak.

Kedua metode selalu mulai dari awal string masukan. Berikut adalah contoh yang menjelaskan fungsi tersebut:

import java.util.regex.*;

public class RegexMatches
{
    private static final String REGEX = "foo";
    private static final String INPUT = "fooooooooooooooooo";
    private static Pattern pattern;
    private static Matcher matcher;

    public static void main( String args[] ){
       pattern = Pattern.compile(REGEX);
       matcher = pattern.matcher(INPUT);

       System.out.println("REGEX saat ini adalah: "+REGEX);
       System.out.println("INPUT adalah: "+INPUT);

       System.out.println("lookingAt(): "+matcher.lookingAt());
       System.out.println("matches(): "+matcher.matches());
   }
}

Berikut adalah hasil dari kode diatas.

REGEX saat ini adalah: foo
INPUT adalah: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst Dan replaceAll Method

replaceFirst dan replaceAll method menggantikan teks yang dengan ekspresi reguler yang diberikan, sesuai dengan nama mereka replaceFirst menggantikan kejadian perama, dan replaceAll menggantikan semua kejadian.

Berikut adalah contoh dari fungsi dari method replaceFirst dan replaceAll method:

import java.util.regex.*;

public class RegexMatches
{
    private static String REGEX = "kambing";
    private static String INPUT = "kambing makan rumput. " +
                                    "semua kambing makan rumput.";
    private static String REPLACE = "sapi";

    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT); 
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
}

Berikut adalah hasil dari kode diatas.

sapi makan rumput. semua sapi makan rumput.

appendReplacement dan appendTail Methods

Matcher class juga menyediakan appendReplacement dan appendTail method untuk penggantian teks.

import java.util.regex.*;

public class RegexMatches
{
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Berikut adalah hasil dari kode diatas.

-foo-foo-foo-

PatternSyntaxException Class Methods

Method ini merupakan pengecualian yang menunjukkan kesalahan syntax dalam pola ekspresi reguler, berikut adalah beberapa method untuk membantu menentukan sesuatu yang salah:

No	Metode dengan Deskripsi
1	public String getDescription() Mengambil deskripsi kesalahan.
2	public int getIndex() Mengambil indeks kesalahan.
3	public String getPattern() Mengambil pola ekspresi reguler yang salah.
4	public String getMessage() Mengembalikan string multi-baris yang berisi deskripsi dari kesalahan sintaks dan indeks, pola ekspresi reguler yang keliru, dan indikasi visual dari indeks kesalahan dalam pola.

+Java Programming Tutorials +NetBeans 

Read More