个人java学习路线-IO流

最新推荐文章于 2022-11-16 10:07:08 发布
最新推荐文章于 2022-11-16 10:07:08 发布
阅读量122 收藏
点赞数
分类专栏： java基础学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youxizaixian123/article/details/118998624
版权

个人java学习路线-IO流

io流介绍

java IO操作主要是指使用Java进行输出，输入操作，这些操作类都放在Java.io包中。
我们在学习io时掌握了解以下16个类即可:

文件专属:
java.io.FileInputStream
java.io.FileOutputStream
java.io.FileReader
java.io.FileWriter

转换流:(将字节转换成字符流)
java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流专属:
java.io.BuffereReader
java.io.BuffereWriter
java.io.BuffereInputStream
java.io.BuffereOutputStream

数据流专属:
java.io.DataInputStream
java.io.DataOutputStream

标准输出流:
java.io.PrintWriter
java.io.PrintStream

对象专属流:
java.io.ObjectInputStream
java.io.ObjectOutputStream

这个类名也是见名大概就知道意思了。这个没必要都说，很多都是差不多的，挑一些重点说说就行。

File

IO包中唯一与文件本身有关的类，创建文件和删除文件都在这个类中，所以先说说这个类。
1》先了解创建文件/目录

public class FileTest {
    public static void main(String[] args) {
        File file=null;
        file=new File("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\试用.txt");//""中填文件的绝对路径，\\双斜杠是为了转义，/也行
        System.out.println(file.exists());
        if (!file.exists()) {//如果试用.txt不存在，创建该文件
            try {
//                file.mkdir();//创建文件夹
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        File file1=new File("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\a\\b\\c");
        if (!file1.exists()){//如果目录不存在创建目录
            file1.mkdirs();
        }
    }
}

运行后结果：
在这里插入图片描述
2》了解获取文件路径

public class FileTest2 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\试用.txt");
        String parentPath=file.getParent();
        System.out.println(parentPath);
        System.out.println(file.getAbsolutePath());
    }
}

输出结果：
在这里插入图片描述
可以看出两个方法的不同
3》了解File的一些方法

public class FileTest3 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\试用.txt");
        System.out.println(file.isDirectory());	//文件是目录吗
        System.out.println(file.isFile());		//是文件吗(普通文本)
        System.out.println(file.lastModified());//文件最后修改时间（毫秒）
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date(file.lastModified())));	//文件最后修改时间改为标准模式
        System.out.println(file.length());		//文件内字节长度，这个不同类型不一样，单个汉字长3，其他可以自己试。
    }
}

输出结果:
在这里插入图片描述
4》了解扫描目录

public class FileTest4 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt");
        File[] files=file.listFiles();
        for (File f:files) {
            System.out.println(f.getAbsolutePath());
        }
    }
}

输出结果:
在这里插入图片描述
目前了解这些就行

文件专属流

FileInputStream

1》先来看看读取字符

