java中的IO整理

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量669 收藏
点赞数
分类专栏： Java 文章标签： java io import string file exception
 

写在前面：本文章基本覆盖了java IO的全部内容，java新IO没有涉及，因为我想和这个分开，以突出那个的重要性，新IO哪一篇文章还没有开始写，估计很快就能和大家见面。照旧，文章 依旧以例子为主，因为讲解内容的java书很多了，我觉的学以致用才是真。代码是写出来的，不是看出来的。

最后欢迎大家提出意见和建议。

【案例1】创建一个新文件

01import java.io.*;
02class hello{
03    public static void main(String[] args) {
04        File f=new File("D:\\hello.txt");
05        try{
06            f.createNewFile();
07        }catch (Exception e) {
08            e.printStackTrace();
09        }
10    }
11}

【运行结果】：

程序运行之后，在d盘下会有一个名字为hello.txt的文件。

【案例2】File类的两个常量

1import java.io.*;
2class hello{
3    public static void main(String[] args) {
4        System.out.println(File.separator);
5        System.out.println(File.pathSeparator);
6    }
7}

【运行结果】：

\

;

此处多说几句：有些同学可能认为，我直接在windows下使用\进行分割不行吗？当然是可以的。但是在linux下就不是\了。所以，要想使得我们的代码跨平台，更加健壮，所以，大家都采用这两个常量吧，其实也多写不了几行。呵呵、

现在我们使用File类中的常量改写上面的代码：

01import java.io.*;
02class hello{
03    public static void main(String[] args) {
04        String fileName="D:"+File.separator+"hello.txt";
05        File f=new File(fileName);
06        try{
07            f.createNewFile();
08        }catch (Exception e) {
09            e.printStackTrace();
10        }
11    }
12}

你看，没有多写多少吧，呵呵。所以建议使用File类中的常量。

 

删除一个文件

