IO流（字符流）

字符流

一.字符流是什么

• 字符流是可以直接读取字符的IO流
• 字符流读取字符，就要先读去到字节数据，然后转为字符，如果要写出字符，需要把字符转为字节再写出

FileReader

• FileReader类的read()方法可以按照字符大小读取

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo1_FileReader {
    

	public static void main(String[] args) throws IOException {
    
		demo1();
		FileReader fr = new FileReader("xxx.txt");
		int x;
		while((x = fr.read()) != -1) {
       //通过项目默认的码表，一次读取一个字符
			System.out.print((char)x);
		}
		fr.close();
	}

	public static void demo1() throws FileNotFoundException, IOException {
    
		FileReader fr = new FileReader("xxx.txt");//需要创建xxx.txt，如果没有就报错
		int x = fr.read();         //read方法返回jdk码值
		System.out.println(x);    
		char c = (char)x;          //要想得到字符，要将码值向下强转成对应的字符
		System.out.println(c);
		fr.close();
	}

}

FileWriter

• FileWrirer类的write()方法可以自动把字符转为字节写出

import java.io.FileWriter;
import java.io.IOException;

public class Demo2_FileWriter {
    

	public static void main(String[] args) throws IOException {
    
		FileWriter fw = new FileWriter("yyy.txt"); //如果有文件直接写，没有文件就创建一个再写
		fw.write("zt是傻x");
		fw.write(122);
		fw.close();
	}

}

拷贝文件

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo3_Copy {
    

	public static void main(String[] args) throws IOException {
    
		FileReader fr = new FileReader("xxx.txt");
		FileWriter fw = new FileWriter("yyy.txt");
		
		int x;
		while((x = fr.read()) != -1) {
    
			fw.write(x);
		}
		fr.close();
		fw.close();
		//Write类中有一个2k的小缓冲区，如果不关流，会将文件内容留到缓冲区中，关流会将缓冲区的内容刷新，再关闭
	}

}

一.什么情况下使用字符流

• 字符流也可以拷贝文件，但不推荐使用，因为读取是会酱紫结转为自负，写出时还要将字符转为字节,很麻烦

那什么时候用呢?

• 程序需要只读取一段文本时用字符流，因为读取的时候是按大小读取的，不会出现半个中文
• 程序需要只写出一段文本时用字符流，因为写出的时候可以直接按字符串写出，不用转换为字符数组

二.字符流是否可以拷贝非纯文本文件

• 不可以，因为在读的时候会将字节转换为字符，在转的过程中，可能找不到对应的字符，就用?代替，
  写出的时候会将字符转为字节写出去，如果是?，直接写出，这样写出的文件就乱了.

三.自定义字符数组的拷贝

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo3_Copy {
    
	public static void main(String[] args) throws IOException {
    
		//自定义字符数组的拷贝
		FileReader fr = new FileReader("xxx.txt");
		FileWriter fw = new FileWriter("yyy.txt");
		
		char[] arr = new char[1024];
		int len;
		while((len = fr.read()) != -1) {
           //将文件的数据读取到字符数组中
			fw.write(arr,0,len);               //将字符数组中的数据写到文件中
		}
		fr.close();
		fw.close();
	}
}

带缓冲区的字符流

一.带缓冲区的流中的常规方法

• BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区，然后逐个返回给程序，降低读取文件的次数，提高效率
• BufferedWriter的Writer()方法写出字符时会先写到缓冲区，缓冲区写满后才会写到文件，降低写文件的次数，提高效率

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo3_Copy {
    
	public static void main(String[] args) throws IOException {
    
		BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("yyy.txt"));
		
		int c;
		while((c = br.read()) != -1) {
    
			bw.write(c);
		}
		br.close();
		bw.close();
	}
}

二.带缓冲区的流中的特殊方法

• BufferedReader的readLine()方法可以读取一行字符(不包括换行符号)
• BufferedWriter的newLine()可以输出一个跨平台的换行符号

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo4_Buffered {
    

	public static void main(String[] args) throws IOException {
    
		//demo1();
		BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("yyy.txt"));
		
		String line;
		while((line = br.readLine()) != null) {
    
			bw.write(line);
			//bw.newLine();             //写出回车换行符
			bw.write("\r\n");
		}
		br.close();
		bw.close();
	}

	public static void demo1() throws FileNotFoundException, IOException {
    
		BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));
		
		String line;//readLine返回一行字符串，用String接收
		while((line = br.readLine()) != null) {
    
			System.out.println(line);
		}
		br.close();
	}

}

newLine()与\r\n的区别

• newLine()是跨平台的方法
• \r\n只支持Windows系统

LineNumberReader

