1. Formatowanie, lokalizacja i internacjonalizacja

1.1. Lokalizacje

import java.text.*;
import java.util.*;

public class DefLok {

  static public void report() {
    Locale defLoc = Locale.getDefault();
    System.out.println("Domyślna lokalizacja : " + defLoc);
    DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
    NumberFormat nf = NumberFormat.getInstance();
    System.out.println(df.format(new Date()));
    System.out.println(nf.format(1234567.1));
  }

  public static void main(String[] args) {
    report();
    Locale.setDefault(new Locale("en"));
    report();
  }

}

• formaty dat i liczb dla różnych lokalizacji różnią się,
• zmiana domyślnej lokalizacji dotyczy wszystkich klas czułych na lokalizację. 

import java.text.*;
import java.util.*;

public class MiscLok {

  public static void main(String[] args) {
    System.out.println("Domyślna lokalizacja : " + Locale.getDefault());
    DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
    System.out.println(df.format(new Date()));
    double num = 123.4;
    NumberFormat nf = NumberFormat.getInstance();
    System.out.println("Liczba " + num +
                       " w lokalizacji domyślnej: " + nf.format(num));
    nf = NumberFormat.getInstance(new Locale("en"));
    System.out.println("Liczba " + num +
                       " w lokalizacji angielskiej: " + nf.format(num));
  }

}

import java.util.*;
import java.text.*;

public class Lokal1 {

  public static void main(String[] args) {

    // Tablica dostępnych lokalizacji

    Locale[] loc = Locale.getAvailableLocales();

    System.out.println("Kod języka" + "#" +
                       "Kod kraju" + "#" +
                       "Kod wariantu" +  "#" +
                       "Język" + "#" +
                       "Kraj" +  "#" + "Wariant"
                      );

    for (int i=0; i<loc.length; i++) {
      String countryCode = loc[i].getCountry();  // kod kraju
      String langCode = loc[i].getLanguage();    // kod języka
      String varCode  = loc[i].getVariant();     // wariant

      // lokalizacja opisana w języku domyślnej lokalizacji (polskim)
      String kraj =  loc[i].getDisplayCountry();
      String jezyk = loc[i].getDisplayLanguage();
      String wariant = loc[i].getDisplayVariant();
      System.out.println(langCode + "#" +
                         countryCode +  "#" +
                         varCode + "#" +
                         jezyk + "#" + kraj + "#" + wariant);

     }
  }

}

• możemy formować lokalizacje tylko na podstawie języka,
• dodatkowa specyfikacja kraju może różnicować formaty językowe zgodnie z tradycjami kulturowymi danego kraju,
• istnieją kraje z kilkoma obowiązującymi językami,
• dla niektórych lokalizacji podano dodatkowe warianty.

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

class CountryTranslator {

  public static void main(String[] args) {

    Locale[] loc = Locale.getAvailableLocales();
    Map map = new HashMap();
    String kraj;

    // Dodanie dostępnych lokalizacji do mapy
    // klucz: nazwa kraju po polsku, wartośc - lokealizacja
    for (int i=0; i<loc.length; i++) {
      String countryCode = loc[i].getCountry();  // kod kraju
      if (countryCode.equals("")) continue;
      kraj =  loc[i].getDisplayCountry();
      map.put(kraj, loc[i]);
    }

    String msg = "Podaj kraj";
    String in = "";
    while((kraj = JOptionPane.showInputDialog(msg)) != null ) {
      // Pobieramy lokalizację dla podanego kraju
      Locale savedLoc = (Locale) map.get(kraj);
      if (savedLoc == null) continue;
      msg = "Podaj kody języków, rozdzielone spacjami";
      while((in = JOptionPane.showInputDialog(null, msg, in)) != null ) {
        StringTokenizer st = new StringTokenizer(in);
        if (st.countTokens() == 0) continue;
        String rep = "Nazwa kraju " + kraj + ":\n";

        // Dla kolejnych kodów języków
        // uzyskujemy nazwę kraju w języku odpowiadającym
        // lokalizacji związanej z kodem jęsyka
        while(st.hasMoreTokens()) {
          Locale lang = new Locale(st.nextToken());
          rep += lang.getDisplayLanguage() + "   =   " +
                 savedLoc.getDisplayCountry(lang) + "\n";
        }
      JOptionPane.showMessageDialog(null,rep);
      }
      msg = "Podaj kraj";
    }
    System.exit(0);
  }
}

1.2. Formatowanie liczb

     NumberFormat nf = NumberFormat.getInstance();
     nf.setMaximumFractionDigits(3);
     String wynik = nf.format(d);
     System.out.println(wynik);

• statyczna metoda getInstance() zwraca obiekt formatujący - formator,
• za pomocą metody setMaximumFractionDigits(..) ustalamy, że ten formator ma formatować liczby w taki sposób, by maksymalna liczba cyfr po przecinku wynosiła 3,
• po czym za pomocą metody format uzyskujemy napis reprezeentujący liczbę d, z maksymalnie trzema miejscami po przecinku i wypisujemy wynik, który teraz będzie wyglądał tak: 3,333
• podkreślmy jeszcze raz (omawialiśmy to w poprzednim punkcie), że sposób formatowania liczb jest zależny od lokalizacji; zastosowana tu lokalizacja domyślna (polska) używa jako separatora miejsc dziesiętnych przecinka.
  
  

• stworzyć obiekt klasy DecimalFormat, podając jako argument konstruktora wzorzec formatowania,
• wywołać metodę format na rzecz tego obiektu.

     double d = 10/3.0;
     DecimalFormat dform = new DecimalFormat("###.###");
     String wynik = dform.format(d);
     System.out.println(wynik);

import java.text.*;
import java.math.*;

public class Format1 {

  public static void show(double n1, Double n2, BigDecimal n3,
                          String format) {
    DecimalFormat df = new DecimalFormat(format);
    System.out.println("Format " + format);
    System.out.println("Liczba: " +  n1 + " wygląda tak: " + df.format(n1));
    System.out.println("Liczba: " +  n2 + " wygląda tak: " + df.format(n2));
    System.out.println("Liczba: " +  n3 + " wygląda tak: " + df.format(n3));
  }


  public static void main(String[] args) {
    double num1  = 1.346;
    Double num2  = new Double(0.765474);
    BigDecimal num3 = new BigDecimal("100.2189091");

    show(num1, num2, num3, "#.##");
    show(num1, num2, num3, "#.## %");
    show(num1, num2, num3, "#.0000");
    show(num1, num2, num3, "#.00 ¤");
    show(num1, num2, num3, "#.00 ¤¤");
    show(num1, num2, num3, "[ 000.0 ]");

 }

}

    DecimalFormat df = (DecimalFormat)
                       NumberFormat.getInstance(new Locale("en", "US"));
    df.applyPattern(format);

• z każdą lokalizacją związany jest zestaw symboli używanych przy formatowaniu liczb (jest to obiekt klasy DecimalFormatSymbols),
• możemy go łatwo uzyskać od formatora dla domyślnej lokalizacji (metoda getDecimalFormatSymbols())
•  i zmienić wybrany symbol (za pomoca odpowiedniej metody klasy DecimalFormatSymbols).

