侯静川
侯静川

Java 8新特性 : λ表达式、Stream API用法详解

目录

一、Lambda表达式

1. lambda表达式的使用情况

二、函数式(Functional)接口

1. 什么是函数式接口

2. 如何理解函数式接口

3. 函数式接口举例

三、方法引用与构造器引用

1. 方法引用

2. 构造器引用

3. 数组引用

四、强大的StreamAPI

1. 为什么使用StreamAPI

2. 什么是Stream

3. Stream的操作步骤

4. Stream的实例化

4.1 创建Stream : 通过集合

4.2 创建Stream : 通过数组

4.3 创建Stream : 通过Stream的of方法

4.4 创建Stream : 创建无限流

5. Stream的中间操作

5.1 筛选与切片

5.2 映射

5.3 排序

6. Stream的终止操作

6.1 匹配与查找

6.2 归约

6.3 收集

五、Optional类

1. 创建Optional类对象

2. Optional类的常用方法

3. Optional类使用举例

一、Lambda表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

Lambda表达式的本质 : 作为函数式接口的实例

举例 :

(o1, o2) -> Integer.compare(o1, o2);

格式 :

-> : lambda操作符 或 箭头操作符
-> 左边 : lambda形参列表(其实就是接口中的抽象方法的形参列表)
-> 右边 : lambda体(其实就是重写的抽象方法的方法体)

1. lambda表达式的使用情况

语法格式一 : 无参、无返回值。

/*
语法格式一 : 无参、无返回值
 */
@Test
public void test01(){
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("我爱北京天安门");
        }
    };
​
    r1.run();
​
    System.out.println("-----------------------------------------");
    //使用lambda表达式
    Runnable r2 = () -> System.out.println("我爱北京故宫");
    r2.run();
}

语法格式二 : Lambda 需要一个参数，但是没有返回值。

/*
语法格式二：Lambda 需要一个参数，但是没有返回值。
 */
@Test
public void test03(){
​
    Consumer cons = new Consumer() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    cons.accept("Hello world");
​
    System.out.println("****************************");
​
    Consumer cons2 = (String s) -> {
        System.out.println(s);
    };
    cons2.accept("Hello world");
}

语法格式三 : 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

/*
语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
 */
@Test
public void test04(){
    Consumer cons2 = (String s) -> {
        System.out.println(s);
    };
    cons2.accept("Hello world");
    //类型推断
    Consumer cons3 = (s) -> {
        System.out.println(s);
    };
    cons3.accept("Hello world");
​
}

语法格式四 : Lambda 若只需要一个参数时，参数的小括号可以省略

/*
语法格式四 : Lambda 若只需要一个参数时，参数的小括号可以省略
 */
@Test
public void test05(){
    //类型推断
    Consumer cons3 = (s) -> {
        System.out.println(s);
    };
    cons3.accept("Hello world");
​
    Consumer cons4 = s -> {
        System.out.println(s);
    };
    cons4.accept("Hello world");
}

语法格式五 : Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

/*
语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
 */
@Test
public void test06(){
    Comparator com1 = new Comparator() {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };
    int compare = com1.compare(12, 23);
    System.out.println(compare);
​
    System.out.println("*************************");
​
    Comparator com2 = (o1, o2) -> {
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
    System.out.println(com2.compare(21, 12));
}

语法格式六 : 当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略

/*
语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
 */
@Test
public void test07(){
    Comparator com = (o1, o2) -> o1.compareTo(o2);
    int compare = com.compare(12, 21);
    System.out.println(compare);
}

总结 :

-> 左边 : lambda形参列表的参数类型可以省略(类型推断);如果lambda形参列表只有一个参数,其一对()也可以省略
-> 右边 : lambda体应该使用一对大括号{}包裹;如果lambda体只有一条执行语句(可能是return语句),可以省略这一对大括号{}以及return关键字

二、函数式(Functional)接口

1. 什么是函数式接口

如果一个接口中只声明了一个抽象方法，则此接口就是函数型接口。

你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。

我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

在java.util.function包下定义了Java 8 的丰富的函数式接口

@FunctionalInterface
public interface MyInterface {
    void method1();
}

2. 如何理解函数式接口

Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程）

在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。

简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。

所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

3. 函数式接口举例

Java内置四大核心函数式接口 :

消费型接口 : Consumer     void accept(T t)
供给型接口 : Supplier     T get()
函数型接口 : Function   R apply(T t)
断定型接口 : Predicate    boolean test(T t)

举例 : 消费型接口

@Test
public void test01(){
    happyTime(100, new Consumer() {
        @Override
        public void accept(Double aDouble) {
            System.out.println("今天很开心，消费" + aDouble);
        }
    });
​
    System.out.println("********************************");
​
    happyTime(100, aDouble -> System.out.println("今天很开心，消费" + aDouble));
}
/*
result :
今天很开心，消费100.0
********************************
今天很开心，消费100.0
 */
​
public void happyTime(double money, Consumer con){
    con.accept(money);
}

举例 : 断言式接口

    @Test
    public void test02(){
        List list = Arrays.asList("北京", "南京", "天津", "东京", "西京", "普京");
​
//        List resList = filterString(list, new Predicate() {
//            @Override
//            public boolean test(String s) {
//                return s.contains("京");
//            }
//        });
//        System.out.println(resList);
        //使用lambda表达式
        List resList = filterString(list, s -> s.contains("京"));
        System.out.println(resList);
    }
​
    public List filterString(List list, Predicate pre){
        List resList = new ArrayList<>();
​
        for (String str : list){
            if (pre.test(str)){
                resList.add(str);
            }
        }
​
        return resList;
    }

三、方法引用与构造器引用

1. 方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

要求 : 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致

格式：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。

如下三种主要使用情况：

  • 对象::实例方法名

  • 类::静态方法名

  • 类::实例方法名

情况一使用举例 :

// 情况一：对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1() {
   Consumer con = str -> System.out.println(str);
   con.accept("测试");
​
   System.out.println("***********************");
​
   PrintStream ps = System.out;
   Consumer con2 = ps::println;
   con2.accept("测试");
}
​
//Supplier中的T get()
//Employee中的String getName()
@Test
public void test2() {
   Employee emp = new Employee(1001, "Tom", 23, 5600);
​
   Supplier sup = () -> emp.getName();
   System.out.println(sup.get());
​
   System.out.println("************************");
​
   Supplier sup2 = emp::getName;
   System.out.println(sup2.get());
}