01/**
02 * 删除一个文件
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) {
07        String fileName="D:"+File.separator+"hello.txt";
08        File f=new File(fileName);
09        if(f.exists()){
10            f.delete();
11        }else{
12            System.out.println("文件不存在");
13        }
14         
15    }
16}

创建一个文件夹

01/**
02 * 创建一个文件夹
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) {
07        String fileName="D:"+File.separator+"hello";
08        File f=new File(fileName);
09        f.mkdir();
10    }
11}

【运行结果】：

D盘下多了一个hello文件夹

 

列出指定目录的全部文件（包括隐藏文件）：

01/**
02 * 使用list列出指定目录的全部文件
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) {
07        String fileName="D:"+File.separator;
08        File f=new File(fileName);
09        String[] str=f.list();
10        for (int i = ; i < str.length; i++) {
11            System.out.println(str[i]);
12        }
13    }
14}

【运行结果】：

$RECYCLE.BIN

360

360Downloads

360Rec

360SoftMove

Config.Msi

da

Downloads

DriversBackup

eclipse

java web整合开发和项目实战

Lenovo

MSOCache

Program

Program Files

python

RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}

System Volume Information

Tomcat6

var

vod_cache_data

新建文件夹

（你的运行结果应该和这个不一样的，呵呵）

但是使用list返回的是String数组，。而且列出的不是完整路径，如果想列出完整路径的话，需要使用listFiles.他返回的是File的数组

列出指定目录的全部文件（包括隐藏文件）：

01/**
02 * 使用listFiles列出指定目录的全部文件
03 * listFiles输出的是完整路径
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) {
08        String fileName="D:"+File.separator;
09        File f=new File(fileName);
10        File[] str=f.listFiles();
11        for (int i = ; i < str.length; i++) {
12            System.out.println(str[i]);
13        }
14    }
15}

【运行结果】：

D:\$RECYCLE.BIN

D:\360

D:\360Downloads

D:\360Rec

D:\360SoftMove

D:\Config.Msi

D:\da

D:\Downloads

D:\DriversBackup

D:\eclipse

D:\java web整合开发和项目实战

D:\Lenovo

D:\MSOCache

D:\Program

D:\Program Files

D:\python

D:\RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}

D:\System Volume Information

D:\Tomcat6

D:\var

D:\vod_cache_data

D:\新建文件夹

通过比较可以指定，使用listFiles更加方便、

 

判断一个指定的路径是否为目录

01/**
02 * 使用isDirectory判断一个指定的路径是否为目录
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) {
07        String fileName="D:"+File.separator;
08        File f=new File(fileName);
09        if(f.isDirectory()){
10            System.out.println("YES");
11        }else{
12            System.out.println("NO");
13        }
14    }
15}

【运行结果】：YES

 

搜索指定目录的全部内容

01/**
02 * 列出指定目录的全部内容
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) {
07        String fileName="D:"+File.separator;
08        File f=new File(fileName);
09        print(f);
10    }
11    public static void print(File f){
12        if(f!=null){
13            if(f.isDirectory()){
14                File[] fileArray=f.listFiles();
15                if(fileArray!=null){
16                    for (int i = ; i < fileArray.length; i++) {
17                        //递归调用
18                        print(fileArray[i]);
19                    }
20                }
21            }
22            else{
23                System.out.println(f);
24            }
25        }
26    }
27}

【运行结果】：

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\framepages\web4welcome_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\transit_jsp.class

……

 

【使用RandomAccessFile写入文件】

01/**
02 * 使用RandomAccessFile写入文件
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) throws IOException {
07        String fileName="D:"+File.separator+"hello.txt";
08        File f=new File(fileName);
09        RandomAccessFile demo=new RandomAccessFile(f,"rw");
10        demo.writeBytes("asdsad");
11        demo.writeInt(12);
12        demo.writeBoolean(true);
13        demo.writeChar('A');
14        demo.writeFloat(1.21f);
15        demo.writeDouble(12.123);
16        demo.close();  
17    }
18}

如果你此时打开hello。txt查看的话，会发现那是乱码。

 

字节流

【向文件中写入字符串】

01/**
02 * 字节流
03 * 向文件中写入字符串
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        OutputStream out =new FileOutputStream(f);
11        String str="你好";
12        byte[] b=str.getBytes();
13        out.write(b);
14        out.close();
15    }
16}

查看hello.txt会看到“你好”

当然也可以一个字节一个字节的写。

01/**
02 * 字节流
03 * 向文件中一个字节一个字节的写入字符串
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        OutputStream out =new FileOutputStream(f);
11        String str="你好";
12        byte[] b=str.getBytes();
13        for (int i = ; i < b.length; i++) {
14            out.write(b[i]);
15        }
16        out.close();
17    }
18}

结果还是：“你好”

 

向文件中追加新内容：

01/**
02 * 字节流
03 * 向文件中追加新内容：
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        OutputStream out =new FileOutputStream(f,true);
11        String str="Rollen";
12        //String str="\r\nRollen";  可以换行
13        byte[] b=str.getBytes();
14        for (int i = ; i < b.length; i++) {
15            out.write(b[i]);
16        }
17        out.close();
18    }
19}

【运行结果】：

你好Rollen

 

【读取文件内容】

01/**
02 * 字节流
03 * 读文件内容
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        InputStream in=new FileInputStream(f);
11        byte[] b=new byte[1024];
12        in.read(b);
13        in.close();
14        System.out.println(new String(b));
15    }
16}

【运行结果】

你好Rollen

Rollen_

但是这个例子读取出来会有大量的空格，我们可以利用in.read(b);的返回值来设计程序。如下：

01/**
02 * 字节流
03 * 读文件内容
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        InputStream in=new FileInputStream(f);
11        byte[] b=new byte[1024];
12        int len=in.read(b);
13        in.close();
14        System.out.println("读入长度为："+len);
15        System.out.println(new String(b,,len));
16    }
17}

【运行结果】：

读入长度为：18

你好Rollen

Rollen

 

读者观察上面的例子可以看出，我们预先申请了一个指定大小的空间，但是有时候这个空间可能太小，有时候可能太大，我们需要准确的大小，这样节省空间，那么我们可以这样干：

01/**
02 * 字节流
03 * 读文件内容,节省空间
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        InputStream in=new FileInputStream(f);
11        byte[] b=new byte[(int)f.length()];
12        in.read(b);
13        System.out.println("文件长度为："+f.length());
14        in.close();
15        System.out.println(new String(b));
16    }
17}

文件长度为：18

你好Rollen

Rollen

 

将上面的例子改为一个一个读：

01/**
02 * 字节流
03 * 读文件内容,节省空间
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        InputStream in=new FileInputStream(f);
11        byte[] b=new byte[(int)f.length()];
12        for (int i = ; i < b.length; i++) {
13            b[i]=(byte)in.read();
14        }
15        in.close();
16        System.out.println(new String(b));
17    }
18}

输出的结果和上面的一样。

 

细心的读者可能会发现，上面的几个例子都是在知道文件的内容多大，然后才展开的，有时候我们不知道文件有多大，这种情况下，我们需要判断是否独到文件的末尾。

01/**
02 * 字节流
03 *读文件
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        InputStream in=new FileInputStream(f);
11        byte[] b=new byte[1024];
12        int count =;
13        int temp=;
14        while((temp=in.read())!=(-1)){
15            b[count++]=(byte)temp;
16        }
17        in.close();
18        System.out.println(new String(b));
19    }
20}

【运行结果】

你好Rollen

Rollen_

提醒一下，当独到文件末尾的时候会返回-1.正常情况下是不会返回-1的

 

字符流

【向文件中写入数据】

现在我们使用字符流

01/**
02 * 字符流
03 * 写入数据
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        Writer out =new FileWriter(f);
11        String str="hello";
12        out.write(str);
13        out.close();
14    }
15}

当你打开hello。txt的时候，会看到hello

其实这个例子上之前的例子没什么区别，只是你可以直接输入字符串，而不需要你将字符串转化为字节数组。

当你如果想问文件中追加内容的时候，可以使用将上面的声明out的哪一行换为：

Writer out =new FileWriter(f,true);

这样，当你运行程序的时候，会发现文件内容变为：

hellohello如果想在文件中换行的话，需要使用“\r\n”

比如将str变为String str="\r\nhello";

这样文件追加的str的内容就会换行了。

 

从文件中读内容：

01/**
02 * 字符流
03 * 从文件中读出内容
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        char[] ch=new char[100];
11        Reader read=new FileReader(f);
12        int count=read.read(ch);
13        read.close();
14        System.out.println("读入的长度为："+count);
15        System.out.println("内容为"+new String(ch,,count));
16    }
17}

【运行结果】：

读入的长度为：17

内容为hellohello

hello

 

当然最好采用循环读取的方式，因为我们有时候不知道文件到底有多大。

01/**
02 * 字符流
03 * 从文件中读出内容
04 * */
05import java.io.*;
06class hello{
07    public static void main(String[] args) throws IOException {
08        String fileName="D:"+File.separator+"hello.txt";
09        File f=new File(fileName);
10        char[] ch=new char[100];
11        Reader read=new FileReader(f);
12        int temp=;
13        int count=;
14        while((temp=read.read())!=(-1)){
15            ch[count++]=(char)temp;
16        }
17        read.close();
18        System.out.println("内容为"+new String(ch,,count));
19    }
20}

运行结果：

内容为hellohello

hello

 

关于字节流和字符流的区别

实际上字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的，但是字符流在操作的 时候下后是会用到缓冲区的，是通过缓冲区来操作文件的。

读者可以试着将上面的字节流和字符流的程序的最后一行关闭文件的代码注释掉，然后运行程序看看。你就会发现使用字节流的话，文件中已经存在内容，但是使用字符流的时候，文件中还是没有内容的，这个时候就要刷新缓冲区。

