java基础专栏—IO（1）

摘要: 笔者在java学习的这条道路上也是断断续续走了一年多了，视频啊，书籍啊什么的也看了好几遍了，真的是java从入门到放弃啊，哈哈，看的多了一渐渐的明白了一点东西，笔者整理了一些自己的学习笔记，在此与大家分享，不喜勿喷，多多指教，万分感谢。

IO

File类

文件，文件夹，路径

file

就是文件路径，文件，文件夹的抽象类。

//file的三种够着函数public File(String pathName)

File file = new File("d:\\xxxx");
//只负责抽象出对象，提供方法，不管路径是否存在
public File(String father, String child)

public File(File parent, String child)

public boolean createNewFile(String name)
//只能从创建文件不能创建文件夹
public boolean mdirs()

public boolean delete()

public File getAbsoluteFile()

public boolean exists()

public boolean isDirectory()

//list listFile获取功能
public String[] list()
//得到File中的文件和文件夹名的集合
public File[] listFile()

文件过滤器

遍历一个文件对象的时候可以根据需求选择合适的文件

在listFile的重载方法的基础上

public File[] listFile(FileFilter filter)

实现

接口FileFilter

并实现内部方法

public boolean accept(File pathName)

for example：

public boolean accept(File file){

​ return file.getName().endWith(".java")

}

**原理：**实现了FileFilter的类就会调用accept

File file = new File("xxxx");
File[] fileArr = file.listFile(new xxxxFilter());

​ listFile先遍历File对象，然后将获得的文件名的全路径，用过滤器传递给accept方法进行判断，最后返回true的就装进File[]

对目录的全遍历

public static getAllDir(File dir){
File[] fileArray = dir.list;
for(File file : fileArray){
if(file.isDirectory){
getAllDir(file);
}else{
System.out.println(file);
}
}
}

字节流

​ 在存储中，任何一个文件个的最小单位都是Byte，字节流就是操作最小的存储单元，对于任何的文件都可以操作，每次只操作一个字节，可以写一个文件，也可以读取文件，但是

文件夹不是文件

。

字节输出流-OutputStream

|--java.io.OutputStream所有的字节输出流的超类

public void

public Byte write(int b)写入一个字节

public Byte write(byte[] b)写入b.length长度的字节

public Byte write(byte[] b, int index, int howmunch)写谁，从哪开始写，写几个字节

public void close()

public void flush()

FileOutputStream

​ 流对象的构造方法都是用来绑定数据目的，

File对象

String串

public FileOutputStream(){

}

流对象的操作

创建流对象，绑定数据对象，

注意文件被覆盖

调用流对象的write()

close()释放资源

FileOutputStream fos = new FileOutputStream("流对象");
//构造方法会自动创建，如果有，就会将数据覆盖
//FileNotFoundException
fos.write(100);
//IOException,可能写不进去
fos.close();

//写字节数组
byte[] bytes = {65,66,67,68};
fos.write(bytes);
//从一开始写两个
fos.write(bytes, 1, 2);
//直接写入字符串的方式
fos.write("hello".getBytes())

打开文件看见的不是100而是

d

字母，因为文本在打开的时候都会去运行ASCII码。

换行问题和续写问题

​ 续写问题，流对象

​ public FileOutputStream = newFileOutputStream(File file, boolean append)

​ 在不同的操作系统中，换行符不一样，但是在Windows中是

\r\n

File file = new File("xxxx.txt")
FileOutputStream  fos = new FileOutputStream(file,true);
fos.write("hello\r\n".getBytes())

IO中的异常处理

确保变量对的作用域

如果文件建立失败了，不用关流对象

catch怎么处理

看见那里出现了问题

让系统停下来

//try的外面声明变量，内部建立对象
//对fos的作用域提升
FileOutputStream fos = null;
try{
fos = new FileOutputStream("xxxxx");
fos.write()
}catch(IOException ex){
System.out.println(ex.getMessage());
throw new RuntimeException("文件写入失败");
}finally{
//提升作用域自后，Unhandle exception type of ioException
if(fos != null){}
try{
fos.close();
}catch (IOException ex){
throw new RuntimeException("关闭文件失败");
}
}
}

字节输入流—InputStream

public int available()

public void close()

public void mark(int readlimit)在此输入流中标记当前位置

public void reset()定位到最后一次调用mark的位置

public boolean MarkSupported()测试此输入流是否支持mark和reset

public int read()将文件读入，下一次调用自动读取下一个字节，到达文件末尾返回-1

public int read(byte[] b)从输入流中读取一定数量的字节，并且将其写入缓冲区数组b中,返回值读取了多少个有效字节，-1表示结束

public long skip(long n)跳过和丢弃n个字节

FileInputstream

流对象操作

创建流对象

调用public ==int== read()

关闭流对象

FileInputStream fis = new FileInputStream("xxxx");
//接受read方法的返回值
int len = 0;
while((len = fis.read() != -1){
System.out.prineln((char)len)
}
fis.close()

//解决读多了的问题
byte[] b = new byte[1024];
int len = 0;
while((len = fis.read(b)) != -1){
System.out.print(new String(b,0,len));
}
fis.close();

文件复制原理

​ 将一个文件中的字节放到另一个文件中去就是复制

//按字节的方式去拿，弊端 慢
public static void main(String[] args){
FileInputStream fis = null;
FIleOutputStream fos = null;
int len = 0;
try{
fis = new FileInputStream("xxxx");
fos = new FileOutputStream("xxxx");
while((len = fis.read()) != -1){
fos.write(len);
}
}catch(IOException ex){
System.out.println(ex.getMessage());
throw new RuntimeException("文件复制失败")
}finally{
if((fis != null)&&(fos != null))){
fis.close();
fos.close();
}
}
}

//采用数组的缓冲来提高效率
public static void main(String[] args){
FileInputStream fis = null;
FIleOutputStream fos = null;
int len = 0;
try{
fis = new FileInputStream("xxxx");
fos = new FileOutputStream("xxxx");
byte[] bytes = new byte[1024]
while((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
}catch(IOException ex){
System.out.println(ex.getMessage());
throw new RuntimeException("文件复制失败")
}finally{
if((fis != null)&&(fos != null))){
fis.close();
fos.close();
}
}
}

编码表

ASCII：一个字节中有七位表示内容

用两个字节表示中文，但是第一个字节的开头一定是复数，但是第二个开头可能是负数

unicode，无论什么类型都用连个字节表示，在java中char就是使用这个编码

UTF-8，一个字节就可存储，不用两个字节，在每个字节头加入了编码信

字符流

这个超类只能写文本文件，每次操作的是一个字符，只能用来读和写字符文件

write

write(int c)

write(char[] c)

write(char[] c,int offset,int how)

write(String s)

FileWriter

​ 与FileOutputStream不同的是，写入之后必须调用flush才能写入，并且close暗含刷新的方法。

FileWriter fw = new FileWriter("xxxxxx");

fw.write("xxxxx");
fw.flush();

Reader

所有字符输入流的超类

int read()读取一个字符

int read(char[] c)

没有读取字符串的读取方法，因为字符串的意义无法界定

FileReader

FileReader fr = new FileReader("xxxx");
int len = 0;
char[] c = new char[1024];
while((len = fr.read()) != -1){
System.out.println(new String(char,0,len));
}