情况二使用举例 :

// 情况二：类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3() {
   Comparator com1 = (o1, o2) -> Integer.compare(o1, o2);
   System.out.println(com1.compare(12, 21));
​
   System.out.println("********************");
​
   Comparator com2 = Integer::compare;
   System.out.println(com2.compare(21, 12));
}
​
//Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4() {
   Function fun = num -> Math.round(num);
   Long res = fun.apply(12.2);
   System.out.println(res);
​
   System.out.println("********************");
​
   Function func = Math::round;
   Long result = fun.apply(12.2);
   System.out.println(result);
}

情况三使用举例 :

// 情况三：类 :: 实例方法 
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
@Test
public void test5() {
   Comparator com1 = (s1, s2) -> s1.compareTo(s2);
   System.out.println(com1.compare("abc", "abd"));
​
   System.out.println("************************");
​
   Comparator com2 = String :: compareTo;
   System.out.println(com2.compare("abc", "abd"));
}
​
//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
@Test
public void test6() {
   BiPredicate pre1 = (s1, s2) -> s1.equals(s2);
   System.out.println(pre1.test("abc", "abc"));
​
   System.out.println("************************");
​
   BiPredicate pre2 = String :: equals;
   System.out.println(pre2.test("abc", "abd"));
​
}
​
// Function中的R apply(T t)
// Employee中的String getName();
@Test
public void test7() {
   Function func1 = (emp) -> emp.getName();
   System.out.println(func1.apply(new Employee(1001, "Tom", 12, 500)));
​
   System.out.println("***********************");
​
   Function func2 = Employee::getName;//Employee的对象调用getName方法
   System.out.println(func2.apply(new Employee(1001, "Tom", 12, 500)));
}

2. 构造器引用

//构造器引用
   //Supplier中的T get()
   @Test
   public void test1(){
       Supplier sup1 = new Supplier() {
           @Override
           public Employee get() {
               return new Employee();
           }
       };
       System.out.println(sup1.get());
​
       System.out.println("*******************");
​
       Supplier sup2 = () -> new Employee();
       System.out.println(sup2.get());
​
       System.out.println("*****************");
​
       Supplier sup3 = Employee :: new;
       System.out.println(sup3.get());
}
​
//Function中的R apply(T t)
   @Test
   public void test2(){
       Function func1 = id -> new Employee(id);
       System.out.println(func1.apply(1001));
​
       System.out.println("*******************");
​
       Function func2 = Employee :: new;
       System.out.println(func2.apply(1002));
}
​
//BiFunction中的R apply(T t,U u)
   @Test
   public void test3(){
       BiFunction func1 = (id, name) -> new Employee(id, name);
       System.out.println(func1.apply(1001, "Tom"));
​
       System.out.println("**************************");
​
       BiFunction func2 = Employee :: new;
       System.out.println(func2.apply(1002, "Jerry"));
}

3. 数组引用

可以把数组看做是一个类，则数组引用的写法与构造器引用一致

//数组引用
   //Function中的R apply(T t)
   @Test
   public void test4(){
       Function func1 = length -> new String[length];
       System.out.println(Arrays.toString(func1.apply(5)));
​
       System.out.println("********************");
​
       Function func2 = String[] :: new;
       System.out.println(Arrays.toString(func2.apply(10)));
   }

四、强大的StreamAPI

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

1. 为什么使用StreamAPI

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。

Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。

2. 什么是Stream

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

集合讲的是数据，Stream讲的是计算！

注意 :

  • Stream 自己不会存储元素。

  • Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

  • Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

3. Stream的操作步骤