使用字节流好还是字符流好呢？

答案是字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

文件的复制

其实ＤＯＳ下就有一个文件复制功能，比如我们想把ｄ盘下面的ｈｅｌｌｏ．ｔｘｔ文件复制到d盘下面的rollen.txt文件中，那么我们就可以使用下面的命令：

copy d:\hello.txt d:\rollen.txt

运行之后你会在d盘中看见hello.txt.，并且两个文件的内容是一样的，（这是屁话）

 

下面我们使用程序来复制文件吧。

基本思路还是从一个文件中读入内容，边读边写入另一个文件，就是这么简单。、

首先编写下面的代码：

01/**
02 * 文件的复制
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) throws IOException {
07        if(args.length!=2){
08            System.out.println("命令行参数输入有误，请检查");
09            System.exit(1);
10        }
11        File file1=new File(args[]);
12        File file2=new File(args[1]);
13         
14        if(!file1.exists()){
15            System.out.println("被复制的文件不存在");
16            System.exit(1);
17        }
18        InputStream input=new FileInputStream(file1);
19        OutputStream output=new FileOutputStream(file2);
20        if((input!=null)&&(output!=null)){
21            int temp=;
22            while((temp=input.read())!=(-1)){
23                output.write(temp);
24            }
25        }
26        input.close();
27        output.close();
28    }
29}

然后在命令行下面

javac hello.java

java hello d:\hello.txt d:\rollen.txt

现在你就会在d盘看到rollen。txt了，

OutputStreramWriter 和InputStreamReader类

整个IO类中除了字节流和字符流还包括字节和字符转换流。

OutputStreramWriter将输出的字符流转化为字节流

InputStreamReader将输入的字节流转换为字符流

但是不管如何操作，最后都是以字节的形式保存在文件中的。

 

将字节输出流转化为字符输出流

01/**
02 * 将字节输出流转化为字符输出流
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) throws IOException {
07        String fileName= "d:"+File.separator+"hello.txt";
08        File file=new File(fileName);
09        Writer out=new OutputStreamWriter(new FileOutputStream(file));
10        out.write("hello");
11        out.close();
12    }
13}

运行结果：文件中内容为：hello

将字节输入流变为字符输入流

01/**
02 * 将字节输入流变为字符输入流
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) throws IOException {
07        String fileName= "d:"+File.separator+"hello.txt";
08        File file=new File(fileName);
09        Reader read=new InputStreamReader(new FileInputStream(file));
10        char[] b=new char[100];
11        int len=read.read(b);
12        System.out.println(new String(b,,len));
13        read.close();
14    }
15}

【运行结果】：hello

前面列举的输出输入都是以文件进行的，现在我们以内容为输出输入目的地，使用内存操作流

ByteArrayInputStream 主要将内容写入内容

ByteArrayOutputStream  主要将内容从内存输出

使用内存操作流将一个大写字母转化为小写字母

01/**
02 * 使用内存操作流将一个大写字母转化为小写字母
03 * */
04import java.io.*;
05class hello{
06    public static void main(String[] args) throws IOException {
07        String str="ROLLENHOLT";
08        ByteArrayInputStream input=new ByteArrayInputStream(str.getBytes());
09        ByteArrayOutputStream output=new ByteArrayOutputStream();
10        int temp=;
11        while((temp=input.read())!=-1){
12            char ch=(char)temp;
13            output.write(Character.toLowerCase(ch));
14        }
15        String outStr=output.toString();
16        input.close();
17        output.close();
18        System.out.println(outStr);
19    }
20}

【运行结果】：

rollenholt

内容操作流一般使用来生成一些临时信息采用的，这样可以避免删除的麻烦。

管道流

管道流主要可以进行两个线程之间的通信。

PipedOutputStream 管道输出流

PipedInputStream 管道输入流

验证管道流
01/**
02 * 验证管道流
03 * */
04import java.io.*;
05 
06/**
07 * 消息发送类
08 * */
09class Send implements Runnable{
10    private PipedOutputStream out=null;
11    public Send() {
12        out=new PipedOutputStream();
13    }
14    public PipedOutputStream getOut(){
15        return this.out;
16    }
17    public void run(){
18        String message="hello , Rollen";
19        try{
20            out.write(message.getBytes());
21        }catch (Exception e) {
22            e.printStackTrace();
23        }try{
24            out.close();
25        }catch (Exception e) {
26            e.printStackTrace();
27        }
28    }
29}
30 
31/**
32 * 接受消息类
33 * */
34class Recive implements Runnable{
35    private PipedInputStream input=null;
36    public Recive(){
37        this.input=new PipedInputStream();
38    }
39    public PipedInputStream getInput(){
40        return this.input;
41    }
42    public void run(){
43        byte[] b=new byte[1000];
44        int len=;
45        try{
46            len=this.input.read(b);
47        }catch (Exception e) {
48            e.printStackTrace();
49        }try{
50            input.close();
51        }catch (Exception e) {
52            e.printStackTrace();
53        }
54        System.out.println("接受的内容为 "+(new String(b,,len)));
55    }
56}
57/**
58 * 测试类
59 * */
60class hello{
61    public static void main(String[] args) throws IOException {
62        Send send=new Send();
63        Recive recive=new Recive();
64        try{
65//管道连接
66            send.getOut().connect(recive.getInput());
67        }catch (Exception e) {
68            e.printStackTrace();
69        }
70        new Thread(send).start();
71        new Thread(recive).start();
72    }
73}

【运行结果】：

接受的内容为 hello , Rollen

打印流

01/**
02 * 使用PrintStream进行输出
03 * */
04import java.io.*;
05 
06class hello {
07    public static void main(String[] args) throws IOException {
08        PrintStream print = new PrintStream(new FileOutputStream(new File("d:"
09                + File.separator + "hello.txt")));
10        print.println(true);
11        print.println("Rollen");
12        print.close();
13    }
14}

