文件传输基础——Java IO流

最新推荐文章于 2022-05-09 14:07:20 发布

lxz26192

最新推荐文章于 2022-05-09 14:07:20 发布

阅读量580

点赞数

分类专栏： Java 学习笔记

本文链接：https://blog.csdn.net/lxz26192/article/details/51106673

版权

Java 学习笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.文件编码

（1）直接新建文本，文本只认识ANSI编码格式。

（2）UTF-8：中文占3个字节、gdk:中文占2个字节、utf-16be(java是双字节编码）：中文英文各占2个字节。

（3）将某种编码的字节序转换为字符串时，需要制定该编码，否则会出现乱码，不指定时使用默认工程编码。

import java.io.UnsupportedEncodingException;


public class Encoding {
    private static void printByte(byte[]bytes)
    {
    	 for(byte b:bytes)
 	    {//把字节转换为int以16进制显示，int 4字节，前两个字节无效
 	    	System.out.print(Integer.toHexString(b&0xff)+" ");
 	    
 	    }
    	 System.out.println();
    }
	public static void main(String[] args)  {
		//默认工程编码
		String str = "我是ABC";
	    byte[] bytes=str.getBytes();
	    printByte(bytes);
	    
	    try {
			bytes = str.getBytes("utf-8");
			printByte(bytes);
			bytes = str.getBytes("utf-16be");
			printByte(bytes);
		} catch (UnsupportedEncodingException e) {
			
			e.printStackTrace();
		}
	 
	
//	    ce d2 ca c7 41 42 43 
//	    e6 88 91 e6 98 af 41 42 43 
//	    62 11 66 2f 0 41 0 42 0 43 
	    
	    
	    
	   

	}

}

2.File类文件使用

File只能用于表示文件（目录），不能访问文件内容。

import java.io.File;


public class FileTest {
    private static int listDerictory(File dir)
    {
    	if (!dir.exists())
    	{
    		System.out.println("文件不存在");
    		return -1;
    	}
    	else if ( !dir.isDirectory())
    	{
    		System.out.println("不是目录");
    		return 0;
    	}
    
        
        File[] files = dir.listFiles();
        
        if (files == null)
        {   
        	System.out.println(dir.getAbsolutePath()+"拒绝访问");
        	return -2;
        }
       //C:\Users\Administrator\AppData\Local\Application Data拒绝访问，出现空指针异常
        for (File file : files)
        { 
        	if(file==null)
        	{
        		file=null;
        	}
        	
        	if (file.isDirectory())
        	{
        		
        		listDerictory(file);
        	}
        	else {
				System.out.println(file.getAbsolutePath());
			}
        }
        return 1;
    	
    }
	public static void main(String[] args) {
		File file = new File("d:\\java_file\\you\\file");
		if(!file.exists())
		{
			file.mkdirs();//创建多级目录
		}

		listDerictory(new File("C:\\Users\\"));
		listDerictory(new File("C:\\Users\\Administrator\\AppData\\Local\\Adobe"));
		//listDerictory(new File("C:\\Users\\"));
	
	}

}

3.IO输入输出流

1）in.read()读取低8位，FileInputStream FileOutputStream字节操作

2）按字节读取不适合读取大文件，批量读取大文件效率较高。

3)DataOuputStream/DataInputStream

对“流”功能的扩展，可以更加方便的读取int,long,字符等类型数据

DataOutputStream

writeInt()/writeDouble()/writeUTF()

4)BufferedInputStream BufferedOutputSteam这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或者读取操作时，都会加上缓冲，这种流模式提高了IO得到性能，注意刷新缓冲区。

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;
public class IOUtil{

	/**public class IOUtil {
	/**
	 * 读取指定文件内容，按照16进制输出到控制台
	 * 每隔10个byte输出换行
	 * @param fileName
	 * @throws IOException
	 */
public static void printHex(String fileName)throws IOException
{
	FileInputStream in = new FileInputStream(fileName);
	int b;
	int i = 1 ;
	while( (b =in.read())!= -1)
	{
		System.out.print(Integer.toHexString(b)+" ");
	    
	    if(i%10==0)
	    {
	    	System.out.println();
	    }
	    i++;
	}
	in.close();
	
}

public static void printHexByByteArray(String fileName) throws IOException
{
	FileInputStream in= new FileInputStream(fileName);
	byte [] buf = new byte[20*1024];
/*	从in批量读取字节，放入buf这个字节数组中，从第0个位置开始放，
	最多放buf.length个
	返回的是读到的字节个数*/

	
	int bytes=0;
	int j = 1;
	while((bytes=in.read(buf,0,buf.length))!=-1)
	{
		for (int i = 0 ; i < bytes;i++)
		{//&0xff:int有32位，byte有8位，为反正转换错误，除去前24位
			System.out.print(Integer.toHexString(buf[i]&0xff)+" ");
			if( j++%10 == 0 )
			{
				System.out.println();
			}
		}
	}
	
}

/**
 * 进行文件的拷贝，利用带缓冲的字节流
 * @param srcFile
 * @param destFile
 * @throws IOException
 */
public static void copyFileByBuffer(File srcFile,File destFile)throws IOException{
	if(!srcFile.exists()){
		throw new IllegalArgumentException("文件:"+srcFile+"不存在");
	}
	if(!srcFile.isFile()){
		throw new IllegalArgumentException(srcFile+"不是文件");
	}
	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();
}

}

