2. Wyrażenia regularne

2.1. Podstawowe zasady

1. jesli chcemy traktować znaki specjalne jako literały - poprzedzamy je odwrotnym ukośnikiem \.
2. w niektórych konstrukcjach składniowych metaznaki tracą specjalne znaczenie i są traktowane literalnie.

• wystąpienie jednego z wielu znaków - odpowiednie konstrukcje składniowe noszą nazwę klasy znaków (np. litery lub cyfry),
• początek lub koniec ograniczonego ciągu znaków (np. wiersza lub słowa) - granice,
• powtórzenia - w składni wyrażeń regularnych opisywane przez tzw. kwantyfikatory,
• logiczne kombinacje wyrażeń regularnych.
  

• stwierdzenia czy dany napis pasuje do podanego przez wyrażenie wzorca,
• stwierdzenia czy dany napis zawiera podłańcuch znakowy pasujący do podanego wzorca i ew. uzyskania tego podnapisu i/lub jego pozycji w napisie,
• zamiany części napisu, pasujących do wzorca na inne napisy,
• wyróżniania części napisu, które są rozdzielane ciagami znaków posującymi do podanego wzorca.

• metoda matches() stara się dopasować do wzorca cały podany łańcuch znakowy,
• metoda find()  przeszukuje wejściowy łańcuch znakowy i wyszukuje kolejne pasujące do wzorca jego podłańcuchy.

  String report(String regex, String text) {
    String result = "Wzorzec: \"" + regex + "\"\n" +
                    "Tekst: \"" + text + "\"";
    // Kompilacja wzorca
    // Gdy wzorzec jest składniowo błędny
    // wystąpi wyjątek PatternSyntaxException
    Pattern pattern = null;
    try {
      pattern = Pattern.compile(regex);
    } catch (Exception exc) {
        return result + "\n" + exc.getMessage(); // zwracamy komunikat o błędzie
    }

    // Uzyakanie matchera dla podanego tekstu
    Matcher matcher = pattern.matcher(text);

    // Próba dopasowania całego tekstu do wzorca
    boolean isMatching = matcher.matches();
    result += "\nmatches(): Cały tekst" + (isMatching ? "" : " NIE") +
              " pasuje do wzorca.";

    matcher.reset(); // Przywrócenie początkowej pozycji matchera

    // Teraz stosujemy metodę find()
    // Jej wywołanie zwraca true po znalezieniu pierwszego
    // pasującego do wzorca podłańcucha w tekście
    // Kolejne wywołania pozwalają wyszukiwać kolejne pasujące podłańcuchy
    // wynik false oznacza, że w tekście nie ma już pasujących podłańcuchów
    boolean found = matcher.find();
    if (!found)
      result += "\nfind(): Nie znaleziono żadnego podłańcucha " +
                "pasującego do wzorca";
    else
      do {
        result += "\nfind(): Dopasowano podłańcuch \"" + matcher.group() +
                   "\" od pozycji " + matcher.start() +
                   " do pozycji " + matcher.end() + ".";
      } while(matcher.find());

    return result;
  }

2.2. Literały

• matcher przegląda tekst znak po znaku i za każdym razem szuka dopasowania całego wyrażenia regularnego; zatem o kolejności odnalezionych podłańcuchów decyduje całe wyrażenie, a nie kolejność jego alternatywnych części - dlatego w ostatnim przykładzie find() najpierw odnalazl ciąg znaków "kot" w wyrazie "Loskotek", a nie wyraz "ala" mimo, że ciąg "kot" wystąpił w wyrażeniu regularnym po ciągu "ala",
• no i oczywiście, wyszukiwane są dowolne ciągi znaków, a nie słowa (o tym jak szukać ciągów znaków, które są słowami - dowiemy się dalej).

2.3. Klasy znaków

Bloki Unicode (wyciąg)

