Java基础之IO

最新推荐文章于 2023-06-08 13:00:27 发布

sun_zhengya

最新推荐文章于 2023-06-08 13:00:27 发布

阅读量426

点赞数

分类专栏： Java编程学习文章标签： java 字符流 IO基础题 IO 字节流

本文链接：https://blog.csdn.net/sun_zhengya/article/details/38613399

版权

Java编程学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

欢迎大家来交流学习，多多指教。。。。。。

Java基础之IO

IO流用来处理设备之间的数据传输，Java对数据的操作是通过流的方式，Java用于操作流的对象都在IO包中流按操作数据分为两种：字节流与字符流；流按流向分为：输入流，输出流。

1、IO常用基类

字节流的抽象基类：InputStream ，OutputStream；

字符流的抽象基类：Reader ， Writer。

2、字节流

2.1、字节流

定义：基本操作与字符流类相同,但它不仅可以操作字符，还可以操作其他媒体文件.

实例代码：

字节流读取文件

import java.io.*;
class Test{
    public static void main(String args[]){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        byte[] buffer = new byte[100];
        int temp = 0;
        try{
            fis = new FileInputStream("D:/test/src/from.txt");
            fos = new FileOutputStream("D:/test/src/to.txt");
            while(true){
                temp = fis.read(buffer,0,buffer.length);
                if(temp == -1){
                    break;
                }
                fos.write(buffer,0,temp);
            }        
        }
        catch(Exception e){
            System.out.println(e);
        }
        finally{
            try{
                fis.close();
                fos.close();
            }
            catch(Exception e2){
                System.out.println(e2);
            }
        }

    }
}

2.2、字节流缓冲区

定义：同样是提高了字节流的读写效率

特点：

InputStream的read方法特点：从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。在输入数据可用、检测到流末尾或者抛出异常前，此方法一直阻塞。

OutputStream的write的特点：将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。

实例代码：

class CopyPic
{
public static void main(String[] args)throws IOException
{
long start = System.currentTimeMillis();
CopyFlv3();
long end = System.currentTimeMillis();
System.out.println((end-start)+"毫秒");
}
public static void CopyFlv3()throws IOException
{
MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("H:\\1.flv"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("H:\\3.flv"));
byte[] buf = new byte[1024];
int len = 0;
while((len=bufis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
bufis.myClose();
bufos.close();
}
}

3、字符流

字符流操作的数据是关于字符的，按照流向，可以分为字符输入流Reader和字符输出流Writer。

Reader和Writer两个类主要用于操作文本数据的内容，而InputStream和OutputStream主要操作二进制格式的内容

基类Writer

备注：

1）Writer的子类在继承父类是需要实现write字符数组的某一部分，flush，close方法。
2）flush和close区别：flush刷新后，流还可以继续使用，close刷新后，流将关闭。
3）Writer中所有的方法都会抛出IOException，因此在实际开发过程中，需要做异常处理。

子类：OutputStreamWriter、FileWriter

过程

创建流对象，建立数据存放文件。
2）调用流对象的写入方法，将数据写入流。
3）关闭流资源，并将流中的数据清空到文件中。

FileWriter fw = new FileWriter(“Test.txt”);
fw.write(“text”);
fw.close();

基类Reader

备注：

1）Reader的子类在继承父类是需要实现Read字符数组的某一部分，close方法。
2）Reader中所有的方法都会抛出IOException，因此在实际开发过程中，需要做异常处理。

子类： InputStreamReader、FileReader

示例代码：

FileReader fr = null;
try{
fr = new FileReader("c:\\test.txt");
char[] buf = new char[1024];
int len= 0;
while((len=fr.read(buf))!=-1){
System.out.println(new String(buf,0,len));
}
}
catch (IOException e){
System.out.println("read-Exception :"+e.toString());
}
finally{
if(fr!=null){
try{
fr.close();
}
catch (IOException e){
System.out.println("close-Exception :"+e.toString());
}
}
}

字符流的缓冲区

1）缓冲区的出现是为了提高流的操作效率而出现的，所以，在创建缓冲区之前，必须要先有流对象。
2）缓冲区要结合流才可以使用，在流的基础上对流的功能进行了增强。
（1）分类
BufferedWriter 字符输出流缓冲区该缓冲区中提供了一个跨平台的换行符newLine();
BufferedReader 字符数入流缓冲区该缓冲区中提供了一个一行数据的方法readLine()
（2）使用方法
缓冲区的出现提高了对数据的读写效率，在开发过程中，要使用字符缓冲区，只要将需要被提高的流对象作为参数传递给缓冲区的构造函数即可

BufferedWriter bufw = new BufferedWriter(new FileWriter("buf.txt"));
BufferedReader bufr = new BufferedReader(new FileReader("buf.txt"));

示例代码：

class CopyTestByBuf
{
public static void main(String[] args)
{
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
bufw = new BufferedWriter(new FileWriter("BufferedWriter_Copy.txt"));
String line = null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("文件操作失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("文件读取失败");
}
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("文件写入失败");
}
}
}
}

下面附上之前做的基础题：

编写程序，将指定目录下所有.java文件拷贝到另一个目的中，并将扩展名改为.txt

代码基本上没有问题，测试过！

import java.io.*;

public class Test9 {
        public static void main(String[] args) {
                File orig=new File("D:\\test\\java"); //源文件夹
                File dest=new File("D:\\test\\txt");//要复制过去的文件夹
                findAndCopyJava(orig,dest); 
                
        }
        
        //寻找.java文件并复制到目标文件夹
        public static void findAndCopyJava(File orig,File dest){ 
                if(!dest.exists()){            //不存在就创建目的目录，但是这个地址有可能是一个绝对地址。
                        dest.mkdir();
                }
                if(!dest.isDirectory()){    //所以再次判断存在的文件是否是一个目录，而不是文件。
                        dest.mkdir();
                }
                File[]  files = orig.listFiles();
                for(File file: files){     //遍历files
                        if(file.isDirectory()){
                                findAndCopyJava(file,dest);  //递归，一直到file是一个文件而不是目录。
                        }
                        else if(file.getName().endsWith(".java")){
                                copy(file,dest);
                        }
                }
        }
        
        //用于改后缀后复制
        public static void copy(File orig,File dest){ 
            BufferedReader buf = null;
            PrintWriter  out=null;;
            try{
                    buf=new BufferedReader(new InputStreamReader(new FileInputStream(orig))); //读取流，提升阅读效率
                    out=new PrintWriter(dest+"\\"+orig.getName().replace(".java", ".txt"));  // 把后缀改成.java，用Print流提升效率
            }catch(IOException e){
                    System.out.println("文件orig或者dest异常");
            }
            String line = null;
            try{
            	while((line = buf.readLine()) != null){
                    out.println(line);
            	}
            }catch(IOException e){
                    
            }finally{
                    try{
                            if(buf!=null)
                                    buf.close();
                            if(out!=null)
                                    out.close();		//关闭
                    }catch(Exception e2){
                            
                    }
            }
    }
}