精华内容
下载资源
问答
  • 字节流和字符流Java流字符流操作使用字符流读取文件使用字符流写文本文件三级目录 Java流 我们知道了如何利用file类对文件或者目录属性进行操作,但File类不能访问文件的内容,即不能从文件中读取数据或向文件里写...

    Java流

    我们知道了如何利用file类对文件或者目录属性进行操作,但File类不能访问文件的内容,即不能从文件中读取数据或向文件里写数据。
    读文件,是指把文件的数据读取到内存中,反之写文件就是把内存中的数据写到文件中。
    流呢,是指一连串流动的字符,是以先进先出的方式发送和接收数据的通道。
    在java.io包中,封装了许多输入\输出流API。在程序中,这些输入输出流的类的对象成为流对象。可以通过这些流对象将内存中的数以流的方式写入文件,也可以通过流对象将文件中的数据以流的方式读取到内存。
    流对象构造的时候往往会和数据源联系起来。数据源分为源数据流和目标数据流源。
    1.输入流联系的是源流数据源
    2.输出流联系的则是目标数据源。
    按照不同的分类方式,可以将流分成不同的类型。
    1.按照流的流向进行划分可以分成输入流和输出流。
    输出流:OUTPutStream和Writter作为基类。只能向其中写入数据,不能读。
    输入流:InputStream和Reader作为基类。只能读取数据,不能写。
    2.按照所操作的数据单元的不同,流又可以分成字节流和字符流。
    字节流操作的最小的数据单位为8位字节,而字符流操作的最下数据单元是16位字符。
    字节流和字符流的区分也很简单,字节流建议使用于二进制数据操作,而字符流用于文本。他们的用法几乎一样。

    字符流操作

    使用字符流读取文件

    1.字符流输入流Reader类
    Reader类是读取字符流的抽象类,他提供了常用的方法。
    int read() 输入流中读取单个字符
    int read(byte[] c)从输入流中读取c.length长度的字符,保存到字符数组C中,返回实际读取的字符数。
    read(char[] c,int off,int len)从输入流中读取最多len的长度字符,保存到字符数组c中,保存的位置从off位置开始,返回实际读取的字符长度。
    close() 关闭流
    2.字符输入流FileReader类
    FileReader类是Reader的子类,常用的构造方法格式如下。
    FileReader(String fileName)其中,fileName是指要从中读取数据文件的名称。使用的方法如下:

    Reader fr=new FileReader(“C:\\myTest.txt”);
    

    3.使用FileReader读取文件
    使用字符流类FileReader读取文本文件的操作如下。
    1.引入类

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.Reader;
    

    2.创建FileReader对象

    Reader re = new FileReader("C:\\mytest.txt");
    

    3.利用FileReader类方法读取文本文件
    int read();//读取单个字符
    4.关闭相关的流对象
    fr.close();

    l练习:

    Reader fe=null;
    		StringBuffer sbf=null;
    		try {
    			fe=new FileReader("hello.txt");
    			char ch[]=new char[1024];//创建字符数组作为中转站
    			sbf=new StringBuffer();
    					int lenth=fe.read(ch);//将字符读入数组
    					while((lenth!=-1)){
    						sbf.append(ch);//追加字符
    						lenth=fe.read();
    					}		
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			if(fe!=null){
    				try {
    					fe.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    

    创建字符的中转站,存入每次读取的数据内容,然后调用FileReader对象的Read()方法将字符读入数组ch,并追加到字符串sbf中。

    或者我们可以这样写:

    char[] cbuf = new char[5];
    		int len = 0;
    		try {
    			fileReader = new FileReader(file);
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}
    		try {
    			while ((len = (fileReader.read(cbuf))) != -1) {
    				String str = new String(cbuf, 0, len);
    				System.out.println(str);
    			}
    

    上面我们演示了FileReader类读取文件。而开发中,我们会将FileReader类和BufferReader类结合使用。提高文件的效率。

    4.字符输入流BufferedReader类
    BufferedReader类是Reader的子类,它与FileReader类的区别在于BufferReader类带有缓冲区,它可以先把一批数据读到缓冲区,接下来的读操作都是从缓冲区内获取数据,避免每次都从数据源读取数据进行字符编码转换,从而提高读取操作的效率。BufferedReader类常用的构造方法如下。
    BufferedReader(Reader in);
    使用此方法创建字符输入对象如下。

    Reader fr=new FileReader(“C:\\mytest.txt”);
    BufferedReader br=new BufferedReader(fr);
    

    其中br就是创建的一个使用默认大小输入缓冲区的缓冲字符输入流。
    5.使用FileReader和BufferedReader读取文本文件。
    具体操作如下;
    1.引入相关类
    2.创建一个BufferedReader对象
    3.利用BufferedReader类的方法读取文本文件的数据。
    4.关闭相关的流对象。
    测试代码:

    public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Reader fe=null;
    		BufferedReader br=null;
    		try {
    			fe=new FileReader("hello.txt");
    			br=new BufferedReader(fe);
    					String lenth=br.readLine();//读取行内容
    					while(lenth!=null){
    						System.out.println(lenth);
    						lenth=br.readLine();
    					}
    		} catch (Exception e) {
    			System.out.println("文件不存在");
    		}finally{
    				try {
    					if(br!=null){
    						br.close();
    					}
    					if(fe!=null){
    					fe.close();
    					}
    				} catch (IOException e) {
    					e.printStackTrace();
    				}	
    		}
    	}
    
    

    使用字符流写文本文件

    1.字符流输出Writer
    writer类是向文件写入数据流的字符流,它提供了常用的方法。
    writer(string str)将str字符串里包含的字符输出到指定的输出流中
    writer(String str,int off,int len)将str字符串里从off位置开始长度为len的字符输出到输出流中。
    close()关闭输出流
    flush()刷新输出流
    2.字符输出流FileWriter类
    FileWriter类是Reader的子类,常用的构造方法如下:
    FileWriter(String fileName)
    其中,filename表示与系统有关的文件名,使用此构造方法创建字符流输出流对象如下。
    Writer fr=new FileWriter(“C:\myTest.txt”);
    3.使用FileWriter写文本文件
    使用FileWriter将数据写入文本文件的步骤如下。
    1.引入相关类
    2.创建一个FileWriter对象
    3.利用FileWriter类的方法写文本文件。
    4.相关流对象的清空和关闭。
    4.字符输出流BufferedWriter类
    同理BufferedWriter也是Writer的子类。其他的情况和上面的BufferedReader类相同。
    5.BufferedWriter和FileWriter写文本文件
    步骤其实是和上面相同。直接练习显示

    try{fw=new FileWriter("hello.txt");
    			bw=new BufferedWriter(fw);
    					bw.write("大家好");
    					bw.write("dsafdfa");
    					bw.newLine();//插入换行
    					bw.write("dthadsn");
    					bw.write(123);
    					bw.flush();//刷新流
    					bw.close();//关闭流
    	}				
    

    字节流操作

    使用字节流读取文本文件

    1.字节输入流InputStream类
    字节输入流InputStream的作用就是将文件中的数据输入到内部存储器(内存)中,它提供了一系列和读取数据有关的方法,常用的方法如下。
    int read() 读取一个字符
    int read(byte[] b)将数据读到字节中
    int read(byte[] b,int off,int len)从输入流中读取最多len长度的字节,保存到字节数组b中,保存的位置从off开始。
    void close() 关闭输入流
    int availabe() 返回输入流读取的估计字节数
    无参的read()方法从输入流读取一个八位的字节,把它转换为0~255的整数返回。
    有参的两个read()方法从输入流批量读取若干字节。从文件或键盘读数据时,采用read(byte[] b)或者int read(byte[] b,int off,int len)方法可以减少进行物理读文件或键盘的次数,提高输入输出操作效率。
    2.字节输入流FileInputStream类
    在实际应用中,我们通常使用InputStream的子类FileStream类来实现本文文件内容的读取,常用的构造方法如下。
    1)FileinputStream(File file)。其中,file指定文件数据源。使用此构造方法创建文件输入流对象如下。

    File file=new File(“C:\\myTest.txt”);
    InputStream fileObject=new FileInputStream(file);
    

    此时的文件输入流对象fileObject就和数据源(“C:\myTest.txt”);联系起来了。
    2)FileInputStream(String name)。其中,name指定文件数据源包含路径信息。使用此构造方法创建文件输入流对象如下。

    InputStream in =new FileInputStream(“C:\\myTest.txt”);
    

    3.使用FileInputStream读取文件
    使用FileInputStream读取文件具体操作如下。
    1)引入相关类

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    

    2)创建一个文件输入流对象

    InputStream fileObject=new FileInputStream(“C:\\myTest.txt”);
    

    3)利用文件输入的方法读取文本文件的数据。

    fileObject.avaliable()//可读取的字节数
    fileObject.read()//读取文件的数据
    

    4)关闭文件输入流对象。

    fileObject.close();
    

    下面我们示例学习一下。首先,我们创建一个文件,hello.txt,然后文件保存的内容为abc,然后输出到控制台上。
    示例:

    FileInputStream fis=null;
    		try{
    			fis=new FileInputStream("hello.txt");
    			int data;
    			System.out.println("可读取的字节数"+fis.available());
    			System.out.println("文件内容为:");
    			while((data=fis.read())!=-1){
    				System.out.println(data+" ");
    			}
    		}catch (Exception e) {
    			// TODO: handle exception
    			e.printStackTrace();
    		}finally{
    			if(fis!=null){
    				try {
    					fis.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    

    发现输出的东西和文件中的东西不一致,那是因为InputStream和read方法是从输入流读取一个八位字节,把它转换为0~255的整数返回。abc各占一个字节所以输出的整数就是97 98 99.

    注意:使用FileInputStream类读文件数据的时候还要注意下面方面。
    1)read()方法返回整数,若读取的是字符串,则需要强制类型转换。例如如果想正常输出abc则要修改语句System.out.print((char)data+" ");
    2)流对象使用完毕之后要关闭。

    使用字节流写文本文件

    1.字节输出流OutputStream类
    字节输出流OutputStream类的作用是把内存中的数据输出到文件中,它提供了一系列文件中写数据的有关方法。常见的方法如下。
    void write(int c)写入一个字节数据
    void write(byte[] buf)写入数组buf的所有字节
    void write(byte[] b,int off,int len)将字节数组从off位置开始,长度为len的字节数据输出到输出流中。
    void close() 关闭输出流
    2.字节输出流FileOutputStream类
    我们通常使用OutputStream的子类FileOutputStream类来实现向文本文件写入数据,常用的构造方法有以下三个。
    1)FileOutputStream(File file)。其中,file指定文件目标数据源。使用此构造方法创建文件输出流对象如下。

    File file=new File(“C:\\myTest.txt”);
    FileOutputStream fos=new FileOutputStream(file);
    

    此时的文件输出流fos就和目标数据源(“C:\myTest.txt”)联系起来。
    2)FileOutputStream(String name)。其中,name指定目标文件数据源,包含路径信息。

    FileOutputStream fos=new FileOutputStream(“C:\\myTest.txt”);
    

    3)FileOutputStream(String name,boolean append)。其中,name指定目标文件数据源,包含路径信息。append表示是否在文件末尾添加数据,若设置为true,则在文件末尾添加数据。使用此构造方法创建文件输出流对象如下。

    FileOutputStream fos=new FileOutputStream(“C:\\myTest.txt”,true;
    

    要注意的是第一种方法和第二种构造方法在向文件写数据时将覆盖文件中原有内容。另外,在使用FileOutputStream的构造方法创建FileOutputStream实例时,如果相应的文件并不存在,就会自动创建一个空的文件。若参数file或name表示的文件路劲尽管存在,但是代表一个文件目录,则此时会抛出FileNotFoundException异常。

    3.使用FileOutputStream写文本文件
    使用FileOutputStream向文本文件中写入数据的具体使用步骤。
    1)引入相关的类。

    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    

    2)构造一个文件输出流对象

    OutputStream fos=new FileOutputStream(“C:\\myTest.txt”);
    

    3)利用文件输出流的方法把数据写入文本文件中

    String str=“好好学习”;
    byte[] words =str.getBytes[];
    fos.write(words,0,words.length);
    

    4)关闭文件输出流

    fos.close();
    

    下面示例是具体的应用。

    	FileOutputStream fos=null;
    		try {
    			String str="学习xuexi";
    			byte[] words=str.getBytes();//字节数组
    			fos=new FileOutputStream("hello.txt");//写文件
    			fos.write(words,0,words.length);
    			System.out.println("hello 文件已经更新了");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}finally{
    			if(fos!=null){
    				try {
    					fos.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    

    首先将要写入文件的字符串通过getBytes()方法转换成字节数组words,然后调用输出流对象的write()方法,将字节数组words中的内容添加到文件(“hello.txt”)的末尾。

    注意:

    // 字节流处理 ( .jpg .mp3 .mp4 .avi .doc .ppt)
    // 字符流 处理 (.txt .java)字符流

    同理,字符流中也有缓冲输入输出 BufferedInputStream 和 BufferedOutputStream
    使用方式和字节流也一样。
    示例复制音乐:

    public  void  BufferedTest() {
    		File file1 = new File("admin.mp3");
    		File file2=new File("tom.mp3");
    		FileInputStream fileInputStream=null;
    		FileOutputStream fileOutputStream=null;
    		try {
    			fileInputStream = new FileInputStream(file1);
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}
    		try {
    			fileOutputStream = new  FileOutputStream(file2);
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}
    		BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
    		BufferedOutputStream bufferedOutputStream = new  BufferedOutputStream(fileOutputStream);
    		byte  [] buffer=new byte[1024];
    		int len=0;
    		try {
    			while((len=bufferedInputStream.read(buffer))!=-1) {	
    				bufferedOutputStream.write(buffer, 0, len);
    				
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		if(fileInputStream!=null) {
    			try {
    				fileInputStream.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		if(fileOutputStream!=null) {
    			try {
    				fileOutputStream.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    展开全文
  • 概述 IO流分类: 流向 输入流 读取数据 FileReader Reader 输出流 出数据 FileWriter Writer 数据类型 字节流 字节输入流 读取数据 ...利用字符流复制文本文件 利用字符流将当前工程下的IODemo.java拷贝到

    概述

    IO流分类:

    流向
      输入流	读取数据	FileReader	Reader
       输出流	写出数据	FileWriter	    Writer
     数据类型
         字节流	
         	字节输入流   读取数据	InputStream
    	    字节输出流   写出数据	OutputStream
    	字符流
    	     字符输入流  读取数据	    Reader
              字符输出流  写出数据	Writer
    

    利用字符流复制文本文件

    利用字符流将当前工程下的IODemo.java拷贝到d盘的a文件夹下

    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 使用字符流复制文本文件
     * 
     * 数据源		IODemo.java
     * 目的地		d:\\IODemo.java
    
     * 	
     */
    public class FileCopyDemo {
    	public static void main(String[] args) throws IOException  {
    		//创建字符输入流对象
    		FileReader fr = new FileReader("IODemo.java");
    		//创建字符输出流对象
    		FileWriter fw = new FileWriter("d:\\IODemo.java");
    		
    		//一次读写一个字符
    		
    		/*int ch;
    		while((ch = fr.read()) != -1) {
    			fw.write(ch);
    			fw.flush();
    		}*/
    		
    		//一次读写一个字符数组
    		int len;//用于存储读到的字符个数
    		char[] chs = new char[1024];
    		while((len = fr.read(chs)) != -1) {
    			fw.write(chs,0,len);
    			fw.flush();
    		}
    		
    		//释放资源
    		fw.close();
    		fr.close();
    	}
    }
    

    利用字节流复制文本文件

    利用字节流将当前工程下的IODemo.java拷贝到d盘下

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * 使用字节流复制文本文件
     * 
     * 数据源		IODemo.java
     * 目的地		d:\\a\\IODemo.java
     * 
    
     */
    public class FileCopyDemo {
    	public static void main(String[] args) throws IOException  {
    		//创建字节输入流对象
    		FileInputStream fis = new FileInputStream("IODemo.java");
    		//创建字节输出流对象
    		FileOutputStream fos = new FileOutputStream("d:\\a\\IODemo.java");
    		
    		//一次读写一个字节
    		/*int by;
    		while((by = fis.read()) != -1) {
    			fos.write(by);
    		}*/
    		//一次读写一个字节数组
    		int len;//存储读到的字节个数
    		byte[] bys = new byte[1024];
    		while((len = fis.read(bys)) != -1) {
    			fos.write(bys,0,len);
    		}
    		
    		
    		//释放资源
    		fos.close();
    		fis.close();
    	}
    }
    

    复制图片

    字节流可以操作所有类型的文件,因为所有的文件在计算机中都是以字节形式存储
    而字符流只能用来操作纯文本类型的文件,不能操作字节类型的文件

    能使用字符流一定可以使用字节流,但是使用字节流不一定能使用字符流

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 分别使用字符流和字节流复制图片
     * 
     * 二进制文件只能使用字节流进行复制(使用windows自带记事本打开读不懂的)
     * 文本文件的复制即可使用字符流,也可以使用字节流
     * 
     * 先随便复制一张图片至项目下
     */
    public class CopyImage {
    	public static void main(String[] args) throws IOException  {
    		//method();
    		
    		//创建字节输入流对象
    		FileInputStream fis = new FileInputStream("a.jpg");
    		//创建字节输出流对象
    		FileOutputStream fos = new FileOutputStream("d:\\a.jpg");
    		
    		//一次读写一个字节数组
    		int len;//用于存储读到的字节个数
    		byte[] bys = new byte[1024];
    		while((len = fis.read(bys)) != -1) {
    			fos.write(bys,0,len);
    		}
    		
    		//释放资源
    		fos.close();
    		fis.close();
    	}
    
    	private static void method() throws FileNotFoundException, IOException {
    		//创建字符输入流对象
    		FileReader fr = new FileReader("a.jpg");
    		//创建字符输出流对象
    		FileWriter fw = new FileWriter("d:\\a.jpg");
    		
    		//一次读写一个字符数组
    		int len;//用于存储读到的字符个数
    		char[] chs = new char[1024];
    		while((len = fr.read(chs)) != -1) {
    			fw.write(chs,0,len);
    			fw.flush();
    		}
    		
    		//释放资源
    		fw.close();
    		fr.close();
    	}
    }
    
    展开全文
  • 我们利用JAVA的IO类进行读写数据的时候所提供的大部份的方法都是采用读写字节的方式,而且通过这种读写字节的方法是可以保存任可类型的数据的,因为任数据类型在计算机中都是字节码,前提是你要先将你写入的数据先...

    在计算机中保存的数据都只是二进制符号并按字节为单位来保存,对计算机看来字符A并不是字符A,而只是一个没有意义的二进制数字是一个字节。我们利用JAVA的IO类进行读写数据的时候所提供的大部份的方法都是采用读写字节的方式,而且通过这种读写字节的方法是可以保存任可类型的数据的,因为任数据类型在计算机中都是字节码,前提是你要先将你写入的数据先转换成字节类型再通过输出流类输出,而要使得读取出来的数据对我们的程序有意义,我们必须将读取出来的字节按它保存时所表达的意义转换回来,如:保存的时候是char型的,那么我们就要把读取出来的字节数据类型转换成char类型还原它来所表达的意义,要不如果直接输出这个字节数据所得的仅仅是一个16进制的符号,对我们来说是没有意义的。所以,在JAVA里字节类型是一种万能的数据类型,也是数据在计算机里的真正面目。

    JAVA的IO类为了方便我们输入输出那些基本的数据类型,基本上在各种的IO类里都提供了针对专门各种的基本数据类型的读写方法,这些方法其实是已经封装了那些转换代码了,如:readInt writeInt 等,但似乎就是没有提供读写STRING类型的方法,原因是JAVA提供了专门读写文本字符的IO类,如:reader writer这两个抽像基类,以及由其派生出来的子类都是专门用来读写文本字符的。因此,如果你要读取文本文件的都话就不要去用inputstrem outStrem这一系列的IO类了,而要使用reader writer 这系列的类了,因为它们不是针对文本的,如果非要用不可的话,你就要在程序中设定专门的程序代码来做这些字符的转换了。如下代码所示:

    RandomAccessFile ra=new RandomAccessFile("c://1.txt","rw");  //RandomAccessFile类不支持字符的直接读写的

    String s=new String("hello world"); 

    ra.write(s.getBytes()); //将String转换成字节类型

    byte buf[]=new byte[1024];   //定义一个字节数组用以接收读取到的字节数据

    raf.read(buf,0,512);  //RandomAccessFile类不支持字符的直接读取
      
    System.out.println("name:"+new String(buf));  //将读取出来的字节数据转换成String并输出。

    这里还有一个问题,那就是字符编码的问题,在JAVA虚拟机上字符是以UNICODE的格式来表示的,而我们的机器则是以本地机字符集对字符编码的,所以存在同一个字符有两种不同的表示,因此,当我们想以GB2312也就是简体中文的格式来把这些字符保存在文件上,并以简体中文的格式在显示器(输出流)上显示这些字符,那么我们只得先将UNICODE格式的String转换成GB2312格式的字符编码即s.getBytes(),其实这个方法的作用是用本地的字符编码将UNICODE格式的字符编码转换成GB2312的编码,除非你的机器本地编码是采用UNICODE格式,否则这样的转换是免不了的,即使采用包装类也只是用方法来把这个转换过程隐藏了。JAVA采用UNICODE来做为JVM的字符编码,是因为UNICODE是全球的统一标准,有助于JAVA 的跨平台实现,但无奈现实中还是有很多系统仍然采用各自国家的字符编码,因此JAVA不得不提供一种方法来进行UNICODE与当地字符编码的转换。

    展开全文
  • 4.字节流每次读取或者写入一个字节,而字符流每次读取或者写入一个字符(两个字节),通常字节流用来对图片、音频、视频等文件进行操作,而字符流用来对文本文件进行操作 5.节点流是处理流的基础,因为处理流的构造...

    目标:理解掌握IO流
    重点:
    1.IO的英文全称为input(输入)、output(输出)
    2.输入是指从磁盘输入到内存(读文件),输出是指从内存输出到磁盘(写文件)
    3.IO流下面的结构图
    尽快解决尽快尽快尽快述
    4.字节流每次读取或者写入一个字节,而字符流每次读取或者写入一个字符(两个字节),通常字节流用来对图片、音频、视频等文件进行操作,而字符流用来对文本文件进行操作
    5.节点流是处理流的基础,因为处理流的构造方法中需要一个其他流作为参数传递,例如
    new BufferedReader(new FileReader(filePath));
    6.处理流比节点流的效率更高
    代码:
    1.利用节点字节流对图片文件进行复制粘贴

    package May.Ninth.IO;
    /**
     * 复制粘贴一个图片、音频、视频
     */
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class OthersFileCopy {
    
    	public static void main(String[] args) {
    
    		new OthersFileCopy().read("E:Javatest/1.jpg", "E:Javatest/1/2.jpg");
    	}
    
    	public void read(String path1, String path2) {
    		// 创建一个字节缓冲区域
    		byte[] bs = new byte[1024];
    		// 创建源文件对象
    		File file1 = new File(path1);
    		// 判断源文件是否存在
    		if (file1.exists()) {
    			// 创建一个目标文件对象
    			File file2 = new File(path2);
    			// 判断目标文件是否存在,不存在,则创建目标文件
    			if (!file2.exists()) {
    				try {
    					file2.createNewFile();
    					System.out.println("目标文件创建成功");
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			} else {
    				System.out.println("目标文件已存在");
    			}
    			// 初始化字节输入流
    			FileInputStream fis = null;
    			// 初始化字节输出流
    			FileOutputStream fos = null;
    			try {
    				// 创建字节输入流
    				fis = new FileInputStream(file1);
    				// 创建字节输出流
    				fos = new FileOutputStream(file2);
    				// 循环读取数据,read()方法返回本次所读取的数据长度,当文件已经被读取到了末尾时,read()方法会返回一个-1
    				int lengh = 0;
    				while ((lengh = fis.read(bs)) != -1) {
    					// 将bs数据写入目标文件中
    					fos.write(bs, 0, lengh);
    					// 强制刷新fos流
    					fos.flush();
    				}
    			} catch (IOException e) {
    				e.printStackTrace();
    			} finally {
    				try {
    					// 关闭字节输出流
    					fos.close();
    					// 关闭字节输入流
    					fis.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		} else {
    			System.out.println("源文件不存在,请重试");
    		}
    	}
    }
    
    

    2.利用缓冲流对文本文件进行复制粘贴

    package May.Tenth.IO_Buffered;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /**
     * 复制一个文本文件
     * @author Jia
     *
     */
    public class CopyJpgFile {
    
    	public static void main(String[] args) {
    		new CopyJpgFile().copyJPGFile("E:/Javatest/1.txt","E:/Javatest/1" );
    		
    	}
    
    	public void copyJPGFile(String path1, String path2) {
    		// 创建源文件的对象
    		File file = new File(path1);
    		// 创建目标文件的路径
    		path2 = path2 + "/" + file.getName();
    		// 判断源文件是否存在
    		if (file.exists()) {
    			// 声明BufferedReader、BufferedWriter对象
    			BufferedReader br = null;
    			BufferedWriter bw = null;
    			try {
    				// 创建BufferedReader、BufferedWriter对象,参数为对应的节点流对象
    				br = new BufferedReader(new FileReader(file));
    				bw = new BufferedWriter(new FileWriter(path2));
    				// 循环读取源文件,readline()方法每次返回一行源文件内容,读到源文件末尾时,返还一个null对象
    				String str = null;
    				while ((str = br.readLine()) != null) {
    					// 将读取到的数据写到目标文件
    					bw.write(str);
    					// 强制刷新
    					bw.flush();
    				}
    				System.out.println("文件复制成功");
    			} catch (IOException e) {
    				e.printStackTrace();
    			} finally {
    				try {
    					// 关闭对象
    					bw.close();
    					br.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}else{
    			System.out.println("文件未找到");
    		}
    	}
    }
    
    
    
    

    备注:文件加密下次再说

    展开全文
  • 文本文件中,写入文本数据分为三步:搭桥、运输、拆桥 ①搭桥 搭建好数据传输通道——对象 创建FileOutputStream对象 构造方法: Ⅰ FileOutputStream(File file) //用File对象创建 Ⅱ FileOutputStream(String ...
  • java IO

    2021-01-16 12:03:32
    使用字节流复制文本文件4. 分别使用字符流和字节流复制图片 1. IO流分类 流向 输入流 读取数据 FileReader Reader 输出流 出数据 FileWriter Writer 数据类型 字节流 字节输入流 读取数据 InputStream ...
  • 首先确定IO流的类型:因为文件可能不是文本文件,故选择字节流,然后选择读取和写入的方式,因为文件可能较大,故采用边读边较好。 编写一个Cop类,利用主函数的两个参数分别获取待操作的文件路径,从而根据路径...
  • 前面学习了对文本文件的读写操作,有了这个基础,我们来学习下,C++对二进制文件的读写操作。因为是二进制,所以不管是读还是文件,其中打开方式要指定为iso::binary。 1.二进制文件 二进制方式文件主要...
  • 最近闲来无聊,想一个简单的文件操作的类。... .NET中操作文件的类如下: FileStream:提供一个访问文件流文件进行读写、打开、关闭等操作 StreamReader:用于读取文本信息。他会检查字节
  • 除了字节流,JDK还提供了用于实现字符操作的字符流,和字节流一样,字符流也有两个抽象顶级父流,分别是Reader和Writer。 思考:什么情况下使用字符流? 字符流也可以拷贝文本文件,但不推荐使用。因为读取时会把...
  • 文件操作

    2019-09-24 17:18:13
    二进制文件 需要特定的软件 字节流 c++通过fstream头文件进行文件的调用 文本文件一般使用 get put 进行读写 二进制文件利用 write和read 打开关闭openclose is_open 读写文件get/putread/writegetline输入输.....
  • 字节流处理文件2. 字符流处理文件二、字节数组流IO 工具类装饰器设计模式字节缓冲流字符缓冲流字符转换流数据流对象流打印流文件序列流文件分割文件合并CommonIO 类 Java IO 利用 Java IO 你可以访问文件与目录,...
  • 同缓冲字节流一致,利用缓存机制,大大提高了读写文本文件的效率。 BufferedReader新增了逐行读取方法 readLine(); BufferedWriter新增了换行方法 newLine(); import java.io.*; public class BufferedReaderTest {...
  • 读取记事本中的纯文本可以采用字符流,其他时候一律使用字节流。IO流主要有四个抽象类,InputStream和OutputStream,Reader和Writer。 Java.io是专门为用户提供I/O操作的软件包。 字符流的缓冲装饰类:利用字符输入...
  • java 面向字符.字节

    2014-07-09 22:38:00
    字符是针对字符数据的特点进行过优化的,因而提供一些面向字符的有用特性,字符的源或目标通常是文本文件。 Reader和Writer是java.io包中所有字符的父类。由于它们都是抽象类,所以应使用它们的子类来创建实体...
  • 使用字节流写二进制文件重定向标准I/O 读写二进制文件 读写二进制文件常用的类有DataInputStream和DataOutputStream。 1.使用字节流读二进制文件 利用DataInputStream类读进制文件, 其实与利用FileInputStream 类...
  • 13.第十三章 文件.txt

    2019-11-08 16:33:27
    w 只打开或建立一个文本文件,只允许数据 a 追加打开一个文本文件,并在文件末尾数据 r+ 读写打开一个文本文件,允许读和 w+ 读写打开或建立一个文本文件,允许读和 a+ 读写打开一个文本文件,允许读...
  • 第十三周学习总结

    2019-05-30 22:30:23
    这周我们学习了文件复制,利用字节流完成文件读写操作,以文件字符流来实现文件读写操作,还有随机存取文件的读写操作,还有许多基本概念:数据从程序到文件,叫做输出,引入流的概念,那就叫输出流,这个流是以字节...
  • 编程题 1. 文件IO练习 ...利用字节流+桥转换+缓冲流读入这个文本文件,然后按照行的顺序,以 UTF-8 的编码方 式,到 test2.txt 文件中,例: 低头思故乡 举头望明月 疑是地上霜 窗前明月光 n...
  • /* 事先在当前目录下准备好一个test.txt ...利用字节流+桥转换读入这个文本文件,然后按照行的顺序,以UTF-8 的编码方式, 到test2.txt 文件中,例: test2.txt 低头思故乡 举头望明月 疑是地上霜 窗前明月光
  • 配书光盘Readme文件 C 语言通用范例开发金典 第1章 数据结构. 1 1.1 数组和字符串 2 1.1.1 一维数组的倒置 2 范例1-1 一维数组的倒置 2 ∷相关函数:fun函数 1.1.2 一维数组应用 3 范例1-2 一维数组应用 3 ...
  • “wt” 只打开或建立一个文本文件,只允许数据 “at” 追加打开一个文本文件,并在文件末尾数据 “rb” 只读打开一个二进制文件,只允许读数据 “wb” 只打开或建立一个二进制文件,只允许数据 “ab”...
  • 实例30 利用字节流读取文件中的内容 实例31 利用字节流把内容写入文件 实例32 用字符输入流读取文件 实例33 用字符输出流写文件 实例34 随机读取文件程序示例 实例35 故事接龙 实例36 文件上传 实例37 在...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
    Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密  Java非对称加密源程序代码实例,本例中使用RSA加密技术,...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
    Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密  Java非对称加密源程序代码实例,本例中使用RSA加密技术...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
    Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密  Java非对称加密源程序代码实例,本例中使用RSA加密技术...
  • Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密 Java非对称加密源程序代码实例,本例中使用RSA加密技术,定义...
  • Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密 Java非对称加密源程序代码实例,本例中使用RSA加密技术,定义...
  • java源码包

    2015-12-01 16:29:37
    Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密  Java非对称加密源程序代码实例,本例中使用RSA加密技术,...
  • Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密 Java非对称加密源程序代码实例,本例中使用RSA加密技术,定义...

空空如也

空空如也

1 2 3 4 5
收藏数 86
精华内容 34
关键字:

利用字节流写文本文件