Stream的执行流程 :

  • Stream的实例化 : 一个数据源（如：集合、数组），获取一个流

  • 一系列的中间操作(过滤、映射...) : 一个中间操作链，对数据源的数据进行处理

  • 终止操作 : 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

        Java 8新特性 : λ表达式、Stream API用法详解_第1张图片 

4. Stream的实例化

4.1 创建Stream : 通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

  • default Stream stream() : 返回一个顺序流

  • default Stream parallelStream() : 返回一个并行流

@Test
public void test01(){
    List employees = EmployeeData.getEmployees();
    //获取一个顺序流
    Stream stream = employees.stream();
    //获取一个并行流
    Stream parallelStream = employees.parallelStream();
}

4.2 创建Stream : 通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

  • static Stream stream(T[] array) : 返回一个流

重载形式，能够处理对应基本类型的数组：

  • public static IntStream stream(int[] array)

  • public static LongStream stream(long[] array)

  • public static DoubleStream stream(double[] array)

@Test
public void test02(){
    int[] arr = new int[5];
    IntStream stream = Arrays.stream(arr);
​
    Employee e1 = new Employee(1001, "Tom");
    Employee e2 = new Employee(1002, "Jerry");
​
    Employee[] arr1 = new Employee[]{e1, e2};
    Stream stream1 = Arrays.stream(arr1);
}

4.3 创建Stream : 通过Stream的of方法

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

  • public static Stream of(T... values) : 返回一个流

@Test
public void test03(){
    Stream stream = Stream.of(1, 2, 3, 4);
}

4.4 创建Stream : 创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。造数据

迭代 public static Stream iterate(final T seed, final UnaryOperator f)

生成 public static Stream generate(Supplier s)

    /*
    创建Stream的方式四 : 通过无限流 -> 造数据
     */
    @Test
    public void test04(){
//        迭代
//        public static Stream iterate(final T seed, final UnaryOperator f)
        //遍历 : 从0开始的偶数 限制前十个数据
        Stream.iterate(0, t -> t+2).limit(10).forEach(System.out::println);
​
//        生成
//        public static Stream generate(Supplier s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
​
    }

5. Stream的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

5.1 筛选与切片

  • filter(Predicate p) : 接收 Lambda ， 从流中排除某些元素

  • distinct() : 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

  • limit(long maxSize) : 截断流，使其元素不超过给定数量

  • skip(long n) : 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

    //1. 筛选与切片
@Test
public void test01(){
    List list = EmployeeData.getEmployees();
    Stream stream = list.stream();
    //filter(Predicate p) :  接收 Lambda，从流中排除某些元素
    //练习 : 找出工资大于7000的员工
    stream.filter(employee -> employee.getSalary() > 7000).forEach(System.out::println);
    System.out.println();
​
    //limit(long maxSize) : 截断流，使其元素不超过给定数量
    //注意 stream 一旦执行了终止操作就关闭了 如果再次使用会报异常
    //java.lang.IllegalStateException: stream has already been operated upon or closed
    //练习 : 输出前三个员工信息
    list.stream().limit(3).forEach(System.out::println);
    System.out.println();
​
    //skip(long n) : 跳过元素，返回一个扔掉了前 n 个元素的流。
    // 若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
    //练习 : 跳过前三个员工
    list.stream().skip(3).forEach(System.out::println);
    System.out.println();
​
    //distinct() : 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
    list.add(new Employee(1009, "侯德阳", 20, 15500));
    list.add(new Employee(1009, "侯德阳", 20, 15500));
    list.add(new Employee(1009, "侯德阳", 20, 15500));
    list.add(new Employee(1009, "侯德阳", 20, 15500));
​
    list.stream().distinct().forEach(System.out::println);
}
/*
result : 
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
​
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
​
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
​
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=1009, name='侯德阳', age=20, salary=15500.0}
​
Process finished with exit code 0
​
*/

5.2 映射

  • map(Function f) : 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

  • mapToDouble(ToDoubleFunction f) : 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。

  • mapToInt(ToIntFunction f) : 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。

  • mapToLong(ToLongFunction f) : 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。

  • flatMap(Function f) : 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

    //2. 映射
@Test
public void test02(){
    //map(Function f) : 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
    List list = Arrays.asList("aa", "bb", "cc");
    list.stream().map(String::toUpperCase).forEach(System.out::println);
    System.out.println();
​
    //练习 : 获取员工姓名长度大于3的员工的姓名
    List employees = EmployeeData.getEmployees();
    employees.stream().map(Employee::getName).filter(str -> str.length() > 3).forEach(System.out::println);
    System.out.println();
​
    //通过map映射将每个字符串都转换为stream 形成streamStream 通过两次forEach遍历出来
    Stream> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
    streamStream.forEach(stream -> stream.forEach(System.out::println));
    System.out.println();
    //flatMap(Function f) : 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
    //如果使用 flatMap 就会自动将内层的stream拆开
    list.stream().flatMap(StreamAPITest1::fromStringToStream).forEach(System.out::println);
​
    //对于集合中套集合的方式 要遍历每一个元素 则使用flatMap
​
}
​
/**
 * @Description 将字符串转换为字符数组的Stream
 * @author hjc
 * @param str 输入的字符串
 * @returnType java.util.stream.Stream
 */
