java中IO流的学

最新推荐文章于 2024-05-05 20:29:22 发布
最新推荐文章于 2024-05-05 20:29:22 发布
阅读量695 收藏
点赞数
分类专栏： java

java IO流涉及到的class 和 interface.

字节流和字符流的区别：

字节流：字节流是一个字节一个字节读取，和一个字节写入，使用于传输任何类型的数据。

字符流：基于字节流，每次需要查询编码表，返回对应的字符，使用于传输字符数据。

一般情况，如果传输的是纯文本数据，建议使用字符流，其他的用字节流。

这些图是我从网上下的，我想对学习java的IO会很有帮助。有什么指点的，还请高手指点。

 

java IO流 class structure picture.

 

InputStream与OutputStream对应图

 

Reader与Writer对应图

 

代码部分：（有点儿多，技术不精，还请高手指点）

01package com.wangbiao.test;
02 
03import java.io.File;
04import java.io.FileInputStream;
05import java.io.FileNotFoundException;
06import java.io.InputStream;
07 
08/**
09 * InputStream及其子类的用法。
10 * @author wangbiao
11 *
12 * 2013-4-27上午12:25:56
13 */
14public class Test_InputStream {
15 
16     
17    public static void test_read_first(File file) throws Exception{
18        InputStream in=new FileInputStream(file);
19        byte[] b=new byte[(int) file.length()];
20        in.read(b);
21        in.close();
22        System.out.println(new String(b));
23    }
24    public static void test_read_second(File file) throws Exception{
25        InputStream in=new FileInputStream(file);
26        byte[] b=new byte[(int) file.length()];
27        int len=in.read(b);
28        in.close();
29        System.out.println(new String(b,0,len));
30    }
31    //如果不知道數組的大小，則通過判斷是否讀到文件的末尾。
32    public static void test_read_third(File file) throws Exception{
33        InputStream in=new FileInputStream(file);
34         
35        byte[] b=new byte[1024];//file被封装起来，不能调用file.length().
36        int temp=0;
37        int len=0;
38        while((temp=in.read())!=-1){
39            b[len]=(byte) temp;
40            len++;
41        }
42        in.close();
43        System.out.println(new String(b,0,len));
44    }
45     
46     
47    public static void main(String[] args) throws Exception {
48        File file=new File("D:"+File.separator+"test.txt");
49        //test_read_first(file);
50        //test_read_second(file);
51        test_read_third(file);
52    }
53     
54}

 

01package com.wangbiao.test;
02 
03import java.io.File;
04import java.io.FileNotFoundException;
05import java.io.FileOutputStream;
06import java.io.OutputStream;
07 
08 
09/**
10 *
11 * OutputStream以及其常用子类的用法。
12 * @author wangbiao
13 * 2013-4-26下午11:58:14
14 */
15public class Test_OutputStream {
16 
17 
18    //将一个字节数组直接写入File里面。
19    public static void test_write_first(File file) throws Exception{
20        OutputStream out=new FileOutputStream(file,true);//true表示可以追加内容，而不是覆盖原内容。
21        String str="test java io";
22        byte[] b=str.getBytes();
23        out.write(b);
24        out.close();
25    }
26    //将一个字节数组里面的内容一个字节一个字节的写入File里面。
27    public static void test_write_second(File file) throws Exception{
28        OutputStream out=new FileOutputStream(file,true);//true表示可以追加内容，而不是覆盖原内容。
29        //String str="test java io";
30        String str="\r\n test java io";//"\r\n"代表换行
31        byte[] b=str.getBytes();
32        for (int i = 0; i < b.length; i++) {
33            out.write(b[i]);
34        }
35        out.close();
36    }
37     
38    public static void main(String[] args) throws Exception {
39        File file=new File("D:"+File.separator+"test.txt");
40        //file.delete();
41        //test_write_first(file);
42        test_write_second(file);
43    }
44}

 