0000; 007F; Basic Latin
0080; 00FF; Latin-1 Supplement
0100; 017F; Latin Extended-A
0180; 024F; Latin Extended-B
0250; 02AF; IPA Extensions
02B0; 02FF; Spacing Modifier Letters
0300; 036F; Combining Diacritical Marks
0370; 03FF; Greek
0400; 04FF; Cyrillic
0530; 058F; Armenian
0590; 05FF; Hebrew
0600; 06FF; Arabic
0700; 074F; Syriac
0780; 07BF; Thaana
0900; 097F; Devanagari
0980; 09FF; Bengali
...
1F00; 1FFF; Greek Extended
2000; 206F; General Punctuation
2070; 209F; Superscripts and Subscripts
20A0; 20CF; Currency Symbols
20D0; 20FF; Combining Marks for Symbols
2100; 214F; Letterlike Symbols
2150; 218F; Number Forms
2190; 21FF; Arrows
2200; 22FF; Mathematical Operators
2300; 23FF; Miscellaneous Technical
2400; 243F; Control Pictures
2440; 245F; Optical Character Recognition
2460; 24FF; Enclosed Alphanumerics
2500; 257F; Box Drawing
2580; 259F; Block Elements
25A0; 25FF; Geometric Shapes
2600; 26FF; Miscellaneous Symbols
2700; 27BF; Dingbats
2800; 28FF; Braille Patterns
...

• sumowania klas (zbiorów) - uzyskiwanego poprzez zagnieżdżenie dodatkowych nawiasów kwadratowych,
• wspólnej części klas (zbiorów) - uzyskiwanej za pomocą operatora &&
• różnicy klas (zbiorów) - uzyskiwanej poprzez kombinację operacji && i negacji.

2.4. Kwantyfikatory

• mógł składać się z dowolnego pojedynczego słowa pies, kot, krowa (bez kończącej spacji),
• mógł składać się z dowolnej liczby powtórzeń tych słów, ale przy tym rozdzielonych co najmniej jedną i nie więcej niż trzema spacjami.

(pies|kot|krowa)( {1,3}(pies|kot|krowa))*

• tekst zaczyna się jednym ze słów pies, kot, krowa
• po czym następuje zero lub więcej powtórzeń (kwantyfikator *) tekstu opisywanego przez wyrażenie w drugich nawiasach,
• wyrażenie w drugich nawiasach stwierdza, że opisywany przez nie tekst ma zaczynać się 1, 2 lub trzema spacjami (kwantyfikator {1,3}), po czym ma następować jedno ze słów pies, kot, krowa.

2.5. Granice

2.6. Flagi

• albo przy kompilacji wyrażenia - jako drugi argument metody compile(...) z klasy Pattern,
• albo bezpośrednio w wyrażeniu regularnym stosując odpowiednie symbole.

String regex = "....";
int flags = Pattern.CASE_INSENSITIVE | Pattern.DOTALL;
Pattern pattern = Pattern.compile(regex, flags);

2.7. Grupy i odniesienia zwrotne

(\w+)\s+(\d+)

import java.util.regex.*;
import javax.swing.*;

public class Grupy {

  public static void main(String[] args) {

    // Kompilacja wzorca
    // uwaga: odwrotne ukośniki w tekście programu duplikujemy

    Pattern pattern = Pattern.compile("(\\w+)\\s+(\\d+)");

    String txt;  // przeszukiwany (dopasowywany) tekst
                 // pobierany w dialogach wejściowych, w pętli

    while((txt = JOptionPane.showInputDialog("Tekst")) != null) {

      Matcher matcher = pattern.matcher(txt); // uzyskanie matchera

      // Próba dopasowania całego tekstu i pokazanie wyniku
      boolean res = matcher.matches();
      report(txt, "matches()", res, matcher);

      // odtworzenie pierwotnego stanu matchera (po matches)
      matcher.reset();

      // Sekwencyjne wyszukiwanie za pomocą metody find
      while ((res = matcher.find()) != false) {
        report(txt, "find()", res, matcher);
      }
    }
    System.exit(0);
  }

