天天学JAVA-JAVA基础(5)

如果觉得我写的还行，请关注我的博客并且点个赞哟。本文主要介绍JAVA Stream 流相关知识，通过阅读本文，你将掌握Stream的基本用法。
如果不知道Stream是什么，请阅读博文天天学JAVA-JAVA基础（2）这篇文章。

1.流的常用创建方法有以下四种
2.Stream具体用法
3.一道阿里面试题，你会做吗？

1. 流的常用创建方法有以下四种

package com.cy.lambda.learning;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Stream;

/**
 * cy
 *
 */
public class CreateStreamDemo {
    public static void main(String[] args) {
        //1.使用Collection下的 stream() 和 parallelStream() 方法
        List<String> list = new ArrayList<String>();
        Stream<String> stream  =list.stream();//创建一个串行流
        Stream<String> parallelStream  =list.parallelStream();//创建一个并行流

        //2.使用Arrays 中的 stream() 方法，将数组转成流
        String[] nums = new String[10];
        Stream<String> alist = Arrays.stream(nums);

        //3.使用Stream中的静态方法：of()、iterate()、generate
        //of
        Stream<Integer> streamk = Stream.of(1,2,3,4,5,6);
        //iterate
        Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
        stream2.forEach(System.out::println); // 0 2 4 6 8 10
        //generate
        Stream<Double> stream3 = Stream.generate(Math::random).limit(2);
        stream3.forEach(System.out::println);
        
        //4.使用 Pattern.splitAsStream() 方法，将字符串分隔成流
        Pattern pattern = Pattern.compile(",");
        Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
        stringStream.forEach(System.out::println);
    }
}

2.Stream具体用法
1.筛选和切片

package com.cy.lambda.learning;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

/**
 * cy
 * 流的筛选与切片
 */
public class FilteringAndSlicingDemo {

    public static void main(String[] args) {

        //数据初始化
         List<Integer>  list =  new ArrayList<>();
         list.add(1);
         list.add(3);
         for (int i = 0; i < 10 ;i ++){
             list.add(i);
             //System.out.println(i);
         }

         //filter：过滤流中的某些元素
        list.stream().filter(s -> s<3)   //1,1,2
                .forEach(System.out::print);
        // limit(n)：获取n个元素
        list.stream().limit(3)
                .forEach(System.out::print);
        //skip(n)：跳过n元素，配合limit(n)可实现分页
        list.stream().skip(2).forEach(System.out::print);
        //distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
        list.stream().distinct().forEach(System.out::print);

        //综合
        list.stream().filter(s -> s<=6)
                     .distinct()
                     .skip(2)
                      .limit(3).forEach(System.out::print;);
    }
}

2.映射

package com.cy.lambda.learning;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class MappingDemo {
    public static void main(String[] args) {
//map(Function f)	接受一个函数作为参数，
//并将函数应用到每一个元素上，返回新的元素
//        mapToDouble(ToDoubleFunction f)	返回的新元素为double类型
//        mapToInt(ToIntFunction f)	返回的新元素为int类型
//        mapToLong(ToLongFunction f)	返回的新元素为long类型
//        flatMap(Function f)	操作多层嵌套的流，使其扁平化

        List<Integer> list =  new ArrayList<>();
        list.add(1);
        list.add(3);
        for (int i = 0; i < 10 ;i ++){
            list.add(i);
            //System.out.println(i);
        }
        //接受一个函数作为参数，并将函数应用到每一个元素上，返回新的元素
        System.out.println("int :");
        list.stream().map(s -> s.intValue());
        //返回的新元素为double类型
        list.stream().mapToDouble(s -> s.intValue());
        // mapToInt(ToIntFunction f)	返回的新元素为int类型
        list.stream().mapToInt(s -> s.intValue());
        //mapToLong(ToLongFunction f)	返回的新元素为long类型
        list.stream().mapToLong(s-> s).forEach(System.out::print);
        //flatMap(Function f)	操作多层嵌套的流，使其扁平化
        list.stream().flatMap(s ->{
            Stream<String> stream =  Stream.empty();
            return stream;
        });
    }
}

3 排序

package com.cy.lambda.learning;

import java.util.Arrays;
import java.util.List;

/**
 * cc程序员
 *
 */
public class StreamSortDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("aa", "ff", "dd","bb");
        //sorted 产生一个新流，其中按自然顺序排序
        list.stream().sorted().forEach(System.out::print);
        System.out.println();
        People people  =  new People("111",11,"1");
        People people1  =  new People("113",13,"1");
        People people2  =  new People("115",13,"1");
         //
        List<People> list1 =   Arrays.asList(people,people1,people2);
        list1.stream().sorted(
                (p1,p2)  ->{
                    if(p1.getUserNaMme().equals(p2.getUserNaMme())){
                        return  p1.getAge() - p2.getAge();
                    }else {
                        return   p1.getUserNaMme().compareTo(p2.getUserNaMme()) ;
                    }
                }
        ).forEach(s ->{
            System.out.println(s.toString());
        });
    }
}
class  People{
    private   String userNaMme;
    private   Integer age;
    private   String  sex;

    public People(String userNaMme, Integer age, String sex) {
        this.userNaMme = userNaMme;
        this.age = age;
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getUserNaMme() {
        return userNaMme;
    }

    public void setUserNaMme(String userNaMme) {
        this.userNaMme = userNaMme;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "People{" +
                "userNaMme='" + userNaMme + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

今天的代码分享就到这里了，上面的例子代码已经上传至github上stream实例，有需要的可以下载下来运行。下面分享一道来自阿里的面试题。

3.有一个类B继承自类A，他们数据成员如下：

class A {
...
private：
   int &a;
};
class B : public A {
...
private:
     int a;
public:
     const int b;
     A c;
     static const char* d;
     A* e;
};

则构造函数中，成员变量一定要通过初始化列表来初始化的是____。

A. b c
B.b c e
C.b c d e
D.c e
E.b d
F.b e

如果你想知道答案或者你知道答案，请留言或者关注下方公众号，并且回复1029，将会得到答案和解析哟。

如果你觉得我写的还行，请关注我的博客并且点个赞哟，也请关注我的公众号并加入下方QQ群,每天都会定时推送干货以及共享一些优质的学习资料和视频哟.