01package com.wangbiao.test;
02 
03import java.io.File;
04import java.io.FileNotFoundException;
05import java.io.FileReader;
06import java.io.Reader;
07 
08 
09 
10/**
11 * Reader及其子类的学习
12 * @author wangbiao
13 *
14 * 2013-4-27上午12:47:46
15 */
16public class Test_Reader {
17 
18     
19    public static void test_read_first(File file) throws Exception{
20        Reader in=new FileReader(file);
21        //注意这里是char[]，而不是byte[]
22        char[] c=new char[1024];
23        int len=in.read(c);
24        in.close();
25        System.out.println(new String(c,0,len));
26    }
27     
28    public static void test_read_second(File file) throws Exception{
29        Reader in=new FileReader(file);
30        //注意这里是char[]，而不是byte[]
31        char[] c=new char[(int) file.length()];
32        int len=in.read(c);
33        in.close();
34        System.out.println(new String(c));
35    }
36     
37    public static void test_read_third(File file) throws Exception{
38        Reader in=new FileReader(file);
39        //注意这里是char[]，而不是byte[]
40        char[] c=new char[1024];
41        int len=0;
42        int temp=0;
43        while((temp=in.read())!=-1){
44            c[len]=(char) temp;
45            len++;
46        }
47        in.close();
48        System.out.println(new String(c,0,len));
49    }
50     
51    public static void main(String[] args) throws Exception{
52        File file=new File("D:"+File.separator+"test.txt");
53        test_read_first(file);
54        test_read_second(file);
55        test_read_third(file);
56    }
57}

 

01package com.wangbiao.test;
02 
03import java.io.File;
04import java.io.FileWriter;
05import java.io.IOException;
06import java.io.Writer;
07 
08 
09/**
10 * Writer及其子类的学习
11 * @author wangbiao
12 *
13 * 2013-4-27上午12:40:55
14 */
15public class Test_Writer {
16 
17    public static void test_write_first(File file) throws Exception{
18        Writer out=new FileWriter(file);
19        String str="\r\n love java";
20        out.write(str);
21        out.close();
22     
23    }
24    //append content
25    public static void test_write_second(File file) throws Exception{
26        Writer out=new FileWriter(file,true);
27        String str="\r\n love java";
28        out.write(str);
29        out.close();
30     
31    }
32     
33    public static void main(String[] args) throws Exception {
34        File file=new File("D:"+File.separator+"test.txt");
35        test_write_first(file);
36        test_write_second(file);
37    }
38     
39}

 

01package com.wangbiao.test;
02 
03import java.io.File;
04import java.io.FileNotFoundException;
05import java.io.FileOutputStream;
06import java.io.FileWriter;
07import java.io.OutputStream;
08import java.io.Writer;
09 
10 
11 
12/**
13 *
14 * 比较字节流和字符流的区别
15 * @author wangbiao
16 *
17 * 2013-4-27上午1:01:31
18 */
19public class Compare_OutputStream_Writer {
20 
21    //可以这么理解，字符流的底层是字节流，底层数据的传输都是通过字节流来实现的。字节流可以传输图片，音乐等，而字符流则只能传输与字符有关的内容。
22    //字节流不需要缓冲区，是直接操作文件，而字符流则需要缓冲区，
23    //例如将内容写入到文件中，字节流是直接写入，字符流，是先把内容写入缓冲区中，然后通过字符流的flush(),和close()方法去触发，将缓冲区的内容传输到文件中。
24     
25     
26    //不需要缓冲区
27    public static void test_outputStream(File file) throws Exception{
28        OutputStream out=new FileOutputStream(file);
29        String str="xxxxxxxxxxxx";
30        byte[] b=str.getBytes();
31        out.write(b);
32        //out.close();不关闭输出流
33    }
34    //需要缓冲区
35    public static void test_writer(File file)throws Exception{
36        Writer out=new FileWriter(file,true);
37        String str="\r\nxxxxxxxxxx";
38        out.write(str);
39        //out.flush()和out.close()都可以触发将缓冲区的内容传输到文件中。
40        out.flush();
41        //out.close();
42         
43    }
44     
45    public static void main(String[] args) throws Exception{
46        File file=new File("D:"+File.separator+"test.txt");
47        test_outputStream(file);
48        test_writer(file);
49    }
50     
51}

 

