• Java基础（三）

    前言：前面主要涉及到java的基本语法，接下来本篇博客主要记录Java中Collections类、泛型、以及File类、IO流的学习。

    目录

    数据结构

    泛型

    集合

    分类

    Collection的分类

    collection常用方法

    collection遍历方式

    迭代器

    for循环

    Lambda表达式

    List集合

    特点

    增删改查

    List集合的遍历方式

    for循环

    迭代器

    增强for循环（for）

    Lambda表达式

    ArrayList集

    底层原理

    适合场景

    LinkedList集合

    底层原理

    应用场景

    设计队列

    栈

    Set集合

    特点

    HashSet

    底层原理

    适用场景

    LinkedHashSet

    底层原理

    适用场景

    TreeSet

    底层原理

    适用场景

    Map集合

    特点

    常用方法

    遍历方式

    for循环

    键找值

    Lambda表达式

    File

    常用方法

    递归

    递归应用-搜索文件

    字符集

    IO流

    IO流体系

    字节流

    FileInputStream（文件字节输入流）

    每次读取一个字节

    每次读取多个字节 

    一次性全都读完全部字节

    OutputStream FileOutputStream（文件字节输出流）

    拷贝文件

    释放资源

    try-catch-finally

    try-with-resource

    实用场景

    字符流

    每次读取一个字符

    每次读取多个字符

    FileWriter（文件字符输出流）

    适用场景

    数据结构

    数据结构是组织数据的方式，数据结构+算法=程序。

    数组是一种基本的数据结构。

    基础的数据结构：List、Set、Queue、Map，比较高级的有Tree、Heap。

    泛型

    英文名：generics

    List ret = new ArrayList<>()

    什么是泛型？

    推荐阅读下面的这篇文章。

    还不知道泛型是什么？这一篇深入浅出泛型教学！ - 知乎 (zhihu.com) 

    集合

     集合，是没有顺序的。

    import java.util.Collection;

    分类

    单列集合 colleciton

    双列集合 Map

    Collection的分类

    接口 Collection

    List 

    • ArrayList
    • LinkedList

    Set

    • HashSet
      • LinkedHashSet
    • TreeSet

    List系列集合：添加的元素是有序、可重复、有索引

    ArrayList、LinkedList：有序、可重复、有索引

    Set系列集合：添加的元素是无序、不重复、无索引

    • HashSet：无序、不重复、无索引
    • LinkedHashSet：有序、不重复、无索引
    • TreeSet：按大小默认升序排序、不重复、无索引

    collection常用方法

    1. package learn11;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Arrays;
    5. import java.util.Collection;
    6. import java.util.List;
    7.  
    8. public class ListMrjj {
    9.     public static void main(String[] args) {
    10.         List List = new ArrayList<>();
    11.         //添加元素
    12.         List.add("mrjj");
    13.         List.add("test");
    14.         List.add("wy");
    15.         // 获取集合的大小
    16.         System.out.println(List.size());
    17.         //判断集合是否包含某个元素 精确匹配
    18.         System.out.println(List.contains("wy"));
    19.         System.out.println(List.contains("WY"));
    20.         //移除第3个元素
    21.         System.out.println(List.remove(2));
    22.         System.out.println(List);
    23.         //获取特定索引的元素
    24.         System.out.println(List.get(0));
    25.         //修改指定索引的元素
    26.         System.out.println(List.set(0, "Mrjj"));
    27.         System.out.println(List);
    28.         //集合转为数组
    29.         Object[] arr = List.toArray();
    30.         System.out.println(Arrays.toString(arr));
    31.         //集合中的数据都是字符串
    32.         String[] arr2 = List.toArray(new String[List.size()]);
    33.         System.out.println(Arrays.toString(arr2));
    34.         //清空集合
    35.         List.clear();
    36.         //判断集合是否为空
    37.         System.out.println(List.isEmpty());
    38.         //将其中一个集合的数据加入另一个集合中
    39.         Collection c1 = new ArrayList<>();
    40.         c1.add("test1");
    41.         c1.add("test2");
    42.         Collection c2 = new ArrayList<>();
    43.         c2.add("test_a");
    44.         c2.add("test_b");
    45.         c1.addAll(c2);
    46.         System.out.println(c1);
    47.         System.out.println(c2);
    48.     }
    49. }

    collection遍历方式

    迭代器

    1. package learn11;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Iterator;
    5. import java.util.List;
    6.  
    7. public class ListLearn {
    8.     public static void main(String[] args) {
    9.         List List = new ArrayList<>();
    10.         List.add("learning");
    11.         List.add("wyLearning");
    12.         List.add("test");
    13.         List.add("wy");
    14.         List.add("wangying");
    15.         List.add("wyy");
    16.         Iterator it = List.iterator();
    17.         while (it.hasNext()) {
    18.             String name = it.next();
    19.             System.out.println(name);
    20.             }
    21.         }
    22. }

    for循环

    1. package learn11;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. public class ListLearn {
    7.     public static void main(String[] args) {
    8.         List List = new ArrayList<>();
    9.         List.add("learning");
    10.         List.add("wyLearning");
    11.         List.add("test");
    12.         List.add("wy");
    13.         List.add("wangying");
    14.         List.add("wyy");
    15.  
    16.         for (int i = 0; i < List.size(); i++) {
    17.             String s = List.get(i);
    18.             System.out.println(s);
    19.  
    20.         }
    21.     }
    22. }

    Lambda表达式

    1. package learn11;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. public class ListLearn {
    7.     public static void main(String[] args) {
    8.         List List = new ArrayList<>();
    9.         List.add("learning");
    10.         List.add("wyLearning");
    11.         List.add("test");
    12.         List.add("wy");
    13.         List.add("wangying");
    14.         List.add("wyy");
    15. //可简写成 List.forEach(System.out::println)
    16.         List.forEach(s -> {
    17.             System.out.println(s);
    18.         });
    19.     }
    20. }

    List集合

    特点

    List系列集合：添加的元素是有序、可重复、有索引

    ArrayList、LinkedList：有序、可重复、有索引

    增删改查

    1. package learn11;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. public class ListMrjj {
    7.     public static void main(String[] args) {
    8.         List List = new ArrayList<>();
    9.         List.add("mrjj");
    10.         List.add("test");
    11.         List.add("wy");
    12.         System.out.println(List);
    13.         System.out.println(List.remove(2));
    14.         System.out.println(List);
    15.         System.out.println(List.get(0));
    16.         System.out.println(List.set(0, "Mrjj"));
    17.         System.out.println(List);
    18.     }
    19. }

    List集合的遍历方式

    for循环
    1. package learn11;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. public class ListLearn {
    7.     public static void main(String[] args) {
    8.         List List = new ArrayList<>();
    9.         List.add("learning");
    10.         List.add("test");
    11.         List.add("wy");
    12.         for (int i = 0; i < List.size(); i++) {
    13.             String s = List.get(i);
    14.             System.out.println(s);
    15.         }
    16.     }
    17. }
    迭代器
    1. Iterator it = List.iterator();
    2.         while (it.hasNext()){
    3.             System.out.println(it.next());
    4.         }
    增强for循环（for）
    1. for (String s : List) {
    2.             System.out.println(s);
    3.         }
    Lambda表达式
    1. List.forEach(s->{
    2.             System.out.println(s);
    3.         });

    数据结构，存储组织数据的方式是不同的。

    ArrayList集

    底层原理

    基于数组实现的

    数组的特点

    根据索引查询数据是比较快的

    删除、添加效率较低

    适合场景

    根据索引查询数据

    不适合场景：

    数据量较大时，需要频繁的增删操作

    LinkedList集合

    底层原理

    基于双链表

    特点：

    查询慢，增删相对较快，首尾元素进行增删改查的速度是极快的

    应用场景
    设计队列

    设计队列（队列，先进先出、后进后出）

    实现一个队列

    1. package learn11;
    2.  
    3. import java.util.LinkedList;
    4.  
    5. public class ListQueue {
    6.     public static void main(String[] args) {
    7.         LinkedList queue = new LinkedList<>();
    8.         queue.addLast("第1个人");
    9.         queue.addLast("第2个人");
    10.         queue.addLast("第3个人");
    11.         queue.addLast("第4个人");
    12.         queue.addLast("第5个人");
    13.         queue.addLast("第6个人");
    14.         System.out.println(queue);
    15.         queue.removeFirst();
    16.         queue.removeFirst();
    17.         queue.removeFirst();
    18.         System.out.println(queue);
    19.     }
    20. }

     

    栈

    进入栈：压栈、进栈（push）

    离开栈：弹栈、出栈（pop）

    1. package learn11;
    2.  
    3. import java.util.LinkedList;
    4.  
    5. public class ListQueue {
    6.     public static void main(String[] args) {
    7.         LinkedList stack = new LinkedList<>();
    8.         stack.addFirst("第1颗子弹");
    9.         stack.addFirst("第2颗子弹");
    10.         stack.addFirst("第3颗子弹");
    11.         stack.addFirst("第4颗子弹");
    12.         stack.addFirst("第5颗子弹");
    13.         stack.addFirst("第6颗子弹");
    14.         System.out.println(stack);
    15.         System.out.println(stack.removeFirst());
    16.         System.out.println(stack.removeFirst());
    17.         System.out.println(stack.removeFirst());
    18.         System.out.println(stack);
    19.     }
    20. }
    1. package learn11;
    2.  
    3. import java.util.LinkedList;
    4.  
    5. public class ListQueue {
    6.     public static void main(String[] args) {
    7.         LinkedList stack = new LinkedList<>();
    8.         stack.push("第1颗子弹");
    9.         stack.push("第2颗子弹");
    10.         stack.push("第3颗子弹");
    11.         stack.push("第4颗子弹");
    12.         stack.push("第5颗子弹");
    13.         stack.push("第6颗子弹");
    14.         System.out.println(stack);
    15.         System.out.println(stack.pop());
    16.         System.out.println(stack.pop());
    17.         System.out.println(stack.pop());
    18.         System.out.println(stack);
    19.     }
    20. }

    实际上，push方法就是调用的addFirst方法，pop方法调用的removeFirst方法

     

     

     

    Set集合

    特点

    Set系列集合：添加的元素是无序、不重复、无索引

    • HashSet：无序、不重复、无索引
    • LinkedHashSet：有序、不重复、无索引
    • ++++：按大小默认升序排序、不重复、无索引

    HashSet

    1. package learn11;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Set;
    5.  
    6. public class SetLearn {
    7.     public static void main(String[] args) {
    8.         Set set = new HashSet<>();
    9.         set.add(23);
    10.         set.add(67);
    11.         set.add(24);
    12.         set.add(74);
    13.         set.add(33);
    14.         set.add(23);
    15.         System.out.println(set);
    16.     }
    17. }

    哈希值

    一个int类型的数值，java中每个对象都有一个哈希值

    java中的所有对象，都可以调用Object类提供的hashCode方法，返回该对象自己的哈希值

    public int hashcode():返回对象的哈希码值

    底层原理

    基于哈希表实现

    哈希表是一种增删改查数据，性能都较好的数据结构

    适用场景

    不需要存储重复元素，不需要排序，无索引

    LinkedHashSet

    1. package learn11;
    2.  
    3. import java.util.LinkedHashSet;
    4. import java.util.Set;
    5.  
    6. public class SetLearn {
    7.     public static void main(String[] args) {
    8.         Set set = new LinkedHashSet<>();
    9.         set.add(23);
    10.         set.add(67);
    11.         set.add(24);
    12.         set.add(74);
    13.         set.add(33);
    14.         set.add(23);
    15.         System.out.println(set);
    16.     }
    17. }

    底层原理

    基于哈希表实现的

    每个元素都额外多了一个双链表的机制记录前后元素的位置

    适用场景

    需要记住元素的添加顺序，无重复元素存储，增删改查都快

    TreeSet

    1. package learn11;
    2.  
    3. import java.util.Set;
    4. import java.util.TreeSet;
    5.  
    6. public class SetLearn {
    7.     public static void main(String[] args) {
    8.         Set set = new TreeSet<>();
    9.         set.add(23);
    10.         set.add(67);
    11.         set.add(24);
    12.         set.add(74);
    13.         set.add(33);
    14.         set.add(23);
    15.         System.out.println(set);
    16.     }
    17. }

    底层原理

    自定义排序规则

    适用场景

    需要对元素进行排序，没有重复元素需要存储，增删改查都快

    Map集合

    键值对集合

    键不能重复

    Map

    HashMap

    LinkedHashMap

    TreeMap

    特点

    Map系列集合的特点都是由键决定的

    HashMap：无序、不重复、无索引

    LinkedHashMap：有序、不重复、无索引

    TreeMap：按照大小默认升序排序、不重复、无索引

    常用方法

    1. package learn11;
    2.  
    3. import java.util.Collection;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6. import java.util.Set;
    7.  
    8. public class MapLearn {
    9.     public static void main(String[] args) {
    10.         Map map = new HashMap<>();
    11.         map.put("test1", 170.0);
    12.         map.put("test2", 160.0);
    13.         map.put("test3", 150.0);
    14.         map.put("test4", 140.0);
    15.         map.put("test5", 130.0);
    16.         System.out.println(map);
    17.         System.out.println(map.size());
    18.         //根据键获取值
    19.         System.out.println(map.get("test1"));
    20.         //找不到返回null
    21.         System.out.println(map.get("wy"));
    22.         //根据键删除元素
    23.         map.remove("test5");
    24.         System.out.println(map);
    25.         //判断是否包含某个键
    26.         System.out.println(map.containsKey("test3"));
    27.         //判断是否包含某个值
    28.         System.out.println(map.containsValue(170.0));
    29. //        map.clear();
    30.         System.out.println(map);
    31.         System.out.println(map.isEmpty());
    32.         //获取所有键
    33.         Set keys = map.keySet();
    34.         System.out.println(keys);
    35.         //获取所有值
    36.         Collection values = map.values();
    37.         System.out.println(values);
    38.         //将其他map集合的数据倒入集合中
    39.         Map map1 = new HashMap<>();
    40.         map1.put("python1",10);
    41.         map1.put("python2",20);
    42.         Map map2 = new HashMap<>();
    43.         map2.put("java1",10);
    44.         map2.put("java2",20);
    45.         map1.putAll(map2);
    46.         System.out.println(map1);
    47.         System.out.println(map2);
    48.     }
    49. }

    遍历方式

    for循环
    1. package learn11;
    2.  
    3. import java.util.Collection;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6. import java.util.Set;
    7.  
    8. public class MapLearn {
    9.     public static void main(String[] args) {
    10.         Map map = new HashMap<>();
    11.         map.put("test1", 170.0);
    12.         map.put("test2", 160.0);
    13.         map.put("test3", 150.0);
    14.         map.put("test4", 140.0);
    15.         map.put("test5", 130.0);
    16.         Set keys = map.keySet();
    17.         for (String key : keys) {
    18.             double value = map.get(key);
    19.             System.out.println(key + "==>" + value);
    20.         }
    21.     }
    22. }
    键找值
    1. package learn11;
    2.  
    3. import java.util.Collection;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6. import java.util.Set;
    7.  
    8. public class MapLearn {
    9.     public static void main(String[] args) {
    10.         Map map = new HashMap<>();
    11.         map.put("test1", 170.0);
    12.         map.put("test2", 160.0);
    13.         map.put("test3", 150.0);
    14.         map.put("test4", 140.0);
    15.         map.put("test5", 130.0);
    16.         Set> entries = map.entrySet();
    17.         for (Map.Entry entry : entries) {
    18.             System.out.println(entry);
    19.         }
    20.         map.forEach((k, v) -> {
    21.             System.out.println(k + "->" + v);
    22.         });
    23.     }
    24. }
    Lambda表达式
    1. package learn11;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. public class MapLearn {
    7.     public static void main(String[] args) {
    8.         Map map = new HashMap<>();
    9.         map.put("test1", 170.0);
    10.         map.put("test2", 160.0);
    11.         map.put("test3", 150.0);
    12.         map.put("test4", 140.0);
    13.         map.put("test5", 130.0);
    14.         map.forEach((k,v) -> {
    15.             System.out.println(k+"->"+v);
    16.         });
    17.     }
    18. }

    File

    常用方法

    只能删除空文件夹

    1. package learn11;
    2.  
    3. import java.io.File;
    4. import java.io.IOException;
    5. import java.text.SimpleDateFormat;
    6.  
    7. public class FileLearn {
    8.     public static void main(String[] args) throws IOException {
    9.         File f1 = new File("D:"+File.separator+"qq\\QQWhatsnew.txt");
    10.         System.out.println(f1.getName());
    11.         System.out.println(f1.length());
    12.         File f2 = new File("D:"+File.separator+"qq");
    13.         System.out.println(f2.length());
    14.         String[] names = f2.list();
    15.         for(String name:names){
    16.             System.out.println(name);
    17.         }
    18.         File[] files = f2.listFiles();
    19.         for(File file:files){
    20.             System.out.println(file.getAbsolutePath());
    21.         }
    22.  
    23.         File f3 = new File("src\\learn");
    24.         System.out.println(f3.length());
    25.         System.out.println(f3.getName());
    26.         System.out.println(f1.isDirectory());
    27.         System.out.println(f1.isFile());
    28.         long time = f1.lastModified();
    29.         SimpleDateFormat sdf = new SimpleDateFormat("yyy/MM/dd HH:mm:ss");
    30.         System.out.println(sdf.format(time));
    31.         System.out.println(f3.getPath());
    32.         System.out.println(f3.getAbsolutePath());
    33.         File f4 = new File("D:/testwy.txt");
    34.         System.out.println(f4.createNewFile());
    35.         File f5 = new File("D:/a/b/c");
    36.         System.out.println(f5.mkdirs());
    37.         System.out.println(f4.delete());
    38.         System.out.println(f5.delete());
    39.         System.out.println(f5.delete());
    40.         System.out.println(f5.delete());
    41.     }
    42. }

    递归

    典型例子，求阶乘

    1. package learn11;
    2.  
    3. public class jc {
    4.     public static void main(String[] args) {
    5.         System.out.println(f(5));
    6.     }
    7.  
    8.     public static int f(int n) {
    9.         if (n == 1) {
    10.             return 1;
    11.         } else {
    12.             return f(n - 1) * n;
    13.         }
    14.     }
    15. }

    递归应用-搜索文件

    1. package learn11;
    2.  
    3. import java.io.File;
    4.  
    5. public class SearchLearn {
    6.     public static void main(String[] args) {
    7.         searchFile(new File("D:/"), "QQ.exe");
    8.     }
    9.  
    10.     public static void searchFile(File dir, String fileName) {
    11.         if (dir == null || !dir.exists() || dir.isFile()) {
    12.             return;
    13.         }
    14.         File[] files = dir.listFiles();
    15.         if (files != null && files.length > 0) {
    16.             for (File f : files) {
    17.                 if (f.isFile()) {
    18.                     if (f.getName().contains(fileName)) {
    19.                         System.out.println("找到了" + f.getAbsolutePath());
    20.                     }
    21.                 } else {
    22.                     searchFile(f, fileName);
    23.                 }
    24.             }
    25.  
    26.         }
    27.     }
    28. }

    字符集

    ASCII

    首尾是0，1个字节存储一个字符，总共表示128个字符

    GBK

    一个中文字符编码成两个字节的形式存储

    GBK兼容了ASCII字符集

    Unicode字符集

    UTF-8

    英文字符、数字等只占1个字节，汉字字符占用3个字节

    IO流

    I是指input，称为输入流，负责把数据读到内存中

    O是指output，称为输出流，负责写数据出去

    IO流体系

    字节流

    字节输入流：InputStream FileInputStream

    字节输出流：OutputStream FileOutputStream

    字符流

    字符输入流：Reader FileReader

    字符输出流：Writer FileWriter

    字节流

    FileInputStream（文件字节输入流）

    每次读取一个字节
    1. package learn11;
    2.  
    3. import java.io.FileInputStream;
    4.  
    5. public class FileInputStreamMrjj {
    6.     public static void main(String[] args) throws Exception {
    7.         FileInputStream is = new FileInputStream("src\\test");
    8.         int b1 = is.read();
    9.         System.out.println((char) b1);
    10.         int b2 = is.read();
    11.         System.out.println((char) b2);
    12.         int b3 = is.read();
    13.         System.out.println(b3);
    14.         int b;
    15.         while ((b = is.read()) != -1) {
    16.             System.out.println((char) b);
    17.         }
    18.         is.close();
    19.     }
    20. }
    每次读取多个字节 
    1. package learn11;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.InputStream;
    5.  
    6. public class FileInputStreamTest {
    7.     public static void main(String[] args) throws Exception {
    8.         InputStream is = new FileInputStream("src\\test");
    9.         byte[] buffer = new byte[3];
    10.         int len;
    11.         while ((len = is.read(buffer)) != -1) {
    12.             String rs = new String(buffer, 0, len);
    13.             System.out.println(rs);
    14.         }
    15.         is.close();
    16.     }
    17. }

    上面读取方法会有中文乱码的问题，用一次性全部读取完字节，可以解决中文乱码的问题

    一次性全都读完全部字节
    1. package learn11;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.InputStream;
    6.  
    7. public class FileInputStreamAll {
    8.     public static void main(String[] args) throws Exception {
    9.         InputStream is = new FileInputStream("src\\test");
    10.         File f = new File("src\\test");
    11.         long size = f.length();
    12.         byte[] buffer = new byte[(int) size];
    13.         int len = is.read(buffer);
    14.         System.out.println(new String(buffer));
    15.         System.out.println(size);
    16.         System.out.println(len);
    17.     }
    18. }

    OutputStream FileOutputStream（文件字节输出流）

    1. package learn11;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.OutputStream;
    6. import java.nio.charset.StandardCharsets;
    7.  
    8. public class FileOutputStreamTest1 {
    9.     public static void main(String[] args) throws Exception {
    10.         OutputStream os = new FileOutputStream("src\\test", true);
    11.         os.write(97);
    12.         os.write('b');
    13. //        os.write('泰');
    14.         byte[] bytes = "中国，加油".getBytes();
    15.         os.write(bytes, 0, 9);
    16.         os.write("\r\n".getBytes());
    17.         os.close();
    18.     }
    19. }

    拷贝文件

    1. package learn11;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.FileOutputStream;
    5. import java.io.InputStream;
    6. import java.io.OutputStream;
    7.  
    8. public class CopyPicture {
    9.     public static void main(String[] args) throws Exception {
    10.         InputStream is = new FileInputStream("C:/Users/HP/Desktop/1.jpg");
    11.         OutputStream os = new FileOutputStream("D:/1.jpg");
    12.         byte[] buffer = new byte[1024];
    13.         int len;
    14.         while ((len = is.read(buffer)) != -1){
    15.             os.write(buffer,0,len);
    16.         }
    17.         os.close();
    18.         is.close();
    19.     }
    20. }

    释放资源

    try-catch-finally

    无论程序是正常执行还是出现异常了，最后一定会执行finally

    1. package learn11;
    2.  
    3. public class test1 {
    4.     public static void main(String[] args) {
    5.         try {
    6.             System.out.println(10 / 0);
    7.         } catch (Exception e) {
    8.             e.printStackTrace();
    9.         } finally {
    10.             System.out.println("finally执行了一次");
    11.         }
    12.     }
    13. }

    复制文件时应用try-catch-finally

    1. package learn11;
    2.  
    3. import java.io.*;
    4.  
    5. public class CopyPicture {
    6.     public static void main(String[] args) throws Exception {
    7.         InputStream is = null;
    8.         OutputStream os = null;
    9.         try {
    10.             is = new FileInputStream("src\\test");
    11.             os = new FileOutputStream("src\\test1");
    12.             byte[] buffer = new byte[1024];
    13.             int len;
    14.             while ((len = is.read(buffer)) != -1) {
    15.                 os.write(buffer, 0, len);
    16.             }
    17.         } catch (IOException e) {
    18.             e.printStackTrace();
    19.         } finally {
    20.             try {
    21.                 if(os != null) is.close();
    22.             } catch (IOException e) {
    23.                 e.printStackTrace();
    24.             }
    25.             try {
    26.                 if(os != null) os.close();
    27.             } catch (IOException e) {
    28.                 e.printStackTrace();
    29.             }
    30.         }
    31.  
    32.     }
    33. }
    try-with-resource

    释放资源，自动调用AutoCloseable接口

    1. package learn11;
    2.  
    3. import java.io.*;
    4.  
    5. public class CopyPicture {
    6.     public static void main(String[] args) throws Exception {
    7.         try (
    8.                 InputStream is = new FileInputStream("src\\test");
    9.                 OutputStream os = new FileOutputStream("src\\test1");
    10.         ) {
    11.  
    12.             byte[] buffer = new byte[1024];
    13.             int len;
    14.             while ((len = is.read(buffer)) != -1) {
    15.                 os.write(buffer, 0, len);
    16.             }
    17.         } catch (IOException e) {
    18.             e.printStackTrace();
    19.         }
    20.  
    21.     }
    22. }
    实用场景

    字节流适合做一切文件数据的拷贝（音视频、文本）；字节流不适合读取中文内容输出（有乱码）

    字符流

    每次读取一个字符

    1. package learn11;
    2.  
    3. import java.io.FileReader;
    4. import java.io.Reader;
    5.  
    6. public class FileReaderTest1 {
    7.     public static void main(String[] args) {
    8.         try (Reader fr = new FileReader("src\\test");) {
    9.             int c;
    10.             while ((c = fr.read()) != -1) {
    11.                 System.out.print((char) c);
    12.             }
    13.         } catch (Exception e) {
    14.             e.printStackTrace();
    15.         }
    16.     }
    17. }

    每次读取多个字符

    1. package learn11;
    2.  
    3. import java.io.FileReader;
    4. import java.io.Reader;
    5.  
    6. public class FileReaderTest1 {
    7.     public static void main(String[] args) {
    8.         try (Reader fr = new FileReader("src\\test");) {
    9.             char[] buffer = new char[3];
    10.             int len;
    11.             while ((len = fr.read(buffer)) != -1) {
    12.                 System.out.println(new String(buffer, 0, len));
    13.             }
    14.         } catch (Exception e) {
    15.             e.printStackTrace();
    16.         }
    17.     }
    18. }

    FileWriter（文件字符输出流）

    需要注意：关闭流包含了刷新流

    字符输出数据后，必须刷新流，或者关闭流。

    1. package learn11;
    2.  
    3. import java.io.FileWriter;
    4. import java.io.Writer;
    5.  
    6. public class FileWriterTest1 {
    7.     public static void main(String[] args) {
    8.         try (Writer fw = new FileWriter("src\\test",true);) {
    9.             fw.write('a');
    10.             fw.write(99);
    11.             fw.write('测');
    12.             fw.write("中国，加油！", 0, 3);
    13.             fw.write("\r\n");
    14.             char[] buffer = {'测', '试', 'a', 'b', 'c'};
    15.             fw.write(buffer);
    16.             fw.write(buffer, 0, 2);
    17.         } catch (Exception e) {
    18.             e.printStackTrace();
    19.         }
    20.     }
    21. }

    适用场景

    适合做文本文件的读写操作

  • 相关阅读:
    EN 14967:防水沥青防潮层—CE认证
    C++零碎记录（七）
    ffmpeg 4.4 cenc-aes-ctr 加解密 MP4 工程性质分析
    centost7下安装oracle11g 总结踩坑
    Ubuntu 20.04上docker安装Redis
    OSPF高级特性 —— LSA-3过滤 + Distribute-list过滤
    Sql面试50题 详解 持续更新
    Zeppelin
    WANem弱网环境模拟工具的使用探索
    The file Structure
  • 原文地址：https://blog.csdn.net/MRJJ_9/article/details/132052637