DecimalFormat df = new DecimalFormat(format);  // formator w domyślnej lokalizacji
DecimalFormatSymbols sym = df.getDecimalFormatSymbols(); // symbole
sym.setDecimalSeparator('.');                  // ustalenie separatora miejsc dziesiętnych

• liczb całkowitych - metoda NumberFormat.getIntegerInstance(...)
• wartości wyrażonych w walucie - metoda NumberFormat.getCurrencyInstance(...)
• wartości w procentach - metoda NumberFormat.getPercentInstance(...)

• metoda parse(...) zwraca referencję do obiektu podklasy klasy Number, który - w zależności od wartości interpretowanego napisu może wskazywać na Long lub Double,
• napis podlega interpretacji jako liczba zgodnie z  lokalizacją (np. w polskiej lokalizacji użycie przecinka jako sepratora miejsc dziesiętnych),
• jeżeli formator  nie dotyczy walut, procentów i nie uzyskano go wg wzorca formatowania, który zawiera inne od specjalnych znaki, to przekształcanie napisu na liczbę będzie dokonywane dopóki można, tzn. dopóki kolejny znak będzie stanowił (w danej lokalizacji) część liczby, pozostałe znaki zostaną pominięte i nie wystąpi żaden wyjątek,
• dla prostego, ogólnego formatu liczbowego wyjątek wystąpi tylko wtedy, gdy początek napisu nie da się zinterpretować jako liczba (wyjątek klasy ParseException)
• przy interpretacji napisów wg specyficznych formatów (np. walutowego lub wg rozbudowanych wzorców formatowania) napis musi być zgodny z formatem i niezaleznie od tego czy niezgodność wystąpi na początku czy na końcu - powstanie wyjątek ParseException.

import javax.swing.*;
import java.text.*;

public class Parse1 {

  public static void main(String[] args) {
    NumberFormat format = NumberFormat.getInstance();
    String in,
           msg = "Podaj liczbę";
    Number num = null;
    while ((in = JOptionPane.showInputDialog(msg)) != null) {
      System.out.println("Wejście: " + in);
      try {
        num = format.parse(in);
      } catch (ParseException exc) {
          System.out.println("Wadliwe dane: " + in);
          System.out.println(exc);
          continue;
      }
      System.out.println("Parse daje: " +
                          num.getClass().getName()+ " = " + num);
    }
    System.exit(0);
  }

}

  public static void main(String[] args) {
    NumberFormat format = new DecimalFormat("[ #.0000 ]");
    //...
    while ((in = JOptionPane.showInputDialog(msg)) != null) {
      System.out.println("Wejscie: " + in);
      try {
        num = format.parse(in);
      } catch (ParseException exc) {
          System.out.println("Wadliwe dane: " + in);
          System.out.println(exc);
          System.out.println("Wadliwa pozycja: " + exc.getErrorOffset());
          continue;
      }
      System.out.println("Parse daje: " +
                          num.getClass().getName()+ " = " + num);
    }
  }

.import java.io.*;
import java.text.*;
import java.util.*;

public class Parse2 {

  public static void main(String[] args) {

    // Format walutowy w domyślnej lokalizacji
    // czyli w PL np. 12 zł
    NumberFormat format = NumberFormat.getCurrencyInstance();

    // Lista wartości wydatków (zapisanych w tekście pliku)
    List numList = new ArrayList();

    try {
      BufferedReader br = new BufferedReader(
                            new FileReader("testdata.txt")
                          );

      // czytanie kolejnych wierszu
      String in;
      while ((in = br.readLine()) != null) {

        int p = 0;                    // bieżący indeks rozbioru
        int last  = in.length() - 1;  // ostatni indeks w wierszu

        // Utworzenie pozycji rozbioru wiersza (od 0)
        ParsePosition ppos = new ParsePosition(0);

        // Dopóki nie dobiegliśmy do końca wiersza
        while (p <= last) {
           // Próbujemy pobrać kolejną liczbę w formacie walutowym
           Number num = format.parse(in, ppos);

           if (num == null)              // jeżeli błąd,
             p = ppos.getErrorIndex()+1; // indeks na znaku po błędzie
           else {                        // jeżeli udało się sczytać wartość
             numList.add(num);           // dodajemy ją do listy
             p =  ppos.getIndex();   // indeks na następnym znaku po
           }
           ppos.setIndex(p);         // ustawiamy następną pozycję
        }                            // od której kontynuacja rozbioru
      }
      br.close();
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }

    // Wypisanie i podsumowanie zapisanych w pliku wydatków
    System.out.println("Wydatki w zł:");
    double suma = 0;
    for (Iterator iter = numList.iterator(); iter.hasNext(); ) {
      Number val  = (Number) iter.next();
      System.out.println(val);
      suma += val.doubleValue();
    }
    System.out.println("Wydano w sumie: " + format.format(suma));
  }
}

• tworzymy obiekt klasy FieldPosition, podając w konstruktorze o jaki rodzaj pola chodzi,
• po czym przekazujemy go jako ostatni argument specjalnej wersji metody format, która ma też jako argumenty liczbę do sformatowania i StringBuffer do którego dołączany jest wynik formatowania,
• i po użyciu metody format(...) możemy dowiedzieć się od obiektu FieldPosition gdzie (na której pozycji) w  buforze wynikowym zaczyna się dane pole (metoda getBeginIndex()) i gdzie się kończy (metoda getEndIndex()).

public class ParseAndFormat {

  public static void main(String[] args) {

    // ... tutaj część analogiczna jak w poprzednim pzrykładzie
    // ... czytanie danych z pliku i parsowanie liczb wg formatu walutowego
    // ... dla przejrzystości format ten (uzyskiwany z getCurrencyInstance())
    // ... nazwano cform (nazwa zmiennej)

    // Wypisanie i podsumowanie przeczytanych z pliku wydatków
    // formatowanie wyjścia za pomocą metody align (zob. dalej)
    // w której używamy FieldPosition

    // Format wyjściowy - walutowy, z dwoma miejscami dziesiętnymi
    DecimalFormat outform = new DecimalFormat("#.00 ¤");

    System.out.println("Wydatki w : " +
                        cform.getCurrency().getSymbol()); // symbol waluty
    double suma = 0;
    int i = 1;
    final int DOTPOS = 30; // pozycja separatora miejsc dziesiętnych

    for (Iterator iter = numList.iterator(); iter.hasNext(); i++ ) {
      Number val  = (Number) iter.next();
      suma += val.doubleValue();
      System.out.println(
        align("Pozycja " + i, outform, val, DOTPOS)
      );
    }
    System.out.println(
        align("Wydano w sumie", outform, new Double(suma), DOTPOS)
    );
  }

  // Metoda wyrównująca liczby na separatorze miejsc dziesiętnuych
  // Liczba v formatowana zgodnie z formatem f
  // poprzedzona jest napisem msg
  // i taką liczbą kropek, by separatory miejsc dziesiętnych
  // były wyrównane na pozycji width

