美文网首页程序猿开发笔记Java 杂谈程序员
第39节：Java当中的IO

第39节：Java当中的IO

作者: 魔王哪吒 | 来源:发表于2018-09-06 02:11 被阅读6次
标题图

Java当中的IO

IO的分类

第一种分：
输入流和输出流
第二种分：
字节流和字符流
第三种分：
节点流和处理流

节点流处理数据，处理流是节点流基础上加工的。

IO中的重点：

InputStream
OutputStream
FileInputStream
FileOutputStream

InputStream

int read(byte[] b,int off,int len)

OutputStream

void write(byte[] b,int off,int len)

说说IO

//第一种：输入流输出流
//第二种：字节流字符流
//第三种：节点流处理流
//FileInputStream
class Test{
 public static void main(String args[]){
  FileInputStream fis = null;
  try{
  fis = new FileInputStream("e:/read.txt");
  byte[] buffer = new byte[100];
  fis.read(buffer,0,buffer.length);
  for(int i = 0;i<buffer.length;i++){
   System.out.println(buffer[i]);
  }
}
 catch(Exception e){
 System.out.println(e);
  }
 }
}

class Test{
 public static void main(String args[]){
  FileInputStream fis = null;
  FileOutputStream fos = null;
 try{
  fis = new FileInputStream("e:/read.txt");
  fos = new FileOutputStream("e:/write.txt");
  byte[] buffer = new byte[100];
  int temp = fis.read(buffer,0,buffer.length);
  fos.write(buffer,0,temp);
  }
   catch(Exception e){
    System.out.println(e);
   }
  }
}