  static void report(String txt, String who, boolean result, Matcher matcher) {

     System.out.println("Tekst: \"" + txt + "\"");

     int lgrup = matcher.groupCount(); // liczba grup
     System.out.println("Liczba grup w wyrażeniu: " + lgrup);

     System.out.println(who + ": znalazł dopasowanie ? - " + result);

     try {

       // Cały dopasowany/wyszukany fragment
       String whatMatches = "\"" + matcher.group() + "\"";

       // Pozycja tekstu na której zaczyna się dopasowanie
       int pos = matcher.start();
       System.out.println("Dopasowano co: " + whatMatches);
       System.out.println("Na pozycji   : " + pos);

       // Wyprowadzamy zwartość wszystkich grup
       for (int i=1; i<=lgrup; i++) {
         System.out.println("Grupa " + i + ": \"" + matcher.group(i) + "\"");
       }

     } catch (IllegalStateException exc) {  // wyjątek - gdy brak dopasowania
         System.out.println(exc.getMessage());
         return;
     }
  }

}

(\b\p{L}+)[\s\p{Punct}]+\1

import java.util.regex.*;
import java.io.*;

public class DupWords {

  public static void main(String[] args) {

    Pattern pattern = Pattern.compile("(\\b\\p{L}+)[\\s\\p{Punct}]+\\1",
                                       Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher("");

    try {
      LineNumberReader lr = new LineNumberReader(
                                 new FileReader(args[0])
                              );
      String line;
      while ((line = lr.readLine()) != null) {
        int  lineNr = lr.getLineNumber();

        matcher.reset(line);  // matcher nastawiamy na nowy tekst

        while (matcher.find()) {
          System.out.println("Powtórzenie słowa " + matcher.group(1) +
                             " w wierszu " + lineNr);
        }

      }
      lr.close();
    } catch(IOException exc) {
        System.out.println(exc);
        System.exit(1);
    }
  }

}

• jedno lub więcej wystąpień tekstów Ax, Bx lub Cx,
• po którym następuje dowolna liczba całkowita,
• po której następują jedno lub więcej wystąpień litery x poprzedzonej za każdym razem dowolnym znakiem buiałym lub nzakiem punktuacji,
• po czym następuje cyfra

 (?:[ABC]x)+(\d+)(?:[\s\p{Punct}-]x)+(\d)

2.8. Dopasowanie i wyszukiwanie.

\s*\d+\s*

\s*(\d+)\s*

import java.util.regex.*;
import java.io.*;

public class Sumowanie {

  public static void sumAndReport(String fileName) {

    try {
      BufferedReader in = new BufferedReader(
                           new FileReader(fileName)
                       );

      Pattern pattern = Pattern.compile("\\s*(\\d+)\\s*");


      Matcher matcher = pattern.matcher("");

      int suma1 = 0,   // suma liczb występujących samotnie w wierszach
          suma2 = 0;   // suma liczb, które nie są w wierszach samotne

      String input;
      while ((input = in.readLine()) != null) {

        matcher.reset(input);          // nowy tekst wejściowy

        if (matcher.matches())         // czy mamy samotną liczbę?
          suma1 += Integer.parseInt(matcher.group(1));

        else {                         // nie, może jest kilka, albo w tekście?

          matcher.reset();             // konieczne, by ew. poprzedni stan
                                       // nie miał wpływu na find()
          while (matcher.find())
            suma2 += Integer.parseInt(matcher.group(1));
        }
      }
      in.close();
      System.out.println("Suma samotnych liczb: " + suma1);
      System.out.println("Suma niesamotnych liczb: " + suma2);
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }

  }

  public static void main(String[] args) {
    sumAndReport(args[0]);
  }

}

\s*?(\d+?)\s*?

• w wierszu jest tylko liczba i nic więcej - wzorzec: ^(\d+)$
• wiersz zaczyna się od liczby, po czym następuje 1 lub więcej spacji : ^(\d+)\s+
• wiersz kończy się liczbą, poprzedzoną jedną lub więcej spacjami:  \s+(\d+)$
• w wierszu występują liczby (lub liczba) okolona jedną lub więcej spacjami: \s+(\d+)\s+

(?:^(\d+)\s+)|(?:^(\d+)$)|(?:\s+(\d+)$)|(?:\s+(\d+)\s+)

import java.util.regex.*;
import java.io.*;

public class Sumowanie2 {

  private Pattern pattern = Pattern.compile("(?:^(\\d+)\\s+)|" +
                                        "(?:^(\\d+)$)|" +
                                        "(?:\\s+(\\d+)$)|" +
                                        "(?:\\s+(\\d+)\\s+)"
                                       );