  static StringBuffer align(String msg, Format f, Number v, int width) {

    //Interesuje nas pole - część całkowita liczby
    FieldPosition fp = new FieldPosition(NumberFormat.INTEGER_FIELD);

    // Bufor do którego zapisywana jest sformatowana liczba
    // na początku bufora już zapisujemy msg (opis pozycji wydatków)

    StringBuffer out = new StringBuffer(msg);
    int msgLen = out.length();

    // formatowanie: v = liczba, out - bufor wynikowy, fp - opis pola
    f.format(v, out, fp);

    // Po sformatowaniu metoda fp.getEndIndex() zwraca
    // pozycję końca pola = części całkowitej liczby
    // łatwo obliczyć liczbę dodatkowych (dotNum) "wypełniaczy",
    // potrzebnych, by separator dziesiętny znalazł się na pozycji width

    int dotNum = width - fp.getEndIndex();

    // Wstawiamy do bufora - jako wypełniacze - kropki
    while (dotNum-- > 0) {
      out.insert(msgLen, '.');
    }
    return out;
  }

}

Wydatki w : zł
Pozycja 1..................123,00 zł
Pozycja 2...................77,77 zł
Pozycja 3..................999,99 zł
Wydano w sumie............1200,76 zł

• tablicę liczb typu double, określająca pólotwarte (z prawej strony) przedziały liczbowe,
• tablicę napisów, kojarzonych z przedziałami.

import java.text.*;

public class ChoiceForm {

  public static void main(String[] args) {
    double[] vals = {  -1, 0, 1, 10 };
    String[] msg  = { "x mniejsze od zera",
                      "0 <= x < 1",
                      "1 <= x < 10",
                      "x >= 10"
                    };
    ChoiceFormat cf = new ChoiceFormat(vals, msg);
    String in;
    while ((in = JOptionPane.showInputDialog("Podaj x")) != null) {
      double x = Double.parseDouble(in);
      String out = cf.format(x);
      System.out.println(x + " : " + out);
    }
  }

}

import javax.swing.*;
import java.text.*;

public class ChoiceForm2 {

  public static void main(String[] args) {
    String pattern =
     "0#brak jablek |0<niecala polowa jablka |"+
     "0.5#rowno pol jablka | 0.5<ponad polowa jablka |" +
     "1#jedno jablko |1<niecale dwa jablka |" +
     "2#dwa jablka |2<wiecej niż dwa jablka";

    ChoiceFormat cf = new ChoiceFormat(pattern);
    String in;
    while ((in = JOptionPane.showInputDialog("Ile jest jabłek?")) != null) {
      double x = Double.parseDouble(in);
      String out = cf.format(x);
      System.out.println("Podano: " + x + " Wynik: " +  out);
    }
  }

}

• SPELLOUT - przedstawianie liczb w postaci słownej,
• ORDINAL - przedstawianie liczb jako liczebników porządkowych (z odpowiednimi końcówkami),
• DURATION -  przekształcanie liczb na jednostki czasu (godziny, minuty, sekundy).

import com.ibm.icu.text.*;  // podpakiet ICU - dla RuleBasedNumberFormat
import java.util.*;         // Locale
import javax.swing.*;       // JOptionPane


class RuleBasedNumberFormatTest {

  public static void main(String[] args) {

    // Lokalizacje
    Locale[] loc = { new Locale("en"),
                     new Locale("es"),
                     new Locale("de"),
                     new Locale("ru"),
                   };

    // Tablica formatorów typu SPELLOUT - dla każdej lokalizacji jeden
    RuleBasedNumberFormat[] rbnfSpell =
                            new RuleBasedNumberFormat[loc.length];

    // Utworzenie formatorów SPELLOUT
    for (int i= 0; i < loc.length; i++) {
      rbnfSpell[i] = new RuleBasedNumberFormat(
                         loc[i], RuleBasedNumberFormat.SPELLOUT
                     );
    }

    // Wartości do formatowania
    long[] values = { 5, 9, 10, 12, 20, 23, 111, 1001 };

    // Jako SPELLOUT
    show(values, rbnfSpell);

    // Jako liczby porządkowe - tylko angielskie
    show(values,
         new NumberFormat[] { new RuleBasedNumberFormat(
                                 loc[0], RuleBasedNumberFormat.ORDINAL
                              )
                            }
        );

    // Formatowanie czasów wyrażonych w sekundach
    // Tylko lokalizacja angielska
    long[] times = { 12, 800, 3712, 9600 };
    show(times,
         new NumberFormat[] { new RuleBasedNumberFormat(
                                  loc[0], RuleBasedNumberFormat.DURATION
                              )
                            }
    );
    System.exit(0);
  }

  // Ogólna metoda formatująca i pokazująca wyniki
  // Argumenty: tablica liczb do sformatowania
  //            tablica formatorów

  static void show(long[] val, NumberFormat[] rbnf) {
    String msg = "";
    for (int i=0; i < val.length; i++) {
      msg += "\n" + val[i];
      for (int j=0; j<rbnf.length; j++) {
        msg += " = " + rbnf[j].format(val[i]);
      }
    }
    JOptionPane.showMessageDialog(null, msg);
  }

}

import com.ibm.icu.text.*;  // podpakiet ICU - dla RuleBasedNumberFormat
import java.util.*;         // Locale
import java.text.*;         // ParsePosition
import javax.swing.*;       // JOptionPane


class LenientParseTest {

  public static void main(String[] args) {

    // formator typu SPELLOUT
    RuleBasedNumberFormat rbnf = new RuleBasedNumberFormat(
                                     new Locale("en"),
                                     RuleBasedNumberFormat.SPELLOUT
                                 );

    // Ustalenie "luźnego" parsowania
    rbnf.setLenientParseMode(true);

    // Wartości do parsowania
    String[] snum = { "twenty-one", "TWENTYone",
                      "one hundred and one",
                      "one-hundred-and-one",
                      "one-hundred AND one",
                    };

    // Przekształcenie opisów na liczby

    for (int i=0; i< snum.length; i++) {
      Number val = rbnf.parse(snum[i], new ParsePosition(0));
      System.out.println(snum[i] + "   =   " + val);
    }

  }

}

1.3. Waluty

import java.util.*;

public class Waluty {

  public static void main(String[] args) {
    // Domyślna lokalizacja (w naszym przypadku polska)
    Locale def = Locale.getDefault();

    // Tablica dostępnych lokalizacji
    Locale[] loc = Locale.getAvailableLocales();

    char[] zera = { '0', '0', '0', '0', '0', '0' }; // do pokazu walut

    for (int i=0; i<loc.length; i++) {
      String countryCode = loc[i].getCountry();  // kod kraju
      String langCode = loc[i].getLanguage();    // kod języka
      if (countryCode.equals("")) continue;

      // lokalizacja opisana w języku domyślnej lokalizacji (polskim)
      String kraj =  loc[i].getDisplayCountry(def);
      String jezyk = loc[i].getDisplayLanguage(def);

      // Waluta dla lokalizacji loc[i]
      Currency c = Currency.getInstance(loc[i]);
      String sym  =  c.getSymbol();      // symbol w domyślnej lokalizacji (pl)
      String nsym = c.getSymbol(loc[i]); // symbol w danym kraju
      String icode = c.getCurrencyCode();     // międzynarod. kod waluty
      int cdig = c.getDefaultFractionDigits(); // ile może być miejsc dzies.

      System.out.println(loc[i]+" kraj: "+kraj+" język: "+jezyk +
        "\nwaluta: "+sym+" "+nsym+" "+icode +
                   " grosz = 1/1"+new String(zera,0,cdig)+" "+sym +
        "\n============================================================"
        );
     }
  }

}

