677 Stream 的中间操作 筛选与切片
/*
测试Stream的中间操作
筛选与切片
*/
@Test
public void test4(){
List<Person> personList = getPersonList();
//filter(Predicate p) 接收 Lambda ， 从流中排除某些元素
Stream<Person> stream = personList.stream();
stream.filter(p ->p.getAge()>=3).forEach(System.out::println);
System.out.println();
//distinct() 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
personList.add(new Person("王哈哈",1));
Stream<Person> stream1 = personList.stream();
stream1.distinct().forEach(System.out::println);
System.out.println();
//limit(long maxSize) 截断流，使其元素不超过给定数量
Stream<Person> stream2 = personList.stream();
stream2.limit(4).forEach(System.out::println);
System.out.println();
//skip(long n) 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
Stream<Person> stream3 = personList.stream();
stream3.skip(3).forEach(System.out::println);
System.out.println();
}多个中间操作可以连接起来形成一个流水 线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
678 Stream 的中间操作 映射
/**
* @Description:
* 测试Stream的中间操作
*
* 映射
* @Author: JOKER
* @Date: 16:54 2022/12/10
* @Params: []
* @return: void
*/
@Test
public void test5(){
List<Person> personList = getPersonList();
//map(Function f)
// 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
personList.stream().map(Person::getName)
.filter(name->name.length()>2).forEach(System.out::println);
// ↑ 取Person的名字中超过2个字的 名字
System.out.println();
//mapToDouble(ToDoubleFunction f)
// 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
//mapToInt(ToIntFunction f)
// 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
//mapToLong(ToLongFunction f)
// 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
//flatMap(Function f)
// 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee");
list.stream().map(StreamAPITest::fromStringToStream).forEach(s->{
s.forEach(System.out::println);
});
System.out.println();
//使用后更简便---------像List.addAll() {1,2,3,{4,5,6}}---------
list.stream().flatMap(StreamAPITest::fromStringToStream).forEach(System.out::println);
}
/**
* @Description: 将字符串中的字符转为字符的Stream
* @Author: JOKER
* @Date: 17:05 2022/12/10
* @Params: [str]
* @return: java.util.stream.Stream<java.lang.Character>
*/
public static Stream<Character> fromStringToStream(String str){
ArrayList<Character> list = new ArrayList();
for (char c :str.toCharArray()){
list.add(c);
}
return list.stream();
}679 Stream的中间操作：排序
/**
* @Description:
* 测试Stream的中间操作
*
* 排序
* @Author: JOKER
* @Date: 17:29 2022/12/10
* @Params: []
* @return: void
*/
@Test
public void test6(){
List<Integer> list = Arrays.asList(314, 24, 35, 46, 7645);
//sorted() 产生一个新流，其中按自然顺序排序
list.sort(Integer::compareTo);//通过Comparator方法排序
System.out.println(list);
System.out.println("----- 使用sorted()方法 -------");
list.stream().sorted().forEach(System.out::println);
System.out.println();
//sorted(Comparator com) 产生一个新流，其中按比较器顺序排序
List<Person> personList = getPersonList();
//使用sorted()，其类需要实现Comparable接口 ， 当然本sort()也提供了定制服务
personList.stream().sorted().forEach(System.out::println);
System.out.println("----- 使用sort()定制 ---------");
// personList.stream().sorted((p1,p2)-> Integer.compare(p1.age,p2.age))
// .forEach(System.out::println);//似乎还可以再简洁点
personList.stream().sorted(Comparator.comparingInt(p -> p.age))
.forEach(System.out::println);
}680 Stream的终止操作：匹配与查找
/**
* @Description:
* Stream 的终止操作
*
* 匹配与查找
* @Author: JOKER
* @Date: 18:07 2022/12/10
* @Params: []
* @return: void
*/
@Test
public void test7(){
List<Person> personList = getPersonList();
//allMatch(Predicate p) 检查是否匹配所有元素
boolean b = personList.stream().allMatch(p -> p.getAge() == 3);
System.out.println(b);
//anyMatch(Predicate p) 检查是否至少匹配一个元素
boolean b1 = personList.stream().anyMatch(p -> p.getAge() == 3);
System.out.println(b1);
//noneMatch(Predicate p) 检查是否没有匹配所有元素
boolean b3 = personList.stream().noneMatch(p -> p.getName().contains("王"));
System.out.println(b3);
//findFirst() 返回第一个元素
Optional<Person> first = personList.stream().findFirst();
System.out.println(first);
//findAny() 返回当前流中的任意元素
Optional<Person> any = personList.stream().findAny();
System.out.println(any);
//count() 返回流中元素总数
long count = personList.stream().count();
System.out.println(count);
//max(Comparator c) 返回流中最大值
Optional<Person> max = personList.stream()
.max((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()));
System.out.println(max);
Optional<Person> max1 = personList.stream()
.max(Comparator.comparingInt(Person::getAge));//同上
System.out.println(max1);
//min(Comparator c) 返回流中最小值
Optional<Integer> min = personList.stream().map(Person::getAge).min(Integer::compare);
System.out.println(min);
//forEach(Consumer c)
// 内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
personList.stream().forEach(System.out::println);
//使用 集合的遍历操作
personList.forEach(System.out::println);
}681 Stream的终止操作：归约
/**
* @Description:
* Stream的终止操作：
*
* 归约
* @Author: JOKER
* @Date: 19:37 2022/12/10
* @Params: []
* @return: void
*/
@Test
public void test8(){
//reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 T
//练习：计算1~10的和
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Optional<Integer> sum = list.stream().reduce((i1, i2) -> i1 + i2);
System.out.println(sum);
Optional<Integer> sum1 = list.stream().reduce(Integer::sum);
System.out.println(sum1);
//reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
List<Person> personList = getPersonList();
//练习：计算所有人的年龄之和
Optional<Integer> agesum = personList.stream().map(Person::getAge).reduce(Integer::sum);
System.out.println(agesum);
}682 Stream的终止操作：收集
/**
* @Description:
* Stream的终止操作：
*
* 收集
* @Author: JOKER
* @Date: 19:57 2022/12/10
* @Params: []
* @return: void
*/
@Test
public void test9(){
List<Person> personList = getPersonList();
//collect(Collector c) 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
//过滤Person中年龄大于3的人，后将结果收集为List类型
List<Person> lst = personList.stream().filter(p -> p.age > 3).collect(Collectors.toList());
lst.forEach(System.out::println);
System.out.println();
//过滤Person中年龄大于3的人，后将结果收集为Set类型
Set<Person> set = personList.stream().filter(p -> p.age > 3).collect(Collectors.toSet());
set.forEach(System.out::println);
}
683 Optional类的介绍
package com.test.optional;
import org.junit.Test;
import java.util.Optional;
/**
* CLassName: OptionalTest
* Package: com.test.optional
* Description: Optional类
*
* @Author: JOKER-wqc
* @Create: 2022/12/10 - 20:43
* @Version: v1.0
*/
public class OptionalTest {
/**
* @Description: 创建Optional对象
* @Author: JOKER
* @Date: 20:47 2022/12/10
* @Params: []
* @return: void
*/
@Test
public void test(){
Girl girl = new Girl();
// Optional.of(T t) : 创建一个 Optional 实例， t必须非空；
Optional<Girl> optionalGirl = Optional.of(girl);
System.out.println(optionalGirl); //Optional[Girl{name='null'}]
// Optional.empty() : 创建一个空的 Optional 实例
// Optional.ofNullable(T t) ： t可以为null
Girl girl1 =null;
Optional<Girl> optionalGirl1 = Optional.ofNullable(girl1);
System.out.println(optionalGirl1); //Optional.empty
}
}
package com.test.optional;
import java.util.Objects;
/**
* CLassName: Girl
* Package: com.test.optional
* Description:
*
* @Author: JOKER-wqc
* @Create: 2022/12/10 - 20:44
* @Version: v1.0
*/
public class Girl {
private String name;
public Girl() {
}
public Girl(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Girl girl = (Girl) o;
return Objects.equals(name, girl.name);
}
@Override
public int hashCode() {
return name != null ? name.hashCode() : 0;
}
@Override
public String toString() {
return "Girl{" +
"name='" + name + '\'' +
'}';
}
}
package com.test.optional;
import java.util.Objects;
/**
* CLassName: Boy
* Package: com.test.optional
* Description:
*
* @Author: JOKER-wqc
* @Create: 2022/12/10 - 20:46
* @Version: v1.0
*/
public class Boy {
private Girl girl;
public Boy(Girl girl) {
this.girl = girl;
}
public Boy() {
}
public Girl getGirl() {
return girl;
}
public void setGirl(Girl girl) {
this.girl = girl;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Boy boy = (Boy) o;
return Objects.equals(girl, boy.girl);
}
@Override
public int hashCode() {
return girl != null ? girl.hashCode() : 0;
}
@Override
public String toString() {
return "Boy{" +
"girl=" + girl +
'}';
}
}
684 Optional类的使用举例
- Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
- 创建Optional 类对象的方法：
- Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
- Optional.empty() : 创建一个空的 Optional 实例
- Optional.ofNullable(T t) ：t可以为null
- 判断Optional 容器中是否包含对象：
- boolean isPresent() : 判断是否包含对象
- void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer
- 接口的实现代码，并且该值会作为参数传给它。
- 获取Optional 容器的对象：
- T get(): 如果调用对象包含值，返回该值，否则抛异常
- T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
- T orElseGet(Supplier<? extends T> other) ： ：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
- T orElseThrow(Supplier<? extends X> exceptionSupplier) ： ：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
685.尚硅谷_复习：动态代理
686 复习：Lambda表达式
687 复习：函数式接口
688 复习：方法引用与构造器引用
689 复习Stream API
690 复习：Optional类的使用
691 JDK版本更新说明
这意味着Java的更新从传统的以特性驱动的发布周期，转变为以时间驱动的（6 个月为周期）发布模式，并逐步的将 Oracle JDK 原商业特性进行开源。
针对企业客户的需求，Oracle 将以三年为周期发布长期支持版本（long term support）。
692 新版本JDK的下载与IDEA的开发设置
693 java9新特性：JDK目录结构的改变
694 Java9新特性：模块化系统
模块化 系统: Jigsaw Modularity
695 Java9新特性：Java的REPL工具：jshell
交互式编程环境 REPL (read - evaluate - print -loop)了
696 java9新特性：接口中声明私有方法
package test.java9;
/**
* CLassName: InterfaceTest
* Package: test.java9
* Description:
*
* @Author: JOKER-wqc
* @Create: 2022/12/11 - 16:49
* @Version: v1.0
*/
public class InterfaceImpTest implements Interface{
@Override
public void abstractMethod() {
System.out.println("类重写抽象方法");
}
@Override
public void defaultMethod() {
//Interface.super.defaultMethod();
System.out.println("类重写默认方法");
}
public static void main(String[] args) {
InterfaceImpTest itf = new InterfaceImpTest();
itf.abstractMethod();
itf.defaultMethod();
// itf.privateMethod(); //'privateMethod()' has private access in 'test.java9.Interface'
//接口中的静态方法只能接口自己调用
Interface.staticMethod();
}
}
697 java9新特性：钻石操作符的语法升级
/**
* @Description: 钻石操作符的升级
* @Author: JOKER
* @Date: 17:04 2022/12/11
* @Params: []
* @return: void
*/
@Test
public void test1(){
//钻石操作符与匿名内部类在java8前不能共存，java9可以（ Comparator<> ）
Comparator<Integer> comparator = new Comparator<>() {
@Override
public int compare(Integer o1, Integer o2) {
return 0;
}
};
//jdk7新特性：类型推断（ ArrayList<> ）
ArrayList<String> strings = new ArrayList<>();
}
698 java9新特性：try结构的语法升级
/**
* @Description: try操作的升级(由于idea的test方法不能输入，故采用main)
* @Author: JOKER
* @Date: 19:15 2022/12/11
* @Params: [args]
* @return: void
*/
public static void main(String[] args) {
//java8之前的关闭操作
/*InputStreamReader reader = null;
try {
reader = new InputStreamReader(System.in);
char[] buffer = new char[100];
int len;
StringBuilder result = new StringBuilder();
if ((len = reader.read(buffer)) != -1) {
result.append(buffer, 0, len);
}
System.out.println(result);
// System.out.println(new BufferedReader(reader).readLine());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
}*/
//Java 8中的资源关闭操作 : Java 8中，可以实现资源的自动关闭
//要求自动关闭的资源的初始化必须放在try的一对小括号中
/*try(InputStreamReader reader1= new InputStreamReader(System.in)){
char[] buffer1 = new char[100];
int len1;
StringBuilder result1 = new StringBuilder();
if ((len1 = reader1.read(buffer1)) != -1){
result1.append(buffer1,0,len1);
}
System.out.println(result1);
// System.out.println(new BufferedReader(reader).readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}*/
//Java 9中资源关闭操作
//需要自动关闭的资源的实例化可以放在try的一对小括号外
InputStreamReader reader2 = new InputStreamReader(System.in);
try (reader2) { //注意此时的reader2为final常理，不能修改
char[] buffer2 = new char[100];
int len2;
StringBuilder result2 = new StringBuilder();
if ((len2 = reader2.read(buffer2)) != -1) {
result2.append(buffer2, 0, len2);
}
System.out.println(result2);
// System.out.println(new BufferedReader(reader).readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
699 Java9新特性：String底层存储
Motivation
The current implementation of the String class stores characters in a char array, using two bytes (sixteen bits) for each character. Data gathered from many different applications indicates that strings are a major component of heap usage and, moreover, that most String objects contain only Latin-1 characters. Such characters require only one byte of storage, hence half of the space in the internal char arrays of such String objects is going unused.
Description
We propose to change the internal representation of the String class from a UTF-16 char array to a byte array plus an encoding-flag field. The new String class will store characters encoded either as ISO-8859-1/Latin-1 (one byte per character), or as UTF-16 (two bytes per character), based upon the contents of the string. The encoding flag will indicate which encoding is used.
700 Java9新特性：Java9&10&11新特性 工厂方法创建只读集合
package test.java9;
import org.junit.Test;
import java.util.*;
/**
* CLassName: Java9Test1
* Package: test.java9
* Description: 集合工厂方法：快速创建只读集合
*
* @Author: JOKER-wqc
* @Create: 2022/12/11 - 20:39
* @Version: v1.0
*/
public class Java9Test1 {
//Java 8 中写法
@Test
public void test(){
List<String> namesList = new ArrayList<>();
namesList.add("Joe");
namesList.add("Bob");
namesList.add("Bill");
/*unmodifiableList返回的list是一个只读集合 */
List<String> unmodifiableList = Collections.unmodifiableList(namesList);
// unmodifiableList.add("haha"); //UnsupportedOperationException
System.out.println(unmodifiableList);
Set<String> set = Set.of("a", "b", "c");//造只读Set
/*如下unmodifiableMap的操作不适用于jdk 8 及之前版本,适用于jdk 9*/
Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<>() {
{
put("a", 1);
put("b", 2);
put("c", 3);
}
});
map.forEach((k, v) -> System.out.println(k + ":" + v));
System.out.println();
/*Java9新特性 集合工厂方法：List.of()创建只读list集合*/
List<String> unmodifiableList1 = Arrays.asList("Joe","Bob","Bill");
// unmodifiableList1.add("haha"); //UnsupportedOperationException
System.out.println(unmodifiableList1);
//Java9新特性 集合工厂方法： Map,of()创建只读map集合
Map<String, Integer> map1 = Map.of("a", 1, "b", 2, "c", 3);
// map1.put("d",4); //UnsupportedOperationException
map1.forEach((k, v) -> System.out.println(k + ":" + v));
}
}
Java 9因此引入了方便的方法，这使得类似的事情更容易表达。
扫一扫
2185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
