0
点赞
收藏
分享

微信扫一扫

java笔记Day11

东方小不点 2022-02-12 阅读 38
java开发语言后端

I/O（输入/输出）

输入/输出流

  • 输入流

    输入流用来读取数据，抽象类有两种，分别是InputStream字节输入流和Reader字符输入流

    • InputStream类

      类中所有方法遇到错误时都会引发IOException异常，该类的常用方法及说明如下：

      方法返回值说明
      read()int从输入流中读取数据的下一个字节。返回0-255范围内的int字节值。如果因为已经到达末尾而没有可用的字节，则返回-1
      read(byte[] b)int从输入流中读入一定长度的字节，并以整数的形式返回字节数。
      mark(int readlimit)void在输入流的当前位置放置一个标记，readlimit参数告知此输入流在标记位置失效之前允许读取的字节数
      reset()void将输入指针返回到当前所作标记处
      skip(long n)long跳过输入流上的n个字节并返回实际跳过的字节数
      markSupported()boolean如果当前流支持mark()/reset()操作就返回True
      close()void关闭此输入流并释放与该流关联的所有系统资源

    • Reader类

      Java中的字符时Unicode编码，双字节的，而InputStream类时用来处理单字节的，并不适合处理字符。Java提供Reader类专门处理字符。

      Reader类中的方法与InputStream类的方法相似，read()方法的参数为char类型数组。还提供了一个额外的ready()方法，用来判断是否准备读取流，其返回值为boolean类型。

  • 输出流

    • OutputStream类

      常用方法：

      方法说明
      write(int b)将指定的字节写入此输出流
      write(byte[] b)将b个字节从指定的byte数组写入此输出流
      write(byte[] b,int off,int len)将指定byte数组中从偏移量off开始的len个字节写入此输出流
      flush()彻底完成输出并清空缓存区
      close()关闭输出流

    • Writer类

      常用方法：

      方法说明
      append(char c)将指定字符添加到此writer
      append(charSequence csq)将指定字符序列添加到此writer
      append(charSequence csq,int start,int end)将指定字符序列的子序列添加到此writer
      close()关闭此流，但要先刷新它
      flush()刷新该流的缓冲
      write(char[] cbuf)写入字符数组
      write(char[] cbuf,int off,int len)写入字符数组的一部分
      write(int c)写入单个字符
      write(String str)写入字符串
      write(String str,int off,int len)写入字符串的某一部分

File类

  • 创建文件对象

    1.File(String pathname) File file = new File("D:/1.txt");

    2.File(String parent,String child) File file = new File("D:/doc/","1.txt");

    3.File(File f,String child) File folder = new File("D:/doc/"); File file = new File(folder,"1.txt");

  • 文件操作

    File类中操作文件常用方法

    import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
创建并获取文件的基本信息
 */
public class FileTest {
    public static void main(String[] args) {
        File file = new File("test.txt");//创建文件对象
        if (!file.exists()){//文件不存在，程序第一次运行执行的语句块
            System.out.println("未在指定路径下找到文件，正在创建.....");
            try{
                file.createNewFile();
            }catch (IOException e){
                e.printStackTrace();
            }
            System.out.println("文件创建成功！");
        }else{//文件存在
            System.out.println("找到文件名为“test”的文本文件！");
            if (file.isFile() && file.canRead()){
                System.out.println("文件可读！正在读取文件信息....");
                String fileName = file.getName();//获取文件名
                String filePath = file.getAbsolutePath();//获取文件的绝对路径
                boolean hidden = file.isHidden();//获得该文件是否被隐藏
                long len = file.length();//获取文件中的字节数
                long tempTime = file.lastModified();//获取文件最后的修改时间
                //创建SimpleDateFormat对象，指定日期格式
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
                Date date = new Date(tempTime);//使用文件最后修改时间创建Date对象
                String time = sdf.format(date);//格式化文件最后的修改时间
                System.out.println("文件名：" + fileName);
                System.out.println("文件的绝对路径"+ filePath);
                System.out.println("文件是否被隐藏：" + hidden);
                System.out.println("文件的总字节数为：" + len);
                System.out.println("文件的最后修改日期为： " + time);
                file.delete();//查完该文件信息后，删除文件
                System.out.println("这个文件的使命结束了！已经被删除了。");
            }else{//文件不可读
                System.out.println("文件不可读！");
            }
        }
    }
}

  • 文件夹操作

    常用方法：

    方法返回值说明
    isDirectory()boolean判断是不是文件夹
    list()String[]返回字符串数组，这些字符串指定此抽象路径名表示的目录中文件和目录
    list(FilenameFilter filter)String[]返回字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录
    listFiles()File[]返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件
    listFiles(FileFilter filter)File[]返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录
    listFiles(FilenameFilter filter)File[]返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录
    mkdir()boolean创建此抽象路径名指定的目录
    mkdirs()boolean创建此抽象路径名指定的目录，包括所有必需但不存在的父目录
    import java.io.File;

