From 9f70a9995508fac6174320f4adbfc159d3551c9d Mon Sep 17 00:00:00 2001
From: Bilalov_Bulat <programming.languages.only@gmail.com>
Date: Fri, 3 Jul 2020 19:21:04 +0300
Subject: [PATCH] Update java8.md

---
 java8.md | 48 ++++++++++++++++++++++++------------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/java8.md b/java8.md
index 333323f..45baa95 100644
--- a/java8.md
+++ b/java8.md
@@ -126,7 +126,7 @@ public static void main(String[] args) {
 operation = (int x, int y) -> x + y;
 //При написании самого лямбда-выражения тип параметров разрешается не указывать:
 (x, y) -> x + y;
-//Если метод не принимает никаких параметров, то пишутся пустые скобки, например:
+//Если метод не принимает никаких параметров, то пишутся пустые скобки, например,
 () -> 30 + 20;
 //Если метод принимает только один параметр, то скобки можно опустить:
 n -> n * n;
@@ -230,7 +230,7 @@ public static void main(String[] args) {
 ## Какие виды ссылок на методы вы знаете?
 + на статический метод;
 + на метод экземпляра;
-+ на конструктор.
++ на конструкторе.
 
 [к оглавлению](#java-8)
 
@@ -259,9 +259,9 @@ Function<String, String> backToString = toInteger.andThen(String::valueOf);
 backToString.apply("123");     // "123"
 ```
 
-+ `DoubleFunction<R>` - функция получающая на вход `Double` и возвращающая на выходе экземпляр класса `R`;
-+ `IntFunction<R>` - функция получающая на вход `Integer` и возвращающая на выходе экземпляр класса `R`;
-+ `LongFunction<R>` - функция получающая на вход `Long` и возвращающая на выходе экземпляр класса `R`.
++ `DoubleFunction<R>` - функция, получающая на вход `Double` и возвращающая на выходе экземпляр класса `R`;
++ `IntFunction<R>` - функция, получающая на вход `Integer` и возвращающая на выходе экземпляр класса `R`;
++ `LongFunction<R>` - функция, получающая на вход `Long` и возвращающая на выходе экземпляр класса `R`.
 
 [к оглавлению](#java-8)
 
@@ -273,9 +273,9 @@ UnaryOperator<Integer> operator = x -> x * x;
 System.out.println(operator.apply(5)); // 25
 ```
 
-+ `DoubleUnaryOperator` - унарный оператор получающий на вход `Double`;
-+ `IntUnaryOperator` - унарный оператор получающий на вход `Integer`;
-+ `LongUnaryOperator` - унарный оператор получающий на вход `Long`.
++ `DoubleUnaryOperator` - унарный оператор, получающий на вход `Double`;
++ `IntUnaryOperator` - унарный оператор, получающий на вход `Integer`;
++ `LongUnaryOperator` - унарный оператор, получающий на вход `Long`.
 
 [к оглавлению](#java-8)
 
@@ -286,9 +286,9 @@ BinaryOperator<Integer> operator = (a, b) -> a + b;
 System.out.println(operator.apply(1, 2)); // 3
 ```
 
-+ `DoubleBinaryOperator` - бинарный оператор получающий на вход `Double`;
-+ `IntBinaryOperator` - бинарный оператор получающий на вход `Integer`;
-+ `LongBinaryOperator` - бинарный оператор получающий на вход `Long`.
++ `DoubleBinaryOperator` - бинарный оператор, получающий на вход `Double`;
++ `IntBinaryOperator` - бинарный оператор, получающий на вход `Integer`;
++ `LongBinaryOperator` - бинарный оператор, получающий на вход `Long`.
 
 [к оглавлению](#java-8)
 
@@ -303,9 +303,9 @@ predicate.test("foo"); // true
 predicate.negate().test("foo"); // false
 ```
 
-+ `DoublePredicate` - предикат получающий на вход `Double`;
-+ `IntPredicate` - предикат получающий на вход `Integer`;
-+ `LongPredicate` - предикат получающий на вход `Long`.
++ `DoublePredicate` - предикат, получающий на вход `Double`;
++ `IntPredicate` - предикат, получающий на вход `Integer`;
++ `LongPredicate` - предикат, получающий на вход `Long`.
 
 [к оглавлению](#java-8)
 
@@ -317,9 +317,9 @@ Consumer<String> hello = (name) -> System.out.println("Hello, " + name);
 hello.accept("world");
 ```
 
-+ `DoubleConsumer` - потребитель получающий на вход `Double`;
-+ `IntConsumer` - потребитель получающий на вход `Integer`;
-+ `LongConsumer` - потребитель получающий на вход `Long`.
++ `DoubleConsumer` - потребитель, получающий на вход `Double`;
++ `IntConsumer` - потребитель, получающий на вход `Integer`;
++ `LongConsumer` - потребитель, получающий на вход `Long`.
 
 [к оглавлению](#java-8)
 
@@ -331,9 +331,9 @@ Supplier<LocalDateTime> now = LocalDateTime::now;
 now.get();
 ```
 
-+ `DoubleSupplier` - поставщик возвращающий `Double`;
-+ `IntSupplier` - поставщик возвращающий `Integer`;
-+ `LongSupplier` - поставщик возвращающий `Long`.
++ `DoubleSupplier` - поставщик, возвращающий `Double`;
++ `IntSupplier` - поставщик, возвращающий `Integer`;
++ `LongSupplier` - поставщик, возвращающий `Long`.
 
 [к оглавлению](#java-8)
 
@@ -489,7 +489,7 @@ optional.orElse("ops..."); // "hello"
 
 Стримы создаются на основе источников каких-либо, например классов из `java.util.Collection`. 
 
-Ассоциативные массивы (maps), например `HashMap`, не поддерживаются.
+Ассоциативные массивы (maps), например, `HashMap`, не поддерживаются.
 
 Операции над стримами могут выполняться как последовательно, так и параллельно.
 
@@ -497,7 +497,7 @@ optional.orElse("ops..."); // "hello"
 
 Кроме универсальных объектных существуют особые виды стримов для работы с примитивными типами данных `int`, `long` и `double`: `IntStream`, `LongStream` и `DoubleStream`. Эти примитивные стримы работают так же, как и обычные объектные, но со следующими отличиями: 
 
-+ используют специализированные лямбда-выражения, например `IntFunction` или `IntPredicate` вместо `Function` и `Predicate`; 
++ используют специализированные лямбда-выражения, например, `IntFunction` или `IntPredicate` вместо `Function` и `Predicate`; 
 + поддерживают дополнительные конечные операции `sum()`, `average()`, `mapToObj()`.
 
 [к оглавлению](#java-8)
@@ -541,7 +541,7 @@ Stream<String> fromGenerate = Stream.generate(() -> "0");
 ## В чем разница между `Collection` и `Stream`?
 Коллекции позволяют работать с элементами по-отдельности, тогда как стримы так делать не позволяют, но вместо этого предоставляют возможность выполнять функции над данными как над одним целым.
 
-Также стоит отметить важность самой концепции сущностей: `Collection` - это прежде всего воплощение _Структуры Данных_. Например `Set` не просто хранит в себе элементы, он реализует идею множества с уникальными элементами,
+Также стоит отметить важность самой концепции сущностей: `Collection` - это прежде всего воплощение _Структуры Данных_. Например, `Set` не просто хранит в себе элементы, он реализует идею множества с уникальными элементами,
 тогда как `Stream`, это прежде всего абстракция необходимая для реализации _конвеера вычислений_, собственно поэтому, результатом работы конвеера являются те или иные _Структуры Данных_ или же результаты проверок/поиска и т.п. 
 
 [к оглавлению](#java-8)
@@ -649,7 +649,7 @@ collection
 + Количество ядер процессора. Теоретически, чем больше ядер в компьютере, тем быстрее программа будет работать. Если на машине одно ядро, нет смысла применять параллельные потоки.
 + Чем проще структура данных, с которой работает поток, тем быстрее будут происходить операции. Например, данные из `ArrayList` легко использовать, так как структура данной коллекции предполагает последовательность несвязанных данных. А вот коллекция типа `LinkedList` - не лучший вариант, так как в последовательном списке все элементы связаны с предыдущими/последующими. И такие данные трудно распараллелить.
 + Над данными примитивных типов операции будут производиться быстрее, чем над объектами классов.
-+ Крайне не рекомендуется использовать параллельные стримы для сколько-нибудь долгих операций (например сетевых соединений), так как все параллельные стримы работают c одним `ForkJoinPool`, то такие долгие операции могут остановить работу всех параллельных стримов в JVM из-за отсутствия доступных потоков в пуле, т.е. параллельные стримы стоит использовать лишь для коротких операций, где счет идет на миллисекунды, но не для тех где счет может идти на секунды и минуты;
++ Крайне не рекомендуется использовать параллельные стримы для скольких-нибудь долгих операций (например, сетевых соединений), так как все параллельные стримы работают c одним ForkJoinPool, то такие долгие операции могут остановить работу всех параллельных стримов в JVM из-за отсутствия доступных потоков в пуле, т.е. параллельные стримы стоит использовать лишь для коротких операций, где счет идет на миллисекунды, но не для тех где счет может идти на секунды и минуты;
 + Сохранение порядка в параллельных стримах увеличивает издержки при выполнении и если порядок не важен, то имеется возможность отключить его сохранение и тем самым увеличить производительность, использовав промежуточную операцию `unordered()`:
 
 ```java