diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Army.java b/src/main/java/cz/vsb/fei/efrei/lab04/Army.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba0909e0ee0af1f1c772cae3f6e9cfa8952ce907
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/Army.java
@@ -0,0 +1,29 @@
+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);
+ }
+
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Car.java b/src/main/java/cz/vsb/fei/efrei/lab04/Car.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc7275ecc34885b4b50e77fecd5847bd2cbe3f4b
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/Car.java
@@ -0,0 +1,57 @@
+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"
+ );
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Country.java b/src/main/java/cz/vsb/fei/efrei/lab04/Country.java
new file mode 100644
index 0000000000000000000000000000000000000000..adb2de49c4df9b74fcce1680cb468b79ea678b33
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/Country.java
@@ -0,0 +1,70 @@
+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;
+ }
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Country2.java b/src/main/java/cz/vsb/fei/efrei/lab04/Country2.java
new file mode 100644
index 0000000000000000000000000000000000000000..188269521cd04f9a478048a60a7fe505c882fd23
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/Country2.java
@@ -0,0 +1,28 @@
+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;
+ }
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Formatter.java b/src/main/java/cz/vsb/fei/efrei/lab04/Formatter.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccd589414fc95caf8aac154e5d78265048f91004
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/Formatter.java
@@ -0,0 +1,15 @@
+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;
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Hero.java b/src/main/java/cz/vsb/fei/efrei/lab04/Hero.java
index 6062aa5942f7f90cd8648153b8f2c74d07142f60..7ade6bfaaad4c3d16f7c1533077331da89fe9f81 100644
--- a/src/main/java/cz/vsb/fei/efrei/lab04/Hero.java
+++ b/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();
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Monster.java b/src/main/java/cz/vsb/fei/efrei/lab04/Monster.java
index dff9ce454063161f1373074a7f23bfb56c0479fa..c0ca7d2e8d30bfa085e17f52b7a4419f9845aa27 100644
--- a/src/main/java/cz/vsb/fei/efrei/lab04/Monster.java
+++ b/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();
}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/MonsterGenerator.java b/src/main/java/cz/vsb/fei/efrei/lab04/MonsterGenerator.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d462bf9a44f58abfd01840a1824b90bd1a88866
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/MonsterGenerator.java
@@ -0,0 +1,11 @@
+package cz.vsb.fei.efrei.lab04;
+
+public class MonsterGenerator implements SoldierGenerator<Monster>{
+
+ @Override
+ public Monster generateSoldier() {
+ return new Monster(Utils.generateMonsterName());
+ }
+
+
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Order.java b/src/main/java/cz/vsb/fei/efrei/lab04/Order.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb1ef8f717e8ab323a48d067537330cbea2f1abe
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/Order.java
@@ -0,0 +1,12 @@
+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();
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/ParralerWorld.java b/src/main/java/cz/vsb/fei/efrei/lab04/ParralerWorld.java
new file mode 100644
index 0000000000000000000000000000000000000000..21f050336b88105f8cb0f381c1d1fb39542c449c
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/ParralerWorld.java
@@ -0,0 +1,120 @@
+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;
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/ReflectedFighter.java b/src/main/java/cz/vsb/fei/efrei/lab04/ReflectedFighter.java
new file mode 100644
index 0000000000000000000000000000000000000000..8653ad195a169bd031bdb0bf319b475b6fca9d98
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/ReflectedFighter.java
@@ -0,0 +1,67 @@
+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();
+ }
+ }
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/SoldierGenerator.java b/src/main/java/cz/vsb/fei/efrei/lab04/SoldierGenerator.java
new file mode 100644
index 0000000000000000000000000000000000000000..9534d1edd986d4cf30379a2523d64066a980b73a
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/SoldierGenerator.java
@@ -0,0 +1,7 @@
+package cz.vsb.fei.efrei.lab04;
+
+@FunctionalInterface
+public interface SoldierGenerator<T> {
+
+ T generateSoldier();
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/Utils.java b/src/main/java/cz/vsb/fei/efrei/lab04/Utils.java
index 7033d48f8d108ee3ec1208c7668821ad21abda3a..2374299ad5c107a2dc1b07ecf7da331b9fbdf3c9 100644
--- a/src/main/java/cz/vsb/fei/efrei/lab04/Utils.java
+++ b/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()));
+ }
}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfGenericCountries.java b/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfGenericCountries.java
new file mode 100644
index 0000000000000000000000000000000000000000..aef1f411f4b98a32b9b29149e63e462533acf339
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfGenericCountries.java
@@ -0,0 +1,89 @@
+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());
+ }
+ }
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfStrongFighteres.java b/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfStrongFighteres.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e336cd06b0bffe22ae48930fb7a051d550391d8
--- /dev/null
+++ b/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfStrongFighteres.java
@@ -0,0 +1,44 @@
+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());
+ }
+}
diff --git a/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfStrongestFighter.java b/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfStrongestFighter.java
index 89b2a62ebee266801a71212946bb8ae1acbead49..51f629a47a68d96eae376a4a1797a39d0dd1de78 100644
--- a/src/main/java/cz/vsb/fei/efrei/lab04/WorldOfStrongestFighter.java
+++ b/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) {