/*
创建文件夹并在该文件夹下创建10个子文件夹
 */
public class FolderTest {
    public static void main(String[] args) {
        String path = "D:\\Test";//声明文件夹Test所在的目录
        for (int i = 1; i <= 10 ; i++) {
            File folder = new File(path + "\\" + i);//根据新的目录创建File对象
            if (!folder.exists()){//文件夹不存在
                folder.mkdirs();//创建新的文件夹（包括不存在的父文件夹）
            }
        }
        System.out.println("文件夹创建成功，请打开D盘查看！\n\nD盘文件及文件夹列表如下：");
        File file = new File("D:\\");//根据路径名创建File对象
        File[] files = file.listFiles();//获得D盘的所有文件和文件夹
        for(File folder : files){//遍历files数组
            if (folder.isFile()){//判断是否为文件
                System.out.println(folder.getName() + " 文件");//输出D盘下所有文件的名称
            }else if(folder.isDirectory()){//判断是否为文件夹
                System.out.println(folder.getName() + " 文件夹");//输出D盘下所有文件夹的名称
            }
        }
    }
}

文件输入/输出流

  • FileInputStream类与FileOutputStream类

    读取内容用FileInputStream类,写入内容用FileOutputStream类

    FileInputStream常用构造方法：

    FileInputStream(String name):使用给定的文件名name创建一个对象

    FileInputStream(File file):使用File对象创建对象，该方法允许在把文件连接输入流之前对文件做进一步分析。

    FileOutputStream常用构造方法：

    FileOutputStream(File file):创建一个向指定File对象表示的文件中写入数据的文件输出流。

    FileOutputStream(File file,boolean append):创建一个向指定File对象表示的文件中写入数据的文件输出流，如果第二个参数为true，则将字节写入文件末尾处。

    FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的文件输出流。

    FileOutputStream(String name,boolean append):创建一个向具有指定名称的文件中写入数据的文件输出流。如果第二个参数为true，则将字节写入文件末尾处。

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

/*
以字节为单位保存、读取名人名言
 */
