Skip to content

part1 (Olga Li) #73

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 3 commits into
base: master
Choose a base branch
from
Open

part1 (Olga Li) #73

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
50df5f4
part1 (Olga Li)
olya-li Jul 13, 2017
d77064f
part1 - exercise 2 (Olga Li)
olyalee Jul 16, 2017
515f89e
part2 - exercise 1 - getCoolestByPostion (Olga Li)
olyalee Jul 16, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 8 additions & 2 deletions src/main/java/data/Generator.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.stream.Collectors.reducing;
import static java.util.stream.Collectors.toList;

/**
Expand Down Expand Up @@ -60,7 +61,12 @@ public static Employee generateEmployee() {
}

public static List<Employee> generateEmployeeList() {
// TODO
throw new UnsupportedOperationException();
// TODO - done
int maxLength = 10;
final int length = ThreadLocalRandom.current().nextInt(maxLength) + 1;

return Stream.generate(Generator::generateEmployee)
.limit(length)
.collect(toList());
}
}
90 changes: 77 additions & 13 deletions src/test/java/part1/exercise/StreamsExercise1.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,15 +6,11 @@
import org.junit.Test;

import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static data.Generator.generateEmployeeList;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.mapping;
import static java.util.stream.Collectors.toList;
import static org.junit.Assert.assertEquals;

public class StreamsExercise1 {
// https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1
Expand All @@ -25,14 +21,54 @@ public class StreamsExercise1 {

@Test
public void getAllEpamEmployees() {
List<Person> epamEmployees = null;// TODO all persons with experience in epam
throw new UnsupportedOperationException();
List<Employee> employees = generateEmployeeList();

List<Person> expectedEpamEmployees = new ArrayList<>();
for (Employee e : employees) {
for (JobHistoryEntry j : e.getJobHistory()) {
if (j.getEmployer().equals("epam")) {
expectedEpamEmployees.add(e.getPerson());
}
}
}

// TODO all persons with experience in epam - done
List<Person> epamEmployees = employees.stream()
.flatMap(e -> e.getJobHistory()
.stream()
.map(j -> new PersonEmployerDuration(e.getPerson(), j.getEmployer(), j.getDuration())))
.filter(p -> p.getEmployer().equals("epam"))
.map(p -> p.getPerson())
.collect(Collectors.toList());

assertEquals(expectedEpamEmployees, epamEmployees);
}

@Test
public void getEmployeesStartedFromEpam() {
List<Person> epamEmployees = null;// TODO all persons with first experience in epam
throw new UnsupportedOperationException();
List<Employee> employees = generateEmployeeList();

List<Person> expectedStartedInEpamEmployees = new ArrayList<>();
for (Employee e : employees) {
Optional<JobHistoryEntry> job = e.getJobHistory().stream().findFirst();
if (job.isPresent()) {
if (job.get().getEmployer().equals("epam")) {
expectedStartedInEpamEmployees.add(e.getPerson());
}
}
}

// TODO all persons with first experience in epam - done
List<Person> startedInEpamEmployees = employees.stream()
.flatMap(e -> e.getJobHistory()
.stream()
.limit(1)
.map(j -> new PersonEmployerDuration(e.getPerson(), j.getEmployer(), j.getDuration())))
.filter(j -> j.getEmployer().equals("epam"))
.map(p -> p.getPerson())
.collect(Collectors.toList());

assertEquals(expectedStartedInEpamEmployees, startedInEpamEmployees);
}

@Test
Expand All @@ -49,11 +85,39 @@ public void sumEpamDurations() {
}
}

// TODO
throw new UnsupportedOperationException();
// TODO - done

// int result = ???
// assertEquals(expected, result);
int result = employees.stream()
.flatMap(employee -> employee.getJobHistory().stream())
.filter(jobHistoryEntry -> jobHistoryEntry.getEmployer().equals("epam"))
.mapToInt(JobHistoryEntry::getDuration)
.sum();

assertEquals(expected, result);
}

static class PersonEmployerDuration {
private final Person person;
private final String employer;
private final int duration;

public PersonEmployerDuration(Person person, String employer, int duration) {
this.person = person;
this.employer = employer;
this.duration = duration;
}

public Person getPerson() {
return person;
}

public String getEmployer() {
return employer;
}

public int getDuration() {
return duration;
}
}

}
84 changes: 69 additions & 15 deletions src/test/java/part1/exercise/StreamsExercise2.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,14 +5,9 @@
import data.Person;
import org.junit.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;

import static data.Generator.generateEmployeeList;
import static java.util.stream.Collectors.*;
import java.util.*;
import java.util.stream.Collectors;

import static org.junit.Assert.assertEquals;

public class StreamsExercise2 {
Expand All @@ -22,28 +17,44 @@ public class StreamsExercise2 {
// https://youtu.be/O8oN4KSZEXE Сергей Куксенко — Stream API, часть 1
// https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2

// TODO class PersonEmployerPair
// TODO class PersonEmployerPair - done

@Test
public void employersStuffLists() {
Map<String, List<Person>> employersStuffLists = null;// TODO
throw new UnsupportedOperationException();
// TODO - Map<company, lists of workers) - done
Map<String, List<Person>> employersStuffLists = getEmployees().stream()
.flatMap(employee -> employee.getJobHistory().stream()
.map(jobHistoryEntry -> new PersonEmployerPair(employee.getPerson(), jobHistoryEntry.getEmployer())))
.collect(Collectors.groupingBy(PersonEmployerPair::getEmployer,
Collectors.mapping(PersonEmployerPair::getPerson, Collectors.toList())));
}

@Test
public void indexByFirstEmployer() {
Map<String, List<Person>> employeesIndex = null;// TODO
throw new UnsupportedOperationException();
// TODO - get only if first job - done
Map<String, List<Person>> employeesIndex = getEmployees().stream()
.flatMap(employee -> employee.getJobHistory().stream().limit(1)
.map(jobHistoryEntry -> new PersonEmployerPair(employee.getPerson(), jobHistoryEntry.getEmployer())))
.collect(Collectors.groupingBy(PersonEmployerPair::getEmployer,
Collectors.mapping(PersonEmployerPair::getPerson, Collectors.toList())));
}

@Test
public void greatestExperiencePerEmployer() {
Map<String, Person> employeesIndex = null;// TODO
// TODO - Map(company, person with longest duration) - done
Map<String, Person> employeesIndex = getEmployees().stream()
.flatMap(employee -> employee.getJobHistory()
.stream().map(jobHistoryEntry -> new PersonEmployerDuration(employee.getPerson(), jobHistoryEntry.getEmployer(), jobHistoryEntry.getDuration())))
.collect(Collectors.groupingBy(PersonEmployerDuration::getEmployer,
Collectors.collectingAndThen(
Collectors.maxBy(Comparator.comparingInt(PersonEmployerDuration::getDuration)), p -> p.get().getPerson())));

assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
}




private List<Employee> getEmployees() {
return Arrays.asList(
new Employee(
Expand Down Expand Up @@ -121,4 +132,47 @@ private List<Employee> getEmployees() {
);
}

}
private static class PersonEmployerPair {
private final Person person;
private final String employer;

public PersonEmployerPair(Person person, String employer) {
this.person = person;
this.employer = employer;
}

public Person getPerson() {
return person;
}

public String getEmployer() {
return employer;
}

}

private static class PersonEmployerDuration {
private final Person person;
private final String employer;
private final int duration;

public PersonEmployerDuration(Person person, String employer, int duration) {
this.person = person;
this.employer = employer;
this.duration = duration;
}

public Person getPerson() {
return person;
}

public String getEmployer() {
return employer;
}

public int getDuration() {
return duration;
}
}

}
27 changes: 15 additions & 12 deletions src/test/java/part2/exercise/CollectorsExercise1.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,20 +3,11 @@
import data.Employee;
import data.JobHistoryEntry;
import data.Person;
import org.junit.Assert;
import org.junit.Test;

import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toList;

public class CollectorsExercise1 {

Expand All @@ -25,6 +16,8 @@ public void getTheCoolestOne() {
final Map<String, Person> coolestByPosition = getCoolestByPosition(getEmployees());

coolestByPosition.forEach((position, person) -> System.out.println(position + " -> " + person));

Assert.assertEquals(new Person("John", "White", 28), coolestByPosition.get("BA"));
}

private static class PersonPositionDuration {
Expand Down Expand Up @@ -57,12 +50,16 @@ private Map<String, Person> getCoolestByPosition(List<Employee> employees) {
// Collectors.maxBy
// Collectors.collectingAndThen
// Collectors.groupingBy
return employees.stream()
.flatMap(e -> e.getJobHistory().stream()
.map(j -> new PersonPositionDuration(e.getPerson(), j.getPosition(), j.getDuration())))
.collect(Collectors.groupingBy(PersonPositionDuration::getPosition,
Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingInt(PersonPositionDuration::getDuration)), p -> p.get().getPerson())));

// Second option
// Collectors.toMap
// iterate twice: stream...collect(...).stream()...
// TODO
throw new UnsupportedOperationException();
// TODO - done
}

@Test
Expand All @@ -76,6 +73,12 @@ public void getTheCoolestOne2() {
// { John Doe, [{dev, google, 4}, {dev, epam, 4}] } предпочтительнее, чем { A B, [{dev, google, 6}, {QA, epam, 100}]}
private Map<String, Person> getCoolestByPosition2(List<Employee> employees) {
// TODO
// employees.stream()
// .flatMap(e->e.getJobHistory().stream()
// .map(j->new PersonPositionDuration(e.getPerson(), j.getPosition(), j.getDuration())))
// .collect(Collectors.groupingBy(PersonPositionDuration::getPosition,
// Collectors.collectingAndThen(Collectors.summarizingInt(PersonPositionDuration::getDuration),

throw new UnsupportedOperationException();
}

Expand Down