public class CookieDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决中文乱码
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");

        PrintWriter out = resp.getWriter();

        // 从客户端获取Cookie
        Cookie[] cookies = req.getCookies();

        // 判断cookies是否存在
        if (cookies != null) {
            out.write("你上次访问的时间是：");

            for (Cookie cookie : cookies) {
                if (cookie.getName().equals("lastLoginTime")) {
                    long lastLoginTime = Long.parseLong(cookie.getValue());
                    Date date = new Date(lastLoginTime);
                    SimpleDateFormat dateFormat = (SimpleDateFormat) DateFormat.getDateTimeInstance();
                    out.write(dateFormat.format(date));
                    break;
                }
            }
        } else {
            out.write("这是你第一次访问本站");
        }

        // 服务器给客户端响应一个cookie
        Cookie cookie = new Cookie("lastLoginTime", Long.toString(System.currentTimeMillis()));
        // 设置cookie过期时间，以秒为单位
        cookie.setMaxAge(24 * 60 * 60);
        resp.addCookie(cookie);
    }
}

Cookie cookie = new Cookie("JSESSIONID", sessionId);
resp.addCookie(cookie);

String password = request.getParameter("password");
HttpSession session = request.getSession();

String name = (String)session.getAttribute("userName");
session.setMaxInactiveTnterval(30 * 60);

session.setAttribute("password", password);

session.removeAttribute("password");

session.invalidate();

ServletConfig config = this.getServletConfig();
String value1 = config.getParameter("参数名1");//根据查找参数名，获取参数值

ServletContext context = this.getServletContext();
String globalValue1 = context.getInitParameter("参数名");

ServletContext context = this.getServletContext();
context.setAttribute("属性名","属性值");
String attribute = (String) context.getAttribute("属性名");//getAttribute的返回值是Object类型
context.removeAttribute("属性名");

ServletContext context = this.getServletContext();
URL url = context.getResource("外部资源配置文件的相对路径");
InputStream in = url.openStream();
/**
利用编写的一个工具类，读取属性值
String property1 = GeneralUtil.getProperty("属性名", in);
*/

public class ServletDemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// 开头的"/"表示当前web项目，具体为target下的servlet-02-1.0-SNAPSHOT目录 （目录名根据pom.xml生成）
        // 参数s 为相对路径
        InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties prop = new Properties();
        prop.load(is);
        String username = prop.getProperty("username");
        String passwd = prop.getProperty("passwd");
        resp.getWriter().print(username + ": " + passwd);
}

String realPath = context.getRealPath("外部资源配置文件的相对路径");

public class ServletDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        // 路径"/getInitParam"是在web.xml文件中配置的<servlet-mapping>的<url-pattern>
        // 开头的"/"表示当前web项目，已涵盖tomcat设置的application context部分
        // forward 实现请求转发
        context.getRequestDispatcher("/getInitParam").forward(req, resp);
    }
}

void setCharacterEncoding(String var1);

void setContentLength(int var1);

void setContentLengthLong(long var1);

void setContentType(String var1);

void setDateHeader(String var1, long var2);

void addDateHeader(String var1, long var2);

void setHeader(String var1, String var2);

void addHeader(String var1, String var2);

void setIntHeader(String var1, int var2);

void addIntHeader(String var1, int var2);

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        ServletContext context = this.getServletContext();
        String username = (String) context.getAttribute("username");

        // 设置响应内容的类型
        resp.setContentType("text/html");
        //resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("用户名：" + username);
    }
}

public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 获取下载文件的路径
        String realPath = "C:\\Users\\Hunter\\IdeaProjects\\javaweb-02-servlet\\response\\src\\main\\resources\\20180422 卡特迈国家公园和自然保护区里午睡的灰熊幼崽，阿拉斯加州 1920x1080.jpg";
        System.out.println("下载文件的路径：" + realPath);

        // 2. 下载的文件名
        String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
        // 3. 让浏览器能够支持下载，支持中文文件名编码
        resp.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "utf-8"));
        // 4. 获取下载文件的输入流
        FileInputStream fis = new FileInputStream(realPath);
        // 5. 创建缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 6. 获取Outputstream对象
        ServletOutputStream sos = resp.getOutputStream();
        // 7. 将FileOutputStream流写入到缓冲区数组，使用OutputStream将缓冲区中的数据输出到客户端
        byte[] bytes = new byte[1024]; // 存储每次读取的数据
        int len = 0; // 记录每次读取的字节个数
        while ((len = bis.read(bytes)) != -1) {
            sos.write(bytes, 0, len);
        }
        bis.close(); // 关闭缓冲流，基本流也会被自动关闭
        sos.close();
    }
}

