JAVA-IO

最新推荐文章于 2016-10-05 00:01:56 发布
最新推荐文章于 2016-10-05 00:01:56 发布
阅读量695 收藏 3
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Thingvellir/article/details/52733271
版权

JAVA-IO

尽可多创造快乐去填满时间，哪可活活缚着时间来陪着快乐。——闻一多

字节流与字符流综述

字符流和字节流：
字节流两个基类：
InputStream   OutputStream
字符流两个基类：
Reader Writer
先学习一下字符流的特点。
既然IO流是用于操作数据的，
那么数据的最常见体现形式是：文件。
那么先以操作文件为主来演示。
需求:在硬盘上，创建一个文件并写入一些文字数据。
找到一个专门用于操作文件的Writer子类对象。FileWriter。  后缀名是父类名。 前缀名是该流对象的功能。

字符流

一个小的用于在硬盘上存储字符的Demo

import java.io.*;
class  FileWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
        //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
        //其实该步就是在明确数据要存放的目的地。
        FileWriter fw = new FileWriter("demo.txt");

        //调用write方法，将字符串写入到流中。
        fw.write("abcde");

        //刷新流对象中的缓冲中的数据。
        //将数据刷到目的地中。
        //fw.flush();


        //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
        //将数据刷到目的地中。
        //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
        fw.close();
    }
}
IO的异常处理方式

有时我们会遇见目的文件不存在、流没有正常的关闭等异常

import java.io.*;

class  FileWriterDemo2
{
    public static void main(String[] args) 
    {
        FileWriter fw = null;
        try
        {
            fw = new FileWriter("demo.txt");
            fw.write("abcdefg");

        }
        catch (IOException e)
        {
            System.out.println("catch:"+e.toString());
        }
        finally
        {
            try
            {
                if(fw!=null)
                    fw.close();             
            }
            catch (IOException e)
            {
                System.out.println(e.toString());
            }

        }       

    }
}
不覆盖续写文件
import java.io.*;
class  FileWriterDemo3
{
    public static void main(String[] args) throws IOException
    {

        //传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
        FileWriter fw = new FileWriter("demo.txt",true);

        fw.write("nihao\r\nxiexie");

        fw.close();
    }
}

注意，在这里/r/n是windows下的换行符号，如果需要打印“/r/n”，就请再加/进行转义。

利用FileReader进行读取
import java.io.*;

class  FileReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个文件读取流对象，和指定名称的文件相关联。
        //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
        FileReader fr = new FileReader("demo.txt");

        //调用读取流对象的read方法。
        //read():一次读一个字符。而且会自动往下读。

        int ch = 0;

        while((ch=fr.read())!=-1)
        {
            System.out.println(
        }


        /*
        while(true)
        {
            int ch = fr.read();
            if(ch==-1)
                break;
            System.out.println("ch="+(char)ch);
        }
        */



        fr.close();


    }
}
利用FileReader进行读取的第二种方式
import java.io.*;

class FileReaderDemo2 
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("demo.txt");


        //定义一个字符数组。用于存储读到字符。
        //该read(char[])返回的是读到字符个数。
        char[] buf = new char[1024];

        int num = 0;
        while((num=fr.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,num));
        }


        fr.close();
    }
}
读取一个.java文件，并打印在控制台上
import java.io.*;

class FileReaderTest 
{
    public static void main(String[] args) throws IOException
    {
        FileReader  fr = new FileReader("DateDemo.java");

        char[] buf = new  char[1024];

        int num = 0;

        while((num=fr.read(buf))!=-1)
        {
            System.out.print(new String(buf,0,num));
        }

        fr.close();
    }

}
将C盘的一个文本文件复制到D盘当中
复制的原理：
其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：
1，在D盘创建一个文件。用于存储C盘文件中的数据。
2，定义读取流和C盘文件关联。
3，通过不断的读写完成数据存储。
4，关闭资源。
import java.io.*;

