# Java基础进阶

**Repository Path**: xxacker/java-base-advanced

## Basic Information

- **Project Name**: Java基础进阶
- **Description**: 用来对Java 基础进行强化
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2021-06-07
- **Last Updated**: 2021-09-24

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Java基础进阶

#### 介绍
用来对Java 基础进行强化

#### 目录
    1. FastJSON 常用操作
    2. Lambda常用操作
    3. 反射
    4. Calendar


# 一、FastJSON 常用操作
FastJSON 常用的对象有三个：***\*JSON\**** | ***\*JSONArray\**** | ***\*JSONObject\****

操作对象：

```java
@Data
public class Student {
    private String name;                // 姓名
    private int age = 18;               // 年龄
    private Long account = 8888;        // 账户
    private String base = "project";               
}
```

***\*JSON\**** | 

***\*String ==> Object\**** 

· 主要是将传进来的 String 转换成 Object 格式输出到控制台。

示例：

```java
/**测试 JSON 对象的操作方法
 *      1. JSON.parseObject("字符串"， 目标类对象.class)
 * 我们使用n ew TypeReference的时候会生成多个 class文件 里面有多少个 new TypeReference 就会新增了class
 * 即使我们在for循环里(0-N)写 new TypeReference 这段代码也是多生成一个 class文件,
 * fastjson是看我们写了多少new TypeReference，而不是调用了多少次new TypeReference。推荐用ArrayList.class
 */
@Test
public void test01() {
    //  String 转 Object 对象
    String jsonString01 = "{\"name\": \"法外狂徒-张三\", \"age\":18 } ";
    Student student01 = JSON.parseObject(jsonString01, Student.class);
    System.out.println("转 Object 对象：" + student01 + "\n");

    // 转换成对象List集合
    String jsonstring02 = "[{\"name\": \"法外狂徒-张三\", \"age\":18 } ]";
    List<Student> student02 = JSON.parseObject(jsonstring02, new TypeReference<List<Student>>() {});
    System.out.println("转 List集合   ：" + student02);

    // 转换成ArrayList
    ArrayList<Student> student03 = JSON.parseObject(jsonstring02, new TypeReference<ArrayList<Student>>() {});
    System.out.println("转 ArrayList 对象：" + student03 + "\n");

    // 转换成对象数组
    Student[] student04 = JSON.parseObject(jsonstring02, new TypeReference<Student[]>() {});
    System.out.println("转 对象数组    ：" + student04);
    List list = Arrays.asList(student04);
    System.out.println("对象数组 转 List：" + list + "\n");

    // 转换成ArrayList(默认)    list3  与 list4  效果相同
    ArrayList<JSONObject> list3 = JSON.parseObject(jsonstring02, new ArrayList<Student>().getClass());
    ArrayList<JSONObject> list4 = JSON.parseObject(jsonstring02, ArrayList.class);
    for (int i = 0; i < list4.size(); i++) {        //  推荐用这个
        JSONObject obj = list4.get(i);
        System.out.println(obj.get("name") + "  |  " + obj.get("age"));
    }
}
```



***\*String ==> Map\**** 

```java
String str="";
HashMap hashMap = JSON.parseObject(str, HashMap.class);
```

***\*Map ==> String\**** 

```java
JSON.toJSONString(accountMap) 
```

***\*====================================================================================\****

***\*JSONArray\**** | 

· 主要是将前端传到服务器端的字符串转换成 JSONArray 对象，方便使用循环遍历取出数组中的各个元素。

示例：

```java
JSONObject parameter = (JSONObject) request.getJson("parameter");     （推荐使用）
List<String> selectPolicies = parameter.getJSONArray("selectPolicies").stream().map(o -> (String) o).collect(Collectors.toList());

List<RectificationTemplate> result = JSONArray.parseArray(JSON.toJSONString(executorList), RectificationTemplate.class);
List<HashMap> resultMap = JSONArray.parseArray(JSON.toJSONString(result), HashMap.class);

JSONArray policyIds = (JSONArray) request.getJson("policyId");
List<String> ids = JSON.parseArray(policyIds.toJSONString(), String.class);
```

***\*===================================================================================\****

***\*JSONObject\**** | 

· 主要是将上一步数组中取出来的单个元素转换成 JSONObject 对象

· 或将一个字符串转换成一个 JSONObject 对象



# 二、Lambda常用操作
Lambda 的核心就是对集合数据进行 

- 遍历
- 提取
- 过滤
- 排序

等一系列操作的简化。