public String replaceSpace(String s) {
	StringBuffer str = new StringBuffer(s); //将String转换为StringBuffer（可变长度）
    int P1 = str.length() - 1; //模拟指针
    for (int i = 0; i <= P1; i++)
        if (str.charAt(i) == ' ') 
            str.append("  "); //出现一个空格，就在字符串末尾添加2个任意字符

    int P2 = str.length() - 1; // 模拟指针，初始指向 将空格替换后的最后一位
    while (P1 >= 0 && P2 > P1) { //从后往前遍历，能保证原来的字符串不会因为替换字符而改变
        char c = str.charAt(P1--); // 获取原始字符串的最后一位字符
        if (c == ' ') {
            str.setCharAt(P2--, '0');
            str.setCharAt(P2--, '2');
            str.setCharAt(P2--, '%');
        } else {
            str.setCharAt(P2--, c);
        }
    }
    return str.toString();
}

public int[] spiralOrder(int[][] matrix) {
        if (matrix.length == 0) { // 矩阵为空
            return new int[0];
        }

        int left = 0;
        int right = matrix[0].length - 1;
        int top = 0;
        int bottom = matrix.length - 1;
        int[] result = new int[(right + 1) * (bottom + 1)];
        int index = 0;

        while(true) {
            for (int i = left; i <= right; i++)  // 遍历top行
                result[index++] = matrix[top][i];
            if (++top > bottom) // 没有新的行，则遍历完成
                break;

            for (int i = top; i <= bottom; i++) 
                result[index++] = matrix[i][right];
            if (--right < left) // 没有新的列
                break;

            for (int i = right; i >= left; i--) 
                result[index++] = matrix[bottom][i];
            if (--bottom < top) // 没有新的行
                break;
            
            for (int i = bottom; i >= top; i--) 
                result[index++] = matrix[i][left];
            if (++left > right) // 没有新的列
                break;
        }
        return result;
    }

public char firstUniqChar(String s) {
    HashMap<Character, Boolean> hm = new HashMap(); // 用布尔值表示是否只有一个字符，比用Integer统计出现次数节约空间
    char[] s2c = s.toCharArray();
    for(char c : s2c) {
        hm.put(c, !hm.containsKey(c)); // 如果已有该字符，false；否则true
    }
    for(char c : s2c) { // 按字符顺序遍历，能返回第一个只出现一次的字符
        if(hm.get(c) == true)
            return c;
    }
    return ' ';
}

private LinkedList<Integer> list1, list2;

public CQueue() {
    list1 = new LinkedList<>();
    list2 = new LinkedList<>();
}

public void appendTail(int value) {
    list1.addLast(value); // 加到链表尾部
}

public int deleteHead() {
    if (!list2.isEmpty()) { //list2中的元素都在list1之前进入栈中
        return list2.removeLast();
    }
    if (list1.isEmpty()) { //模拟的队列中没有元素了
        return -1;
    }

    while (!list1.isEmpty()) { //将list1中已存在的元素都移入list2中
        list2.addLast(list1.removeLast());
    }
    return list2.removeLast();
}

private LinkedList<Integer> stack, minStack;

public MinStack() {
    stack = new LinkedList<>();
    minStack = new LinkedList<>();
}

public void push(int x) { //插入元素，同时记录当前最小的元素
    stack.addLast(x);
    minStack.addLast(minStack.isEmpty() ? x : Math.min(minStack.getLast(), x));
}

public void pop() { // 同步更新最小值
    stack.removeLast();
    minStack.removeLast();
}

public int top() {
    return stack.getLast();
}

public int min() {
    return minStack.getLast();
}

public boolean validateStackSequences(int[] pushed, int[] popped) {
    if(pushed.length == 0)
        return true;
    LinkedList<Integer> stack = new LinkedList<> ();
    int i = 0;
    for(int num : pushed) { // 遍历入栈顺序数组
        stack.addFirst(num); // 入栈
        while(!stack.isEmpty() && stack.getFirst() == popped[i]) { // 当前栈不为空，且 栈顶元素为出栈元素时
            stack.removeFirst(); // 出栈
            i++;
        }
    }
    return stack.isEmpty(); // 如果都顺利出栈，则说明弹出序列是正确的
}

