慕课网5 文件传输基础

1.radix 文件的编码

public class radix {
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		/*
		 * 文本文件 就是字节序列
		 * 可以使任意编码的字节序列
		 *  中文机器上直接创建文件，文本文件 只认识ANSI编码，直接粘贴的全认识
		 *  联通、联想是一种巧合，正好符合了utf-8的规则
		 */
		
		String s="慕课ABC";
		//默认gbk  中文两个字节 英文一个字节
		byte[] bytes1=s.getBytes();
		for(byte b:bytes1){ 
			System.out.print(Integer.toHexString(b&0xff)+" ");  //c4 bd bf ce 41 42 43 
		}
		
		 //utf-8  中文三个字节 英文一个字节
		System.out.println();
		byte[] bytes2=s.getBytes("utf-8");
		for(byte b:bytes2){
			System.out.print(Integer.toHexString(b&0xff)+" "); //e6 85 95 e8 af be 41 42 43
		}
	
		//JAVA是双字节编码 utf-16be 中文英文两个字节
		System.out.println();
		byte[] bytes3=s.getBytes("utf-16be");
		for(byte b:bytes3){ 
			System.out.print(Integer.toHexString(b&0xff)+" "); //61 55 8b fe 0 41 0 42 0 43 
		}
		/*
		 * 当你的字节序列是某种编码时，转换为字符串时也需要用这种编码方式
		 */
		String s2=new String(bytes2);
		System.out.print(s2);
		String s3=new String(bytes2,"utf-8");
		System.out.print(s3);	
	}
}

2.FileDemo File类的使用

import java.io.File;
import java.io.IOException;

public class FileDemo {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub		
		/*
		 * java.io.File类用于表示文件（目录）
		 * File类只用于表示文件（目录）的信息（名称），不能直接用于文件内容的访问
		 */
		//了解构造函数的情况  alt+/查看帮助
		File file=new File("D:\\A");
		if(!file.exists()) //不存在
			file.mkdir();  //创建目录       mkdirs创建多级目录
		/*else
			file.delete();   //删除目录
                */		
		System.out.println(file.isDirectory());  //是否是目录
		System.out.println(file.isFile());//是否是文件
		
		//File file2=new File("D:\\A\\A1.txt");
		File file2=new File("D:\\A","A1.txt");
		if(!file2.exists()) //不存在
		{
			try{
				file2.createNewFile();
			}catch(IOException e){
				e.printStackTrace();
			}
		}else{
			file2.delete();
		}
		
		//常用File对象的API
		System.out.println(file);    //D:\A
		System.out.println(file.getAbsolutePath());  //D:\A
		System.out.println(file.getName());   //A
		System.out.println(file2.getName());  //A1.txt
		System.out.println(file.getParent());  //D:\
		System.out.println(file2.getParent());   //D:\A
		System.out.println(file.getParentFile().getAbsolutePath());  //D:\
	}

}

3.FileUtil    遍历目录

import java.io.File;

