Plant task. 1-st

Boris/src/laba29/FrequencyVocabulary.java

@@ -0,0 +1,69 @@
+package laba29;
+
+//Имеется текст. Следует составить для него частотный словарь.
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FrequencyVocabulary {
+    private static final int INCREASE = 1;
+    private final static String WORD_SPLIT_REGEX = "\\W+";
+    private Map<String, Integer> vocabularyFrequencyWord;
+
+    public FrequencyVocabulary() {
+        vocabularyFrequencyWord = new HashMap<>();
+    }
+
+    public void addTextToVocabulary(String text) {
+        String[] words = text.split(WORD_SPLIT_REGEX);
+        for (String word : words) {
+            addWordToVocabulary(word);
+        }
+    }
+
+    private void addWordToVocabulary(String word) {
+        if (vocabularyFrequencyWord.containsKey(word)) {
+            increaseValueKeyMap(word);
+        } else {
+            vocabularyFrequencyWord.put(word, INCREASE);
+        }
+    }
+
+    private void increaseValueKeyMap(String word) {
+        vocabularyFrequencyWord.put(word, vocabularyFrequencyWord.get(word) + INCREASE);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        FrequencyVocabulary that = (FrequencyVocabulary) o;
+
+        if (vocabularyFrequencyWord != null ? !vocabularyFrequencyWord.equals
+                (that.vocabularyFrequencyWord) : that.vocabularyFrequencyWord != null)
+            return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return vocabularyFrequencyWord != null ? vocabularyFrequencyWord.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return "FrequencyVocabulary{" +
+                "vocabularyFrequencyWord=\n" + getColon(vocabularyFrequencyWord) +
+                '}';
+    }
+
+    private StringBuilder getColon(Map<String, Integer> words) {
+        StringBuilder strB = new StringBuilder();
+        for (String word : words.keySet()) {
+            strB.append(word).append("=").append(words.get(word)).append("\n");
+        }
+        return strB;
+    }
+}

Boris/src/laba29/TestVocabulary.java

@@ -0,0 +1,24 @@
+package laba29;
+
+
+public class TestVocabulary {
+    public static void main(String[] args) {
+        String testText = "A man was pulled over for driving too fast, even though he thought he was driving " +
+                "just fine.\n" +
+                "\n" +
+                "Officer: You were speeding.\n" +
+                "Man: No, I wasn't.\n" +
+                "Officer: Yes, you were. I'm giving you a ticket.\n" +
+                "Man: But I wasn't speeding.\n" +
+                "Officer: Tell that to the judge! (The officer gives man the ticket.)\n" +
+                "Man: Would I get another ticket if I called you a jerk?\n" +
+                "Officer: Yes, you would.\n" +
+                "Man: What if I just thought that you were?\n" +
+                "Officer: I can't give you a ticket for what you think.\n" +
+                "Man: Fine, I think you're a jerk! ";
+
+        FrequencyVocabulary vocabulary = new FrequencyVocabulary();
+        vocabulary.addTextToVocabulary(testText);
+        System.out.println(vocabulary);
+    }
+}

Boris/src/laba30/Test.java

@@ -0,0 +1,13 @@
+package laba30;
+
+
+public class Test {
+    public static void main(String[] args) {
+
+        WorkingWithFile text = new WorkingWithFile();
+        text.addTextFromFile("textForTesting.txt");
+        System.out.println(text.getText());
+        System.out.println("Punctuation quantity is " + text.countPunctuationQuantity() + ".");
+        System.out.println("Word quantity is " + text.countWordQuantity() + ".");
+    }
+}

Boris/src/laba30/WorkingWithFile.java

