feat: solution

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

 package cz.vsb.fei.efrei.lab04;
 
-public interface Fighter {
+public interface Fighter extends Comparable<Fighter> {
 
 	int getLives();
 

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

@@ -20,7 +20,7 @@ public class Hero implements Fighter {
 	}
 
 	public Hero(String name) {
-		this(name, RANDOM.nextInt(5000) + 50);
+		this(name, RANDOM.nextInt(60) + 50);
 	}
 
 	@Override
@@ -53,7 +53,12 @@ public class Hero implements Fighter {
 
 	@Override
 	public String toString() {
-		return "Hero " + name + "(" + strenght + ")";
+		return String.format("Hero    %20s (%4d) - has %4d lives.", name, strenght, lives);
+	}
+
+	@Override
+	public int compareTo(Fighter o) {
+		return this.getName().compareTo(o.getName());
 	}
 
 }

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

@@ -11,13 +11,11 @@ public class Monster implements Fighter {
 	private int lives;
 
 	public Monster(String name, int strenght) {
-		if(name == null || name.length() < 2 ) {
-			throw new IllegalArgumentException(
-					"Too short name");
+		if (name == null || name.length() < 2) {
+			throw new IllegalArgumentException("Too short name");
 		}
-		if(strenght < 10) {
-			throw new IllegalArgumentException(
-					"Monster is too weak!!");
+		if (strenght < 10) {
+			throw new IllegalArgumentException("Monster is too weak!!");
 		}
 		this.name = name;
 		this.strenght = strenght;
@@ -33,7 +31,7 @@ public class Monster implements Fighter {
 		System.out.println(fighter.getName() + " attack " + getName() + "!");
 		lives -= fighter.getStrenght();
 	}
-	
+
 	@Override
 	public String getName() {
 		return name;
@@ -51,7 +49,12 @@ public class Monster implements Fighter {
 
 	@Override
 	public String toString() {
-		return "Monster " + name + "(" + strenght + ") - has " + lives + " lives.";
+		return String.format("Monster %20s (%4d) - has %4d lives.", name, strenght, lives);
+	}
+
+	@Override
+	public int compareTo(Fighter o) {
+		return this.getName().compareTo(o.getName());
 	}
 
 }

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

+package cz.vsb.fei.efrei.lab04;
+
+import java.util.Comparator;
+
+public class StrenghtComparator implements Comparator<Fighter> {
+
+	@Override
+	public int compare(Fighter o1, Fighter o2) {
+		return o1.getStrenght() - o2.getStrenght();
+	}
+
+}

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

@@ -8,13 +8,13 @@ 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",
+			"Č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",
+			"Á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() {

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

+package cz.vsb.fei.efrei.lab04;
+
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Random;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+public class WorldOfStrongestFighter {
+	public static void main(String[] args) {
+		int countOfHeros = 10;
+		int countOfMonsters = 10;
+		List<Fighter> fighters = generateFighters(countOfHeros, countOfMonsters);
+
+		printOutListOfFighters(fighters, "Generated fighters");
+
+		shuffleAndSortFighters(new ArrayList<Fighter>(fighters));
+
+		compareTimeForIndexOfandBinarySearch(generateFighters(10000, 10000));
+
+		sortUsingNormalClass(new ArrayList<Fighter>(fighters));
+		sortUsingInnerClass(new ArrayList<Fighter>(fighters));
+
+		sortUsingAnonymousInnerClass(new ArrayList<Fighter>(fighters));
+
+		sortByNameAndThenByStrenght(new ArrayList<Fighter>(fighters));
+
+		createNullSafeComparator(new ArrayList<Fighter>(fighters));
+
+		sortBaseOnLives(new ArrayList<Fighter>(fighters));
+
+		sortBaseOnNativeLanguageRules(fighters);
+
+		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)],
+					Utils.RANDOM.nextInt(1, 200)));
+		}
+		sortStringsAsNumberAware(streetAddresses);
+	}
+
+	private static void sortStringsAsNumberAware(List<String> streetAddresses) {
+		Collections.shuffle(streetAddresses);
+		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]));
+			}
+		});
+		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());
+			}
+		});
+		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()));
+			try {
+				f1.attackedBy(f2);
+			} catch (AlreadyDeadException e) {
+				System.out.println("Some one attack dead fighter");
+			}
+		}
+		Collections.sort(fighters, Comparator.comparing(new Function<Fighter, Integer>() {
+			@Override
+			public Integer apply(Fighter t) {
+				return t.getLives();
+			}
+		}));
+		printOutListOfFighters(fighters, "Sort base on lives");
+	}
+
+	private static void createNullSafeComparator(List<Fighter> fighters) {
+		for (int i = 0; i < 10; i++) {
+			fighters.add(null);
+		}
+		Collections.shuffle(fighters);
+		Collections.sort(fighters, Comparator.nullsFirst(new StrenghtInnerClassComparator()));
+		printOutListOfFighters(fighters, "Null safe comparator");
+	}
+
+	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());
+			}
+		});
+		printOutListOfFighters(fighters, "Sorted fighters by name and by strenght");
+	}
+
+	private static void sortUsingAnonymousInnerClass(List<Fighter> fighters) {
+		Collections.sort(fighters, new Comparator<Fighter>() {
+
+			@Override
+			public int compare(Fighter o1, Fighter o2) {
+				return Integer.compare(o1.getStrenght(), o2.getStrenght());
+			}
+		});
+		printOutListOfFighters(fighters, "Sorted fighters using anonymous inner class");
+	}
+
+	private static void sortUsingInnerClass(List<Fighter> fighters) {
+		Collections.sort(fighters, new StrenghtInnerClassComparator());
+		printOutListOfFighters(fighters, "Sorted fighters using Comparator implemented by inner class");
+	}
+
+	private static void sortUsingNormalClass(List<Fighter> fighters) {
+		Collections.sort(fighters, new StrenghtComparator());
+		printOutListOfFighters(fighters, "Sorted fighters using Comparator implemented by normal class");
+	}
+
+	private static void compareTimeForIndexOfandBinarySearch(List<Fighter> fighters) {
+		Fighter heroToSearch = new Hero(Utils.generateHeroName());
+		Stopwatch stopwatch = new Stopwatch();
+		stopwatch.start();
+		fighters.indexOf(heroToSearch);
+		stopwatch.stop();
+		System.out.println("Not sorted collection search duration: " + stopwatch.formatDuration());
+		Collections.sort(fighters);
+		stopwatch.start();
+		Collections.binarySearch(fighters, heroToSearch);
+		stopwatch.stop();
+		System.out.println("Sorted collection binary search duration: " + stopwatch.formatDuration());
+	}
+
+	private static void printOutListOfFighters(List<?> listOfObjects, String title) {
+		System.out.println("=========" + title + "============================================");
+		for (Object element : listOfObjects) {
+			System.out.println(element);
+		}
+		System.out.println("=============================================================================");
+	}
+
+	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;
+	}
+
+	private static void shuffleAndSortFighters(List<Fighter> fighters) {
+		Collections.shuffle(fighters);
+		printOutListOfFighters(fighters, "Shuffled fighters");
+		Collections.sort(fighters);
+		printOutListOfFighters(fighters, "Sorted fighters");
+	}
+
+	private static class StrenghtInnerClassComparator implements Comparator<Fighter> {
+
+		@Override
+		public int compare(Fighter o1, Fighter o2) {
+			return Integer.compare(o1.getStrenght(), o2.getStrenght());
+		}
+
+	}
+}