//列出File的一些常用操作如过滤.遍历等
public class FileUtil {
	/**
	 * 列出指定目录下（包括其子目录）的所有文件
	 * 
	 * @param dir
	 * @throws Exception
	 */
	public static void listDirectoy(File dir) throws Exception {
		if (!dir.exists()) {
			throw new IllegalArgumentException("目录" + dir + "不存在");
		} else if (!dir.isDirectory()) {
			throw new IllegalArgumentException(dir + "不是目录");
		}
		// 子文件或目录名称，不包含子目录下的名称
		String[] names = dir.list();
		for (String name : names) {
			System.out.println(name);
		}

		// 如果要遍历子目录下的内容就需要构造成File对象做递归操作
		File[] files = dir.listFiles();
		if (files != null && files.length > 0) {
			for (File file : files) {
				if (file.isDirectory()) {
					listDirectoy(file); // 递归
				} else {
					System.out.println(file);
				}
			}
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			FileUtil.listDirectoy(new File("D:\\"));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

4.RandomAccessFile类的使用

/*RandomAccessFile java提供对文件内容的访问，既可以读文件，也可以写文件。
 *RandomAccessFile支持随机访问文件，可以访问文件的任意位置
 *
 *1）JAVA文件模型
 *  在硬盘上的文件时byte存储的，是数据的集合
 *2）打开文件 
 *   两种模式 rw （读写）,r(只读)
 *RandomAccessFile raf=new RandomAccessFile(file,"rw");
 *文件指针，打开文件时指针在开头pointer=0;
 *3）写方法
 *raf.write(int)-->只写一个字节（后8位），同时指针指向下一个字节位置
 *4）读方法
 *raf.read()-->读一个字节
 *5)关闭文件
 */
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
public class RandomAccessFileDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		File demo=new File("demo");//相对路径，项目下
		if(!demo.exists()){
			demo.mkdir();
		}
		File file=new File(demo,"raf.dat");
		if(!file.exists()){
			file.createNewFile();
		}
		
		RandomAccessFile raf =new RandomAccessFile(file,"rw");
		//指针的位置
		System.out.println(raf.getFilePointer()); //0 
		//用write只写了一个字节
		raf.write('A');  
		System.out.println(raf.getFilePointer());  //1
		raf.write('B');
		System.out.println(raf.getFilePointer());  //2
		
		//可以writeInt直接写一个int
		int i=0x7fffffff;
		raf.writeInt(i);
		System.out.println(raf.getFilePointer());  //6
		
		String s="中";  //utf-16be
		byte[] gbk=s.getBytes();
		raf.write(gbk);
		System.out.println(raf.getFilePointer());  //8
		
		//读文件，必须把指针移到头部
		raf.seek(0);
		//一次性读取,把文件中的内容都读到字节数组中
		byte[]buf=new byte[(int)raf.length()];
		raf.read(buf);
		System.out.println(Arrays.toString(buf));//[65, 66, 127, -1, -1, -1, -42, -48, 45]
				
		for(byte b:buf){
			System.out.println(Integer.toHexString(b));  //十六进制输出
		}
		String s1=new String(buf);
		System.out.println(s1); //AB???
		
		//关闭文件
		raf.close();
	}

}

5.字节流  InputStream、OutputStream  FIleInputStream/ FIleOutputStream

BufferedInputStream/BufferedOutputoutStream

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * IO流（输入流，输出流）
 * 字节流、字符流
 * 1.字节流
 * 1）InputStream、OutputStream 抽象类
 *    InputStream抽象了应用程序读取数据的方式
 *    OutputStream抽象了应用程序写出数据的方式
 * 2）EOF=End  读到-1就读到结尾
 * 3）输入流基本方法
 *    int b=in.read(); //读取一个字节无符号填充到整形的低8位。-1是EOF
 *    in.read(byte[] buf);
 *    in.read(byte[] buf,int start,int size);
 *4）输出流基本方法
 *    out.write(int b)//写出一个byte到流，低8位
 *    out.write(byte[] buf) //将byte字节数组都写入到流
 *    out.write(byte[] buf,int start,int size);
 *5） FIleInputStream继承InputStream,具体实现了在文件上读取 
 *6） FIleOutputStream实现了向文件中写出byte数据的方法
 */

/*
 * BufferedInputStream/BufferedOutputoutStream
 * 这两个流为IO提供了带缓冲区的操作，一般打开文件进行写入
 * 或读取操作时，都会加入缓冲，这种流模式提高了IO的性能
 * 从应用程序中把输入放入文件，相当将一缸水倒入另一个缸中
 * FileOutputStream-->wrie()方法相当于一滴滴转移
 * DataOutputStream-->writeXXx()方法，相当于一瓢瓢转移
 * BufferedOutputStream-->wrie()方法，相当将一瓢瓢先放入桶，再从桶倒入缸中
 */


public class FileInputDemo {
	/*读取制定文件内容，按照16进制输出
	*每输出10个换行
	*单字节读取不适合大文件
	*/
	public static void printHex(String fileName) throws IOException{
		//把文件作为字节流进行读操作
		FileInputStream in=new FileInputStream(fileName);
		int b;
		int i=1;
		while((b=in.read())!=-1){
			if(b<=0xf){
				//单位数前面补0
				System.out.print("0");
			}
			System.out.print(Integer.toHexString(b)+" ");
			if((i++)%10==0)
				System.out.println();
		}
		System.out.println();
		in.close();  //关闭操作
	}
	/**
	 * 大文件适于批量读取
	 * @param fileName
	 * @throws IOException
	 */
	public static void printHexByByteArray(String fileName) throws IOException{
		FileInputStream in=new FileInputStream(fileName);
		byte[] buf=new byte[20*1024];
		/*//从In中批量读取字节，从第0个位子开始放，最多放buf.length个，返回读取字节个数
		int bytes=in.read(buf, 0, buf.length);//若一次性读完，说明buf足够大		
		for(int i=0;i<bytes;i++){
			if(buf[i]<=0xf){
				//单位数前面补0
				System.out.print("0");
			}
			System.out.print(Integer.toHexString(buf[i])+" ");
			if((i+1)%10==0)
				System.out.println();
		}*/
		
		//有可能一次性读不完	
		int bytes=0;
		while((bytes=in.read(buf, 0, buf.length))!=-1){
			for(int i=0;i<bytes;i++){
				if(buf[i]<=0xf){
					//单位数前面补0
					System.out.print("0");
				}
				System.out.print(Integer.toHexString(buf[i])+" ");
				if((i+1)%10==0)
					System.out.println();
			}
		}
		System.out.println();
		in.close();
	}
	
