Skip to content

Streams Part 1 (by Narek Karapetian) #80

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
NarekDW wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Streams Part 1 (by Narek Karapetian) #80

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
8 changes: 6 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 @@ -60,7 +60,11 @@ public static Employee generateEmployee() {
}

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

return Stream.generate(Generator::generateEmployee)
.limit(length)
.collect(toList());
}
}
118 changes: 102 additions & 16 deletions src/test/java/part1/exercise/StreamsExercise1.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,20 +1,18 @@
package part1.exercise;

import data.Employee;
import data.Generator;
import data.JobHistoryEntry;
import data.Person;
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 java.util.List;

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.summarizingInt;
import static java.util.stream.Collectors.toList;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

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

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

List<Person> epamEmployees =
employees.stream()
.filter(employee ->
employee.getJobHistory()
.stream()
.anyMatch(
job -> job.getEmployer().equals("epam")
)
)
.map(Employee::getPerson)
.collect(toList());

employees.forEach(employee ->
{
epamEmployees.forEach(
person -> {
if (person.equals(employee.getPerson())) {
assertTrue(
employee.getJobHistory()
.stream()
.anyMatch(
job -> job.getEmployer().equals("epam")
)
);
}
}
);
}
);

long epamEmployeesCount =
employees.stream()
.filter(
employee -> employee.getJobHistory()
.stream()
.anyMatch(job -> job.getEmployer().equals("epam"))
)
.count();

assertEquals(epamEmployees.size(), epamEmployeesCount);
}

@Test
public void getEmployeesStartedFromEpam() {
List<Person> epamEmployees = null;// TODO all persons with first experience in epam
throw new UnsupportedOperationException();
List<Employee> employees = Generator.generateEmployeeList();
List<Person> epamEmployees =
employees.stream()
.filter(
employee -> employee.getJobHistory()
.stream()
.findFirst()
.filter(job -> job.getEmployer().equals("epam"))
.isPresent()
)
.map(Employee::getPerson)
.collect(toList());

employees.forEach(employee ->
{
epamEmployees.forEach(
person -> {
if (person.equals(employee.getPerson())) {
employee.getJobHistory()
.stream()
.findFirst()
.ifPresent(
job -> assertEquals("epam", job.getEmployer())
);
}
}
);
}
);

long epamEmployeesCount =
employees.stream()
.filter(
employee -> employee.getJobHistory()
.stream()
.findFirst()
.filter(job -> job.getEmployer().equals("epam"))
.isPresent()
)
.count();

assertEquals(epamEmployees.size(), epamEmployeesCount);

}

@Test
public void sumEpamDurations() {
final List<Employee> employees = generateEmployeeList();

int expected = 0;
long expected = 0;

for (Employee e : employees) {
for (JobHistoryEntry j : e.getJobHistory()) {
Expand All @@ -49,11 +128,18 @@ public void sumEpamDurations() {
}
}

// TODO
throw new UnsupportedOperationException();
long result =
employees.stream()
.flatMap(employee ->
employee.getJobHistory().stream()
.filter(job -> job.getEmployer().equals("epam"))
)
.collect(
summarizingInt(JobHistoryEntry::getDuration)
)
.getSum();

// int result = ???
// assertEquals(expected, result);
assertEquals(expected, result);
}

}
152 changes: 138 additions & 14 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,15 +5,11 @@
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 java.util.*;

import static data.Generator.generateEmployeeList;
import static java.util.stream.Collectors.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

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

// TODO class PersonEmployerPair


class PersonEmployerPair {
private String employer;
private Person person;

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

Person getPerson() {
return person;
}

String getEmployer() {
return employer;
}
}

class PersonEmployerDuration extends PersonEmployerPair {
private int duration;

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

int getDuration() {
return duration;
}
}

@Test
public void employersStuffLists() {
Map<String, List<Person>> employersStuffLists = null;// TODO
throw new UnsupportedOperationException();
Map<String, Set<Person>> employersStuffLists =
getEmployees().stream()
.flatMap(e ->
e.getJobHistory()
.stream()
.map(job -> new PersonEmployerPair(job.getEmployer(), e.getPerson()))
)
.collect(
groupingBy(
PersonEmployerPair::getEmployer,
mapping(
PersonEmployerPair::getPerson,
toSet()
)
)
);

getEmployees().forEach(
employee -> {
employersStuffLists.forEach(
(employer, persons) -> {
persons.forEach(p ->
{
if (employee.getPerson().equals(p)) {
assertTrue(employee.getJobHistory()
.stream()
.anyMatch(
job -> job.getEmployer().equals(employer)
)
);
}
}
);
}
);
});
}

@Test
public void indexByFirstEmployer() {
Map<String, List<Person>> employeesIndex = null;// TODO
throw new UnsupportedOperationException();
Map<String, Set<Person>> employeesIndex =
getEmployees().stream()
.map(e ->
e.getJobHistory()
.stream()
.findFirst()
.map(job -> new PersonEmployerPair(job.getEmployer(), e.getPerson()))
)
.filter(Optional::isPresent)
.map(Optional::get)
.collect(
groupingBy(
PersonEmployerPair::getEmployer,
mapping(
PersonEmployerPair::getPerson,
toSet()
)
)
);

getEmployees()
.forEach(employee ->
employeesIndex.forEach(
(employer, persons) -> {
persons.forEach(p ->
{
if (employee.getPerson().equals(p)) {
assertTrue(
employee.getJobHistory()
.get(0).getEmployer()
.equals(employer)
);
}
}
);
}
)
);
}

@Test
public void greatestExperiencePerEmployer() {
Map<String, Person> employeesIndex = null;// TODO
Map<String, Person> employeesIndex =
getEmployees().stream()
.flatMap(e ->
e.getJobHistory()
.stream()
.map(job -> new PersonEmployerDuration(
job.getEmployer(),
e.getPerson(),
job.getDuration())
)
)
.collect(
groupingBy(
PersonEmployerDuration::getEmployer,
collectingAndThen(
maxBy(Comparator.comparingInt(PersonEmployerDuration::getDuration)),
ped -> ped.get().getPerson()
)
)
);

assertEquals(new Person("John", "Doe", 30), employeesIndex.get("abc"));
assertEquals(new Person("John", "Doe", 21), employeesIndex.get("yandex"));
assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
assertEquals(new Person("John", "Galt", 20), employeesIndex.get("google"));
}


Expand All @@ -55,7 +175,7 @@ private List<Employee> getEmployees() {
new Employee(
new Person("John", "Doe", 21),
Arrays.asList(
new JobHistoryEntry(4, "BA", "yandex"),
new JobHistoryEntry(7, "BA", "yandex"),
new JobHistoryEntry(2, "QA", "epam"),
new JobHistoryEntry(2, "dev", "abc")
)),
Expand Down Expand Up @@ -117,8 +237,12 @@ private List<Employee> getEmployees() {
new Person("Bob", "White", 31),
Collections.singletonList(
new JobHistoryEntry(6, "QA", "epam")
))
);
)),
new Employee(
new Person("Empty", "JobHistory", 666),
Collections.EMPTY_LIST
));

}

}