import javax.swing.*;
import java.awt.*;
import java.util.Locale;
import com.ibm.icu.util.Currency;


public class Waluty1 {

  public static void main(String[] args) {

    Locale def = Locale.getDefault();
    Locale en =  new Locale("en", "US");


    // Tablica dostępnych lokalizacji
    Locale[] loc = Currency.getAvailableLocales();


    boolean[] b  = { false }; // dla getName() - oznacza normalny wynik
                              // w przeciwieństwie do wyniku dla ChoiceFormat

    String out = "";

    for (int i=0; i<loc.length; i++) {
      String kraj =  loc[i].getDisplayCountry(def);
      if (kraj.equals("")) continue;
      String lang = loc[i].getDisplayLanguage(def);
      String variant = loc[i].getVariant();

      // Waluta dla lokalizacji loc[i]
      Currency c = Currency.getInstance(loc[i]);

      String icode = c.getCurrencyCode();     // międzynarod. kod waluty

      // symbol w danym kraju
      String sym  =  c.getName(loc[i], Currency.SYMBOL_NAME, b);
      // nazwa w danym kraju
      String name = c.getName(loc[i], Currency.LONG_NAME, b);
      // nazwa po angielsku
      String enName = c.getName(en, Currency.LONG_NAME, b);


      out += kraj + " " + lang + " " + variant +
        "\nwaluta: "+icode+" "+sym+
        "\n"+ name + '\n' + enName +
        "\n------------------------------------------\n";
     }

     JFrame f = new JFrame();
     JTextArea ta = new JTextArea();
     ta.setFont(new Font("Dialog", Font.BOLD, 14));
     ta.setText(out);
     f.getContentPane().add(new JScrollPane(ta));
     f.pack();
     f.show();
  }

}

1.4. Strefy czasowe

import java.util.*;

public class Strefy0 {

  public static void main(String[] args) {
    TimeZone tz = TimeZone.getDefault();

    // --- Informacje o strefie czasowej

    // identyfikator strefy
    String id = tz.getID();

    // różnica względem czasu standardowego (UCT)
    int diff = tz.getRawOffset();

    // czy strefa używa czasu letniego
    boolean useDST = tz.useDaylightTime();

    // ile czasu trzeba dodać do lokalnego zegara
    // aby uzyskać czas bez ew. przesunięcia letniego
    int dstSav = tz.getDSTSavings();

    // Nazwa strefy
    String defName = tz.getDisplayName();

    // Krótka nazwa strefy
    String shortName = tz.getDisplayName(useDST, TimeZone.SHORT);

    // Nazwa strefy w podanym języku
    String locName = tz.getDisplayName(new Locale("fr"));

    // Dluga nazwa strefy
    String fullName = tz.getDisplayName(useDST, TimeZone.LONG);

    // Długa nazwa strefy w podanym języku
    String locFullName = tz.getDisplayName(useDST, TimeZone.LONG,
                         new Locale("es"));

    // Jaka jest aktualna różnica czasu TERAZ wobec UCT,
    // z uwzględnieniem czasu letniego
    Date teraz = new Date();
    long ms = teraz.getTime();
    int offset = tz.getOffset(ms);


    System.out.println("ID = " + id);
    System.out.println("RawOffset = " + diff);
    System.out.println("useDaylightTime = " + useDST);
    System.out.println("DSTSavings = " + dstSav);
    System.out.println("DisplayName = " + defName);
    System.out.println("DisplayName short = " + shortName);
    System.out.println("DisplayName full = " + fullName);
    System.out.println("DisplayName locale(\"fr\") = " + locName);
    System.out.println("DisplayName full locale(\"es\") = " + locFullName);
    System.out.println("Offset = " + offset);
  }

}

• identyfikatory stref są podawane w różnej postaci, najcześciej: region/miasto; trzyliterowe identyfikatory stref czasowych (takie jak np. CET, AST, CST) są również dostępne, ale nie powinny być używane ze względu na niejednoznaczność (CST - to zarówno U.S. Central Standard Time jak i China Standard Time); UTC, GMT i Zulu - oznaczają czas standardowy;
• nasza strefa czasowa - to czas środkowoeuropejski, mający tu pierwszy dostępny identyfikator Europe/Belgrad,
• różnice czasu podawane są w milisekundach,
• raw offset - pokazuje aktualną różnicę wobec czasu standardowego (UTC) bez uwzględnienia przesunięcia czasu letniego; jest to czas, który trzeba dodać do UTC, aby uzyskać "prawdziwą" godzinę  (nie przesuniętą z uwagi na czas letni)
• różnica czasu dla podanej daty wobec UTC z uwzględnieniem czasu letniego pokazywana jest przez metodę getOffset().

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Strefy1 {

  public static void main(String[] args) {

    // Konstruowanie stref czasowych
    TimeZone myTz = TimeZone.getTimeZone("Europe/Warsaw");
    TimeZone java = TimeZone.getTimeZone("Asia/Jakarta");
    TimeZone cuba = TimeZone.getTimeZone("America/Havana");

    // za pomocą pokazanej dalej metody getDiffMsg
    // wyliczamy i pokazujemy aktualną różnicę czasu
    // pomiędzy sterfami czasowymi

    System.out.println(getDiffMsg(myTz, java));
    System.out.println("--------------------------------------------------");
    System.out.println(getDiffMsg(myTz, cuba));
    System.out.println("--------------------------------------------------");
    System.out.println(getDiffMsg(cuba, java));
    System.out.println("--------------------------------------------------");

    // Jakie strefy czasowe mają podaną różnicę czasu wobec GMT

   for (int k = 12; k <= 14; k++) {
     String[] ids = TimeZone.getAvailableIDs(k*3600000);
     Arrays.sort(ids);
     System.out.println(
      "Strefy czasowe mające różnice +" + k + " godzin wobec GMT" );
     for (int i=0; i < ids.length; i++) {
       System.out.println(ids[i]);
     }
     System.out.println("--------------------------------------------------");
   }
  }

  static String getDiffMsg(TimeZone z1, TimeZone z2) {
    Date data = new Date();
    long teraz = data.getTime();
    double offset1 = z1.getOffset(teraz)/3600000.0;
    double offset2 = z2.getOffset(teraz)/3600000.0;
    double diff;
    if (offset1 > offset2)  diff = -(offset1 - offset2);
    else diff = offset2 - offset1;
    String out =  "Różnica czasu pomiędzy" + '\n' +
                  z1.getID() + " i " + z2.getID()  + '\n' +
                  "wynosi teraz : " + diff + " godz."  + '\n' +
                  "W strefie " + z1.getID() +
                       (z1.inDaylightTime(data) ? " " : " nie ") +
                       "działa czas letni"  + '\n' +
                  "W strefie " + z2.getID() +
                       (z2.inDaylightTime(data) ? " " : " nie ") +
                       "działa czas letni";

    return out;
  }

}

1.5. Kalendarze

import java.util.*;

public class Kal1 {

  public static void say(String s) { System.out.println(s+'\n'); }

