diff --git a/src/main/java/cz/vsb/fei/efrei/lab03/DangerWorld.java b/src/main/java/cz/vsb/fei/efrei/lab03/DangerWorld.java
index f8966b97ee846a85e9cd1c36dc5a2670cd3ef826..877827935a2469941fbd3cca0492cd39deffa0ff 100644
--- a/src/main/java/cz/vsb/fei/efrei/lab03/DangerWorld.java
+++ b/src/main/java/cz/vsb/fei/efrei/lab03/DangerWorld.java
@@ -1,10 +1,7 @@
package cz.vsb.fei.efrei.lab03;
import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
-import java.util.Map;
import java.util.Random;
import java.util.Scanner;
@@ -13,113 +10,41 @@ public class DangerWorld {
public static void main(String[] args) {
List<Fighter> fighters = new ArrayList<>();
+
+ generateMonstersAndHeros(fighters);
+
+ WorkWithCollections.playWithCollections(fighters);
+
+ }
+
+ private static void generateMonstersAndHeros(List<Fighter> fighters) {
try (Scanner s = new Scanner(System.in)) {
System.out.println("Type name of monster:");
String name = s.next();
-
+
Monster monster = new Monster(name);
fighters.add(monster);
- fighters.add(new Monster("King"));
- fighters.add(new Monster("Queen"));
- fighters.add(new Monster("Fairy"));
- fighters.add(new Hero("Shrek"));
- fighters.add(new Hero("Cinderela"));
-
- int countOfHeros = RANDOM.nextInt(200);
- for (int i = 0; i < countOfHeros; i++) {
- fighters.add(new Hero(Utils.generateHeroName()));
- }
-
- int countOfMonsters = RANDOM.nextInt(250);
- for (int i = 0; i < countOfMonsters; i++) {
- fighters.add(new Monster(Utils.generateMonsterName()));
- }
-
- int sumStrenght = 0;
- for (Fighter fighter : fighters) {
- sumStrenght += fighter.getStrenght();
- }
- System.out.println("Average strenght of all fighters is " + sumStrenght / fighters.size());
- int sumStrenghtOfHeroes = 0;
- int numberOfHeroes = 0;
- int sumStrenghtOfMonsters = 0;
- int numberOfMonsters = 0;
- for (Fighter fighter : fighters) {
- if (fighter instanceof Monster) {
- sumStrenghtOfMonsters += fighter.getStrenght();
- numberOfMonsters++;
- } else if (fighter instanceof Hero) {
- sumStrenghtOfHeroes += fighter.getStrenght();
- numberOfHeroes++;
- }
-
- }
- System.out.println("Average strenght of all Heros is " + sumStrenghtOfHeroes / numberOfHeroes);
- System.out.println("Average strenght of all Monsters is " + sumStrenghtOfMonsters / numberOfMonsters);
-
- int rounds = 1000;
-
- for (int i = 0; i < rounds; i++) {
- Fighter fighter1 = fighters.get(RANDOM.nextInt(fighters.size()));
- Fighter fighter2 = fighters.get(RANDOM.nextInt(fighters.size()));
- try {
- fighter1.attackedBy(fighter2);
- } catch (AlreadyDeadException e) {
- System.out.println(
- "Ups! Fighter " + fighter2.getName() + " attack already dead " + fighter1.getName());
- }
- }
-
- int countDeath = 0;
-// List<Fighter> deads = new ArrayList<>();
-// for (Fighter fighter : fighters) {
-// if(!fighter.isAlive()) {
-// countDeath++;
-// deads.add(fighter);
-// }
-// } int countOfHeros = RANDOM.nextInt(200);
-
-// fighters.removeAll(deads);
-// for (int i = fighters.size()-1; i>=0; i--) {
-// if(!fighters.get(i).isAlive()) {
-// countDeath++;
-// fighters.remove(i);
-// }
-// }
-
- Iterator<Fighter> iterator = fighters.iterator();
- while (iterator.hasNext()) {
- if (!iterator.next().isAlive()) {
- iterator.remove();
- countDeath++;
- }
- }
-
- System.out.println("Number of deats:" + countDeath);
-
- for (Fighter fighter2 : fighters) {
- if (!fighter2.isAlive()) {
- System.out.println("Fount dead fighter " + fighter2.getName());
- }
- }
-
- Map<String, Integer> namesCountMap = new HashMap<>();
- for (Fighter fighter : fighters) {
- if (namesCountMap.containsKey(fighter.getName())) {
- Integer count = namesCountMap.get(fighter.getName());
- int newCount = count + 1;
- namesCountMap.put(fighter.getName(), newCount);
- } else {
- namesCountMap.put(fighter.getName(), 1);
- }
- }
-
- for (String name1 : namesCountMap.keySet()) {
- int count = namesCountMap.get(name1);
- System.out.println(name1 + ": " + count);
- }
-
+ } catch (Exception e) {
+ System.out.println("Cannot properlly read name from STDIN. Continu without named monster");
+ }
+ fighters.add(new Monster("King"));
+ fighters.add(new Monster("Queen"));
+ fighters.add(new Monster("Fairy"));
+ fighters.add(new Hero("Shrek"));
+ fighters.add(new Hero("Cinderela"));
+
+ int countOfHeros = RANDOM.nextInt(200);
+ for (int i = 0; i < countOfHeros; i++) {
+ fighters.add(new Hero(Utils.generateHeroName()));
+ }
+
+ int countOfMonsters = RANDOM.nextInt(250);
+ for (int i = 0; i < countOfMonsters; i++) {
+ fighters.add(new Monster(Utils.generateMonsterName()));
}
-
}
+
+
+
+
}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab03/WorkWithCollections.java b/src/main/java/cz/vsb/fei/efrei/lab03/WorkWithCollections.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7a8f7443502719cb4d1120efe809d6951db8183
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab03/WorkWithCollections.java
@@ -0,0 +1,225 @@
+package cz.vsb.fei.efrei.lab03;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class WorkWithCollections {
+
+ public static void playWithCollections(List<Fighter> fighters) {
+ calculateAverageStrenght(fighters);
+ calculateAverageLives(fighters);
+
+ System.out.println("=========================================================");
+ makeFights(fighters, 1000);
+ System.out.println("=========================================================");
+
+ calculateAverageLives(fighters);
+ System.out.println("=========================================================");
+
+ try {
+ removeDeadsCauseException(fighters);
+ printDeadAndlives(fighters);
+ } catch (Exception e) {
+ e.printStackTrace();
+ System.out.println("Continue! Expected exception");
+ }
+ System.out.println("=========================================================");
+
+ //use copy of list
+ int countDeath = removeDeadsUsingAnotherCollection(new ArrayList<>(fighters));
+ System.out.println("Number of deats:" + countDeath);
+ System.out.println("=========================================================");
+
+ //use copy of list
+ countDeath = removeDeadsUsingIndexWithMistakes(new ArrayList<>(fighters));
+ System.out.println("Number of deats:" + countDeath);
+ System.out.println("=========================================================");
+
+ //use copy of list
+ countDeath = removeDeadsUsingIndex(new ArrayList<>(fighters));
+ System.out.println("Number of deats:" + countDeath);
+ System.out.println("=========================================================");
+
+ countDeath = removeDeadsUsingIterator(fighters);
+ System.out.println("Number of deats:" + countDeath);
+ System.out.println("=========================================================");
+
+
+ for (Fighter fighter2 : fighters) {
+ if (!fighter2.isAlive()) {
+ System.out.println("Fount dead fighter " + fighter2.getName());
+ }
+ }
+
+ Map<String, Integer> namesCountMap = new HashMap<>();
+ countFrequencyOfNames(fighters, namesCountMap);
+
+ printOutAllNamesAndTheirCount(namesCountMap);
+
+
+ }
+
+ private static void makeFights(List<Fighter> fighters, int rounds) {
+ for (int i = 0; i < rounds; i++) {
+ Fighter fighter1 = fighters.get(Utils.RANDOM.nextInt(fighters.size()));
+ Fighter fighter2 = fighters.get(Utils.RANDOM.nextInt(fighters.size()));
+ try {
+ fighter1.attackedBy(fighter2);
+ } catch (AlreadyDeadException e) {
+ System.out.println("Ups! Fighter " + fighter2.getName() + " attack already dead " + fighter1.getName());
+ }
+ }
+ }
+
+ private static int removeDeadsCauseException(List<Fighter> fighters) {
+ int countDeath = 0;
+ List<Fighter> deads = new ArrayList<>();
+ //use foreach loop that use iterator
+ for (Fighter fighter : fighters) {
+ if (!fighter.isAlive()) {
+ countDeath++;
+ /*cannot remove from collection which is iterated*/
+ fighters.remove(fighter);
+ }
+ }
+ fighters.removeAll(deads);
+ return countDeath;
+ }
+
+ private static int removeDeadsUsingAnotherCollection(List<Fighter> fighters) {
+ System.out.println("Remove using another collection");
+ printDeadAndlives(fighters);
+ int countDeath = 0;
+ List<Fighter> deads = new ArrayList<>();
+ for (Fighter fighter : fighters) {
+ if (!fighter.isAlive()) {
+ countDeath++;
+ deads.add(fighter);
+ }
+ }
+ fighters.removeAll(deads);
+ printDeadAndlives(fighters);
+ return countDeath;
+ }
+
+ private static int removeDeadsUsingIndexWithMistakes(List<Fighter> fighters) {
+ System.out.println("Remove using index with errors");
+ int countDeath = 0;
+ printDeadAndlives(fighters);
+ for (int i = 0; i < fighters.size(); i++) {
+ if (!fighters.get(i).isAlive()) {
+ countDeath++;
+ fighters.remove(i);
+ }
+ }
+ printDeadAndlives(fighters);
+ return countDeath;
+ }
+
+ private static int removeDeadsUsingIndex(List<Fighter> fighters) {
+ System.out.println("Remove using index");
+ int countDeath = 0;
+ printDeadAndlives(fighters);
+ for (int i = fighters.size() - 1; i >= 0; i--) {
+ if (!fighters.get(i).isAlive()) {
+ countDeath++;
+ fighters.remove(i);
+ }
+ }
+ printDeadAndlives(fighters);
+ return countDeath;
+ }
+
+ private static int removeDeadsUsingIterator(List<Fighter> fighters) {
+ System.out.println("Remove using Iterator");
+ printDeadAndlives(fighters);
+ int countDeath = 0;
+ Iterator<Fighter> iterator = fighters.iterator();
+ while (iterator.hasNext()) {
+ if (!iterator.next().isAlive()) {
+ iterator.remove();
+ countDeath++;
+ }
+ }
+ printDeadAndlives(fighters);
+ return countDeath;
+ }
+
+ private static void calculateAverageStrenght(List<Fighter> fighters) {
+ int sumStrenght = 0;
+ for (Fighter fighter : fighters) {
+ sumStrenght += fighter.getStrenght();
+ }
+ System.out.println("Average strenght of all fighters is " + sumStrenght / fighters.size());
+ int sumStrenghtOfHeroes = 0;
+ int numberOfHeroes = 0;
+ int sumStrenghtOfMonsters = 0;
+ int numberOfMonsters = 0;
+ for (Fighter fighter : fighters) {
+ if (fighter instanceof Monster) {
+ sumStrenghtOfMonsters += fighter.getStrenght();
+ numberOfMonsters++;
+ } else if (fighter instanceof Hero) {
+ sumStrenghtOfHeroes += fighter.getStrenght();
+ numberOfHeroes++;
+ }
+
+ }
+ System.out.println("Average strenght of all Heros is " + sumStrenghtOfHeroes / numberOfHeroes);
+ System.out.println("Average strenght of all Monsters is " + sumStrenghtOfMonsters / numberOfMonsters);
+ }
+
+ private static void calculateAverageLives(List<Fighter> fighters) {
+ int sumLives = 0;
+ for (Fighter fighter : fighters) {
+ sumLives += fighter.getLives();
+ }
+ System.out.println("Average lives of all fighters is " + sumLives / fighters.size());
+ int sumLivesOfHeroes = 0;
+ int numberOfHeroes = 0;
+ int sumLivesOfMonsters = 0;
+ int numberOfMonsters = 0;
+ for (Fighter fighter : fighters) {
+ if (fighter instanceof Monster) {
+ sumLivesOfMonsters += fighter.getLives();
+ numberOfMonsters++;
+ } else if (fighter instanceof Hero) {
+ sumLivesOfHeroes += fighter.getLives();
+ numberOfHeroes++;
+ }
+
+ }
+ System.out.println("Average strenght of all Heros is " + sumLivesOfHeroes / numberOfHeroes);
+ System.out.println("Average strenght of all Monsters is " + sumLivesOfMonsters / numberOfMonsters);
+ }
+
+ private static void printDeadAndlives(List<Fighter> fighters) {
+ for (Fighter fighter : fighters) {
+ System.out.print(fighter.isAlive()?"a":"D");
+ }
+ System.out.println();
+ }
+
+ private static void countFrequencyOfNames(List<Fighter> fighters, Map<String, Integer> namesCountMap) {
+ for (Fighter fighter : fighters) {
+ if (namesCountMap.containsKey(fighter.getName())) {
+ Integer count = namesCountMap.get(fighter.getName());
+ int newCount = count + 1;
+ namesCountMap.put(fighter.getName(), newCount);
+ } else {
+ namesCountMap.put(fighter.getName(), 1);
+ }
+ }
+ }
+
+ private static void printOutAllNamesAndTheirCount(Map<String, Integer> namesCountMap) {
+ for (String name1 : namesCountMap.keySet()) {
+ int count = namesCountMap.get(name1);
+ System.out.println(name1 + ": " + count);
+ }
+ }
+
+}