文件操作-----文件传输基础-Java IO流

这篇文章代码比较全面文件传输基础(Java IO流)–慕课网笔记

IO操作

文件传输基础-Java IO流

编码问题

String s="慕课ABC";
byte[] bytes1=s.getBytes();//这是把字符串转换成字符数组，转换成的字节序列用的是项目默认的编码
for(byte b: bytes1){
//toHexString这个函数是把字节（转换成了Int）以16进制的方式显示
System.out.println(Integer.toHexString(b & 0xff)+" ");// & 0xff是为了把前面的24个0去掉只留下后八位
}
byte[] bytes1=s.getBytes("gbk");//也可以转换成指定的编码

• “gbk”中文占2个字节，英文占1个字节
• “utf-8”中文占3个字节，英文占1个字节
• “utf-16be”中文占2个字节，英文占2个字节

【注意】当字节序列为某种编码，把字节序列转换成字符串时，也要用该种编码方式，否则会出现乱码
String str = new String(bytes1,“指定的编码”);

文本文件就是字节序列，可以是任意编码的字节序列

如果我们在中文机器上直接创建文本文件，那么该文件只认识ANSI编码（例如直接在电脑中创建文本文件）

File类常用API介绍

1、Java.io.File类 用于表示文件（目录）
File类只用于表示文件（或目录）的信息（名称、大小等），不能用于文件内容的访问
1.创建File对象：File file=new File(String path);注意：File.seperater();获取系统分隔符（所有的系统都认识该分隔符）
2.boolean file.exists();是否存在.
3.file.mkdir();创建目录 。file.mkdirs();创建多级目录。
4.file.isDirectory()判断是否是目录 ；file.isFile()判断是否是文件。
5.file.delete();删除文件或目录。
6.file.createNewFile();创建新文件。【IOException异常】
7.file.getName()获取文件名称或目录的名字。
8.file.getAbsolutePath()获取绝对路径。
9.file.getParent();获取父级绝对路径。
10.file.getSize();获取文件大小。
11.file.getFormat();获取文件格式名。

遍历目录

public class FileUtil {
	public static void listDirectory(File dir)throws IOException{	
		if(!dir.exists()){	//文件或目录是否存在
			throw new IllegalArgumentException("目录"+dir+"不存在");
		}
		if(!dir.isDirectory()){	//判断File对象是否是目录		
			throw new IllegalArgumentException(dir+"不是目录");			
		}
//file.list() 返回的是 字符串数组 String[] fileNames=file.list();
【用于列出`当前`目录下的子目录和文件】直接子的名称，不包含子目录下的内容
//如果要遍历目录下的内容就需要构造成File对象做递归  File提供了直接返回File对象Api


		//遍历目录下所有的子目录'文件,及子目录下的文件   通过递归实现
		File []files=dir.listFiles();//返回直接子目录（文件）的抽象==>对象
		if(files!=null&&files.length>0){			
			for(File file:files){
				if(file.isDirectory()){
				//递归
				listDirectory(file);
				}else{					
					System.out.println(dir.getAbsolutePath()+file+"   ");
					System.out.println();
				}			
			}		
		}
	}
}

RandomAccessFile

Java提供的对文件内容的访问，既可以读文件，也可以写文件
RandomAccessFile 支持随机访问文件，可以访问文件的任意位置
步骤：
（1）Java文件的模型
在硬盘上的文件是byte byte byte存储的，是数据的集合
（2）打开文件
有两种模式"rw”(读写) "r”(只读)
RandomAccessFile raf = new RandomAccessFile(file,“rw”)
文件指针，打开文件时指针在开头 pointer=0(读写时指针会移动)
【多线程下载 各下载文件的一部分，然后拼接】raf.seek(0)//读文件必须把指针移到头部
（3）写方法
raf.write(int)—>只写一个字节（后8位），同时指针指向下一个位置，准备再次写入
raf.writeInt(int)—>直接写一个int（查看底层代码实现）

int i = 0x7ffffff;
  //用write方法每次只能写一个字节（后8位），如果要把i写进去就得写4次
  raf.write(i>>>24);//高8位
  raf.write(i>>>16);
  raf.write(i>>>8);
  raf.write(i);

 String s = "中";
  //以gbk编码存储
  byte[] gbk = s.getBytes("gbk");
  raf.write(gbk);
  System.out.println(raf.length());

（4）读方法
int b = raf.read() —>读一个字节
（5）文件读写完之后一定要关闭
该模块代码

IO流(输入流、输出流)