【运行结果】：

true

Rollen

当然也可以格式化输出

01/**
02 * 使用PrintStream进行输出
03 * 并进行格式化
04 * */
05import java.io.*;
06class hello {
07    public static void main(String[] args) throws IOException {
08        PrintStream print = new PrintStream(new FileOutputStream(new File("d:"
09                + File.separator + "hello.txt")));
10        String name="Rollen";
11        int age=20;
12        print.printf("姓名：%s. 年龄：%d.",name,age);
13        print.close();
14    }
15}

【运行结果】：

姓名：Rollen. 年龄：20.

 

使用OutputStream向屏幕上输出内容

01/**
02 * 使用OutputStream向屏幕上输出内容
03 * */
04import java.io.*;
05class hello {
06    public static void main(String[] args) throws IOException {
07        OutputStream out=System.out;
08        try{
09            out.write("hello".getBytes());
10        }catch (Exception e) {
11            e.printStackTrace();
12        }
13        try{
14            out.close();
15        }catch (Exception e) {
16            e.printStackTrace();
17        }
18    }
19}

【运行结果】：

hello

 

输入输出重定向

01import java.io.File;
02import java.io.FileNotFoundException;
03import java.io.FileOutputStream;
04import java.io.PrintStream;
05 
06/**
07 * 为System.out.println()重定向输出
08 * */
09public class systemDemo{
10    public static void main(String[] args){
11        // 此刻直接输出到屏幕
12        System.out.println("hello");
13        File file = new File("d:" + File.separator + "hello.txt");
14        try{
15            System.setOut(new PrintStream(new FileOutputStream(file)));
16        }catch(FileNotFoundException e){
17            e.printStackTrace();
18        }
19        System.out.println("这些内容在文件中才能看到哦！");
20    }
21}

【运行结果】：

eclipse的控制台输出的是hello。然后当我们查看d盘下面的hello.txt文件的时候，会在里面看到：这些内容在文件中才能看到哦！

01import java.io.File;
02import java.io.FileNotFoundException;
03import java.io.FileOutputStream;
04import java.io.PrintStream;
05 
06/**
07 * System.err重定向 这个例子也提示我们可以使用这种方法保存错误信息
08 * */
09public class systemErr{
10    public static void main(String[] args){
11        File file = new File("d:" + File.separator + "hello.txt");
12        System.err.println("这些在控制台输出");
13        try{
14            System.setErr(new PrintStream(new FileOutputStream(file)));
15        }catch(FileNotFoundException e){
16            e.printStackTrace();
17        }
18        System.err.println("这些在文件中才能看到哦！");
19    }
20}

【运行结果】：

你会在eclipse的控制台看到红色的输出：“这些在控制台输出”，然后在d盘下面的hello.txt中会看到：这些在文件中才能看到哦！

01import java.io.File;
02import java.io.FileInputStream;
03import java.io.FileNotFoundException;
04import java.io.IOException;
05 
06/**
07 * System.in重定向
08 * */
09public class systemIn{
10    public static void main(String[] args){
11        File file = new File("d:" + File.separator + "hello.txt");
12        if(!file.exists()){
13            return;
14        }else{
15            try{
16                System.setIn(new FileInputStream(file));
17            }catch(FileNotFoundException e){
18                e.printStackTrace();
19            }
20            byte[] bytes = new byte[1024];
21            int len = ;
22            try{
23                len = System.in.read(bytes);
24            }catch(IOException e){
25                e.printStackTrace();
26            }
27            System.out.println("读入的内容为：" + new String(bytes, , len));
28        }
29    }
30}

【运行结果】：

前提是我的d盘下面的hello.txt中的内容是：“这些文件中的内容哦！”，然后运行程序，输出的结果为：读入的内容为：这些文件中的内容哦！

 

BufferedReader的小例子

注意： BufferedReader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流，采用：

BufferedReader buf = new BufferedReader(
                new InputStreamReader(System.in));

下面给一个实例：

01import java.io.BufferedReader;
02import java.io.IOException;
03import java.io.InputStreamReader;
04 
05/**
06 * 使用缓冲区从键盘上读入内容
07 * */
08public class BufferedReaderDemo{
09    public static void main(String[] args){
10        BufferedReader buf = new BufferedReader(
11                new InputStreamReader(System.in));
12        String str = null;
13        System.out.println("请输入内容");
14        try{
15            str = buf.readLine();
16        }catch(IOException e){
17            e.printStackTrace();
18        }
19        System.out.println("你输入的内容是：" + str);
20    }
21}

运行结果：

请输入内容

dasdas

你输入的内容是：dasdas

 

Scanner类

其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧

01import java.util.Scanner;
02 
03/**
04 * Scanner的小例子，从键盘读数据
05 * */
06public class ScannerDemo{
07    public static void main(String[] args){
08        Scanner sca = new Scanner(System.in);
09        // 读一个整数
10        int temp = sca.nextInt();
11        System.out.println(temp);
12        //读取浮点数
13        float flo=sca.nextFloat();
14        System.out.println(flo);
15        //读取字符
16        //...等等的，都是一些太基础的，就不师范了。
17    }
18}

其实Scanner可以接受任何的输入流

下面给一个使用Scanner类从文件中读出内容

01import java.io.File;
02import java.io.FileNotFoundException;
03import java.util.Scanner;
04 
05/**
06 * Scanner的小例子，从文件中读内容
07 * */
08public class ScannerDemo{
09    public static void main(String[] args){
10 
11        File file = new File("d:" + File.separator + "hello.txt");
12        Scanner sca = null;
13        try{
14            sca = new Scanner(file);
15        }catch(FileNotFoundException e){
16            e.printStackTrace();
17        }
18        String str = sca.next();
19        System.out.println("从文件中读取的内容是：" + str);
20    }
21}

【运行结果】：

从文件中读取的内容是：这些文件中的内容哦！

