solution

src/main/java/cz/jezek/lab11/Match.java

 package cz.jezek.lab11;
 
+import java.io.Serializable;
 import java.util.Objects;
 
-public class Match {
+public class Match implements Serializable{
 
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -7368303036334738923L;
+	
 	private Oponents oponents;
 	private int player1Scorel;
 	private int player2Scorel;

src/main/java/cz/jezek/lab11/Oponents.java

 package cz.jezek.lab11;
 
+import java.io.Serializable;
 import java.util.Objects;
 
-public class Oponents {
+public class Oponents implements Serializable{
 
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	
 	private Player player1;
 	private Player player2;
 

src/main/java/cz/jezek/lab11/Player.java

 package cz.jezek.lab11;
 
-public class Player {
+import java.io.Serializable;
 
+public class Player implements Serializable {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
 	private String firstName;
 	private String lastName;
 

src/main/java/cz/jezek/lab11/StreamMain.java

 package cz.jezek.lab11;
 
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Comparator;
+import java.util.stream.Collectors;
+
 public class StreamMain {
 
   public static void main(String[] args) {
-    Tournament tournament = Tournament.generate();
+    Tournament tournament = loadTournament();
 
     printStatAboutTournament(tournament);
 
     saveTournament(tournament);
-    loadTournament();
   }
 
   public static void printStatAboutTournament(Tournament tournament) {
@@ -21,6 +28,11 @@ public class StreamMain {
     
     System.out.print("Goals scored: ");
     //TODO 3.b Show the number of goals scored by a given player (help Streams)
+    System.out.println(tournament.getMatches().stream()
+    .filter( m -> m.getOponents().contains(player))
+    .map(m -> m.getScoreForPlayer(player))
+    .mapToInt(score -> score.intValue())
+    .sum());
 
     Oponents oponents = new Oponents(tournament.getRandomPlayer(),
         tournament.getRandomPlayer());
@@ -30,15 +42,40 @@ public class StreamMain {
     //TODO 4.a List the matches played between the given players (using the stream)
     System.out.print("Number of mathes: ");
     //TODO 4.b Print the number of matches played between the given players (using the stream)
-    System.out.print("Match with the largest total number:");
+    final String tournamentName = tournament.getMatches().stream().filter(m -> m.getOponents().equals(oponents))
+    	    .sorted(Comparator.<Match>comparingInt(m -> m.getPlayer1Scorel() + m.getPlayer2Scorel()).reversed())
+    	    .map(Object::toString).findFirst().orElse("N/A");
+    	    
+    System.out.println("Match with the largest total number: " + tournamentName);
+    
+    
+  //TODO 4.b Print the number of matches played between the given players (using the stream)
+    final String tournamentName2 = tournament.getMatches().stream().filter(m -> m.getOponents().equals(oponents))
+    	    .collect(Collectors.maxBy(Comparator.comparingInt(m -> m.getPlayer1Scorel() + m.getPlayer2Scorel())))
+    	    .map(Object::toString)
+    	    .orElse("N/A");
+    	    
+    System.out.println("Match with the largest total number: " + tournamentName2);
     //TODO 4.c Show match with the largest total number (sum of both players) scored goals between relevant players (help Streams)
+    
   }
 
-  public static void loadTournament() {
-    //TODO 5.b Load a serialized tournament from a file
+  public static Tournament loadTournament() {
+	  try(ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("data.obj"))) {
+	    	return (Tournament) ois.readObject();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} catch (ClassNotFoundException e) {
+			e.printStackTrace();
+		}
+	  return null;
   }
 
   public static void saveTournament(Tournament tournament) {
-    //TODO 5.a Save the tournament to a file using object serialization.
+    try(ObjectOutputStream oos  = new ObjectOutputStream(new FileOutputStream("data.obj"))) {
+    	oos.writeObject(tournament);
+	} catch (IOException e) {
+		e.printStackTrace();
+	}
   }
 }

src/main/java/cz/jezek/lab11/Tournament.java

 package cz.jezek.lab11;
 
-import java.util.Collections;
+import static cz.jezek.lab11.RandomGenerator.random;
+import static cz.jezek.lab11.RandomGenerator.selectRandom;
+
+import java.io.Serializable;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
-public class Tournament {
+public class Tournament implements Serializable{
 
+  private static final long serialVersionUID = 1L;
+ 
   private List<Player> players;
   private List<Match> matches;
 
   public static Tournament generate() {
 	// TODO 1.a Generate a list of 10 random players using the stream and then filter so that it does not contain players with the same name
-	List<Player> players = Collections.emptyList();
+	List<Player> players = 
+			Stream.generate(Player::generateRandom)
+			      .distinct()
+			      .limit(10)
+			      .collect(Collectors.toList());
 
-    // TODO 1.b Use the stream to generate a list of 50 matches between random players (from the list of players) with a random result. Make sure the player does not play with himself.
-    List<Match> matches = Collections.emptyList();
+    // TODO 1.b Use the stream to generate a list of 500 matches between random players (from the list of players) with a random result. Make sure the player does not play with himself.
+    List<Match> matches = Stream.generate(() -> generateRandomMatch(players))
+		      .filter(m -> m.getOponents().getPlayer1() != m.getOponents().getPlayer2())
+		      .limit(500)
+		      .collect(Collectors.toList());
 
 
     return new Tournament(players, matches);
@@ -33,7 +47,7 @@ public class Tournament {
   }
 
   public Player getRandomPlayer() {
-    return RandomGenarator.selectRandom(players);
+    return RandomGenerator.selectRandom(players);
   }
 
   @Override
@@ -45,13 +59,19 @@ public class Tournament {
 
     builder.append("\n\nPlayers:\n");
     // TODO 2.a Use the stream to add a listing of all players to the builder. Individual players are separated by a "\ n" character
-    builder.append(/* list of all players */"");
+    players.stream().map(Object::toString).forEach(name -> builder.append(name).append(",\n"));
+    
 
     builder.append("\n\nMatches:\n");
     // TODO 2.b Use the stream to add a listing of all entries to the builder. Individual matches are separated by a "\ n" character
-    builder.append(/* list of all matches */"");
+    builder.append(matches.stream().map(Object::toString).collect(Collectors.joining(",\n")));
 
     return builder.toString();
   }
+  
+  
+	private static Match generateRandomMatch(List<Player> players) {
+		return new Match(selectRandom(players), random.nextInt(11), selectRandom(players), random.nextInt(11));
+	}
 
 }