字节流、字符流
字节流
1）InputStream、OutputStream
InputStream 抽象了应用程序读取数据的方式
OutPutStream 抽象了应用程序写出数据的方式
2）EOF = End 或者说读到-1就读到结尾
3）输入流基本方法是读
int b = in.read();读取一个字节无符号填充到int的低八位。-1是EOF
in.read(byte[] buf)读取数据填充到字节数组buf
in.read(byte[] buf,int start,int size)读取数据到字节数组buf，从buf的start位置开始存放size长度的数据
4）输出流基本方法是写
out.write(int b) 写出一个byte到流，b的低8位
out.write(byte[] buf) 将buf字节数组都写入到流
out.write(byte[] buf,int start,int size)字节数组buf从start位置开始写size长度的字节到流
5）FileInputStream 具体实现了在文件上读取数据

字节流之文件输入流FileInputStream1

  //把文件作为字节流进行读操作
 FileInputStream in = new FileInputStream(fileName);
   int b;
   int num=1;
   while((b=in.read())!=-1){
         if(b<=0xf){//0xf表示1位
                 System.out.print("0");//单位数前面补0
         }
         //将整形b换成16进制表示的字符串
         System.out.print(Integer.toHexString(b&0xff)+"  ");
         if(num++%10==0){//每输出10个byte换行
               System.out.println();
         }
   }
   in.close();

字节流之文件输入流FileInputStream2

FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[8*1024];//内存不是越多越好
/*从in中批量读取字节，放入到buf字节数组中，从第0个位置开始放，最多放buf.length个。
*返回的是读到的字节的个数（1：读不满；2：不够放）
*并不是每次都读入了这么多个字节，（可能读的文件没这么长）所以用bytes用来记录读入了多少个字节（in.read()的返回类型就是int，值为读的字节个数）*/
int bytes = in.read(buf,0,buf.length);//一次性读完，说明字节数组足够大
int j = 1; 
for(int i = 0; i < bytes;i++){
 if(buf[i]<=0xf){
       System.out.print("0");
    }
	System.out.print(Integer.toHexString(buf[i] & 0xff)+"  ");
	if(j++%10==0){
		System.out.println();
	}
}
//============当字节数组不够大，一次性读不完时===========
int bytes=0;
while((bytes=in.read(buf,0,buf.length))!=-1){
  for(int i = 0 ; i < bytes;i++){//bytes有效字节的个数
		 System.out.print(Integer.toHexString(buf[i] & 0xff)+"  ");
		  if(j++%10==0){
			  System.out.println();
		  }
	  }
	}
 in.close();

为避免数据转换错误，通过&0xff将高24位清零

字节流之文件输出流FileOutputStream

6）FileOutputStream 具体实现了向文件中写出byte数据的方法

//如果该文件不存在，则直接创建；如果存在，删除后创建
FileOutputStream out = new FileOutputStream ("demon/out.dat");
//参数true 如果该文件不存在则直接创建，存在则追加内容
FileOutputStream out = new FileOutputStream ("demon/out.dat",true);

文件拷贝操作：批量读写（速度最快）

public static void copyFile(File srcFile,File destFile)throws IOException{
        if(!srcFile.exists()){
            throw new IllegalArgumentException("文件："+srcFile+"不存在");
        }
        if(!srcFile.isFile()){
            throw new IllegalArgumentException(srcFile+"不是文件");
        }
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        byte[] buf = new byte[8*1024];
        int b;
         //批量读写
        while((b=in.read(buf,0,buf.length))!=-1){
//从buf字节数组的第0个位置（就是第一个开始写）开始，到第b个位置结束的内容写入write所指向的文件里
            out.write(buf,0,b);
            out.flush();
        }
        in.close();
        out.close();
    }

字节流之数据输入输出流

7）DataOutputStream/DataInputStream
对"流"功能的扩展，可以更加方面的读取int,long，字符等类型数据
DataOutputStream:
writeInt()【写入一个int用write要写4次，writeInt()其实就是包装了4次write】;writeDouble();writeUTF();【装饰模式封装操作】

DataOutputStream：使用FileOutputStream构造出来，通过包装FileOutput，可以调用FileOutput类的write方法来构造新的更方便的写方法：
其新建对象为嵌套创建，例：

String file = "xxx";
DataInputStream dis = new DataInputStream(new FileInputStream(file));
DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));

DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
dos.writeInt(10);
dos.writeLong(10l);
dos.writeDouble(10.5);
//采用utf-8编码写出
dos.writeUTF("中国");
//采用utf-16be编码写出
dos.writeChars("中国");
dos.close();//关闭

DataInputStream dis = new DataInputStream(new FileInputStream(file));
int i = dis.readInt();
i = dis.readInt();
long l = dis.readLong();
double d = dis.readDouble();
String s = dis.readUTF();

字节缓冲流

