public class Demo02Stream {
public static void main(String[] args) {
//创建一个List集合,存储姓名
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
// 使用Stream流式操作
list.stream()
.filter(name -> name.startsWith("张")) // 第一次过滤: 只要以张开头的元素
.filter(name -> name.length()==3) // 第二次过滤: 只要姓名长度为3的人
.forEach(name -> System.out.println(name)); // 遍历查看结果
}
}// 集合转换为Stream流对象
List<String> list = new ArrayList<>();
Stream<String> listStream = list.stream(); // List集合的Stream
Set<String> set = new HashSet<>();
Stream<String> setStream = set.stream(); // Set集合的Stream
Map<String,String> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream(); // 键的集合的Stream
Stream<String> valueStream = map.values().stream(); // 值的集合的Stream
Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream(); // 键值对的集合的Stream
// 数组转换为Stream流对象
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
String[] array = {"a", "b", "c"};
Stream<String> arrayStream = Stream.of(array);
public class Test {
public static void main(String[] args) {
String[] arr = {"张三", "李四", "王五", "赵六", "田七"};
// 将数组转换为流对象
Stream<String> stream = Stream.of(arr);
// 遍历流
stream.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
// 使用链式调用+Lambda表达式的标准格式
Stream.of("张三", "李四", "王五", "赵六", "田七")
.forEach((String name)-> {
System.out.println(name);
});
// Lambda的省略格式
Stream.of("张三", "李四", "王五", "赵六", "田七")
.forEach(name-> System.out.println(name));
}
}public class Test {
public static void main(String[] args) {
// 普通方式
String[] arr = {"张三丰", "张翠山", "赵敏", "周芷若", "张无忌"};
Stream<String> stream1 = Stream.of(arr);
Stream<String> stream2 = stream1.filter(new Predicate<String>() {
@Override
public boolean test(String name) {
return name.startsWith("张");
}
});
stream2.forEach(new Consumer<String>() {
@Override
public void accept(String name) {
System.out.println(name);
}
});
// 链式调用+Lambda表达式
Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌")
.filter(name->name.startsWith("张"))
.forEach(name-> System.out.println(name));
}
}public class Test {
public static void main(String[] args) {
String[] arr = {"1", "2", "3", "4"};
Stream<String> stream1 = Stream.of(arr);
Stream<Integer> stream2 = stream1.map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s);
}
});
stream2.forEach(i-> System.out.println(i));
// 链式调用+Lambda表达式
Stream.of("1", "2", "3", "4")
.map(s -> Integer.parseInt(s))
.forEach(i-> System.out.println(i));
}
}public class Test {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
long count = list.stream().count();
System.out.println(count);
// 利用JDK9提供的快速创建集合方法
long count2 = List.of(1, 2, 3, 4, 5, 6, 7)
.stream()
.count();
System.out.println(count2);
}
}public class Test {
public static void main(String[] args) {
String[] arr = {"美羊羊", "喜洋洋", "懒洋洋", "灰太狼", "红太狼"};
// Stream.of(arr)
// .limit(3)
// .forEach(name-> System.out.println(name));
Stream.of("美羊羊", "喜洋洋", "懒洋洋", "灰太狼", "红太狼")
.limit(300) // 超出实际大小, 有多少返回多少
.forEach(name-> System.out.println(name));
}
}public class Test {
public static void main(String[] args) {
String[] arr = {"美羊羊", "喜洋洋", "懒洋洋", "灰太狼", "红太狼"};
Stream.of(arr)
.skip(3)
.forEach(name-> System.out.println(name));
System.out.println("-----------");
Stream.of("美羊羊", "喜洋洋", "懒洋洋", "灰太狼", "红太狼")
.skip(3)
.forEach(name-> System.out.println(name));
}
}public class Test {
public static void main(String[] args) {
String[] arr1 = {"张三丰", "张翠山", "赵敏", "周芷若", "张无忌"};
String[] arr2 = {"美羊羊", "喜洋洋", "懒洋洋", "灰太狼", "红太狼"};
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
Stream<String> concat = Stream.concat(stream1, stream2);
concat.forEach(name-> System.out.println(name));
System.out.println("---------");
// 简化
Stream.concat(
Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌"),
Stream.of("美羊羊", "喜洋洋", "懒洋洋", "灰太狼", "红太狼")
).forEach(name-> System.out.println(name));
}
}// 定义函数式接口: 模拟Java中已经提供的函数式接口
@FunctionalInterface
public interface Printable {
// 定义功能: 打印s. 功能怎么实现先不管
void print(String s);
}
// 定义一个类: 模拟Java中已经定义好的类和方法
public class MethodRefObject {
// 将字符串变大写再打印出来
public void printUpperCaseString(String str){
System.out.println(str.toUpperCase());
}
}
public class Test {
// 定义方法用于打印Hello, 参数为 打印字符串的方式
public static void printString(Printable lambda){
lambda.print("Hello");
}
public static void main(String[] args) {
// 普通Lambda方式
printString((s)->{
// 创建对象, 调用已经存在方法printUpperCase
MethodRefObject obj = new MethodRefObject();
obj.printUpperCaseString(s);
});
// 使用方法引用简化
MethodRefObject obj = new MethodRefObject();
printString(obj::printUpperCaseString);
// 直接引用obj的printUpperCaseString方法作为抽象方法print的实现
}
}
public class Test {
//定义方法用来计算一个数的结果. 参数: 被计算的整数 和 计算的方式
public static int method(int number, Calcable c){
return c.calcAbs(number);
}
public static void main(String[] args) {
// Lambda方式调用method方法: 传递-10和Lambda, 调用Math.abs()方法计算出结果, 并返回
int result1 = method(-10, (number)->{return Math.abs(number);});
System.out.println(result1); // 10
// 方法引用方式调用method方法: 传递-10, 直接引用Math类中的abs方法
int result2 = method(-10, Math::abs);
System.out.println(result2); // 10
}
}// 定义见面打招呼的函数式接口: 模拟Java中已经提供的函数式接口
@FunctionalInterface
public interface Greetable {
// 见面打招呼的方法
void greet();
}
// 定义父类: 人类
public class Human {
//定义一个sayHello的方法
public void sayHello(){
System.out.println("Hello 我是Human!");
}
}
// 定义子类: 男人类, 继承人类
public class Man extends Human {
// 子类重写了父类sayHello的方法
@Override
public void sayHello() {
System.out.println("Hello 我是Man!");
}
//定义方法用来见面打招呼. 参数是见面打招呼的方式
public void method(Greetable g){
g.greet();
}
// 因为要使用super, 所以定义了一个成员方法
public void show(){
// Lambda方式: 创建父类对象, 用父类对象调用方法
method(()->{
Human h = new Human(); // 创建父类Human对象
h.sayHello(); // 调用父类的sayHello方法
});
// Lambda方式: 直接使用super调用父类方法, 省去创建父类对象的麻烦
method(()->{
super.sayHello(); // 直接使用super调用父类的sayHello方法
});
// 方法引用方式: 直接引用父类的sayHello方法作为greet抽象方法的实现
method(super::sayHello); // 其实就是 对象名::成员方法名 只不过对象用super代表
}
public static void main(String[] args) {
new Man().show();
}
}
// 定义一个表示富有的函数式接口, 模拟Java中提供的函数式接口
@FunctionalInterface
public interface Richable {
//定义一个想买什么就买什么的方法
void buy();
}
// Husband类, 表示一个要买房结婚丈夫
public class Husband {
// 本类中已经存在的方法: 买房子的方法
public void buyHouse(){
System.out.println("北京二环内买一套四合院!");
}
//定义结婚的方法, 参数: 传递Richable接口
public void marry(Richable r){
r.buy();
}
//定义非常高兴的方法: 因为要调用this, 所以定义这个非静态方法
public void soHappy(){
// Lambda方式: 使用this调用本类已经存在的方法
marry(()->{
this.buyHouse();
});
// 方法引用方式: 直接通过this引用本类中的buyHouse方法
marry(this::buyHouse); // 其实也是 对象名::成员方法名 只不过对象名用this表示
}
public static void main(String[] args) {
new Husband().soHappy();
}
}
// Person类
public class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// 定义用于创建Person对象的函数式接口, 模拟Java中已经提供的函数式接口
@FunctionalInterface
public interface PersonBuilder { // Function转换
// 根据姓名创建Person对象, 怎么创建需要Lambda来实现
Person builderPerson(String name);
}
// 测试类
public class Test {
// 定义方法, 用于根据传入的姓名创建一个Person对象并打印名称
// 参数: 姓名 和 创建Person对象的方式
public static void printName(String name, PersonBuilder pb){
Person person = pb.builderPerson(name);
System.out.println(person.getName());
}
public static void main(String[] args) {
// Lambda方式: 传递姓名和创建对象的方式
printName("迪丽热巴",(String name)->{
return new Person(name); // 仅仅调用了Person类的构造方法
});
// 方法引用方式: 直接引用Person类的构造方法
printName("古力娜扎",Person::new);
}
}
// 定义创建数组的函数式接口, 模拟Java中已经提供的函数式接口
@FunctionalInterface
public interface ArrayBuilder {
// 根据指定length长度, 创建一个int[]数组. 怎么创建需要我们传递Lambda实现
int[] builderArray(int length);
}
// 测试类
public class Test {
// 定义方法用于创建数组
// 参数: 数组的长度 和 创建数组的方式
public static int[] createArray(int length, ArrayBuilder ab){
return ab.builderArray(length);
}
public static void main(String[] args) {
// Lambda方式: 传递长度10, 以及创建数组的Lambda表达式
int[] arr1 = createArray(
10,
(len)->{
return new int[len];
});
System.out.println(arr1.length); //10
// 方法引用方式: 传递长度10, 和数组的构造方法
int[] arr2 = createArray(10, int[]::new);
System.out.println(arr2.length); //10
}
}
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) | 黑马程序员IT技术论坛 X3.2 |