  public static void main(String[] args) {

    // uzyskanie kalendarza domyślnego
    // (obowiązującgo dla domyślnej lokalizacji - tu dla Polski)
    // ustawionego na bieżącą datę i czas

    Calendar cal = Calendar.getInstance();

    say("ERA.............. " + cal.get(Calendar.ERA) +
        " (tu: 0=pne, 1=AD)");

    say("ROK.............. " + cal.get(Calendar.YEAR));
    say("MIESIĄC.......... " + cal.get(Calendar.MONTH) +
        " (0-styczeń, 2-luty, ..., 11-grudzień)");

    say("LICZBA DNI\n" +
        "W MIESIĄCU....... " + cal.getActualMaximum(Calendar.DAY_OF_MONTH));

    say("DZIEŃ MIESIĄCA... " + cal.get(Calendar.DAY_OF_MONTH));
    say("DZIEŃ MIESIĄCA... " + cal.get(Calendar.DATE));
    say("TYDZIEŃ ROKU..... " + cal.get(Calendar.WEEK_OF_YEAR));
    say("TYDZIEŃ MIESIĄCA. " + cal.get(Calendar.WEEK_OF_MONTH));
    say("DZIEŃ W ROKU..... " + cal.get(Calendar.DAY_OF_YEAR));

    say("PIERWSZY DZIEŃ\n" +
        "TYGODNIA......... " + cal.getFirstDayOfWeek() +
        " (1-niedziela, 2-poniedziałek, ..., 7 sobota)");

    say("DZIEŃ TYGODNIA... " + cal.get(Calendar.DAY_OF_WEEK) +
        " (1-niedziela, 2-poniedziałek, ..., 7-sobota)");

    say("GODZINA.......... " + cal.get(Calendar.HOUR) +
        " (12 godzinna skala; następne odwolanie czy AM czy PM)");

    say("AM/PM............ " + cal.get(Calendar.AM_PM) +
        " (AM=0, PM=1)");

    say("GODZINA.......... " + cal.get(Calendar.HOUR_OF_DAY) +
        " (24 godzinna skala)");

    say("MINUTA........... " + cal.get(Calendar.MINUTE));
    say("SEKUNDA.........  " + cal.get(Calendar.SECOND));
    say("MILISEKUNDA:      " + cal.get(Calendar.MILLISECOND));

    int msh = 3600*1000; // liczba milisekund w godzinie

    say("RÓŻNICA CZASU\n" +
        "WOBEC GMT........ " + cal.get(Calendar.ZONE_OFFSET)/msh);

    say("PRZESUNIĘCIE\n" +
        "CZASU............ " + cal.get(Calendar.DST_OFFSET)/msh +
        " (w Polsce obowiązuje w lecie)");

  }

}

ERA.............. 1 (tu: 0=pne, 1=AD)

ROK.............. 2003

MIESIĄC.......... 4 (0-styczeń, 2-luty, ..., 11-grudzień)

LICZBA DNI
W MIESIĄCU....... 31

DZIEŃ MIESIĄCA... 6

DZIEŃ MIESIĄCA... 6

TYDZIEŃ ROKU..... 19

TYDZIEŃ MIESIĄCA. 2

DZIEŃ W ROKU..... 126

PIERWSZY DZIEŃ
TYGODNIA......... 2 (1-niedziela, 2-poniedziałek, ..., 7 sobota)

DZIEŃ TYGODNIA... 3 (1-niedziela, 2-poniedziałek, ..., 7-sobota)

GODZINA.......... 6 (12 godzinna skala; następne odwolanie czy AM czy PM)

AM/PM............ 1 (AM=0, PM=1)

GODZINA.......... 18 (24 godzinna skala)

MINUTA........... 5

SEKUNDA.........  0

MILISEKUNDA:      550

RÓŻNICA CZASU
WOBEC GMT........ 1

PRZESUNIĘCIE
CZASU............ 1 (w Polsce obowiązuje w lecie)

• set - ustala wartość pola; jeśli trzeba  dostosowując inne pola (np. ustawienie pola DAY_OF_MONTH na wartość 31 dla kalendarza ustawionego na dowolną datę w czerwcu spowoduje, że kalendarz będzie wskazywał na 1 lipca, gdyż w czerwcu jest tylko 30 dni),
• add  - dodaje do pola podaną wartość, stosując przy tym arytmetykę kalendarzową (np. dodanie do 30 maja 2 dni spowoduje ustawienie kalendarza na  1 czerwca),
• roll - również wykonuje dodawanie, ale przy tym nie zmienia wartości "starszych" pól np. jeżeli dodajemy dni i okaże się, że nowa data znajdzie się w innym niż teraz miesiącu, to miesiąc nie zostanie zmieniony, zaś "nadwyżka" dni (poza końcem bieżącego miesiąca) będzie dodawana od początku miesiąca.

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

public class TestKal {

  public static void main(String[] args) {
    String in;
    int d = 0;
    while ((in = JOptionPane.showInputDialog("DATE:")) != null) {
      d = Integer.parseInt(in);
      show("set",  "DATE", Calendar.DATE, d);
      show("add",  "DATE", Calendar.DATE, d);
      show("roll", "DATE", Calendar.DATE, d);
    }
    System.exit(0);
  }

  static void say(String s) { System.out.println(s); }


  static void show(String oper, String what, int field, int value) {
    Calendar c = Calendar.getInstance();
    say("Teraz jest: " + c.getTime());
    say("Operacja: " + oper + "(Calendar." + what + ", " + value + ")");
    if (oper.equals("set")) c.set(field, value);
    else if (oper.equals("add")) c.add(field, value);
         else if (oper.equals("roll")) c.roll(field,value);

    say("Aktualne ustawienia kalendarza: " + c.get(Calendar.YEAR) + '/'
                               + (c.get(Calendar.MONTH) + 1) + '/' +
                               + c.get(Calendar.DATE));
     say("-----------------------------------------------------------");
  }

}

• porównywania dat (bowiem w klasie Date zdefiniowano metodę compareTo(...), której brakuje w klasie Calendar),
• szybkiem uzyskiwaniu standardowej angielskiej postaci napisów reprezentujących daty (poprzez bezpośrednie lub automatyczne zastosowanie metody toString(); jest ona stosowana automatycznie przy konkatenacji napisu i zmiennej typu Date lub przekazaniu argumentu typu Date metodzie println),
• oraz - co szczególnie ważne - przy formatowaniu dat i czasu za pomocą metody format(...) formatorów daty i czasu (której argument jest referencją do obiektu klasy Date) oraz przy przekształcaniu znakowej postaci dat i czasy do obiektów klasy Date za pomocą metody parse(...) klasy DateFormat.

• dla domyślnej lokalizacji, ale ustawiony na podaną strefę czasową (Calendar.getInstance(TimeZone)),
• dla podanej lokalizacji (Calendar.getInstance(Locale)),
• dla podanej lokalizacji i strefy czasowej (Calendar.getInstance(TimeZone,Locale)),

    TimeZone tz = TimeZone.getTimeZone("Asia/Jakarta");
    Calendar c = Calendar.getInstance(tz);
    System.out.println("Current time: " + c.getTime());
    System.out.println("Java time: " +
         c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE));

    Calendar c = Calendar.getInstance();
    System.out.println(c.getClass().getName());
    c = Calendar.getInstance(new Locale("th", "TH"));
    System.out.println(c.getClass().getName());