01package com.wangbiao.test;
02 
03import java.io.ByteArrayInputStream;
04import java.io.ByteArrayOutputStream;
05import java.io.File;
06import java.io.IOException;
07import java.io.InputStream;
08import java.io.OutputStream;
09 
10 
11/**
12 *
13 * 内存操作流ByteArrayInputStream and ByteArrayOutputStream.
14 * @author WangBiao
15 *2013-4-27上午09:21:30
16 */
17public class Test_ByteArray {
18     
19     
20    public static void test(File file) throws Exception{
21        String str="work hard";
22        byte[] b=str.getBytes();
23         
24        //ByteArrayInputStream(byte[] buf, int offset, int length)
25        //ByteArrayInputStream(byte[] buf)
26 
27        InputStream in=new ByteArrayInputStream(b);
28        OutputStream out=new ByteArrayOutputStream();
29        int temp=0;
30        while ((temp=in.read())!=-1) {
31//          System.out.println(temp);//temp是字符的ASCII值
32//          out.write(temp);
33            char c=(char) temp;
34            //转换字符大小写
35            out.write(Character.toUpperCase(c));
36        }
37         
38        String string=out.toString();
39        out.close();
40        in.close();
41        System.out.println(string);
42    }
43     
44     
45    public static void main(String[] args)throws Exception{
46        File file=new File("D:"+File.separator+"test.txt");
47        test(file);
48    }
49 
50}

 

01package com.wangbiao.test;
02 
03import java.io.File;
04import java.io.FileInputStream;
05import java.io.FileOutputStream;
06import java.io.FileWriter;
07import java.io.InputStream;
08import java.io.InputStreamReader;
09import java.io.OutputStreamWriter;
10import java.io.Reader;
11import java.io.Writer;
12 
13 
14/**
15 * 转换流InputStreamReader and OutputStreamWriter,都是将字节流装换成字符流
16 * @author WangBiao
17 *2013-4-27上午08:49:09
18 */
19public class Test_InputSteamReader {
20 
21    //InputStreamReader
22    public static void test_inputStreamReader(File file) throws Exception{
23        InputStream in=new FileInputStream(file);
24        Reader rd=new InputStreamReader(in);
25        char[] c=new char[(int) file.length()];
26        rd.read(c);
27        rd.close();
28        System.out.println(new String(c));
29         
30    }
31    //OutputStreamWriter
32    public static void test_outputStreamWriter(File file) throws Exception{
33         
34        String str="test";
35        Writer out=new OutputStreamWriter(new FileOutputStream(file));
36        out.write(str);
37        out.close();
38    }
39     
40    public static void main(String[] args) throws Exception {
41        File file=new File("D:"+File.separator+"test"+File.separator+"test.txt");
42        file.setWritable(true);
43        test_inputStreamReader(file);
44        test_outputStreamWriter(file);
45    }
46}

 

01package com.wangbiao.test;
02 
03import java.io.IOException;
04import java.io.PipedInputStream;
05import java.io.PipedOutputStream;
06 
07 
08/**
09 *
10 * PipedInputStream and PipedOutputStream,用于不同线程之间流的数据传输
11 * @author WangBiao
12 *2013-4-27上午10:24:51
13 */
14public class Test_Piped {
15 
16    public static void main(String[] args) throws Exception {
17        PipedOutputStream_Class send=new PipedOutputStream_Class();
18        PipedInputStream_Class receive=new PipedInputStream_Class();
19        //连接两个线程管道流。
20        send.getOutput().connect(receive.getInput());
21         
22        new Thread(send).start();
23        new Thread(receive).start();
24    }
25     
26     
27}
28class PipedInputStream_Class implements Runnable{
29    private PipedInputStream input=null;
30    public PipedInputStream_Class() {
31        this.input=new PipedInputStream();
32    }
33     
34    @Override
35    public void run() {
36         
37        byte[] b=new byte[1024];
38        int temp=0;
39        int len=0;
40        try {
41            while((temp=input.read())!=-1){
42                b[len]=(byte) temp;
43                len++;
44            }
45            input.close();
46        } catch (IOException e) {
47            e.printStackTrace();
48        }
49        System.out.println(new String(b,0,len));
50    }
51 
52    public PipedInputStream getInput() {
53        return input;
54    }
55 
56}
57 
58 class PipedOutputStream_Class implements Runnable{
59    private PipedOutputStream output=null;
60    public PipedOutputStream_Class() {
61        this.output=new PipedOutputStream();
62    }
63     
64    @Override
65    public void run() {
66        String str="test";
67        try {
68            output.write(str.getBytes());
69            output.close();
70        } catch (IOException e) {
71            e.printStackTrace();
72        }
73         
74    }
75 
76    public PipedOutputStream getOutput() {
77        return output;
78    }
79 
80}

 