用函数式编程的方式，对集合进行操作。

**----------------------------------------------------------------------------------------------------------**

单词表：

> account     账户
> 
> reversed    反转,颠倒
> 
> Comparator  比较器

操作的对象：

```java
@Data
public class Person {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private BigDecimal account;
}
```

操作的集合：

```java
Person p1 = new Person(1,"张三","男",18,new BigDecimal(100));
Person p2 = new Person(2,"小红","女",16,new BigDecimal(200));
Person p3 = new Person(3,"李四","男",18,new BigDecimal(300));
Person p4 = new Person(4,"王五","男",18,new BigDecimal(400.5));
Person p5 = new Person(5,"小花","女",16,new BigDecimal(500));

List<Person> list = Arrays.asList(p1, p2, p3, p4, p5);
System.out.println("所有人：" + list + "\n");
```

**==========================================================================================**

**.map()** 

获取某个元素 | 元素的集合：

```java
//获取所有ID集合
List<Integer> idList = list.stream().map(Person::getId).collect(Collectors.toList());
```

```java
//获取最小
BigDecimal id1 = list.stream().map(Person::getAccount).min(BigDecimal::compareTo).get();
```

```java
//获取最大
Integer id = list.stream().map(Person::getId).max(Integer::compareTo).get();
```

```java
//获取id数量
long count = list.stream().map(Person::getId).count();
```

```java
//总和
int sum = list.stream().mapToInt(Person::getId).sum();
```

```java
//获取平均值
double avg = list.stream().mapToInt(Person::getId).average().getAsDouble();
```

```java
//将名字全转换为大写
List<String> listStr = list.stream().map(Person::getName).map(String::toUpperCase).collect(Collectors.toList());
```

**=========================================================================================**

求最小值：.min()

```java
BigDecimal account = newList.stream().min(Comparator.comparing(Person::getAccount)).get().getAccount();
```

**===========================================================================================**

过滤：.filter()

```java
// 只保留男性
List<Person> list1 = list.stream().filter(p -> "男".equals(p.getSex())).collect(Collectors.toList());
```

```java
//获取年龄大于16的
List<Person> list2 = list.stream().filter(person -> person.getAge() > 16).collect(Collectors.toList());
```

**===========================================================================================**

排序：.sorted()

```java
// 按 Id 正序排列
List<Person> list1 = list.stream().sorted(Comparator.comparingInt(Person::getId)).collect(Collectors.toList());
```

```java
// 按账户金额倒叙排列
List<Person> newList = list.stream().sorted(Comparator.comparing(Person::getAccount).reversed()).collect(Collectors.toList());
```

**==========================================================================================**

分组：

```java
//分组
Map<String, Long> map01 = list.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.counting()));
System.out.println(map01);      // 输出结果：{女=2, 男=3}
```

**==========================================================================================**

```java
//根据年龄和性别分组，并求出分组后账户的总金额
Map<String, Person> accountMap = list.stream().collect(Collectors.toMap(
        p -> String.valueOf(p.getAge()) + "_" + p.getSex()
        , Function.identity()
        , (t1, t2) -> {
            t2.setAccount(t2.getAccount().add(t1.getAccount()));
            return t2;
        }
));
System.out.println("根据年龄和性别分组，并求出分组后账户的总金额：" + JSON.toJSONString(accountMap) + "\n");
// 根据年龄和性别分组，并求出分组后账户的总金额：
// {"16_女":{"account":700,"age":16,"id":5,"name":"小花","sex":"女"},"18_男":{"account":800.5,"age":18,"id":4,"name":"王五","sex":"男"}}
```

```java
//获取第一个对象
Person person6 = list.stream().findFirst().get();
```

```java
//获取忽略第一个并取前几条数据
List<Person> listP3 = list.stream().skip(1).limit(2).collect(Collectors.toList());
```

```java
//去重
List<Person> collect = list.stream().distinct().collect(Collectors.toList());
```

```java
//判断是否为空
Person p1 = new Person(1,"张三","男",18,new BigDecimal(100));
String s1 = Optional.ofNullable(p1).map(u -> u.getName()).get();
System.out.println(s1);

//判读是否为空，抛异常
Person p = null;
String s = Optional.ofNullable(p).map(u -> u.getName()).orElse("0");
try {
    Optional.ofNullable(p).map(u -> u.getName()).orElseThrow(() ->  new Exception("132"));
} catch (Exception e) {
    e.printStackTrace();
}
```

# 三、反射
详见代码

# 四、Calendar 操作
详见代码