class CopyText 
{
    public static void main(String[] args) throws IOException
    {
        copy_2();
    }


    public static void copy_2()
    {
        FileWriter fw = null;
        FileReader fr = null;
        try
        {
            fw = new FileWriter("SystemDemo_copy.txt");
            fr = new FileReader("SystemDemo.java");

            char[] buf = new char[1024];

            int len = 0;
            while((len=fr.read(buf))!=-1)
            {
                fw.write(buf,0,len);
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("读写失败");

        }
        finally
        {
            if(fr!=null)
                try
                {
                    fr.close();
                }
                catch (IOException e)
                {
                }
            if(fw!=null)
                try
                {
                    fw.close();
                }
                catch (IOException e)
                {
                }
        }
    }

    //从C盘读一个字符，就往D盘写一个字符。
    public static void copy_1()throws IOException
    {
        //创建目的地。
        FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");

        //与已有文件关联。
        FileReader fr = new FileReader("RuntimeDemo.java");

        int ch = 0;

        while((ch=fr.read())!=-1)
        {
            fw.write(ch);
        }

        fw.close();
        fr.close();

    }


}
带有缓冲区的Writer
缓冲区的出现是为了提高流的操作效率而出现的。

所以在创建缓冲区之前，必须要先有流对象。

该缓冲区中提供了一个跨平台的换行符。
newLine();
import java.io.*;

class  BufferedWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个字符写入流对象。
        FileWriter fw = new FileWriter("buf.txt");

        //为了提高字符写入流效率。加入了缓冲技术。
        //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
        BufferedWriter bufw = new BufferedWriter(fw);

        for(int x=1; x<5; x++)
        {
            bufw.write("abcd"+x);
            bufw.newLine();
            bufw.flush();
        }

        //记住，只要用到缓冲区，就要记得刷新。
        //bufw.flush();

        //其实关闭缓冲区，就是在关闭缓冲区中的流对象。
        bufw.close();


    }
}
带有缓冲区的Reader
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
import java.io.*;

class  BufferedReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个读取流对象和文件相关联。
        FileReader fr = new FileReader("buf.txt");

        //为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
        BufferedReader bufr = new BufferedReader(fr);


        String line = null;

        while((line=bufr.readLine())!=null)
        {
            System.out.print(line);
        }


        bufr.close();
    }

}
通过缓冲区来复制文件
import java.io.*;

class  CopyTextByBuf
{
    public static void main(String[] args) 
    {
        BufferedReader bufr = null;
        BufferedWriter bufw = null;

        try
        {
            bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
            bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));

            String line = null;

            while((line=bufr.readLine())!=null)
            {
                bufw.write(line);
                bufw.newLine();
                bufw.flush();

            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        finally
        {
            try
            {
                if(bufr!=null)
                    bufr.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}
模拟BufferedReader
明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟一下BufferedReader
import java.io.*;
class MyBufferedReader extends Reader
{

    private Reader r;
    MyBufferedReader(Reader r)
    {
        this.r = r;
    }

    //可以一次读一行数据的方法。
    public String myReadLine()throws IOException
    {
        //定义一个临时容器。原BufferReader封装的是字符数组。
        //为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while((ch=r.read())!=-1)
        {
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return sb.toString();
            else
                sb.append((char)ch);
        }

        if(sb.length()!=0)
            return sb.toString();
        return null;        
    }

    /*
    覆盖Reader类中的抽象方法。

    */
    public int read(char[] cbuf, int off, int len) throws IOException
    {
        return r.read(cbuf,off,len) ;
    }

    public void close()throws IOException
    {
        r.close();
    }
    public void myClose()throws IOException
    {
        r.close();
    }
}


class  MyBufferedReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("buf.txt");

        MyBufferedReader myBuf = new MyBufferedReader(fr);

        String line = null;

        while((line=myBuf.myReadLine())!=null)
        {
            System.out.println(line);
        }

        myBuf.myClose();
    }
}

字节流

字符流：
FileReader
FileWriter。

BufferedReader
BufferedWriter

字节流：
InputStream  OutputStream

需求，想要操作图片数据。这时就要用到字节流。
复制一个图片.
import java.io.*;
class  FileStream
{
    public static void main(String[] args) throws IOException
    {
        readFile_3();
    }