• LineNumberReader是BufferedReader的子类，具有相同的功能，并且可以统计行号
• 调用getLineNumber()方法可以获取当前行号
• 调用setLineNumber()方法可以设置当前行号

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class Demo5_LineNumberReader {
    

	public static void main(String[] args) throws IOException {
    
		LineNumberReader lnr = new LineNumberReader(new FileReader("zzz.txt"));
		
		String line;
		lnr.setLineNumber(100); //设置开始编号
		while((line = lnr.readLine()) != null) {
    
			System.out.println(lnr.getLineNumber() + ":" + line);
			//101:a 102:b 103:c 104:d 105:e
		}
		lnr.close();
 	}

}

装饰设计模式

一. 装饰设计模式的好处是

• 耦合性不强，被装饰类的变化与装饰类的变化无关

public class Demo6_Warp {
    

	public static void main(String[] args) {
    
		HeiMaStudent hs = new HeiMaStudent(new Student());//向装饰类中传入被装饰类
		hs.code();
		//javase javaweb ssh 数据库 大数据
	}

}

interface Coder {
    
	public void code();
}

class Student implements Coder {
    //被装饰类

	@Override
	public void code() {
    
		System.out.println("javase");
		System.out.println("javaweb");
	}
	
}

class HeiMaStudent implements Coder {
    //装饰类
	//1.获取装饰类的引用
	private Student s;
	//2.在构造方法中传入被装饰的对象
	public HeiMaStudent(Student s) {
    
		this.s = s;
	}
	//3.对原有功能升级
	@Override
	public void code() {
    
		s.code();
		System.out.println("shh");
		System.out.println("数据库");
		System.out.println("大数据");
	}
	
}

使用指定的码表读写字符

• FileReader是使用默认码表读取文件，如果需要使用指定码表读取，那么可以使用InputStreamReader(字节流对象,编码表)：字节转字符
• FileWriter是使用默认码表写出文件，如果需要使用指定码表写出，那么可以使用InputStreamWriter(字节流对象,编码表)：字符转字节

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class Demo7_TransIO {
    

	public static void main(String[] args) throws IOException {
    
		//demo1();
		//demo2();
		//demo3();
	}

	public static void demo3() throws UnsupportedEncodingException, FileNotFoundException, IOException {
    
		//使用BufferedReader，BufferedWriter包装类包装InputStreamReader，使其更强大
		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("utf-8.txt"), "utf-8"));//更高效地读
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk"));//更高效的写
		
		int c;
		while((c = br.read()) != -1) {
    
			bw.write(c);
		}
		br.close();
		bw.close();
	}

	public static void demo2() throws UnsupportedEncodingException, FileNotFoundException, IOException {
    
		//使用指定的码表读写字符
		InputStreamReader isr = new InputStreamReader(new FileInputStream("utf-8.txt"), "uTf-8");  //指定码表读字符
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk");//指定码表写字符
		
		int c;
		while((c = isr.read()) != -1) {
    
			osw.write(c);
		}
		isr.close();
		osw.close();
	}

	public static void demo1() throws FileNotFoundException, IOException {
    
		//根据默认编码表读写，出现乱码
		FileReader fr = new FileReader("utf-8.txt");//使用utf-8码表读（你好你好）
		FileWriter fw = new FileWriter("gbk.txt");//使用gbk码表写（浣犲ソ浣犲ソ）
		
		int c;
		while((c = fr.read()) != -1) {
    
			fw.write(c);
		}
		fr.close();
		fw.close();
	}

}

包装类图解

递归

一.概述

• 方法自己调用自己

二.递归的利与弊

• 递归的弊端：不能调用次数太多，容易导致栈内存溢出
• 递归的好处：不用知道循环次数

三.构造方法不能使用递归调用
四.递归调用是否必须有返回值？

• 不一定(可以有，可以没有)

public class Demo8_Digui {
    

	public static void main(String[] args) {
    
		System.out.println(fun(6));
	}

	public static int fun(int n) {
    
		if(n == 1)
			return 1;
		else
			return n * fun(n-1);
	}
	
}

案例演示

获取某个文件夹下的所有.java文件，递归打印

import java.io.File;
import java.util.Scanner;

public class Test5 {
    

	public static void main(String[] args) {
    
		File dir = getDir();
		printJavaFile(dir);
	}
	
	public static File getDir() {
    
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个文件夹路径：");
		while(true) {
    
			String line = sc.nextLine();
			File dir = new File(line);       //封装成File文件
			if(!dir.exists()) {
    
				System.out.println("您输入的文件夹不存在,请重新输入：");
			} else if(dir.isFile()) {
    
				System.out.println("您输入的是文件,请重新输入：");
			} else {
    
				return dir;
			}
		}
	}
	
	public static void printJavaFile(File dir) {
    
		File[] subFiles = dir.listFiles();   //创建文件夹数组存储文件和文件夹
		for (File subFile : subFiles) {
    
			if(subFile.isFile() && subFile.getName().endsWith(".java")) {
    
				System.out.println(subFile);
			} else if(subFile.isDirectory()) {
    
				printJavaFile(subFile);//递归
			}
		}
	}
	
}