public int[] getLeastNumbers(int[] arr, int k) {
        if (k >= arr.length)
            return arr; //不限制输出顺序
        return quickSort(arr, k, 0, arr.length - 1);
    }

    private int[] quickSort(int[] arr, int k, int left, int right) {
        int i = left, j = right;
        while (i < j) { // 分别从左右开始，直至"相遇"；默认取第一个元素为哨兵（arr[left]）
            while (i < j && arr[j] >= arr[left]) { // 从右往左，找到比哨兵小的数（且保证左右未相遇）
                j--;
            }
            while (i < j && arr[i] <= arr[left]) { // 从左往右，找到比哨兵大的数
                i++;
            }
            swap(arr, i, j); // 交换位置（比哨兵小的放在左边，大的放在右边）
        }
        swap(arr, i, left); // 将哨兵置于最终位置i
        // 【递归判断】优化时间复杂度的关键
        if (i > k) { // 确认最终位置的哨兵，其左侧的数 > k，比最终需要的数多，继续递归
            return quickSort(arr, k, left, i - 1);
        }
        if (i < k) {
            return quickSort(arr, k, i + 1, right);
        }
        return Arrays.copyOf(arr, k); //哨兵左侧的数 = k 个，复制数组左侧的k个数，无需再进行完整的排序
    }

    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

private Queue<Integer> minHeap, maxHeap;

public MedianFinder() {
    minHeap = new PriorityQueue<>(); // 默认构造小顶堆，保存较大的一半
    maxHeap = new PriorityQueue<>((x, y) -> (y - x)); //lambda表达式，大顶堆，保存较小的一半
}

public void addNum(int num) {
    if (minHeap.size() == maxHeap.size()) { // 添加新的整数后，会是奇数个数值
        maxHeap.offer(num);
        minHeap.offer(maxHeap.poll()); //取出最大堆中最大的数放入最小堆中 --> 中位数在最小堆的堆顶
    } else { // 添加新的整数后，会是偶数个数值（奇数个数值时，最小堆的数值更多）
        minHeap.offer(num);
        maxHeap.offer(minHeap.poll()); // 取出最小堆中的最大数放入最大堆
    }
}

public double findMedian() {
    return minHeap.size() == maxHeap.size() ? (minHeap.peek() + maxHeap.peek()) / 2.0 : minHeap.peek();
}

private Deque<Integer> deque;
public int[] maxSlidingWindow(int[] nums, int k) {
    if(nums.length == 0) {
        return new int[0];
    }
    int[] result = new int[nums.length - k + 1];
    int index = 0;
    deque = new LinkedList<>(); //双端队列，存储每个窗口中的最大值
    // 先形成一个窗口
    for(int i = 0; i < k; i++) {
        while(!deque.isEmpty() && deque.getLast() < nums[i]) { // 队列不为空，且队尾元素 < 当前进入窗口的数字
            deque.removeLast();
        }
        deque.addLast(nums[i]);
    }
    result[index++] = deque.getFirst(); // 第一个窗口中的最大值入队
    // 窗口形成后
    for(int i = k; i < nums.length; i++) {
        if(nums[i - k] == deque.getFirst()) // 如果滑出窗口的数是队首数字
            deque.removeFirst(); // 队首数字也出队
        while(!deque.isEmpty() && deque.getLast() < nums[i]) { // 队列不为空，且队尾元素 < 当前进入窗口的数字
            deque.removeLast();
        }
        deque.addLast(nums[i]);
        result[index++] = deque.getFirst();
    }
    return result;
}

public int[] twoSum(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while(left < right) {
        if(nums[left] + nums[right] == target) {
            return new int[] {nums[left], nums[right]};
        } else if (nums[left] + nums[right] < target) { //需要更大的数
            left++;
        } else (nums[left] + nums[right] > target) { //需要更小的数
            right--;
        }
    }
    return new int[0];
}

public int[][] findContinuousSequence(int target) {
    int left = 1, right = 2;
    List<int[]> list = new ArrayList<>();
    int sum = 3; // 初始滑动窗口中数字的和
    while (left <= target / 2) {
        if (sum == target) {
            int[] result = new int[right - left + 1];
            for(int i = 0; i < right - left + 1; i++) {
                result[i] = left + i;
            }
            list.add(result);
        }
        if (sum < target) { // 向右移动右指针
            sum += ++right;
        } else { // 连续正数的和 >= target
            sum -= left++; //向右移动左指针
        }
    }
    return list.toArray(new int[0][]); //参数为 返回的数组类型(存储数组的数组)，不指定则为Object
}