    public static void readFile_3()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

//      int num = fis.available();
        byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不用在循环了。

        fis.read(buf);

        System.out.println(new String(buf));

        fis.close();
    }


    public static void readFile_2()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,len));
        }

        fis.close();

    }



    public static void readFile_1()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        int ch = 0;

        while((ch=fis.read())!=-1)
        {
            System.out.println((char)ch);
        }

        fis.close();
    }

    public static void writeFile()throws IOException
    {
        FileOutputStream fos = new FileOutputStream("fos.txt");


        fos.write("abcde".getBytes());

        fos.close();


    }
}
一个复制图片的demo
复制一个图片
思路：
1，用字节读取流对象和图片关联。
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3，通过循环读写，完成数据的存储。
4，关闭资源。

import java.io.*;
class  CopyPic
{
    public static void main(String[] args) 
    {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try
        {
            fos = new FileOutputStream("c:\\2.bmp");
            fis = new FileInputStream("c:\\1.bmp");

            byte[] buf = new byte[1024];

            int len = 0;

            while((len=fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("复制文件失败");
        }
        finally
        {
            try
            {
                if(fis!=null)
                    fis.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(fos!=null)
                    fos.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}
一个复制mp3的demo
/*
演示mp3的复制。通过缓冲区。
BufferedOutputStream
BufferedInputStream


*/
import java.io.*;
class  CopyMp3
{
    public static void main(String[] args) throws IOException
    {
        long start = System.currentTimeMillis();
        copy_2();
        long end = System.currentTimeMillis();

        System.out.println((end-start)+"毫秒");
    }

    public static void copy_2()throws IOException
    {
        MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("c:\\9.mp3"));
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\3.mp3"));

        int by = 0;

        //System.out.println("第一个字节:"+bufis.myRead());

        while((by=bufis.myRead())!=-1)
        {
            bufos.write(by);
        }

        bufos.close();
        bufis.myClose();
    }

    //通过字节流的缓冲区完成复制。
    public static void copy_1()throws IOException
    {
        BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));

        int by = 0;

        while((by=bufis.read())!=-1)
        {
            bufos.write(by);
        }

        bufos.close();
        bufis.close();


    }
}
读取键盘的录入
读取键盘录入。
System.out:对应的是标准输出设备，控制台。
System.in:对应的标准输入设备：键盘。


需求：
通过键盘录入数据。
当录入一行数据后，就将该行数据进行打印。
如果录入的数据是over，那么停止录入。
import java.io.*;
class  ReadIn
{
    public static void main(String[] args) throws IOException
    {
        InputStream in = System.in;
        StringBuilder sb = new StringBuilder();

        while(true)
        {
            int ch = in.read();
            if(ch=='\r')
                continue;
            if(ch=='\n')
            {
                String s = sb.toString();
                if("over".equals(s))
                    break;
                System.out.println(s.toUpperCase());
                sb.delete(0,sb.length());
            }
            else
                sb.append((char)ch);

        }
    }
}
字符转换流
字符流：
FileReader
FileWriter。

BufferedReader
BufferedWriter

字节流：
FileInputStream
FileOutputStream

BufferedInputStream
BufferedOutputStream

通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
也就是readLine方法。
能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
readLine方法是字符流BufferedReader类中的方法。
而键盘录入的read方法是字节流InputStream的方法。
那么能不能将字节流转成字符流在使用字符流缓冲去的readLine方法呢？
import java.io.*;

class  TransStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        //获取键盘录入对象。
        //InputStream in = System.in;

        //将字节流对象转成字符流对象，使用转换流。InputStreamReader
        //InputStreamReader isr = new InputStreamReader(in);

        //为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

        //BufferedReader bufr = new BufferedReader(isr);


        //键盘的最常见写法。
        BufferedReader bufr = 
                new BufferedReader(new InputStreamReader(System.in));






//      OutputStream out = System.out;
//      OutputStreamWriter osw = new OutputStreamWriter(out);
//      BufferedWriter bufw = new BufferedWriter(osw);
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));




        String line = null;

        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }

        bufr.close();

    }
}
转换流思维模型
1,
源：键盘录入。
目的：控制台。