public static Stream fromStringToStream(String str){
    List list = new ArrayList<>();
​
    for (char character : str.toCharArray()){
        list.add(character);
    }
​
    return list.stream();
​
}
​
/*
result : 
AA
BB
CC
​
比尔盖茨
扎克伯格
​
a
a
b
b
c
c
​
a
a
b
b
c
c
​
Process finished with exit code 0
​
*/

5.3 排序

  • sorted() : 产生一个新流，其中按自然顺序排序

  • sorted(Comparator com) : 产生一个新流，其中按比较器顺序排序

    //3. 排序
@Test
public void test04(){
    List list = Arrays.asList(1, 6, 4, 3);
    //按照自然排序
    list.stream().sorted().forEach(System.out::println);
​
    List employees = EmployeeData.getEmployees();
    //按照年龄从小到大 按照工资从小到大
    employees.stream().sorted((e1, e2) -> {
        int ageValue = Integer.compare(e1.getAge(), e2.getAge());
        if (ageValue != 0){
            return ageValue;
        } else {
            return Double.compare(e1.getSalary(), e2.getSalary());
        }
    }).forEach(System.out::println);
}
/*
result : 
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1007, name='任正非', age=26, salary=4333.32}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
​
Process finished with exit code 0
 */

6. Stream的终止操作

6.1 匹配与查找

  • allMatch(Predicate p) : 检查是否匹配所有元素

  • anyMatch(Predicate p) : 检查是否至少匹配一个元素

  • noneMatch(Predicate p) : 检查是否没有匹配所有元素

  • findFirst() : 返回第一个元素

  • findAny() : 返回当前流中的任意元素

  • count() : 返回流中元素总数

  • max(Comparator c) : 返回流中最大值

  • min(Comparator c) : 返回流中最小值

  • forEach(Consumer c) : 内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)

    @Test
public void test01(){
    List employees = EmployeeData.getEmployees();
    //allMatch(Predicate p) : 检查是否匹配所有元素
    //练习 : 是否所有的员工年龄大于18岁
    boolean allMatch = employees.stream().allMatch(emp -> emp.getAge() > 18);
    System.out.println(allMatch);//false

    //anyMatch(Predicate p) : 检查是否至少匹配一个元素
    //练习 : 是否存在员工的工资大于10000
    boolean anyMatch = employees.stream().anyMatch(emp -> emp.getSalary() > 10000);
    System.out.println(anyMatch);//false

    //noneMatch(Predicate p) : 检查是否没有匹配所有元素
    //练习 : 是否存在员工姓'雷'
    boolean noneMatch = employees.stream().noneMatch(emp -> emp.getName().startsWith("雷"));
    System.out.println(noneMatch);//false

    //findFirst() : 返回第一个元素
    //找出工资最高的员工
    Optional employee = employees.stream()
            .sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary())).findFirst();
    System.out.println(employee);
    //Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]

    //findAny() : 返回当前流中的任意元素
    Optional anyEmployee = employees.stream().findAny();
    System.out.println(anyEmployee);
    //Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]

    //count() : 返回流中元素总数
    long count = employees.stream().filter(emp -> emp.getSalary() > 5000).count();
    System.out.println(count);//5

    //max(Comparator c) : 返回流中最大值
    //找出最高的工资
    Optional maxSalary = employees.stream().map(Employee::getSalary).max(Double::compare);
    System.out.println(maxSalary);//Optional[9876.12]

    //min(Comparator c) : 返回流中最小值
    //找出年龄最小员工
    Optional min = employees.stream().min((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
    System.out.println(min);
    //Optional[Employee{id=1002, name='马云', age=12, salary=9876.12}]

    //forEach(Consumer c) : 内部迭代
    employees.stream().forEach(System.out::println);

    //使用集合的遍历操作
    employees.forEach(System.out::println);
}
/*
result : 
false
false
false
Optional[Employee{id=1002, name='马云', age=12, salary=9876.12}]
Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]
5
Optional[9876.12]
Optional[Employee{id=1002, name='马云', age=12, salary=9876.12}]
*/

6.2 归约

  • reduce(T iden, BinaryOperator b) : 可以将流中元素反复结合起来，得到一个值。返回 T

  • reduce(BinaryOperator b) : 可以将流中元素反复结合起来，得到一个值。返回 Optional

说明 : map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。

    //2. 归约
    @Test
    public void test02(){
        //reduce(T iden, BinaryOperator b) : 可以将流中元素反复结合起来，得到一个值。返回 T
        //计算 1-10 的自然数的和
        List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        //reduce的第一个参数是初始值
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);//55

        //reduce(BinaryOperator b) : 可以将流中元素反复结合起来，得到一个值。返回 Optional
        List employees = EmployeeData.getEmployees();
        Optional sumSalary = employees.stream().map(Employee::getSalary).reduce(Double::sum);
//        employees.stream().map(Employee::getSalary).reduce((d1, d2) -> d1 + d2);
        System.out.println(sumSalary);//Optional[48424.08]
    }