数据操作流DataOutputStream、DataInputStream类

01import java.io.DataOutputStream;
02import java.io.File;
03import java.io.FileOutputStream;
04import java.io.IOException;
05 
06public class DataOutputStreamDemo{
07    public static void main(String[] args) throws IOException{
08        File file = new File("d:" + File.separator + "hello.txt");
09        char[] ch = { 'A', 'B', 'C' };
10        DataOutputStream out = null;
11        out = new DataOutputStream(new FileOutputStream(file));
12        for(char temp : ch){
13            out.writeChar(temp);
14        }
15        out.close();
16    }
17}

A B C

现在我们在上面例子的基础上，使用DataInputStream读出内容

01import java.io.DataInputStream;
02import java.io.File;
03import java.io.FileInputStream;
04import java.io.IOException;
05 
06public class DataOutputStreamDemo{
07    public static void main(String[] args) throws IOException{
08        File file = new File("d:" + File.separator + "hello.txt");
09        DataInputStream input = new DataInputStream(new FileInputStream(file));
10        char[] ch = new char[10];
11        int count = ;
12        char temp;
13        while((temp = input.readChar()) != 'C'){
14            ch[count++] = temp;
15        }
16        System.out.println(ch);
17    }
18}

【运行结果】：

AB

合并流 SequenceInputStream

SequenceInputStream主要用来将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt。下面给出一个实例：

01import java.io.File;
02import java.io.FileInputStream;
03import java.io.FileOutputStream;
04import java.io.IOException;
05import java.io.InputStream;
06import java.io.OutputStream;
07import java.io.SequenceInputStream;
08 
09/**
10 * 将两个文本文件合并为另外一个文本文件
11 * */
12public class SequenceInputStreamDemo{
13    public static void main(String[] args) throws IOException{
14        File file1 = new File("d:" + File.separator + "hello1.txt");
15        File file2 = new File("d:" + File.separator + "hello2.txt");
16        File file3 = new File("d:" + File.separator + "hello.txt");
17        InputStream input1 = new FileInputStream(file1);
18        InputStream input2 = new FileInputStream(file2);
19        OutputStream output = new FileOutputStream(file3);
20        // 合并流
21        SequenceInputStream sis = new SequenceInputStream(input1, input2);
22        int temp = ;
23        while((temp = sis.read()) != -1){
24            output.write(temp);
25        }
26        input1.close();
27        input2.close();
28        output.close();
29        sis.close();
30    }
31}

【运行结果】

结果会在hello.txt文件中包含hello1.txt和hello2.txt文件中的内容。

文件压缩 ZipOutputStream类

先举一个压缩单个文件的例子吧：

01import java.io.File;
02import java.io.FileInputStream;
03import java.io.FileOutputStream;
04import java.io.IOException;
05import java.io.InputStream;
06import java.util.zip.ZipEntry;
07import java.util.zip.ZipOutputStream;
08 
09public class ZipOutputStreamDemo1{
10    public static void main(String[] args) throws IOException{
11        File file = new File("d:" + File.separator + "hello.txt");
12        File zipFile = new File("d:" + File.separator + "hello.zip");
13        InputStream input = new FileInputStream(file);
14        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
15                zipFile));
16        zipOut.putNextEntry(new ZipEntry(file.getName()));
17        // 设置注释
18        zipOut.setComment("hello");
19        int temp = ;
20        while((temp = input.read()) != -1){
21            zipOut.write(temp);
22        }
23        input.close();
24        zipOut.close();
25    }
26}

【运行结果】

运行结果之前，我创建了一个hello.txt的文件，原本大小56个字节，但是压缩之后产生hello.zip之后，居然变成了175个字节，有点搞不懂。

不过结果肯定是正确的，我只是提出我的一个疑问而已。

上面的这个例子测试的是压缩单个文件，下面的们来看看如何压缩多个文件。

01import java.io.File;
02import java.io.FileInputStream;
03import java.io.FileOutputStream;
04import java.io.IOException;
05import java.io.InputStream;
06import java.util.zip.ZipEntry;
07import java.util.zip.ZipOutputStream;
08 
09/**
10 * 一次性压缩多个文件
11 * */
12public class ZipOutputStreamDemo2{
13    public static void main(String[] args) throws IOException{
14        // 要被压缩的文件夹
15        File file = new File("d:" + File.separator + "temp");
16        File zipFile = new File("d:" + File.separator + "zipFile.zip");
17        InputStream input = null;
18        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
19                zipFile));
20        zipOut.setComment("hello");
21        if(file.isDirectory()){
22            File[] files = file.listFiles();
23            for(int i = ; i < files.length; ++i){
24                input = new FileInputStream(files[i]);
25                zipOut.putNextEntry(new ZipEntry(file.getName()
26                        + File.separator + files[i].getName()));
27                int temp = ;
28                while((temp = input.read()) != -1){
29                    zipOut.write(temp);
30                }
31                input.close();
32            }
33        }
34        zipOut.close();
35    }
36}

【运行结果】

先看看要被压缩的文件吧：

接下来看看压缩之后的：

大家自然想到，既然能压缩，自然能解压缩，在谈解压缩之前，我们会用到一个ZipFile类，先给一个这个例子吧。java中的每一个压缩文件都是可以使用ZipFile来进行表示的

01import java.io.File;
02import java.io.IOException;
03import java.util.zip.ZipFile;
04 
05/**
06 * ZipFile演示
07 * */
08public class ZipFileDemo{
09    public static void main(String[] args) throws IOException{
10        File file = new File("d:" + File.separator + "hello.zip");
11        ZipFile zipFile = new ZipFile(file);
12        System.out.println("压缩文件的名称为：" + zipFile.getName());
13    }
14}

【运行结果】：

压缩文件的名称为：d:\hello.zip

 