public String reverseWords(String s) {
    s = s.trim(); // 去除首尾空格
    StringBuilder sb = new StringBuilder();
    int i = s.length() - 1;
    int j = i;
    while (i >= 0) {
        while(i >= 0 && s.charAt(i) != ' ') { //找到句中空格或遍历结束
            i--;
        }
        sb.append(s.substring(i+1, j + 1) + ' ');
        while(i >= 0 && s.charAt(i) == ' ') { //跳过多余的空格
            i--;
        }
        j = i;
    }
    return sb.toString().trim();
}

public String reverseLeftWords(String s, int n) {
    StringBuilder sb = new StringBuilder();
    sb.append(s.substring(n, s.length()));
    sb.append(s.substring(0, n));
    return sb.toString();
}

public int[] reversePrint(ListNode head) {
    List<Integer> list = new ArrayList<>();
    while(head != null) {
        list.add(head.val);
        head = head.next;
    }
    int[] result = new int[list.size()];
    for(int i = result.length - 1; i >= 0; i--) {
        result[i] = list.get(result.length - 1 - i);
    }
    return result;
}

public ListNode deleteNode(ListNode head, int val) {
    if(head.val == val) { // 头结点即为被删的节点
        return head.next;
    }
    ListNode pre = head;
    ListNode cur = pre.next;
    while(cur.val != val) {
        pre = cur;
        cur = cur.next;
    }
    pre.next = cur.next;
    return head;
}

public ListNode getKthFromEnd(ListNode head, int k) {
    ListNode right = head;
    ListNode left = head;
    for(int i = 0; i < k; i++) { //只要让第二个指针落后于第一个指针k位，遍历完成时，即能得到倒数第k个节点
        right = right.next;
    }
    while(right != null) {
        right = right.next;
        left = left.next;
    }
    return left;
}

public ListNode detectCycle(ListNode head) {
    ListNode fast = head; // 创建一快一慢的指针，快的速度是慢的2倍
    ListNode slow = head;
    while(fast != null && slow != null) {
        fast = fast.next.next; // 一次前进两个节点
        slow = slow.next; // 一次前进一个节点
        if(fast == slow) { // 快的指针追上了慢的指针，说明存在环
            slow = head;
            while (slow != fast) {
                slow = slow.next;
                fast = fast.next;
            }
            return fast;
        }
    }
    return null;
}

public ListNode reverseList(ListNode head) {
    ListNode cur = head; // 1
    if(cur == null) {
        return null;
    }
    ListNode nextNode = cur.next; // 2
    head.next = null;
    ListNode preNode = head; // 1
    while(nextNode != null) {
        cur = nextNode; // 2
        nextNode = nextNode.next; // 3
        cur.next = preNode; // 1
        preNode = cur; 
    }
    return cur;
}

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    ListNode head = new ListNode(1); // 创建一个任意的节点
    ListNode cur = head;
    while(l1 != null && l2 != null) {
        if(l1.val <= l2.val) {
            cur.next = l1;
            l1 = l1.next;
        } else {
            cur.next = l2;
            l2 = l2.next;
        }
        cur = cur.next;
    }
    cur.next = l1 != null ? l1 : l2;
    return head.next;
}

public Node copyRandomList(Node head) {
    Map<Node, Node> hm = new HashMap<>();
    Node cur = head;
    while(cur != null) { // 构建节点的映射
        hm.put(cur, new Node(cur.val)); 
        cur = cur.next;
    }
    cur = head;
    while(cur != null) {
        hm.get(cur).next = hm.get(cur.next); // 只有这样，才能获得新地址下的Node
        hm.get(cur).random = hm.get(cur.random);
        cur = cur.next;
    }
    return hm.get(head);
}

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    int step1 = 0, step2 = 0;
    ListNode A = headA, B = headB;
    while(A != null) {
        step1++;
        A = A.next;
    }
    while(B != null) {
        step2++;
        B = B.next;
    }
    int step = step1 - step2;
    A = headA;
    B = headB;
    if(step < 0) { // 第一个链表比较短
        while(step != 0) {
            B = B.next;
            step++;
        }
    } else if(step > 0) { // 第一个链表比较长
        while (step != 0) {
            A = A.next;
            step--;
        }
    }
    while (A != B) {
        A = A.next;
        B = B.next;
    }
    return A;
}

public int majorityElement(int[] nums) {
    int target = nums[0], times = 1;
    for(int i = 1; i < nums.length; i++) {
        if (target != nums[i]) {
            times--;
        } else {
            times++;
        }
        if (times == 0) {
            target = nums[i];
            times = 1;
        }
    }
    return target;
}

