diff --git a/pom.xml b/pom.xml index 10e5035e..02b3cc9f 100644 --- a/pom.xml +++ b/pom.xml @@ -7,60 +7,74 @@ manning lambdasinaction 1.0 - + - UTF-8 + UTF-8 - - - org.openjdk.jmh - jmh-core - 1.17.4 - - - org.openjdk.jmh - jmh-generator-annprocess - 1.17.4 - - - junit - junit - 4.11 - - + + + org.openjdk.jmh + jmh-core + 1.17.4 + + + org.openjdk.jmh + jmh-generator-annprocess + 1.17.4 + + + junit + junit + 4.11 + + + + org.apache.commons + commons-lang3 + 3.4 + + + + org.apache.commons + commons-collections4 + 4.1 + + + - - - - org.apache.maven.plugins - maven-compiler-plugin - 3.1 - - 1.9 - 1.9 - - - - org.apache.maven.plugins - maven-shade-plugin - - - package - - shade - - - benchmarks - - - org.openjdk.jmh.Main - - - - - - - - + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.1 + + 1.8 + 1.8 + + + + org.apache.maven.plugins + maven-shade-plugin + + + package + + shade + + + benchmarks + + + org.openjdk.jmh.Main + + + + + + + + \ No newline at end of file diff --git a/src/main/java/lambdasinaction/chap10/Demo103.java b/src/main/java/lambdasinaction/chap10/Demo103.java new file mode 100644 index 00000000..bae13b66 --- /dev/null +++ b/src/main/java/lambdasinaction/chap10/Demo103.java @@ -0,0 +1,23 @@ +package lambdasinaction.chap10; + +import java.util.Optional; +import java.util.function.Consumer; + +/** + * @author vector + * @date: 2018/10/10 0010 11:29 + */ +public class Demo103 { + public static void main(String[] args) { + Person person = new Person(); + Optional car = person.getCar(); + System.out.println(car.orElse(new Car())); + car.ifPresent(System.out::println); + ; + + +// Optional optCar2 = Optional.of(car) + + + } +} diff --git a/src/main/java/lambdasinaction/chap10/Demo104.java b/src/main/java/lambdasinaction/chap10/Demo104.java new file mode 100644 index 00000000..93fb3c8c --- /dev/null +++ b/src/main/java/lambdasinaction/chap10/Demo104.java @@ -0,0 +1,36 @@ +package lambdasinaction.chap10; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * @author vector + * @date: 2018/10/10 0010 14:00 + */ +public class Demo104 { + public static void main(String[] args) { + Map map = new HashMap<>(); + + map.put("a", "sadfas"); + map.put("b", "sadfas1"); + map.put("c", "sadfas2"); + map.put("d", "sadfas3"); + + String e = map.get("e"); + System.out.println(e); + + Optional e1 = Optional.ofNullable(map.get("e")); + String s = Optional.ofNullable(map.get("e")).orElse("unknown key"); + System.out.println(s); + + } + + public static Optional stringToInt(String s) { + try { + return Optional.of(Integer.parseInt(s)); + } catch (NumberFormatException e) { + return Optional.empty(); + } + } +} diff --git a/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java b/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java index d2940969..23fc2250 100644 --- a/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java +++ b/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java @@ -12,11 +12,12 @@ public static void main(String... args) { System.out.println(max(empty(), of(5))); Optional opt1 = of(5); - Optional opt2 = opt1.or(() -> of(4)); - System.out.println( - of(5).or(() -> of(4)) - ); +// Optional opt2 = opt1.or(() -> of(4)); +// +// System.out.println( +// of(5).or(() -> of(4)) +// ); } public static final Optional max(Optional i, Optional j) { diff --git a/src/main/java/lambdasinaction/chap10/OptionalMain.java b/src/main/java/lambdasinaction/chap10/OptionalMain.java index dcd97792..0a4a1cbd 100644 --- a/src/main/java/lambdasinaction/chap10/OptionalMain.java +++ b/src/main/java/lambdasinaction/chap10/OptionalMain.java @@ -1,24 +1,62 @@ package lambdasinaction.chap10; import java.util.*; - -import static java.util.stream.Collectors.toSet; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; public class OptionalMain { - public String getCarInsuranceName(Optional person) { - return person.flatMap(Person::getCar) - .flatMap(Car::getInsurance) - .map(Insurance::getName) - .orElse("Unknown"); + + // public Set getCarInsuranceNames(List persons) { +// return persons.stream() +// .map(Person::getCar) +// .map(optCar -> optCar.flatMap(Car::getInsurance)) +// .map(optInsurance -> optInsurance.map(Insurance::getName)) +// .flatMap(Optional::stream) +// .collect(toSet()); +// } + public static void main(String[] args) { + Stream stream = Stream.of("lamurudu", "Okanbi", "Oduduwa"); + Optional f = stream.filter(name -> name.startsWith("L")).findFirst(); + String lambda = f.orElse("Lambda"); + // String lambda = f.orElseGet(() -> "Lambda"); + f.ifPresent(s -> { + s = s.toUpperCase(); + System.out.println(s); + }); + System.out.println(lambda); + + + Optional.ofNullable("Jackson").filter(s -> s.equals("Jackson")).ifPresent(s -> System.out.println(s + "~~~")); + + Stream.of("lamurudu", "Okanbi", "Oduduwa").filter(s -> s.contains("c")).findFirst().ifPresent(s -> System.out.println(123)); + + Set words = new HashSet<>(Arrays.asList("this", "is", "a", "stream", "of", "strings")); + Optional firstString = words.stream() + .findFirst(); + System.out.println(firstString); + + List equal = IntStream.range(0, 100) + .mapToObj(i -> new String("test")) // don't do this in normal code + .collect(Collectors.toList()); + Map map = IntStream.range(0, equal.size()) + .collect(IdentityHashMap::new, (m, i) -> m.put(equal.get(i), i), Map::putAll); + + equal.parallelStream().distinct().map(map::get) + .findFirst().ifPresent(System.out::println); + + + Predicate startsWithJ = (n) -> n.startsWith("J"); + Predicate fourLetterLong = (n) -> n.length() == 4; + Predicate containsBig = (n) -> n.contains("A"); + Stream.of("lamurudu", "Jack", "Oduduwa", "Jbulsu Abas") + .filter(startsWithJ.and(fourLetterLong.or(containsBig))) + .forEach((n) -> System.out.print("nName, which starts with 'J' and four letter long is : " + n)); } - public Set getCarInsuranceNames(List persons) { - return persons.stream() - .map(Person::getCar) - .map(optCar -> optCar.flatMap(Car::getInsurance)) - .map(optInsurance -> optInsurance.map(Insurance::getName)) - .flatMap(Optional::stream) - .collect(toSet()); + public String getCarInsuranceName(Optional person) { + return person.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName).orElse("Unknown"); } } diff --git a/src/main/java/lambdasinaction/chap11/BestPriceFinder.java b/src/main/java/lambdasinaction/chap11/BestPriceFinder.java index 51412e93..b8713d01 100644 --- a/src/main/java/lambdasinaction/chap11/BestPriceFinder.java +++ b/src/main/java/lambdasinaction/chap11/BestPriceFinder.java @@ -1,5 +1,7 @@ package lambdasinaction.chap11; +import com.sun.xml.internal.ws.util.CompletedFuture; + import java.util.Arrays; import java.util.List; import java.util.concurrent.CompletableFuture; @@ -27,6 +29,12 @@ public Thread newThread(Runnable r) { }); public List findPricesSequential(String product) { +// shops.stream().map(shop -> shop.getPrice(product)) +// .map(Quote::parse) +// .map(Discount::applyDiscount) +// .collect(Collectors.toList()); + + return shops.stream() .map(shop -> shop.getPrice(product)) .map(Quote::parse) @@ -42,10 +50,14 @@ public List findPricesParallel(String product) { .collect(Collectors.toList()); } - public List findPricesFuture(String product) { + /** + * 两个延时任务A,B，B的参数是A的结果，简单的说A与B有依赖的关系 + * @param product + * @return + */ + public List findPricesFuture(String product) { List> priceFutures = findPricesStream(product) - .collect(Collectors.>toList()); - + .collect(Collectors.toList()); return priceFutures.stream() .map(CompletableFuture::join) .collect(Collectors.toList()); @@ -67,4 +79,15 @@ public void printPricesStream(String product) { System.out.println("All shops have now responded in " + ((System.nanoTime() - start) / 1_000_000) + " msecs"); } + public void fun1143(String product) { + List> priceFutures = shops.stream() + .map(shop -> CompletableFuture.supplyAsync(() -> shop.getPrice(product), executor)) + .map(future -> future.thenApply(Quote::parse)).map(future -> future.thenCompose( + quote -> CompletableFuture.supplyAsync(() -> Discount.applyDiscount(quote), executor))) + .collect(Collectors.toList()); + priceFutures.stream().map(CompletableFuture::join).collect(Collectors.toList()); + + + } + } diff --git a/src/main/java/lambdasinaction/chap11/BestPriceFinderMain.java b/src/main/java/lambdasinaction/chap11/BestPriceFinderMain.java index 43ec8fba..2b3da052 100644 --- a/src/main/java/lambdasinaction/chap11/BestPriceFinderMain.java +++ b/src/main/java/lambdasinaction/chap11/BestPriceFinderMain.java @@ -8,7 +8,7 @@ public class BestPriceFinderMain { private static BestPriceFinder bestPriceFinder = new BestPriceFinder(); public static void main(String[] args) { - execute("sequential", () -> bestPriceFinder.findPricesSequential("myPhone27S")); +// execute("sequential", () -> bestPriceFinder.findPricesSequential("myPhone27S")); execute("parallel", () -> bestPriceFinder.findPricesParallel("myPhone27S")); execute("composed CompletableFuture", () -> bestPriceFinder.findPricesFuture("myPhone27S")); bestPriceFinder.printPricesStream("myPhone27S"); diff --git a/src/main/java/lambdasinaction/chap11/Discount.java b/src/main/java/lambdasinaction/chap11/Discount.java index 5624abd1..f01966ec 100644 --- a/src/main/java/lambdasinaction/chap11/Discount.java +++ b/src/main/java/lambdasinaction/chap11/Discount.java @@ -22,4 +22,9 @@ private static double apply(double price, Code code) { delay(); return format(price * (100 - code.percentage) / 100); } + + + public static void main(String[] args) { + + } } diff --git a/src/main/java/lambdasinaction/chap11/Quote.java b/src/main/java/lambdasinaction/chap11/Quote.java index 72dd81bf..0e7b9f7e 100644 --- a/src/main/java/lambdasinaction/chap11/Quote.java +++ b/src/main/java/lambdasinaction/chap11/Quote.java @@ -2,33 +2,34 @@ public class Quote { - private final String shopName; - private final double price; - private final Discount.Code discountCode; + private final String shopName; + private final double price; + private final Discount.Code discountCode; - public Quote(String shopName, double price, Discount.Code discountCode) { - this.shopName = shopName; - this.price = price; - this.discountCode = discountCode; - } + public Quote(String shopName, double price, Discount.Code discountCode) { + this.shopName = shopName; + this.price = price; + this.discountCode = discountCode; + } - public static Quote parse(String s) { - String[] split = s.split(":"); - String shopName = split[0]; - double price = Double.parseDouble(split[1]); - Discount.Code discountCode = Discount.Code.valueOf(split[2]); - return new Quote(shopName, price, discountCode); - } + public static Quote parse(String s) { + System.out.println("parse " + s); + String[] split = s.split(":"); + String shopName = split[0]; + double price = Double.parseDouble(split[1]); + Discount.Code discountCode = Discount.Code.valueOf(split[2]); + return new Quote(shopName, price, discountCode); + } - public String getShopName() { - return shopName; - } + public String getShopName() { + return shopName; + } - public double getPrice() { - return price; - } + public double getPrice() { + return price; + } - public Discount.Code getDiscountCode() { - return discountCode; - } + public Discount.Code getDiscountCode() { + return discountCode; + } } diff --git a/src/main/java/lambdasinaction/chap11/standard/Resume.java b/src/main/java/lambdasinaction/chap11/standard/Resume.java new file mode 100644 index 00000000..306a6630 --- /dev/null +++ b/src/main/java/lambdasinaction/chap11/standard/Resume.java @@ -0,0 +1,87 @@ +package lambdasinaction.chap11.standard; + +public class Resume { + + private StandardService standardService = new StandardService(); + + private String company; + + private String school; + + private String skill; + + private String title; + + public Resume(String company, String school, String skill, String title) { + this.company = company; + this.school = school; + this.skill = skill; + this.title = title; + } + + public Resume() { + + } + + public String getCompany() { + return company; + } + + public void setCompany(String company) { + this.company = company; + } + + public String getSchool() { + return school; + } + + public void setSchool(String school) { + this.school = school; + } + + public String getSkill() { + return skill; + } + + public void setSkill(String skill) { + this.skill = skill; + } + + public String getTitle() { + return title; + } + + public void setTitle(String title) { + this.title = title; + } + + public Resume stadardCompany() { + this.company = standardService.stadardCompany(this.company); + return this; + } + + public Resume standardSchool() { + this.school = standardService.standardSchool(this.school); + return this; + } + + public Resume standardSkill() { + this.skill = standardService.standardSkill(this.skill); + return this; + } + + public Resume standardTitle() { + this.title = standardService.standardTitle(this.title); + return this; + } + + @Override + public String toString() { + return "Resume{" + + "company='" + company + '\'' + + ", school='" + school + '\'' + + ", skill='" + skill + '\'' + + ", title='" + title + '\'' + + '}'; + } +} diff --git a/src/main/java/lambdasinaction/chap11/standard/StandardService.java b/src/main/java/lambdasinaction/chap11/standard/StandardService.java new file mode 100644 index 00000000..84835757 --- /dev/null +++ b/src/main/java/lambdasinaction/chap11/standard/StandardService.java @@ -0,0 +1,119 @@ +package lambdasinaction.chap11.standard; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import java.util.concurrent.*; +import java.util.function.Supplier; +import java.util.stream.Collectors; + +public class StandardService { + + private final Executor executor = Executors.newFixedThreadPool(5, new ThreadFactory() { + @Override + public Thread newThread(Runnable r) { + Thread t = new Thread(r); + t.setDaemon(true); + return t; + } + }); + + public String stadardCompany(String company) { + delay(100); + return "standard " + company; + } + + public String standardSchool(String schoole) { + delay(50); + return "standard " + schoole; + } + + public String standardSkill(String skill) { + delay(200); + return "standard " + skill; + } + + public String standardTitle(String title) { + delay(1000); + return "standard " + title; + } + + private void delay(int target) { + int delayMils = new Random().nextInt(target); + try { + Thread.sleep(delayMils); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + public String buildTag(String com, String school, String skill, String title) { + return com + school + skill + title + "tag"; + } + + public List oldFun(List resumes) { + List result = new ArrayList<>(); + for (Resume resume : resumes) { + String company = this.stadardCompany(resume.getCompany()); + String school= this.standardSchool(resume.getSchool()); + String skill = this.standardSkill(resume.getSkill()); + String title = this.standardTitle(resume.getTitle()); + result.add(new Resume(company, school, skill, title)); + } + System.out.println(result); + return result; + } + +// public List futureFun(List resumes) { +// List +// } + + public List newFun(List resumes) { + List> completableFutures = resumes.stream() + .map(resume -> CompletableFuture.supplyAsync(resume::stadardCompany, executor)) + .map(task -> task + .thenCompose(resume -> CompletableFuture.supplyAsync(resume::standardSchool, executor))) + .map(task -> task + .thenCompose(resume -> CompletableFuture.supplyAsync(resume::standardSkill, executor))) + .map(task -> task + .thenCompose(resume -> CompletableFuture.supplyAsync(resume::standardTitle, executor))) + .collect(Collectors.toList()); + + List collect = completableFutures.stream().map(CompletableFuture::join).collect(Collectors.toList()); + System.out.println(collect); + return collect; + } + + public static void execute(String msg, Supplier> supplier) { + long s = System.nanoTime(); + supplier.get(); + long e = System.nanoTime(); + System.out.println(msg + " done in " + (e - s) / 1_000_000 + " mesc"); + } + + public static void main(String[] args) { + List resumes = new ArrayList(){{ + add(new Resume("A1", "B1", "C1", "D1")); + add(new Resume("A2", "B2", "C2", "D2")); + add(new Resume("A3", "B3", "C3", "D3")); + add(new Resume("A4", "B4", "C4", "D4")); + add(new Resume("A5", "B5", "C5", "D5")); + add(new Resume("A6", "B6", "C6", "D6")); + add(new Resume("A7", "B7", "C7", "D7")); + add(new Resume("A8", "B8", "C8", "D8")); + add(new Resume("A9", "B9", "C9", "D9")); + add(new Resume("A0", "B0", "C0", "D0")); + }}; + + List resumes2 = new ArrayList<>(); + + for (int i = 0; i < 1000; i++) { + resumes2.add(new Resume("A"+i, "B0", "C0", "D0")); + } + + StandardService standardService = new StandardService(); +// execute("oldFun",()->standardService.oldFun(resumes) ); + execute("newFun",()->standardService.newFun(resumes) ); + } + +} diff --git a/src/main/java/lambdasinaction/chap11/v1/BestPriceFinderMain.java b/src/main/java/lambdasinaction/chap11/v1/BestPriceFinderMain.java index 5a74161a..fc32664b 100644 --- a/src/main/java/lambdasinaction/chap11/v1/BestPriceFinderMain.java +++ b/src/main/java/lambdasinaction/chap11/v1/BestPriceFinderMain.java @@ -8,12 +8,12 @@ public class BestPriceFinderMain { private static BestPriceFinder bestPriceFinder = new BestPriceFinder(); public static void main(String[] args) { - execute("sequential", () -> bestPriceFinder.findPricesSequential("myPhone27S")); - execute("parallel", () -> bestPriceFinder.findPricesParallel("myPhone27S")); +// execute("sequential", () -> bestPriceFinder.findPricesSequential("myPhone27S")); +// execute("parallel", () -> bestPriceFinder.findPricesParallel("myPhone27S")); execute("composed CompletableFuture", () -> bestPriceFinder.findPricesFuture("myPhone27S")); - execute("combined USD CompletableFuture", () -> bestPriceFinder.findPricesInUSD("myPhone27S")); - execute("combined USD CompletableFuture v2", () -> bestPriceFinder.findPricesInUSD2("myPhone27S")); - execute("combined USD CompletableFuture v3", () -> bestPriceFinder.findPricesInUSD3("myPhone27S")); +// execute("combined USD CompletableFuture", () -> bestPriceFinder.findPricesInUSD("myPhone27S")); +// execute("combined USD CompletableFuture v2", () -> bestPriceFinder.findPricesInUSD2("myPhone27S")); +// execute("combined USD CompletableFuture v3", () -> bestPriceFinder.findPricesInUSD3("myPhone27S")); } private static void execute(String msg, Supplier> s) { diff --git a/src/main/java/lambdasinaction/chap11/v1/Shop.java b/src/main/java/lambdasinaction/chap11/v1/Shop.java index cd3da975..e54fb064 100644 --- a/src/main/java/lambdasinaction/chap11/v1/Shop.java +++ b/src/main/java/lambdasinaction/chap11/v1/Shop.java @@ -38,4 +38,11 @@ public String getName() { return name; } + + public static void main(String[] args) { +// System.out.println(new Shop("yonwang").getPrice("apple")); + System.out.println(new Shop("yongwang").getPriceAsync("origin")); + + } + } diff --git a/src/main/java/lambdasinaction/chap12/DateTimeExamples.java b/src/main/java/lambdasinaction/chap12/DateTimeExamples.java index 46895cc5..41193a55 100644 --- a/src/main/java/lambdasinaction/chap12/DateTimeExamples.java +++ b/src/main/java/lambdasinaction/chap12/DateTimeExamples.java @@ -5,13 +5,9 @@ import java.text.DateFormat; import java.text.SimpleDateFormat; -import java.time.DayOfWeek; -import java.time.Duration; -import java.time.Instant; -import java.time.LocalDate; -import java.time.LocalDateTime; -import java.time.LocalTime; -import java.time.Month; +import java.time.*; +import java.time.chrono.ChronoLocalDate; +import java.time.chrono.Chronology; import java.time.chrono.JapaneseDate; import java.time.format.DateTimeFormatter; import java.time.format.DateTimeFormatterBuilder; @@ -22,6 +18,7 @@ import java.util.Calendar; import java.util.Date; import java.util.Locale; +import java.util.TimeZone; public class DateTimeExamples { @@ -32,10 +29,14 @@ protected DateFormat initialValue() { }; public static void main(String[] args) { - useOldDate(); - useLocalDate(); - useTemporalAdjuster(); - useDateFormatter(); +// useOldDate(); +// useLocalDate(); +// useTemporalAdjuster(); +// useDateFormatter(); + + +// fun121(); + fun1222(); } private static void useOldDate() { @@ -154,4 +155,57 @@ private static void useDateFormatter() { System.out.println(date.format(complexFormatter)); } + private static void fun1211() { + LocalDate localDate = LocalDate.of(2014, 10, 15); + } + + private static void fun121() { + LocalDate date = LocalDate.of(2014, 3, 18); + date = date.with(ChronoField.MONTH_OF_YEAR, 9); + date = date.plusYears(2).minusDays(10); + date.withYear(2011); + System.out.println(date); + } + + private static void fun122() { + LocalDate date = LocalDate.of(2018, 10, 16); + date.with(temporal -> { + DayOfWeek dow = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK)); + int dayToAdd = 1; + if (dow == DayOfWeek.FRIDAY) { + dayToAdd = 3; + } else if (dow == DayOfWeek.SATURDAY) { + dayToAdd = 2; + } + return temporal.plus(dayToAdd, ChronoUnit.DAYS); + }); + } + + private static void fun1222() { + LocalDate date = LocalDate.of(2014, 10, 16); + String format = date.format(DateTimeFormatter.BASIC_ISO_DATE); + String format1 = date.format(DateTimeFormatter.ISO_LOCAL_DATE); + System.out.println(format+"|"+format1); + + LocalDate date1 = LocalDate.parse("20141016", DateTimeFormatter.BASIC_ISO_DATE); + LocalDate date2 = LocalDate.parse("2014-10-16", DateTimeFormatter.ISO_LOCAL_DATE); + + } + + private static void fun123() { + ZoneId romeZone = ZoneId.of("Europe/Rome"); + ZoneId zoneId = TimeZone.getDefault().toZoneId(); + + LocalDate date = LocalDate.of(2014, Month.MARCH, 18); + ZonedDateTime zonedDateTime = date.atStartOfDay(zoneId); + } + + private static void fun1231() { + ZoneOffset newYrokOffset = ZoneOffset.of("-05:00"); + Chronology japaneseChronology = Chronology.ofLocale(Locale.JAPAN); + ChronoLocalDate now = japaneseChronology.dateNow(); + + } + + } diff --git a/src/main/java/lambdasinaction/chap14/Currying.java b/src/main/java/lambdasinaction/chap14/Currying.java index f17ac928..877f3373 100644 --- a/src/main/java/lambdasinaction/chap14/Currying.java +++ b/src/main/java/lambdasinaction/chap14/Currying.java @@ -22,6 +22,11 @@ static double converter(double x, double y, double z) { return x * y + z; } + + static DoubleUnaryOperator curriedConverter2(double f, double b) { + return operand -> operand * f + b; + } + static DoubleUnaryOperator curriedConverter(double y, double z) { return (double x) -> x * y + z; } diff --git a/src/main/java/lambdasinaction/chap2/FilteringApples.java b/src/main/java/lambdasinaction/chap2/FilteringApples.java index 0f61fd08..7bd8288f 100644 --- a/src/main/java/lambdasinaction/chap2/FilteringApples.java +++ b/src/main/java/lambdasinaction/chap2/FilteringApples.java @@ -31,11 +31,24 @@ public static void main(String ... args){ // [Apple{color='red', weight=120}] List redApples2 = filter(inventory, new ApplePredicate() { public boolean test(Apple a){ - return a.getColor().equals("red"); + return a.getColor().equals("red"); } }); System.out.println(redApples2); + + List red = filter(inventory, (Apple a) -> a.getColor().equals("red")); + + inventory.sort(new Comparator() { + @Override + public int compare(Apple o1, Apple o2) { + return o1.getWeight().compareTo(o2.getWeight()); + } + }); + + inventory.sort(Comparator.comparing(Apple::getWeight)); + + } public static List filterGreenApples(List inventory){ diff --git a/src/main/java/lambdasinaction/chap3/Demo342.java b/src/main/java/lambdasinaction/chap3/Demo342.java new file mode 100644 index 00000000..a17c6e85 --- /dev/null +++ b/src/main/java/lambdasinaction/chap3/Demo342.java @@ -0,0 +1,22 @@ +package lambdasinaction.chap3; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; + +/** + * @author vector + * @date: 2018/9/28 0028 14:00 + */ +public class Demo342 { + public static void forEach(List list, Consumer consumer) { + for (T t : list) { + consumer.accept(t); + } + } + + public static void main(String[] args) { + + forEach(Arrays.asList(1,2,3,4,5,6),(Integer i)-> System.out.println(i)); + } +} diff --git a/src/main/java/lambdasinaction/chap3/Demo343.java b/src/main/java/lambdasinaction/chap3/Demo343.java new file mode 100644 index 00000000..3fd27779 --- /dev/null +++ b/src/main/java/lambdasinaction/chap3/Demo343.java @@ -0,0 +1,25 @@ +package lambdasinaction.chap3; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +/** + * @author vector + * @date: 2018/9/28 0028 14:21 + */ +public class Demo343 { + public static List map(List list, Function function) { + List result = new ArrayList<>(); + for (T t : list) { + result.add(function.apply(t)); + } + return result; + } + + public static void main(String[] args) { + List map = map(Arrays.asList("ladf", "in", "action"), (String s) -> s.length()); + System.out.println(map); + } +} diff --git a/src/main/java/lambdasinaction/chap3/Sorting.java b/src/main/java/lambdasinaction/chap3/Sorting.java index 41acbe25..4b1d4453 100644 --- a/src/main/java/lambdasinaction/chap3/Sorting.java +++ b/src/main/java/lambdasinaction/chap3/Sorting.java @@ -1,6 +1,8 @@ package lambdasinaction.chap3; import java.util.*; +import java.util.function.Consumer; + import static java.util.Comparator.comparing; public class Sorting { @@ -28,7 +30,9 @@ public int compare(Apple a1, Apple a2){ // reshuffling things a little inventory.set(1, new Apple(20, "red")); - + + inventory.sort((Apple o1, Apple o2)->o1.getWeight().compareTo(o2.getWeight())); + // 3 // [Apple{color='red', weight=20}, Apple{color='green', weight=30}, Apple{color='green', weight=155}] inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight())); @@ -40,8 +44,12 @@ public int compare(Apple a1, Apple a2){ // 4 // [Apple{color='red', weight=10}, Apple{color='red', weight=20}, Apple{color='green', weight=155}] inventory.sort(comparing(Apple::getWeight)); - System.out.println(inventory); - } + System.out.println(inventory); + + String si = "123"; + int i = Integer.parseInt(si); + + } public static class Apple { private Integer weight = 0; diff --git a/src/main/java/lambdasinaction/chap3/demo341.java b/src/main/java/lambdasinaction/chap3/demo341.java new file mode 100644 index 00000000..ea2c86ed --- /dev/null +++ b/src/main/java/lambdasinaction/chap3/demo341.java @@ -0,0 +1,30 @@ +package lambdasinaction.chap3; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Predicate; + +/** + * @author vector + * @date: 2018/9/28 0028 13:51 + */ +public class demo341 { + public static List filter(List list, Predicate p) { + List result = new ArrayList<>(); + for (T t : list) { + if (p.test(t)) { + result.add(t); + } + } + return result; + } + + public static void main(String[] args) { + Predicate nonEmptyStringPredicate = (String s) -> !s.isEmpty(); + List filter = filter(Arrays.asList("123","","asv","^&*"), nonEmptyStringPredicate); + System.out.println(filter); + } + + +} diff --git a/src/main/java/lambdasinaction/chap4/StreamBasic.java b/src/main/java/lambdasinaction/chap4/StreamBasic.java index 19a8c176..ebfa074c 100644 --- a/src/main/java/lambdasinaction/chap4/StreamBasic.java +++ b/src/main/java/lambdasinaction/chap4/StreamBasic.java @@ -1,6 +1,7 @@ package lambdasinaction.chap4; import java.util.*; +import java.util.function.Function; import java.util.stream.*; import static java.util.Comparator.comparing; @@ -10,7 +11,7 @@ public class StreamBasic { - public static void main(String...args){ + public static void main(String... args) { // Java 7 getLowCaloricDishesNamesInJava7(Dish.menu).forEach(System.out::println); @@ -21,26 +22,26 @@ public static void main(String...args){ } - public static List getLowCaloricDishesNamesInJava7(List dishes){ + public static List getLowCaloricDishesNamesInJava7(List dishes) { List lowCaloricDishes = new ArrayList<>(); - for(Dish d: dishes){ - if(d.getCalories() < 400){ + for (Dish d : dishes) { + if (d.getCalories() < 400) { lowCaloricDishes.add(d); } } List lowCaloricDishesName = new ArrayList<>(); Collections.sort(lowCaloricDishes, new Comparator() { - public int compare(Dish d1, Dish d2){ + public int compare(Dish d1, Dish d2) { return Integer.compare(d1.getCalories(), d2.getCalories()); } }); - for(Dish d: lowCaloricDishes){ + for (Dish d : lowCaloricDishes) { lowCaloricDishesName.add(d.getName()); } return lowCaloricDishesName; } - public static List getLowCaloricDishesNamesInJava8(List dishes){ + public static List getLowCaloricDishesNamesInJava8(List dishes) { return dishes.stream() .filter(d -> d.getCalories() < 400) .sorted(comparing(Dish::getCalories)) diff --git a/src/main/java/lambdasinaction/chap4/StreamParallellTest.java b/src/main/java/lambdasinaction/chap4/StreamParallellTest.java new file mode 100644 index 00000000..30cfd663 --- /dev/null +++ b/src/main/java/lambdasinaction/chap4/StreamParallellTest.java @@ -0,0 +1,57 @@ +package lambdasinaction.chap4; + +import org.apache.commons.collections4.ListUtils; + +import java.util.List; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +/** + * @author vector + * @date: 2018/10/18 0018 10:00 + *

+ * List> -> List + *

+ * 使用parallelstream需注意【共享对象的可变状态】 + * 如使用foreach就能改变其状态 + * 需要特别注意下 + */ +public class StreamParallellTest { + + public static List sum(List items, int count) { + List> listList = ListUtils.partition(items, count); + return listList.stream().flatMap(List::stream).map(StreamParallellTest::delayFun).collect(Collectors.toList()); + } + + public static List parallelSum(List items, int count) { + List> listList = ListUtils.partition(items, count); + return listList.parallelStream().flatMap(List::stream).map(StreamParallellTest::delayFun).collect(Collectors.toList()); + } + + public static String delayFun(int digist) { + try { + Thread.sleep(digist); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return digist + ""; + } + + private static void execute(String msg, Supplier> supplier) { + long s = System.nanoTime(); + supplier.get(); + long e = System.nanoTime(); + long duration = (e - s) / 1_000_000; + + System.out.println(msg + " done in " + duration + " msecs"); + } + + + public static void main(String[] args) { + List items = IntStream.rangeClosed(1, 50).boxed().collect(Collectors.toList()); + System.out.println(items); + execute("sum", () -> sum(items, 10)); + execute("parallelSum", () -> parallelSum(items, 10)); + } +} diff --git a/src/main/java/lambdasinaction/chap5/Demo522.java b/src/main/java/lambdasinaction/chap5/Demo522.java new file mode 100644 index 00000000..348b8cc2 --- /dev/null +++ b/src/main/java/lambdasinaction/chap5/Demo522.java @@ -0,0 +1,21 @@ +package lambdasinaction.chap5; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static java.util.stream.Collectors.toList; + +/** + * @author vector + * @date: 2018/9/29 0029 15:48 + */ +public class Demo522 { + public static void main(String[] args) { + List hw = Arrays.asList("Hello", "World"); + List collect = hw.stream().map(word -> word.split("")).flatMap(Arrays::stream).distinct().collect(toList()); + System.out.println(collect); + } +} diff --git a/src/main/java/lambdasinaction/chap5/Demo551.java b/src/main/java/lambdasinaction/chap5/Demo551.java new file mode 100644 index 00000000..8fa16d23 --- /dev/null +++ b/src/main/java/lambdasinaction/chap5/Demo551.java @@ -0,0 +1,36 @@ +package lambdasinaction.chap5; + +import java.util.*; +import java.util.stream.Collectors; + +import static java.util.Comparator.comparing; +import static java.util.stream.Collectors.joining; +import static java.util.stream.Collectors.toList; + +/** + * @author vector + * @date: 2018/9/29 0029 16:48 + */ +public class Demo551 { + public static void main(String[] args) { + List list = new ArrayList<>(); + List list1 = list.stream().filter(item -> item.getYear() == 2011).sorted(comparing(Transaction::getValue)).collect(toList()); + + Set set2 = list.stream().map(item -> item.getTrader().getCity()).collect(Collectors.toSet()); + + List list3 = list.stream().map(Transaction::getTrader).filter(item -> item.getCity().equals("剑桥")).distinct().sorted(comparing(Trader::getName)).collect(toList()); + + String collect4 = list.stream().map(item -> item.getTrader().getName()).distinct().sorted().collect(joining()); + + boolean boolean5 = list.stream().anyMatch(item -> item.getTrader().getCity().equals("米兰")); + + list.stream().filter(item->item.getTrader().getCity().equals("剑桥")).map(Transaction::getValue).forEach(System.out::println); + + Optional first7 = list.stream().map(Transaction::getValue).sorted(Integer::compareTo).limit(1).findFirst(); + + list.stream().min(comparing(Transaction::getValue)); + + + + } +} diff --git a/src/main/java/lambdasinaction/chap6/CollectorHarness.java b/src/main/java/lambdasinaction/chap6/CollectorHarness.java index 8370be16..d8049d2a 100644 --- a/src/main/java/lambdasinaction/chap6/CollectorHarness.java +++ b/src/main/java/lambdasinaction/chap6/CollectorHarness.java @@ -5,8 +5,8 @@ public class CollectorHarness { public static void main(String[] args) { - //System.out.println("Partitioning done in: " + execute(PartitionPrimeNumbers::partitionPrimes) + " msecs"); - System.out.println("Partitioning done in: " + execute(PartitionPrimeNumbers::partitionPrimesWithCustomCollector) + " msecs" ); + System.out.println("Partitioning done in: " + execute(PartitionPrimeNumbers::partitionPrimes) + " msecs"); +// System.out.println("Partitioning done in: " + execute(PartitionPrimeNumbers::partitionPrimesWithCustomCollector) + " msecs" ); } private static long execute(Consumer primePartitioner) { diff --git a/src/main/java/lambdasinaction/chap6/Demo62.java b/src/main/java/lambdasinaction/chap6/Demo62.java new file mode 100644 index 00000000..f829a260 --- /dev/null +++ b/src/main/java/lambdasinaction/chap6/Demo62.java @@ -0,0 +1,26 @@ +package lambdasinaction.chap6; + +import java.util.Arrays; +import java.util.List; + +public class Demo62 { + public static List transactions = Arrays + .asList( new GroupingTransactions.Transaction(GroupingTransactions.Currency.EUR, 1500.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.USD, 2300.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.GBP, 9900.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.EUR, 1100.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.JPY, 7800.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.CHF, 6700.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.EUR, 5600.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.USD, 4500.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.CHF, 3400.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.GBP, 3200.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.USD, 4600.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.JPY, 5700.0), + new GroupingTransactions.Transaction(GroupingTransactions.Currency.EUR, 6800.0) ); + + public static void main(String[] args) { + System.out.println(transactions.size()); + System.out.println(transactions.stream().count()); + } +} diff --git a/src/main/java/lambdasinaction/chap6/Grouping.java b/src/main/java/lambdasinaction/chap6/Grouping.java index 9105cc80..d2642a7f 100644 --- a/src/main/java/lambdasinaction/chap6/Grouping.java +++ b/src/main/java/lambdasinaction/chap6/Grouping.java @@ -13,8 +13,8 @@ enum CaloricLevel { DIET, NORMAL, FAT }; public static void main(String ... args) { System.out.println("Dishes grouped by type: " + groupDishesByType()); System.out.println("Dish names grouped by type: " + groupDishNamesByType()); - System.out.println("Dish tags grouped by type: " + groupDishTagsByType()); - System.out.println("Caloric dishes grouped by type: " + groupCaloricDishesByType()); +// System.out.println("Dish tags grouped by type: " + groupDishTagsByType()); +// System.out.println("Caloric dishes grouped by type: " + groupCaloricDishesByType()); System.out.println("Dishes grouped by caloric level: " + groupDishesByCaloricLevel()); System.out.println("Dishes grouped by type and caloric level: " + groupDishedByTypeAndCaloricLevel()); System.out.println("Count dishes in groups: " + countDishesInGroups()); @@ -32,14 +32,14 @@ private static Map> groupDishNamesByType() { return menu.stream().collect(groupingBy(Dish::getType, mapping(Dish::getName, toList()))); } - private static Map> groupDishTagsByType() { - return menu.stream().collect(groupingBy(Dish::getType, flatMapping(dish -> dishTags.get( dish.getName() ).stream(), toSet()))); - } - - private static Map> groupCaloricDishesByType() { +// private static Map> groupDishTagsByType() { +// return menu.stream().collect(groupingBy(Dish::getType, flatMapping(dish -> dishTags.get( dish.getName() ).stream(), toSet()))); +// } +// +// private static Map> groupCaloricDishesByType() { // return menu.stream().filter(dish -> dish.getCalories() > 500).collect(groupingBy(Dish::getType)); - return menu.stream().collect(groupingBy(Dish::getType, filtering(dish -> dish.getCalories() > 500, toList()))); - } +// return menu.stream().collect(groupingBy(Dish::getType, filtering(dish -> dish.getCalories() > 500, toList()))); +// } private static Map> groupDishesByCaloricLevel() { return menu.stream().collect( @@ -63,16 +63,22 @@ private static Map>> groupDishedByTypeAn } private static Map countDishesInGroups() { + Map collect = menu.stream().collect(groupingBy(Dish::getType, counting())); return menu.stream().collect(groupingBy(Dish::getType, counting())); } private static Map> mostCaloricDishesByType() { + menu.stream().collect(groupingBy(Dish::getType, reducing((d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2))); + + return menu.stream().collect( groupingBy(Dish::getType, reducing((Dish d1, Dish d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2))); } private static Map mostCaloricDishesByTypeWithoutOprionals() { + + return menu.stream().collect( groupingBy(Dish::getType, collectingAndThen( @@ -86,6 +92,8 @@ private static Map sumCaloriesByType() { } private static Map> caloricLevelsByType() { + + return menu.stream().collect( groupingBy(Dish::getType, mapping( dish -> { if (dish.getCalories() <= 400) return CaloricLevel.DIET; diff --git a/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java b/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java index 69d7c4ca..cd4c3990 100644 --- a/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java +++ b/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java @@ -32,10 +32,10 @@ public static Map> partitionPrimesWithCustomCollector(int public static boolean isPrime(List primes, Integer candidate) { double candidateRoot = Math.sqrt((double) candidate); - //return takeWhile(primes, i -> i <= candidateRoot).stream().noneMatch(i -> candidate % i == 0); - return primes.stream().takeWhile(i -> i <= candidateRoot).noneMatch(i -> candidate % i == 0); + return takeWhile(primes, i -> i <= candidateRoot).stream().noneMatch(i -> candidate % i == 0); +// return primes.stream().takeWhile(i -> i <= candidateRoot).noneMatch(i -> candidate % i == 0); +// return false; } -/* public static List takeWhile(List list, Predicate p) { int i = 0; for (A item : list) { @@ -46,16 +46,26 @@ public static List takeWhile(List list, Predicate p) { } return list; } -*/ + public static class PrimeNumbersCollector implements Collector>, Map>> { @Override public Supplier>> supplier() { - return () -> new HashMap>() {{ - put(true, new ArrayList()); - put(false, new ArrayList()); - }}; + return () -> + new HashMap>() {{ + put(true,new ArrayList()); + } + }; + + +// booleanListHashMap.put(true,new ArrayList<>()); +// booleanListHashMap.put(false, new ArrayList<>()); +// return booleanListHashMap; +// } return () -> new HashMap>() {{ +// put(true, new ArrayList()); +// put(false, new ArrayList()); +// }}; } @Override diff --git a/src/main/java/lambdasinaction/chap6/Partitioning.java b/src/main/java/lambdasinaction/chap6/Partitioning.java index 2ec8dc79..7dfad9b1 100644 --- a/src/main/java/lambdasinaction/chap6/Partitioning.java +++ b/src/main/java/lambdasinaction/chap6/Partitioning.java @@ -8,7 +8,7 @@ public class Partitioning { - public static void main(String ... args) { + public static void main(String... args) { System.out.println("Dishes partitioned by vegetarian: " + partitionByVegeterian()); System.out.println("Vegetarian Dishes by type: " + vegetarianDishesByType()); System.out.println("Most caloric dishes by vegetarian: " + mostCaloricPartitionedByVegetarian()); @@ -23,6 +23,10 @@ private static Map>> vegetarianDishesByType() } private static Object mostCaloricPartitionedByVegetarian() { + + Map collect = menu.stream().collect(partitioningBy(Dish::isVegetarian, collectingAndThen(maxBy(comparingInt(Dish::getCalories)), Optional::get))); + System.out.println(collect); + return menu.stream().collect( partitioningBy(Dish::isVegetarian, collectingAndThen( diff --git a/src/main/java/lambdasinaction/chap6/Reducing.java b/src/main/java/lambdasinaction/chap6/Reducing.java index fb7cf971..44973e3e 100644 --- a/src/main/java/lambdasinaction/chap6/Reducing.java +++ b/src/main/java/lambdasinaction/chap6/Reducing.java @@ -1,15 +1,18 @@ package lambdasinaction.chap6; +import java.util.function.BiFunction; + import static java.util.stream.Collectors.*; import static lambdasinaction.chap6.Dish.menu; public class Reducing { - public static void main(String ... args) { + public static void main(String... args) { System.out.println("Total calories in menu: " + calculateTotalCalories()); System.out.println("Total calories in menu: " + calculateTotalCaloriesWithMethodReference()); System.out.println("Total calories in menu: " + calculateTotalCaloriesWithoutCollectors()); System.out.println("Total calories in menu: " + calculateTotalCaloriesUsingSum()); + System.out.println("Total calories in menu: " + oldCount()); } private static int calculateTotalCalories() { @@ -27,4 +30,17 @@ private static int calculateTotalCaloriesWithoutCollectors() { private static int calculateTotalCaloriesUsingSum() { return menu.stream().mapToInt(Dish::getCalories).sum(); } + + private static int oldCount() { + menu.stream().map(Dish::getCalories).reduce(Integer::sum); + menu.stream().mapToInt(Dish::getCalories).sum(); + + menu.stream().collect(reducing(0, Dish::getCalories, Integer::sum)); + + int sum = 0; + for (Dish dish : menu) { + sum += dish.getCalories(); + } + return sum; + } } \ No newline at end of file diff --git a/src/main/java/lambdasinaction/chap6/ToListCollector.java b/src/main/java/lambdasinaction/chap6/ToListCollector.java index 0621d96a..05f613ca 100644 --- a/src/main/java/lambdasinaction/chap6/ToListCollector.java +++ b/src/main/java/lambdasinaction/chap6/ToListCollector.java @@ -9,6 +9,7 @@ public class ToListCollector implements Collector, List> { @Override public Supplier> supplier() { + return () -> new ArrayList(); } diff --git a/src/main/java/lambdasinaction/chap7/Demo71.java b/src/main/java/lambdasinaction/chap7/Demo71.java new file mode 100644 index 00000000..ddba8693 --- /dev/null +++ b/src/main/java/lambdasinaction/chap7/Demo71.java @@ -0,0 +1,30 @@ +package lambdasinaction.chap7; + +import java.util.stream.Stream; + +/** + * @author vector + * @date: 2018/10/9 0009 11:21 + */ +public class Demo71 { + + public static long sequentialSum(int n) { + return Stream.iterate(1L, i -> i + 1).limit(n).reduce(0L, (l1, l2) -> l1 + l2); + } + + public static long parallelSum(int n) { + return Stream.iterate(1L, i -> i + 1).limit(n).parallel().reduce(0L, (l1, l2) -> l1 + l2); + } + + public static long iterativeSum(int n) { + long result = 0; + for (int i = 0; i < n; i++) { + result += i; + } + return result; + } + + public static void main(String[] args) { + + } +} diff --git a/src/main/java/lambdasinaction/chap8/Peek.java b/src/main/java/lambdasinaction/chap8/Peek.java index e25d68a4..01b839ce 100644 --- a/src/main/java/lambdasinaction/chap8/Peek.java +++ b/src/main/java/lambdasinaction/chap8/Peek.java @@ -10,7 +10,7 @@ public class Peek { public static void main(String[] args) { - List result = Stream.of(2, 3, 4, 5) + List result = Stream.of(2, 3, 4, 5, 13, 23) .peek(x -> System.out.println("taking from stream: " + x)).map(x -> x + 17) .peek(x -> System.out.println("after map: " + x)).filter(x -> x % 2 == 0) .peek(x -> System.out.println("after filter: " + x)).limit(3) diff --git a/src/main/java/lambdasinaction/chap9/Body.java b/src/main/java/lambdasinaction/chap9/Body.java new file mode 100644 index 00000000..ee3a0476 --- /dev/null +++ b/src/main/java/lambdasinaction/chap9/Body.java @@ -0,0 +1,18 @@ +package lambdasinaction.chap9; + +public class Body implements Sized { + + public static void main(String[] args) { + System.out.println(new Body().size()); + } + + @Override + public int size() { + return 20; + } + + @Override + public boolean isEmpty() { + return false; + } +} diff --git a/src/main/java/lambdasinaction/chap9/Sized.java b/src/main/java/lambdasinaction/chap9/Sized.java new file mode 100644 index 00000000..206dea5a --- /dev/null +++ b/src/main/java/lambdasinaction/chap9/Sized.java @@ -0,0 +1,9 @@ +package lambdasinaction.chap9; + +public interface Sized { + int size(); + + default boolean isEmpty() { + return size() == 0; + } +} diff --git a/src/test/java/TransformTest/Demo1.java b/src/test/java/TransformTest/Demo1.java new file mode 100644 index 00000000..36c02ee0 --- /dev/null +++ b/src/test/java/TransformTest/Demo1.java @@ -0,0 +1,70 @@ +package TransformTest; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +/** + * @author vector + * @date: 2018/10/15 0015 11:47 + */ +public class Demo1 { + public static List getLongestList(List> lists) { + if (lists.isEmpty()) { + return new ArrayList<>(); + } + int index = 0; + int max = 0; + for (int i = 0; i < lists.size(); i++) { + List list = lists.get(i); + if (list.size() > max) { + index = i; + max = list.size(); + } + } + return lists.get(index); + } + + + public static List getLongestList2(List> lists) { + return lists.stream().max(Comparator.comparing(List::size)).orElse(Collections.emptyList()); +// List max = Collections.max(lists, Comparator.comparingInt(List::size)); +// return max; + + } + + public static void main(String[] args) { + List> bigList = new ArrayList>(){{ + add(new ArrayList(){{ + add("A"); + add("B"); + add("C"); + add("D"); + }}); + add(new ArrayList(){{ + add("a"); + add("b"); + add("c"); + }}); + add(new ArrayList(){{ + add("A"); + add("B"); + add("C"); + add("d"); + }}); + add(new ArrayList(){{ + add("A"); + add("B"); + }}); + }}; + System.out.println(bigList.size()); + for (int i = 0; i < 100; i++) { + System.out.println(getLongestList(bigList)); + System.out.println(getLongestList2(bigList)); + System.out.println(new ArrayList<>()); + System.out.println("===="); + } + + } +} diff --git a/src/test/java/TransformTest/Demo2.java b/src/test/java/TransformTest/Demo2.java new file mode 100644 index 00000000..7945283d --- /dev/null +++ b/src/test/java/TransformTest/Demo2.java @@ -0,0 +1,46 @@ +package TransformTest; + +import org.apache.commons.lang3.time.DateFormatUtils; +import org.apache.commons.lang3.time.DateUtils; + +import java.text.ParseException; +import java.util.Date; +import java.util.Objects; + +/** + * @author vector + * @date: 2018/10/15 0015 13:55 + */ +public class Demo2 { + public static boolean validDateTime(Date date, Date start, Date end) { + if (Objects.isNull(date) || Objects.isNull(start) ||Objects.isNull(end) ) { + return false; + } + if (date.after(start) && date.before(end) ) { + return true; + } + return false; + } + public static boolean validDateTime2(Date date, Date start, Date end) { + if (Objects.isNull(date)) { + return false; + } + if (Objects.isNull(start) || date.before(start)) { + return false; + } + if (Objects.isNull(end) || date.after(end)) { + return false; + } + return true; + } + + public static void main(String[] args) throws ParseException { + Date currentDate = new Date(); + Date start = DateFormatUtils.ISO_DATE_FORMAT.parse("2018-10-15"); + Date end = DateFormatUtils.ISO_DATE_FORMAT.parse("2070-01-01"); + + System.out.println(validDateTime(currentDate,start,end)); + System.out.println(validDateTime2(currentDate,start,end)); + } + +}