csv又有叫做Char-separated values（字符分隔值类型），通过字符值进行分隔。

但因为半角逗号在数据中出现的的可能性比较大，所以经常会使用文本包装符来标识逗号为数据中的一部分，或者直接使用其它特殊符号作为分隔符。

二、csv文件规范

三、csv使用场景

四、Java中的csv类库

1. javacsv

2. opencsv

<dependency>
    <groupId>com.opencsv</groupId>
    <artifactId>opencsv</artifactId>
    <version>5.6</version>
</dependency>
12345
名称
描述
CSVWriter
简单的CSV写入器
CSVParserWriter
通过CSVParser解析数据的写入器
StatefulBeanToCsv
直接将bean写入CSV的写入器
注解
描述
主要属性
@CsvBindByName
按表头名称绑定
required：必须字段,默认为false.该字段为空抛异常 column：对象列标题名称
@CsvBindByPosition
按位置绑定
required：必须字段,默认为false.该字段为空抛异常 position：位置索引
@CsvCustomBindByName
与CsvBindByName相同，但必须提供自己的数据转换类
required：必须字段,默认为false.该字段为空抛异常 column：对象列标题名称 converter：转换器
@CsvCustomBindByPosition
与CsvBindByPosition相同，但必须提供自己的数据转换类
required：必须字段,默认为false.该字段为空抛异常 column：对象列标题名称 converter：转换器
@CsvBindAndJoinByName
应用于MultiValuedMap集合类型的bean字段，通过标题名称绑定
required：必须字段,默认为false.该字段为空抛异常 column：对象列标题名称 converter：转换器 mapType：集合类型 elementTyp：元素类型
@CsvBindAndJoinByPosition
应用于MultiValuedMap集合类型的bean字段，通过位置索引绑定
required：必须字段,默认为false.该字段为空抛异常 position：位置索引 converter：转换器 mapType：集合类型 elementTyp：元素类型
@CsvBindAndSplitByName
应用于Collection集合类型的bean字段，通过标题名称绑定
required：必须字段,默认为false.该字段为空抛异常 column：对象列标题名称 converter：转换器 mapType：集合类型 elementTyp：元素类型 splitOn：
@CsvBindAndSplitByPosition
应用于Collection集合类型的bean字段，通过位置索引绑定
required：必须字段,默认为false.该字段为空抛异常 position：位置索引 converter：转换器 mapType：集合类型 elementTyp：元素类型 splitOn：
@CsvDate
应用于日期/时间类型的bean字段，与上面相关的绑定注解结合使用
value：日期格式，例如：yyyy-MM-dd
@CsvNumber
应用于数字类型的bean字段，与上面相关的绑定注解结合使用
value：数字格式，例如：000.###
名称
描述
重要方法
方法描述
ColumnPositionMappingStrategy
列位置映射策略，用于没有头文件（标题行）的文件
setColumnMapping(String… columnMapping
设置要映射的列名集合，集合下标即为列写入顺序
HeaderColumnNameMappingStrategy
标题列名称映射策略，
setColumnOrderOnWrite(Comparator writeOrder)
通过比较器，设置列写入顺序
HeaderColumnNameTranslateMappingStrategy
标题列名称翻译映射策略 bean的属性名可以与csv列头不一样，通过指定map来映射。
setColumnMapping(Map<String, String> columnMapping)
设置标题名与列名的映射
FuzzyMappingStrategy

① ColumnPositionMappingStrategy
使用该映射策略需要csv文件没有标题行。该策略通过设置列的下标位置来指定列的顺序，有两种方式来设置列的下标：
通过CsvBindByPosition、CsvCustomBindByPosition、CsvBindAndJoinByPosition、CsvBindAndSplitByPosition注解来设置列的下标
通过setColumnMapping(String… columnMapping)方法来设置列的下标
② HeaderColumnNameMappingStrategy
该映射策略用于有标题行的csv文件。该策略通过指定比较器来指定列的顺序：
通过setColumnOrderOnWrite(Comparator writeOrder)指定比较器
关于标题列的名称：
默认使用bean的字段名称大写作为标题列的名称
如果使用CsvBindByName、CsvCustomBindByName、CsvBindAndJoinByName、CsvBindAndSplitByName注解的column属性指定列名称，则使用该值，否则使用bean的字段名称大写作为标题列的名称
③ HeaderColumnNameTranslateMappingStrategy
该映射策略用于有标题行的csv文件。该策略通过映射Map来指定标题列名与bean的属性名映射关系。
映射Map的key=标题列名，value=bean的属性名。
需要注意：
该映射策略只适用于读取csv文件时，指定标题列名与bean的属性名的映射关系
该映射策略不适用于写入csv文件时，指定bean的属性名与标题列名的映射关系（不要误解）
名称
描述
CSVWriterBuilder
CSV写入构建器，构建CSVWriter或CSVParserWriter
StatefulBeanToCsvBuilder
对象写入CSV构建器，构建StatefulBeanToCsv
CSVReaderBuilder
CSV读取构建器，构建CSVReader
CsvToBeanBuilder
CSV读取对象构建器，构建CsvToBean
CSVReaderHeaderAwareBuilder
构建CSVReaderHeaderAware
CSVParserBuilder
CSV解析器构造器，构建CSVParser
RFC4180ParserBuilder
RFC4180解析器构造器，构建RFC4180Parser
User类：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    public String userId;
    public String userName;
    public String sex;
123456789101112
User1类：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User1 {
    @CsvBindByPosition(position = 0)
    public String userId;
    @CsvBindByPosition(position = 1)
    public String userName;
    @CsvBindByPosition(position = 2)
    public String sex;
1234567891011121314
User2类：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User2 {
    @CsvBindByName(column = "用户ID")
    public String userId;
    @CsvBindByName(column = "用户名")
    public String userName;
    @CsvBindByName(column = "性别")
    public String sex;
1234567891011121314
① 简单的写入

CSVWriter的主要参数：
Writer writer：指定需要写入的源文件
char separator：分隔符（默认逗号）
char quotechar：文本边界符（默认双引号）
如果数据中包含分隔符，需要使用文本边界符包裹数据。通常用双引号、单引号或斜杠作为文本边界符
char escapechar：转义字符（默认双引号）
String lineend：行分隔符（默认为\n）
使用方法：
     * 简单的写入
     * @throws Exception
    private static void csvWriter() throws Exception {
        // 写入位置
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        // 标题行
        String[] titleRow = {"用户ID", "用户名", "性别"};
        // 数据行
        ArrayList<String[]> dataRows = new ArrayList<>();
        String[] dataRow1 = {"1", "张三", "男"};
        String[] dataRow2 = {"2", "李四", "男"};
        String[] dataRow3 = {"3", "翠花", "女"};
        dataRows.add(dataRow1);
        dataRows.add(dataRow2);
        dataRows.add(dataRow3);
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(fileName), Charset.forName("UTF-8"));
        // 1. 通过new CSVWriter对象的方式直接创建CSVWriter对象
        // CSVWriter csvWriter = new CSVWriter(writer);
        // 2. 通过CSVWriterBuilder构造器构建CSVWriter对象
        CSVWriter csvWriter = (CSVWriter) new CSVWriterBuilder(writer)
                .build();
        // 写入标题行
        csvWriter.writeNext(titleRow, false);
        // 写入数据行
        csvWriter.writeAll(dataRows, false);
        csvWriter.close();
12345678910111213141516171819202122232425262728293031
demo.csv内容：
用户ID,用户名,性别
1,张三,男
2,李四,男
3,翠花,女
② 基于位置映射的写入

使用方法：
     * 基于位置映射的写入
     * @throws Exception
    private static void beanToCsvByPosition() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        List<User> list = new ArrayList<>();
        list.add(new User("1", "张三", "男"));
        list.add(new User("2", "李四", "男"));
        list.add(new User("3", "翠花", "女"));
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(fileName), Charset.forName("UTF-8"));
        ColumnPositionMappingStrategy<User> strategy = new ColumnPositionMappingStrategy();
        // 未指定的列不写入
        String[] columns = new String[] { "userId", "userName", "sex"};
        strategy.setColumnMapping(columns);
        strategy.setType(User.class);
        // 如果需要标题行，可这样写入
        // CSVWriter csvWriter = (CSVWriter) new CSVWriterBuilder(writer)
        //         .build();
        // String[] titleRow = {"用户ID", "用户名", "性别"};
        // csvWriter.writeNext(titleRow, false);
        StatefulBeanToCsv<User> statefulBeanToCsv = new StatefulBeanToCsvBuilder<User>(writer)
                .withMappingStrategy(strategy)
                .withApplyQuotesToAll(false)
                .build();
        statefulBeanToCsv.write(list);
        writer.close();
1234567891011121314151617181920212223242526272829303132
demo.csv内容：




    

1,张三,男
2,李四,男
3,翠花,女
③ 基于CsvBindByPosition注解映射的写入

使用方法：
     * 基于CsvBindByPosition注解映射的写入
     * @throws Exception
    private static void beanToCsvByPositionAnnotation() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        List<User1> list = new ArrayList<>();
        list.add(new User1("1", "张三", "男"));
        list.add(new User1("2", "李四", "男"));
        list.add(new User1("3", "翠花", "女"));
        // 未使用@CsvBindByPosition注解的列不写入
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(fileName), Charset.forName("UTF-8"));
        // 如果需要标题行，可这样写入
        // CSVWriter csvWriter = (CSVWriter) new CSVWriterBuilder(writer)
        //         .build();
        // String[] titleRow = {"用户ID", "用户名", "性别"};
        // csvWriter.writeNext(titleRow, false);
        StatefulBeanToCsv<User1> statefulBeanToCsv = new StatefulBeanToCsvBuilder<User1>(writer)
                .withApplyQuotesToAll(false)
                .build();
        statefulBeanToCsv.write(list);
        writer.close();
123456789101112131415161718192021222324252627
demo.csv内容：
1,张三,男
2,李四,男
3,翠花,女
④ 基于列名映射的写入

使用方法：
     * 基于列名映射的写入
     * @throws Exception
    private static void beanToCsvByName() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        List<User> list = new ArrayList<>();
        list.add(new User("1", "张三", "男"));
        list.add(new User("2", "李四", "男"));
        list.add(new User("3", "翠花", "女"));
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(fileName), Charset.forName("UTF-8"));
        // 可通过比较器指定列的顺序
        // 标题行的列名默认为bean的字段名大写
        HeaderColumnNameMappingStrategy<User> strategy = new HeaderColumnNameMappingStrategy<>();
        HashMap<String, Integer> columnOrderMap = new HashMap<>();
        columnOrderMap.put("USERID", 1);
        columnOrderMap.put("SEX", 10);
        columnOrderMap.put("USERNAME", 100);
        strategy.setColumnOrderOnWrite(Comparator.comparingInt(column -> (columnOrderMap.getOrDefault(column, 0))));
        strategy.setType(User.class);
        StatefulBeanToCsv<User> statefulBeanToCsv = new StatefulBeanToCsvBuilder<User>(writer)
                .withMappingStrategy(strategy)
                .withApplyQuotesToAll(false)
                .build();
        statefulBeanToCsv.write(list);
        writer.close();
