src/main/java/cz/vsb/fei/efrei/lab03/DangerWorld.java

 package cz.vsb.fei.efrei.lab03;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 import java.util.Scanner;
 
@@ -7,35 +9,42 @@ public class DangerWorld {
 	private static final Random RANDOM = new Random();
 
 	public static void main(String[] args) {
-		Fighter[] fighters = new Fighter[6];
+		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[0] = monster;
-			fighters[1] = new Monster("King");
-			fighters[2] = new Monster("Queen");
-			fighters[3] = new Monster("Fairy");
-			fighters[4] = new Hero("Shrek");
-			fighters[5] = new Hero("Cinderela");
-
-			int rounds = 100;
-
-			for (int i = 0; i < rounds; i++) {
-				Fighter fighter1 = fighters[RANDOM.nextInt(6)];
-				Fighter fighter2 = fighters[RANDOM.nextInt(6)];
-				try {
-					fighter1.attackedBy(fighter2);
-				} catch (AlreadyDeadException e) {
-					System.out.println(
-							"Ups! Fighter " 
-					+ fighter2.getName()
-					+ " attack already dead "
-					+ fighter1.getName());
-				}
-			}
+			fighters.add(monster);
+		} 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()));
 		}
-
 	}
+
+	
+	
+	
 }

src/main/java/cz/vsb/fei/efrei/lab03/Utils.java

@@ -17,10 +17,10 @@ public class Utils {
 			"Terrorclaw", "Bloodfeast", "Ravenous Maw", "Storm Serpent", "Hellhound", "Dark Overlord", "Necroshade",
 			"Plaguebeast", "Stone Golem", "Fire Leviathan");
 
-	public String generateHeroName() {
+	public static String generateHeroName() {
 		return heroNames.get(RANDOM.nextInt(heroNames.size()));
 	}
-	public String generateMonsterName() {
+	public static String generateMonsterName() {
 		return monsterNames.get(RANDOM.nextInt(monsterNames.size()));
 	}
 	

src/main/java/cz/vsb/fei/efrei/lab03/WorkWithCollections.java

+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);
+		}
+	}
+
+}