8)BufferedInputStream、BufferedOutputStream 这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能
从应用程序中把数据放入文件，相当于把一缸水倒入到另一个缸中：
FileOutputStream---->write()方法相当于一滴一滴的把水转移
DataOutputStream---->writeXxx()方法相当于一瓢一瓢的转移
BufferedOutputStream---->write方法相当于一瓢一瓢先放入桶中（缓冲区），再倒入缸中
但是批量读取最快

//利用带缓冲的字节流，进行文件的拷贝
//判断是不是文件及文件是否存在 （前代码有）
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
	int c ;
	while((c = bis.read())!=-1){
		bos.write(c);
		bos.flush();//刷新缓冲区，不然写不到文件中去
	}
	bis.close();
	bos.close();

字符流

1）编码问题
2）认识文本和文本文件
Java的文本(char)是16位无符号整数，是字符的unicode编码(双字节编码)
文件是byte byte byte……的数据序列
文本文件是文本(char)序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为byte的存储结果

3）字符流(Reader/Writer)---->操作的是文本 文本文件
字符的处理，一次处理一个字符
字符的底层任然是基本的字节序列

字符流的基本实现：	byte<----->char	解析
InputStreamReader	完成byte流解析为char流	按照编码解析
OutputStreamWriter	提供char流到byte流	按照编码处理

FileReader/FileWriter（操作文件）【注意不能设置编码格式 其按项目默认编码格式】

字符流的过滤器

BufferedReader----->readLine 一次读一行
BufferedWriter/PrintWriter----->写一行

public static void main(String[] args) throws IOException {
      // 对文件进行读操作,套接流，需要套在节点流上
      BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("F:\\IO流\\Buffered/br.txt")));
//一般使用 PrintWriter而不使用BufferedWriter  
      // 使用BufferedWriter对文件进行写操作
      BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                          new FileOutputStream("F:\\IO流\\Buffered/bw.txt")));
      // 使用PrintWriter对文件进行写操作
      PrintWriter pw = new PrintWriter("F:/IO流/Buffered\\pw.txt");      
      bw.append("我是使用Buffered方法写入的");
      pw.append("我是使用Print方法写入的");
      String line;
      while ((line = br.readLine()) != null) {
            // 一次读一行，并不能识别换行符，输出时可以加上ln
            System.out.println(line);
            bw.write(line);
            // 单独写出换行
            bw.newLine();
            bw.flush();
            
            pw.println(line);//换行
            pw.flush();
        }
        br.close();
        bw.close();
        pw.close();
    }
  

对象的序列化，反序列化

| 对象的序列化/反序列化 | 转换| 流| 方法|
| ------------- |:-------------? -----?
| 序列化 | object转换成byte序列| ObjectOutputStream| 是过滤流---->writeObject()|
|反序列化 |byte转换成object| ObjectInputStream| readObject()|

3）序列化接口(Serializable)
对象必须实现序列化接口，才能进行序列化，否则将出现异常
这个接口没有任何方法，只是一个标准

String file = "demo/obj.dat";
		//1.对象的序列化
		/*ObjectOutputStream oos = new ObjectOutputStream(
				new FileOutputStream(file));
		Student stu = new Student("10001", "张三", 20);
		oos.writeObject(stu);
		oos.flush();
		oos.close();*/
		ObjectInputStream ois = new ObjectInputStream(
				new FileInputStream(file));
		Student stu = (Student)ois.readObject();
		System.out.println(stu);
		ois.close();

4）transient关键字：使元素不会进行jvm默认的序列化，也可以自己完成该元素的序列化
分析ArrayList源码中序列化和反序列化的问题【数组可能没放满，自己序列化数组的有效元素】【提高性能】

Student.java

private String stuno;
private String stuname;
//该元素不会进行jvm默认的序列化,也可以自己完成这个元素的序列化
private transient int stuage;  
	
 private void writeObject(java.io.ObjectOutputStream s)
		        throws java.io.IOException{
		 s.defaultWriteObject();//把jvm能默认序列化的元素进行序列化操作
		 s.writeInt(stuage);//自己完成stuage的序列化
	 }
	 private void readObject(java.io.ObjectInputStream s)
		        throws java.io.IOException, ClassNotFoundException{
		  s.defaultReadObject();//把jvm能默认反序列化的元素进行反序列化操作
		  this.stuage = s.readInt();//自己完成stuage的反序列化操作
	}

5）序列化中 子类和父类构造函数的调用问题
一个类实现了序列化接口，其子类都可以进行序列化

序列化：使用子类创建对象的时候会递归调用父类的构造函数

反序列化：对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被递归调用。反之，如果父类实现了序列化的接口，那么子类继承它的属性和方法就可以直接反序列化，就不会调用父类的构造函数了。