2，需求：想把键盘录入的数据存储到一个文件中。
源：键盘。
目的：文件。

3，需求：想要将一个文件的数据打印在控制台上。
源：文件。
目的：控制台。

流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪一个。

通过三个明确来完成。

1，明确源和目的。
    源：输入流。InputStream  Reader
    目的：输出流。OutputStream  Writer。
2，操作的数据是否是纯文本。
    是：字符流。
    不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。
    通过设备来进行区分：
    源设备：内存，硬盘。键盘
    目的设备：内存，硬盘，控制台。


1，将一个文本文件中数据存储到另一个文件中。复制文件。
    源：因为是源，所以使用读取流。InputStream Reader 
    是不是操作文本文件。
    是！这时就可以选择Reader
    这样体系就明确了。

    接下来明确要使用该体系中的哪个对象。
    明确设备：硬盘。上一个文件。
    Reader体系中可以操作文件的对象是 FileReader

    是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.


    FileReader fr = new FileReader("a.txt");
    BufferedReader bufr = new BufferedReader(fr);




    目的：OutputStream Writer
    是否是纯文本。
    是！Writer。
    设备：硬盘，一个文件。
    Writer体系中可以操作文件的对象FileWriter。
    是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter

    FileWriter fw = new FileWriter("b.txt");
    BufferedWriter bufw = new BufferedWriter(fw);


练习：将一个图片文件中数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。


---------------------------------------

2，需求：将键盘录入的数据保存到一个文件中。
    这个需求中有源和目的都存在。
    那么分别分析
    源：InputStream Reader
    是不是纯文本？是！Reader

    设备：键盘。对应的对象是System.in.
    不是选择Reader吗？System.in对应的不是字节流吗？
    为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
    所以既然明确了Reader，那么就将System.in转换成Reader。
    用了Reader体系中转换流,InputStreamReader

    InputStreamReader isr = new InputStreamReader(System.in);

    需要提高效率吗？需要！BufferedReader
    BufferedReader bufr = new BufferedReader(isr);



    目的：OutputStream  Writer
    是否是存文本？是！Writer。
    设备：硬盘。一个文件。使用 FileWriter。
    FileWriter fw = new FileWriter("c.txt");
    需要提高效率吗？需要。
    BufferedWriter bufw = new BufferedWriter(fw);


    **************
    扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。

    目的：OutputStream  Writer
    是否是存文本？是！Writer。
    设备：硬盘。一个文件。使用 FileWriter。
    但是FileWriter是使用的默认编码表。GBK.

    但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
    所以要使用的对象是OutputStreamWriter。
    而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream

    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

    需要高效吗？需要。
    BufferedWriter bufw = new BufferedWriter(osw);

    所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，
    需要用到转换流。


练习：将一个文本数据打印在控制台上。要按照以上格式自己完成三个明确。

class  TransStreamDemo2
{
    public static void main(String[] args) throws IOException
    {
        System.setIn(new FileInputStream("PersonDemo.java"));

        System.setOut(new PrintStream("zzz.txt"));

        //键盘的最常见写法。
        BufferedReader bufr = 
                new BufferedReader(new InputStreamReader(System.in));


        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

        String line = null;

        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }

        bufr.close();

    }
}
打印流
打印流：
该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流：
PrintStream
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream



字符打印流：
PrintWriter
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream
4，字符输出流，Writer。
import java.io.*;

class  PrintStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader bufr = 
            new BufferedReader(new InputStreamReader(System.in));

        PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);

        String line = null;

        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            out.println(line.toUpperCase());
            //out.flush();
        }

        out.close();
        bufr.close();

    }   
}
PipedStream（管道流对象）

import java.io.*;

class Read implements Runnable
{
    private PipedInputStream in;
    Read(PipedInputStream in)
    {
        this.in = in;
    }
    public void run()
    {
        try
        {
            byte[] buf = new byte[1024];

            System.out.println("读取前。。没有数据阻塞");
            int len = in.read(buf);
            System.out.println("读到数据。。阻塞结束");



            String s= new String(buf,0,len);

            System.out.println(s);

            in.close();

        }
        catch (IOException e)
        {
            throw new RuntimeException("管道读取流失败");
        }
    }
}

class Write implements Runnable
{
    private PipedOutputStream out;
    Write(PipedOutputStream out)
    {
        this.out = out;
    }
    public void run()
    {
        try
        {
            System.out.println("开始写入数据，等待6秒后。");
            Thread.sleep(6000);
            out.write("piped lai la".getBytes());
            out.close();
        }
        catch (Exception e)
        {
            throw new RuntimeException("管道输出流失败");
        }
    }
}

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

        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream();
        in.connect(out);

        Read r = new Read(in);
        Write w = new Write(out);
        new Thread(r).start();
        new Thread(w).start();


    }
}
RandomAccessFile
class RandomAccessFileDemo 
{
    public static void main(String[] args) throws IOException
    {
        //writeFile_2();
        //readFile();

        //System.out.println(Integer.toBinaryString(258));

    }

    public static void readFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","r");

        //调整对象中指针。
        //raf.seek(8*1);

        //跳过指定的字节数
        raf.skipBytes(8);

        byte[] buf = new byte[4];

        raf.read(buf);

        String name = new String(buf);

        int age = raf.readInt();


        System.out.println("name="+name);
        System.out.println("age="+age);

        raf.close();


    }

    public static void writeFile_2()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
        raf.seek(8*0);
        raf.write("周期".getBytes());
        raf.writeInt(103);

        raf.close();
    }

    public static void writeFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

        raf.write("李四".getBytes());
        raf.writeInt(97);
        raf.write("王五".getBytes());
        raf.writeInt(99);

        raf.close();
    }
}
操作基本数据类型流DataInputStream与DataOutputStream
import java.io.*;
class DataStreamDemo 
{
    public static void main(String[] args) throws IOException
    {
        //writeData();
        //readData();

        //writeUTFDemo();

//      OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
//
//      osw.write("你好");
//      osw.close();

//      readUTFDemo();

    }
    public static void readUTFDemo()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));

        String s = dis.readUTF();

        System.out.println(s);
        dis.close();
    }



    public static void writeUTFDemo()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));

        dos.writeUTF("你好");

        dos.close();
    }

    public static void readData()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

        int num = dis.readInt();
        boolean b = dis.readBoolean();
        double d = dis.readDouble();

        System.out.println("num="+num);
        System.out.println("b="+b);
        System.out.println("d="+d);

        dis.close();
    }
    public static void writeData()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

        dos.writeInt(234);
        dos.writeBoolean(true);
        dos.writeDouble(9887.543);

        dos.close();

        ObjectOutputStream oos = null;
        oos.writeObject(new O());


    }
}
/*
DataInputStream与DataOutputStream

可以用于操作基本数据类型的数据的流对象。

*/
import java.io.*;
class DataStreamDemo 
{
    public static void main(String[] args) throws IOException
    {
        //writeData();
        //readData();

        //writeUTFDemo();

//      OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
//
//      osw.write("你好");
//      osw.close();

//      readUTFDemo();

    }
    public static void readUTFDemo()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));

        String s = dis.readUTF();

        System.out.println(s);
        dis.close();
    }



    public static void writeUTFDemo()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));

        dos.writeUTF("你好");

        dos.close();
    }

    public static void readData()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

        int num = dis.readInt();
        boolean b = dis.readBoolean();
        double d = dis.readDouble();

        System.out.println("num="+num);
        System.out.println("b="+b);
        System.out.println("d="+d);

        dis.close();
    }
    public static void writeData()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

        dos.writeInt(234);
        dos.writeBoolean(true);
        dos.writeDouble(9887.543);

        dos.close();

        ObjectOutputStream oos = null;
        oos.writeObject(new O());


    }
}
ByteArrayStream
import java.io.*;
class ByteArrayStream 
{
    public static void main(String[] args) 
    {
        //数据源。
        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());