import com.ibm.icu.util.*;
import com.ibm.icu.text.*;

public class MiscCal {

  public static void main(String[] args) {
    Calendar[] kal = {
               Calendar.getInstance(),   // domyślny kalendarz - gregoriański
               new GregorianCalendar(),  // jeszcze raz - ale inaczej tworzony
               new BuddhistCalendar(),   // buddyjski
               new ChineseCalendar(),    // chiński
               new JapaneseCalendar(),   // japoński
               new IslamicCalendar(),    // islamski
               new HebrewCalendar(),     // hebrajski
               };
    java.util.Date teraz = new java.util.Date(); // aktualny czas
    System.out.println("Teraz jest: " + teraz);  // po angielsku

    // przebiegamy po klaendarzach
    // ustawiamy je na bieżący czas
    // i pokazujemy wartości takich pól jak rok, miesiąc itp.

    for (int i=0; i<kal.length; i++) {
      kal[i].setTime(teraz);
      String className = kal[i].getClass().getName();
      String name = className.substring(className.lastIndexOf(".") + 1);
      System.out.println(name + " - " +
            "era " + kal[i].get(Calendar.ERA) +
            "; rok " + kal[i].get(Calendar.YEAR) +
            (name.equals("ChineseCalendar") ?
                  " czyli " + kal[i].get(Calendar.EXTENDED_YEAR)  : "") +
            "; mies " + kal[i].get(Calendar.MONTH) +
            "; dzień mies. " + kal[i].get(Calendar.DAY_OF_MONTH) +
            "; dzień tyg. " + kal[i].get(Calendar.DAY_OF_WEEK)
            );
    }
  }

}

import com.ibm.icu.util.Calendar;
import java.util.Locale;
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;
import java.text.DateFormatSymbols;

public class FirstDoW {

  public static void main(String[] args) {
    // Domyślna lokalizacja (w naszym przypadku polska
    Locale def = Locale.getDefault();

    // Chcemy mieć dni tygodnia po polsku
    DateFormatSymbols dafs = new DateFormatSymbols(def);
    String[] wdays = dafs.getWeekdays();  // dni tygodnia po polsku


    // Tablica dostępnych lokalizacji (z pakietu ICU!!!)
    Locale[] loc = Calendar.getAvailableLocales();

    // Mapa: klucz = kraj, wartość = piewrwszy dzień tygodnia
    Map fdowMap = new TreeMap();

    for (int i=0; i<loc.length; i++) {

      // Uzyskanie kalendarza dla danej lokalizacji
      // (będą to kalendzrae gregoriańskie, bo taka jest właściwość pakietu ICU)
      Calendar c = Calendar.getInstance(loc[i]);

      // indeks pierwszego dnia tygodnia w tym kalendarzu
      int fdow = c.getFirstDayOfWeek();
      // jeżeli to poniedziałek - nie interesuej nas
      if (fdow == 2) continue;

      // lokalizacja opisana w języku domyślnej lokalizacji (polskim)
      String country = loc[i].getDisplayCountry(def);
      if (country.equals("")) continue; // pomijamy te bez kraju

      if (!fdowMap.containsKey(country)) fdowMap.put(country, wdays[fdow]);
    }

    System.out.println("Gdzie pierwszy dzień tygodnia nie jest poniedziałkiem?");
    for (Iterator it = fdowMap.keySet().iterator(); it.hasNext(); ) {
      // Jaki jest pierwszy dzień tygodnia
      String country = (String) it.next();
      String fday = (String) fdowMap.get(country);
      System.out.println(country  +  " = " + fday);
    }
  }

1.6. Formatowanie dat

• formator dla dat - metody getDateInstance(...)
• formator dla czasu - metody getTimeInstance(...)
• formator dla daty i czasu - metody getDateTimeInstance(...)
• domyślny formator dla daty i czasu - metoda getInstance().

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

public class Daty {

  public static void main(String[] args) {
    Date teraz = new Date();

    int[] styles = { DateFormat.SHORT, DateFormat.MEDIUM,
                     DateFormat.LONG, DateFormat.FULL };

    String outMsg = "";

    for (int i=0; i < styles.length; i++) {

      DateFormat df = DateFormat.getDateTimeInstance(
                                    styles[i],          // styl daty
                                    DateFormat.FULL     // styl czasu
                      );

      outMsg += df.format(teraz) + '\n' + "-----------------\n" ;
    }
    System.out.println(outMsg);


    Locale[] llist = { new Locale("de"),
                       new Locale("fr"),
                       new Locale("es"),
                       new Locale("ar"),
                       new Locale("ru"),
                       new Locale("th")
                     };
    outMsg = "";
    for (int i=0; i < llist.length; i++) {
      DateFormat df = DateFormat.getDateTimeInstance(
                                    DateFormat.FULL,    // styl daty
                                    DateFormat.FULL,    // styl czasu
                                    llist[i]            // lokalizacja
                      );
      outMsg += df.format(teraz) + '\n' + "-----------------\n" ;
    }
    JOptionPane.showMessageDialog(null, outMsg);
    System.exit(0);
  }

}

• dla składowych typu Tekst : jeśli przy formatowaniu powtórzono literę 4 lub więcej razy stosowana jest pełna forma (np. EEEE - "wtorek"), przy parsowaniu - liczba liter nie ma znaczenia,
• dla składowej typu Rok:  jeśli podano dwie litery YY - dostaniemy dwie cyfry roku, w przeciwnym  razie rok jest traktowany jako typu Liczba,
• dla składowych typu Miesiąc: jeśli podano 3 lub więcej liter mamy miesiąc w postaci słownej (traktowany jak Tekst), w przeciwnym razie jako typu Liczba,
  
• dla składowych typu Liczba:  liczba liter określa minimalną liczbę cyfr (nie ma to znaczenia przy parsowaniu, o ile nie trzeba oddzielać dwóch stycznych pól).

import java.util.*;

public class Daty1 {

  public static void main(String[] args) {

    Calendar c = Calendar.getInstance();
    Date teraz = c.getTime();

    SimpleDateFormat df = (SimpleDateFormat) DateFormat.getDateInstance();

    String[] pattern = {"dd-MM-yyyy",
                        "MMMM, 'dzień 'dd ( EE ), 'roku 'yyyy GGGG",
                        "EEEE, dd MMM yyyy 'r.'"
                       };
    for (int i=0; i<pattern.length; i++) {
      df.applyPattern(pattern[i]);
      System.out.println(df.format(teraz));
    }

  }

}

   public static void main(String[] args) {


    SimpleDateFormat df = (SimpleDateFormat) DateFormat.getDateInstance();

    String[] pattern = {"dd-MM-yyyy",
                        "MMMM, 'dzień 'dd ( EE ), 'roku 'yyyy GGGG",
                        "EEEE, dd MMM yyyy 'r.'"
                       };

    for (int i=0; i<pattern.length; i++) {

      String in=JOptionPane.
                showInputDialog("Wprowadź datę wg wzorca " + pattern[i]);
      df.applyPattern(pattern[i]);
      Date data = df.parse(in, new ParsePosition(0));
      System.out.println(data);
    }
  }

import java.util.*;
import java.text.*;
import java.awt.*;
import javax.swing.*;

public class DateFormatSymbolsShow {

