Lesson_37 (collection list) - for review.

.gitignore

@@ -1,2 +1,3 @@
 # Project exclude paths
-/out/
+/out/
+/resource/

src/com/walking/lesson37_collection_list/task1/Main.java

@@ -1,5 +1,12 @@
 package com.walking.lesson37_collection_list.task1;
 
+import com.walking.lesson37_collection_list.task1.model.Counter;
+import com.walking.lesson37_collection_list.task1.service.CounterService;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringJoiner;
+
 /**
  * Реализуйте задачу
  * <a href="https://github.com/KFalcon2022/CounterAggregation">...</a>, используя ArrayList.
@@ -10,6 +17,87 @@
  * Изменилось ли что-то в кодовой базе при использовании списка другой реализации?
  */
 public class Main {
+    public static final String GAS_COUNTER_NAME = "Газ";
+    public static final String HOT_WATER_COUNTER_NAME = "Горячая вода";
+    public static final String COLD_WATER_COUNTER_NAME = "Холодная вода";
+    public static final String ELECTRIC_COUNTER_NAME = "Электричество";
+
+    public static final String M_3_UNIT = "м3";
+    public static final String KW_H_UNIT = "кВт*ч";
+
+    private static final String LINE_DELIMITER = "-".repeat(20);
+
     public static void main(String[] args) {
+        CounterService counterService = new CounterService(new ArrayList<>());
+        printOverview(counterService.getAllCounters());
+
+        Counter gasCounter = new Counter(GAS_COUNTER_NAME, M_3_UNIT);
+        Counter hotWaterCounter = new Counter(HOT_WATER_COUNTER_NAME, M_3_UNIT);
+        Counter coldWaterCounter = new Counter(COLD_WATER_COUNTER_NAME, M_3_UNIT);
+
+        Counter electricCounter = new Counter(ELECTRIC_COUNTER_NAME, KW_H_UNIT);
+        electricCounter.setValue(15);
+
+        counterService = new CounterService(List.of(coldWaterCounter, gasCounter));
+
+        counterService.addCounter(hotWaterCounter);
+        counterService.addCountersIfAbsent(electricCounter);
+        counterService.addCountersIfAbsent(electricCounter);
+        counterService.addCounter(electricCounter);
+        counterService.addFirst(electricCounter);
+        counterService.addFirst(new Counter("Электричество", KW_H_UNIT, 456));
+        counterService.increaseCounter(GAS_COUNTER_NAME, 100);
+        counterService.increaseCounter(coldWaterCounter, 10);
+        printOverview(counterService.getAllCounters());
+
+        counterService.removeDuplicates();
+        counterService.sortByName();
+        counterService.removeIdleCounters();
+        System.out.println(">>>Удаляем дубликаты, счетчики с нулевыми показаниями и сортируем по алфавиту:");
+        printOverview(counterService.getAllCounters());
+
+
+        System.out.println("Название первого в списке счетчика: " + counterService.getFirst().getName());
+
+        Counter[] allCounters = counterService.getAllCounters().toArray(new Counter[0]);
+        System.out.println(">>>Переносим счетчики из списка в массив и выводим их названия:");
+        printCounterNames(allCounters);
+
+        List<Counter> waterCounters = List.of(hotWaterCounter, coldWaterCounter);
+
+
+        hotWaterCounter.setValue(100);
+        counterService.addCounter(hotWaterCounter);
+        counterService.removeIfNotMatch(waterCounters);
+        System.out.println(">>>Оставляем только счетчики воды:");
+        printOverview(counterService.getAllCounters());
+    }
+
+    public static void printCounterNames(Counter[] counters) {
+        StringJoiner result = new StringJoiner("\n", LINE_DELIMITER + "\n", "\n" + LINE_DELIMITER);
+
+        for (Counter counter : counters) {
+            result.add(counter == null ? "-" : counter.getName());
+        }
+
+        System.out.println(result);
+    }
+
+    public static void printOverview(List<Counter> counters) {
+        System.out.printf("Всего счетчиков: %s\n%s\n", counters.size(), LINE_DELIMITER);
+
+        if (counters.isEmpty()) {
+            System.out.println("Добавьте счетчики для работы с ними.");
+        } else {
+            printCounterValues(counters);
+        }
+
+        System.out.println(LINE_DELIMITER);
+    }
+
+    private static void printCounterValues(List<Counter> counters) {
+        for (Counter counter : counters) {
+            System.out.printf("%s: %d %s\n", counter.getName(), counter.getValue(), counter.getUnitOfMeasure());
+        }
     }
-}
+}

src/com/walking/lesson37_collection_list/task1/model/Counter.java

