Java 8学习笔记随记

一、Dos命令

1、打开方式：

        ①、打开快捷键：Windows+R键输入cmd

        ②、任意文件夹下，按住shift键+鼠标右键点击打开命令行窗口

        ③、资源管理器的地址栏加上cmd路径

        ④、管理员方式运行

2、Dos命令

       ①、 #盘符切换：  输入想要进入的盘符+冒号；如：E：回车

       ②、查看当前目录下的所有文件：dir

        ③、切换目录：cd /d f:

        ④、返回上一级：cd..

二、日常学习

1.XML和YAML的区别

        xml：可扩展性标记语言，用来标记数据，定义数据类型，适合web传输，仅仅存储数据；通过Javascript读写xml数据；特点：1.区分大小写2.所有的标签成对出现

        yaml：比xml更易读懂的序列化语言，Structure通过空格来展示。Sequence里的项用"-"来代表，Map里的键值对用":"分隔.

        yaml相比xml优点：1.脚本语言交互性好；2.可读性好；3.实现语言的数据类型；4.有一个一致的信息模型；5.易于实现。

2.在maven项目中对于端口、数据驱动类的配置在application.yml配置文件中。对于redis、数据库等数据源在application-dev.yml中配置；

3.数据库连接池：Durid（最好的数据库连接池）、DBCP、C3P0、BoneCP、Proxool、JBoss、DateSource。

        Durid：是一个JDBC组件，包含三部分：基于Filter（过滤器）——Chain模式的插件体系、DuridSource（高效可管理的数据库连接池）、SQLParser；Durid功能：1.提供一个高效、功能强大、可扩展性好的数据库连接池；2.可以监控数据库访问性能，Durid内部提供StatFilter插件，能够详细统计SQL的执行性能，对于线上数据库访问性能有帮助。3.数据库密码加密。直接把数据库密码写在配置文件中是不好的行为，容易导致安全问题。DuridDriver和DuridDataSource都支持PassWordCallback。4.SQL执行日志，Durid提供了不同的LogFilter，能够支持Common-Logging、Log4j狠人JDKLog，可以按需要选择相应的LogFilter，监控数据库的访问情况。5.扩展JDBC，如果要对JDBC层有编程的需求，可以通过Druid提供的Filter机制，很方便JDBC层的扩展插件。

4.knife4j：Java MVC框架集成Swagger生成API文档解决

5.Lamda

        定义：一种简洁、可传递的匿名函数，虽不属于某个特定的类，但具备参数列表，函数主体，返回类型，甚至能够报出异常。允许把函数作为一个方法的参数进行传递。可以把函数作为一个方法的参数。

        格式：参数列表 ->表达式 、参数列表 ->{表达式集}。当为单个表达式时不需要加return，隐含return关键字，当为表达式集时需要加return关键字。

        例如：返回字符串长度：

（String str）->str.length();

                返回233的无参方法：

（）-> 233;

                返回当前用户的年龄是否大于20岁，返回一个boolean值：

（User user）-> user.getAge()>20;

                包含多行表达式，需要return的关键字返回：

（int x,int y）->{
     int z = x*y;
     return z+x;
}

          关于Lambda的异常抛出问题：

                1.添加FunctionInterface，用于对函数式接口的检查，非函数式接口使用回报错，但是函数式接口可使用，也可不适用，不会报错，只是不会检查。     

具体操作如下：定义一个Try类：       

public class Try {
 
    public static  Function of(UncheckedFunction mapper) {
        Objects.requireNonNull(mapper);
        return t -> {
            try {
                return mapper.apply(t);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        };
    }
 
    @FunctionalInterface
    public static interface UncheckedFunction {
 
        R apply(T t) throws Exception;
    }
}

例如：对于一个数字集合进行依次除法，当除到0时就不回报出异常

Listintegers=Arrays.asList(1,2,3,4,5,6,0);
integers.forEach(Try.of(i->System.out.println(50/i)));

6.Stream（流）

作用：用于对于集合的处理，如对于集合的筛选，投影等

特点：1.只遍历一次，一旦结束，无法对于流进行操作，可以新建流进行遍历；2.采用内部迭代，写代码进行处理属于外部迭代，流处理，只需要告诉想要的结果，流去处理，属于内部迭代。

流的两个操作：1.中间操作：一旦把数据源放到流水线上，之后对于流水线的操作都属于中间操作，也就是说，一个流水线可以有多个中间操作串和起来。2.终端操作：终端操作指的是流水线的中间操作都结束，你想要获得这个数据，则需要将数据将流水线上拿下来，则需要这个终端操作返回一个执行过程，拿到数据。

流的操作过程：1.准备数据源 2.进行中间操作（可多个，组成一个流水线）3.终端操作（执行终端操作之后，流结束，而你会获得一个执行结果）。

1.list的转换

//转Stream
list.stream();
//并发处理
list.parallelStream();