001package com.wangbiao.test;
002 
003import java.io.File;
004import java.io.FileInputStream;
005import java.io.FileNotFoundException;
006import java.io.FileOutputStream;
007import java.io.InputStream;
008import java.io.PrintStream;
009 
010/**
011 *
012 * PrintStream
013 *
014 * @author WangBiao 2013-4-27上午10:44:34
015 */
016public class Test_PrintStream {
017//  PrintStream(File file)
018//    创建具有指定文件且不带自动行刷新的新打印流。
019//  PrintStream(File file, String csn)
020//    创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
021//  PrintStream(OutputStream out)
022//    创建新的打印流。
023//  PrintStream(OutputStream out, boolean autoFlush)
024//    创建新的打印流。
025//  PrintStream(OutputStream out, boolean autoFlush, String encoding)
026//    创建新的打印流。
027//  PrintStream(String fileName)
028//    创建具有指定文件名称且不带自动行刷新的新打印流。
029//  PrintStream(String fileName, String csn)
030//    创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
031 
032    public static void test_printStream(File file) throws Exception{
033        PrintStream ps=new PrintStream(new FileOutputStream(file));
034        //虽然没有System.setOut(ps),但还是重定向了，内容输出到了指定的文件
035        ps.print("ddddddddd");
036        ps.println("ccccccccccc");
037        ps.close();
038         
039    }
040     
041    //有点儿C语言的意思
042    public static void test_format(File file) throws Exception{
043        PrintStream ps=new PrintStream(file);
044        String name="zhangsan";
045        int age=22;
046        float score=(float) 97.5;
047        char sex='M';
048        ps.printf("姓名为：%s;年龄为：%d;分数为：%f;性别为：%c ", name,age,score,sex);
049        ps.close();
050    }
051     
052 
053    public static void test_sys_in() throws Exception {
054        InputStream in=System.in;
055        //若字节数组的大小为奇数，并且数组大小偏小，则输入中文的时候，会出现乱码的情况,原因是一个中文占两个字节，字节数组没有完整的将中文字符装入。
056        //byte[] b=new byte[5];
057        byte[] b=new byte[1024];
058        System.out.print("请输入内容：");
059        //in.read(b);
060        StringBuffer sb=new StringBuffer();
061        int temp=0;
062        //中文是乱码，原因是中文占两个字节，不能拆开读取。
063        while((temp=in.read())!=-1){
064            char c=(char) temp;
065            if('\n'==c){
066                break;
067            }
068            sb.append(c);
069        }
070        System.out.println(sb.toString());
071        in.close();
072    }
073 
074    public static void test_sys_out() {
075        //System.out.print()
076    }
077 
078    public static void test_sys_err() {
079        //System.err.print()
080    }
081 
082    //System.in重定向
083    public static void test_sys_in_redirect(File file) throws Exception {
084        System.setIn(new FileInputStream(file));
085        InputStream input=System.in;
086        byte[] b=new byte[1024];
087        input.read(b);
088        System.out.println(new String(b));
089        input.close();
090    }
091    //System.out重定向
092    public static void test_sys_out_redirect(File file) throws Exception {
093        PrintStream ps=new PrintStream(file);
094        System.setOut(ps);
095        System.out.println("love java");
096        ps.close();
097    }
098     
099    //System.err重定向
100    public static void test_sys_err_redirect(File file) throws Exception {
101        PrintStream ps=new PrintStream(file);
102        System.setErr(ps);
103        System.err.println("love java");
104        ps.close();
105    }
106 
107    public static void main(String[] args) throws Exception {
108        File file=new File("D:"+File.separator+"test"+File.separator+"test.txt");
109        //test_printStream(file);
110        //test_format(file);
111        //test_sys_in();
112        //test_sys_in_redirect(file);
113        test_sys_out_redirect(file);
114        test_sys_err_redirect(file);
115         
116    }
117}

 

