package data;
import java.io.FileReader;
import java.io.IOException;
import java.nio.CharBuffer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CharacterCounter {
 /**
  * Vytvoříme metodu, která vrátí počet
  * znaků v souboru
  * 
  * @param file
  * @return
  * @throws IOException
  */
 public int getNumberOfCharactersInFile(
   String file) throws IOException {
  FileReader inputStream = null;
  // Vytvořím si proměnnou, do které
  // budeme ukládat počet načtených
  // znaků
  int counter = 0;
  try {
   // Vytvořím vstupní proud
   inputStream = new FileReader(file);
   int c;
   // čtu znak po zanku metodou read
   // (pokud vrátí -1 pak už není možné
   // další znak číst = jsme na konci
   // souboru)
   while ((c = inputStream.read()) != -1) {
    // zvednu hodnotu proměnné counter o
    // jednotku
    counter++;
    // nebo provedu konstrukci (counter
    // =
    // counter + 1);
    // nebo provedu tuto konstrukci
    // (counter +=counter);
   }
  }
  finally {
   if (inputStream != null) {
    inputStream.close();
   }
  }
  return counter;
 }
 /**
  * Tato metoda sečte počet čísel v
  * souboru.
  * 
  * @param file
  * @return
  * @throws IOException
  */
 public int getNumberOfDigitsInFile(
   String file) throws IOException {
  FileReader inputStream = null;
  // Vytvořím si proměnnou, do které
  // budeme ukládat počet načtených
  // znaků
  int counter = 0;
  try {
   // Vytvořím vstupní proud
   inputStream = new FileReader(file);
   int c;
   // čtu znak po zanku metodou read
   // (pokud vrátí -1 pak už není možné
   // další znak číst = jsme na konci
   // souboru)
   while ((c = inputStream.read()) != -1) {
    // Vytvořím pole byte a hodnotu int
    // proměnné c přetypuji na typ byte.
    byte[] byteArray = new byte[] { (byte) c };
    // new byte[] { (byte) c } je
    // zkrácená konstrukce.
    // Do proměnné value uložím hodnotu
    // pole bytů
    String value = new String(byteArray);
    // Použiji objekt Pattern (v
    // překladu nejspíš vzor), který
    // umožní definovat regulární
    // výraz. Tento výraz znamená
    // "pouze číslice". Kdyby jsi chtěl
    // počítat pouze znaky, mohl by jsi
    // použít reg. výraz negaci čísel
    // tedy: [^0-9]
    Pattern p = Pattern
      .compile("[0-9]");
    // Objekt Matcher (tedy v překladu
    // porovnávač) porovná vstupní
    // řetězec s definovaným vzorem
    // (patternem)
    Matcher m = p.matcher(value);
    // Tato podmínka, je-li splněna
    // (tzn. vstup obsahuje
    // číslici),vypíše na obrazovku
    // nalezené číslo v souboru a zvedne
    // hodnotu čítače o jednotku.
    if (m.find()) {
     System.out
       .println(" nalezl jsem číslo: "
       + value);
     counter++;
    }
   }
  }
  finally {
   if (inputStream != null) {
    inputStream.close();
   }
  }
  return counter;
 }
 /**
  * Tato metoda sečte počet čísel v
  * souboru.
  * 
  * @param file
  * @return
  * @throws IOException
  */
 public int getNumberOfDigitsInFile2Version(
   String file) throws IOException {
  FileReader inputStream = null;
  // Vytvořím si proměnnou, do které
  // budeme ukládat počet načtených
  // znaků
  int counter = 0;
  try {
   // Vytvořím vstupní proud
   inputStream = new FileReader(file);
   int c;
   // čtu znak po zanku metodou read
   // (pokud vrátí -1 pak už není možné
   // další znak číst = jsme na konci
   // souboru)
   while ((c = inputStream.read()) != -1) {
    // Vytvořím pole byte a hodnotu int
    // proměnné c přetypuji na typ byte.
    byte[] byteArray = new byte[] { (byte) c };
    // new byte[] { (byte) c } je
    // zkrácená konstrukce.
    // Do proměnné value uložím hodnotu
    // pole bytů
    String value = new String(byteArray);
    // Protože budu konvertovat hodnotu
    // řetězec do objektu Integer
    // (číslo) a nebude-li možno tuto
    // konverzi provést (protože
    // proměnná value bude znak, nikoliv
    // číslice) java vrátí výjimku
    // NumberFormatException
    // špatného číselného formátu, je
    // nezbytné tuto část kódu uzavřít
    // do bloku try/catch.
    try {
     Integer cislo = new Integer(value);
     System.out
       .println(" nalezl jsem číslo: "
       + cislo);
     counter++;
    }
    catch (NumberFormatException e) {
     // V tomto případě není vhodné
     // výjimku ošetřovat. To ale může
     // vést k značným chybám a problémů
     // při ladění kódu. Proto tuto
     // konstrukci nedoporučuji. V
     // některých případech se jí ale
     // není možné vyhnout. V tomto
     // případě ji využívej jen velmi
     // opatrně.
    }
   }
  }
  finally {
   if (inputStream != null) {
    inputStream.close();
   }
  }
  return counter;
 }
 /**
  * Tato metoda umožní spočítat výskyt
  * definovaného vzoru v proměnné
  * pattern v souboru file
  * 
  * @param file
  * @param pattern
  * @return
  * @throws IOException
  */
 public int getNumberOfPatterns(
   String file, String pattern)
   throws IOException {
  FileReader inputStream = null;
  // Vytvořím si proměnnou, do které
  // budeme ukládat počet načtených
  // znaků
  int counter = 0;
  try {
   // Vytvořím vstupní proud
   inputStream = new FileReader(file);
   int c;
   // čtu znak po zanku metodou read
   // (pokud vrátí -1 pak už není možné
   // další znak číst = jsme na konci
   // souboru)
   while ((c = inputStream.read()) != -1) {
    // Vytvořím pole byte a hodnotu int
    // proměnné c přetypuji na typ byte.
    byte[] byteArray = new byte[] { (byte) c };
    // new byte[] { (byte) c } je
    // zkrácená konstrukce.
    // Do proměnné value uložím hodnotu
    // pole bytů
    String value = new String(byteArray);
    Pattern p = Pattern
      .compile(pattern);
    Matcher m = p.matcher(value);
    if (m.find()) {
     counter++;
    }
   }
  }
  finally {
   if (inputStream != null) {
    inputStream.close();
   }
  }
  return counter;
 }
}