6.3 收集

  • collect(Collector c) : 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。

另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。

//3. 收集
@Test
public void test04(){
    //collect(Collector c) : 将流转换为其他形式。
    // 接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
    //练习 : 查找工资大于6000的员工 结果返回一个List或Set
    List employees = EmployeeData.getEmployees();
    List collect = employees.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toList());
    collect.forEach(System.out::println);
    System.out.println();
    Set collectSet = employees.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toSet());
    collectSet.forEach(System.out::println);
}
/*
result : 
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}

Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1004, name='雷军', age=26, salary=7657.37}

Process finished with exit code 0
*/

五、Optional类

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

1. 创建Optional类对象

  • Optional.of(T t) : 创建一个 Optional 实例，t必须非空；

  • Optional.empty() : 创建一个空的 Optional 实例

  • Optional.ofNullable(T t) : t 可以为null

        /*
    创建Optional类对象
     */
    @Test
    public void test01(){
        Girl girl = new Girl();
//        girl = null;
        //of() : 创建一个Optional实例,t必须是非空的
        Optional optionalGirl = Optional.of(girl);
        System.out.println(optionalGirl);//Optional[Girl{name='null'}]

        //empty() : 创建一个空的Optional实例
        Optional objectOptional = Optional.empty();
        System.out.println(objectOptional);//Optional.empty

        //ofNullable() : t 可以为null
        girl = null;
        Optional optionalGirl1 = Optional.ofNullable(girl);
        System.out.println(optionalGirl1);//Optional.empty
    }  
   
  
    2. Optional类的常用方法
     
  
    判断Optional容器中是否包含对象：
     
  
       
   
    •  
      boolean isPresent() :  判断是否包含对象
       
      •  
   
    •  
      void ifPresent(Consumer consumer) : 如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
       
      •  
  
     
  
    获取Optional容器的对象：
     
  
       
   
    •  
      T get() :  如果调用对象包含值，返回该值，否则抛异常
       
      •  
   
    •  
      T orElse(T other) : 如果有值则将其返回，否则返回指定的other对象。
       
      •  
   
    •  
      T orElseGet(Supplier other) : 如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
       
      •  
   
    •  
      T orElseThrow(Supplier exceptionSupplier) : 如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
       
      /*
of()方法与get()方法搭配使用
*/
@Test
public void test06(){

    Boy boy = new Boy();
    Optional optionalBoy = Optional.of(boy);
    System.out.println(optionalBoy.isPresent());//true
    optionalBoy.ifPresent(System.out::println);//Boy{girl=null}
    
	//通常与of方法搭配使用 用于获取封装的数据
    Boy boy1 = optionalBoy.get();
    System.out.println(boy1);//Boy{girl=null}

}
/*
ofNullable()与orElse()搭配使用
 */
@Test
public void test02(){
    String str = "北京";
    str = null;

    Optional optionalS = Optional.ofNullable(str);
    String s = optionalS.orElse("上海");

    System.out.println(s);
}
       
      •  
  
     
  
    3. Optional类使用举例
     
  
    为了在程序中避免出现空指针异常
     
  
    /*
Optional类使用举例
 */
public String getGirlName(Boy boy){
    return boy.getGirl().getName();
}

/*
使用Optional类之前
 */
@Test
public void test02(){
    Boy boy = new Boy();
    String girlName = getGirlName(boy);
    System.out.println(girlName);
}

//优化以后的getGirlName方法 :
public String getGirlName1(Boy boy){
    if (boy != null){
        Girl girl = boy.getGirl();
        if (girl != null){
            return girl.getName();
        }
    }
    return null;
}
@Test
public void test04(){
    Boy boy = new Boy();
    String girlName1 = getGirlName1(boy);
    System.out.println(girlName1);//null
}

//使用Optional类后的getGirlName方法 :
public String getGirlName2(Boy boy){
    //将boy包装进Optional中
    Optional optionalBoy = Optional.ofNullable(boy);

    //此时返回的boy一定是非空的
    Boy boy1 = optionalBoy.orElse(new Boy());

    Girl girl = boy1.getGirl();

    Optional optionalGirl = Optional.ofNullable(girl);
    //此时返回的girl1一定是非空的
    Girl girl1 = optionalGirl.orElse(new Girl("迪丽热巴"));

    return girl1.getName();
}

@Test
public void test05(){
    Boy nullBoy = null;
    String girlName2 = getGirlName2(nullBoy);
    System.out.println(girlName2);//迪丽热巴

    Boy boy = new Boy(new Girl("古力娜扎"));
    String girlName21 = getGirlName2(boy);
    System.out.println(girlName21);//古力娜扎
}
     
  
     
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(Java高级编程,java,jvm,面试)
    
        
    
            
    
                
      
                    
    • Long类型前后端数据不一致
                        igotyback
前端
                        
      响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
      
                    
      • 
                    
    • LocalDateTime 转 String
                        igotyback
