- Today, we go beyond what Codecheck can do. Fire up your favorite Java IDE and make a project Unit5.
- At http://horstmann.com/heig-vd/spring2015/poo/unit5/movies.txt , there is a database of movie facts. Each movie has five lines that look like this:
Name: Five Easy Pieces
Year: 1970
Directed by: Bob Rafelson
Produced by: Bob Rafelson, Richard Wechsler, Harold Schneider
Actors: Jack Nicholson, Karen Black, Billy Green Bush, more...
- First, let’s come up with a class that describes a movie. Add it to the project.
- Next, we need to read in the movies. Because we need to consume five input lines per movie,
there is nothing to be gained by reading the input as a stream of lines. Instead, we just put the
movies into an ArrayList:
public static List<Movie> readMovies(String url) throws IOException
{
List<Movie> movies = new ArrayList<>();
try (Scanner in = new Scanner(new URL(url).openStream()))
{
while (in.hasNextLine())
{
String nameLine = in.nextLine();
String yearLine = in.nextLine();
String directorsLine = in.nextLine();
String producersLine = in.nextLine();
String actorsLine = in.nextLine();
movies.add(new Movie(getString(nameLine),
Integer.parseInt(getString(yearLine)),
getList(directorsLine),
getList(producersLine),
getList(actorsLine)));
}
}
return movies;
}
Here, getString is a helper method that strips off the field header, and getList is a helper that
breaks up a comma-separated list:
private static String getString(String line)
{
int colon = line.indexOf(":");
return line.substring(colon + 1).trim();
}
private static List<String> getList(String line)
{
return Stream.of(getString(line).split(", "))
.collect(Collectors.toList());
}
- Now we can make a stream:
List<Movie> movieList = readMovies("http://horstmann.com/heig-vd/spring2015/poo/unit5/movies.txt");
Stream<Movie> movies = movieList.stream();
- Let's do something interesting with the data. Are there any movie titles that start with X?
List<String> result1 = movieList.stream()
.map(m -> m.getTitle())
.filter(t -> t.startsWith("X"))
.collect(Collectors.toList());
- Let's find out how many movies start with a given letter.
This is a typical use of
groupingBy with a secondary collector:
Map<String, Long> firstLetters = movieList.stream()
.collect(Collectors.groupingBy(
m -> m.getTitle().substring(0, 1),
Collectors.counting()));
How many movies start with the letter T?
- There is a simple reason for that. What do you get from
movieList.stream()
.filter(m -> m.getTitle().startsWith("The "))
.count();
- What other letters are common starting letters of movies? Why do you think that is?
- Who is the most prolific director? This is not so easy to answer because a movie can have
more than one director. Fortunately, this only happens with about five percent of movies, so
let’s just pick the first one. There are, however, a number of movies with no directors in the
data set. We filter those out first. Then we can group by the first director:
Map<String, List<Movie>> moviesByDirector = movieList.stream()
.filter(m -> m.getDirectors().size() > 0)
.collect(Collectors.groupingBy(
m -> m.getDirectors().get(0)));
This map associates all directors with a list of the movies that they directed. Unfortunately,
that’s a large map. How many entries does it have?
- Let's find the map entry with the longest list. There is no need to use streams.
String mostProlificDirector = Collections.max(
moviesByDirector.entrySet(),
Comparator.comparing(e -> e.getValue().size())).getKey();
Who is this director? Never heard of him? Google his name!
- Which movies? To extract the titles, it is easy to use map with a stream:
List<String> titles = moviesByDirector.get(mostProlificDirector)
.stream()
.map(m -> m.getTitle())
.collect(Collectors.toList());
Which of these would you like to see first?