	/**
	 * 文件拷贝，批量读取，最快
	 * @param srcFile
	 * @param desrFile
	 * @throws IOException
	 */
	
	public static void copyFile(File srcFile,File destFile) throws IOException{
		if(!srcFile.exists()){
			throw new IllegalArgumentException("文件不存在");
		}
		if(!srcFile.isFile()){
			throw new IllegalArgumentException("文件不存在");
		}
		FileInputStream in = new FileInputStream(srcFile);
		FileOutputStream out = new FileOutputStream(destFile);
		byte[] buf=new byte[8*1024];
		int bytes;
		while((bytes=in.read(buf, 0, buf.length))!=-1){
			out.write(buf, 0, bytes);
			out.flush();  //带缓冲区要刷新
		}
		in.close();
		out.close();		
	}

	/**
	 * 文件拷贝，单字节读取，最慢
	 * @param srcFile
	 * @param desrFile
	 * @throws IOException
	 */
	
	public static void copyFileByByte(File srcFile,File destFile) throws IOException{
		if(!srcFile.exists()){
			throw new IllegalArgumentException("文件不存在");
		}
		if(!srcFile.isFile()){
			throw new IllegalArgumentException("文件不存在");
		}
		FileInputStream in = new FileInputStream(srcFile);
		FileOutputStream out = new FileOutputStream(destFile);		
		int bytes;
		while((bytes=in.read())!=-1){
			out.write(bytes);
		}
		in.close();
		out.close();
	}
    /*
     * 带有缓冲区的读取
     */
	public static void copyFileByBuffered(File srcFile,File destFile) throws IOException{
		if(!srcFile.exists()){
			throw new IllegalArgumentException("文件不存在");
		}
		if(!srcFile.isFile()){
			throw new IllegalArgumentException("文件不存在");
		}
		
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));
		int b;
		while((b=bis.read())!=-1){
			bos.write(b);
			bos.flush();//带缓冲区要刷新
		}
		
		bis.close();
		bos.close();
	}
	
	/**
	 * @param args
	 * @throws IOException 
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException  {
		// TODO Auto-generated method stub
		try {
			FileInputDemo.printHex("demo\\raf.txt");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		try {
			long start=System.currentTimeMillis();
			FileInputDemo.printHexByByteArray("demo\\raf.txt");
			long end=System.currentTimeMillis();
			System.out.println(end-start);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		//如果该文件不存在，则直接创建，如果存在，删除后删除重建
		//若第二个参数为true，则append
		FileOutputStream out=new FileOutputStream("demo\\raf.txt");
		out.write('A');  //低8位
		out.write('B');
		byte[] gbk="中国".getBytes("gbk");
		out.write(gbk);
		FileInputDemo.printHex("demo\\raf.txt");
		
		FileInputDemo.copyFile(new File("demo\\raf.txt"),new File( "demo\\raf1.txt"));
	}

}

6.DataOutputStream、DataInputStream 

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * DataInputStream / DataOutputStream
 * 对“流”功能的扩展，可以更加方面的读取int,long,字符等类型数据
 * DataOutputStream
 * writeInt()/writeDouble/writeUTF()
 */
public class DataInputDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub
		String file="demo\\raf.txt";
		
		//DataOutputStream
		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
		DataInputStream dis=new DataInputStream(new FileInputStream(file));
		
		int i=dis.readInt();
		System.out.println(i);
		long l=dis.readLong();
		System.out.println(l);
		double d=dis.readDouble();
		System.out.println(d);
		String s=dis.readUTF();
		System.out.println(s);
	}

}

7.字符流  InputStreamReader/OutputStreamReader   BufferedReader  BufferedWriter/PrintWriter