  private Matcher matcher = pattern.matcher("");

  private int lgroup = matcher.groupCount(); // liczba grup

  public void sumAndReport(String fileName) {

    try {
      BufferedReader in = new BufferedReader(
                           new FileReader(fileName)
                       );
      int suma1 = 0,   // suma liczb występujących samotnie w wierszach
          suma2 = 0;   // suma liczb, które nie są w wierszach samotne

      String input;
      while ((input = in.readLine()) != null) {

        matcher.reset(input);          // nowy tekst wejściowy

        if (matcher.matches())         // czy mamy samotną liczbę?
          suma1 += getMatchingGroupAsNumber("matches");

        else {                         // nie, może jest kilka, albo w tekście?
          matcher.reset();
          while (matcher.find())
            suma2 += getMatchingGroupAsNumber("find");
        }
      }
      in.close();
      System.out.println("Suma samotnych liczb: " + suma1);
      System.out.println("Suma niesamotnych liczb: " + suma2);
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }

  }

  // Metoda zwracająca dopasowaną grupę
  // przekształconą na liczbę

  private int getMatchingGroupAsNumber(String info)
              throws NumberFormatException
  {
    System.out.println(info + "\nDopasowanie: \"" + matcher.group() + "\"");
    int wynik = 0;
    for (int i=1; i <= lgroup; i++) {
       System.out.println("Gr. " + i + " \"" + matcher.group(i) + "\"");
       if (matcher.group(i) != null) {
         wynik = Integer.parseInt(matcher.group(i));
       }
    }
    return wynik;
  }

  public static void main(String[] args) {
    new Sumowanie2().sumAndReport(args[0]);
  }

}

\s*\b(\d+)\b\s*

• wyrażenia regularne nie są lekiem dobrym na wszystko,
• czasem mniej wysiłku kosztuje oprogramowanie od podstaw analizy składniowej tekstu, niż zbudowanie właściwego wzorca,
• większą moc zyskuje się przy połączeniu wyrażeń regularnych z innymi środkami programowania, m.in. metodami klasy Matcher, ale również z innymi prostymi środkami przetwarzania łańcuchów znakowych.

import java.util.regex.*;
import java.io.*;

public class Sumowanie3 {

  public static void sumAndReport(String fileName) {

    try {
      BufferedReader in = new BufferedReader(
                           new FileReader(fileName)
                       );

      // Ten wzorzec nie spłenia wszystkich wymagań
      Pattern pattern = Pattern.compile("\\s*(\\d+)\\s*");

      Matcher matcher = pattern.matcher("");

      int suma1 = 0,   // suma liczb występujących samotnie w wierszach
          suma2 = 0;   // suma liczb, które nie są w wierszach samotne

      String input;
      while ((input = in.readLine()) != null) {

        int len = input.length();       // długość tekstu

        matcher.reset(input);

        if (matcher.matches())         // czy mamy samotną liczbę?
          suma1 += Integer.parseInt(matcher.group(1));

        else {                         // nie, może jest kilka, albo w tekście?
          matcher.reset();
          while (matcher.find()) {

            // pozycja znaku tuż przed dopasowaną grupą cyfr
            int start = matcher.start(1) - 1;
            // pozycja znaku tuż po dopasowanej grupie cyfr
            int end = matcher.end(1);

            // jeżeli są takie znaki i nie są to spacje
            // - odrzucamy dopasowanie
            if (start == end ||
                (start >= 0 && !Character.isWhitespace(input.charAt(start))) ||
                (end < len && !Character.isWhitespace(input.charAt(end)))
               ) continue;

            // w przeciwnym razie mamy dopasowanie i sumujemy liczby
            suma2 += Integer.parseInt(matcher.group(1));
          }
        }
      }
      in.close();
      System.out.println("Suma samotnych liczb: " + suma1);
      System.out.println("Suma niesamotnych liczb: " + suma2);
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }

  }

  public static void main(String[] args) {
    sumAndReport(args[0]);
  }

}

2.9. Rozbiór

import java.util.regex.*;
import java.nio.*;
import java.io.*;
import java.nio.channels.*;
import java.nio.charset.*;
import javax.swing.*;


public class Parsing {