public int countDigitOne(int n) {
    int digit = 1, res = 0;
    int high = n / 10, cur = n % 10, low = 0; // 高位，当前位，低位；从个位开始统计
    while(high != 0 || cur != 0) {
        if(cur == 0) { // 当前位最大为0
            res += high * digit; // 该位出现1的次数，由高位决定
        } else if(cur == 1) { //当前位最大为1
            res += high * digit + low + 1; // 该位出现1的次数 由高位和低位决定
        } else { // 当前位最大 > 1
            res += (high + 1) * digit;
        }
        low += cur * digit;
        cur = high % 10;
        high /= 10;
        digit *= 10;
    }
    return res;
}

File f = new File("C:\\download\\xx.torrent");

// 如果路径不存在，没有必要进行后续的判断
if(f.exists()) {
    System.out.println(f.isFile());
}

public static void listAllFiles(File dir) {
    if (dir == null || !dir.exists()) {
        return;
    }
    if (dir.isFile()) {
        System.out.println(dir.getName());
        return;
    }
    for (File file : dir.listFiles()) {
        listAllFiles(file);
    }
}

FileOutputStream fos = new FileOutputStream("C:\\download\\xx.md");
byte[] bytes = "Hellow World!".getBytes();

System.out.println(Arrays.toString(bytes)); // 可以看到字符串转换成字节数组后，再将字节数组转换为字符串形式
System.out.println(new String(bytes)); // 可以看到字符串转换成字节数组后，再转换为字符串

fos.write(bytes);

fos.close();

fos.write("\r\n".getBytes());

FileInputStream fis = new FileInputStream("C:\\download\\xx.md");

int len; // 存储读取的字节
while ((len = fis.read()) != -1) {
    System.out.print((char)len);
}

fis.close();

public static void copyFile(String src, String dist) throws IOException {
    FileInputStream fis = new FileInputStream(src);
    FileOutputStream fos = new FileOutputStream(dist);

    byte[] buffer = new byte[20 * 1024];
    int cnt;

    // read() 最多读取 buffer.length 个字节
    // 返回的是实际读取的个数
    // 返回 -1 的时候表示读到 eof，即文件尾
    while ((cnt = fis.read(buffer)) != -1) { // 该read方法返回每次读取的有效字节个数
        fos.write(buffer, 0, cnt);
    }

    fis.close();
    fos.close();
}

FileWriter fw = new FileWriter("C:\\download\\xx.md");

fw.write(97); // 不会直接写入文件，而是写入内存缓冲区
fw.flush();

fw.close(); 

fw.writer("\r\n");

FileReader fr = new FileReader("C:\\download\\xx.md");


int len; // 存储读取的【字符】
while ((len = fr.read()) != -1) { // 一次读取一个字符
    System.out.print((char)len);
}


// 一次读取多个字符
char[] chars = new char[2 * 1024];
len = 0; // 记录有效字符个数
while((len = fr.read(chars) != -1)) {
    /*
    	String类的构造方法
    	String(char[] value) 把字符数组转换为字符串
    	String(char[] value, int offset, int count) 把字符数组的一个
    */
    System.out.println(new String(chars, 0, len));
}

fr.close();