 2.filter

Stream filter(Predicate predicate);

3.map（元素转换）

 Stream map(Function mapper);
IntStream mapToInt(ToIntFunction mapper);
LongStream mapToLong(ToLongFunction mapper);
DoubleStream mapToDouble(ToDoubleFunctionT mapper);

4.flatMap(元素转换)

 Stream flatMap(Function> mapper); 
IntStream flatMapToInt(Function mapper); 
LongStream flatMapToLong(Function mapper); 
DoubleStream flatMapToDouble(Function mapper);

5.distinct（去除重复，对象需要重写 equals、hashCode）    

Stream distinct();

6.sorted排序

Stream sorted(); 
Stream sorted(Comparator comparator);

7.peek（生成新的流：流是单向的，例如用于日志打印） 

Stream peek(Consumer action);

8.limit（取前面 n 个元素）

Stream limit(long maxSize);

9.skip（跳过 n 个元素） 

Stream skip(long n);

10.forEach（遍历）

void forEach(Consumer action); 
void forEachOrdered(Consumer action);

11.toArray（转换成数组） 

Object[] toArray(); 
 A[] toArray(IntFunction generator);

12.reduce（结果归并）  

T reduce(T identity, BinaryOperator accumulator);
Optional reduce(BinaryOperator accumulator); 
 U reduce(U identity, BiFunction accumulator
, BinaryOperator combiner);

 R collect(Supplier supplier, BiConsumer accumulator
, BiConsumer combiner);
 R collect(Collector collector);

// 转list 
Collectors.toList(); 
// 转set 
Collectors.toSet(); 
// 转map 
List testList = new ArrayList<>(10); 
Map data = releaseList.stream() 
                            .collect(Collectors
                            .toMap(TestVo::getId, x -> x));

long count();

boolean anyMatch(Predicate predicate); 
boolean allMatch(Predicate predicate); 
boolean noneMatch(Predicate predicate);

Optional findFirst(); 
Optional findAny();

List list = new ArrayList(); 
Stream stream = list.stream();

String[] names = {"chaimm","peter","john"}; 
Stream stream = Arrays.stream(names);

Stream stream = Stream.of("chaimm","peter","john");

try(Stream lines = Files.lines(Paths.get(“文件路径名”)
                    ,Charset.defaultCharset())){ //可对lines做一些操作 }
catch(IOException e){ }

Stream.iterate(0, n -> n + 2) 
    .limit(10)
    .forEach(System.out::println);

List result = list.stream() 
                          .filter(Person::isStudent) 
                          .collect(toList());

List result = list.stream() 
                          .distinct() 
                          .collect(toList());

List result = list.stream()
                         .limit(3) 
                         .collect(toList());

List result = list.stream() 
                          .skip(3) 
                          .collect(toList());

List result = list.stream() 
                        .map(Person::getName) 
                        .collect(toList());

List list = new ArrayList(); 
list.add("I am a boy"); 
list.add("I love the girl"); 
list.add("But the girl loves another girl");

list.stream() //将list变成流
    .map(line->line.split(" ")) //将各个单词以空格分开，变成String[],成为各个String[]
    .flatMap(Arrays::stream) //将各个String[]变成小流并合并，将map转换成flatmap
    .distinct() //去重
    .collect(toList());//获得结果集

boolean result = list.stream() 
                    .anyMatch(Person::isStudent);

boolean result = list.stream() 
                     .allMatch(Person::isStudent);

boolean result = list.stream() 
                    .noneMatch(Person::isStudent);

Optional person = list.stream().findAny();

@Test 
public void contextLoads() { 
    List list = new ArrayList<>(); 
    list.add(new Person().setAge(20)); 
    list.add(new Person().setAge(25)); 
    int age = list.stream().map(Person::getAge).reduce(0, Integer::sum);                                 
    System.out.println(age); 
}

@Data 
@Accessors(chain = true) 
class Person { 
    int age; 
}

int age = list.stream().reduce(0, Integer::sum);

IntStream stream=list.stream().mapToInt(Person::getAge);

OptionalInt maxAge = list.stream()
                        .mapToInt(Person::getAge)
                        .max();