现在我们呢是时候来看看如何加压缩文件了，和之前一样，先让我们来解压单个压缩文件（也就是压缩文件中只有一个文件的情况），我们采用前面的例子产生的压缩文件hello.zip

01import java.io.File;
02import java.io.FileOutputStream;
03import java.io.IOException;
04import java.io.InputStream;
05import java.io.OutputStream;
06import java.util.zip.ZipEntry;
07import java.util.zip.ZipFile;
08 
09/**
10 * 解压缩文件（压缩文件中只有一个文件的情况）
11 * */
12public class ZipFileDemo2{
13    public static void main(String[] args) throws IOException{
14        File file = new File("d:" + File.separator + "hello.zip");
15        File outFile = new File("d:" + File.separator + "unZipFile.txt");
16        ZipFile zipFile = new ZipFile(file);
17        ZipEntry entry = zipFile.getEntry("hello.txt");
18        InputStream input = zipFile.getInputStream(entry);
19        OutputStream output = new FileOutputStream(outFile);
20        int temp = ;
21        while((temp = input.read()) != -1){
22            output.write(temp);
23        }
24        input.close();
25        output.close();
26    }
27}

【运行结果】：

解压缩之前：

这个压缩文件还是175字节

解压之后产生：

又回到了56字节，表示郁闷。

 

现在让我们来解压一个压缩文件中包含多个文件的情况吧

ZipInputStream类

当我们需要解压缩多个文件的时候，ZipEntry就无法使用了，如果想操作更加复杂的压缩文件，我们就必须使用ZipInputStream类

01import java.io.File;
02import java.io.FileInputStream;
03import java.io.FileOutputStream;
04import java.io.IOException;
05import java.io.InputStream;
06import java.io.OutputStream;
07import java.util.zip.ZipEntry;
08import java.util.zip.ZipFile;
09import java.util.zip.ZipInputStream;
10 
11/**
12 * 解压缩一个压缩文件中包含多个文件的情况
13 * */
14public class ZipFileDemo3{
15    public static void main(String[] args) throws IOException{
16        File file = new File("d:" + File.separator + "zipFile.zip");
17        File outFile = null;
18        ZipFile zipFile = new ZipFile(file);
19        ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));
20        ZipEntry entry = null;
21        InputStream input = null;
22        OutputStream output = null;
23        while((entry = zipInput.getNextEntry()) != null){
24            System.out.println("解压缩" + entry.getName() + "文件");
25            outFile = new File("d:" + File.separator + entry.getName());
26            if(!outFile.getParentFile().exists()){
27                outFile.getParentFile().mkdir();
28            }
29            if(!outFile.exists()){
30                outFile.createNewFile();
31            }
32            input = zipFile.getInputStream(entry);
33            output = new FileOutputStream(outFile);
34            int temp = ;
35            while((temp = input.read()) != -1){
36                output.write(temp);
37            }
38            input.close();
39            output.close();
40        }
41    }
42}

【运行结果】：

被解压的文件：

解压之后再D盘下会出现一个temp文件夹，里面内容：

PushBackInputStream回退流
01import java.io.ByteArrayInputStream;
02import java.io.IOException;
03import java.io.PushbackInputStream;
04 
05/**
06 * 回退流操作
07 * */
08public class PushBackInputStreamDemo{
09    public static void main(String[] args) throws IOException{
10        String str = "hello,rollenholt";
11        PushbackInputStream push = null;
12        ByteArrayInputStream bat = null;
13        bat = new ByteArrayInputStream(str.getBytes());
14        push = new PushbackInputStream(bat);
15        int temp = ;
16        while((temp = push.read()) != -1){
17            if(temp == ','){
18                push.unread(temp);
19                temp = push.read();
20                System.out.print("(回退" + (char) temp + ") ");
21            }else{
22                System.out.print((char) temp);
23            }
24        }
25    }
26}

【运行结果】：

hello(回退,) rollenholt

1/**
2 * 取得本地的默认编码
3 * */
4public class CharSetDemo{
5    public static void main(String[] args){
6        System.out.println("系统默认编码为：" + System.getProperty("file.encoding"));
7    }
8}

【运行结果】：

系统默认编码为：GBK

 

乱码的产生：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
 
/**
 * 乱码的产生
 * */
public class CharSetDemo2{
    public static void main(String[] args) throws IOException{
        File file = new File("d:" + File.separator + "hello.txt");
        OutputStream out = new FileOutputStream(file);
        byte[] bytes = "你好".getBytes("ISO8859-1");
        out.write(bytes);
        out.close();
    }
}

【运行结果】：

??

 

一般情况下产生乱码，都是由于编码不一致的问题。

对象的序列化

对象序列化就是把一个对象变为二进制数据流的一种方法。

一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。

先让我们实现一个具有序列化能力的类吧：

01import java.io.*;
02/**
03 * 实现具有序列化能力的类
04 * */
05public class SerializableDemo implements Serializable{
06    public SerializableDemo(){
07         
08    }
09    public SerializableDemo(String name, int age){
10        this.name=name;
11        this.age=age;
12    }
13    @Override
14    public String toString(){
15        return "姓名："+name+"  年龄："+age;
16    }
17    private String name;
18    private int age;
19}

这个类就具有实现序列化能力，

在继续将序列化之前，先将一下ObjectInputStream和ObjectOutputStream这两个类

先给一个ObjectOutputStream的例子吧：

01import java.io.Serializable;
02import java.io.File;
03import java.io.FileOutputStream;
04import java.io.IOException;
05import java.io.ObjectOutputStream;
06 
07/**
08 * 实现具有序列化能力的类
09 * */
10public class Person implements Serializable{
11    public Person(){
12 
13    }
14 
15    public Person(String name, int age){
16        this.name = name;
17        this.age = age;
18    }
19 
20    @Override
21    public String toString(){
22        return "姓名：" + name + "  年龄：" + age;
23    }
24 
25    private String name;
26    private int age;
27}
28/**
29 * 示范ObjectOutputStream
30 * */
31public class ObjectOutputStreamDemo{
32    public static void main(String[] args) throws IOException{
33        File file = new File("d:" + File.separator + "hello.txt");
34        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
35                file));
36        oos.writeObject(new Person("rollen", 20));
37        oos.close();
38    }
39}

