From 256cf7f01c4ead6ede8fce6443c387d34bcee4c9 Mon Sep 17 00:00:00 2001 From: kshokh <128833441+kshokh@users.noreply.github.com> Date: Thu, 23 Oct 2025 11:56:37 -0400 Subject: [PATCH] Lesson 11 --- .../executionHistory/executionHistory.bin | Bin 19717 -> 26206 bytes .../executionHistory/executionHistory.lock | Bin 17 -> 17 bytes .../.gradle/8.13/fileHashes/fileHashes.bin | Bin 18697 -> 20097 bytes .../.gradle/8.13/fileHashes/fileHashes.lock | Bin 17 -> 17 bytes .../buildOutputCleanup.lock | Bin 17 -> 17 bytes .../buildOutputCleanup/outputFiles.bin | Bin 18731 -> 19055 bytes lessons/.gradle/file-system.probe | Bin 8 -> 8 bytes .../java/lesson12/FunctionalInterface.java | 218 ++++++++++++++++++ .../main/java/lesson12/streamapi/Product.java | 4 + .../main/java/lesson12/streamapi/WithFor.java | 180 +++++++++++++++ .../java/lesson12/streamapi/WithStream.java | 140 +++++++++++ .../src/main/java/lessons/lesson01/Main.java | 15 -- 12 files changed, 542 insertions(+), 15 deletions(-) create mode 100644 lessons/src/main/java/lesson12/FunctionalInterface.java create mode 100644 lessons/src/main/java/lesson12/streamapi/Product.java create mode 100644 lessons/src/main/java/lesson12/streamapi/WithFor.java create mode 100644 lessons/src/main/java/lesson12/streamapi/WithStream.java delete mode 100644 lessons/src/main/java/lessons/lesson01/Main.java diff --git a/lessons/.gradle/8.13/executionHistory/executionHistory.bin b/lessons/.gradle/8.13/executionHistory/executionHistory.bin index 89c5370b7c590da65e0d84000ce8bd72fafb96c2..492a31e955b4e64619da379dfcdc20649c401cd3 100644 GIT binary patch literal 26206 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 delta 49 zcmcb2hOu=P;{*{_1|SgKX!t^WqJzX_NeO92#>u`C%8Z&Ip^XkVfx_yW9X*b)003_` B4>$k- diff --git a/lessons/.gradle/8.13/executionHistory/executionHistory.lock b/lessons/.gradle/8.13/executionHistory/executionHistory.lock index 76f66aa61155ad2a3bd909ef4bc639d07adc3d42..9ed029fc3623889864bc88174b560619b5c6064c 100644 GIT binary patch literal 17 UcmZQB{cmo3foGa70|aOT04@FltN;K2 literal 17 UcmZQB{cmo3foGa70|YPw04>%7ga7~l diff --git a/lessons/.gradle/8.13/fileHashes/fileHashes.bin b/lessons/.gradle/8.13/fileHashes/fileHashes.bin index 9f95a891008ba666abcdf7734332eab4ab7b688c..cf08a0f6f38765d684e07b292c704e4cb1058176 100644 GIT binary patch literal 20097 zcmeI4{Wnx;9Ki34W-2d7YLGHbmUBXy6s=mTH*1-hWNVN~wW}1iBikyZ6?uuQwk=EY z((4*;o1~YOB~e@9=gN3um=U802F`%Pyh-*0Vn_kpa2wr0#E=7KmjNK1)u;FfC5ke3jALR zxS@%t&U*xG4jKFsSDxhtNO1+ zJ$3EIT=J6e!&QBD$2MNtgSl9Z@RL31pIR;3zKiCs2|vY)X>P3KXk+el>n#sI*Kt!4 z-GI6CdBO`PtN%t#mUA&*vWM_e1NS550m&uwc@`0Vao}!%u6}(i<|2Q>%N;Kz%&s&~ zr_WPHc!gnyv3Pcj0p^m#w>;lgZJ~A=-9hX_c+H9XReTPIp0B8m@Y}hCsny<%q4fP^ z65hf&-5p}Ly_dcpTf*-e+uO{2g=2Ov1^QqSSQo&)^*jKmjNK1)u;FfC5ke3P1rU00p1`6o3Ly017|>C;$bZ z02F`%Pyh-*0Vn_kpa2wr0#E=7KmjNK1)u;FfC5ke3P1rU@ZlG*Lbqs!UPg-7xLNDJ zu1MqkQy%)Go?yVOWD!NNQrUccKAwk0GTI798W|TNXMNE)7{;E{R&k@@=i}JWbH+yQ zd8Q$1kZo8IR3*{3ur1JW*cC<_5^PX|Ov75_=o@RB9_X`f`QC*sQIlvR8yg>4G7V8% zqj!6j#*0mlYd2Kb*#sdY`HYd`)M#)_3edaCJZw|tmtt02+g!S8_b*;Dt@;rLRbR<8 zociySQPP}zgI>cRn{e5L5e8?>PfVjda_;@i5{}R1?+wk%*qUu44E^9NrePf<&7a=6 z^Md9xr|VQrSkJr0sPQsarr~HW<)n@+xcPMIiLCgRa#Z!5nV)U_l4*1m)h#!iaQeoB zd0xfBFg3Ia;~m3PYR)twrlgd7EZe&|4ub*P?T#e)0o@sH~-k9=1lI!UZ1v`7Ru*JM?51J9f=0_J%$8l@|5g9+4;@j z0n?!dc}tVW7-be4s0c^PNYr8M>nw$a8prXgIA!OKZb zNHV%(B-HYh*kgm=P8;P+<3(^!dhxn>L%NebaVU$~X{t051b<+I@?jd$M_3WrrDt8{ zMf0{)g?6EpK&VxMU~(}4;Dsp15v$of_>{IE&UDe)Mc;>MYdWtJh6koBbM&%j-wHBWX_nF^L WHuvXu`W3IlcNGz?6evS2h4CNcQzVN3 delta 52 zcmZpi%h)-Iaf68jBg^Eq5)zZY0&%OP#AH_~37-E@z`(#zxKZ(k_(p>j;*%XcP5=NZ CTo#f5 diff --git a/lessons/.gradle/8.13/fileHashes/fileHashes.lock b/lessons/.gradle/8.13/fileHashes/fileHashes.lock index 0ef8a01bd4be288bfdcae305b83fd5df93062bd6..1b37c972fffdbad2ad1a59664ca9bf50f882c0b0 100644 GIT binary patch literal 17 UcmZSHbmUsodQCnl1_-DI05ui_O#lD@ literal 17 UcmZSHbmUsodQCnl1_)pS05qWk*Z=?k diff --git a/lessons/.gradle/buildOutputCleanup/buildOutputCleanup.lock b/lessons/.gradle/buildOutputCleanup/buildOutputCleanup.lock index 00e9ec4ec98dc7e0ed11b35c1301569eab70d77e..9684afd612e861b60d78cf1d98f4aa096ab389df 100644 GIT binary patch literal 17 TcmZQBI2fQ2lb$5T00B_|CaeQO literal 17 TcmZQBI2fQ2lb$5T009C3CSn5k diff --git a/lessons/.gradle/buildOutputCleanup/outputFiles.bin b/lessons/.gradle/buildOutputCleanup/outputFiles.bin index a6faea7c6a1d78ece40f4ebf3fab7ad7010ea4f9..677178f9a9ea226c683c99c86f207985ebe3e006 100644 GIT binary patch delta 502 zcmZ2IiShju#tkMC_419e6Cd3YI~K(N2A-||p&>2bHy=UJiRwlMJ-g1z=SzX~ou z#kFDLvv}epzRX}>4H5SUhKaAdm&P;ooO3Hw{YselhD{gd|DQ8CSi(u;kjyh>FQZmT zh!QVLn3Aji_?J$(|MVtQtN-L)2@8$;u8((fuD){(s@NN*`2L))j_I=*)<6{(Pu>eu z{C8WM9fzU*GpOKhnBxC`E*+KmTdNBdpFa7mM1Y2BTHb@ly<$pG!TT`9j_m2V%O+Nz zfQWmkPd1fQs1FF6qUTe#{UTH_7N$5zBCl^#Oe-`PyqMwQ(K{x|{$yl=8vYR`9woR+ zdeq2Xm`Z*xG+7lnxzR7reM%lpmw0;(Z#vah5T6VuO)ia*3R8YqZP ecJz2PS<+Joh^N5;!&%*=A76$;lpz0a` delta 54 zcmaDqg>m&H#tkMCjJ%U;B_t-VmGGFXDrqpe6^NfodQ6U$l9Z KVv`*`UI73A=n~lg diff --git a/lessons/.gradle/file-system.probe b/lessons/.gradle/file-system.probe index f55ab291748e983b9c9ad0567df044c245d6f3ed..d8f6ea8ea7ea46f769999c121a86b194c5dabde1 100644 GIT binary patch literal 8 PcmZQzV4Nk`Ub_td2AKk9 literal 8 PcmZQzV4TGyE3OLw1IhsZ diff --git a/lessons/src/main/java/lesson12/FunctionalInterface.java b/lessons/src/main/java/lesson12/FunctionalInterface.java new file mode 100644 index 0000000..efc80f2 --- /dev/null +++ b/lessons/src/main/java/lesson12/FunctionalInterface.java @@ -0,0 +1,218 @@ +package lesson12; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import java.util.function.*; + +/** + * @author Shohjahon + * @version 1 + */ + +public class FunctionalInterface { + public static void main(String[] args) { + //ManualGenerate(); + //ManualForEach(); + //ManualMap(); + //ManualFilter(); + //UnaryOperator(); + //BiFunctionAndThen(); + //Predicate(); + //ConsumerAndThen(); + //FunctionCombine(); + //SumBiFunction(); + //UpperCaseConsumer(); + //UUIDSupplier(); + //StringLength(); + //StringPredicate(); + } + + private static void ManualGenerate() { + Supplier randomIntSupplier = () -> (int) (Math.random() * 100); + + List randomNumbers = generate(randomIntSupplier, 5); + + System.out.println(randomNumbers); + + Supplier uuidSupplier = () -> UUID.randomUUID().toString(); + List uuids = generate(uuidSupplier, 3); + uuids.forEach(System.out::println); + } + + public static List generate(Supplier supplier, int n) { + List result = new ArrayList<>(); + for (int i = 0; i < n; i++) { + result.add(supplier.get()); + } + return result; + } + + private static void ManualForEach() { + List words = List.of("apple", "pear", "banana", "kiwi"); + + Consumer print = System.out::println; + + forEach(words, print); + } + + public static void forEach(List list, Consumer consumer) { + for (T element : list) { + consumer.accept(element); + } + } + + private static void ManualMap() { + List words = List.of("apple", "pear", "banana", "kiwi"); + + Function stringLength = String::length; + + List lengths = map(words, stringLength); + + System.out.println(lengths); + } + + public static List map(List list, Function mapper) { + List result = new ArrayList<>(); + for (T element : list) { + result.add(mapper.apply(element)); + } + return result; + } + + private static void ManualFilter() { + List words = List.of("apple", "pear", "banana", "kiwi"); + + Predicate longerThanFour = s -> s.length() > 4; + + List filteredWords = filter(words, longerThanFour); + + System.out.println(filteredWords); + } + + public static List filter(List list, Predicate predicate) { + List result = new ArrayList<>(); + for (T element : list) { + if (predicate.test(element)) { + result.add(element); + } + } + return result; + } + + private static void UnaryOperator() { + UnaryOperator addExclamations = s -> s + "!!!"; + + String[] testStrings = {"Hello", "Java", "Shohjahon"}; + + for (String str : testStrings) { + System.out.println(addExclamations.apply(str)); + } + } + + private static void BiFunctionAndThen() { + BiFunction multiply = (a, b) -> a * b; + + Function toStr = x -> "Result: " + x; + + Function multiplyThenToStr = arr -> toStr.apply(multiply.apply(arr[0], arr[1])); + + int a = 5, b = 3; + System.out.println(multiplyThenToStr.apply(new Integer[]{a, b})); + + a = 7; + b = 4; + System.out.println(multiplyThenToStr.apply(new Integer[]{a, b})); + } + + private static void Predicate() { + Predicate isEven = n -> n % 2 == 0; + + Predicate isPositive = n -> n > 0; + + Predicate evenAndPositive = isEven.and(isPositive); + + Predicate oddOrNegative = evenAndPositive.negate(); + + int[] numbers = {-3, -2, 0, 1, 2, 3, 4}; + + for (int n : numbers) { + System.out.println(n + " -> evenAndPositive: " + evenAndPositive.test(n) + + ", oddOrNegative: " + oddOrNegative.test(n)); + } + } + + private static void ConsumerAndThen() { + Consumer printString = s -> System.out.println("String: " + s); + + Consumer printLength = s -> System.out.println("Length: " + s.length()); + + Consumer combined = printString.andThen(printLength); + + String[] testStrings = {"Hello", "Java", "Shohjahon"}; + + for (String str : testStrings) { + combined.accept(str); + } + } + + private static void FunctionCombine() { + Function trim = String::trim; + + Function toUpperCase = String::toUpperCase; + + Function trimThenUpper = trim.andThen(toUpperCase); + + String[] testStrings = {" hello ", " Java ", " Shohjahon "}; + + for (String str : testStrings) { + System.out.println("'" + trimThenUpper.apply(str) + "'"); + } + } + + private static void SumBiFunction() { + BiFunction sum = Integer::sum; + + System.out.println("5 + 3 = " + sum.apply(5, 3)); + System.out.println("10 + 20 = " + sum.apply(10, 20)); + System.out.println("-2 + 7 = " + sum.apply(-2, 7)); + } + + private static void UpperCaseConsumer() { + Consumer printUpperCase = s -> System.out.println(s.toUpperCase()); + + String[] testStrings = {"hello", "java", "shohjahon"}; + + for (String str : testStrings) { + printUpperCase.accept(str); + } + } + + private static void UUIDSupplier() { + Supplier uuidSupplier = UUID::randomUUID; + + for (int i = 0; i < 3; i++) { + System.out.println(uuidSupplier.get()); + } + } + + private static void StringLength() { + Function stringLength = String::length; + + String[] testStrings = {"Hello", "Java", "Shohjahon", ""}; + + for (String str : testStrings) { + System.out.println(str + " -> " + stringLength.apply(str)); + } + } + + private static void StringPredicate() { + Predicate isValid = s -> s.length() > 3; + + String[] testStrings = {"", "Hi", "Java", "Shohjahon"}; + + for (String str : testStrings) { + System.out.println(str + " -> " + isValid.test(str)); + } + } +} diff --git a/lessons/src/main/java/lesson12/streamapi/Product.java b/lessons/src/main/java/lesson12/streamapi/Product.java new file mode 100644 index 0000000..9b565bd --- /dev/null +++ b/lessons/src/main/java/lesson12/streamapi/Product.java @@ -0,0 +1,4 @@ +package lesson12.streamapi; + +public record Product(String name, String category, double price) { +} diff --git a/lessons/src/main/java/lesson12/streamapi/WithFor.java b/lessons/src/main/java/lesson12/streamapi/WithFor.java new file mode 100644 index 0000000..56dcf2d --- /dev/null +++ b/lessons/src/main/java/lesson12/streamapi/WithFor.java @@ -0,0 +1,180 @@ +package lesson12.streamapi; + +import java.util.*; + +/** + * @author Shohjahon + * @version 1 + */ + +public class WithFor { + public static void main(String[] args) { + //EvenSquares(); + //CountLongWords(); + //FindMinMax(); + //AverageStringLength(); + //RemoveDuplicatesAndSort(); + //ToMap(); + //GroupByFirstLetter(); + //JoinNames(); + //SplitSentences(); + //MostExpensive(); + } + + private static void MostExpensive() { + List products = List.of( + new Product("Phone", "Electronics", 1200), + new Product("TV", "Electronics", 1800), + new Product("Apple", "Fruits", 2.5), + new Product("Mango", "Fruits", 4.0) + ); + + Map mostExpensive = new HashMap<>(); + + for (Product p : products) { + if (!mostExpensive.containsKey(p.category()) || + p.price() > mostExpensive.get(p.category()).price()) { + mostExpensive.put(p.category(), p); + } + } + + for (String category : mostExpensive.keySet()) { + Product product = mostExpensive.get(category); + System.out.println(category + " -> " + product.name() + " ($" + product.price() + ")"); + } + } + + private static void SplitSentences() { + List sentences = List.of("Java is cool", "Streams are powerful"); + + List words = new ArrayList<>(); + + for (String sentence : sentences) { + String[] splitWords = sentence.split(" "); + words.addAll(Arrays.asList(splitWords)); + } + + System.out.println(words); + } + + private static void JoinNames() { + List names = List.of("Tom", "Jerry", "Spike"); + + StringBuilder result = new StringBuilder(); + for (int i = 0; i < names.size(); i++) { + result.append(names.get(i)); + if (i < names.size() - 1) { + result.append(", "); + } + } + + System.out.println(result); + } + + private static void GroupByFirstLetter() { + List names = List.of("Alice", "Andrew", "Bob", "Charlie", "Catherine"); + + Map> grouped = new HashMap<>(); + + for (String name : names) { + char firstLetter = name.charAt(0); + + if (!grouped.containsKey(firstLetter)) { + grouped.put(firstLetter, new ArrayList<>()); + } + + grouped.get(firstLetter).add(name); + } + + System.out.println(grouped); + } + + private static void ToMap() { + List fruits = List.of("apple", "banana", "kiwi"); + + Map fruitMap = new HashMap<>(); + + for (String fruit : fruits) { + fruitMap.put(fruit, fruit.length()); + } + + System.out.println(fruitMap); + } + + private static void RemoveDuplicatesAndSort() { + List input = List.of("apple", "pear", "apple", "banana", "pear"); + + Set uniqueSet = new HashSet<>(input); + + List uniqueList = new ArrayList<>(uniqueSet); + + for (int i = 0; i < uniqueList.size() - 1; i++) { + for (int j = i + 1; j < uniqueList.size(); j++) { + if (uniqueList.get(i).length() > uniqueList.get(j).length()) { + String temp = uniqueList.get(i); + uniqueList.set(i, uniqueList.get(j)); + uniqueList.set(j, temp); + } + } + } + + System.out.println("Result: " + uniqueList); + } + + private static void AverageStringLength() { + List names = List.of("Alice", "Bob", "Charlie", "David"); + + int totalLength = 0; + + for (String name : names) { + totalLength += name.length(); + } + + double average = (double) totalLength / names.size(); + + System.out.println("Average length: " + average); + } + + private static void FindMinMax() { + List nums = List.of(10, 2, 33, 4, 25); + + int max = nums.getFirst(); + int min = nums.getFirst(); + + for (int num : nums) { + if (num > max) { + max = num; + } + if (num < min) { + min = num; + } + } + + System.out.println("Maximum: " + max); + System.out.println("Minimum: " + min); + } + + private static void CountLongWords() { + List words = List.of("apple", "banana", "pear", "pineapple"); + + int count = 0; + for (String word : words) { + if (word.length() > 5) { + count++; + } + } + + System.out.printf("Number of words longer than 5 characters: %s.", count); + } + + private static void EvenSquares() { + List numbers = List.of(1, 2, 3, 4, 5, 6); + + for (int number : numbers) { + if (number % 2 == 0) { + int square = number * number; + System.out.println(square); + } + } + } +} diff --git a/lessons/src/main/java/lesson12/streamapi/WithStream.java b/lessons/src/main/java/lesson12/streamapi/WithStream.java new file mode 100644 index 0000000..8646ffb --- /dev/null +++ b/lessons/src/main/java/lesson12/streamapi/WithStream.java @@ -0,0 +1,140 @@ +package lesson12.streamapi; + +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * @author Shohjahon + * @version 1 + */ + +public class WithStream { + public static void main(String[] args) { + //MostExpensive(); + //WordsFromSentences(); + //JoinNames(); + //GroupByFirstLetter(); + //ListToMap(); + //RemoveDuplicatesAndSort(); + //AverageStringLength(); + //MinMax(); + //CountLongWords(); + //EvenSquares(); + } + + private static void MostExpensive() { + List products = List.of( + new Product("Phone", "Electronics", 1200), + new Product("TV", "Electronics", 1800), + new Product("Apple", "Fruits", 2.5), + new Product("Mango", "Fruits", 4.0) + ); + + Map> mostExpensive = products.stream() + .collect(Collectors.groupingBy( + Product::category, + Collectors.maxBy(Comparator.comparingDouble(Product::price)) + )); + + mostExpensive.forEach((category, productOpt) -> + productOpt.ifPresent(product -> + System.out.println(category + " -> " + product.name() + " ($" + product.price() + ")") + ) + ); + } + + private static void WordsFromSentences() { + List sentences = List.of("Java is cool", "Streams are powerful"); + + List words = sentences.stream() + .flatMap(sentence -> Stream.of(sentence.split(" "))) + .collect(Collectors.toList()); + + System.out.println(words); + } + + private static void JoinNames() { + List names = List.of("Tom", "Jerry", "Spike"); + + String result = names.stream() + .collect(Collectors.joining(", ")); + + System.out.println(result); + } + + private static void GroupByFirstLetter() { + List names = List.of("Alice", "Andrew", "Bob", "Charlie", "Catherine"); + + Map> grouped = names.stream() + .collect(Collectors.groupingBy(name -> name.charAt(0))); + + System.out.println(grouped); + } + + private static void ListToMap() { + List fruits = List.of("apple", "banana", "kiwi"); + + Map fruitLengthMap = fruits.stream() + .collect(Collectors.toMap( + fruit -> fruit, + String::length + )); + + System.out.println(fruitLengthMap); + } + + private static void RemoveDuplicatesAndSort() { + List input = List.of("apple", "pear", "apple", "banana", "pear"); + + List result = input.stream() + .distinct() + .sorted(Comparator.comparingInt(String::length)) + .collect(Collectors.toList()); + + System.out.println(result); + } + + private static void AverageStringLength() { + List names = List.of("Alice", "Bob", "Charlie", "David"); + + double average = names.stream() + .mapToInt(String::length) + .average() + .orElse(0); + + System.out.println("Average length: " + average); + } + + private static void MinMax() { + List nums = List.of(10, 2, 33, 4, 25); + + Optional max = nums.stream().max(Integer::compareTo); + Optional min = nums.stream().min(Integer::compareTo); + + max.ifPresent(m -> System.out.println("Maximum: " + m)); + min.ifPresent(m -> System.out.println("Minimum: " + m)); + } + + private static void CountLongWords() { + List words = List.of("apple", "banana", "pear", "pineapple"); + + long count = words.stream() + .filter(word -> word.length() > 5) + .count(); + + System.out.println("Number of words longer than 5 characters: " + count); + } + + private static void EvenSquares() { + List numbers = List.of(1, 2, 3, 4, 5, 6); + + numbers.stream() + .filter(n -> n % 2 == 0) + .map(n -> n * n) + .forEach(System.out::println); + } +} diff --git a/lessons/src/main/java/lessons/lesson01/Main.java b/lessons/src/main/java/lessons/lesson01/Main.java deleted file mode 100644 index c725125..0000000 --- a/lessons/src/main/java/lessons/lesson01/Main.java +++ /dev/null @@ -1,15 +0,0 @@ -package lessons.lesson01; - -public class Main { - - int value = 5; - String name = "Mike"; - - static final int DEFAULT_VALUE = 0; - static final String DEFAULT_NAME = "John"; -// test - public static void main(String[] args) { - System.out.println("Hello, World!"); - Math.abs(1); - } -} \ No newline at end of file