backup

src/main/java/cz/vsb/fei/efrei/lab04/Army.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+public class Army {
+
+	private String name;
+	private List<? extends Fighter> soldiers;
+
+	public Army(String name, List<? extends Fighter> soldiers) {
+		this.name = name;
+		this.soldiers = soldiers;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public List<? extends Fighter> getSoldiers() {
+		return soldiers;
+	}
+
+	public static Army generate() {
+		List<? extends Fighter> soldiers = Stream.generate(Utils::generateHeroName).map(Hero::new).limit(2000).toList();
+		return new Army("Army of general "  +Utils.generateHeroName(), soldiers); 
+	}
+
+}

src/main/java/cz/vsb/fei/efrei/lab04/Car.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.util.List;
+import java.util.Random;
+
+public class Car {
+
+	@Order(2)
+	@Formatter(name = "Nuber of Doors", length = 1)
+	private int numberOfDors;
+	@Order(1)
+	@Formatter(name = "Car maker", length = 10)
+	private String producer;
+	@Order(3)
+	@Formatter(name = "Horse power", length = 5)
+	private double engineStrength;
+
+	public Car(int numberOfDors, String producer, double engineStrength) {
+		this.numberOfDors = numberOfDors;
+		this.producer = producer;
+		this.engineStrength = engineStrength;
+	}
+
+	public int getNumberOfDors() {
+		return numberOfDors;
+	}
+
+	public void setNumberOfDors(int numberOfDors) {
+		this.numberOfDors = numberOfDors;
+	}
+
+	public String getProducer() {
+		return producer;
+	}
+
+	public void setProducer(String producer) {
+		this.producer = producer;
+	}
+
+	public double getEngineStrength() {
+		return engineStrength;
+	}
+
+	public void setEngineStrength(double engineStrength) {
+		this.engineStrength = engineStrength;
+	}
+
+	public static Car generate() {
+		return new Car(RANDOM.nextInt(2,5), carProducers.get(RANDOM.nextInt(carProducers.size())), RANDOM.nextDouble(100, 1000));
+	}
+	
+	private static final Random RANDOM = new Random();
+	private static List<String> carProducers = List.of(
+            "Toyota", "Ford", "BMW", "Mercedes-Benz", "Audi",
+            "Volkswagen", "Honda", "Chevrolet", "Nissan", "Hyundai"
+        );
+}

src/main/java/cz/vsb/fei/efrei/lab04/Country.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class Country<T extends Fighter> {
+
+	private List<T> army;
+
+	private String name;
+
+	public Country(String name) {
+		this.name = name;
+		army = new LinkedList<>();
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void hire(T soldier) {
+		army.add(soldier);
+	}
+
+	public int getArmyStrength() {
+		int sum = 0;
+		for (T t : army) {
+			if(t.isAlive()) {
+				sum += t.getStrenght();
+			}
+		}
+		return sum;
+	}
+
+	public int getAliveSoldierCount() {
+		int count = 0;
+		for (T t : army) {
+			if(t.isAlive()) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	public int getSoldierAverageStrength() {
+		int sum = getArmyStrength();
+		int count =getAliveSoldierCount();
+		if(count == 0) {
+			return 0;
+		}
+		return sum/count;
+	}
+
+	public List<? extends Fighter> getArmy() {
+		return army;
+	}
+	
+	public String getArmyStat() {
+		return String.format("%6d[%3d] - %5d", getArmyStrength(), getSoldierAverageStrength(), getAliveSoldierCount());
+	}
+	
+	public boolean someoneAlive() {
+		for (T t : army) {
+			if(t.isAlive()) {
+				return true;
+			}
+		}
+		return false;
+	}
+}

src/main/java/cz/vsb/fei/efrei/lab04/Country2.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class Country2 {
+
+	private List<Fighter> army;
+	
+	private String name; 
+	
+	public Country2(String name) {
+		this.name = name;
+		army = new LinkedList<>();
+	}
+
+	public String getName() {
+		return name;
+	}
+	
+	public void hire(Fighter soldier) {
+		army.add(soldier);
+	}
+	
+	public List<Fighter> getArmy(){
+		return army;
+	}
+}

src/main/java/cz/vsb/fei/efrei/lab04/Formatter.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Formatter {
+
+	public int length() default 10;
+	public String name() default "";
+	public boolean hidden() default false;
+}

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

@@ -6,8 +6,14 @@ public class Hero implements Fighter {
 
 	private static final Random RANDOM = new Random();
 
+	@Order(2)
+	@Formatter(length = 15)
 	protected String name;
+	@Order(3)
+	@Formatter(length = 5)
 	protected int strenght;
+	@Order(1)
+	@Formatter(length = 4, name = "LIVES")
 	private int lives;
 
 	public Hero(String name, int strenght) {
@@ -28,9 +34,9 @@ public class Hero implements Fighter {
 		if (!isAlive()) {
 			throw new AlreadyDeadException(this);
 		}
-		System.out.println(fighter.getName() + " attack " + getName() + "!");
+//		System.out.println(fighter.getName() + " attack " + getName() + "!");
 		if (RANDOM.nextBoolean()) {
-			System.out.println("Attack was blocked!! Ha. Ha. Ha.");
+//			System.out.println("Attack was blocked!! Ha. Ha. Ha.");
 			return;
 		}
 		lives -= fighter.getStrenght();

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

@@ -6,9 +6,18 @@ public class Monster implements Fighter {
 
 	private static final Random RANDOM = new Random();
 
+	@Order(3)
+	@Formatter(length = 15)
 	private String name;
+	@Order(1)
+	@Formatter(length = 5)
 	private final int strenght;
+	@Order(2)
+	@Formatter(length = 4)
 	private int lives;
+	@Order(1)
+	@Formatter(hidden = true)
+	private boolean leader = true;
 
 	public Monster(String name, int strenght) {
 		if (name == null || name.length() < 2) {
@@ -28,7 +37,7 @@ public class Monster implements Fighter {
 
 	@Override
 	public void attackedBy(Fighter fighter) {
-		System.out.println(fighter.getName() + " attack " + getName() + "!");
+//		System.out.println(fighter.getName() + " attack " + getName() + "!");
 		lives -= fighter.getStrenght();
 	}
 

src/main/java/cz/vsb/fei/efrei/lab04/MonsterGenerator.java

+package cz.vsb.fei.efrei.lab04;
+
+public class MonsterGenerator implements SoldierGenerator<Monster>{
+
+	@Override
+	public Monster generateSoldier() {
+		return new Monster(Utils.generateMonsterName());
+	}
+
+	
+}

src/main/java/cz/vsb/fei/efrei/lab04/Order.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Order {
+	public int value();
+}

src/main/java/cz/vsb/fei/efrei/lab04/ParralerWorld.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.util.Random;
+
+public class ParralerWorld {
+
+	private char[] text;
+	private boolean stop;
+	private Object bounceMonitor = new Object();
+	private int bouncePosition = 10;
+
+	public static void main(String[] args) {
+		new ParralerWorld().animation();
+	}
+
+	public static void printOuptup() {
+		Object monitor = new Object();
+		for (int i = 0; i < 5; i++) {
+			Thread t = new Thread(() -> {
+				Random random = new Random();
+				for (int j = 0; j < 100 && !Thread.currentThread().isInterrupted(); j++) {
+					synchronized (monitor) {
+						for (int k = 0; k < 5; k++) {
+							System.out.println(
+									((j * 5) + k) + ": Hello from thread: " + Thread.currentThread().getName());
+						}
+					}
+//					try {
+//						Thread.sleep(random.nextInt(1000, 5000));
+//					} catch (InterruptedException e) {
+//						Thread.currentThread().interrupt();
+//					}
+				}
+			});
+			t.setName("My super Thrtead " + i);
+			t.start();
+		}
+
+	}
+
+	private void animation() {
+		Thread t1 = new Thread(this::draw);
+		t1.start();
+		new Thread(() -> rotatingBackslash(100)).start();
+		new Thread(() -> rotatingBackslash(500)).start();
+		new Thread(() -> move(200, 'o', 1)).start();
+		new Thread(() -> move(200, '*', 18)).start();
+	}
+
+	private void draw() {
+		text = new char[20];
+		for (int i = 0; i < text.length; i++) {
+			text[i] = '_';
+		}
+		while (!stop && !Thread.currentThread().isInterrupted()) {
+			for (int i = 0; i < text.length; i++) {
+				if (text[i] == '_') {
+					text[i] = '‾';
+				} else if (text[i] == '‾') {
+					text[i] = '_';
+				}
+			}
+			System.out.print(new String(text));
+			System.out.print("\r");
+			try {
+				Thread.sleep(1);
+			} catch (InterruptedException e) {
+				Thread.currentThread().interrupt();
+			}
+		}
+	}
+
+	private void rotatingBackslash(int delay) {
+		char[] backslash = new char[] { '\\', '/', '—' };
+		int index = new Random().nextInt(text.length);
+		while (!stop && !Thread.currentThread().isInterrupted()) {
+			for (int i = 0; i < backslash.length; i++) {
+				text[index] = backslash[i];
+				try {
+					Thread.sleep(delay);
+				} catch (InterruptedException e) {
+					Thread.currentThread().interrupt();
+					break;
+				}
+			}
+		}
+	}
+
+	private void move(int delay, char character, int index) {
+//		int index = new Random().nextInt(text.length);
+		int direction = 1;
+		int oldIndex = index;
+		synchronized (bounceMonitor) {
+			while (!stop && !Thread.currentThread().isInterrupted()) {
+				text[oldIndex] = '_';
+				text[index] = character;
+				oldIndex = index;
+				index += direction;
+				if (index == 0 || index == text.length - 1 || index == bouncePosition) {
+					direction = -direction;
+				}
+				if(index == bouncePosition) {
+					try {
+						bounceMonitor.notifyAll();
+						bounceMonitor.wait();
+					} catch (InterruptedException e) {
+						Thread.currentThread().interrupt();
+						continue;
+					}
+				}
+				try {
+					Thread.sleep(delay);
+				} catch (InterruptedException e) {
+					Thread.currentThread().interrupt();
+					break;
+				}
+			}
+		}
+	}
+}

src/main/java/cz/vsb/fei/efrei/lab04/ReflectedFighter.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class ReflectedFighter {
+
+	public static void main(String[] args) {
+		List<Fighter> fighters = Stream
+				.concat(Stream.generate(Utils::generateHeroName).map(Hero::new).limit(10),
+						Stream.generate(Utils::generateMonsterName).map(Monster::new).limit(10))
+				.collect(Collectors.toList());
+		Collections.shuffle(fighters);
+
+		for (Fighter fighter : fighters) {
+			printUsingReflection(fighter);
+		}
+
+		for(Car car : Stream.generate(Car::generate).limit(10).toList()) {
+			printUsingReflection(car);
+		}
+	}
+
+	private static void printUsingReflection(Object object) {
+		try {
+			Class<?> fighterClass = object.getClass();
+			Field[] fields = fighterClass.getDeclaredFields();
+			List<Field> listOfFields = new ArrayList<>();
+			listOfFields.addAll(List.of(fields));
+			listOfFields.sort(Comparator.comparing(field -> {
+				if (field.getAnnotation(Order.class) != null) {
+					return field.getAnnotation(Order.class).value();
+				}
+				return 0;
+			}));
+			for (Field field : listOfFields) {
+				if (Modifier.isStatic(field.getModifiers())) {
+					continue;
+				}
+				Formatter f = field.getAnnotation(Formatter.class);
+				field.setAccessible(true);
+				int length = 10;
+				String name = field.getName();
+				boolean hidden = false;
+				if (f != null) {
+					length = f.length();
+					name = f.name().isEmpty()?name:f.name();
+					hidden = f.hidden();
+				}
+				if (hidden) {
+					continue;
+				}
+				System.out.format("%s: %" + length + "s  ", name, field.get(object));
+			}
+			System.out.println();
+		} catch (IllegalArgumentException | IllegalAccessException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/cz/vsb/fei/efrei/lab04/SoldierGenerator.java

+package cz.vsb.fei.efrei.lab04;
+
+@FunctionalInterface
+public interface SoldierGenerator<T> {
+
+	T generateSoldier();
+}

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

@@ -24,4 +24,7 @@ public class Utils {
 		return monsterNames.get(RANDOM.nextInt(monsterNames.size()));
 	}
 	
+	public static <T> T getRandom(List<T> list) {
+		return list.get(RANDOM.nextInt(list.size()));
+	}
 }

src/main/java/cz/vsb/fei/efrei/lab04/WorldOfGenericCountries.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class WorldOfGenericCountries {
+
+	public static void main(String[] args) {
+//		Country2 countryOfEvil = new Country2("Mordor");
+//		Country2 countryOfBraves = new Country2("Heros from lake of Braves");
+//		countryOfEvil.hire(new Hero(Utils.generateHeroName()));
+//		countryOfBraves.hire(new Monster(Utils.generateMonsterName()));
+
+		List<Country<? extends Fighter>> countries = new ArrayList<>();
+
+		countries.add(createCountryOfMonsters());
+		countries.add(createCountryOfHeros());
+
+		Country<? extends Fighter> c1 = Utils.getRandom(countries);
+		Country<? extends Fighter> c2 = Utils.getRandom(countries);
+		boolean c1Miss = false;
+		boolean c2Miss = false;
+		System.out.println(String.format("%20s X %20s", c1.getName(), c2.getName()));
+		while (c1.someoneAlive() && c2.someoneAlive()) {
+			c1Miss = false;
+			c2Miss = false;
+			Fighter f1 = choseAliveFighter(c1);
+			Fighter f2 = choseAliveFighter(c2);
+			try {
+				f1.attackedBy(f2);
+			} catch (AlreadyDeadException e) {
+				c2Miss = true;
+			}
+			f1 = choseAliveFighter(c1);
+			f2 = choseAliveFighter(c2);
+			try {
+				f2.attackedBy(f1);
+			} catch (AlreadyDeadException e) {
+				c1Miss = true;
+			}
+			System.out.print(String.format("%s%s <> %s%s", c1Miss ? "miss" : "    ", c1.getArmyStat(),
+					c2Miss ? "miss" : "    ", c2.getArmyStat()));
+			System.out.print("\r");
+			try {
+				Thread.sleep(10);
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		}
+
+	}
+
+	private static Fighter choseAliveFighter(Country<? extends Fighter> c) {
+		Fighter f;
+		f = Utils.getRandom(c.getArmy());
+		while (!f.isAlive() && c.someoneAlive()) {
+			f = Utils.getRandom(c.getArmy());
+		}
+		return f;
+	}
+
+	private static Country<? extends Fighter> createCountryOfMonsters() {
+		Country<Monster> countryOfEvil = new Country<>("SoldierGenerator<T> generatorMordor");
+
+		populateArmy(countryOfEvil, new MonsterGenerator(), 200);
+		populateArmy(countryOfEvil, new MonsterGenerator2(), 200);
+		populateArmy(countryOfEvil, () -> new Monster(Utils.generateMonsterName()), 200);
+		return countryOfEvil;
+	}
+
+	private static Country<? extends Fighter> createCountryOfHeros() {
+		Country<Hero> countryOfBraves = new Country<>("Heros from lake of Braves");
+		populateArmy(countryOfBraves, () -> new Hero(Utils.generateHeroName()), 300);
+		return countryOfBraves;
+	}
+
+	private static <T extends Fighter> void populateArmy(Country<T> country, SoldierGenerator<T> generator, int count) {
+		for (int i = 0; i < count; i++) {
+			country.hire(generator.generateSoldier());
+		}
+	}
+
+	public static class MonsterGenerator2 implements SoldierGenerator<Monster> {
+		@Override
+		public Monster generateSoldier() {
+			return new Monster(Utils.generateMonsterName());
+		}
+	}
+}

src/main/java/cz/vsb/fei/efrei/lab04/WorldOfStrongFighteres.java

+package cz.vsb.fei.efrei.lab04;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+public class WorldOfStrongFighteres {
+	public static void main(String[] args) {
+		//generate names
+		//map names to Heros  - create heros with name
+		//filter out weaker then 100 (strength)
+		//limit to 20 elemnts
+		//print all to the consola
+		
+		
+		Stream.generate(Utils::generateHeroName)
+			.map(Hero::new)
+//			.peek(hero -> System.out.println("All: " + hero))
+			.filter(hero -> hero.getStrenght()>=100)
+			.limit(20)
+			.forEach(System.out::println);
+		
+		
+		List<Army> armies = Stream.generate(Army::generate).limit(200).toList();
+		
+		double avgStrength = armies.stream().flatMap(a -> a.getSoldiers().stream())
+			.mapToInt(fighter -> fighter.getStrenght()).average().orElse(0);
+		System.out.println(avgStrength);
+
+		armies.stream().flatMap(a -> a.getSoldiers().stream())
+				.limit(0)
+				.mapToInt(Fighter::getStrenght).average()
+				.ifPresent(d -> System.out.println("Average is:" + d));
+
+		System.out.println("==============================================");
+		Stopwatch stopwatch = new Stopwatch();
+		stopwatch.start();
+		List<Army> a2 = Stream.generate(Army::generate).limit(200000).toList();
+		double sum = a2.parallelStream().flatMap(a -> a.getSoldiers().stream())
+		.mapToInt(Fighter::getStrenght).sum();
+		//.ifPresent(d -> System.out.println("Average is:" + d));
+		stopwatch.stop();
+		System.out.println(stopwatch.formatDuration());
+	}
+}

src/main/java/cz/vsb/fei/efrei/lab04/WorldOfStrongestFighter.java

@@ -10,6 +10,8 @@ import java.util.Locale;
 import java.util.Random;
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class WorldOfStrongestFighter {
 	public static void main(String[] args) {
@@ -36,13 +38,16 @@ public class WorldOfStrongestFighter {
 
 		sortBaseOnNativeLanguageRules(fighters);
 
-		String[] streetNames = new String[] {"Broadway", "Abbey_Road", "Champs-Élysées"};
+		String[] streetNames = new String[] { "Broadway", "Abbey_Road", "Champs-Élysées" };
 		List<String> streetAddresses = new ArrayList<>();
 		for (int i = 0; i < 20; i++) {
-			streetAddresses.add(String.format("%s %s", 
-					streetNames[Utils.RANDOM.nextInt(streetNames.length)],
+			streetAddresses.add(String.format("%s %s", streetNames[Utils.RANDOM.nextInt(streetNames.length)],
 					Utils.RANDOM.nextInt(1, 200)));
 		}
+		streetAddresses = Stream.generate(() -> 
+			String.format("%s %s",streetNames[Utils.RANDOM.nextInt(streetNames.length)], Utils.RANDOM.nextInt(1, 200)))
+			.limit(20)
+				.collect(Collectors.toList());
 		sortStringsAsNumberAware(streetAddresses);
 	}
 
@@ -51,37 +56,28 @@ public class WorldOfStrongestFighter {
 		Collections.sort(streetAddresses);
 		printOutListOfFighters(streetAddresses, "Sort street address using strings");
 		Collections.shuffle(streetAddresses);
-		Collections.sort(streetAddresses, new Comparator<String>() {
-			@Override
-			public int compare(String s1, String s2) {
-				String[] parts1 = s1.split(" ");
-				String[] parts2 = s2.split(" ");
-				int result = parts1[0].compareTo(parts2[0]);
-				if(result != 0) {
-					return result;
-				}
-				return Integer.compare(
-						Integer.parseInt(parts1[1]), 
-						Integer.parseInt(parts2[1]));
+		Collections.sort(streetAddresses, (s1, s2) -> {
+			String[] parts1 = s1.split(" ");
+			String[] parts2 = s2.split(" ");
+			int result = parts1[0].compareTo(parts2[0]);
+			if (result != 0) {
+				return result;
 			}
+			return Integer.compare(Integer.parseInt(parts1[1]), Integer.parseInt(parts2[1]));
 		});
 		printOutListOfFighters(streetAddresses, "Sort street address using numbers");
 	}
+
 	private static void sortBaseOnNativeLanguageRules(List<Fighter> fighters) {
-		Collator czCollator = Collator.getInstance(Locale.of("cs"));
-		Collections.sort(fighters, new Comparator<Fighter>() {
-			@Override
-			public int compare(Fighter o1, Fighter o2) {
-				return czCollator.compare(o1.getName(), o2.getName());
-			}
-		});
+//		Collator czCollator = Collator.getInstance(Locale.of("cs"));
+		Collections.sort(fighters, Comparator.comparing(Fighter::getName));
 		printOutListOfFighters(fighters, "Sort base on czech language native rules");
 	}
 
 	private static void sortBaseOnLives(List<Fighter> fighters) {
 		for (int i = 0; i < 20; i++) {
-			Fighter f1 =  fighters.get(Utils.RANDOM.nextInt(fighters.size()));
-			Fighter f2 =  fighters.get(Utils.RANDOM.nextInt(fighters.size()));
+			Fighter f1 = fighters.get(Utils.RANDOM.nextInt(fighters.size()));
+			Fighter f2 = fighters.get(Utils.RANDOM.nextInt(fighters.size()));
 			try {
 				f1.attackedBy(f2);
 			} catch (AlreadyDeadException e) {
@@ -107,17 +103,7 @@ public class WorldOfStrongestFighter {
 	}
 
 	private static void sortByNameAndThenByStrenght(List<Fighter> fighters) {
-		Collections.sort(fighters, new Comparator<Fighter>() {
-
-			@Override
-			public int compare(Fighter o1, Fighter o2) {
-				int result = o1.getName().compareTo(o2.getName());
-				if (result != 0) {
-					return result;
-				}
-				return Integer.compare(o1.getStrenght(), o2.getStrenght());
-			}
-		});
+		Collections.sort(fighters, Comparator.comparing(Fighter::getName).thenComparing(Fighter::getStrenght));
 		printOutListOfFighters(fighters, "Sorted fighters by name and by strenght");
 	}
 
@@ -165,15 +151,23 @@ public class WorldOfStrongestFighter {
 	}
 
 	private static List<Fighter> generateFighters(int countOfHeros, int countOfMonsters) {
-		List<Fighter> fighters = new ArrayList<>(countOfHeros + countOfMonsters);
-		for (int i = 0; i < countOfHeros; i++) {
-			fighters.add(new Hero(Utils.generateHeroName()));
-		}
-
-		for (int i = 0; i < countOfMonsters; i++) {
-			fighters.add(new Monster(Utils.generateMonsterName()));
-		}
-		return fighters;
+//		List<Fighter> fighters = new ArrayList<>(countOfHeros + countOfMonsters);
+		
+		return Stream.concat(
+			Stream.generate(Utils::generateHeroName)
+				.map(Hero::new)
+				.limit(countOfHeros)
+			,
+			Stream.generate(Utils::generateMonsterName)
+				.map(Monster::new)
+				.limit(countOfHeros)
+//		).collect(Collectors.toList());
+		).toList();
+
+//		for (int i = 0; i < countOfMonsters; i++) {
+//			fighters.add(new Monster(Utils.generateMonsterName()));
+//		}
+//		return fighters;
 	}
 
 	private static void shuffleAndSortFighters(List<Fighter> fighters) {