  String[] lang = { "fr", "es", "de", "ru" };

  String out = "";

  public DateFormatSymbolsShow() {
    for (int i=0; i<lang.length; i++) {
      Locale  loc = new Locale(lang[i]);
      DateFormatSymbols dfs = new DateFormatSymbols(loc);
      out += '\n' + loc.getDisplayLanguage();
      // nazwy er
      addToOut("Ery: ", dfs.getEras());
      // nazwy miesięcy
      addToOut("Miesiące: ", dfs.getMonths());
      // skróty miesięcy
      addToOut("Miesiące - skróty: ", dfs.getShortMonths());
      // nazwy dni tygodnia
      addToOut("Dni tygodnia: ", dfs.getWeekdays());
      // skróty nazw dni tygodnia
      addToOut("Dni tygodnia - skróty: ", dfs.getShortWeekdays());
    }
    JTextArea ta = new JTextArea(out);
    ta.setFont(new Font("Dialog", Font.BOLD, 14));
    JFrame f = new JFrame();
    f.getContentPane().add(ta);
    f.pack();
    f.show();
  }

  void addToOut(String msg, String[] s) {
    out += "\n" + msg;
    for (int i=0; i<s.length; i++) {
      out += ' ' + s[i];
    }
  }

  public static void main(String[] args) {
    new DateFormatSymbolsShow();
  }

}

import java.util.*;
import java.text.*;

public class DateFormatPol {

  public static String polskaData(Date data) {
    String[] mies = { "stycznia", "lutego", "marca", "kwietnia",
                      "maja", "czerwca", "lipca", "sierpnia",
                      "września", "października", "listopada",
                      "grudnia"
                    };
    DateFormatSymbols dfs = new DateFormatSymbols();
    dfs.setMonths(mies);
    SimpleDateFormat df = new SimpleDateFormat("dd MMMM yyyy", dfs);
    return df.format(data);
  }



  public static void main(String[] args) {
    System.out.println( polskaData( new Date() ) );
  }

}

1.7. Zlokalizowany rozbiór tekstów

• pobranie indeksu pierwszej pozycji podziału tekstu na elementy (zdania, wiersza etc) - metoda first().
• pobranie indeksu ostatniej pozycji podziału tekstu na elementy (zdania, wiersza etc)  - metoda last(),
• pobranie indeksu  następnej pozycji podziału tektsu na elementy (zdania, wiersza etc) - metoda next(),
• pobranie indeksu  poprzedniej pozycji podziału tektsu na elementy (zdania, wiersza etc) - metoda previous(),
• swobodny wybór elementów tekstu - np. pobranie indeksu poz ycji podziału tekstu oddalonego o n pozycji od bieżącego "w przód" lub  "w tył" - metody next(int n) lub preceding(int n).

import java.text.BreakIterator;

public class BreakIteratorTest {

  // Metoda wypisująca na konsoli
  //  - zdania - jeśli przekazano jako argument typ wartość 0
  //  - lub słowa - jeśli przekazano jako argument typ wartość 1
  // wyodrębnione z tekstu txt

  private static void show(int typ, String txt) {
    String[] head = { "Zdania", "Słowa" }; // Nagłówek: dla typ==0 "Zdania"
                                           //           dla typ==1 "Słowa"

    // Uzyskanie odpowiedniego breakiteratora
    // dla typ == 0 będzie to iterator "po zdaniach"
    // dla typ == 1 będzie to iterator "po słowach"
    BreakIterator bri = (typ == 0 ? BreakIterator.getSentenceInstance()
                                  : BreakIterator.getWordInstance()
                        );
    System.out.println(head[typ]); // Wypisanie nagłówka

    // Po stworzeniu iteratora a przed jego użyciem
    // należy ustalić tekst, który będzie przetwarzany

    bri.setText(txt);

    // Iterowanie

    int start = bri.first();  // pozycja pierwszego podziału na elementy
    int end   = bri.next();   // pozycja następnego podziału na elementy

    while (end != BreakIterator.DONE) { // dopóki można dzielić tekst

      // Wyodrębniamy element
      String elt = txt.substring( start, end);

      // Wypisujemy element jeżeli to jest iterator dla zdań
      // albo jeżeli to jest iterator dla słów, a elementem jest słowo
      // Czy to jest słowo stwierdzamy za pomocą metody
      // isIteratorWord(...) - zob. dalej

      if (typ == 0 | (typ == 1 && isIteratorWord(elt)))
         System.out.println(start + ": " +  elt);


      start = end;        // początek następnego (po wypisanym) elementu
      end = bri.next();   // pozycja  następnego podziału
    }
  }

  // Metoda stwierdza czy element wyodrębniony przez iterator słów
  // jest słowem. Będzie nim każdy element, który zawiera choć jedną
  // literę lub cyfrę. Czy dany znak jest literą lub cyfrą
  // stwierdzamy za pomocą statycznej metody z klasy Character
  // Character.isLetterOrDigit(znak)

  private static boolean isIteratorWord(String elt) {
    int l = elt.length();
    for (int i=0; i < l; i++)
      if (Character.isLetterOrDigit(elt.charAt(i))) return true;
    return false;
  }


  public static void main(String[] args) {

    String s = "Ala Kot-Kotowska ma kota. A mleko? "+
               "Pies go wychłeptał (swobodnie) - 0.1 litra. " +
               "Tak? Nie! Chyba nie... A może? Byłażby to \"hańba\"?!!!";

    show(0, s); // pokaż zdania
    show(1, s); // pokaż słowa
  }

}

1.8. Porównywanie i sortowanie napisów

• uzyskać kolator dla lokalizacji domyslnej (polskiej) - metoda Collator.getInstance(),
• podać ten kolator jako komparator w metodzie Arrays.sort(...) 

import java.util.*;
import java.text.*;

public class Kolator0 {

  static void sortShow(String msg, String[] txt, Collator col) {
    String[] copyTxt = (String[]) txt.clone();
    Arrays.sort(copyTxt, col);
    System.out.println(msg);
    for (int i=0; i < copyTxt.length; i++) {
      System.out.println(copyTxt[i]);
    }
  }


  public static void main(String[] args) {
    String[] txt = { "bela", "Ala", "ą", "Ą", "ą", "ala" , "Be", "Ala",
                     "alabama", "be", "Be", "1", "ć", "my", "My", "Myk", "myk"  };
    Collator col = Collator.getInstance();
    sortShow("Sort pol", txt, col);
    Collator col1 = Collator.getInstance(new Locale("en"));
    sortShow("Sort en", txt, col1);
  }

}

• podstawowy (PRIMARY), w którym rozróżniane są (zdefiniowane w zestawie reguł  jako rozróżnialne) znaki,
• drugorzędny (SECONDARY) , który określa porządek napisów identycznych ze względu na porządek podstawowy, ale różniących się akcentowanymi znakami (to dotyczy np. języków francuskiego, hiszpańskiego, angielskiego),
• trzeciorzędny (TERTIARY), który napisy identyczne wedle dwóch poprzednich porządków rozróżnia na podstawie wielkości liter,
• identyczności (IDENTICAL): rozróżniający wszelkie znaki, nawet te uznane za takie same wedle trzech poprzednicj porządków (np. w wielu lokalizacjach znaki \u0001 i \u0002 są uznawane za takie same wedle trzech w/w porządków, natomiast porządek identyczności będzie je rozróżniał)
  

