Skip to content
Snippets Groups Projects
Commit 8888479b authored by jez04's avatar jez04
Browse files

feat: solution

parent 2f6ad78f
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 346 additions and 286 deletions
pom.xml
+ 2
− 2
View file @ 8888479b
......@@ -3,10 +3,10 @@
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>
<artifactId>efrei-lab04</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>efrei-lab03</name>
<name>efrei-lab04</name>
<packaging>jar</packaging>
......
src/main/java/cz/vsb/fei/efrei/lab03/DangerWorld.java deleted 100644 → 0
+ 0
− 50
View file @ 2f6ad78f
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/WorkWithCollections.java deleted 100644 → 0
+ 0
− 225
View file @ 2f6ad78f
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/cz/vsb/fei/efrei/lab03/AlreadyDeadException.java → src/main/java/cz/vsb/fei/efrei/lab04/AlreadyDeadException.java
+ 1
− 1
View file @ 8888479b
package cz.vsb.fei.efrei.lab03;
package cz.vsb.fei.efrei.lab04;
public class AlreadyDeadException extends Exception {
......
src/main/java/cz/vsb/fei/efrei/lab03/Fighter.java → src/main/java/cz/vsb/fei/efrei/lab04/Fighter.java
+ 1
− 1
View file @ 8888479b
package cz.vsb.fei.efrei.lab03;
package cz.vsb.fei.efrei.lab04;
public interface Fighter {
......
src/main/java/cz/vsb/fei/efrei/lab03/Hero.java → src/main/java/cz/vsb/fei/efrei/lab04/Hero.java
+ 6
− 5
View file @ 8888479b
package cz.vsb.fei.efrei.lab03;
package cz.vsb.fei.efrei.lab04;
import java.util.Objects;
import java.util.Random;
public class Hero implements Fighter{
private static final Random RANDOM = new Random();
private String name;
private int strenght;
protected String name;
protected int strenght;
private int lives;
public Hero(String name, int strenght) {
......@@ -22,7 +23,7 @@ public class Hero implements Fighter{
}
public Hero(String name) {
this(name, RANDOM.nextInt(50) + 50);
this(name, RANDOM.nextInt(5000) + 50);
}
@Override
......@@ -56,7 +57,7 @@ public class Hero implements Fighter{
@Override
public String toString() {
return "Hero " + name + "(" + strenght + ") - has " + lives + " lives.";
return "Hero " + name + "(" + strenght + ")";
}
}
src/main/java/cz/vsb/fei/efrei/lab04/HeroWithEquals.java 0 → 100644
+ 27
− 0
View file @ 8888479b
package cz.vsb.fei.efrei.lab04;
import java.util.Objects;
public class HeroWithEquals extends Hero {
public HeroWithEquals(String name) {
super(name);
}
public HeroWithEquals(String name, int strenght) {
super(name, strenght);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Hero other = (Hero) obj;
return Objects.equals(name, other.name);
}
}
src/main/java/cz/vsb/fei/efrei/lab04/HeroWithEqualsAndBadHashcode.java 0 → 100644
+ 32
− 0
View file @ 8888479b
package cz.vsb.fei.efrei.lab04;
import java.util.Objects;
public class HeroWithEqualsAndBadHashcode extends Hero {
public HeroWithEqualsAndBadHashcode(String name) {
super(name);
}
public HeroWithEqualsAndBadHashcode(String name, int strenght) {
super(name, strenght);
}
@Override
public int hashCode() {
return Objects.hash(strenght);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Hero other = (Hero) obj;
return Objects.equals(name, other.name) && strenght == other.strenght;
}
}
src/main/java/cz/vsb/fei/efrei/lab04/HeroWithEqualsAndConstantHashcode.java 0 → 100644
+ 32
− 0
View file @ 8888479b
package cz.vsb.fei.efrei.lab04;
import java.util.Objects;
public class HeroWithEqualsAndConstantHashcode extends Hero {
public HeroWithEqualsAndConstantHashcode(String name) {
super(name);
}
public HeroWithEqualsAndConstantHashcode(String name, int strenght) {
super(name, strenght);
}
@Override
public int hashCode() {
return 1;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Hero other = (Hero) obj;
return Objects.equals(name, other.name) && strenght == other.strenght;
}
}
src/main/java/cz/vsb/fei/efrei/lab04/HeroWithEqualsAndHashcode.java 0 → 100644
+ 32
− 0
View file @ 8888479b
package cz.vsb.fei.efrei.lab04;
import java.util.Objects;
public class HeroWithEqualsAndHashcode extends Hero {
public HeroWithEqualsAndHashcode(String name) {
super(name);
}
public HeroWithEqualsAndHashcode(String name, int strenght) {
super(name, strenght);
}
@Override
public int hashCode() {
return Objects.hash(name, strenght);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Hero other = (Hero) obj;
return Objects.equals(name, other.name) && strenght == other.strenght;
}
}
src/main/java/cz/vsb/fei/efrei/lab03/Monster.java → src/main/java/cz/vsb/fei/efrei/lab04/Monster.java
+ 1
− 1
View file @ 8888479b
package cz.vsb.fei.efrei.lab03;
package cz.vsb.fei.efrei.lab04;
import java.util.Random;
......
src/main/java/cz/vsb/fei/efrei/lab04/Stopwatch.java 0 → 100644
+ 34
− 0
View file @ 8888479b
package cz.vsb.fei.efrei.lab04;
public class Stopwatch {
private long startTime;
private long endTime;
public void start() {
startTime = System.nanoTime();
}
public void stop() {
endTime = System.nanoTime();
}
public long getDuration() {
return endTime - startTime;
}
public String formatDuration() {
long timeDuration = getDuration();
long timeNanoSec = timeDuration % 1000;
timeDuration = timeDuration / 1000;
long timeMicroSec = timeDuration % 1000;
timeDuration = timeDuration / 1000;
long timeMiliSec = timeDuration % 1000;
timeDuration = timeDuration / 1000;
long timeSec = timeDuration % 60;
timeDuration = timeDuration / 60;
long timeMinutes = timeDuration;
return String.format("%2dmin %2ds %3dms %3dus %3dns", timeMinutes, timeSec, timeMiliSec, timeMicroSec,
timeNanoSec);
}
}
src/main/java/cz/vsb/fei/efrei/lab03/Utils.java → src/main/java/cz/vsb/fei/efrei/lab04/Utils.java
+ 1
− 1
View file @ 8888479b
package cz.vsb.fei.efrei.lab03;
package cz.vsb.fei.efrei.lab04;
import java.util.Arrays;
import java.util.List;
......
src/main/java/cz/vsb/fei/efrei/lab04/WorldOfCollections.java 0 → 100644
+ 177
− 0
View file @ 8888479b
package cz.vsb.fei.efrei.lab04;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.Set;
public class WorldOfCollections {
private static final Random RANDOM = new Random();
public static void main(String[] args) {
useSetToStoreObjectWithoutHashCodeAndEquals();
useSetToStoreObjectWithEqualsOnlyForName();
useSetToStoreObjectWithEqualsAndHashCode();
useSetToStoreObjectWithEqualsBasedOnNameAndBadHashCode();
useSetToStoreObjectWithEqualsAndConstantHashCode();
System.out.println("==========================================================================================");
performanceForUseSetToStoreObjectWithEqualsAndHashCode();
performanceForUseSetToStoreObjectWithEqualsAndConstantHashCode();
System.out.println("==========================================================================================");
performanceForAddIntoArrayList();
performanceForAddIntoLinkedList();
performanceForInsertIntoArrayList();
performanceForInsertIntoLinkedList();
}
private static void testObjectAnHashSet(Set<Fighter> setOfFighters, Hero king1, Hero king2) {
setOfFighters.add(king1);
System.out.println("Is king1 " + king1 + " in set: " + setOfFighters.contains(king1));
System.out.println("Is king1 " + king1 + " equal to king2 " + king2 + ": " + king1.equals(king2));
System.out.println("Is king2 in set: " + setOfFighters.contains(king2));
setOfFighters.add(king2);
System.out.println("Is king2 in set after add: " + setOfFighters.contains(king2));
System.out.println("Size of set is: " + setOfFighters.size());
}
public static void useSetToStoreObjectWithoutHashCodeAndEquals() {
Set<Fighter> setOfFighters = new HashSet<>();
Hero king1 = new Hero("King", 66);
Hero king2 = new Hero("King", 66);
System.out.println("=====Use HashSet to Store Object Without HashCode And Equals================================");
testObjectAnHashSet(setOfFighters, king1, king2);
System.out.println("Each object is different (different palces in memory) even look same!");
}
public static void useSetToStoreObjectWithEqualsOnlyForName() {
Set<Fighter> setOfFighters = new HashSet<>();
Hero king1 = new HeroWithEquals("King", 66);
Hero king2 = new HeroWithEquals("King", 42);
System.out.println("=====Use HashSet to Store Object Only With Equals================================");
testObjectAnHashSet(setOfFighters, king1, king2);
System.out.println("Object are equals because of same name, but not found in set because of worng hashcode!");
}
public static void useSetToStoreObjectWithEqualsAndHashCode() {
Set<Fighter> setOfFighters = new HashSet<>();
Hero king1 = new HeroWithEqualsAndHashcode("King", 66);
Hero king2 = new HeroWithEqualsAndHashcode("King", 66);
System.out.println("=====Use HashSet to Store Object Only With Equals================================");
testObjectAnHashSet(setOfFighters, king1, king2);
System.out.println("It's work!");
}
public static void useSetToStoreObjectWithEqualsBasedOnNameAndBadHashCode() {
Set<Fighter> setOfFighters = new HashSet<>();
Hero king1 = new HeroWithEqualsAndBadHashcode("King", 66);
Hero king2 = new HeroWithEqualsAndBadHashcode("King", 42);
System.out.println("=====Use HashSet to Store Object With Equals and BAD hashcode================================");
testObjectAnHashSet(setOfFighters, king1, king2);
System.out.println("It does'n work!");
System.out.println("Object are equals because of same name, but not found in set because of worng hashcode calculated from strenght!");
}
public static void useSetToStoreObjectWithEqualsAndConstantHashCode() {
Set<Fighter> setOfFighters = new HashSet<>();
Hero king1 = new HeroWithEqualsAndConstantHashcode("King", 66);
Hero king2 = new HeroWithEqualsAndConstantHashcode("King", 66);
System.out.println("=====Use HashSet to Store Object With Equals and constant hashcode================================");
testObjectAnHashSet(setOfFighters, king1, king2);
System.out.println("It's work!");
}
private static String mesureAndAdd(Collection<Hero> sourceOfHeros, Collection<Hero> tragetOfHeros) {
Stopwatch stopwatch = new Stopwatch();
stopwatch.start();
for (Hero hero : sourceOfHeros) {
tragetOfHeros.add(hero);
}
stopwatch.stop();
String duration = stopwatch.formatDuration();
return duration;
}
private static String mesureAndInsert(Collection<Hero> sourceOfHeros, List<Hero> tragetOfHeros) {
Stopwatch stopwatch = new Stopwatch();
stopwatch.start();
for (Hero hero : sourceOfHeros) {
tragetOfHeros.add(0, hero);
}
stopwatch.stop();
String duration = stopwatch.formatDuration();
return duration;
}
public static void performanceForUseSetToStoreObjectWithEqualsAndHashCode() {
int countOfHeros = 20000;
List<Hero> heros = new ArrayList<>(countOfHeros);
for (int i = 0; i < countOfHeros; i++) {
heros.add(new HeroWithEqualsAndHashcode(Utils.generateHeroName()));
}
Set<Hero> setOfHeros = new HashSet<>();
String duration = mesureAndAdd(heros, setOfHeros);
System.out.println("Adding " + countOfHeros + " heros with correct hashcode and equals into set take " + duration);
}
public static void performanceForUseSetToStoreObjectWithEqualsAndConstantHashCode() {
int countOfHeros = 20000;
List<Hero> heros = new ArrayList<>(countOfHeros);
for (int i = 0; i < countOfHeros; i++) {
heros.add(new HeroWithEqualsAndConstantHashcode(Utils.generateHeroName()));
}
Set<Hero> setOfHeros = new HashSet<>();
String duration = mesureAndAdd(heros, setOfHeros);
System.out.println("Adding " + countOfHeros + " heros with constant hashcode into set take " + duration);
}
public static void performanceForAddIntoArrayList() {
int countOfHeros = 500000;
List<Hero> heros = new ArrayList<>(countOfHeros);
for (int i = 0; i < countOfHeros; i++) {
heros.add(new HeroWithEqualsAndConstantHashcode(Utils.generateHeroName()));
}
List<Hero> arrayListOfHeros = new ArrayList<>();
String duration = mesureAndAdd(heros, arrayListOfHeros);
System.out.println("Adding " + countOfHeros + " heros to end of ArrayList take " + duration);
}
public static void performanceForAddIntoLinkedList() {
int countOfHeros = 500000;
List<Hero> heros = new ArrayList<>(countOfHeros);
for (int i = 0; i < countOfHeros; i++) {
heros.add(new HeroWithEqualsAndConstantHashcode(Utils.generateHeroName()));
}
List<Hero> arrayListOfHeros = new LinkedList<>();
String duration = mesureAndAdd(heros, arrayListOfHeros);
System.out.println("Adding " + countOfHeros + " heros to end of LinkedList take " + duration);
}
public static void performanceForInsertIntoArrayList() {
int countOfHeros = 500000;
List<Hero> heros = new ArrayList<>(countOfHeros);
for (int i = 0; i < countOfHeros; i++) {
heros.add(new HeroWithEqualsAndConstantHashcode(Utils.generateHeroName()));
}
List<Hero> arrayListOfHeros = new ArrayList<>();
String duration = mesureAndInsert(heros, arrayListOfHeros);
System.out.println("Inserting " + countOfHeros + " heros at beginnig of ArrayList take " + duration);
}
public static void performanceForInsertIntoLinkedList() {
int countOfHeros = 500000;
List<Hero> heros = new ArrayList<>(countOfHeros);
for (int i = 0; i < countOfHeros; i++) {
heros.add(new HeroWithEqualsAndConstantHashcode(Utils.generateHeroName()));
}
List<Hero> arrayListOfHeros = new LinkedList<>();
String duration = mesureAndInsert(heros, arrayListOfHeros);
System.out.println("Inserting " + countOfHeros + " heros at beginnig of LinkedList take " + duration);
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment