2020.8.3输入输出流（一）

                                   输入、输出处理（一）

Java输入输出是站在程序角度上看
java.io.File类用于操作文件和目录
File类常用方法：

绝对路径：绝对路径就是你的主页上的文件或目录在硬盘上真正的路径，从盘符出发，找到文件。
相对路径：从当前的位置出发找到文件。

流：通过流来读写文件。流是一组有序的数据序列，以先进先出方式发送信息的通道
Java流的分类：

InputStream类常用方法：（抽象基类）

int read（）：
从输入流一个字节一个字节的读，返回的是该字节的整数表示形式，如果读到了输入流的末尾，返回-1
int read(byte[] b):
从输入流读取若干字节，把这些字节保存到数组b中。返回的是读取到的字节数，如果读到了输入流的末尾，返回-1
int read（byte，int off,int len):
从输入流读取若干字节，把这些字节保存到数组b中。返回的是读取到的字节数，如果读到了输入流的末尾，返回-1,off指的是字节数组中开始保存数据的起始下标。len读取的字节数目。返回的是读取到的字节数
使用FileInputStream读文本文件的步骤：
close：关闭输入流

OutputStream类常用方法：

write（int）：往输出流中写入一个个的字节
write（byte[]):往输出流中写入一个字节数组
close：关闭输出流
void flush（）：强制把缓冲区的数据写到输出流中、off指的是字节off位置开始往外写
len代表往外写len的长度的字节
子类FileOutStream常用的构造方法：

题目：

补充：

StringBuilder跟StringBuffer方法基本相同，前者多了一个Insert方法
线程安全：synchronized 保证线程间隔离
前者线程不安全，速度块，后者线程安全，速度慢；
String：不可被改变，真正意义上的安全，在频繁字符串拼接的情况下，速度非常慢
绝对路径：一般从根目录开始，写全路径
相对路径：从当前目录开始
FileInputStream读文件的流程：
FileInputStream对象和String对象声明
创建FileInputStream对象（文件路径或Filed对象）
读单字节或整个读到byte数组中
转成字符串
关闭FileInputStream流
返回结果
FileOutputStream写文件的流程：
File对象装载文件路径
判断文件父级目录是否存在，不存在则创建
声明FileOutputStream对象
创建FileOutputStream对象（File对象，是否追加）
把要写的字符串转成byte数组，并写入输出流
关闭FileOutputStream对象
代码：
读取：
public class TestFileInputStream {
public static void main(String[] args) throws IOException {
// File file = new File(“D:/myDoc/hello.txt”);
// FileInputStream fis = new FileInputStream(file);
//// int tmp;
//// while ((tmp = fis.read()) != -1) {
//// System.out.print((char)tmp);
//// }
// byte[] b = new byte[1024];
// fis.read(b);
// byte[] rst = null;
// for (int i = 0; i < b.length; i++) {
// if (b[i] == 0) {
// rst = Arrays.copyOf(b, i);
// break;
// }
// }
// String str = new String(rst);
// System.out.println(str);
String s = readFile(“D:/myDoc/test.txt”);
// String s = readByOne(“D:/myDoc/test.txt”)
System.out.println(s);
}

public static String readFile(String path) {
//数组的方式
File f =new File(path);
FileInputStream fis= null;
String str = null;
try {
fis = new FileInputStream(path);
byte[] b = new byte[fis.available()];
fis.read(b);
str = new String(b);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return str;
}

public static String readByOne(String path) {
//字节的方式
FileInputStream fis = null;
String str = null;
try {
fis = new FileInputStream(path);
StringBuffer sb = new StringBuffer();
int tmp;
while ((tmp = fis.read()) != -1) {
char c = (char) tmp;
sb.append©;
}
str = sb.toString();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return str;
}
}

输入：
public class TestFileOutputStream {
public static void main(String[] args) throws IOException {
String str = “How do you do.\r\nFine,thanks,and you?\r\nThat’s OK”;
// FileOutputStream fos = new FileOutputStream(“def.txt”,true);
// byte[] b = str.getBytes();
// fos.write(b);
// fos.close();
writeFile(str, “txt/a.txt”, true);
}

public static void writeFile(String str,String path,boolean isAppend) {
File f =new File(path);
if (!f.getParentFile().exists()) {
f.getParentFile().mkdirs();
}
FileOutputStream fos = null;
try {
fos = new FileOutputStream(f,isAppend);
byte[] b = str.getBytes();
fos.write(b);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}

}
}