Java8 学习

tiancaisq · 发表于 2018-12-12 20:24:58

经过一番苦战，终于把Java8 的绝大部分内容学完了，啃书还真心不容易呢

返回一个热量低于400的卡路里并按照热量升序获取菜肴名称

public class Dish {
private final String name;
private final boolean vegetarian;
private final int calories;
private final Type type;
public enum Type {
MEAT, FISH, OTHER
}

复制代码

结果：
[season fruit, prawns, rice]

private List<Dish> menu = Arrays.asList(new Dish("pork", false, 800, Dish.Type.MEAT),
new Dish("beef", false, 700, Dish.Type.MEAT), new Dish("chicken", false, 400, Dish.Type.MEAT),
new Dish("french fries", true, 530, Dish.Type.OTHER), new Dish("rice", true, 350, Dish.Type.OTHER),
new Dish("season fruit", true, 120, Dish.Type.OTHER), new Dish("pizza", true, 550, Dish.Type.OTHER),
new Dish("prawns", false, 300, Dish.Type.FISH), new Dish("salmon", false, 450, Dish.Type.FISH));;

复制代码

Java8之前

Java8 写法

stream 操作分为
数据源
中间操作

终端操作

数组-> Stream Arrays.stream(T[] arrays)
distinct-> toSet()

流操作的模式
过滤：filter（predicate）， distinct（），limit（n），skip（n），
切片
查找：findFirst（），findAny（）
匹配：allMatch（predicate），anyMatch（predicate），noneMatch（predicate）
映射：map（function），flatMap(function)
归约：reduce（）

IntStream-> boxed()-> collect()

private List<Dish> menu = Arrays.asList(new Dish("pork", false, 800, Dish.Type.MEAT),
new Dish("beef", false, 700, Dish.Type.MEAT), new Dish("chicken", false, 400, Dish.Type.MEAT),
new Dish("french fries", true, 530, Dish.Type.OTHER), new Dish("rice", true, 350, Dish.Type.OTHER),
new Dish("season fruit", true, 120, Dish.Type.OTHER), new Dish("pizza", true, 550, Dish.Type.OTHER),
new Dish("prawns", false, 300, Dish.Type.FISH), new Dish("salmon", false, 450, Dish.Type.FISH));;
@Test
public void test00() {
List<Dish> lowCaloricDishes = new ArrayList<>();
for (Dish d : menu) {
if (d.getCalories() < 400) {
lowCaloricDishes.add(d);
}
}
Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
public int compare(Dish d1, Dish d2) {
return Integer.compare(d1.getCalories(), d2.getCalories());
}
});
List<String> lowCaloricDishesName = new ArrayList<>();
for (Dish d : lowCaloricDishes) {
lowCaloricDishesName.add(d.getName());
}
System.out.println(lowCaloricDishesName);
}
@Test
public void test01() {
// 获取卡路里小于400 ，热量顺序排列获取菜肴名称
List<String> list = menu.stream().filter(item -> item.getCalories() < 400)
.sorted((i1, i2) -> Integer.compare(i1.getCalories(), i2.getCalories())).map(item -> item.getName())
.collect(Collectors.toList());
System.out.println(list);
// 写法2，使用辅助方法
List<String> list2 = menu.stream().filter(item -> item.getCalories() < 400)
.sorted(Comparator.comparing(Dish::getCalories)).map(Dish::getName).collect(Collectors.toList());
System.out.println(list2);
// 写法3，添加方法引用
List<String> list3 = menu.stream().filter(Dish::isLose).sorted(Comparator.comparing(Dish::getCalories))
.map(Dish::getName).collect(Collectors.toList());
System.out.println(list3);
}
@Test
public void test02() {
Map<Type, List<Dish>> list = menu.stream().collect(Collectors.groupingBy(Dish::getType));
System.out.println(list);
}
@Test
public void test03() {
// ["Hello","World"]，你想要返回列表["H","e","l", "o","W","r","d"]。
String[] strArr = { "Hello", "World" };
List<String> collect = Arrays.stream(strArr).flatMap(str -> Arrays.asList(str.split("")).stream()).distinct()
.collect(Collectors.toList());
System.out.println(collect);
List<String> collect2 = Arrays.asList(strArr).stream().map(str -> str.split("")).flatMap(Arrays::stream)
.distinct().collect(Collectors.toList());
System.out.println(collect2);
}
@Test
public void test04() {
// (1) 给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？
// 例如，给定[1, 2, 3, 4, 5]，应该返回[1, 4, 9, 16, 25]
int[] arr = { 1, 2, 3, 4, 5 };
List<Integer> collect = Arrays.stream(arr).map(item -> item * item).boxed().collect(Collectors.toList());
System.out.println(collect);
}
@Test
public void test05() {
// (2) 给定两个数字列表，如何返回所有的数对呢？
// 例如，给定列表[1, 2, 3]和列表[3, 4]，
// 应该返回[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]。
// 为简单起见，你可以用有两个元素的数组来代
// 表数对。
List<Integer> alist = Arrays.asList(1, 2, 3);
List<Integer> blist = Arrays.asList(3, 4);
List<int[]> collect = alist.stream().flatMap(item -> blist.stream().map(bitem -> new int[] { item, bitem }))
.collect(Collectors.toList());
for (int[] is : collect) {
System.out.println(Arrays.toString(is));
}
System.out.println("====");
// (3) 如何扩展前一个例子，只返回总和能被3整除的数对呢？例如(2, 4)和(3, 3)是可以的。
List<int[]> collect2 = alist.stream().flatMap(
item -> blist.stream().filter(bitem -> (item + bitem) % 3 == 0).map(bitem -> new int[] { item, bitem }))
.collect(Collectors.toList());
for (int[] is : collect2) {
System.out.println(Arrays.toString(is));
}
}
@Test
public void test06() {
IntStream stream = IntStream.of(1, 2, 3, 4, 5, 6, 7, 12);
boolean allMatch = stream.allMatch(item -> item < 12);
System.out.println(allMatch);
stream = IntStream.of(1, 2, 3, 4, 5, 6, 7, 12);
boolean anyMatch = stream.anyMatch(item -> item < 0);
System.out.println(anyMatch);
stream = IntStream.of(1, 2, 3, 4, 5, 6, 7, 12);
boolean anyMatch2 = stream.noneMatch(item -> item < 0);
System.out.println(anyMatch2);
}
@Test
public void test07() {
IntStream stream = IntStream.of(1, 2, 3, 4, 5, 6, 7);
OptionalInt findFirst = stream.findFirst();
findFirst.ifPresent(System.out::println);
stream = IntStream.of(1, 2, 3, 4, 5, 6, 7);
OptionalInt findFirst2 = stream.findAny();
findFirst2.ifPresent(System.out::println);
}
@Test
public void test08() {
IntStream stream = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int reduce = stream.reduce(0, (i1, i2) -> i1 + i2);
System.out.println(reduce);
stream = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
OptionalInt reduce2 = stream.reduce(Integer::sum);
reduce2.ifPresent(System.out::println);
}
@Test
public void test09() {
IntStream stream = IntStream.of(1, 2, 32, 4, 5, 6, 7, 8, 9, 10);
OptionalInt max = stream.max();
System.out.println(max);
List<Integer> asList = Arrays.asList(1,2,32,4,5,6,7,8,9,10);
Integer reduce = asList.stream().reduce(0, Math:: max);
System.out.println(reduce);
}
@Test
public void test10() {
IntStream stream = IntStream.of(1, 2, 32, 4, 5, 6, 7, 8, 9, 10);
int sum = stream.sum();
System.out.println(sum);
List<Integer> asList = Arrays.asList(1,2,32,4,5,6,7,8,9,10);
Integer reduce = asList.stream().mapToInt(i->i).sum();
System.out.println(reduce);
}
@Test
public void test11() {
IntStream range = IntStream.rangeClosed(0, 100);
int sum = range.sum();
System.out.println(sum);
}
@Test
public void test12() {
IntStream rangeClosed = IntStream.rangeClosed(1, 100);
rangeClosed.boxed().flatMap(a-> IntStream.rangeClosed(a, 100).filter(b-> Math.sqrt(a*a + b*b) % 1.0 ==0).mapToObj(b-> new int[] {a, b, (int)Math.sqrt(a*a + b*b)})).forEach(item->System.out.println(Arrays.toString(item)));
}
@Test
public void test13() {
Stream<Integer> iterate = Stream.iterate(1, i->i+1);
List<Integer> collect = iterate.limit(10).collect(Collectors.toList());
System.out.println(collect);
}
@Test
public void test14() {
IntStream stream = IntStream.of(1, 2, 32, 4, 5, 6, 7, 8, 9, 10);
long count = stream.count();
System.out.println(count);
stream = IntStream.of(1, 2, 32, 4, 5, 6, 7, 8, 9, 10);
Long collect = stream.boxed().collect(Collectors.counting());
System.out.println(collect);
stream = IntStream.of(1, 2, 32, 4, 5, 6, 7, 8, 9, 10);
// OptionalInt max = stream.max();
Optional<Integer> collect2 = stream.boxed().collect(Collectors.maxBy(Comparator.comparingInt(i->i)));
System.out.println(collect2);
}