01package com.wangbiao.test;
02 
03import java.io.DataInputStream;
04import java.io.DataOutputStream;
05import java.io.File;
06import java.io.FileInputStream;
07import java.io.FileOutputStream;
08import java.io.InputStream;
09import java.io.OutputStream;
10 
11 
12/**
13 * DataInputStream and DataOutputStream,就我的理解是，这两个类不同之处是可以读取和写入基本数据类型的数据。
14 * 两者搭配起来使用，并且写入和读取的顺序要严格一样
15 * @author WangBiao
16 *2013-4-27下午03:26:37
17 */
18public class Test_DataInputStream {
19 
20    //DataInputStream(InputStream in)
21    public static void test_DataInputStream(File file) throws Exception{
22        InputStream in=new FileInputStream(file);
23        DataInputStream input=new DataInputStream(in);
24        String name=null;
25        float fl=0.0f;
26        int classNum=0;
27        char[] temp=null;
28        char c;
29        try {
30            while(true){
31                temp=new char[200];
32                int len=0;
33                while((c=input.readChar())!='\t'){
34                    temp[len]=c;
35                    len++;
36                }
37                name=new String(temp,0,len);
38                fl=input.readFloat();
39                input.readChar();
40                classNum=input.readInt();
41                input.readChar();
42                System.out.printf("姓名为：%s; 分数为: %5.2f; 班级为：%d\n",name,fl,classNum);
43            }
44        } catch (Exception e) {
45        }
46         
47        input.close();
48         
49         
50         
51         
52    }
53     
54    //DataOutputStream(OutputStream out)
55    public static void test_DataOutputStream(File file)throws Exception{
56        OutputStream out=new FileOutputStream(file);
57        DataOutputStream output=new DataOutputStream(out);
58        String[] name=new String[]{"zhangsan","lisi","wangwu"};
59        float[] score={95.5f,86.5f,100f};
60        int[] classNum={1,1,3};
61        for (int i = 0; i < name.length; i++) {
62             output.writeChars(name[i]);
63             output.writeChar('\t');
64             output.writeFloat(score[i]);
65             output.writeChar('\t');
66             output.writeInt(classNum[i]);
67             output.writeChar('\n');
68        }
69        output.close();
70    }
71    public static void main(String[] args) throws Exception{
72        File file=new File("D:"+File.separator+"test"+File.separator+"test.txt");  
73        test_DataOutputStream(file);
74        test_DataInputStream(file);
75    }
76}

 

01package com.wangbiao.test;
02 
03import java.io.File;
04import java.io.FileInputStream;
05import java.io.FileNotFoundException;
06import java.io.InputStream;
07import java.io.SequenceInputStream;
08 
09 
10/**
11 * SequenceInputStream，合并流的主要功能是将两个文件的内容合并成一个文件
12 * @author WangBiao
13 *2013-4-27下午04:08:37
14 */
15public class Test_SequenceInputStream {
16 
17    public static void test(File file1,File file2,File all) throws Exception{
18        if(!all.exists()){
19            all.createNewFile();
20        }
21        InputStream input_first=new FileInputStream(file1);
22        InputStream input_second=new FileInputStream(file2);
23        InputStream input_all=new FileInputStream(all);
24        //SequenceInputStream(InputStream s1, InputStream s2)
25        SequenceInputStream sq=new SequenceInputStream(input_first,input_second);
26        byte[] temp= new byte[1024];
27        int data=0;
28        int len=0;
29        while((data=sq.read())!=-1){
30            temp[len]=(byte) data;
31            len++;
32        }
33        System.out.println(new String(temp,0,len));
34         
35    }
36     
37    public static void main(String[] args)throws Exception{
38        File file1=new File("D:"+File.separator+"test"+File.separator+"test.txt");
39        File file2=new File("D:"+File.separator+"test"+File.separator+"good.txt");
40        File all=new File("D:"+File.separator+"test"+File.separator+"all.txt");
41        test(file1,file2,all);
42    }
43}

 

 