@@ -0,0 +1,58 @@
+package com.walking.lesson37_collection_list.task1.model;
+
+import java.util.Objects;
+
+public class Counter implements Comparable<Counter> {
+    private final String name;
+    private final String unitOfMeasure;
+
+    private int value;
+
+    public Counter(String name, String unitOfMeasure, int value) {
+        this.name = name;
+        this.unitOfMeasure = unitOfMeasure;
+        this.value = value;
+    }
+
+    public Counter(String name, String unitOfMeasure) {
+        this(name, unitOfMeasure, 0);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getUnitOfMeasure() {
+        return unitOfMeasure;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+
+    @Override
+    public int compareTo(Counter counter) {
+        return name.compareTo(counter.getName());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Counter counter = (Counter) o;
+        return Objects.equals(name, counter.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return name.hashCode();
+    }
+}

src/com/walking/lesson37_collection_list/task1/service/CounterService.java

@@ -0,0 +1,167 @@
+package com.walking.lesson37_collection_list.task1.service;
+
+import com.walking.lesson37_collection_list.task1.model.Counter;
+
+import java.util.*;
+
+public class CounterService {
+    /*// замена ArrayList на Vector не повлияла на кодовую базу, т.к. они оба реализуют интерфейс List,
+    // что делает их взаимозаменяемыми
+    private final Vector<Counter> counters;
+
+    public CounterService(Counter... counters) {
+        this.counters = new Vector<>(Arrays.asList(counters));
+    } */
+
+    private final ArrayList<Counter> counters;
+
+    public CounterService(List<Counter> counters) {
+        this.counters = new ArrayList<>(counters);
+    }
+
+    public List<Counter> getAllCounters() {
+        return List.copyOf(counters);
+    }
+
+    public Counter getFirst() {
+        return counters.get(0);
+    }
+
+    public void addFirst(Counter counter) {
+        counters.add(0, counter);
+    }
+
+    public Counter addCounter(Counter counter) {
+        counters.add(counter);
+        return counters.get(counters.size() - 1);
+    }
+
+    public boolean addCountersIfAbsent(Counter... counters) {
+        List<Counter> candidates = new ArrayList<>(Arrays.asList(counters));
+        candidates.removeAll(this.counters);
+        return this.counters.addAll(candidates);
+    }
+
+    public boolean removeIfNotMatch(Collection<? extends Counter> sample) {
+        return counters.retainAll(sample);
+    }
+
+    public boolean removeDuplicates() {
+        List<Counter> uniques = getUniques();
+
+        if (uniques.size() == counters.size()) {
+            return false;
+        }
+
+        counters.clear();
+        counters.addAll(uniques);
+        return true;
+    }
+
+    public boolean removeIdleCounters() {
+        List<Counter> idles = getIdles();
+
+        if (idles.size() == 0) {
+            return false;
+        }
+
+        counters.removeAll(idles);
+        return true;
+    }
+
+    public void sortByName() {
+        counters.sort(Comparator.naturalOrder());
+    }
+
+    public void sortBy(Comparator<Counter> comparator) {
+        counters.sort(comparator);
+    }
+
+    public Counter getCounterByName(String name) {
+        for (Counter counter : counters) {
+            if (counter.getName().equals(name)) {
+                return counter;
+            }
+        }
+
+        return null;
+    }
+
+    public Counter increaseCounter(String name, int value) {
+        Counter counter = getCounterByName(name);
+        return counter == null ? null : increaseCounter(counter, value);
+    }
+
+    public Counter increaseCounter(Counter counter, int value) {
+        counter.setValue(counter.getValue() + value);
+        return counter;
+    }
+
+    public Counter decreaseCounter(String name, int value) {
+        Counter counter = getCounterByName(name);
+        return counter == null ? null : decreaseCounter(counter, value);
+    }
+
+    public Counter decreaseCounter(Counter counter, int value) {
+        counter.setValue(counter.getValue() - value);
+        return counter;
+    }
+
+    public Counter incrementCounter(String name) {
+        Counter counter = getCounterByName(name);
+        return counter == null ? null : incrementCounter(counter);
+    }
+
+    public Counter incrementCounter(Counter counter) {
+        increaseCounter(counter, 1);
+        return counter;
+    }
+
+    public Counter decrementCounter(String name) {
+        Counter counter = getCounterByName(name);
+        return counter == null ? null : decrementCounter(counter);
+    }
+
+    public Counter decrementCounter(Counter counter) {
+        decreaseCounter(counter, 1);
+        return counter;
+    }
+
+    public Counter reset(String name) {
+        Counter counter = getCounterByName(name);
+        return counter == null ? null : reset(counter);
+    }
+
+    public Counter reset(Counter counter) {
+        counter.setValue(0);
+        return counter;
+    }
+
+    private List<Counter> getUniques() {
+        List<Counter> uniques = new ArrayList<>();
+
+        for (Counter counter : counters) {
+            if (!uniques.contains(counter)) {
+                uniques.add(counter);
+            }
+        }
+
+        return uniques;
+    }
+
+    private List<Counter> getIdles() {
+        List<Counter> idles = new ArrayList<>();
+
+        for (Counter counter : counters) {
+            if (isIdle(counter)) {
+                idles.add(counter);
+            }
+        }
+
+        return idles;
+    }
+
+    private boolean isIdle(Counter counter) {
+        return counter.getValue() == 0;
+    }
+}