  private CharBuffer input;
  private Charset inCharset  = Charset.forName("Cp1250");


  public void readFile(String fname) throws IOException {

    // Wczytanie pliku
    FileInputStream instream = new FileInputStream(fname);
    FileChannel in = instream.getChannel();
    ByteBuffer buf = ByteBuffer.allocate((int) in.size());
    in.read(buf); in.close(); instream.close();

    // Dekodowanie
    buf.flip();
    input = inCharset.decode(buf);
  }

  public void reporter(Pattern pattern) {
    String[] subs = pattern.split(input);
    System.out.println("Rozbiór wg wzorca: \""+ pattern.pattern() + "\"");
    boolean isOk = subs.length > 1;
    System.out.println( isOk ? " udany" : " nieudany");
    if (!isOk) return;
    System.out.println("Wyróżnione podłańcuchy:");
    for (int i=0; i < subs.length; i++) {
      System.out.println("[ " + (i+1) + " ] \"" + subs[i] + "\"");
    }
  }


  public static void main(String[] args) throws Exception {

    Parsing parse = new Parsing();
    parse.readFile(args[0]);

    String regex = "";
    while ((regex = JOptionPane.showInputDialog("Wzorzec", regex)) != null) {
      Pattern pattern = Pattern.compile(regex, Pattern.DOTALL);
      parse.reporter(pattern);
    }

  }

}

2.10. Zastępowanie

import java.util.regex.*;
import java.io.*;

public class Replace1 {

  public static void main(String[] args) {

    Matcher matcher = Pattern.compile(" +").matcher("");

    try {
      BufferedReader in = new BufferedReader(
                            new FileReader(args[0])
                          );
      String input;
      while ((input = in.readLine()) != null) {
        matcher.reset(input);
        input = matcher.replaceAll(" ");
        System.out.println(input);
      }
      in.close();
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }

  }

}

1. kopiuje do bufora StringBuffer wszystkie znaki  tekstu wejściowego od bieżącej pozycji "append" (przy pierwszym użyciu jest to początek tekstu wejściowego) do pozycji poprzedzającej ostatnie dopasowanie wzorca (czyli start()-1),
2. następnie dopisuje do bufora tekst podany jako jej argument replacement,
3. ustala bieżącą pozycję "append" na pierwszy znak po ostatnio dopasowanym wzorcu (czyli end())

import java.util.regex.*;

public class Replace2 {

  public static void main(String[] args) {

    String input = "To jest   tekst  gdzie za dużo  spacji";
    Matcher matcher = Pattern.compile(" +").matcher(input);
    StringBuffer nowyTekst = new StringBuffer();
    while (matcher.find()) {
      matcher.appendReplacement(nowyTekst, " ");
    }
    matcher.appendTail(nowyTekst);
    System.out.println("Tekst wejściowy:");
    System.out.println(input);
    System.out.println("Tekst wyjściowy:");
    System.out.println(nowyTekst.toString());
  }

}

import java.util.regex.*;

public class Replace3 {

  public static void main(String[] args) {

    String input = "1111111111111";
    Matcher matcher = Pattern.compile("1").matcher(input);
    StringBuffer nowyTekst = new StringBuffer();
    while (matcher.find() && matcher.find()) {
      matcher.appendReplacement(nowyTekst, "3");
    }
    matcher.appendTail(nowyTekst);
    System.out.println("Tekst wejściowy:");
    System.out.println(input);
    System.out.println("Tekst wyjściowy:");
    System.out.println(nowyTekst.toString());
  }

}

^s(\d+) +([\p{L}-]+) +([\p{L}-]+)$

import java.util.regex.*;
import java.io.*;

public class Replace4 {

