.gitignore

+# Eclipse
+.classpath
+.project
+.settings/
+ 
+# Intellij
+.idea/
+*.iml
+*.iws
+ 
+# Mac
+.DS_Store
+ 
+# Maven
+log/
+target/

pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>cz.vsb.fei.efrei</groupId>
+	<artifactId>efrei-lab03</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+
+	<name>efrei-lab03</name>
+
+	<packaging>jar</packaging>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<maven.compiler.release>21</maven.compiler.release>
+		<JUnit.version>5.11.0</JUnit.version>
+		<log4j.version>2.23.1</log4j.version>
+		<lombok.version>1.18.34</lombok.version>
+	</properties>
+	<dependencyManagement>
+		<dependencies>
+			<dependency>
+				<groupId>org.junit</groupId>
+				<artifactId>junit-bom</artifactId>
+				<version>${JUnit.version}</version>
+				<type>pom</type>
+				<scope>import</scope>
+			</dependency>
+		</dependencies>
+	</dependencyManagement>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-core</artifactId>
+			<version>${log4j.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-api</artifactId>
+			<version>${log4j.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.projectlombok</groupId>
+			<artifactId>lombok</artifactId>
+			<version>${lombok.version}</version>
+			<scope>provided</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.13.0</version>
+				<configuration>
+					<annotationProcessorPaths>
+						<path>
+							<groupId>org.projectlombok</groupId>
+							<artifactId>lombok</artifactId>
+							<version>${lombok.version}</version>
+						</path>
+					</annotationProcessorPaths>
+				</configuration>
+			</plugin>
+			<plugin>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>3.5.0</version>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>

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

+package cz.vsb.fei.efrei.lab03;
+
+public class AlreadyDeadException extends Exception {
+
+	private static final long serialVersionUID = -7052667091386255519L;
+
+	private Fighter fighter;
+
+	public AlreadyDeadException(Fighter fighter) {
+		this.fighter = fighter;
+	}
+
+	public Fighter getFighter() {
+		return fighter;
+	}
+
+	
+	
+	
+	
+	
+}

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;
+
+public class DangerWorld {
+	private static final Random RANDOM = new Random();
+
+	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);
+		} 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/Fighter.java

+package cz.vsb.fei.efrei.lab03;
+
+public interface Fighter {
+
+	int getLives();
+
+	public default boolean isAlive() {
+		return getLives() > 0;
+	}
+
+	public void attackedBy(Fighter fighter) throws AlreadyDeadException;
+
+	public String getName();
+
+	public int getStrenght();
+
+}

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

+package cz.vsb.fei.efrei.lab03;
+
+import java.util.Random;
+
+public class Hero implements Fighter{
+
+	private static final Random RANDOM = new Random();
+
+	private String name;
+	private int strenght;
+	private int lives;
+
+	public Hero(String name, int strenght) {
+		if(name == null || name.length() < 2 ||
+				strenght < 30) {
+			throw new IllegalArgumentException(
+					"Sorry wrong arguments!!");
+		}
+		this.name = name;
+		this.strenght = strenght;
+		this.lives = 100;
+	}
+
+	public Hero(String name) {
+		this(name, RANDOM.nextInt(50) + 50);
+	}
+
+	@Override
+	public void attackedBy(Fighter fighter) 
+			throws AlreadyDeadException {
+		if(!isAlive()) {
+			throw new AlreadyDeadException(this);
+		}
+		System.out.println(fighter.getName() + " attack " + getName() + "!");
+		if (RANDOM.nextBoolean()) {
+			System.out.println("Attack was blocked!! Ha. Ha. Ha.");
+			return;
+		}
+		lives -= fighter.getStrenght();
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public int getStrenght() {
+		return strenght;
+	}
+
+	@Override
+	public int getLives() {
+		return lives;
+	}
+
+	@Override
+	public String toString() {
+		return "Hero " + name + "(" + strenght + ") - has " + lives + " lives.";
+	}
+
+}

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

+package cz.vsb.fei.efrei.lab03;
+
+import java.util.Random;
+
+public class Monster implements Fighter {
+
+	private static final Random RANDOM = new Random();
+
+	private String name;
+	private final int strenght;
+	private int lives;
+
+	public Monster(String name, int strenght) {
+		if(name == null || name.length() < 2 ) {
+			throw new IllegalArgumentException(
+					"Too short name");
+		}
+		if(strenght < 10) {
+			throw new IllegalArgumentException(
+					"Monster is too weak!!");
+		}
+		this.name = name;
+		this.strenght = strenght;
+		this.lives = 100;
+	}
+
+	public Monster(String name) {
+		this(name, RANDOM.nextInt(90) + 10);
+	}
+
+	@Override
+	public void attackedBy(Fighter fighter) {
+		System.out.println(fighter.getName() + " attack " + getName() + "!");
+		lives -= fighter.getStrenght();
+	}
+	
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public int getStrenght() {
+		return strenght;
+	}
+
+	@Override
+	public int getLives() {
+		return lives;
+	}
+
+	@Override
+	public String toString() {
+		return "Monster " + name + "(" + strenght + ") - has " + lives + " lives.";
+	}
+
+}

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

+package cz.vsb.fei.efrei.lab03;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+public class Utils {
+
+	public static final Random RANDOM = new Random();
+	private static List<String> heroNames = Arrays.asList("Captain Freedom", "Iron Blade", "Shadow Hunter",
+			"Silver Hawk", "Mighty Thunder", "Lunar Knight", "Phoenix Blaze", "Stormbreaker", "Star Guardian",
+			"Solar Sentinel", "Dark Raven", "Blaze Falcon", "Crystal Viper", "Lightning Strike", "Firestorm",
+			"Eagle Eye", "Nightshade", "Frostbite", "Wind Whisperer", "Shadow Blaze");
+
+	private static List<String> monsterNames = Arrays.asList("Nightmare Reaper", "Shadow Fiend", "Bonecrusher",
+			"Venomous Hydra", "Doomfang", "Blightbringer", "Void Stalker", "Inferno Drake", "Ghoul King", "Frost Wyrm",
+			"Terrorclaw", "Bloodfeast", "Ravenous Maw", "Storm Serpent", "Hellhound", "Dark Overlord", "Necroshade",
+			"Plaguebeast", "Stone Golem", "Fire Leviathan");
+
+	public static String generateHeroName() {
+		return heroNames.get(RANDOM.nextInt(heroNames.size()));
+	}
+	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);
+		}
+	}
+
+}

src/main/java/module-info.java

+module cz.vsb.fei.efrei.lab03 {
+	requires static lombok;
+	requires org.apache.logging.log4j;
+}
\ No newline at end of file

src/main/resources/log4j2.xml

+<Configuration>
+	<Appenders>
+		<Console name="Console">
+			<PatternLayout
+				pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
+		</Console>
+	</Appenders>
+	<Loggers>
+		<Root level="info">
+			<AppenderRef ref="Console"></AppenderRef>
+		</Root>
+	</Loggers>
+</Configuration>

src/test/java/cz/vsb/fei/efrei/lab03/AppTest.java

+package cz.vsb.fei.efrei.lab03;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit test for simple App.
+ */
+class AppTest {
+
+	/**
+	 * Rigorous Test :-)
+	 */
+	@Test
+	void shouldAnswerWithTrue() {
+		assertTrue(true);
+	}
+}