public class FileInputStreamTest {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\fileio.txt");//连接fileio.txt文件
            int readData= fis.read();//往后读一位
            System.out.println(readData);
            System.out.println(fis.read());//继续读
            System.out.println(fis.read());
            System.out.println(fis.read());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();	//关闭流，必须关闭
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出结果：
在这里插入图片描述
可见输出的是ASCII码
2》用循环读完整个txt

public class FileInputStreamTest2 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\fileio.txt");
            int readData=0;
            while((readData= fis.read())!=-1){//read=-1代表没东西读了
                System.out.print(readData+" ");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

读出来的都是ASCII码
3》输出字符串

public class FileInputStreamTest3 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\fileio.txt");
            byte[] bytes=new byte[8];//一次读8byte
            int readCount;
            while ((readCount= fis.read(bytes))!=-1){
                System.out.print(new String(bytes,0,readCount));
            };
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出结果：
在这里插入图片描述
乱码是因为读的不完整，把new byte[8]改大些就行比如new byte[1024]，就不会有错误了。
4》文件.available()方法，直接返回文件大小。

public class FileInputStreamTest4 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\fileio.txt");
            byte[] bytes=new byte[fis.available()];
            int readCount= fis.read(bytes);
            System.out.println(new String(bytes));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

注意：4》不常用，大文件读取没那么大的空间存数组，一般用3》读几m(x10241024)就行

FileOutputStream

public class FileOutputStreamTest {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        try {
        //            fos=new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\fileiooutput.txt",true);这个true代表是再txt原有内容上继续写入，默认是重写。
            fos=new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\fileiooutput.txt");
            String s="学习真开心啊!\n";
            byte[] bytes=s.getBytes();//把s存入字节数组中
            fos.write(bytes);			//写入
            fos.flush();				//刷新，必须步骤
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出结果：
在这里插入图片描述

缓冲流

该流使用需转换。
文件.readLine()可以读一行，同样文件.write()也可以写入一行

public class BufferedReaderTest {
    public static void main(String[] args){
        FileReader reader= null;
        BufferedReader br=null;
        try {
            reader = new FileReader("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\fileio.txt");//节点流
            br=new BufferedReader(reader);//包装流，处理流
             String s=null;
            while ((s=br.readLine())!=null){
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在使用BufferedReader时需要用转换流转换。

br=new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\fileio.txt")));

这个简单了解就行。

数据流

这个容易读出错，所以先写再读，可以当一种密码了，如果不知道写入顺序，很难读出来。
写入：

public class DataOutputStreamTest {
    public static void main(String[] args) {
        DataOutputStream dos=null;
        try {
            dos=new DataOutputStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\试用.txt"));
            int i=10;
            boolean b=true;
            double d=1.2;
            char c='d';
            dos.writeInt(i);
            dos.writeBoolean(b);
            dos.writeDouble(d);
            dos.writeChar(c);
            dos.writeChars("how old are you");
            dos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (dos != null) {
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

txt中保存的直接看时乱码的：
在这里插入图片描述
接下来就是读取了：

public class DataInputStreamTest {
    public static void main(String[] args) {
        DataInputStream dis=null;
        try {
            dis=new DataInputStream(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\试用.txt"));
            System.out.print(dis.readInt());
            System.out.print(dis.readBoolean());
            System.out.print(dis.readDouble());
            System.out.print(dis.readChar());
            System.out.print(dis.readLine());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (dis != null) {
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出结果：
在这里插入图片描述
简单了解就行。

标准输出流

1》
这个可以改我们的老朋友Hello World了，这个操作相关就行System.out,直接看代码：

public class PrintStreamTest {
    public static void main(String[] args) {
        PrintStream ps=System.out;
        ps.println(123);		//这里就相当于System.out.println();了
        ps.println("hello");
        try {
            System.setOut(new PrintStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\试用.txt")));//设置输出口，本该打印到控制台的内容打印到txt文件。
            System.out.println("welcome");
            System.out.println("earth");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出结果：
在这里插入图片描述
还是很有意思的。
2》
我们来尝试往txt里输入时间：
设定一个方法，先将System.out输出口设为txt，再正常打印时间。

public class PrintStreamTest2 {
    public static void log(String s){
        try {
            System.setOut(new PrintStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\试用.txt")));
            System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date())+":"+s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

调用方法：

public class Test2Test {
    public static void main(String[] args) {
        PrintStreamTest2.log("测试时间");
    }
}

查看txt：
在这里插入图片描述
简单了解一下。

对象专属流

1》
和上面都一样拉，不过改成对象了。
学生类:

public class Student implements Serializable {
    private int no;
    private String name;
    public Student() {
    }
    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return no == student.no &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(no, name);
    }
    @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

写入类：

public class ObjectStreamTest {
    public static void main(String[] args) {
        Student stu=new Student(1111,"张三");
        ObjectOutputStream oos=null;
        try {
            oos=new ObjectOutputStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\oos.txt"));
            oos.writeObject(stu);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

查看Txt:
在这里插入图片描述
然后就是读取了：

public class ObjectInputStreamTest {
    public static void main(String[] args) {
        ObjectInputStream ois=null;
        try {
            ois=new ObjectInputStream(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\oos.txt"));
            System.out.println(ois.readObject());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

读取结果：
在这里插入图片描述
2》集合当然也可以，感兴趣自己尝试。

补充IoAndProperties

这个对以后的学习很重要，重要再Properties这个属性文件，往后我们可能经常会写xx.properties文件。先看看txt里内容：
在这里插入图片描述
然后看代码：

public class Test {
    public static void main(String[] args) {
        FileReader reader=null;
        try {
            reader=new FileReader("C:\\Users\\Lenovo\\Desktop\\java\\1javaio控制的txt\\ioAndProperties.txt");
            Properties pro=new Properties();
            pro.load(reader);
            System.out.println(pro.getProperty("username"));
            System.out.println(pro.getProperty("password"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

再看看运行输出：
在这里插入图片描述
是不是有集合那感觉了，这个很有用。

拷贝目录

自己做个复制文件出来，直接给代码，感兴趣自己看：
这个容易出错，即目录是有多层的，需要进入扫描拷贝，容易错位啥的，这个改了挺久，应该没啥大问题，反正是玩玩。

public class 拷贝目录修改 {
    public static void main(String[] args) {
        File srcFile=new File("I:\\yule\\ce修改器");		//需拷贝文件
        File destFile=new File("C:\\Users\\Lenovo\\Desktop");//拷贝地点
        copyDir(srcFile,destFile);
    }
    /**
     * 拷贝文件
     * @param srcFile 拷贝源
     * @param destFile 拷贝目标
     */
    private static void copyDir(File srcFile, File destFile) {
        String srcStr=srcFile.getAbsolutePath();
        String destStr=destFile.getAbsolutePath()+"\\"+srcFile.getName()+"javaio复制";
        copyDirStart(srcFile,srcStr,destStr);
    }

    private static void copyDirStart(File srcFile, String srcStr,String destStr) {
        if (srcFile.isFile()){
            copyFile(srcFile,srcStr,destStr);
            return;
        }
        if (srcFile.isDirectory()){
            File[] files=srcFile.listFiles();
            if((files != null ? files.length : 0) !=0){
                for (File sonFile:files) {
                    if (sonFile.isFile()){
                        copyFile(sonFile,srcStr,destStr);
                    }else {
                        File newFile=new File(sonFile.getAbsolutePath().replace(srcStr,destStr));
                        if (!newFile.exists()){
                            newFile.mkdirs();
                        }
                        copyDirStart(sonFile,srcStr,destStr);
                    }
                }
            }
        }
    }

    private static void copyFile(File srcFile,String srcStr,String destStr) {
        FileInputStream in=null;
        FileOutputStream out=null;
        try {
            in=new FileInputStream(srcFile);
            out=new FileOutputStream(srcFile.getAbsolutePath().replace(srcStr,destStr));
            byte[] bytes=new byte[50*1024*1024];
            int readCount=0;
            while ((readCount=in.read(bytes))!=-1){
                out.write(bytes,0,readCount);
            }
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
初入编程的薯条
关注
专栏目录
Java学习路线-五大步骤让你入门到精通
编程领域的博客
08-28 335
Web后端架构 后端进阶第一步，先把Web架构相关的技术学好吧，因为之前大家都做过Java Web项目，想必对这块内容还是比较熟悉的吧。我们需要了解Web架构演化的历史，了解为什么要做服务器集群，为什么要用缓存，为什么要做拆分，做主从，以及为什么要有分布式。 后一本则是李智慧大佬写的架构科普书籍，用非常简单易懂的语言写出了大型Web项目架构之美，分别着眼于高可用，高性能，高扩展等方面讲解了很多设计结构的原则和方法。这本书应该是Web架构小白最好的入门书籍了。 分布式理论基础 由于下面的内容或
2024最新版Java学习路线图--Java语言进阶重点知识
2401_84046876的博客
04-22 405
1、看视频进行系统学习这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。2、读源码，看实战笔记，学习大神思路“编程语言是程序员的表达的方式，而架构是程序员对世界的认知”。所以，程序员要想快速认知并学习架构，读源码是必不可少的。
Java IO流学习路线纲要（初学者推荐）
Kristabo的博客
03-24 863
1.什么是IO流？ I，即Input；O，即OutPut；翻译过来是输入以及输出。IO流输入输出是数据相对于硬盘与内存间交互而言的。从内存角度看，若从硬盘取数据到内存，则称之为输入，也即为读入（read）；若让内存的数据去到硬盘中，则称之为输出，也即为写入（write）。有个通俗的例子：把一本笔记本当作硬盘，而人的大脑当作内存；我们要想从笔记本获取信息并纳入脑中，往往是要通过看笔记本写了什么，读入大脑后才可以进行相应的信息加工处理，成为知识（就像数据读入内存，方便CPU从内存中取数据运算一样。）
Java基础之IO流学习
SuperGeekNumber的博客
08-08 299
IO流属于一种Java技术，主要用于处理数据传输。通过IO与外界进行数据交互，通信等。 IO流适用于文件，图片，音乐，视频等等的传输任务。 通信的目标也存在多种。例如：文件，数据库，网络地址，硬件设备等等。...
Java IO相关流的学习
weixin_64167856的博客
08-06 121
IO流：用来处理设备之间的数据传输，java.io包下提供了各种“流"类和接口，用以获取不同种类的数据，并通过标准的方法输入或者输出数据。File类代表与平台无关的文件和目录，File 能新建，删除，重命名文件和目录，凡是实现Serializable接口的类都有一个表示序列化版本标书符的静态变量。若某一个类实现了Serializable接口，该类的对象就是可序列化的。但File不能访问文件内容本身，若要访问，需使用输入/输出流。计算机操作系统中的文件和文件夹。...
Java-IO流学习
akxnxbshai的博客
11-16 456
java-IO学习
java学习：IO流
刘松松的博客
10-13 166
1、File的使用 java.io.file类：表示文本或文件夹(目录路径)，与平台无关的一种抽象表示方式。 可以进行新建、删除、重命名等操作，但是不能操作文件内容本身，如果需要访问文件内容则使用输入输出流。 构造器：File(String pathname) @Test public void test() {//创建File对象 --- 可以表示一个不存在的路径或文件 File file = ...
java学习路线1
08-04
【Java学习路线1】是一条全面且最新的Java学习路径，旨在帮助从新手到专业人士的全程进阶。这个路线特别适合那些希望全面学习Java或者迅速准备求职的人，他们可以根据路线中的符号自定义学习路径。 路线特点： 1. *...
Java学习路线.docx
04-29
### Java学习路线详解 #### 一、引言 Java作为一种广泛应用的编程语言，在软件开发、Web应用、移动应用等多个领域都有着不可替代的地位。其特点包括跨平台性、简单易学及安全性高等，使得无论是初学者还是资深...
java学习路线.docx
最新发布
07-24
### Java学习路线详解 #### 一、Java基础 **目标：** 理解Java语言的基本语法，掌握基本的编程技巧。 1. **Java开发环境搭建：** - **JDK（Java Development Kit）安装：** JDK是Java开发的基础工具包，包含了...
Java入门—— IO流
wk3510的博客
04-19 521
1.File对象 1.1 file的介绍 File 类 就是当前系统中 文件或者文件夹的抽象表示 通俗的讲 就是 使用File对象 来操作我们电脑系统中的文件或者文件 学习File类 其实就是学习 如果通过file对象 对系统中的文件/文件夹进行增删改查 1.2 创建File对象 1. 磁盘准备一个目录AAA。以后对文件得操作都放在该目录下 1.3 增加操作 1.4 删除操作 1.5 修改操作 1.6 查询操作 经典题目: 用的方法的递归调用 ...
浅谈Java学习以及学习路线图
11-08 295
关于这篇，应该很早就要更新了，奈何一直拖拖拖（因为自己在跟着做项目），导致到现在才更新，今天就聊一聊关于我，自己接触Java比较早，但真正实际能到开发阶段，还是在疫情期间，因为要准备实习了，看网上这么卷，所以才开始框架的学习，在此之前，学习的态度的：三天打鱼，两天晒网；现在回想之前的大学时光，感觉自己很荒废，自己也走了不少弯路，强烈建议：如果能找到一个大佬带你学习或者给你提供学习路线等，你将会少走很多弯路！不然大部分应该和我一样，学完一个全新的框架之后，总会纠结到底该学哪个，在此件事情上浪费很多时间。
Java中的io流学习（了解四大基类和基本步骤）
weixin_30607029的博客
04-28 879
Java中io流四大基类及io流操作四大基本步骤 io流：（input/output）即输入输出流。面向对象的思想之一是面向接口编程，面向父类编程，也就是多态。所以学好基类（父类）很重要。 分类 按处理数据类型角度，可分为字节流（例如音频视频等）和字符流（针对纯文本）。 按数据流向，可分为输入流和输出流（输入输出是对程序来说的）。 按流的功能，可分为节点流和处理流（没有节点流，处理流发挥不了任何...
Java IO学习
三哥的博客
04-22 2350
一、Java IO 　　Java 的IO包含了java的输入输出，所有的类都在java.io包中。其主要内容就是java的输入输出流，又可以分为字符流和字节流。其中字符流以字符来处理输入输出操作，字节流则以字节为单位来处理输入输出流。接下来将分别介绍几个重要的IO操作类。 二、File类 　　File类是java.io包下与平台无关的文件和目录处理类，对文件和目录可以实现新建，删除，重命
Java之IO学习
qq_60416816的博客
05-29 148
IO 一、IO和流的划分 1.IO 硬盘 ----> 内存 input 即内存中读入硬盘上的数据，叫做 读-read 内存 ----> 硬盘 output 即内存中往硬盘上写数据，叫做 写-write 2.读数据的方式划分 a）字节流 每次读取 1byte b）字符流 每次读取一个字符 适用于普通文本文件 3.字节流与字符流的区别 字节流可以读取任何形式的数据：包括文本、音频、图像、视频等 字符流只能读取纯文本形式的数据，也就是txt格式的数据 4.有哪些是字节流，哪些是字符流？ 以
Java IO流 : 新手入门最全面总结
houjingchuan的博客
09-09 540
Java高级编程之IO流，根据尚硅谷宋红康Java课程总结，适合新手学习，也可作为查阅文档
新手如何学习java的IO（一）
tofuxu的博客
09-07 346
前言，对于java本人是个小白，不过有点其他语言的经验，知道java是面向对象的，也就这么多。刚开始学习java，我也是蒙头啃书，啃完《Java核心编程一卷》的前8章，看着好像都懂，但是合上书回忆自己到底学了些什么，又好像一片空白。ps：我也有过打书上的代码，但是感觉这本书还是实例太少，缺少那种可实际操作的问题吧（仅对于我，勿喷！）。于是，我就去网上查查看看别人是如何学习java的，第一站就是知乎...
JAVA I/O学习
courage_lizy的博客
03-25 723
package IO; import java.io.File; public class IO_study01 { public static void main(String[] args) { //名称分隔符separator String path="D:\\src\\IO\\VCG211294347471.png"; System.out.println(File.separatorChar); ...
Java之IO流简单学习
wenhuabuzhijian的博客
07-11 103
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings(
Java学习路线与面试攻略
"这是一个关于Java学习历程的指南，涵盖了从基础到进阶的多个阶段，适合不同水平的学习者。" 在Java学习的旅程中，无论是初学者还是有一定基础的开发者，都需要一个系统的路径来逐步掌握这门强大的编程语言。本指南...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值