        //数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        int by = 0;

        while((by=bis.read())!=-1)
        {
            bos.write(by);
        }



        System.out.println(bos.size());
        System.out.println(bos.toString());

    //  bos.writeTo(new FileOutputStream("a.txt"));

    }
}
Thingvellir
关注
专栏目录
libgfapi-java-io:libgfapi的Java绑定，类似于java.io
05-13
libgfapi-java-io libgfapi的Java 1.4+绑定，类似于具有Maven支持的java.io。 要构建，请运行./build-maven.sh 要测试（junit / maven），请运行./test.sh
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
Java-IO.rar_java IO
09-24
Java IO 是Java编程语言中处理输入/输出操作的重要部分，它允许程序与各种类型的设备（如硬盘、网络、内存等）进行数据交换。在给定的"Java-IO.rar_java IO"主题中，有两个主要的知识点：文件拷贝和序列化。 首先，...
test java-io
最新发布
06-11
test java-io
java-IO.rar_io_java IO
09-21
Java IO（Input/Output）是Java编程语言中用于处理输入和输出操作的重要组成部分。它提供了丰富的类库，使得开发者能够高效地读写数据，不论是来自硬盘、网络、内存还是其他类型的输入输出源。本资料“java-IO.rar”...
JAVA-Map
Thingvellir的博客
10-03 3109
JAVA-Map 生命苦短，只是美德能将它传到遥远的后世。——莎士比亚 关于Map集合的综述 Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。 1，添加。 put(K key, V value) putAll(Map<? extends K,? extends V> m) 2，删除。 clear()
JAVA-自定义异常/异常覆盖
Thingvellir的博客
09-30 2108
JAVA-自定义异常 良心是一种内心的感觉，是对于躁动于我们体内的某种异常愿望的抵制。 —— 弗洛伊德 一个自定义异常的demo/* 因为项目中会出现特有的问题， 而这些问题并未被java所描述并封装对象。 所以对于这些特有的问题可以按照java的对问题封装的思想。 将特有的问题。进行自定义的异常封装。自定义异常。需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。 那么就需要对这
JAVA-集合工具类
Thingvellir的博客
10-04 1076
JAVA-集合工具类 一个伟大的灵魂，会强化思想和生命。——爱默生 Collections工具类集合框架的工具类。 Collections:集合框架的工具类。里面定义的都是静态方法。Collections和Collection有什么区别？ Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。 它有两个常用的子接口， List：对元素都有
JAVA-正则表达式
Thingvellir的博客
10-05 1039
JAVA-正则表达式 人生真正的快乐，在于能对一个事业有所贡献，而自己认识到这是个伟大的事业。——萧伯纳 正则表达式综述正则表达式:符合一定规则的表达式。 作用：用于专门操作字符串。 特点：用于一些特定的符号来表示一些代码操作。这样就简化书写。 所以学习正则表达式，就是在学习一些特殊符号的使用。 好处：可以简化对字符串的复杂操作。 弊端：符号定义越多，正则越
JAVA-网络编程
Thingvellir的博客
10-04 1019
JAVA-网络编程 金玉其外，败絮其中。——刘基 获取制定的IP地址import java.net.*;class IPDemo { public static void main(String[] args) throws Exception { //InetAddress i = InetAddress.getLocalHost();// Syst
JAVA-泛型
Thingvellir的博客
10-03 914
JAVA-泛型 你热爱生命吗？那么别浪费时间，因为时间是构成生命的材料。——富兰克林 关于泛型在集合当中的运用泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。 好处 1.将运行时期出现问题ClassCastException，转移到了编译时期。， 方便于程序员解决问题。让运行时问题减少，安全。， 2，避免了强制转换麻烦。 泛型格式：通过<>来定义要操作的引用数
JAVA-集合概述/List
Thingvellir的博客
10-03 886
JAVA-集合 谁若游戏人生，他就一事无成；谁不能主宰自己，便永远是一个奴隶。——歌德 集合框架Vector迭代器/* 枚举就是Vector特有的取出方式。 发现枚举和迭代器很像。 其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。 所以被迭代器取代了。 枚举郁郁而终了。*/ class VectorDemo { public static void main(String[
JAVA-File
Thingvellir的博客
10-04 646
JAVA-File 合理安排时间，就等于节约时间。——培根 File（文件）类的常见方法File类常见方法： 1，创建。 boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。 和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。 boolean mkdir(
JAVA-零碎知识点
Thingvellir的博客
09-26 604
JAVA-零碎知识点 你若要喜爱你自己的价值，你就得给世界创造价值。——歌德 函数的重载 什么时候用重载？ 当定义的功能相同，但参与运算的未知内容不同。 那么，这时就定义一个函数名称以表示起功能，方便阅读，而通过参数列表的不同来区分多个同名函数。 /*void show(int a,char b,double c){}a. void show(int x,char y,double z){}
JAVA-增强for循环
Thingvellir的博客
10-04 579
JAVA-增强for循环 世界上只有一种英雄主义，那就是了解生命而且热爱生命的人。——罗曼·罗兰 增强for循环综述 格式： for(数据类型 变量名 : 被遍历的集合(Collection)或者数组) { } 对集合进行遍历。 只能获取集合元素。但是不能对集合进行操作。 迭代器除了遍历，还可以进行remove集合中元素的动作。 如果是用ListIterator，还可以在遍历过程中对集合
JAVA-集合SET
Thingvellir的博客
10-03 575
JAVA-集合SET 等到自私的幸福变成了人生唯一的目标之后，不久人生就变得没有目标。——罗曼.罗兰 SET综述Set:无序，不可以重复元素。 |--HashSet：数据结构是哈希表。线程是非同步的。 保证元素唯一性的原理：判断元素的hashCode值是否相同。 如果相同，还会继续判断元素的equals方法，是否为true。
JAVA-SYSTEM/RUNTIME/DATE/CALENDAR
Thingvellir的博客
10-04 534
JAVA-SYSTEM/RUNTIME/DATE/CALENDAR 世界上最快而又最慢，最长而又最短，最平凡而又最珍贵，最易被忽视而又最令人后悔的就是时间。——高尔基 System类/* System:类中的方法和属性都是静态的。 out:标准输出，默认是控制台。 in：标准输入，默认是键盘。 描述系统一些信息。获取系统属性信息：Properties getProperties(); */ im
JAVA-Properties
Thingvellir的博客
10-04 521
JAVA-Properties 人只能有献身社会，才能找出那实际上是短暂而有风险的生命的意义。——爱因斯坦 Properties综述Properties是hashtable的子类。 也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。是集合中和IO技术相结合的集合容器。该对象的特点：可以用于键值对形式的配置文件。那么在加载数据时，需要数据有固定格式：键=值。一个小Demoimpor
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值