【运行结果】：

当我们查看产生的hello.txt的时候，看到的是乱码，呵呵。因为是二进制文件。

虽然我们不能直接查看里面的内容，但是我们可以使用ObjectＩｎｐｕｔＳｔｒｅａｍ类查看：

01import java.io.File;
02import java.io.FileInputStream;
03import java.io.ObjectInputStream;
04 
05/**
06 * ObjectInputStream示范
07 * */
08public class ObjectInputStreamDemo{
09    public static void main(String[] args) throws Exception{
10        File file = new File("d:" + File.separator + "hello.txt");
11        ObjectInputStream input = new ObjectInputStream(new FileInputStream(
12                file));
13        Object obj = input.readObject();
14        input.close();
15        System.out.println(obj);
16    }
17}

【运行结果】

姓名：rollen  年龄：20

 

到底序列化什么内容呢？

其实只有属性会被序列化。

Externalizable接口

被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。

当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。

现在我们来演示一下序列化和反序列话：

01package IO;
02 
03import java.io.Externalizable;
04import java.io.File;
05import java.io.FileInputStream;
06import java.io.FileOutputStream;
07import java.io.IOException;
08import java.io.ObjectInput;
09import java.io.ObjectInputStream;
10import java.io.ObjectOutput;
11import java.io.ObjectOutputStream;
12 
13/**
14 * 序列化和反序列化的操作
15 * */
16public class ExternalizableDemo{
17    public static void main(String[] args) throws Exception{
18        ser(); // 序列化
19        dser(); // 反序列话
20    }
21 
22    public static void ser() throws Exception{
23        File file = new File("d:" + File.separator + "hello.txt");
24        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
25                file));
26        out.writeObject(new Person("rollen", 20));
27        out.close();
28    }
29 
30    public static void dser() throws Exception{
31        File file = new File("d:" + File.separator + "hello.txt");
32        ObjectInputStream input = new ObjectInputStream(new FileInputStream(
33                file));
34        Object obj = input.readObject();
35        input.close();
36        System.out.println(obj);
37    }
38}
39 
40class Person implements Externalizable{
41    public Person(){
42 
43    }
44 
45    public Person(String name, int age){
46        this.name = name;
47        this.age = age;
48    }
49 
50    @Override
51    public String toString(){
52        return "姓名：" + name + "  年龄：" + age;
53    }
54 
55    // 复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用
56    @Override
57    public void writeExternal(ObjectOutput out) throws IOException{
58        out.writeObject(this.name);
59        out.writeInt(age);
60    }
61 
62    // 复写这个方法，根据需要读取内容 反序列话的时候需要
63    @Override
64    public void readExternal(ObjectInput in) throws IOException,
65            ClassNotFoundException{
66        this.name = (String) in.readObject();
67        this.age = in.readInt();
68    }
69 
70    private String name;
71    private int age;
72}

【运行结果】：

姓名：rollen  年龄：20

本例中，我们将全部的属性都保留了下来，

Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，

当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：

下面举一个例子：

01package IO;
02 
03import java.io.File;
04import java.io.FileInputStream;
05import java.io.FileOutputStream;
06import java.io.ObjectInputStream;
07import java.io.ObjectOutputStream;
08import java.io.Serializable;
09 
10/**
11 * 序列化和反序列化的操作
12 * */
13public class serDemo{
14    public static void main(String[] args) throws Exception{
15        ser(); // 序列化
16        dser(); // 反序列话
17    }
18 
19    public static void ser() throws Exception{
20        File file = new File("d:" + File.separator + "hello.txt");
21        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
22                file));
23        out.writeObject(new Person1("rollen", 20));
24        out.close();
25    }
26 
27    public static void dser() throws Exception{
28        File file = new File("d:" + File.separator + "hello.txt");
29        ObjectInputStream input = new ObjectInputStream(new FileInputStream(
30                file));
31        Object obj = input.readObject();
32        input.close();
33        System.out.println(obj);
34    }
35}
36 
37class Person1 implements Serializable{
38    public Person1(){
39 
40    }
41 
42    public Person1(String name, int age){
43        this.name = name;
44        this.age = age;
45    }
46 
47    @Override
48    public String toString(){
49        return "姓名：" + name + "  年龄：" + age;
50    }
51 
52    // 注意这里
53    private transient String name;
54    private int age;
55}

【运行结果】：

姓名：null  年龄：20

最后在给一个序列化一组对象的例子吧：

01import java.io.File;
02import java.io.FileInputStream;
03import java.io.FileOutputStream;
04import java.io.ObjectInputStream;
05import java.io.ObjectOutputStream;
06import java.io.Serializable;
07 
08/**
09 * 序列化一组对象
10 * */
11public class SerDemo1{
12    public static void main(String[] args) throws Exception{
13        Student[] stu = { new Student("hello", 20), new Student("world", 30),
14                new Student("rollen", 40) };
15        ser(stu);
16        Object[] obj = dser();
17        for(int i = ; i < obj.length; ++i){
18            Student s = (Student) obj[i];
19            System.out.println(s);
20        }
21    }
22 
23    // 序列化
24    public static void ser(Object[] obj) throws Exception{
25        File file = new File("d:" + File.separator + "hello.txt");
26        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
27                file));
28        out.writeObject(obj);
29        out.close();
30    }
31 
32    // 反序列化
33    public static Object[] dser() throws Exception{
34        File file = new File("d:" + File.separator + "hello.txt");
35        ObjectInputStream input = new ObjectInputStream(new FileInputStream(
36                file));
37        Object[] obj = (Object[]) input.readObject();
38        input.close();
39        return obj;
40    }
41}
42 
43class Student implements Serializable{
44    public Student(){
45 
46    }
47 
48    public Student(String name, int age){
49        this.name = name;
50        this.age = age;
51    }
52 
53    @Override
54    public String toString(){
55        return "姓名：  " + name + "  年龄：" + age;
56    }
57 
58    private String name;
59    private int age;
60}