  public static void main(String[] args) {

    Matcher matcher = Pattern.compile(
                        "^s(\\d+) +([\\p{L}-]+) +([\\p{L}-]+)$"
                      ).matcher("");

    try {
      BufferedReader in = new BufferedReader(
                            new FileReader(args[0])
                          );
      String input;
      while ((input = in.readLine()) != null) {
        matcher.reset(input);
        input = matcher.replaceFirst("$3 $2 $1");
        System.out.println(input);
      }
      in.close();
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }

  }

}

2.11. Metody klasy String związane z wyrażeniami regularnymi

2.12. Praktyczny przykład

<h[1-6]>(.+)</h[1-6]>

(?i)(?s)<h[1-6]>(.+)</h[1-6]>

(?i)(?s)<h[1-6]>(.+?)</h[1-6]>

• w jaki sposób przeczytać plik, tak by wielowierszowe nagłówki dały się przetwarzać przez wybrane wyrażenie regularne? Na pewno nie możemy stosować go do każdego z wierszy pliku oddzielnie.
• co zrobić ze znakami nowego wiersza umieszczonymi wewnętrz nagłówków? Raczej chcielibyśmy wypisywać tytuły w jednym wierszu, a nie zachowywać  - często przypadkowego, dokonanego np. przez jakieś wizualne edytory HTML, rozbicia.
• co robić w przypadku błędów w pliku HTML - niesparowania znaczników otwierających i kończących? Nasz wzorzec znajdzie (jakieś) dopasowanie np. w takim tekście, <h1>xxxx<h2>xxxx</h1>xxx</h2>, jak również i w takim <h1>xxxx</h2>. Czy warto szukać wzorca bardziej odpornego na błędy?

(?i)charset *?= *?([\p{Alnum}.:_-]+)

• będziemy wykrywać otwarte znaczniki <h wewnątrz nagłówków,
• będziemy sprawdzać, czy nasze wyrażenie spowodowało dopasowania znaczników (otwierającego i zamykającego) nagłówków różnych poziomów.

import java.util.regex.*;
import java.nio.*;
import java.io.*;
import java.nio.channels.*;
import java.nio.charset.*;

public class Headers1 {

  // Matcher do wyszukiwania metatagu charset
  // i wyłuskania strony kodowej
  private Matcher charsetMatcher = Pattern.compile(
                                   "charset *?= *?([\\p{Alnum}.:_-]+)",
                                   Pattern.CASE_INSENSITIVE
                                   ).matcher("");

  // Matcher do wyłuskania tytułu dokumentu
  private Matcher titleMatcher =  Pattern.compile(
                                  "<title>(.+?)</title>",
                                  Pattern.CASE_INSENSITIVE |
                                  Pattern.DOTALL
                                  ).matcher("");

  // Matcher do wyszukiwania podtytułów (headingów)
  private Matcher headingMatcher = Pattern.compile(
                                    "<h[1-6]>(.+?)</h[1-6]>",
                                    Pattern.CASE_INSENSITIVE |
                                    Pattern.DOTALL
                                    ).matcher("");

  // Matcher do zastępowania domyślnego dla danej platformy
  // zestawu znaków końca wiersza jedną spacją
  private Matcher replaceMatcher = Pattern.compile(
                                    System.getProperty("line.separator")//"\\r\\n"
                                   ).matcher("");

  // Wzorzec do podziału dokumentu na dwie części: nagłówek i ciało
  private Pattern splitPattern = Pattern.compile("</head>",
                                         Pattern.CASE_INSENSITIVE
                                 );


  // Domyślna strona kodowa
  private Charset defaultCharset = Charset.forName("ISO-8859-2");

  ByteBuffer channelBuffer;   // bufor bajtowy kanalu
  CharBuffer input;           // bufor znakowy z wejściem dla matcherów


  // Główna metoda
  // przetwarzająca dokument HTML
  // i wypisująca jego "spis treści"