001package com.wangbiao.test;
002 
003import java.io.File;
004import java.io.FileInputStream;
005import java.io.FileOutputStream;
006import java.io.InputStream;
007import java.io.OutputStream;
008import java.util.zip.ZipEntry;
009import java.util.zip.ZipFile;
010import java.util.zip.ZipInputStream;
011import java.util.zip.ZipOutputStream;
012 
013 
014 
015/**
016 * ZipOutputStream和ZipInputStream为压缩流,每一个压缩文件都可以称为ZipFile.
017 * @author WangBiao
018 *2013-4-27下午04:41:01
019 */
020public class Test_ZipOutputStream {
021 
022    //将文件压缩成zip包
023    public static void test_zipOutputStream(File file) throws Exception{
024        InputStream input=null;
025        File zipFile=new File("D:"+File.separator+"test"+File.separator+"test.zip");
026        ZipOutputStream zipOut=new ZipOutputStream(new FileOutputStream(zipFile));;
027        if(file.isDirectory()){
028            File[] files=file.listFiles();
029            for (int i = 0; i < files.length; i++) {
030                input=new FileInputStream(files[i]);
031                zipOut.putNextEntry(new ZipEntry(file.getName()+File.separator+files[i].getName()));
032                zipOut.setComment(files[i].getName());
033                int temp=0;
034                while((temp=input.read())!=-1){
035                    zipOut.write(temp);
036                }
037            }
038        }else{
039            input=new FileInputStream(file);
040            zipOut.putNextEntry(new ZipEntry(file.getName()));
041            zipOut.setComment("test zipoutputStream");
042            int temp=0;
043            while((temp=input.read())!=-1){
044                zipOut.write(temp);
045            }
046        }
047         
048        input.close();
049        zipOut.close();
050         
051    }
052    //getNextEntry();
053    //ZipInputStream(InputStream in)
054 
055    public static void test_zipInputStream()throws Exception{
056        File file=new File("D:"+File.separator+"test"+File.separator+"test.zip");
057        InputStream input=null;
058        OutputStream output=null;
059        ZipEntry entry=null;
060        File outFile=null;
061        ZipFile zipFile=new ZipFile(file);
062        ZipInputStream zipInputStream=new ZipInputStream(new FileInputStream(file));
063         
064        while((entry=zipInputStream.getNextEntry())!=null){
065            System.out.println("解压缩"+entry.getName());
066            outFile=new File("D:"+File.separator+entry.getName());
067            if(!outFile.getParentFile().exists()){
068                outFile.getParentFile().mkdir();
069            }
070            if(!outFile.exists()){
071                outFile.createNewFile();
072            }
073            input=zipFile.getInputStream(entry);
074            output=new FileOutputStream(outFile);
075            int temp=0;
076            while((temp=input.read())!=-1){
077                output.write(temp);
078            }
079        }
080        zipInputStream.close();
081        input.close();
082        output.close();
083    }
084     
085     
086    public static void test_zipFile()throws Exception{
087        File file=new File("D:"+File.separator+"test"+File.separator+"test.zip");
088        ZipFile zipFile=new ZipFile(file);
089        System.out.println(zipFile.getName());//D:\test\test.zip
090         
091    }
092    public static void main(String[] args) throws Exception{
093//      File file=new File("D:"+File.separator+"test");
094//      test_zipOutputStream(file);
095//      test_zipFile();
096        test_zipInputStream();
097    }
098     
099     
100     
101}
01package com.wangbiao.test;
02 
03import java.io.ByteArrayInputStream;
04import java.io.File;
05import java.io.FileInputStream;
06import java.io.IOException;
07import java.io.InputStream;
08import java.io.PushbackInputStream;
09 
10 
11/**
12 * PushbackInputStream and PushbackReader 为回退流，在数据读取的时候，都是按着顺序读取的，回退流就是讲读取进来的某些数据重新退回到输入流的缓冲区中。
13 * @author WangBiao
14 *2013-4-27下午06:07:45
15 */
16public class Test_PushbackInputStream {
17     
18     
19        public static void test() throws IOException{
20            InputStream input=new ByteArrayInputStream("www.oschina.net".getBytes());
21            PushbackInputStream pushbackInput=new PushbackInputStream(input);
22            int temp=0;
23            while((temp=pushbackInput.read())!=-1){
24                if(temp=='.'){
25                    pushbackInput.unread(temp);
26                    temp=pushbackInput.read();//讀出來的依舊是‘.’，因为被退回到缓冲流里面，所有再读的时候，又把它读出来了。
27                    System.out.print("濾掉"+(char)temp);
28                }else{
29                    System.out.print((char)temp);
30                }
31            }
32            input.close();
33            pushbackInput.close();
34        }
35     
36     
37      public static void main(String[] args) throws IOException{
38          test();
39}
40}
Ryuka-fly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中io流拒绝访问_JAVA IO流常见问题
weixin_34800530的博客
02-16 2287
1、字节流和字符流的区别？(1)读写单位不同：字节流以字节(8 bit)为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。(2)处理对象不同：字节流能处理所有类型的数据(如图片、avi 等)，而字符流只能处理字符类型的数据。(3)字节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。因此在输出时，字节流不调用 colse() 方法时，信息已经输出了，而字符流只有在调用 clos...
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
javaIO流详解
weixin_46676497的博客
01-27 2283
java常用io流介绍
Java io流学习
hua226的博客
04-12 2万+
Java io 一、File 1.1 File类概述和构造方法 概述： 它是文件和目录路径名的抽象表示 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。 将来是要通过具体的操作把这个路径的内容转换为具体存在的。 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例 File(String parent,String child) 从父路径名字符串
java中IO流有哪些？
liuqinhou的博客
11-16 746
java 流
JAVA—IO流详解
weixin_48006490的博客
09-01 8039
IO:Input/Output即输入&输出，也称之为流（河流，水流），指的是数据从一个地点到另一个地点过程；对于计算机来说文件的拷贝过程，文件的编写保存，显示功能都是使用到IO；将数据的传输过程看做一个输入输出。现实角度考虑可以将耳朵作为输入流，将嘴巴当做输出流输入输出介质：文件网络键盘（输入）显示器（输出）
java-io流 超详细！
weixin_74886498的博客
05-05 1229
public class 拷贝 {// 字节基本流 一次读取一个字节// 1.创建对象FileInputStream fis=new FileInputStream("D:\\测试安全\\d.txt");FileOutputStream fos=new FileOutputStream("D:\\测试安全\\dd.txt");// 2.读数据// 依次读取读取一个数据 指针后移 返回值是字符对应的ASCII码值 如果全部读取完 返回-1// ascii码表中不存在acsii码值为-1的字符。
Java中的io流
medlidenhed的博客
04-07 942
对文件内容进行读写操作。Java的IO流通常是基于InputStream、OutputStream、Reader和Writer这四个抽象类实现的。具体的IO流类包括FileInputStream、FileOutputStream、BufferedInputStream等。在使用Java的IO流时，需要注意的是要适时关闭IO流以释放资源。Java的IO流是Java程序与外部世界之间进行数据交换的重要方式，也是开发Java应用程序时常用的工具之一。
Java IO流学习总结一：输入输出流
热门推荐
赵彦军
01-09 6万+
Java IO流学习总结一：输入输出流 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构：流的概念和作用流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直
java IO流详解
weixin_62275996的博客
08-17 998
🌈🌈😄😄 欢迎来到茶色岛独家岛屿，本期将为大家揭晓JavaIO流详解，做好准备了么，那么开始吧 🌲🌲🐴🐴
java-io流学习总结.doc
11-24
Java IO 流学习总结的主要内容是对 Java 语言中 IO 流的机制和应用进行了详细的介绍，包括流的基本概念、字节流和字符流的区别、IO 体系的基本结构、FileReader 和 FileWriter 的使用、IO 流的应用等等。
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
《JAVA_IO流学习总结》
04-23
在本文中，我们将深入探讨Java IO流的各个方面，包括它的分类、工作原理、常见类以及实际应用。 一、IO流的分类 Java IO流分为两大类：字节流和字符流。字节流处理的是单个8位的字节，而字符流处理的是16位Unicode...
java-IO流学习使用教程
06-14
Java IO流是Java平台中处理输入输出操作的重要组成部分，它允许程序与外部设备（如硬盘、网络、内存等）进行数据传输。Java IO流分为两大类：字节流（Byte Stream）和字符流（Character Stream）。本文将详细介绍...
Java之IO流学习总结.pdf
10-27
Java的IO流是Java编程语言中处理输入输出的重要机制，主要负责数据的传输。本文将对Java之IO流进行深入的解析和总结。 首先，理解流的概念至关重要。流是数据的流动，它抽象了从数据源读取数据或向接收端写入数据的...
Mali_Texture_Compression_Tool_v4_Windows_x64.zip
08-30
Mali_Texture_Compression_Tool_v4_Windows_x64.zip
高分项目-卡卡汽车 获取用户 设备信息小程序源码（优秀毕业设计源码）.zip
08-30
1. 精选系统小程序代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：java，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
基于Java的图书馆管理系统代码.rar
08-30
一键三连加关注私信up获取源码无偿分享群，以下为福利链接：https://pan.baidu.com/s/1niFL_7h0KhdJSW7r0XdtDw?pwd=1234 提取码：1234 基于springboot的XXXX管理系统，可以用于计算机专业毕设和课设使用 开发语言：Java 开发软件：eclipse/myeclipse/idea 框架：ssm JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7（一定要5.7版本） 数据库工具：Navicat11 Maven包：Maven3.3.9 浏览器：谷歌浏览器 管理员账号：admin 管理员密码：admin 配置环境安装包： Java配置环境链接：https://cloud.189.cn/t/baeQZrAjEvyy （访问码：pfd5） 后台路径地址：localhost:8080/项目名称/admin/dist/index.html 前台路径地址：localhost:8080/项目名称/front/dist/inde
免费prometheus Mac 版本安装包
最新发布
08-30
Prometheus是一个流行的开源监控和告警工具，特别适合于云原生环境和Kubernetes集群的监控。以下是Prometheus的详细描述： 一、概述 Prometheus是一个基于时序数据库的开源服务监控系统和时序数据库，其提供了通用的数据模型和快捷数据采集、存储和查询接口。自2012年启动以来，许多公司和组织都采用了Prometheus，该项目拥有非常活跃的开发人员和用户社区。Prometheus于2016年加入云原生计算基金会，成为继Kubernetes之后的第二个托管项目。 二、主要特性 多维数据模型：Prometheus的数据模型是基于时间序列的，每个时间序列由度量名称（metric name）和一系列键值对（key-value pairs，也称为标签labels）唯一标识。这种模型允许对数据进行多维度的查询和聚合。 PromQL查询语言：Prometheus提供了一个功能强大的查询语言PromQL（Prometheus Query Language），用户可以使用这个语言对收集到的时序数据进行查询和分析。 高效的数据采集和存储：Prometheus通过HTTP协议周
Java IO流详解：字节流与字符流的区别
总结来说，Java的IO流是处理数据流动的核心工具，理解字节流和字符流的差异以及如何在实际操作中选择合适的流类型，对于开发涉及文件操作或网络通信的Java应用程序至关重要。在实际编程中，根据文件类型和需求选择...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值