12345678910111213141516171819202122232425262728293031
demo.csv内容：
USERID,SEX,USERNAME
1,男,张三
2,男,李四
3,女,翠花
⑤ 基于CsvBindByName注解映射的写入

使用方法：
     * 基于CsvBindByName注解映射的写入
     * @throws Exception
    private static void beanToCsvByNameAnnotation() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        List<User2> list = new ArrayList<>();
        list.add(new User2("1", "张三", "男"));
        list.add(new User2("2", "李四", "男"));
        list.add(new User2("3", "翠花", "女"));
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(fileName), Charset.forName("UTF-8"));
        // 可通过比较器指定列的顺序
        // 通过CsvBindByName注解的column属性，指定标题行的列名
        HeaderColumnNameMappingStrategy<User2> strategy = new HeaderColumnNameMappingStrategy<>();
        // 注意这里的key是指的标题行的列名
        HashMap<String, Integer> columnOrderMap = new HashMap<>();
        columnOrderMap.put("用户ID", 1);
        columnOrderMap.put("用户名", 10);
        columnOrderMap.put("性别", 100);
        strategy.setColumnOrderOnWrite(Comparator.comparingInt(column -> (columnOrderMap.getOrDefault(column, 0))));
        strategy.setType(User2.class);
        StatefulBeanToCsv<User2> statefulBeanToCsv = new StatefulBeanToCsvBuilder<User2>(writer)
                .withMappingStrategy(strategy)
                .withApplyQuotesToAll(false)
                .build();
        statefulBeanToCsv.write(list);
        writer.close();