// 提高变量fw的作用域，让finally能使用
FileWriter fw = null; // 必须初始化，避免try中发生异常时，fw还没有被赋值，导致finally中的代码无法正常执行。
try {
    // 可能会产生异常的代码
    fw = new FileWriter("C:\\download\\xx.md", true);
    for (int i = 0; i < 10; i++) {
        fw.write("Hellow world!" + i + "\r\n");
    }
    fw.close();
} catch (IOException e) {
	// 异常的处理逻辑
    System.,out.println(e);
} finally {
    // 资源释放
    // 如果创建对象FileWriter对象失败，fw为null，null无法调用方法，会抛出空指针异常，需要增加一个判断
    if(fw != null) {
        try {
            fw.close(); // close方法本身也声明会抛出异常对象，因此也要处理
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

try (// 1. 创建一个字节输入流对象，构造方法中绑定要读取的数据源
    FileInputStream fis = new FileInputStream("C:\\download\\xx.md");
    // 2. 创建一个字节输出流对象，构造方法中绑定要写入的文件
    FileOutputStream fos = new FileOutputStream("D:\\download\\1.jpg")) {

    int len = 0;
    while((len = fis.read()) != 1) {
        fos.write(len);
    }
} catch (IOException e) {
    System.out.println(e);
}

// 创建Properties集合对象
Properties prop = new Properties();

// 使用setProperty往集合中添加数据
prop.setProperty("邓肯", "21");
prop.setProperty("吉诺比利", "20");
prop.setProperty("吉诺比利", "9");

// 把Properties集合中的键取出，存储到一个Set集合中
Set<String> set = prop.stringPropertyNames();

// 遍历Set集合，获取每个键对应的值
for (String key : set) {
    String value = prop.getProperty(key);
    System.out.println(key + "=" + value);
}

// 创建Properties集合对象
Properties prop = new Properties();

// 使用setProperty往集合中添加数据
prop.setProperty("邓肯", "21");
prop.setProperty("吉诺比利", "20");
prop.setProperty("吉诺比利", "9");

FileWriter fw = new FileWriter("C:\\download\\xx.md");

prop.store(fw, "save data");

fw.close();

// 创建Properties集合对象
Properties prop = new Properties();

// 读取键值对文件
prop.load(new FileReader("C:\\download\\xx.md"));

// 遍历集合
for (String key : set) {
    String value = prop.getProperty(key);
    System.out.println(key + "=" + value);
}

fw.close();

// 1.
FileOutputStream fos = new FileOutputStream("C:\\download\\xx.md");

// 2.
BufferedOutputStream bos = new BufferedOutputStream(fos);

// 3.
bos.write("把数据写入到内部缓冲区中".getBytes());

bos.flush();

bos.close(); // 关闭缓冲流，基本流也会被自动关闭

// 1.
FileInputStream fis = new FileInputStream("C:\\download\\xx.md");

// 2.
BufferedInputStream bis = new BufferedInputStream(fis);

// 3.
byte[] bytes = new byte[1024]; // 存储每次读取的数据
int len = 0; // 记录每次读取的字节个数
while((len = bis.read(bytes)) != -1) {
    System.out.println(new String(bytes, 0 ,len));
}

bis.close(); // 关闭缓冲流，基本流也会被自动关闭

long s = System.currentTimeMills(); // 测试程序效率

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\download\\xx.md"));

BufferedOutStream bos = new BufferedOutputStream(new FileOutputStream("C:\\download\\yy.md"));

byte[] bytes = new byte[1024]; // 存储每次读取的数据
int len = 0; // 记录每次读取的字节个数
while((len = bis.read(bytes)) != -1) {
    bos.write(bytes, 0, len);
}

bis.close();
bos.close();

long e = System.currentTimeMills(); // 测试程序效率
System.out.println("程序共耗时：" + (e - s) + "毫秒");

BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\download\\xx.md"));

for(int i = 0; i < 10; i++) {
    bw.write("机智医生生活");
    bw.newLine(); // 换行（根据不同的操作系统，获取不同的行分隔符）
}

bw.flush();
bw.close(); // 关闭缓冲流，基本流也会被自动关闭

BufferedReader br = new BufferedReader(new FileReader("C:\\download\\xx.md"));

String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}

br.close();

String str1 = "中文";
byte[] bytes = str1.getBytes("UTF-8");
String str2 = new String(bytes, "UTF-8");
System.out.println(str2);

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C:\\download\\xx.md"), "GBK");

osw.write("机智医生生活"); // 不会直接写入文件，而是写入内存缓冲区（编码过程）
osw.flush();

osw.close(); 

InputStreamReader isr = new InputStreamReader(new FileInputStream("C:\\download\\xx.md"), "GBK");

int len = 0;
while((len = isr.read() != -1)) {
    System.out.println((char)len);
}

// 一次读取多个字符
char[] chars = new char[2 * 1024];
len = 0; // 记录有效字符个数
while((len = isr.read(chars) != -1)) {
    System.out.println(new String(chars, 0, len));
}
isr.close(); 

InputStreamReader isr = new InputStreamReader(new FileInputStream("C:\\download\\xx.md"), "GBK");

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C:\\download\\yy.md"), "UTF-8");

int len = 0;
while((len = isr.read() != -1)) {
    osw.write(len);
}

public static void main(String[] args) throws IOException, ClassNotFoundException {

    A a1 = new A(123, "abc");
    String objectFile = "C:\\download\\a1.md";

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(objectFile));
    oos.writeObject(a1);
    oos.close();

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(objectFile));
    A a2 = (A) ois.readObject(); // 类型转换
    ois.close();
    System.out.println(a2);
}

private static class A implements Serializable {

    private int x;
    private String y;

    A(int x, String y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "x = " + x + "  " + "y = " + y;
    }
}