zoukankan      html  css  js  c++  java
  • java中io流浅析

    1.java.io包下
    File类:java程序中的此类的一个对象,就对应着硬盘中的一个文件或网络中的一个资源。
    File file1 = new File("d:\io\helloworld.txt");
    File file2 = new File("d:\io\io1");
    >1.File既可以表示一个文件(.doc .xls .mp3 .avi .jpg .dat),也可以表示一个文件目录!
    >2.File类的对象是与平台无关的。
    >3.File类针对于文件或文件目录,只能进行新建、删除、重命名、上层目录等等的操作。如果涉及到访问文件的内容,File
    是无能为力的,只能使用IO流下提供的相应的输入输出流来实现。
    >4.常把File类的对象作为形参传递给相应的输入输出流的构造器中!

    file类下的基本常用方法:

    boolean exists();判断这个文件是否存在

    boolean mkdir();创建文件夹路径(只能一层)

    directory

    boolean mkdirs();创建文件夹路径(可过层的)

    creatNewFile创建一个文件

    delete删除一个文件

    renameTo(File File)重命名

    getName获取文件名称

    getPath获取文件路径

    length文件的长度

    isDirectory:判断是不是一个目录

    isFile是不是一个文件

    File[]   listFiles获取当前文件夹下的所有文件与文件目录

    import java.io.File;
    
    public class TestFile {
    	public static void main(String[] args){
    File filet=new File("E:\BaiduYunDownload");
    /*Boolean b=filet.isDirectory();
    System.out.println(b);
    File[] fil=filet.listFiles();
    for(File f:fil){
    	System.out.println(f);
    }*/
    TestFile.printf(filet,1);
    
    }
    	public static void printf(File f,int len){
    	if(f.exists()){//文件是否存在
    	 File[] file=f.listFiles();//创建文件数组
    	 for(File fi:file){//遍历数组
    		 if(fi.isDirectory()){//如果是数组继续进入方法并打印出文件夹名
    			 kongge(len);
    			 System.out.println(fi.getName());
    			 printf(fi,len+1);
    		 }else{
    			 kongge(len);
    			 System.out.println(fi.getName());
    		 }
    	 }
    	}}
    	public static void kongge(int len){//给文件夹前边加空格
    		for(int i=0;i<len;i++){
    			System.out.print("  ");
    		}
    	}
    }
    

    io流分类 :

     

    3.IO流的划分
    1) 按照流的流向的不同:输入流 输出流 (站位于程序的角度)
    2) 按照流中的数据单位的不同:字节流 字符流 (纯文本文件使用字符流 ,除此之外使用字节流
    3) 按照流的角色的不同:节点流 处理流 (流直接作用于文件上是节点流(4个),除此之外都是处理流)

    4.重点掌握
    * 抽象基类(InputStream、OurputStream、Reader、Writer)   节点流(文件流) 缓冲流(处理流的一种,可以提升文件操作的效率)
    * InputStream FileInputStream (int read(byte[] b)) BufferedInputStream (int read(byte[] b))
    * OutputStream FileOutputStream (void write(b,0,len)) BufferedOutputStream (flush()) (void write(b,0,len))
    * Reader FileReader (int read(char[] c)) BufferedReader (readLine()) (int read(char[] c))或String readLine()
    * Writer FileWriter (void write(c,0,len)) BufferedWriter (flush()) (void write(c,0,len)或void write(String str))
    注: 1.从硬盘中读入一个文件,要求此文件一定得存在。若不存在,报FileNotFoundException的异常
    2.从程序中输出一个文件到硬盘,此文件可以不存在。若不存在,就创建一个实现输出。若存在,则将已存在的文件覆盖
    3.真正开发时,就使用缓冲流来代替节点流
    4.主要最后要关闭相应的流。先关闭输出流,再关闭输入流。将此操作放入finally

    package day31;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Reader;
    import java.io.Writer;
    
    public class iotext {
    public static void main(String[] args){
    File fi=new File("C:\Users\gaofangquan\Desktop\新建文件夹\新建文本文档.txt");
    File fi1=new File("C:\Users\gaofangquan\Desktop\新建文件夹\新建文本文档 (3).txt");
    try {
    	Reader r=new FileReader(fi);
    	Writer w=new FileWriter(fi1);
    	BufferedReader br=new BufferedReader(r);
    	BufferedWriter bw=new BufferedWriter(w);
    	//char[] c=new char[5];
    	String str=null;
    	@SuppressWarnings("unused")
    	int len=0;
    	//while((len=br.read(c))!=-1){//可以使用字符数组接收
    	while((str=br.readLine())!=null){
    	    bw.write(str);
    	    bw.newLine();
    	    bw.flush();//刷新一下
    	    }
    	bw.close();
    	br.close();
    } catch (FileNotFoundException e) {
    	
    	e.printStackTrace();
    } catch (IOException e) {
    	
    	e.printStackTrace();
    }
       
    }
    }
    

      

    5.其它的流
    1.转换流:实现字节流与字符流之间的转换
    InputStreamReader:输入时,实现字节流到字符流的转换,提高操作的效率(前提是,数据是文本文件) ===>解码:字节数组--->字符串
    OutputStreamWriter:输出时,实现字符流到字节流的转换。 ===>编码: 字符串---->字节数组
    例子:从键盘输入字符串,要求将读取到的整行字符串转成大写输出。然后继续进行输入操作,直至当输入“e”或者“exit”时,退出程序。

    package day31;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.Writer;
    
    public class zhuanhuan {
    	public static void main(String[] args){
    		InputStreamReader isr=new InputStreamReader(System.in);
    		BufferedReader br=new BufferedReader(isr);
    		try {
    			Writer w=new FileWriter("C:\Users\gaofangquan\Desktop\新建文件夹\新建文本文档 (5).txt");
    			BufferedWriter bw=new BufferedWriter(w);
    			String s=null;
    			while((s=br.readLine())!=null){
    				if(s.equalsIgnoreCase("exit")){
    					break;
    				}
    				bw.write(s);
    				bw.newLine();//换行
    				bw.flush();
    			}
    			bw.close();
    			br.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    }
    }
    

      

    2.标准的输入输出流
    System.in: The "standard" input stream:从键盘输入数据
    System.out:The "standard" output stream:从显示器输出数据

    3.打印流 (都是输出流) PrintStream(处理字节) PrintWriter(处理字符)
    可以使用System.setOut(PrintStream p)重新设置一下输出的位置。
    PrintStream p = new PrintStream(new FileOutputStream("hello.txt"),true);

    package print;
    
    import java.io.BufferedReader;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.PrintStream;
    import java.io.Reader;
    
    public class TestPrintStream2 {
    	public static void main(String[] args) {
    		String fileName = "C:\Users\gaofangquan\Desktop\新建文件夹\新建文本文档 (6).txt";
    		
    		list(fileName, System.out);
    	}
    
    	private static void list(String fileName, PrintStream ps) {
    		try {
    			Reader r=new FileReader(fileName);
    			BufferedReader br = new BufferedReader(r);
    			String s = null;
    			
    			while((s = br.readLine()) != null) {
    				// System.out.println();
    				ps.println(s);//等同于System.out.println();
    			}
    			br.close();
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			ps.println("无法读取文件 !");
    			e.printStackTrace();
    		}
    	}
    }
    

      


    4.数据流(处理基本数据类型、String类、字节数组)
    DataInputStream DataOutputStream

    package data;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.IOException;
    
    public class TestDataStream {
    	public static void main(String[] args) {
    		
    		ByteArrayOutputStream baos = new ByteArrayOutputStream();
    		
    		DataOutputStream dos = new DataOutputStream(baos);
    		
    		try {
    			dos.writeDouble(Math.random());
    			dos.writeBoolean(true);
    			ByteArrayInputStream bais = 
    					new ByteArrayInputStream(baos.toByteArray());
    			System.out.println(bais.available());
    			DataInputStream dis = new DataInputStream(bais);
    			/*
    			 * 先进先出---队列
    			 * 先进后出---栈
    			 */
    			System.out.println(dis.readBoolean());
    			System.out.println(dis.readDouble());//两种数据占用的空间不同必须遵守先进后出
    			dos.close();
    			dis.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    

      


    5.对象流(用来处理对象的)
    >对象的序列化机制:允许把内存中的Java对象转换成平台无关的二进制流,从而允许把这种二进制流持久地保存在磁盘上,
    或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流,就可以恢复成原来的Java对象
    ObjectInputStream(Object readObject();) ObjectOutputStream (void writeObject(Object obj))
    如何创建流的对象:ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("person.txt")));
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("person.txt")));

    实现序列化机制的对象对应的类的要求:①要求类要实现Serializable接口②同样要求类的所有属性也必须实现Serializable接口
    ③ 要求给类提供一个序列版本号:private static final long serialVersionUID;
    ④属性声明为static 或transient的,不可以实现序列化

    package object;
    
    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;
    
    public class TestObjectStream {
    	public static void main(String[] args) {
    		try {
    			Test t = new Test();
    			t.i += 5;
    			FileOutputStream fos = 
    					new FileOutputStream("C:\Users\gaofangquan\Desktop\新建文件夹\新建文本文档 (6).txt");
    			ObjectOutputStream oos = 
    					new ObjectOutputStream(fos);
    			oos.writeObject(t);
    			oos.flush();
    			oos.close();
    			
    			FileInputStream fis = 
    					new FileInputStream("C:\Users\gaofangquan\Desktop\新建文件夹\新建文本文档 (6).txt");
    			ObjectInputStream ois = 
    					new ObjectInputStream(fis);
    			Test t_read = (Test)ois.readObject();
    			
    			System.out.println(t_read);
    			
    			ois.close();
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    // Serializable--标记型接口, 没有实际的方法, 只是用来表示这个类可以被序列化
    class Test implements Serializable {
    	
    	private static final long serialVersionUID = 1L;
    	
    	String name = "hanqi";
    	int i = 3;
    	int j = 15;
    	transient // 透明的, 表示这个属性在写入流的时候不予考虑
    		double d = 12.345;
    	
    	@Override
    	public String toString() {
    		return "Test [name=" + name + ", i=" + i + ", j=" + j + ", d=" + d + "]";
    	}
    }
    

      

    6.随机存取文件流:RandomAccessFile
    6.1既可以充当一个输入流,又可以充当一个输出流:public RandomAccessFile(File file, String mode)
    6.2支持从文件的开头读取、写入。若输出的文件不存在,直接创建。若存在,则是对原有文件内容的覆盖。
    6.3 支持任意位置的“插入”。

  • 相关阅读:
    97. Interleaving String
    96. Unique Binary Search Trees
    95. Unique Binary Search Trees II
    94. Binary Tree Inorder Traversal
    odoo many2many字段 指定打开的form视图
    docker sentry 配置文件位置
    postgres 计算时差
    postgres 字符操作补位,字符切割
    postgres判断字符串是否为时间,数字
    odoo fields_view_get
  • 原文地址:https://www.cnblogs.com/gaofangquan/p/7270891.html
Copyright © 2011-2022 走看看