@@ -0,0 +1,54 @@
+package laba30;
+
+
+import java.io.*;
+
+//Создать файл с текстом, прочитать, подсчитать в тексте количество знаков препинания и слов.
+
+public class WorkingWithFile {
+    private final String WORD_REGEX = "\\w+";
+    private final String PUNCTUATION_REGEX = "\\p{Punct}";
+    private String text;
+
+    public void addTextFromFile(String file) {
+        BufferedReader inputText = null;
+        try {
+            inputText = new BufferedReader(new FileReader(file));
+            String readLine = inputText.readLine();
+            StringBuilder outputBuffer = new StringBuilder();
+            while (readLine != null) {
+                outputBuffer.append(readLine);
+                readLine = inputText.readLine();
+                if (readLine != null) {
+                    outputBuffer.append("\n");
+                }
+            }
+            this.text = outputBuffer.toString();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (inputText != null) {
+                try {
+                    inputText.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    public int countPunctuationQuantity() {
+        return text.split(PUNCTUATION_REGEX).length - 1;
+
+    }
+
+    public int countWordQuantity() {
+        return text.split(WORD_REGEX).length - 1;
+    }
+
+    public String getText() {
+        return text;
+    }
+}

Boris/src/laba32/BinaryFile.java

@@ -0,0 +1,114 @@
+package laba32;
+
+//Записать в двоичный файл 20 случайных чисел. Прочитать записан-ный файл,
+//        распечатать числа и их среднее арифметическое.
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class BinaryFile {
+    private File file;
+
+    public BinaryFile(File file) {
+        this.file = file;
+    }
+
+    public BinaryFile(String str) {
+        this(new File(str));
+    }
+
+    public void writeNumbersToBinaryFile(int quantity) {
+        DataOutputStream outputFile = null;
+        try {
+            outputFile = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
+            writeToFile(addRandomNumbers(quantity), outputFile);
+        } catch (FileNotFoundException e) {
+            System.out.println("Exception opened file.");
+        } catch (IOException e) {
+            System.out.println("Exception add numbers.");
+        } finally {
+            if (outputFile != null) {
+                try {
+                    outputFile.close();
+                } catch (IOException e) {
+                    System.out.println("Exception closed file.");
+                }
+            }
+        }
+    }
+
+    private void writeToFile(List<Integer> numbers, DataOutputStream outputFile) throws IOException {
+        for (Integer number : numbers) {
+            outputFile.writeInt(number);
+        }
+    }
+
+    private List<Integer> addRandomNumbers(int quantity) {
+        List<Integer> numbers = new ArrayList<>();
+        if (quantity > 0) {
+            for (int i = 0; i < quantity; i++) {
+                numbers.add(generateRandomNumber());
+            }
+        } else {
+            for (int i = quantity; i < 0; i++) {
+                numbers.add(i);
+            }
+        }
+        return numbers;
+    }
+
+    private Integer generateRandomNumber() {
+        return new Random().nextInt(10);
+    }
+
+    public List<Integer> getNumbersFromBinaryFile() {
+        List<Integer> numbers = new ArrayList<>();
+        DataInputStream reader = null;
+        try {
+            reader = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
+            getNumbers(reader, numbers);
+        } catch (FileNotFoundException e) {
+            System.out.println("Exception opened file.");
+        } catch (IOException e) {
+            System.out.println("Exception read file.");
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (IOException e) {
+                    System.out.println("Exception closed file.");
+                }
+            }
+        }
+        return numbers;
+    }
+
+    private void getNumbers(DataInputStream reader, List<Integer> numbers) throws IOException {
+        while (true) {
+            try {
+                numbers.add(reader.readInt());
+            } catch (EOFException e) {
+                break;
+            }
+        }
+    }
+
+    public double calculateAverage() {
+        List<Integer> numbers = getNumbersFromBinaryFile();
+        double sum = 0;
+        if (numbers.isEmpty()) {
+            return 0;
+        } else {
+            return calculateSum(numbers, sum) / numbers.size();
+        }
+    }
+
+    private double calculateSum(List<Integer> numbers, double sum) {
+        for (Integer number : numbers) {
+            sum += number;
+        }
+        return sum;
+    }
+}

Boris/src/laba32/TestBinaryFile.java

@@ -0,0 +1,12 @@
+package laba32;
+
+
+public class TestBinaryFile {
+    public static void main(String[] args) {
+        BinaryFile file = new BinaryFile("./binary.txt");
+        file.writeNumbersToBinaryFile(3);
+        System.out.println(file.getNumbersFromBinaryFile());
+        System.out.println("Average = " + file.calculateAverage());
+
+    }
+}

Boris/src/park/Park.java

@@ -0,0 +1,44 @@
+package park;
+
+
+import park.parser.Parser;
+import park.parser.dom.DOMParser;
+import park.plant.Plant;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Park {
+    private List<Plant> plants;
+
+    public Park() {
+        plants = new ArrayList<>();
+    }
+
+    public void addPlant(Plant plant) {
+        plants.add(plant);
+    }
+
+    public void growParkFromXML(File file) {
+        Parser parser = new DOMParser();
+        try {
+            parser.parseXML(file);
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+        plants.addAll(parser.getPlants());
+    }
+
+    public void grow() {
+        for (Plant plant : plants) {
+            plant.grow();
+        }
+    }
+
+    public String seePlantsInPark() {
+        return Arrays.toString(plants.toArray());
+    }
+}

Boris/src/park/TestPark.java

@@ -0,0 +1,16 @@
+package park;
+
+
+import java.io.File;
+
+public class TestPark {
+    public static void main(String[] args) {
+        Park park = new Park();
+        File file = new File("Boris/src/park/xml/park.xml");
+        park.growParkFromXML(file);
+        System.out.println(park.seePlantsInPark());
+        park.grow();
+        System.out.println(park.seePlantsInPark());
+    }
+
+}

Boris/src/park/parser/Parser.java

@@ -0,0 +1,31 @@
+package park.parser;
+
+
+import park.plant.Plant;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public abstract class Parser {
+    private final static String XML_FILE_REGEX = "\\.xml$";
+    public List<Plant> plants;
+
+    public abstract void parseXML(File file) throws FileNotFoundException;
+
+    public static boolean isXML(File file) throws FileNotFoundException {
+        if (file.exists()) {
+            if (Pattern.compile(XML_FILE_REGEX).matcher(file.getName()).find()) {
+                return true;
+            }
+        } else {
+            throw new FileNotFoundException(file.getPath());
+        }
+        return false;
+    }
+
+    public List<Plant> getPlants() {
+        return plants;
+    }
+}