class Test{
 public static void main(String args[]){
  FileInputStream fis = null;
  FileOutputStream fos = null;
  try{
   fis = new FileInputStream("e:/read.txt");
   fos = new FileOutputStream("e:/write.txt");
  byte[] buffer = new byte[1024];
  while(true){
   int temp = fis.read(buffer,o,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(Excepiton e){
 System.out.println(e);
  }
 }
}
}  

//字符流
public class TextChar
 public static void main(String args[]){
  FileReader fr = null;
  FileWriter fw = null;
  try{
  fr = new FileReader("e:/read.txt");
  fw = new FileWriter("e:/write.txt");
   
   char[] buffer = new char[100];
   int temp = fr.read(buffer,0,buffer.length);
   fw.write(buffer,0,temp); 
   }
   catch(Exception e){
    System.out.println(e);
   }finally{
     try{
       fr.close();
       fw.close();
       }
   catch(Excepiton e){
    System.out.println(e); 
   }
  }
}

//FileReader和BufferedReader
class Test{
 public static void main(String args[]){
  FileReader fileReader = null;
  BufferedReader bufferedReader = null;
try{
  fileReader = new FileReader("e:/read.txt");
  bufferedReader = new BufferedReader(fileReader);
  String line = null;
   while(true){
   line = bufferedReader.readLine();
   if(line == null){ 
     break;
   }
   System.out.println(line);
  }
  }catch(Exception e){
  System.out.println(e); 
 }
  finally{
   try{
     bufferedReader.close(); 
     fileReader.close();
    }
    catch(Exception e){
     System.out.println(e);
    }
   }
  }
}

public class Test{
 public static void main(String[] args) throws Exception{
  //字节流
 FileInputStream in = new FileInputStream("c:/read.txt");
 FileOutStream out = new FileOutputStream("c:/write.txt");
 byte[] buffer = new byte[1024];
  int len;
  while( (len = in.read(buffer)) != -1){
  out.write(buffer,0,len);
  }
  in.close();
  out.close();
  //字符流
  BufferedReader bf = new BufferedReader(new FileReader("c:/read.txt");
  BufferedWriter bw = new BufferedWriter(new FileWriter("c:/write.txt");
 String str;
 while( (str=bf.readLine()) != null ){
  bw.write(str);
  bw.newLine();
 }
 bf.close();
 bw.close();
  }
}

字节流: InputStream字节输入流,OutputStream字节输出流
字符流 : Reader字符输入流 ,Writer字符输出流
数据流: DataInputStream 数据输入流 ,DataOutputStream 数据输出流

文件读写

目的
1 掌握文件读写的几种方法
2 FileOutputStream和FileInputStream类的使用。
3 基本数据类型之间的转换

实现文件读取后转换为大写后写入到目标文件中，其中src是指源文件，des是目标文件目录。

public class FileDemo {

    //创建一个文件夹
    public static void createFolder(String path){
        File folder=new File(path);
        if(folder.exists()){
            System.out.println("文件夹已存在！");
        }else{
            //不存在时去创建
            folder.mkdir();
        }
    }
    //创建一个文件
    public static void createFile(String path,String filename){
        File file=new File(path,filename);
        //文件判断是否已存在
        if(file.exists()){
            System.out.println("文件已存在！");
            System.out.println(file.length());
        }else{
            try{
                file.createNewFile();
            }catch(IOException e){
                System.out.println("文件创建失败！");
            }
        }
    }
    //写文件
    public static void write(String path,String filename){
        try{
            String str="0123456789/nac";
            String Upstr = str.toUpperCase();//
            byte b[]=Upstr.getBytes();//
            FileOutputStream fos=new FileOutputStream(new File(path,filename));
            fos.write(b);
            fos.close();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            System.out.println("写文件失败");
        }
    }
    //读文件
    public static void read(String path,String filename){
        try{
            int length=0;
            String str="";
        
            byte buffer[]=new byte[10];
            FileInputStream fis=new FileInputStream(new File(path,filename));
            
            while((length=fis.read(buffer, 0, buffer.length)) !=-1){
                str+=new String (buffer, 0, length);
            }
            System.out.println(str);//
            fis.close();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            e.printStackTrace();
        }
    }
//
    public static void FileReaderCopy(String src,String des){
        try{
        FileReader fr=new FileReader(src);
        FileWriter fw=new FileWriter(des);
        char c[]=new char[1024];
        int len=0;
        
        while((len=fr.read(c, 0, c.length)) != -1){
            fw.write(c, 0, c.length);
        }
        fw.close();
        fr.close();
    } catch(FileNotFoundException e){
        System.out.println("文件不存在");
    }catch(IOException e){
        System.out.println("读写失败");
    }
    }
    //
    public static void BufferedReaderCopy(String src,String des){
        try{
            BufferedReader br=new BufferedReader(new FileReader(src));
            BufferedWriter bw=new BufferedWriter(new FileWriter(des));
            String str="";
            while((str=br.readLine()) != null){
                String Upstr = str.toUpperCase();//加入大写的变换
                bw.write(Upstr);//
                bw.newLine();
            }
            bw.close();
            br.close();
        } catch(FileNotFoundException e){
            System.out.println("文件存在");
        }catch(IOException e){
            System.out.println("读写失败");
        }
        }
    //复制
    public static void copy(String src,String des){
        try{
            FileInputStream fis=new FileInputStream(src);
            FileOutputStream fos=new FileOutputStream(des);
            int c;
            while((c=fis.read()) != -1){
                fos.write(c);
            }
            fos.close();
            fis.close();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            System.out.println("读写失败");
        }
    }
    //复制文件
    public static void copy1(String src,String des){
        try{
            FileInputStream fis=new FileInputStream(src);
            FileOutputStream fos=new FileOutputStream(des);
            int c;
            byte buff[]=new byte[1024];
            while((c=fis.read(buff,0,buff.length)) != -1){
                fos.write(buff,0,c);
            }
            fos.close();
            fis.close();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            System.out.println("读写失败");
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        FileDemo.createFolder("c:/test");
        FileDemo.createFile("c:/test", "1.txt");
        FileDemo.write("c:/test", "1.txt");
        FileDemo.read("c:/test", "1.txt");
        FileDemo.read("c:/test", "FileDemo.java");
        FileDemo.BufferedReaderCopy("c:/test/FileDemo.java", "c:/test/FileDemo2.java");
        FileDemo.copy1("c:/test/1.mp3", "c:/test/2.mp3");
    }

}

读文件

//读文件
public static void read(String path,String filename){
 try{
  int length = 0;
  String str = "";
  byte buffer[]=new byte[10];
  FileInputStream fis=new FileInputStream(new File(path,filename));
  
  while((length=fis.read(buffer,0,buffer.length))!=-1){
     str+=new String(buffer,0,length);
  }
  System.out.println(str);
  fis.close();
 }catch(FileNotFoundException e){
   System.out.println("文件不存在");
 }catch(IOException e){
  e.printStackTrace();
 }
}

文件的创建

public class FileDemo{
 public static void createFolder(String path){
  File folder = new File(path);
  if(folder.exists()){
   System.out.println("文件已存在!");
  }else{
    folder.mkdir();
 }
}

 public static void createFile(String path,String filename){
  File file = new File(path,filename);
  if(file.exists()){
   System.out.println("文件已存在!");
   System.out.println(file.length());
  }else{
   try{
    file.createNewFile();
  }catch(IOException e){
   System.out.println("文件创建失败");
  }
  }
}

public static void main(String[] args){
  FileDemo.createFolder("c:/test");
  FileDemo.createFile("c:/test","1.txt");
}
}

写文件

public static void write(String path,String filename){
 try{
  String str = "234455";
   byte b[] = str.getBytes();
   FileOutputStream fos =  new FileOutputStream(new File(path,filename));
  fos.write(b);
 }catch(FileNotFoundException e){
   System.out.println("文件不存在");
  }catch(IOException e){
   System.out.println("写文件失败");
  }
}

文件的读写

重点：

文件类主要功能：创建，读属性，写属性，删除等

文件读写操作

File类
File类的对象

用来获取文件本身的信息，如文件所在目录、文件长度、文件读写权限等，不涉及文件的读写操作。

构造函数

File(String filename)
File(String directoryPath,String filename)
File(File f,String filename)

获取文件的属性

String getName()
boolean canRead()
boolean canWrite()
long length()
boolean isFile()等

目录操作

boolean mkdir()：创建目录。
String[] list()：以字符串的形式返回目录下所有文件。
File[] listFiles()：以File对象形式返回目录下所有文件。

文件操作

boolean createNewFile()：创建一个新的文件。
boolean delete()：删除一个文件

流的概念

Java输入输出功能是借助输入输出流类来实现的。

java.io包中包含大量用来完成输入输出流的类。

Java中流的分类：

流的运动方向，可分为输入流和输出流两种。

流的数据类型，可以分为字节流和字符流。

输入流类都是抽象类InputStream（字节输入流）或抽象类Reader类（字符输入流）的子类。

输出流类都是抽象类OutputStream（字节输出流）或抽象类Writer类（字符输出流）的子类。

输入流

输入流用于读取数据，用户可以从输入流中读取数据，但不能写入数据。

输入流读取数据过程如下：

（1）打开一个流。
如：FileInputStream inputFile=new FileInputStream("数据源");
（2）从信息源读取信息。
如：inputFile.read();
（3）关闭流。
如：inputFile.close();

输出流

输出流用于写入数据。只能写，不能读。

写数据到输出流过程如下：

（1）打开一个流。
如：FileOutputStream outFile=new FileOutputStream("数据源");
（2）写入信息到目的地。
如：outFile.write(inputFile.read()):
（3）关闭流。如：
如：outFile.close();

IO

  1. I/O操作的目标
  2. IO的分类方法
  3. 读取文件和写入文件的方法

I/O操作的目标

目标是从数据源中读取数据，将数据写入到数据目的地中。

从一个地方输入到java程序中输出到另外一个地方。

文件与数据流

写入和读出数据文件，在Java的输入/输出操作采用数据流的形式，数据流的两种形式为16位字符或8位字节

数据流的操作对象：

数据文件的读写
线程间的数据传输
网络间的数据传播

读/写步骤：
导入输入/输出包，导入java.io.*包
创建文件对象

FileReader/FileWriter类用于文本文件的读写操作
DataInputStream（用于文件读出）和DataOutputStream（用于文件写入）类文件的读写
FileInputStream（用于文件读出）和FileOutputStream对象（用于文件写入）

关闭文件

close函数关闭文件

File对象的特性

创建文件

boolean createNewFile();

创建子目录

boolean mkdir();
boolean mkdirs();

重命名/移动文件

boolean renameTo(File dest);

删除文件

boolean delete();

检查文件是否存在

boolean exists();

检查是否为文件

boolean isFile();

检查是否为文件夹

boolean isDirectory();

查询文件长度

long length();

往后余生，唯独有你
简书作者：达叔小生
90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通
简书博客： https://www.jianshu.com/u/c785ece603d1

结语

  • 下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
  • 小礼物走一走 or 点赞

相关文章

网友评论

    本文标题：第39节：Java当中的IO

    本文链接：https://www.haomeiwen.com/subject/idhtgftx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    程序猿开发笔记

    Java 杂谈

    程序员

    程序员

    编程语言

    手机开发

    Java开发工程师V

    达叔的朋友圈们

    关于我们|服务条款|联系我们|第39节：Java当中的IO|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！