【运行结果】：

姓名：  hello  年龄：20

姓名：  world  年龄：30

姓名：  rollen 年龄：40

awj3584
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
import java.io 是什么意思_Java IO 详解
weixin_34304274的博客
02-17 1万+
Java IO 详解初学java，一直搞不懂java里面的io关系，在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术，所以自己来整理一下，有错的话请指正，也希望大家提出宝贵意见。首先看个图：(如果你也是初学者，我相信你看了真个人都不好了，想想java设计者真是煞费苦心啊！)这是java io 比较基本的一些处理流，除此之外我们还会提到一些比较深入的基于i...
Java中IO流简介_动力节点Java学院整理
08-30
IO流是Java中一个基本概念，理解IO流是Java开发中的一项重要技能。下面将对Java IO流进行详细的介绍。 什么是流 所谓“流”，就是一种抽象的数据的总称，它的本质是能够进行传输。流可以按照数据流向和处理数据的...
java 中 IO 流有哪些？
热门推荐
ConstXiong
04-22 1万+
java 中 IO 流有哪些？ 按数据流向:输入流和输出流 输入和输出都是从程序的角度来说的。输入流：数据流向程序；输出流：数据从程序流出。 按处理单位:字节流和字符流 字节流：一次读入或读出是8位二进制；字符流：一次读入或读出是16位二进制。 JDK中后缀是Stream是字节流；后缀是Reader，Writer是字符流。 按功能功能:节点流和处理...
java.io在哪个包_Java中IO软件包的详细介绍
weixin_36053926的博客
02-13 1564
一、Java Io流Java Io流的概念java的io是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源(键盘，文件，网络连接等)抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。stram是从起源(source)到接收的(sink)的有序数据。注：java把所有的传统的流类型都放到在java io包下...
Java中IO流体系
交换一个思想，能得到俩思想
10-08 1950
转载: https://mp.weixin.qq.com/s?__biz=MzA5NzgzODI5NA==&mid=2454030958&idx=1&sn=df27aadb92e575e96115ec809506245a&chksm=872b9fd7b05c16c10f265b495b7204b843f6825771292b30a9124f6d32367d2d9485493316ea&scene=
Java IO详解
07-11 6210
作者：一面千人来源：cnblogs.com/EvswardJava I/O流是一组有顺序的，有起点和终点的字节集合。是对设备文件间数据传输的总称和抽象。在IO中涉及的设备文件包括文件、控制台、网络链接等，这其中又根据流的方向可以将两端的设备文件分为数据源对象和接收端对象数据源对象：有能力产出数据接收端对象：有能力接收数据而IO流实际上屏蔽了在实际设备中的处理数据的细节，这...
Java NIO, IO 整理
生命不息，奋斗不止
12-07 549
NIO:IO多路复用:
Java中的IO整理完整版
程序员成长之路
09-27 972
本文章基本覆盖了java IO的全部内容，java新IO没有涉及，因为我想和这个分开，以突出那个的重要性，新IO哪一篇文章还没有开始写，估计很快就能和大家见面。照旧，文章依旧以例子为主，因为讲解内容的java书很多了，我觉的学以致用才是真。代码是写出来的，不是看出来的。 最
Java中commons-IO
a1901149的博客
05-04 922
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
【Java中IO流】面试知识点总结
02-02 5452
好久不见的IO流 对IO流的学习，我记得还是初学Java基础的时候，后来找工作过程中经常看到有些招聘信息中写到熟悉IO流，现在想想IO流，真的是一脸懵逼，不说这么多废话了，IO流这次好好整理一下。 说说IO流的类别 在说流的类别之前，先说说什么是流，流其实就是对输入输出设备的抽象，可以把输入输出流理解为是一个通道，输入输出是相对程序而言的，如果是输出流，也就是往文件中写文件，而输入流，则是从文件中读取文件。从三个方面对IO流进行总结，一、字节流（一般都是xxxStream），二、字符流（xxxRead、xx
面试专区|【40道Java IO高频题整理(附答案背诵版)】
尺小闹的博客
06-07 1049
同步 I/O（Input/Output）和异步 I/O 是两种基本的数据交换模式。在同步 I/O 模式中，一个 I/O 操作必须在完成之前，其他所有的操作都必须等待。也就是说，一个同步 I/O 操作阻止了程序的执行，直到这个操作完成。这种方式简单、直接，但也容易造成程序阻塞，降低了程序的整体效率。例如，当你在 Java 中使用读取文件时，如果文件非常大，那么程序会阻塞，直到整个文件都被读取完毕。在异步 I/O 模式中，一个 I/O 操作的开始和结束（或完成）是分离的。
java中的IO整理完整版
04-14
以下是对Java IO的详细整理： 首先，Java中的`File`类是操作文件和目录的基础，它提供了许多方法来创建、删除、重命名文件以及检查文件属性。在案例1中，通过`new File("D:\\hello.txt")`创建了一个`File`对象，...
JAVA_IO流整理思维导图.emmx
06-04
JAVA_IO流整理思维导图.
Java IO复用_动力节点Java学院整理
08-30
在实际应用中，Java可以通过Java NIO（Non-blocking I/O）库来实现IO复用，NIO的Selector类对应于epoll的概念，可以注册多个Channel（对应于文件描述符），并在有事件发生时唤醒，从而实现高效的并发处理。...
javaIO流思维导图
07-20
自己整理了一下javaIO流的相关知识点 用xmind软件做了一下
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 461
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 263
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 628
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 376
集合之Map
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值