IO基础小结

于 2019-12-24 11:58:03 发布
阅读量107 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43688527/article/details/103238775
版权

File类

 * java.io.File;
 * 文件和目录路径名的抽象表现形式
 * file:文件
 * directory:文件夹/目录
 * path:路径
  • 绝对路径：完整的路径 以盘符开始的
  • 相对路径：简化的路径 指的是相对于当前项目的根目录 可以省略项目的根目录
  • 注意：1.路径不区分大小写
    2.路径中的文件名称分隔符windows使用\
File类的构造方法
 * [1]  File(String pathname)
 * 路径可以以文件结尾，也可以以文件夹结尾
 * 路径可以是绝对路经，也可以是相对路径
 * 路径可以是存在，也可以是不存在
 * 创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况
 * [2]  File(String parent ,String child)父路径和子路径可以单独书写，都可以变化
 *[3]File(File parent ,String child)父类型可以使用File的方法对路径进行一系列操作，再使用路径创建对象

public static void main(String[] args) {
        System.out.println(File.pathSeparator);//路径分隔符
        //windows ; Linux :
        System.out.println(File.separator);//文件名称分隔符
        //windows \  Linus   /
        meth1();
        meth2("c:\\",".txt");
        meth3();
    }

    private static void meth3() {
        File parent=new File("c:\\");
        File c=new File(parent,"hello.java");
        System.out.println(c);
    }

    private static void meth2(String s, String s1) {
        File b=new File(s,s1);
        System.out.println(b);
    }

    private static void meth1() {
        File a=new File("C:\\a");
        System.out.println(a);//覆写了toString方法

    }
File类常用方法
获取
 public static void main(String[] args) {
        show1();//路径
        show2();//名称
    }

    /**
     * public long length  返回由此File表示的文件长度
     * 获取的是构造方法指定的文件的大小，以字节为单位
     * 注意：1.文件夹没有大小的概念，不能获取文件夹的大小
     * 2.如果构造方法中给定的路径不存在，则length()返回0
     * public String getName
     */
    private static void show3() {

    }

    private static void show2() {
        File f1=new File("C:\\HG");
        File f2=new File("txt");
        //获取路径的结尾部分
        System.out.println(f1.getName());
    }

    private static void show1() {
        //返回的都是绝对路径
        File f1=new File("C:\\HG");
        System.out.println(f1.getAbsolutePath());
        File f2=new File("txt");
        System.out.println(f2.getAbsolutePath());
        //绝对的返回绝对路径  相对的返回相对路径
        System.out.println(f1.getPath());
        System.out.println(f2.getPath());
        //toString方法调用的就是getPath()
        System.out.println(f1);
        System.out.println(f1.toString());

    }

输入输出流

  • 输 入就是将数据从各种输入设备（包括文件、键盘等）中读取到内存中。
  • 输出则正好相反，是将数据写入到各种输出设备（比如文件、显示器、磁盘等）。例如键盘就是一个标准的输入设备，而显示器就是一个标准的输出设备，但是文件既可以作为输入设备，又可以作为输出设备。
    在这里插入图片描述
字节流（8位比特位）
  • 字节流：数据流中最小的数据单元是字节 。 InputStream，OutputStream。
  • FileInputStream 从文件系统中的某个文件中获得输入字节。
  • FileInputStream 用于读取诸如图像数据之类的原始字节流。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
FileInputStream fin=new FileInputStream("E:\\bit\\bit.jpg");
FileOutputStream fout=new FileOutputStream("E:\\bit\\bit\\BitCopy.jpg");
int len=0;
byte[] buff=new byte[1024];
while((len=fin.read(buff))!=-1) {
fout.write(buff, 0, len);
}
fin.close();
fout.close();
}
}
字节缓冲流
  • 为什么要有缓冲流？
    当我们用read()读取文件时，每读一个字节，访问一次硬盘，效率很低。文件过时操作起来也不是很方便。因此我们需要用到buffer缓存流，当创建buffer对象时，会创建一个缓冲区数组。当我们读一个文件时，先从硬盘中读到缓冲区，然后直接从缓冲区输出即可，效率会更高。
import java.io.*;
public class TestBufferStreamCopy {
  public static void main(String[] args) throws IOException {
    File file=new File("bit.txt");
    if(!file.isFile()){  return;  }
    BufferedInputStream bfis=new BufferedInputStream(new
FileInputStream(file));
    BufferedOutputStream  bfos=new BufferedOutputStream(new
FileOutputStream("src\\"+file.getName()));//copy到src目录下
    byte bytes[]=new byte[1024];
    int temp=0;    //边读边写
    while ((temp=bfis.read(bytes))!=-1){//读
      bfos.write(bytes,0,temp);  //写
   }
    bfos.flush();
    bfos.close();
    bfis.close();
    System.out.println("copy成功！");
 }
 }