java开发语言
                        
      importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
      
                    
      • 
                    
    • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
      
                    
      • 
                    
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      
                    
      • 
                    
    • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
      华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
      
                    
      • 
                    
    • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
      ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
      
                    
      • 
                    
    • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
      Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
      
                    
      • 
                    
    • python八股文面试题分享及解析(1)
                        Shawn________
python
                        
      #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
      
                    
      • 
                    
    • MYSQL面试系列-04
                        king01299
面试mysql面试
                        
      MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
      
                    
      • 
                    
    • Kafka 消息丢失如何处理？
                        架构文摘JGWZ
学习
                        
      今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
      
                    
      • 
                    
    • 每日算法&面试题，大厂特训二十八天——第二十天（树）
                        肥学
⚡算法题⚡面试题每日精进java算法数据结构
                        
      目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
      
                    
      • 
                    
    • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
      node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
      
                    
      • 
                    
    • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
      华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
      
                    
      • 
                    
    • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
      华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
      
                    
      • 
                    
    • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面
                        一个射手座的程序媛
程序员华为od面试职场和发展
                        
      最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
      
                    
      • 
                    
    • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
                        算法大师
华为od面试python
                        
      华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
      
                    
      • 
                    
    • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
      Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
      
                    
      • 
                    
    • 简单了解 JVM
                        记得开心一点啊
jvm
                        
      目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
      
                    
      • 
                    
    • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
      1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
      
                    
      • 
                    
    • Java企业面试题3
                        马龙强_
java
                        
      1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
      
                    
      • 
                    
    • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
      Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
      
                    
      • 
                    
    • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
      一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
      
                    
      • 
                    
    • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
      欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
      
                    
      • 
                    
    • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
      在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
      
                    
      • 
                    
    • 2019考研 | 西交大软件工程
                        笔者阿蓉

                        
      本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
      
                    
      • 
                    
    • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
      ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
      
                    
      • 
                    
    • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
      一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
      
                    
      • 
                    
    • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
      一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
      
                    
      • 
                    
    • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
      发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
      
                    
      • 
                    
    • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
      在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
      
                    
      • 
                                
    • Java常用排序算法/程序员必须掌握的8大排序算法
                                    cugfy
java
                                    
      分类： 
 
1）插入排序（直接插入排序、希尔排序） 
2）交换排序（冒泡排序、快速排序） 
3）选择排序（直接选择排序、堆排序） 
4）归并排序 
5）分配排序（基数排序） 
 
所需辅助空间最多：归并排序 
所需辅助空间最少：堆排序 
平均速度最快：快速排序 
 
不稳定：快速排序，希尔排序，堆排序。 
 
先来看看8种排序之间的关系： 
 
  
 
 1.直接插入排序 
 
（1
      
                                
      • 
                                
    • 【Spark102】Spark存储模块BlockManager剖析
                                    bit1129
manager
                                    
      Spark围绕着BlockManager构建了存储模块，包括RDD，Shuffle，Broadcast的存储都使用了BlockManager。而BlockManager在实现上是一个针对每个应用的Master/Executor结构，即Driver上BlockManager充当了Master角色，而各个Slave上(具体到应用范围，就是Executor)的BlockManager充当了Slave角色
      
                                
      • 
                                
    • linux 查看端口被占用情况详解
                                    daizj
linux端口占用netstatlsof
                                    
      经常在启动一个程序会碰到端口被占用，这里讲一下怎么查看端口是否被占用，及哪个程序占用，怎么Kill掉已占用端口的程序 
  
1、lsof -i:port 
port为端口号 
  
[root@slave /data/spark-1.4.0-bin-cdh4]# lsof -i:8080 
COMMAND   PID USER   FD   TY
      
                                
      • 
                                
    • Hosts文件使用
                                    周凡杨
hostslocahost
                                    
           一切都要从localhost说起，经常在tomcat容器起动后，访问页面时输入http://localhost:8088/index.jsp，大家都知道localhost代表本机地址，如果本机IP是10.10.134.21，那就相当于http://10.10.134.21:8088/index.jsp，有时候也会看到http: 127.0.0.1:
      
                                
      • 
                                
    • java excel工具
                                    g21121
Java excel
                                    
      直接上代码，一看就懂，利用的是jxl： 
import java.io.File;
import java.io.IOException;
import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;
import jxl.read.biff.BiffException;
import jxl.write.Label;
import 
      
                                
      • 
                                
    • web报表工具finereport常用函数的用法总结（数组函数）
                                    老A不折腾
finereportweb报表函数总结
                                    
      ADD2ARRAY 