  public static void main(String[] args) {
    String[] txt = { "bela", "Ala", "ą", "Ą", "ą", "ala" , "Be", "Ala",
                     "alabama", "be", "Be", "1", "ć", "my", "My", "Myk", "myk"  };
    Collator col = Collator.getInstance();
    sortShow("Sort TERTIARY", txt, col);
    col.setStrength(Collator.PRIMARY);
    sortShow("Sort PRIMARY", txt, col);
}

    Collator col = Collator.getInstance();
    String rules = ((RuleBasedCollator) col).getRules();

import java.util.*;
import java.text.*;

public class Kolator1 {

  static void sortShow(String msg, String[] txt, final Collator col) {
    String[] copyTxt = (String[]) txt.clone();
    Arrays.sort(copyTxt, col);
    System.out.println(msg);
    for (int i=0; i < copyTxt.length; i++) {
      System.out.println(copyTxt[i]);
    }
  }


  public static void main(String[] args) {

    // Napisy do posortowania
    String[] txt = { "bela", "Ala", "ą", "Ą", "ą", "ala" , "Be", "Ala",
                     "alabama", "be", "Be", "1", "Ćwikła", "ćwikła",
                     "ćwikla", "Polska",
                     "My", "my", "Myk", "myk"  };

    // Domyślny polski kolator
    Collator col = Collator.getInstance();
    sortShow("Default sort", txt, col);

    // Nowe reguły
    String rules = " < Polska < A < Ą < B < C < Ć < D < E < Ę < F < G < H" +
                  " < I < J < K < L < Ł < M < N < Ń < O < P < Q < R < S < Ś" +
                  " < T < U < V < W < X < Y < Z < Ź " +
                  " < a < ą < b < c < ć < d < e < ę < f < g < h" +
                  " < i < j < k < l < ł < m < n < ń < o < p < q < r < s < ś" +
                  " < t < u < v < w < x < y < z < ź";

    try {
      col = new RuleBasedCollator(rules);
    } catch (ParseException exc) {
        System.out.println("Wadliwa reguła na pozycji " + exc.getErrorOffset());
        System.out.println(exc);
        System.exit(1);
    }

    sortShow("My new rules sort", txt, col);

  }

}

• stworzyć kolekcję lub tablicę na przechowywanie kluczy (obiektó klasy CollationKeys),
• dla każdego napisu, który ma podlegać porządkowaniu (sortowaniu) uzyskąc klucz do kolatora za pomocą wywołania metody getCollationKey(napis) z klasy Collator,
• wstawić klucz do tablicy lub kolekcji,
• posortować tablicę lub kolekcję,
• teraz klucze w tablicy/kolekcji są ustwaione w porządku napisów, określanym przez kolator
• żeby pokazać wynik sortowania przebiegamy tablicę/kolekcję kluczy i od każdgeo klucza za pomocą odwołania getSourceString() uzyskujemy skojarzony z nim napis.

import java.util.*;
import java.text.*;

public class Kolator2 {

  public static void main(String[] args) {

    // Napisy do posortowania
    String[] txt = { "bela", "Ala", "ą", "Ą", "ą", "ala" , "Be", "Ala",
                     "alabama", "be", "Be", "1", "Ćwikła", "ćwikła",
                     "ćwikla", "Polska",
                     "My", "my", "Myk", "myk"  };

    // Domyślny polski kolator
    Collator col = Collator.getInstance();

    // Lista kluczy
    List keys = new ArrayList();

    // Uzyskanie kluczy dla napisów
    // wartości kluczy uzyskujemy od kolatora
    for (int i=0; i<txt.length; i++) {
      CollationKey key = col.getCollationKey( txt[i] );
      keys.add(key);
    }

    // Sortowanie
    // porównywane mogą być tylko klucze uzyskane od tego samego kolatora!

    Collections.sort(keys);

    // Pokazanie wyniku
    // mamy klucze ułożone w określonym porządku napisów, które reprezentują
    // musimy pobrać napis skojarzony z kluczem

    for (Iterator it = keys.iterator(); it.hasNext(); ) {
      CollationKey key = (CollationKey) it.next();
      String napis = key.getSourceString();
      System.out.println(napis);
    }
  }

}

1.9. Internacjonalizacja aplikacji i dodatkowe zasoby (resource bundle)

import java.util.*;

public class Hello {

  static void sayHello() {
    Locale defLoc = Locale.getDefault();
    ResourceBundle msgs =
                   ResourceBundle.getBundle("HelloMessages", defLoc);
    String powitaj  = msgs.getString("hello");
    String pozegnaj = msgs.getString("bye");
    System.out.println(powitaj);
    System.out.println(pozegnaj);
 }


  public static void main(String[] args) {
    sayHello(); // tutaj działa domyślna lokalizacja pl_PL
    // zmieniamy domyślną lokalizację
    Locale.setDefault(new Locale("en"));
    sayHello();
  }

}

• pierwsza para napisów powstaje, gdyż domyślną lokalizacją jest pl_PL, getBundle(defLoc) nie znajduje pliku właściwości o takim sufiksie, ale znajduje bliski mu z sufiksem pl, 
• przy drugim odwołaniu do sayHello poszukiwany jest plik HelloMessages_en.properties, a ponieważ go nie ma - używany jest domyślny HelloMessages.properties

• mają nazwy zgodne z opisaną wcześniej (przy okazji plików własciwości) konwencją  (sufiksy wskazujące na lokalizację)
• dziedziczą klasęe ListResourceBundle,
• dostarczają publicznej metody Object[][] getContents() która zwraca tablicę odpowiedniości klucze - wartości, przy czym zaróno klucze jak i odpowiadające im wartości mogą być dowolnymi obiektami.

public class CountryInfo_pl_PL extends ListResourceBundle {

   public Object[][] getContents() {
	return contents;
    }

    private Object[][] contents = {
	{ "name", "Polska" },
	{ "flag",  new ImageIcon("PolskaFlaga.gif" },
    };
}

ResourceBundle info =
		ResourceBundle.getBundle("CountryInfo", currentLocale);

String nazwaKraju = info.getString("name");
ImageIcon flaga = (ImageIcon) info.getObject("flag");

1.10. Zadania i ćwiczenia

1. Dokonać internacjonalizacji aplikacji Owoce (z części B), tak by możliwe było jej własciwe działanie w lokalizacji polskiej i angielskiej. Przy wydruku rachunku  z kasy podać godzinę. Uwzględnić właściwie dla danych lokalizacji: nazwy owoców, formaty liczb, waluty, formaty dat i czasu.
2. Samodzielnie opanować posługiwanie się klasą MessageFormat. Użyć jej dla zlokalizowanego traktowania liczby mnogiej liczebników (np. 1 kosz owowców, 2 kosze owoców). W jaki sposób możemy tu użyć klasy ChoiceFormat? A jak zdefiniuejmy reguły dla korzystania z klasy RuledBasedFormat pakietu ICU?