123456789101112131415161718192021222324252627282930313233
demo.csv内容：
用户ID,用户名,性别
1,张三,男
2,李四,男
3,翠花,女
通过简单的写入写入的数据
① 简单的读取

使用方法：
     * 简单的读取
     * @throws Exception
    private static void csvReader() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        InputStreamReader reader = new InputStreamReader(new FileInputStream(fileName), Charset.forName("UTF-8"));
        CSVReader csvReader = new CSVReaderBuilder(reader).build();
        List<String[]> list = csvReader.readAll();
        for (String[] strings : list) {
            System.out.println(JSON.toJSONString(strings));
        csvReader.close();
123456789101112131415
控制台日志：
["用户ID","用户名","性别"]
["1","张三","男"]
["2","李四","男"]
["3","翠花","女"]
② 基于位置映射的读取

通过基于位置映射的写入写入的数据
使用方法：
     * 基于位置映射的读取
     * @throws Exception
    private static void csvToBeanByPosition() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        InputStreamReader reader = new InputStreamReader(new FileInputStream(fileName), Charset.forName("UTF-8"));
        // 不需要标题行，列的顺序通过列位置映射指定
        ColumnPositionMappingStrategy<User> strategy = new ColumnPositionMappingStrategy();
        String[] columns = new String[] { "userId", "userName", "sex"};
        strategy.setColumnMapping(columns);
        strategy.setType(User.class);
        CsvToBean<User> csvToBean = new CsvToBeanBuilder<User>(reader)
                .withMappingStrategy(strategy)
                .build();
        List<User> list = csvToBean.parse();
        for (User user : list) {
            System.out.println(JSON.toJSONString(user));
        reader.close();
12345678910111213141516171819202122
控制台日志：
{"sex":"男","userId":"1","userName":"张三"}
{"sex":"男","userId":"2","userName":"李四"}
{"sex":"女","userId":"3","userName":"翠花"}
③ 基于CsvBindByPosition注解映射的读取

通过基于CsvBindByPosition注解映射的写入写入的数据
使用方法：
     * 基于CsvBindByPosition注解映射的读取
     * @throws Exception
    private static void csvToBeanByPositionAnnotation() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        InputStreamReader reader = new InputStreamReader(new FileInputStream(fileName), Charset.forName("UTF-8"));
        // 不需要标题行，列的顺序通过CsvBindByPosition注解的position属性指定
        CsvToBean<User1> csvToBean = new CsvToBeanBuilder<User1>(reader)
                .withType(User1.class)
                .build();
        List<User1> list = csvToBean.parse();
        for (User1 user : list) {
            System.out.println(JSON.toJSONString(user));
        reader.close();
123456789101112131415161718
控制台日志：
{"sex":"男","userId":"1","userName":"张三"}
{"sex":"男","userId":"2","userName":"李四"}
{"sex":"女","userId":"3","userName":"翠花"}
④ 基于列名映射的读取

通过基于列名映射的写入写入的数据
使用方法：
     * 基于列名映射的读取
     * @throws Exception
    private static void csvToBeanByName() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        InputStreamReader reader = new InputStreamReader(new FileInputStream(fileName), Charset.forName("UTF-8"));
        // bean的字段名称大写为标题列名
        CsvToBean<User> csvToBean = new CsvToBeanBuilder<User>(reader)
                .withType(User.class)
                .build();
        List<User> list = csvToBean.parse();
        for (User user : list) {
            System.out.println(JSON.toJSONString(user));
        reader.close();
123456789101112131415161718
控制台日志：
{"sex":"男","userId":"1","userName":"张三"}
{"sex":"男","userId":"2","userName":"李四"}
{"sex":"女","userId":"3","userName":"翠花"}
⑤ 基于CsvBindByName注解映射的读取

通过基于CsvBindByName注解映射的写入写入的数据
使用方法：
    private static void csvToBeanByNameAnnotation() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        InputStreamReader reader = new InputStreamReader(new FileInputStream(fileName), Charset.forName("UTF-8"));
        // CsvBindByName注解的column属性为标题列名
        CsvToBean<User2> csvToBean = new CsvToBeanBuilder<User2>(reader)
                .withType(User2.class)
                .build();
        List<User2> list = csvToBean.parse();
        for (User2 user : list) {
            System.out.println(JSON.toJSONString(user));
        reader.close();
1234567891011121314
控制台日志：
{"sex":"男","userId":"1","userName":"张三"}
{"sex":"男","userId":"2","userName":"李四"}
{"sex":"女","userId":"3","userName":"翠花"}
⑥ 基于列名转换映射的读取

通过基于CsvBindByName注解映射的读取写入的数据
使用方法：
public class MyCsvToBeanFilter implements CsvToBeanFilter {
    @Override
    public boolean allowLine(String[] line) {
        // 过滤掉用户名为李四的行
        if("李四".equals(line[1])){
            return false;
        return true;
1234567891011
     * 基于列名转换映射的读取
     * @throws Exception
    private static void csvToBeanByColumnNameTranslateMapping() throws Exception {
        String classpath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        String fileName = classpath+"test/demo.csv";
        InputStreamReader reader = new InputStreamReader(new FileInputStream(fileName), Charset.forName("UTF-8"));
        // 指定标题列名和bean列名映射关系
        HeaderColumnNameTranslateMappingStrategy<User> strategy = new HeaderColumnNameTranslateMappingStrategy<>();
        // key：标题列名，value：bean的属性名
        HashMap<String, String> columnMappingMap = new HashMap<>();
        columnMappingMap.put("用户ID", "userId");
        columnMappingMap.put("性别", "sex");
        columnMappingMap.put("用户名", "userName");
        strategy.setColumnMapping(columnMappingMap);
        strategy.setType(User.class);
        CsvToBean<User> csvToBean = new CsvToBeanBuilder<User>(reader)
                .withMappingStrategy(strategy)
                .withFilter(new MyCsvToBeanFilter())
                .withIgnoreField(User2.class, User2.class.getField("userId"))// 忽略userId属性
                .build();
        List<User> list = csvToBean.parse();
        for (User user : list) {
            System.out.println(JSON.toJSONString(user));
        reader.close();
1234567891011121314151617181920212223242526272829
控制台日志：
{"sex":"男","userName":"张三"}
{"sex":"女","userName":"翠花"}
3. commons-csv

4. hutool CsvUtil（扩展）
  
分类：




    
 后端
 
  
   
相关推荐
 
  
        Spring Boot
      
 
    @Schedule 通过 ShedLock 实现分布式定时任务
 
默认的 @Schedule 注解实现的定时任务是单个应用的，当开启了多个实例，每个实例中都会执行一次。 此时可通过添加 shedlock-spring 包来支持这种分布式场景。
 
 217
 





    
 
        Java查序
      
 
    idea 中的 lombok 不生效的四种解决方法
 
Lombok项目是一个java库，它可以自动插入到编辑器和构建工具中，增强java的性能。不需要再写getter、setter或equals方法，只要有一个注解，你的类就有一个功能齐全的构建器、自动记
 
 227
 
 
        会飞的喵喵
        Spring Boot
      
 
    AOP是什么？Spring Boot AOP 怎么使用？
 
1. Spring Boot AOP 是什么？ 1.1 AOP 是什么？   AOP是面向切面编程（Aspect-Oriented Programming）的缩写。AOP是一种编程范式，旨在通过将横切
 
 210
 
 
        写bug写bug
        Linux
      
 
    Java IO 体系、线程模型大总结
 
Java 中的 I/O 按照其发展历程，可以划分为传统 IO（阻塞式 I/O）和新 IO（非阻塞式 I/O）。 传统 I/O 传统 IO 也称为 BIO（Blocking IO），是面向字节流或字符流
 
 196
 
 
        Redis
      
 
    一次redis主从切换导致的数据丢失与陷入只读状态故障
 
背景 最近一组业务redis数据不断增长需要扩容内存，而扩容内存则需要重启云主机，在按计划扩容升级执行主从切换时意外发生了数据丢失与master进入只读状态的故障，这里记录分享一下。 业务redis高
 
 163
 





    
 
        一条小鲤鱼
      
 
    Sping Security （一）： 入门原理
 
选择Spring Security来保护web应用是一个非常不错的选择，Spring Security是spring项目中的一个安全模块，可以非常方便地集成到spring项目中。
 
 167
 
 
        一只爱撸猫的程序猿
      
 
    Spring的循环依赖
 
循环依赖（Circular Dependency）在 Spring 中是指两个或者更多的 bean 彼此依赖对方，形成一个闭环。这种依赖关系在对象创建时，可能会导致一系列问题。
 
 166
 
 
        tizzybepeacejoy
      
 
    SpringCloud 使用SpringCloudConfig搭建远程配置中心，包含手动刷新以及Bus总线刷新
 
随着服务数量越来越多，模块越来越多我们的各种服务的配置文件也越来越多，同时多个服务在项目中采用配置文件的方式，越来越显得力不从心，往往一次更改配置文件很是麻烦，这时候SpringCloudConfig出现，他的出现让我们集中配置配置文件，服务端集中管理，客户端一次读取，同时采用更...
 
 57
 
 
        Java查序
      
 
    Idea中为java程序添加启动参数（含：VM options、Program arguments、Environment variable）
 
一、运行Java程序 我们运行Java程序的时候，一般可以通过下列方式： 运行某个Class类（class表示的是包含main函数的class名称(含包名)） 运行某个jar包（jar和xxx.jar
 
 93
 
 
        Java查序
      
 
    Java中的反射（通过反射获取类的结构、invoke方法、获取注解）
 
1. 创建运行时类的对象 创建运行时类的对象是反射机制应用最多的地方。创建运行时类的对象有两种方式： 方式1：直接调用Class对象的newInstance()方法 要求： 1）类必须有一个无参数的构
 
 240
 





    
 
      
 
    线程池 KeyAffinityExecutor
 
KeyAffinityExecutor 可以按照一个固定的 key 分组并发，实现任务整体并行的前提下，进行局部串行。并且能够保证热点分散和 key 的均匀分布执行。
 
 306
 
 
        程序员的思考与落地
        Spring Boot
      
 
    使用自定义注解和@Aspect实现责任链模式的组件增强
 
责任链模式 责任链模式是一种行为设计模式，其作用是将请求的发送者和接收者解耦，从而可以灵活地组织和处理请求。它通过将请求沿着一个由多个处理器组成的链路进行传递和处理，直到有一个处理器能够处理该请求或者
 
 936
 
 
        Groovy
        Spring Boot
      
 
    Groovy 学习（2）：函数式编程
 
Groovy 一般不被看作一种函数式语言，但它具备很多函数式的范式，只是命名上往往带有脚本语言的色彩。
 
 863
 
 
        EtherealGoGoGo
      
 
    Java 8 新的时间api LocalDate/LocalDateTime
 
引言 在项目中，时间的使用必不可少，而java 8之前的时间api Date和Calander等在使用上存在着很多问题，于是，jdk1.8引进了新的时间api -->LocalDateTime，很好解
 
 2018
 
 
        一条小鲤鱼
      
 
    Sping Security （二）： 认证流程
 
这一篇主要介绍spring Secutity 的认证流程和原理 ，并实现自定义加载用户信息 和 实现token登录。
 
 172
 
 
        按时交作业
      
 
    【一文通关】==，equals()与hashcode()的使用
 
==，equals()与hashcode() "==" 在讲解之前，我们是怎么接触到==的，我们在作比较时经常用到 ==, 这个符号常用作基本类的数据。 ==运算符通常用于比较基本数据类型（如int、
 
 72
 
 
        越走越远的风
        Spring Boot
      
 
    并发编程之BlockingQueue实现原理
 
什么是队列 队列（Queue） 是一种线性数据结构，也称为队列树（Queue Tree） 或 先进先出（First In First Out, FIFO）队列。这是一种环形结构，其中队列中的元素按照插
 
 173
 
 
          
 
 
  
 
 
友情链接：
 

    Java查序
        程序员 @ 腾讯科技（深圳）有限公司