字符流（16位比特位）
  • 字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。Reader、Writer。
  • FileWriter 是用于写入字符流。 要编写原始字节流，请考虑使用FileOutputStream.
  • FileReader 是用于读取字符流。 要读取原始字节流，请考虑使用 FileInputStream .
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//创建输入流对象
FileReader fr = new FileReader("E:\\bit\\bitSrc.java");
//创建输出流对象
FileWriter fw = new FileWriter("E:\\bit\\bitCopy.java");
//读写数据
int ch;
while((ch=fr.read())!=-1) {
fw.write(ch);
}
//释放资源
fw.close();
fr.close();
}
字符缓冲流
  • 为了提高字符流读写的效率，引入了缓冲机制，进行字符批量的读写，提高了单个字符读写的效率。
    BufferedReader 用于加快读取字符的速度， BufferedWriter 用于加快写入的速度。BufferedReader 和 BufferedWriter 类各拥有 8192个 字符的缓冲区。当 BufferedReader在 读取文本文件时，会先尽量从文件中读入字符数据并放满缓冲区，而之后若使用read()方法，会先从缓冲区中进行读取。如果缓冲区数据不足，才会再从文件中读取，使用 BufferedWriter 时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。
字节流与字符流比较
  • 字节流操作的基本单元是字节；字符流操作的基本单元为Unicode码元。
  • 字节流在操作的时候本身不会用到缓冲区的，是与文件本身直接操作的；而字符流在操作的时候使用到缓冲区的。
  • 所有文件的存储都是字节(byte)的存储，在磁盘上保留的是字节。
  • 在使用字节流操作中，即使没有关闭资源（close方法），也能输出；而字符流不使用close方法的话，不会输出任何内容。

字符字节转换流

需要用到 OutputStreamWriter 和 InputStreamReader，InputStreamReader 是Reader的子类，将输入的字节流转换成字符流，
OutputStreamWriter是将字符流转换为字节流。

import java.io.*;
import java.net.Socket;
import java.nio.Buffer;
import java.util.Scanner;
import java.util.logging.SocketHandler;

public class Demo {
    /**
     * 1.从哪读
     * 可以从文件读
     * 可以从网络读(tcp)
     * 可以从内存读
     * 可以从标准输入读
     * 2.怎么读
     * @param
     */
    private static InputStream 获取一个输入流() throws IOException {
        InputStream inputstream;
        /*从文件读
        inputstream= new FileInputStream("java.txt");
        */
        Socket socket=new Socket("www.baidu.com",80);
        OutputStream os=socket.getOutputStream();
        Writer writer=new OutputStreamWriter(os,"UTF-8");
        PrintWriter pw=new PrintWriter(writer,false);
        pw.printf("GET/HTTP/1.0\r\n\r\n");
        pw.flush();
        inputstream=socket.getInputStream();

        /*从内存读
        byte[]bytes="我只是内存中的一段空间\r\n第二行\r\n".getBytes("uTF-8");
       inputstream=new  ByteArrayInputStream(bytes);
       */
        /*
        inputstream=System.in;
        */

        return inputstream;
    }
    private static String 从字节流中最终获得的数据(InputStream is) throws IOException {
       /* 直接读字节
        byte[]bytes=new byte[1024];
        int len=is.read(bytes);
        String message=new String(bytes,0,len,"UTF-8");
        return message;
        */

       /*通过字符读
      char[]buffer=new char[10];
      Reader reader=new InputStreamReader(is,"UTF-8");
      int len=reader.read(buffer);
      String message=new String(buffer,0,len);
      return message;
      */

       /*把数据读完
          -1就代表读到最后了
       char[]buffer=new char[10];
       Reader reader=new InputStreamReader(is,"UTF-8");
       StringBuffer sb=new StringBuffer();
       int len;
       while((len=reader.read(buffer))!=-1){
           sb.append(buffer,0,len);
       }
       String message=new String(sb);
       return message;
       */

       /*BufferReader默认4096这么大，每次读4096大小，每次只返回一行内容
       Reader reader=new InputStreamReader(is,"UTF-8");
       BufferedReader br=new BufferedReader(reader);
       String line;
       StringBuilder sb=new StringBuilder();
       while((line=br.readLine())!=null){
           sb.append(line+"\r\n");
       }
       String message=new String(sb);
       return message;
       */
       Scanner scanner=new Scanner(is,"UTF-8");
       return scanner.nextLine();
    }
    private static OutputStream 获取一个输出流() throws IOException {
        OutputStream os=new FileOutputStream("java输出.txt");
        /*
        Socket socket=new Socket("www.baidu.com",80);
        os=socket.getOutputStream();
        */

        //os=new ByteArrayOutputStream();
        return os;

    }
    private static void 输出一段字符(OutputStream os,String message) throws IOException {
        /*byte[]bytes=new byte[1024];
        os.write(bytes);*/

      // Writer writer=new OutputStreamWriter(os,"UTF-8");
      // writer.append(message);
      // writer.flush();
        Writer writer=new OutputStreamWriter(os,"UTF-8");
        PrintWriter pw=new PrintWriter(writer,false);
        pw.printf("%s",message);
        pw.flush();
    }

    public static void main(String[] args) throws IOException {

        /**InputStream is=获取一个输入流();
        String message=从字节流中最终获得的数据(is);
        System.out.println(message);**/
        OutputStream os=获取一个输出流();
        输出一段字符(os,"我是中国人，最喜欢吃好吃的了\r\n");
    }
}
测开小白
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值