<p><span style="font-size:14px;">
/*
 * 字符流
 * 1）编码问题
 * 2）认识文本和文本文件
 *    JAVA的文本（char）是16位无符号整数，是自负的unicode编码（双字节编码）
 *    文件是byte byte byte---的数据序列
 * 	     文本文件是文本（char）序列按照某种编码方案（utf-8,.utf-16be,gbk）序列化为byte的存储
 * 3）字符流（Reader Writer）
 * 	     字符的</span>处理，一次处理一个字符</p> *    字符的底层仍然是基本的字符序列
 *    字符流的基本实现
 *    InputStreamReader 完成byte流解析为char流，按照编码解析
 *    OutputStreamReader 提供char流到byte流，按照编码处理
 * 4）FileReader FileWriter 
 * 5)字符流的过滤器
 *   BufferedReader -->readLine()一次读取一行
 *   BufferedWriter/PrintWriter  --写一行
 */
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.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
public class InputStreamReaderDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		//字节字符转换流
		InputStreamReader isr=new InputStreamReader(new FileInputStream("demo\\raf.txt"),"gbk");
		OutputStreamWriter osr=new OutputStreamWriter(new FileOutputStream("demo\\raf3.txt"));
		int c;
		/*while((c=isr.read())!=-1){
			System.out.print((char)c);
			osr.write(c);
		}*/
		
		//批量读取
		char []buf=new char[8*1024];
		while((c=isr.read(buf, 0, buf.length))!=-1){
			String s=new String(buf,0,c);
			System.out.print(s);
			osr.write(buf,0, c);
			osr.flush();			
		}
		
		isr.close();
		osr.close();
		
		//字符流之文件读写流
		FileReader fr=new FileReader("demo\\raf.txt");
		FileWriter fw=new FileWriter("demo\\raf4.txt");
		char []buffer=new char[8*1024];
		while((c=fr.read(buffer, 0, buffer.length))!=-1){
			fw.write(buffer,0, c);
			fw.flush();			
		}
		fr.close();
		fw.close();
		
		
		//字符流的过滤器
		BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("demo\\raf.txt")));
		//BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("demo\\raf5.txt")));
		PrintWriter pw=new PrintWriter("demo\\raf5.txt");
		String line;
		while((line=br.readLine())!=null){
			/*bw.write(line);
			bw.newLine();
			bw.flush();*/
			pw.println(line);
			pw.flush();
		}
		br.close();
		pw.close();
	}

}

8.序列化和反序列化

/**
 * 对象的序列化和反序列化
 * 1）将Object转换成byte序列，反之为对象的反序列化
 * 2）序列化流（ObjectOutputStream） ---->writeObject
 *    反序列化流（ObjectInputStream） ---->readObject
 * 3）序列化接口（Serializable）
 *    对象必须实现序列化接口，才能进行序列化，否则出现异常
 *    这个借口，没有任何方法，只是一个标准
 * 4）transient关键字  该元素不会被进行jvm默认序列化，也可以自己完成元素的序列化
 *    private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException{}
 *    private void readObject(java.io.ObjectInputStream s)
   			throws java.io.IOException, ClassNotFoundException{}
 * 5）父类实现序列化接口，其子类都可进行初始化
 * 6）对子类对象进行序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用
 */


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;


public class SeriablizableDemo implements Serializable{  //声明Serializable接口，否则异常
	private String stu;
	private String stuname;
	private transient int stuage;
	
	@Override
	public String toString() {
		return "SeriablizableDemo [stu=" + stu + ", stuage=" + stuage
				+ ", stuname=" + stuname + "]";
	}

	public SeriablizableDemo(String stu, String stuname, int stuage) {
		super();
		this.stu = stu;
		this.stuname = stuname;
		this.stuage = stuage;
	}
	
    private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException{  //ArrayList方法名粘贴
	    s.defaultWriteObject(); //默认
        s.writeInt(stuage);  //自己完成
    }
    private void readObject(java.io.ObjectInputStream s)
   			throws java.io.IOException, ClassNotFoundException {
    	s.defaultReadObject();//默认
    	this.stuage=s.readInt(); //自己完成 
	}


	/**
	 * @param args
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws  IOException, ClassNotFoundException {
		// TODO Auto-generated method stub
		String file="demo\\raf6.txt";  //保存到此文件中
		//序列化
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file));
		SeriablizableDemo  stu=new SeriablizableDemo("张三","小",20);
		oos.writeObject(stu);
		oos.flush();
		oos.close();
		
		//反序列化
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));
		SeriablizableDemo  stu2=(SeriablizableDemo)ois.readObject();
		System.out.println(stu2.toString());
		ois.close();
	}

}