精华内容
下载资源
问答
  • 1 Java IO 概述

    2017-11-01 15:39:42
    1 Java IO 概述

    Java IO 主要关注:
    1. 从原始数据源中读取数据
    2. 输出原始数据到目标媒介

    典型的数据源和目标媒介包括:
    1. 文件
    2. 管道
    3. 网络连接
    4. 内存缓存
    5. System.in, System.out, System.error (Java标准输入、输出、错误输出)

    注意:对输入和输出的理解:
    1. 输入流可以理解为向内存输入
    2. 输出流可以理解为从内存输出

    在 Java IO 中,【】是一个核心概念。概念上来说是一个连续的数据流,既可以从流中读取数据,也可以向流中写入数据,流与数据源或数据流向的媒介相关联。

    在 Java IO 中,流既可以是字节流(以字节为单位进行读写),也可以是字符流(以字符为单位进行读写)。

    Java IO 中 InputStream 和 Reader 从数据源中读取数据,OutputStream 和 Writer 将数据写入到目标媒介中,即 InputStream 和 Reader 与数据源相关联,OutputStream 和 Writer 与目标媒介相关联。

    Java IO 中定义的 InputStream / OutputStream / Reader / Writer 的子类分别用于:
    1. 文件访问
    2. 网络访问
    3. 内存缓存访问
    4. 线程内部通信(管道)
    5. 缓冲
    6. 过滤
    7. 解析
    8. 读写文本
    9. 读写基本类型数据
    10. 读写对象

    不同子类用途参考下表:
    这里写图片描述

    展开全文
  • Java io概述

    2017-09-25 16:13:00
    Java IO 概述 输入流可以理解为向内存输入,输出流可以理解为从内存输出 Java的IO包主要关注的是从原始数据源的读取以及输出原始数据到目标媒介。以下是最典型的数据源和目标媒介: 文件 管道 网络连接 内存...

    内容来源:http://ifeve.com/java-io/

    Java IO 概述

    输入流可以理解为向内存输入,输出流可以理解为从内存输出

    Java的IO包主要关注的是从原始数据源的读取以及输出原始数据到目标媒介。以下是最典型的数据源和目标媒介:

    • 文件
    • 管道
    • 网络连接
    • 内存缓存
    • System.in, System.out, System.error(注:Java标准输入、输出、错误输出)

     

    Java IO的用途和特征

    Java IO中包含了许多InputStream、OutputStream、Reader、Writer的子类。这样设计的原因是让每一个类都负责不同的功能。这也就是为什么IO包中有这么多不同的类的缘故。各类用途汇总如下:

    • 文件访问
    • 网络访问
    • 内存缓存访问
    • 线程内部通信(管道)
    • 缓冲
    • 过滤
    • 解析
    • 读写文本 (Readers / Writers)
    • 读写基本类型数据 (long, int etc.)
    • 读写对象

     

    Java IO类概述表

     

     

    Java IO: InputStream

    read()

    read()方法返回从InputStream流内读取到的一个字节内容

    InputStream包含了2个从InputStream中读取数据并将数据存储到缓冲数组中的read()方法,他们分别是:

    • int read(byte[])
    • int read(byte, int offset, int length)

    一次性读取一个字节数组的方式,比一次性读取一个字节的方式快的多,所以,尽可能使用这两个方法代替read()方法。

     

    Java IO: OutputStream

    Write(byte)

    write(byte)方法用于把单个字节写入到输出流中。

     

    write(byte[])

    OutputStream同样包含了将字节数据中全部或者部分数据写入到输出流中的方法,分别是write(byte[])和write(byte[], int offset, int length)。

    write(byte[])把字节数组中所有数据写入到输出流中。

    write(byte[], int offset, int length)把字节数据中从offset位置开始,length个字节的数据写入到输出流。

     

    flush()

    OutputStream的flush()方法将所有写入到OutputStream的数据冲刷到相应的目标媒介中。比如,如果输出流是FileOutputStream,那么写入到其中的数据可能并没有真正写入到磁盘中。即使所有数据都写入到了FileOutputStream,这些数据还是有可能保留在内存的缓冲区中。通过调用flush()方法,可以把缓冲区内的数据刷新到磁盘(或者网络,以及其他任何形式的目标媒介)中。

     

    Java IO: FileInputStream

    FileInputStream可以以字节流的形式读取文件内容。

    // FileInputStream是InputStream的子类,这意味着你可以把FileInputStream当做InputStream使用(FileInputStream与InputStream的行为类似)。
    InputStream input = new FileInputStream("c:\\data\\input-text.txt");
    File file = new File("c:\\data\\input-text.txt");
    // 其中一个FileInputStream构造函数取一个File对象替代String对象作为参数。这里是一个使用该构造函数的例子:
    InputStream input = new FileInputStream(file);

     

    Java IO: FileOutputStream

    FileOutputStream可以往文件里写入字节流

    文件内容的覆盖Override VS追加Appending

    当你创建了一个指向已存在文件的FileOutputStream,你可以选择覆盖整个文件,或者在文件末尾追加内容。通过使用不同的构造函数可以实现不同的目的。

    // 其中一个构造函数取文件名作为参数,会覆盖任何此文件名指向的文件。
    OutputStream output = new FileOutputStream("c:\\data\\output-text.txt");
    // 另外一个构造函数取2个参数:文件名和一个布尔值,布尔值表明你是否需要覆盖文件。这是构造函数的例子:
    OutputStream output = new FileOutputStream("c:\\data\\output-text.txt", true); //appends to file
    OutputStream output = new FileOutputStream("c:\\data\\output-text.txt", false); //overwrites file

     

    Java IO: Reader And Writer

    Java IO的Reader和Writer除了基于字符之外,其他方面都与InputStream和OutputStream非常类似。他们被用于读写文本。

    Reader类是Java IO中所有Reader的基类。子类包括BufferedReader,PushbackReader,InputStreamReader,StringReader和其他Reader。

    Reader reader = new FileReader("c:\\data\\myfile.txt");

    Writer类是Java IO中所有Writer的基类。子类包括BufferedWriter和PrintWriter等等。

    Writer writer = new FileWriter("c:\\data\\file-output.txt"); 

     

    整合Reader与InputStream

    一个Reader可以和一个InputStream相结合。如果你有一个InputStream输入流,并且想从其中读取字符,可以把这个InputStream包装到InputStreamReader中。

    // InputStream传递到InputStreamReader的构造函数中:
    Reader reader = new InputStreamReader(inputStream);

     

    整合Writer和OutputStream

    与Reader和InputStream类似,一个Writer可以和一个OutputStream相结合。把OutputStream包装到OutputStreamWriter中,所有写入到OutputStreamWriter的字符都将会传递给OutputStream。

    Writer writer = new OutputStreamWriter(outputStream);

     

    整合Reader和Writer

    和字节流一样,Reader和Writer可以相互结合实现更多更有趣的IO,工作原理和把Reader与InputStream或者Writer与OutputStream相结合类似。举个栗子,可以通过将Reader包装到BufferedReader、Writer包装到BufferedWriter中实现缓冲。

    Reader reader = new BufferedReader(new FileReader(...));
    Writer writer = new BufferedWriter(new FileWriter(...));

     

    Java IO: RandomAccessFile

    创建一个RandomAccessFile

    // 在使用RandomAccessFile之前,必须初始化它。这是例子:
    RandomAccessFile file = new RandomAccessFile("c:\\data\\file.txt", "rw");
    // 请注意构造函数的第二个参数:“rw”,表明你以读写方式打开文件。请查阅Java文档获知你需要以何种方式构造RandomAccessFile。

     

    在RandomAccessFile中来回读写

    在RandomAccessFile的某个位置读写之前,必须把文件指针指向该位置。通过seek()方法可以达到这一目标。可以通过调用getFilePointer()获得当前文件指针的位置。

    RandomAccessFile file = new RandomAccessFile("c:\\data\\file.txt", "rw");
    file.seek(200);
    long pointer = file.getFilePointer();
    file.close();

    RandomAccessFile中的任何一个read()方法都可以读取RandomAccessFile的数据。

    RandomAccessFile中的任何一个write()方法都可以往RandomAccessFile中写入数据。

    转载于:https://www.cnblogs.com/ooo0/p/7592399.html

    展开全文
  • java io 概述

    2019-09-12 17:25:03
    一、java io 概述 1.1 相关概念 Java IO Java IO即Java 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要...

    一、java io 概述

    1.1 相关概念

    Java IO

    Java IO即Java 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要考虑和哪种媒介进行IO(文件、控制台、网络),我们还要考虑具体和它们的通信方式(顺序、随机、二进制、按字符、按字、按行等等)。Java类库的设计者通过设计大量的类来攻克这些难题,这些类就位于java.io包中。

    在JDK1.4之后,为了提高Java IO的效率,Java又提供了一套新的IO,Java New IO简称Java NIO。它在标准java代码中提供了高速的面向块的IO操作。本篇文章重点介绍Java IO,关于Java NIO请参考我的另两篇文章: 
    Java NIO详解(一) 
    Java NIO详解(二)

    在Java IO中,流是一个核心的概念。流从概念上来说是一个连续的数据流。你既可以从流中读取数据,也可以往流中写数据。流与数据源或者数据流向的媒介相关联。在Java IO中流既可以是字节流(以字节为单位进行读写),也可以是字符流(以字符为单位进行读写)。

    IO相关的媒介

    Java的IO包主要关注的是从原始数据源的读取以及输出原始数据到目标媒介。以下是最典型的数据源和目标媒介:

    • 文件
    • 管道
    • 网络连接
    • 内存缓存
    • System.in, System.out, System.error(注:Java标准输入、输出、错误输出)

    二、Java IO类库的框架

    2.1 Java IO的类型

    虽然java IO类库庞大,但总体来说其框架还是很清楚的。从是读媒介还是写媒介的维度看,Java IO可以分为:

    1. 输入流:InputStream和Reader
    2. 输出流:OutputStream和Writer

    而从其处理流的类型的维度上看,Java IO又可以分为:

    1. 字节流:InputStream和OutputStream
    2. 字符流:Reader和Writer

    下面这幅图就清晰的描述了JavaIO的分类:

    - 字节流 字符流
    输入流 InputStream Reader
    输出流 OutputStream Writer

    我们的程序需要通过InputStream或Reader从数据源读取数据,然后用OutputStream或者Writer将数据写入到目标媒介中。其中,InputStream和Reader与数据源相关联,OutputStream和writer与目标媒介相关联。 以下的图说明了这一点:

    这里写图片描述

    2.2 IO 类库

    上面我们介绍了Java IO中的四各类:InputStream、OutputStream、Reader、Writer,其实在我们的实际应用中,我们用到的一般是它们的子类,之所以设计这么多子类,目的就是让每一个类都负责不同的功能,以方便我们开发各种应用。各类用途汇总如下:

    • 文件访问
    • 网络访问
    • 内存缓存访问
    • 线程内部通信(管道)
    • 缓冲
    • 过滤
    • 解析
    • 读写文本 (Readers / Writers)
    • 读写基本类型数据 (long, int etc.)
    • 读写对象

    下面我们就通过两张图来大体了解一下这些类的继承关系及其作用

    图1:java io 类的集成关系

    这里写图片描述

    图2:java io中各个类所负责的媒介

    这里写图片描述

    三、Java IO的基本用法

    3.1 Java IO :字节流

    通过上面的介绍我们已经知道,字节流对应的类应该是InputStreamOutputStream,而在我们实际开发中,我们应该根据不同的媒介类型选用相应的子类来处理。下面我们就用字节流来操作文件媒介:

    例1,用字节流写文件

      public static void writeByteToFile() throws IOException{
            String hello= new String( "hello word!");
             byte[] byteArray= hello.getBytes();
            File file= new File( "d:/test.txt");
             //因为是用字节流来写媒介,所以对应的是OutputStream 
             //又因为媒介对象是文件,所以用到子类是FileOutputStream
            OutputStream os= new FileOutputStream( file);
             os.write( byteArray);
             os.close();
      }
    

    例2,用字节流读文件

    public static void readByteFromFile() throws IOException{
            File file= new File( "d:/test.txt");
             byte[] byteArray= new byte[( int) file.length()];
             //因为是用字节流来读媒介,所以对应的是InputStream
             //又因为媒介对象是文件,所以用到子类是FileInputStream
            InputStream is= new FileInputStream( file);
             int size= is.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             is.close();
      }
    

    3.2 Java IO :字符流

    同样,字符流对应的类应该是ReaderWriter。下面我们就用字符流来操作文件媒介:

    例3,用字符流读文件

    public static void writeCharToFile() throws IOException{
            String hello= new String( "hello word!");
            File file= new File( "d:/test.txt");
             //因为是用字符流来读媒介,所以对应的是Writer,又因为媒介对象是文件,所以用到子类是FileWriter
            Writer os= new FileWriter( file);
             os.write( hello);
             os.close();
      }
    

    例4,用字符流写文件

      public static void readCharFromFile() throws IOException{
            File file= new File( "d:/test.txt");
             //因为是用字符流来读媒介,所以对应的是Reader
             //又因为媒介对象是文件,所以用到子类是FileReader
            Reader reader= new FileReader( file);
             char [] byteArray= new char[( int) file.length()];
             int size= reader.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             reader.close();
      }
    

    3.3 Java IO :字节流转换为字符流

    字节流可以转换成字符流,java.io包中提供的InputStreamReader类就可以实现,当然从其命名上就可以看出它的作用。其实这涉及到另一个概念,IO流的组合,后面我们详细介绍。下面看一个简单的例子:

    例5 ,字节流转换为字符流

    public static void convertByteToChar() throws IOException{
            File file= new File( "d:/test.txt");
             //获得一个字节流
            InputStream is= new FileInputStream( file);
             //把字节流转换为字符流,其实就是把字符流和字节流组合的结果。
            Reader reader= new InputStreamReader( is);
             char [] byteArray= new char[( int) file.length()];
             int size= reader.read( byteArray);
            System. out.println( "大小:"+size +";内容:" +new String(byteArray));
             is.close();
             reader.close();
      }
    

    3.4 Java IO :IO类的组合

    从上面字节流转换成字符流的例子中我们知道了IO流之间可以组合(或称嵌套),其实组合的目的很简单,就是把多种类的特性融合在一起以实现更多的功能。组合使用的方式很简单,通过把一个流放入另一个流的构造器中即可实现,两个流之间可以组合,三个或者更多流之间也可组合到一起。当然,并不是任意流之间都可以组合。关于组合就不过多介绍了,后面的例子中有很多都用到了组合,大家好好体会即可。

    3.5 Java IO:文件媒介操作

    File是Java IO中最常用的读写媒介,那么我们在这里就对文件再做进一步介绍。

    3.5.1 File媒介

    例6 ,File操作

    public class FileDemo {
      public static void main(String[] args) {
             //检查文件是否存在
            File file = new File( "d:/test.txt");
             boolean fileExists = file.exists();
            System. out.println( fileExists);
             //创建文件目录,若父目录不存在则返回false
            File file2 = new File( "d:/fatherDir/subDir");
             boolean dirCreated = file2.mkdir();
            System. out.println( dirCreated);
             //创建文件目录,若父目录不存则连同父目录一起创建
            File file3 = new File( "d:/fatherDir/subDir2");
             boolean dirCreated2 = file3.mkdirs();
            System. out.println( dirCreated2);
            File file4= new File( "d:/test.txt");
             //判断长度
             long length = file4.length();
             //重命名文件
             boolean isRenamed = file4.renameTo( new File("d:/test2.txt"));
             //删除文件
             boolean isDeleted = file4.delete();
            File file5= new File( "d:/fatherDir/subDir");
             //是否是目录
             boolean isDirectory = file5.isDirectory();
             //列出文件名
            String[] fileNames = file5.list();
             //列出目录
            File[]   files = file4.listFiles();
      }
    

    }

    3.5.3 随机读取File文件

    通过上面的例子我们已经知道,我们可以用FileInputStream(文件字符流)或FileReader(文件字节流)来读文件,这两个类可以让我们分别以字符和字节的方式来读取文件内容,但是它们都有一个不足之处,就是只能从文件头开始读,然后读到文件结束。

    但是有时候我们只希望读取文件的一部分,或者是说随机的读取文件,那么我们就可以利用RandomAccessFile。RandomAccessFile提供了seek()方法,用来定位将要读写文件的指针位置,我们也可以通过调用getFilePointer()方法来获取当前指针的位置,具体看下面的例子:

    例7,随机读取文件

      public static void randomAccessFileRead() throws IOException {
             // 创建一个RandomAccessFile对象
            RandomAccessFile file = new RandomAccessFile( "d:/test.txt", "rw");
             // 通过seek方法来移动读写位置的指针
             file.seek(10);
             // 获取当前指针
             long pointerBegin = file.getFilePointer();
             // 从当前指针开始读
             byte[] contents = new byte[1024];
             file.read( contents);
             long pointerEnd = file.getFilePointer();
            System. out.println( "pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n" + new String(contents));
             file.close();
      }
    

    例8,随机写入文件

      public static void randomAccessFileWrite() throws IOException {
             // 创建一个RandomAccessFile对象
            RandomAccessFile file = new RandomAccessFile( "d:/test.txt", "rw");
             // 通过seek方法来移动读写位置的指针
             file.seek(10);
             // 获取当前指针
             long pointerBegin = file.getFilePointer();
             // 从当前指针位置开始写
             file.write( "HELLO WORD".getBytes());
             long pointerEnd = file.getFilePointer();
            System. out.println( "pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n" );
             file.close();
      }
    

    3.6 Java IO:管道媒介

    管道主要用来实现同一个虚拟机中的两个线程进行交流。因此,一个管道既可以作为数据源媒介也可作为目标媒介。

    需要注意的是java中的管道和Unix/Linux中的管道含义并不一样,在Unix/Linux中管道可以作为两个位于不同空间进程通信的媒介,而在java中,管道只能为同一个JVM进程中的不同线程进行通信。和管道相关的IO类为:PipedInputStreamPipedOutputStream,下面我们来看一个例子:

    例9,读写管道

     

    3.7 Java IO:网络媒介

    关于Java IO面向网络媒介的操作即Java 网络编程,其核心是Socket,同磁盘操作一样,java网络编程对应着两套API,即Java IO和Java NIO,关于这部分我会准备专门的文章进行介绍。

    3.8 Java IO:BufferedInputStream和BufferedOutputStream

    BufferedInputStream顾名思义,就是在对流进行写入时提供一个buffer来提高IO效率。在进行磁盘或网络IO时,原始的InputStream对数据读取的过程都是一个字节一个字节操作的,而BufferedInputStream在其内部提供了一个buffer,在读数据时,会一次读取一大块数据到buffer中,这样比单字节的操作效率要高的多,特别是进程磁盘IO和对大量数据进行读写的时候。

    使用BufferedInputStream十分简单,只要把普通的输入流和BufferedInputStream组合到一起即可。我们把上面的例2改造成用BufferedInputStream进行读文件,请看下面例子:

    例10 ,用缓冲流读文件

      public static void readByBufferedInputStream() throws IOException {
            File file = new File( "d:/test.txt");
             byte[] byteArray = new byte[( int) file.length()];
             //可以在构造参数中传入buffer大小
            InputStream is = new BufferedInputStream( new FileInputStream(file),2*1024);
             int size = is.read( byteArray);
            System. out.println( "大小:" + size + ";内容:" + new String(byteArray));
             is.close();
      }
    

    关于如何设置buffer的大小,我们应根据我们的硬件状况来确定。对于磁盘IO来说,如果硬盘每次读取4KB大小的文件块,那么我们最好设置成这个大小的整数倍。因为磁盘对于顺序读的效率是特别高的,所以如果buffer再设置的大写可能会带来更好的效率,比如设置成4*4KB或8*4KB。

    还需要注意一点的就是磁盘本身就会有缓存,在这种情况下,BufferedInputStream会一次读取磁盘缓存大小的数据,而不是分多次的去读。所以要想得到一个最优的buffer值,我们必须得知道磁盘每次读的块大小和其缓存大小,然后根据多次试验的结果来得到最佳的buffer大小。

    BufferedOutputStream的情况和BufferedInputStream一致,在这里就不多做描述了。

    3.9 Java IO:BufferedReader和BufferedWriter

    BufferedReader、BufferedWriter 的作用基本和BufferedInputStream、BufferedOutputStream一致,具体用法和原理都差不多 ,只不过一个是面向字符流一个是面向字节流。同样,我们将改造字符流中的例4,给其加上buffer功能,看例子:

     public static void readByBufferedReader() throws IOException {
            File file = new File( "d:/test.txt");
             // 在字符流基础上用buffer流包装,也可以指定buffer的大小
            Reader reader = new BufferedReader( new FileReader(file),2*1024);
             char[] byteArray = new char[( int) file.length()];
             int size = reader.read( byteArray);
            System. out.println( "大小:" + size + ";内容:" + new String(byteArray));
             reader.close();
      }

    转载于:https://my.oschina.net/u/3756749/blog/1594670

    展开全文
  • Java IO 概述

    千次阅读 2017-07-16 19:57:47
    Java IO 概述输入和输出 – 数据源和目标媒介术语“输入”和“输出”有时候会有一点让人疑惑。一个应用程序的输入往往是另外一个应用程序的输出。那么OutputStream流到底是一个输出到目的地的流呢,还是一个产生输出...

    Java IO 概述

    (1)输入和输出 – 数据源和目标媒介

    术语“输入”和“输出”有时候会有一点让人疑惑。一个应用程序的输入往往是另外一个应用程序的输出。那么OutputStream流到底是一个输出到目的地的流呢,还是一个产生输出的流?InputStream流到底会不会输出它的数据给读取数据的程序呢?就我个人而言,在第一天学习Java IO的时候我就感觉到了一丝疑惑。(校对注:输入流可以理解为向内存输入,输出流可以理解为从内存输出)

    为了消除这个疑惑,我试着给输入和输出起一些不一样的别名,让它们从概念上与数据的来源和数据的流向相联系。

    Java的IO包主要关注的是从原始数据源的读取以及输出原始数据到目标媒介。以下是最典型的数据源和目标媒介:

    • 文件
    • 管道
    • 网络连接
    • 内存缓存
    • System.in, System.out, System.error(注:Java标准输入、输出、错误输出)

      下面这张图描绘了一个程序从数据源读取数据,然后将数据输出到其他媒介的原理:
      这里写图片描述

    (2)流

    在Java IO中,流是一个核心的概念。流从概念上来说是一个连续的数据流。你既可以从流中读取数据,也可以往流中写数据。流与数据源或者数据流向的媒介相关联。在Java IO中流既可以是字节流(以字节为单位进行读写),也可以是字符流(以字符为单位进行读写)。

    (3)类InputStream, OutputStream, Reader 和Writer

    一个程序需要InputStream或者Reader从数据源读取数据,需要OutputStream或者Writer将数据写入到目标媒介中。以下的图说明了这一点:

    这里写图片描述

    InputStream和Reader与数据源相关联,OutputStream和writer与目标媒介相关联。

    (4)Java IO的用途和特征

    Java IO中包含了许多InputStream、OutputStream、Reader、Writer的子类。这样设计的原因是让每一个类都负责不同的功能。这也就是为什么IO包中有这么多不同的类的缘故。各类用途汇总如下:

    • 文件访问
    • 网络访问
    • 内存缓存访问
    • 线程内部通信(管道)
    • 缓冲
    • 过滤
    • 解析
    • 读写文本 (Readers / Writers)
    • 读写基本类型数据 (long, int etc.)
    • 读写对象

    (5)Java IO类概述表

    已经讨论了数据源、目标媒介、输入、输出和各类不同用途的Java IO类,接下来是一张通过输入、输出、基于字节或者字符、以及其他比如缓冲、解析之类的特定用途划分的大部分Java IO类的表格。

    这里写图片描述

    更多互联网与金融技术精华:http://www.moxianbin.com/

    展开全文
  • java IO概述

    2019-03-11 10:34:20
    一、java io 概述 1.1 相关概念 Java IO Java IO即Java 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要考虑和...
  • 4.1 Java IO概述

    2021-02-18 22:28:44
    IO的含义事Input和Output,不过关于IO是很难定义的,从硬件操作系统层面,IO可以是系统管理的输入输出设备,可以是数据的传入和输出,这是一个比较难定义的点,而此章节只聚焦于java IO,这儿指的IO是相对于java程序...
  • java概述

    2017-07-07 11:16:26
    1:流是什么呢? 流是一个很形象的概念,简单来说呢,大部分的应用程序都需要接受某种形式的数据输入,并产生某种形式的数据输出。当需要读入数据的时候,就...为了对数据进行输入输出操作,java把不同的输入输出源
  • Java IO概述

    2021-03-25 11:45:23
    Java 1.0版本以来,Java的I/O类库发生了明显的改变,在原来面向字节的类中添加了面向字符和基于Unicode编码的类。在Java 1.4中, 添加了nio类以改进性能及功能。因此,有必要学习Java IO。另外,很犹豫必要理解I/O...
  • 一、java io 概述

    2016-10-14 14:27:18
    一、java io 概述 1.1 相关概念 Java IO Java IO即Java 输入输出系统。不管我们编写何种应用,都难免和各种输入输出相关的媒介打交道,其实和媒介进行IO的过程是十分复杂的,这要考虑的因素特别多,比如我们要...
  • Java 8 - 概述

    2019-09-16 06:02:13
    Java 8 - 概述 1 Java 8-概述 2 Java 8 - Lambda表达式 3 Java 8 - 方法引用 4 Java8-Functional Interfaces函数式接口 5 Java 8 - 默认方法 6 Java 8 - Streams 7 Java 8 - Op...
  • Java Nio 由以下几个核心部分组成: *
  • 1 Java IO 概述 java.io 通过数据流、序列化和文件系统提供系统输入和输出。 1.1 输入和输出 – 数据源和目标媒介 ​ 输入和输出经常混淆,疑惑。 输入流:向内存输入 输出流:从内存输出 为了消除这种疑惑,java...
  • 【原创】陌霖Java架构2019-04-15 16:08:54 一、阻塞IO与非阻塞IO 阻塞IO: 通常在进行同步I/O操作时,如果读取数据,代码会阻塞直至有可供读取的数据。同样,写入调用将会阻塞直至数据能够写入。传统的Server/...
  • Socket套接字,它也是java中一个类,由它来实现两台主机的交互、由它搭建起的一个输入输出流的管道;例如:浏览器向服务器发送请求,需要Socket架起输出流管道,而服务器响应浏览器发送的请求,则需要由Socket架起...
  • java之io概述

    2016-10-25 15:22:04
    Java 中使用 “流”(Stream) 的概念来描述数据。Java 中使用流对数据操作的类,位于...数据像水流一样在管道中传输。 2、流具有方向性。 相对于内存而言,流入内存称:InputStream,流出内存称:OutputStream ...
  • Java IO(概述

    2020-06-19 09:43:07
    Java IO 是一套Java用来读写数据(输入和输出)的API。大部分程序都要处理一些输入,并由输入产生一些输出。Java为此提供了java.io包。... 管道 网络连接 内存缓存 System.in, System.out, System.error(注:
  • Java IO流概述

    2021-02-19 22:58:20
    Java程序中,数据的输入、输出操作以“流(stream)” 的 方式进行 I/O是Input/Output的缩写。I/O技术用于处理设备之间的数据传输。如读、写文件、网络通讯等 (1)流的分类 按操作数据单位:字节流(8 bit)、字符流(16...
  • Java IO-01 Java流的概述

    2018-08-23 13:51:00
    Java IO-01 Java流的概述 1 Java IO的概念 Java IO 流是实现输入/输出的基础,它方便的实现数据的输入/输出操作,把 Java 中不同的输入/输出源(键盘、文件、网络连接等)抽象表述为“流”( Stream ),通过流的...
  • JAVA NIO ---Java的NIO概述

    2019-09-15 14:35:29
    Java的NIO包括以下核心组件: 通道 缓冲器 选择器 Java的NIO拥有不止这些类和...部件,象其余管道和的FileLock都与三个核心组件一起使用仅仅工具类。因此,我将专注于这三个组件在这个NIO概述。其他组...
  • Java Transaction API概述

    2011-07-25 11:03:01
    引言 JTA(Java Transaction API)允许应用程序执行分布式事务处理--在两个或多个网络计算机资源上访问并且更新数据。... 本文的目的是要提供一个关于的Java事务处理API(JTA)的高级的概述,以及与分布

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,468
精华内容 4,587
关键字:

java管道概述

java 订阅