JAVA总结2

## 1.Collection
#### ①常见方法：
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/06f51b7c-1ca3-f0ba-7c3a-1d7c4401c31a.png)
```java
        Collection<String> c = new ArrayList<>();// 多态写法
        // 1.添加元素，添加成功返回true
        c.add("java1");
        c.add("java1");
        c.add("java2");
        c.add("java2");
        c.add("java3");
        System.out.println(c);// [java1, java1, java2, java2, java3]

        // 2.清空集合元素
        // c.clear();
        // System.out.println(c);// []

        // 3.判断集合是否为空，是空返回true，反之
        System.out.println(c.isEmpty());// false

        // 4.获取集合的大小
        System.out.println(c.size());// 5

        // 5.判断集合中是否包含某个元素
        System.out.println(c.contains("java1"));// true

        // 6.删除某个元素，如果有多个重复元素默认删除前面的第一个
        System.out.println(c.remove("java1"));// true
        System.out.println(c);// [java1, java2, java2, java3]

        // 7.把集合转换成数组
        Object[] arr =  c.toArray();
        System.out.println(Arrays.toString(arr));// [java1, java2, java2, java3]


        // 把一个集合的全部数据倒入到另一个集合中去
        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2);// 就是把c2集合的全部数据倒入到c1集合中去
        System.out.println(c1);// [java1, java2, java3, java4]
        System.out.println(c2);// [java3, java4]
```
#### ②遍历方式
⭐迭代器（Iterator）
用来遍历集合的专用方式（数组没有迭代器）
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/4e8c0330-7c19-404a-1879-e25265343809.png)
```java
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);  // c =  [赵敏, 小昭, 素素, 灭绝]

        // 使用迭代器遍历集合
        // 1.从集合对象中获取迭代器对象
         Iterator<String> it =  c.iterator();
         System.out.println(it.next());// 赵敏
         System.out.println(it.next());// 小昭
         System.out.println(it.next());// 素素
         System.out.println(it.next());// 灭绝
         System.out.println(it.next());// 出现异常

         // 2.使用循环结合迭代器遍历集合
        while (it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
            // 赵敏
            // 小昭
            // 素素
            // 灭绝
            // System.out.println(it.next());  × 别用 
        }
```
⭐增强for
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/850f8493-7d6a-d647-b4d7-af0f5c8d305e.png)
```java
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);
        // c =  [赵敏, 小昭, 素素, 灭绝]
        //        ele

        // 使用增强for遍历集合或者数组
        for (String ele : c) {
            System.out.println(ele);
        }
            // 赵敏
            // 小昭
            // 素素
            // 灭绝

        String[] names = {"迪丽热巴","古力娜扎","七七八八"};
        for (String name:names){
            System.out.println(name);
            // 迪丽热巴
            // 古力娜扎
            // 七七八八
        }
```
⭐lambda表达式
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/f3a5cab4-27cc-9d46-3368-51c93f044b33.png)
```java
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);
        //  [赵敏, 小昭, 素素, 灭绝]
        //   s

        // 集合Lambda表达式遍历集合
        c.forEach(s -> {
            System.out.println(s);
        });
       
```
## 2.List集合
#### ①特点：有序 可重复 有索引
#### ②特有方法
当然，Collection的功能List也都继承了
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/5cc53bb6-407e-55da-1bd9-057fa366e068.png)
```java
        // 1.有序 可重复 有索引
        List<String> list = new ArrayList<>();// 经典代码
        list.add("蜘蛛精");
        list.add("至尊宝");
        list.add("至尊宝");
        list.add("牛夫人");
        System.out.println(list);// [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

        // 2.在某个索引位置插入元素
        list.add(2,"紫霞仙子");
        System.out.println(list);// [蜘蛛精, 至尊宝, 紫霞仙子, 至尊宝, 牛夫人]

        // 3.根据索引删除元素，返回被删除元素
        System.out.println(list.remove(2));// 紫霞仙子
        System.out.println(list);// [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

        // 4.返回集合中指定位置的元素
        System.out.println(list.get(3));// 牛夫人

        // 5.修改索引位置处的元素，修改成功后，会返回原来的数据
        System.out.println(list.set(3, "牛魔王"));// 牛夫人
        System.out.println(list);// [蜘蛛精, 至尊宝, 至尊宝, 牛魔王]
```
## 3.Set集合
Set要用到的常用方法，基本上就是Collection提供的。
自己几乎没有额外新增的一些常用功能
## 4.Map
#### ①常用方法
```java
        // 1.添加元素：无序 不重复 无索引
        Map<String,Integer> map = new HashMap<>();
        map.put("手表",100);
        map.put("手表",220);
        map.put("手机",2);
        map.put("JAVA",2);
        map.put(null,null);
        System.out.println(map);// {JAVA=2, null=null, 手表=220, 手机=2}

        // 2.获取集合的大小
        System.out.println(map.size());// 4

        // 3.清空集合
//        map.clear();
//        System.out.println(map);

        // 4.判断集合是否为空，为空返回true，反之
        System.out.println(map.isEmpty());

        // 5.根据键获取对应值
        int v1 = map.get("手表");
        System.out.println(v1);// 220

        // 6.根据键删除整个元素（删除键会返回键的值）
        System.out.println(map.remove("手表"));// 220
        System.out.println(map);// {JAVA=2, null=null, 手机=2}

        // 7.判断是否包含某个键，包含返回true，反之
        System.out.println(map.containsKey("手表"));// false
        System.out.println(map.containsKey("手机"));// true

        // 8.判断是否包含某个值
        System.out.println(map.containsValue(2));// true

        // 9.获取Map集合的全部键
        Set<String> keys = map.keySet();
        System.out.println(keys);// [JAVA, null, 手机]

        // 10.获取Map集合的全部值
        Collection<Integer> values = map.values();
        System.out.println(values);// [2, null, 2]

        // 11.把其他Map集合的数据倒入到自己集合中来（拓展）
        Map<String,Integer> map1 = new HashMap<>();
        map1.put("java1",10);
        map1.put("java2",20);
        Map<String,Integer> map2 = new HashMap<>();
        map2.put("java3",10);
        map2.put("java2",222);
        map1.putAll(map2);// putAll:把map2集合中的元素全部倒入一份到map1集合中去
        System.out.println(map1);// {java3=10, java2=222, java1=10}
        System.out.println(map2);// {java3=10, java2=222}
```
#### ②遍历方式 
1.键找值
先获取map集合全部的键，再通过遍历键来找值
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/56cdbf22-9e47-2f31-7ab9-bf2d8f77bf4c.png)
```java
        // 准备一个Map集合
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精",162.5);
        map.put("蜘蛛精",169.8);
        map.put("紫霞",165.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        System.out.println(map);
        // {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}

        // 1.获取集合的全部键
        Set<String> keys = map.keySet();
        System.out.println(keys);// [蜘蛛精, 牛魔王, 至尊宝, 紫霞]
        // 2.遍历全部的键，根据键获取其对应的值
        for (String key : keys) {
            // 根据键获取其对应的值
           double value =  map.get(key);
            System.out.println(key + "------>" + value);
            // 蜘蛛精------>169.8
            //牛魔王------>183.6
            //至尊宝------>169.5
            //紫霞------>165.8
```
2.键值对
把“键值对”看成是一个整体进行遍历
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/cd8bb8eb-441a-276b-e4b8-f92f7a2855b0.png)
```java
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精",169.8);
        map.put("紫霞",165.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        System.out.println(map);
        // {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
        // entries = [{蜘蛛精=169.8},{牛魔王=183.6},{至尊宝=169.5},{紫霞=165.8}]

        // 1.调用Map集合提供的entrySet方法，把Map集合转换成键值对类型的Set集合
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        for (Map.Entry<String, Double> entry : entries) {
            String key = entry.getKey();
            Double value = entry.getValue();
            System.out.println(key + "--->" + value);
            // 蜘蛛精--->169.8
            //牛魔王--->183.6
            //至尊宝--->169.5
            //紫霞--->165.8
```
3.lambda
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/6dc16e8f-36cd-7ec9-534d-d14d46c3b6e4.png)
```java
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精",169.8);
        map.put("紫霞",165.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        System.out.println(map);
        // {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
        map.forEach((k,v) -> {
            System.out.println(k + "--->" + v);
            // 蜘蛛精--->169.8
            //牛魔王--->183.6
            //至尊宝--->169.5
            //紫霞--->165.8
        });
```
## 5.异常(Exception)
⭐抛出异常(throws)：在方法上使用throws关键字，可以将方法内部出现的异常抛出去给调用者处理
⭐捕获异常(try - catch)：直接捕获程序出现的异常
#### 自定义异常的种类
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/416f0ce3-e7a4-76e1-9a47-a63b7da6023d.png)
## 6.Object类
#### equals:判断两个对象是否相等
⭐为了被子类重写，以便子类自己来定制比较规则（比如比较对象的内容）
直接比较两个对象的地址是否相同：==
```java
        // TODO Object类提供的常用方法
        Student s1 = new Student("赵敏",23);
        System.out.println(s1.toString());// Student{name='赵敏', age=23}
        System.out.println(s1);// Student{name='赵敏', age=23}


        Student s2 = new Student("赵敏",23);
        System.out.println(s2.equals(s1));// true
        System.out.println(s2 == s1);// false
```
## 7.StringBuilder/StringBuffer
代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的(类似于String的功能)
#### ①方法
⭐append:添加数据并返回StringBuilder对象本身(添加内容)
⭐reverse:将对象的内容反转
⭐length:返回对象内容长度
⭐toString:把StringBuilder转换为String
## 8.API
localDate:代表本地日期（年月日星期） 
LocalTime：代表本地时间（时分秒纳秒） 
localDateTime：代表本地日期，时间（年月日星期时分秒纳秒）
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/518478fd-b571-44ed-0a62-b5ef684f2b4e.png)
## 9.Arrays
用来操作数组的工具类
```java
        // 对数组进行排序，默认升序排序
        Arrays.sort(prices);
        System.out.println(Arrays.toString(prices));// [79.84, 80.0, 102.4]
```
## 10.创建文件，删除文件
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/14408946-6a80-2b08-2bd4-a65005a91725.png)
```java
        // 1.创建一个新文件（文件内容为空），创建成功返回true,反之
        File f1 = new File("C:/resource/itheima2.txt");
        System.out.println(f1.createNewFile());

        // 2.用于创建文件夹，注意，只能创建一级文件夹
        File f2 = new File("C:/resource/aaa");
        System.out.println(f2.mkdir());

        // 3.用于创建文件夹，注意，可以创建多级文件夹
        File f3 = new File("C:/resource/bbb/ccc/ddd");
        System.out.println(f3.mkdirs());

        // 4.删除文件或者空文件，注意，不能删除非空文件
        System.out.println(f1.delete());
        System.out.println(f2.delete());
```
## 11.释放资源的方式 
#### ①try-catch-finally
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/c58ba7d2-08c3-2d2e-7847-69f2d56a3bc5.png)
#### ②try-with-resource
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/c26bc3b2-f1d5-09ed-4207-397fb14a7655.png)