  public void processFile(String fname) {
    // Wczytanie pliku
    try {
      FileInputStream instream = new FileInputStream(fname);
      FileChannel in = instream.getChannel();
      channelBuffer = ByteBuffer.allocate((int) in.size());
      in.read(channelBuffer);
      in.close();
      instream.close();
    } catch (IOException exc) { errMsg(exc); }

    // Dekodowanie (na razie wedle domyślnej strony)
    // Jeśli okaże się, że plik jest kodowany inaczej
    // - powtórzymy dekodowanie

    channelBuffer.flip();
    input = defaultCharset.decode(channelBuffer);

    // Teraz wyróżniamy dwie części pliku : nagłówek pliku
    // i ciało. W ten sposób matchery będą działać szybciej
    // Uwaga: podział następuje na pierwszym </head>
    // ew. następne w tekście html (np. w <pre>...</pre>
    // nie będą brane pod uwagę

    String[] part = splitPattern.split(input, 2);
    // jeżeli jest nagłówek - szukamy w nim określenia strony kodowej
    // i ew. ponawiamy dekodowanie za pomocą własnej metody newDecode,
    // a także wyszukujemy tytuł

    String title = "Bez tytułu";  // zakładamy, że nie ma tytułu
    String body;                  // tu będzie ciało, w nim będziemy szukać
                                  // headingów

    if (part.length == 2) {        // jeżeli jest nagłówek
       if (newDecoding(part[0]))   // jeżeli ponowiono dekodowanie
          part = splitPattern.split(input, 2); // - nowy podział na części

       titleMatcher.reset(part[0]);  // szukamy tytułu
       if (titleMatcher.find())
         title = titleMatcher.group(1);

       body = part[1];             // ciałem będzie druga część
    } else {                       // nie ma nagłówka, wtedy
       body = part[0];             // ciałem będzie jedyna pierwsz część
    }

    System.out.println(title);     // wypisanie tytułu

    // Teraz szukamy headingów
    headingMatcher.reset(body);
    while (headingMatcher.find()) {
      String heading = headingMatcher.group(1);
      replaceMatcher.reset(heading);  // zamiana znaku końca wiersza
      heading = replaceMatcher.replaceAll(" "); // na jedną spację

      // Sprawdzenie poprawności
      boolean valid = true;

      // - czy nie ma <h>  w srodku?
      if (heading.indexOf("<h") != -1) valid = false;

      // czy otwierający i zamykający numer poziomu jest zgodny?
      String match = headingMatcher.group();
      char level = match.charAt(2);
      if (level != match.charAt(match.length()-2)) valid = false;
      if (!valid)
        System.out.println("***** uwaga poniższy heading jest błędny!");
      else {
         int k = level - '0' - 1;
         while(k-- > 0)                // poziomy wyróżniamy tabulacjami
           System.out.print('\t');
      }
      System.out.println(heading);      // wypisanie podtytułu
    }

  }

  // Metoda wyszukuje metatatg charset i ew. ponawia dekodowanie
  // Jeśli tagu nie ma, albo podany charset jest taki sam jak
  // domyślny, albo jest wadliwy - nie ponawiamy dekodowania
  // Zwraca true, gdy zdekdodowano na nowa
  private boolean newDecoding(String header) {
    charsetMatcher.reset(header);
    if (charsetMatcher.find()) { // czy jest metatag charset?
       try {
           Charset fileCharset = Charset.forName(charsetMatcher.group(1));
           if (fileCharset.equals(defaultCharset)) // gdy taki sam jak domyślny
              return false;                        // nie trzeba dekodować
           channelBuffer.flip();                   // inny - ponowne dekodowanie
           input = fileCharset.decode(channelBuffer);
         } catch(Exception exc) {
             return false;
         }
       return true; // zdekodowany na nowo
    }
    return false;
  }

  private void errMsg(Exception exc) {
    exc.printStackTrace();
    System.exit(1);
  }

  public static void main(String[] args) {
     new Headers1().processFile(args[0]);
  }

}

2.13. Zadania i ćwiczenia

1. Zbudować wyrażenie regularne, które dopasowuje dowolną liczbę - całkowitą lub rzeczywistą. Użyć go w programie, który z pliku wejściowego wybiera wszystkie takie liczby i zastępuje je ich dwukrotnością.
2. Stworzyć program do przetwarzania plików HTML, w taki sposób, by zapisane w nich kody programów Javy, znajdujące się w znacznikach <pre>.... </pre> były zapisowane jako pliki .java z nazwą wyłuskaną z kodu na podstawie nazwy obecnej tam klasy publicznej.
3. Napisać program, który  w pliku źródłowym zmienia nazwy wybranych metod. Uwaga: trzeba też zmeinić identyfikatory w wyrażeniach wywołujących metody.