4.字符流
1）编码问题
2）认识文本和文本文件
java的文本（char)是16位无符号整数，是字符的unicode编码（双字节编码）
文本是byte byte byte...的数据序列
文本文件是文本（char）序列按照某种编码方案（utf-8,utf16be,gdk)序列化为byte的存储结果
3）字符流（Reader Writer)
字符的处理，一次处理一个字符
字符的底层仍然是基本的字节序列
字符流的实现：
InputStreamReader 完成byte流解析为char流，按照编码解析

OutputStreamWriter 提供char流到byte流，按照编码处理

FileReader FileWriter 无法指定编码，很可能出现乱码

		FileInputStream in = new FileInputStream("e:\\myutf8.txt");
		InputStreamReader isr = new InputStreamReader(in,"utf-8");//默认项目的编码,操作的时候，要写文件本身的编码格式
	
		FileOutputStream out = new FileOutputStream("e:\\my81.txt");
		OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
		/*int c ;
		while((c = isr.read())!=-1){
			System.out.print((char)c);
		}*/
		char[] buffer = new char[8*1024];
		int c;
		<span style="color:#ff0000;">/*批量读取，放入buffer这个字符数组，从第0个位置开始放置，最多放buffer.length个
		  返回的是读到的字符的个数</span>
		*/
		while(( c = isr.read(buffer,0,buffer.length))!=-1){
			String s = new String(buffer,0,c);
			System.out.print(s);
			osw.write(buffer,0,c);
			osw.flush();
		}
		isr.close();
		osw.close();

BufferedReader

BurreredWriter 不识别换行//单独写出换行操作
bw.newLine();//换行操作

PrintWriter

 //对文件进行读写操作 
		BufferedReader br = new BufferedReader(
				new InputStreamReader(
						new FileInputStream("e:\\javaio\\imooc.txt")));
		/*BufferedWriter bw = new BufferedWriter(
				new OutputStreamWriter(
						new FileOutputStream("e:\\javaio\\imooc3.txt")));*/
		PrintWriter pw = new PrintWriter("e:\\javaio\\imooc4.txt");
		//PrintWriter pw1 = new PrintWriter(outputStream,boolean autoFlush);
		String line ;
		while((line = br.readLine())!=null){
			System.out.println(line);//一次读一行，并不能识别换行
			/*bw.write(line);
			//单独写出换行操作
			bw.newLine();//换行操作
			bw.flush();*/
			pw.println(line);
			pw.flush();
		}
		br.close();
		//bw.close();
		pw.close();

5.对象的序列化和反序列化

1）对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化

2）序列化流（ObjectOutputStream），是过滤流--writeObject

反序列化流（ObjectInputStream）--readObject

3)序列化接口（Serializable)

对象必须实现序列化接口，才能进行序列化，否则出现异常

这个接口，没有任何方法，只是一个标准

4）transient关键字,指定默认不序列化，可以查看ArrayList源码查看transient的用法。

private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException

private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException

5）父类实现了序列化，则子类可以直接序列化

对子类对象进行反序列化操作时，会递归调用其父类的构造函数

/*
* 对子类对象进行反序列化操作时，
* 如果其父类没有实现序列化接口
* 那么其父类的构造函数会被调用
*/

	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();

package com.imooc.io;

import java.io.Serializable;

public class Student implements Serializable{
	private String stuno;
	private String stuname;
	//该元素不会进行jvm默认的序列化,也可以自己完成这个元素的序列化
	private transient int stuage;  
	
	public Student(String stuno, String stuname, int stuage) {
		super();
		this.stuno = stuno;
		this.stuname = stuname;
		this.stuage = stuage;
	}

	public String getStuno() {
		return stuno;
	}
	public void setStuno(String stuno) {
		this.stuno = stuno;
	}
	public String getStuname() {
		return stuname;
	}
	public void setStuname(String stuname) {
		this.stuname = stuname;
	}
	public int getStuage() {
		return stuage;
	}
	public void setStuage(int stuage) {
		this.stuage = stuage;
	}
	@Override
	public String toString() {
		return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage="
				+ 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的反序列化操作
	}
}

package com.imooc.io;

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

public class FileDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		File file = new File("e:\\example");
		/*String[] filenames = file.list(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				System.out.println(dir+"\\"+name);
				return name.endsWith("java");
			}
		});
		for (String string : filenames) {
			System.out.println(string);
		}*/
		/*File[] files = file.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
				System.out.println(dir+"\\"+name);
			
				return false;
			}
		});*/
		File[] files = file.listFiles(new FileFilter() {
			
			@Override
			public boolean accept(File pathname) {
				// TODO Auto-generated method stub
				System.out.println(pathname);
				
				return false;
			}
		});

	}

}