ADDARRAY(array,insertArray, start):在数组第start个位置插入insertArray中的所有元素，再返回该数组。 
示例： 
ADDARRAY([3,4, 1, 5, 7], [23, 43, 22], 3)返回[3, 4, 23, 43, 22, 1, 5, 7]. 
ADDARRAY([3,4, 1, 5, 7], "测试&q
      
                                
      • 
                                
    • 游戏服务器网络带宽负载计算
                                    墙头上一根草
服务器
                                    
      家庭所安装的4M，8M宽带。其中M是指，Mbits/S 
其中要提前说明的是： 
8bits = 1Byte 
即8位等于1字节。我们硬盘大小50G。意思是50*1024M字节，约为 50000多字节。但是网宽是以“位”为单位的，所以，8Mbits就是1M字节。是容积体积的单位。 
8Mbits/s后面的S是秒。8Mbits/s意思是 每秒8M位，即每秒1M字节。 
我是在计算我们网络流量时想到的
      
                                
      • 
                                
    • 我的spring学习笔记2-IoC（反向控制 依赖注入）
                                    aijuans
Spring 3 系列
                                    
      IoC（反向控制 依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 
IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明： 
如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
      
                                
      • 
                                
    • 高性能mysql 之 选择存储引擎(一)
                                    annan211
mysqlInnoDBMySQL引擎存储引擎
                                    
        1 没有特殊情况，应尽可能使用InnoDB存储引擎。   原因：InnoDB 和 MYIsAM 是mysql 最常用、使用最普遍的存储引擎。其中InnoDB是最重要、最广泛的存储引擎。她   被设计用来处理大量的短期事务。短期事务大部分情况下是正常提交的，很少有回滚的情况。InnoDB的性能和自动崩溃   恢复特性使得她在非事务型存储的需求中也非常流行，除非有非常
      
                                
      • 
                                
    • UDP网络编程
                                    百合不是茶
UDP编程局域网组播
                                    
        
UDP是基于无连接的,不可靠的传输   与TCP/IP相反 
  
  
  
UDP实现私聊,发送方式客户端,接受方式服务器 
package netUDP_sc;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Ine
      
                                
      • 
                                
    • JQuery对象的val()方法执行结果分析
                                    bijian1013
JavaScriptjsjquery
                                    
              JavaScript中，如果id对应的标签不存在（同理JAVA中，如果对象不存在），则调用它的方法会报错或抛异常。在实际开发中，发现JQuery在id对应的标签不存在时，调其val()方法不会报错，结果是undefined。 
        
      
                                
      • 
                                
    • http请求测试实例（采用json-lib解析）
                                    bijian1013
jsonhttp
                                    
              由于fastjson只支持JDK1.5版本，因些对于JDK1.4的项目，可以采用json-lib来解析JSON数据。如下是http请求的另外一种写法，仅供参考。 
package com;

import java.util.HashMap;
import java.util.Map;

import 
      
                                
      • 
                                
    • 【RPC框架Hessian四】Hessian与Spring集成
                                    bit1129
hessian
                                    
      在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中介绍了基于Hessian的RPC服务的实现步骤，在那里使用Hessian提供的API完成基于Hessian的RPC服务开发和客户端调用，本文使用Spring对Hessian的集成来实现Hessian的RPC调用。 
  定义模型、接口和服务器端代码 
|---Model 
   &nb
      
                                
      • 
                                
    • 【Mahout三】基于Mahout CBayes算法的20newsgroup流程分析
                                    bit1129
Mahout
                                    
      1.Mahout环境搭建 
 1.下载Mahout 
http://mirror.bit.edu.cn/apache/mahout/0.10.0/mahout-distribution-0.10.0.tar.gz 
  
 2.解压Mahout 
 3. 配置环境变量 
vim /etc/profile

export HADOOP_HOME=/home
      
                                
      • 
                                
    • nginx负载tomcat遇非80时的转发问题
                                    ronin47

                                    
      　　nginx负载后端容器是tomcat（其它容器如WAS,JBOSS暂没发现这个问题）非８０端口，遇到跳转异常问题。解决的思路是：$host:port 
       详细如下： 
　　  
该问题是最先发现的，由于之前对nginx不是特别的熟悉所以该问题是个入门级别的：    
?       1   2   3   4   5   
      
                                
      • 
                                
    • java-17-在一个字符串中找到第一个只出现一次的字符
                                    bylijinnan
java
                                    
      

public class FirstShowOnlyOnceElement {

	/**Q17.在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b
	 * 1.int[] count:count[i]表示i对应字符出现的次数
	 * 2.将26个英文字母映射：a-z <--> 0-25
	 * 3.假设全部字母都是小写
	 */
	pu
      
                                
      • 
                                
    • mongoDB 复制集
                                    开窍的石头
mongodb
                                    
      mongo的复制集就像mysql的主从数据库，当你往其中的主复制集(primary)写数据的时候，副复制集(secondary)会自动同步主复制集(Primary)的数据,当主复制集挂掉以后其中的一个副复制集会自动成为主复制集。提供服务器的可用性。和防止当机问题 
       
 
     mo
      
                                
      • 
                                
    • [宇宙与天文]宇宙时代的经济学
                                    comsci
经济
                                    
       
    宇宙尺度的交通工具一般都体型巨大，造价高昂。。。。。 
 
     在宇宙中进行航行，近程采用反作用力类型的发动机，需要消耗少量矿石燃料，中远程航行要采用量子或者聚变反应堆发动机，进行超空间跳跃，要消耗大量高纯度水晶体能源 
 
     以目前地球上国家的经济发展水平来讲，
      
                                
      • 
                                
    • Git忽略文件
                                    Cwind
git
                                    
           有很多文件不必使用git管理。例如Eclipse或其他IDE生成的项目文件，编译生成的各种目标或临时文件等。使用git status时，会在Untracked files里面看到这些文件列表，在一次需要添加的文件比较多时（使用git add . / git add -u），会把这些所有的未跟踪文件添加进索引。  
   ==== ==== ==== 一些牢骚
      
                                
      • 
                                
    • MySQL连接数据库的必须配置
                                    dashuaifu
mysql连接数据库配置
                                    
      MySQL连接数据库的必须配置 
  
1.driverClass：com.mysql.jdbc.Driver 
  
2.jdbcUrl：jdbc:mysql://localhost:3306/dbname 
  
3.user：username 
  
4.password：password 
  
其中1是驱动名；2是url，这里的‘dbna
      
                                
      • 
                                
    • 一生要养成的60个习惯
                                    dcj3sjt126com
习惯
                                    
      一生要养成的60个习惯 
第1篇 让你更受大家欢迎的习惯 
1 守时，不准时赴约,让别人等,会失去很多机会。 
如何做到： 
①该起床时就起床， 
②养成任何事情都提前15分钟的习惯。 
③带本可以随时阅读的书，如果早了就拿出来读读。 
④有条理，生活没条理最容易耽误时间。 
⑤提前计划：将重要和不重要的事情岔开。 
⑥今天就准备好明天要穿的衣服。 
⑦按时睡觉，这会让按时起床更容易。 
2 注重
      
                                
      • 
                                
    • [介绍]Yii 是什么
                                    dcj3sjt126com
PHPyii2
                                    
      Yii 是一个高性能，基于组件的 PHP 框架，用于快速开发现代 Web 应用程序。名字 Yii （读作 易）在中文里有“极致简单与不断演变”两重含义，也可看作 Yes It Is! 的缩写。  
Yii 最适合做什么？ 
Yii 是一个通用的 Web 编程框架，即可以用于开发各种用 PHP 构建的 Web 应用。因为基于组件的框架结构和设计精巧的缓存支持，它特别适合开发大型应
      
                                
      • 
                                
    • Linux SSH常用总结
                                    eksliang
linux sshSSHD
                                    
      转载请出自出处：http://eksliang.iteye.com/blog/2186931 一、连接到远程主机 
  
格式：
ssh name@remoteserver
例如：
ssh [email protected] 
  二、连接到远程主机指定的端口 
  
格式：
ssh name@remoteserver -p 22
例如：
ssh i
      
                                
      • 
                                
    • 快速上传头像到服务端工具类FaceUtil
                                    gundumw100
android
                                    
      快速迭代用 
 
 

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOExceptio
      
                                
      • 
                                
    • jQuery入门之怎么使用
                                    ini
JavaScripthtmljqueryWebcss
                                    
      jQuery的强大我何问起（个人主页：hovertree.com）就不用多说了，那么怎么使用jQuery呢？ 
  
首先，下载jquery。下载地址：http://hovertree.com/hvtart/bjae/b8627323101a4994.htm，一个是压缩版本，一个是未压缩版本，如果在开发测试阶段，可以使用未压缩版本，实际应用一般使用压缩版本(min)。然后就在页面上引用。
      
                                
      • 
                                
    • 带filter的hbase查询优化
                                    kane_xie
查询优化hbaseRandomRowFilter
                                    
       
 问题描述 
 
hbase scan数据缓慢，server端出现LeaseException。hbase写入缓慢。     
 
 问题原因 
 
直接原因是：  hbase client端每次和regionserver交互的时候，都会在服务器端生成一个Lease,Lease的有效期由参数hbase.regionserver.lease.period确定。如果hbase scan需
      
                                
      • 
                                
    • java设计模式-单例模式
                                    men4661273
java单例枚举反射IOC
                                    
               单例模式1，饿汉模式 
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
    //私有的默认构造函数
    private Singleton1() {}
    //已经自行实例化
    private static final Singleton1 singl
      
                                
      • 
                                
    • mongodb 查询某一天所有信息的3种方法，根据日期查询
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
      // mongodb的查询真让人难以琢磨，就查询单天信息，都需要花费一番功夫才行。

// 第一种方式：
coll.aggregate([
          {$project:{sendDate: {$substr: ['$sendTime', 0, 10]}, sendTime: 1, content:1}},
          {$match:{sendDate: '2015-
      
                                
      • 
                                
    • 二维数组转换成JSON
                                    tangqi609567707
java二维数组json
                                    
      原文出处：http://blog.csdn.net/springsen/article/details/7833596 
public class Demo { 
    public static void main(String[] args) {        String[][] blogL
      
                                
      • 
                                
    • erlang supervisor
                                    wudixiaotie
erlang
                                    
      定义supervisor时，如果是监控celuesimple_one_for_one则删除children的时候就用supervisor:terminate_child (SupModuleName, ChildPid)，如果shutdown策略选择的是brutal_kill，那么supervisor会调用exit(ChildPid, kill)，这样的话如果Child的behavior是gen_
      
                                
      •