复制代码

tiancaisq · 发表于 2018-12-12 20:26:16

一个lambda 表达式
引入函数式编程
Stream流概念
数据并行
组合式的异步编程理念
新的日期时间api
Optional 取代null

tiancaisq · 发表于 2018-12-12 22:52:21

CompletableFuture

@Test
public void test01() {
// 组合式的异步编程
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
Future<Integer> submit = newCachedThreadPool.submit(() -> 1);
// ...
try {
Integer integer = submit.get(1, TimeUnit.SECONDS);
System.out.println(integer);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void test02() {
// String str = "test";
// String remoteMethod = remoteMethod(str);
// String remoteMethod = remoteMethod(str);
// String remoteMethod = remoteMethod(str);
// ...
// CompletableFuture<String> remoteMethod = remoteMethod(str);
// CompletableFuture<String> remoteMethod = remoteMethod(str);
// CompletableFuture<String> remoteMethod = remoteMethod(str);
// ..
List<String> asList = Arrays.asList("1", "2", "3", "4", "4", "4", "4", "4");
long start, end = 0;
start = System.currentTimeMillis();
List<String> collect = asList.parallelStream().map(str -> str + "," + remoteMethod(str))
.collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect);
System.out.println(end - start);
}
@Test
public void test03() {
List<String> asList = Arrays.asList("1", "2", "3", "4", "4", "4", "4", "4");
long start, end = 0;
start = System.currentTimeMillis();
List<CompletableFuture<String>> collect = asList.stream()
.map(str -> CompletableFuture.supplyAsync(() -> str + "," + remoteMethod(str)))
.collect(Collectors.toList());
List<String> collect2 = collect.stream().map(CompletableFuture::join).collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect2);
System.out.println(end - start);
}
@Test
public void test04() {
List<String> asList = Arrays.asList("1", "2", "3", "4", "4", "4", "4", "4");
long start, end = 0;
start = System.currentTimeMillis();
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(asList.size(), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r);
return thread;
}
});
List<CompletableFuture<String>> collect = asList.stream()
.map(str -> CompletableFuture.supplyAsync(() -> str + "," + remoteMethod(str), newFixedThreadPool))
.collect(Collectors.toList());
List<String> collect2 = collect.stream().map(CompletableFuture::join).collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect2);
System.out.println(end - start);
}
public static void main(String[] args) {
CompletableFutureTest completableFutureTest = new CompletableFutureTest();
List<String> asList = Arrays.asList("1", "2", "3", "4", "4", "4", "4", "4");
long start, end = 0;
start = System.currentTimeMillis();
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(asList.size(), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r);
thread.setDaemon(true);
return thread;
}
});
List<CompletableFuture<String>> collect = asList
.stream().map(str -> CompletableFuture
.supplyAsync(() -> str + "," + completableFutureTest.remoteMethod(str), newFixedThreadPool))
.collect(Collectors.toList());
List<String> collect2 = collect.stream().map(CompletableFuture::join).collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect2);
System.out.println(end - start);
}
@Test
public void test05() {
List<String> asList = Arrays.asList("1", "2", "5", "4", "7", "4", "77", "4", "54");
long start, end = 0;
start = System.currentTimeMillis();
List<String> collect = asList.parallelStream().map(str -> localMethod(str)).map(str -> remoteMethod(str))
.map(str -> remoteMethod2(str)).collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect);
System.out.println(end - start);
}
@Test
public void test06() {
List<String> asList = Arrays.asList("1", "2", "5", "4", "7", "4", "77", "4", "54");
long start, end = 0;
start = System.currentTimeMillis();
List<String> collect = asList.stream().map(str -> localMethod(str)).map(str -> remoteMethod(str))
.map(str -> remoteMethod2(str)).collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect);
System.out.println(end - start);
}
@Test
public void test07() {
List<String> asList = Arrays.asList("1", "2", "5", "4", "7", "4", "77", "4", "54");
long start, end = 0;
start = System.currentTimeMillis();
Executor pool = Executors.newFixedThreadPool(asList.size());
List<CompletableFuture<String>> collect = asList.stream().map(str -> localMethod(str))
.map(str -> CompletableFuture.supplyAsync(() -> remoteMethod(str), pool))
.map(future -> future.thenCompose(str -> CompletableFuture.supplyAsync(() -> remoteMethod2(str), pool)))
.collect(Collectors.toList());
List<String> collect2 = collect.stream().map(CompletableFuture::join).collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect2);
System.out.println(end - start);
}
@Test
public void test08() {
List<String> asList = Arrays.asList("1", "2", "5", "4", "7", "4", "77", "4", "54");
long start, end = 0;
Executor pool = Executors.newFixedThreadPool(asList.size());
start = System.currentTimeMillis();
List<String> collect = asList.stream().map(str-> remoteMethod3(str)).collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect);
System.out.println(end - start);
}
@Test
public void test09() {
List<String> asList = Arrays.asList("1", "2", "5", "4", "7", "4", "77", "4", "54");
long start, end = 0;
Executor pool = Executors.newFixedThreadPool(asList.size());
start = System.currentTimeMillis();
List<String> collect = asList.parallelStream().map(str-> remoteMethod3(str)).collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(collect);
System.out.println(end - start);
}
@Test
public void test10() {
List<String> asList = Arrays.asList("1", "2", "5", "4", "7", "4", "77", "4", "54");
long start, end = 0;
Executor pool = Executors.newFixedThreadPool(asList.size());
start = System.currentTimeMillis();
List<CompletableFuture<String>> collect = asList.stream().map(str-> CompletableFuture.supplyAsync(()-> remoteMethod3(str), pool)).collect(Collectors.toList());
CompletableFuture[] array = collect.stream().map(future-> future.thenAccept(System.out:: println)).toArray(size-> new CompletableFuture[size]);
// CompletableFuture.allOf(array).join();
CompletableFuture.anyOf(array).join();
// .collect(Collectors.toList());
end = System.currentTimeMillis();
System.out.println(end - start);
}
public String localMethod(String str) {
return "自加工+" + str;
}
/**
* 远程方法
*
* @param str
* @return
*/
public String remoteMethod(String str) {
delay();
str += "Call Action";
return str;
// CompletableFuture<String> futureString = new CompletableFuture<>();
// new Thread(()->{
// String resultString = str + "Call Action";
// futureString.complete(resultString);
// }).start();
// return futureString;
// return CompletableFuture.supplyAsync(()-> str + "Call Action");
}
public String remoteMethod2(String str) {
delay();
str += "@@ Call Action2";
return str;
}
public String remoteMethod3(String str) {
delay2();
str += "@@ Call Action2";
return str;
}
/**
* 模拟延迟
*/
public void delay() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public Random random = new Random();
/**
* 模拟延迟
*/
public void delay2() {
try {
Thread.sleep(random.nextInt(2000));
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

复制代码

		自动登录	找回密码
密码			立即注册

Java8 学习

本帖子中包含更多资源