public class FileStreamTest {
    public static void main(String[] args) {
        //创建文件对象
        File file = new File("word.txt");
        try {
            //创建FileOutputStream对象，用来向文件写入数据
            FileOutputStream out = new FileOutputStream(file);
            //定义字符串，用来存储要写入文件的内容
            String content = "你见过洛杉矶四点的样子吗？";
            byte buy[]= content.getBytes();//创建byte型数组，将要写入文件的内容转换为字节数组
            out.write(buy);//将数组中的信息写入到文件中
            out.close();//关闭流
        }catch (IOException e){
            e.printStackTrace();
        }
        try{
            //创建FileInputStream对象，用来读取文件内容
            FileInputStream in = new FileInputStream(file);
            byte byt[] = new byte[1024];//用来存储读取到的内容
            int len = in.read(byt);//从文件中读取内容并存储到字节数组中
            System.out.println("文件中的信息是：" + new String(byt,0,len));
            in.close();//关闭流
            file.delete();//删除文件
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

  • FileReader类与FileWriter类

    FileReader类和FileWriter类分别对应FileInputStream类与FileOutputStream类。

    /*
向文件写入并读取控制台输入的内容
 */
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.InputMismatchException;
import java.util.Scanner;

public class ReaderAndWriter {
    public static void main(String[] args) {
        while (true){//设置无线循环。实现控制台的多次输入
            try{
                //在当前目录下创建名为”word.txt“的文本文件
                File file = new File("word.txt");
                if (!file.exists()){//文件不存在
                    file.createNewFile();
                }
                System.out.println("请输入要执行的操作序号：（0.结束程序；1.写入文件；2.读取文件）");
                Scanner sc = new Scanner(System.in);
                int choice = sc.nextInt();
                boolean flag = false;//设置flag控制循环
                switch (choice){
                    case 0:
                        System.out.println("退出成功！");
                        flag = true;
                        break;
                    case 1:
                        System.out.print("请输入要写入文件的内容：");
                        String tempStr = sc.next();//获取控制台写入的内容
                        FileWriter fw = null;//声明字符输出流
                        try{
                            //创建可扩展的字符输出流，向文件中写入新数据时不覆盖已存在的数据
                            fw = new FileWriter(file,true);
                            //把控制台的文本写入到文件中
                            fw.write(tempStr + "\r\n");
                        }catch (IOException e){
                            e.printStackTrace();
                        }finally {
                            fw.close();//关闭流
                        }
                        System.out.println("上述内容已写到文本文件中！");
                        break;
                    case 2:
                        FileReader fr = null;//声明字符输入流
                        //"word.txt"中字符数为0时，控制台输出“文本中的字符数为0！！！”
                        if (file.length() == 0){
                            System.out.println("文本中的字符数为0！！！");
                        }else{
                            try{
                                //创建用来读取“word.txt”中的字符输入流
                                fr = new FileReader(file);
                                //创建容纳1024个字符的数组，用来存储读取的字符数的缓冲区
                                char[] cbuf = new char[1024];
                                int hasread = -1;//初始化已读的字符数
                                //循环读取“word.txt”中的数据
                                while ((hasread = fr.read(cbuf)) != -1){
                                    System.out.println("文件“word.txt”中的内容：\n" + new String(cbuf,0,hasread));
                                }
                            }catch (IOException e){
                                e.printStackTrace();
                            }finally {
                                fr.close();//关闭字符输入流
                            }
                        }
                        break;
                    default:
                        System.out.println("请输入符合要求的有效数字！");
                        break;
                }
                if (flag){//结束循环
                    break;
                }
            }catch (InputMismatchException imexc){
                imexc.printStackTrace();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

带缓冲的输入/输出流

缓冲是I/O的一种性能优化。缓冲流为了I/O流增加了内存缓冲区。

  • BufferedInputStream类与BufferedOutputStream类

    BufferedInputStream(InputStream in):创建一个带有32个字节的缓冲输入流。

    BufferedInputStream(InputStream in,int size):按指定大小来创建缓冲输入流。

    BufferedOutputStream(OutputStream out):创建一个有32个字节的缓冲输出流

    BufferedOutputStream(OutputStream out,int size):以指定大小来创建缓冲输出流

    import java.io.*;

/*
以字节为单位进行输入/输出
 */
public class BufferedStreamTest {
    public static void main(String[] args) {
        //定义字符串数组
        String content[] = {"你不喜欢我，", "我一点都不介意。", "因为我活下来，", "不是为了取悦你！"};
        //创建文件对象
        File file = new File("word.txt");
        //创建FileOutputStream对象
        FileOutputStream fos = null;
        //创建BufferedOutputStream对象
        BufferedOutputStream bos = null;
        //创建FileInputStream对象
        FileInputStream fis = null;
        //创建BufferedInputStream对象
        BufferedInputStream bis = null;
        try {
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            byte[] bContent = new byte[1024];//创建可以容纳1024个字节数的缓冲区
            for (int i = 0; i < content.length; i++) {
                bContent = content[i].getBytes();//将遍历到的数组内容转换为字节数组
                bos.write(bContent);//将字节数组内容写入到文件
            }
            System.out.println("写入成功！\n");
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                bos.close();//关闭流
                fos.close();//关闭流
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        try{
            fis = new FileInputStream(file);
            bis = new BufferedInputStream(fis);
            byte bContent[] = new byte[1024];//创建byte数组，用来存储读取到的内容
            int len = bis.read(bContent);//从文件中读取信息，并存入字节数组中
            System.out.println("文件中的信息是：" + new String(bContent,0,len));
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                bis.close();
                fis.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

  • BufferedReader类与BufferedWriter类

    BufferedReader类的常用方法：

    方法返回值说明
    read()int读取单个字符
    readLine()String读取一个文本行，并将其返回为字符串。若无数据可读，则返回null

    BufferedWriter类的常用方法：

    方法返回值说明
    write(String s,int off, int len)void写入字符串的一部分
    flush()void刷新该流的缓冲
    newLine()void写入一个行分符
    import java.io.*;

/*
以行为单位进行输入/输出
 */
public class BufferedTest {
    public static void main(String[] args) {
        //定义字符串数组
        String content[] = {"你不喜欢我，", "我一点都不介意。", "因为我活下来，", "不是为了取悦你！"};
        File file = new File("word.txt");
        try{
            FileWriter fw = new FileWriter(file);//创建FileWriter类对象
            BufferedWriter br = new BufferedWriter(fw);//创建BufferedReader对象
            for (int i = 0; i < content.length; i++) {
                br.write(content[i]);//将字符串数组中元素写入到磁盘文件中
                br.newLine();//将数组中的单个元素以单行的形式写入文件
            }
            br.close();
            fw.close();
        }catch (IOException e){
            e.printStackTrace();
        }
        try{
            FileReader fr = new FileReader(file);
            BufferedReader br2 = new BufferedReader(fr);
            String s = null;
            int i = 0;
            //如果文本行数不为null，则进入循环
            while ((s= br2.readLine())!=null){
                i++;
                System.out.println("第" + i + "行数据："+s);
            }
            br2.close();
            fr.close();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}
举报

相关推荐

Java学习-Day11

java学习

java算法题Day11

算法

Java(day11)：顺序结构

顺序结构JavaSystem后端开发yyds干货盘点

总结-day11

python

日撸 Java 三百行学习笔记day11

java学习数据结构

Java经典笔试题—day11

网络前端服务器

HTML入门DAY11

htmlcsscss3

Linux学习-DAY11

linux逻辑卷硬盘分区运维

JavaEE Day11 BootStrap

bootstraphtml栅格Java编程语言

数组基础（day11）

数组数组名字符串C/C++编程语言
0 条评论