精华内容
下载资源
问答
  • 字符串的输入输出处理Java代码)
    千次阅读
    2021-03-11 10:20:04

    解题思路:

    对于前几项,直接原样输出,加空行;对于多出的几项加以处理;

    String类方法中有一个sprilt();的方法,

    例:String s = sc.nextLine();

    String x[] = s.split(" ");

    该方法实现将字符串以空壳为标准分割成几个小的字符串并放入数组中;

    如 s = "asd dfg fgh";

    则x[0] = "asd";x[1] = "dfg";x[2] = "fgh";

    注意事项:

    再按照题目样例输入时;在输入2后的换行,也会被字符串扫描到;

    固利用:String s = sc.nextLine();

    if(i==1)

    continue;

    进行跳过;

    参考代码:import java.util.Scanner;

    public class Main{

    public static void main(String args[]) {

    Scanner sc = new Scanner(System.in);

    int a = sc.nextInt();

    for(int i=1;i<=a+1;i++) {

    String s = sc.nextLine();

    if(i==1)

    continue;

    System.out.println(s+"\n");

    }

    while(sc.hasNext()) {

    String s = sc.nextLine();

    String x[] = s.split(" ");

    for(int i=0;i

    System.out.println(x[i]+"\n");

    }

    }

    }

    }

    更多相关内容
  • Java输入输出

    万次阅读 多人点赞 2018-05-12 15:27:45
    引言:在平时java开发中,被输入输出搞得头疼。特此写下这篇博客,一是为了总结输入输出,二是为了和大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!! 1.输入格式,输出格式控制 1.1输入处理 java的...

    源代码见:点击打开链接

    引言:在平时java开发中,被输入输出搞得头疼。特此写下这篇博客,一是为了总结输入输出,二是为了和大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!!

    1.输入格式,输出格式控制

    1.1输入处理

        java的输入,我们用到Scanner类,可以用它创建一个对象

        Scanner reader=new Scanner(System.in);

        然后reader对象调用nextBoolean(),nextByte(),nextShort(),nextInt(),nextLong(),nextFloat(),nextDouble()方法来从输入流中获取数据。这些方法在执行时都会阻塞,程序等待用户在输入流中输入enter键(\n)时继续执行。这里的nextInt,hasNextInt()这些方法的调用,会判断当前字节流里面是否有东西,没有就阻塞等待输入直到用户按enter键(\n)结束输入,在Scanner类中有一个变量needInput,当需要读取数据时,needInput=true(也就是调用nextInt,hasNextInt()这些函数的时候)。有一个readInput方法,当字节流中有东西可读时,让needInput=false(表示不需要阻塞等待输入);下面是Scanner.class源码:

     // Tries to read more input. May block.
        private void readInput() {
            if (buf.limit() == buf.capacity())
                makeSpace();
    
            // Prepare to receive data
            int p = buf.position();
            buf.position(buf.limit());
            buf.limit(buf.capacity());
    
            int n = 0;
            try {
                n = source.read(buf);//这儿
            } catch (IOException ioe) {
                lastException = ioe;
                n = -1;//这儿
            }
    
            if (n == -1) {
                sourceClosed = true;
                needInput = false;//这儿
            }
    
            if (n > 0)
                needInput = false;/这儿
    
            // Restore current position and limit for reading
            buf.limit(buf.position());
            buf.position(p);
        }
    

        总之,在调用next(),hasNext()方法时,字节流里面有东西,就不用等待,没有东西就阻塞等待。例如:

    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner s=new Scanner(System.in);
    		int a,b;
    		a=s.nextInt();
    		System.out.println(a);
    		b=s.nextInt();
    		System.out.println(b);
    		/*a=s.nextInt();
    		b=s.nextInt();
    		System.out.println(a+"  "+b);*/
    	}

        当在命令行时输入时,我可以这样输入(在一行就输入两个数据再按enter),当运行到b=s.nextInt()时,发现字节流里面有东西,就没有阻塞等待输入了。

        当然我们也可以这样输入(第一行输入2后,按enter键,然后在输入3,再按enter键)。运行过程是这样的,首先,当运行到a=s.nextInput()时发现,字节流里面没东西,等待输入,于是我们在命令行的第一行输入了2,按回车确认,这时程序继续执行。当运行到b=s.nextInt()时,发现字节流里面没东西,则阻塞等待输入,于是我们在命令行第三行输入3,按enter键确认,程序继续执行。

        Scanner 使用分隔符模式将其输入分解为标记,默认情况下该分隔符模式与空白匹配(当然可以自定义分隔符)。

         在下面1.3中我们举一个输入控制实例来熟练输入控制的使用。

     

    1.2 hasNext源码解析

    首先我们分输入源是System.in(也就是控制台),和从文件中读取(FileInputStream)。

    (1)对于System.in,不管如何都是要返回true的。我们看源码:

            /*这是测试代码*/
            Scanner scanner=new Scanner(System.in);
    
    
            while (scanner.hasNext()){
                System.out.println(scanner.next());
            }

     我们进入hasNext()函数

    
    public boolean hasNext() {
            ensureOpen();
            saveState();
            while (!sourceClosed) {
                /*看buffer里面是否有东西,有就返回ture*/
                if (hasTokenInBuffer())
                    return revertState(true);
                
                /*没有就从System.in中读入数据。该方法可能会阻塞*/
                readInput();
            }
            
            /*对于从控制台中读入数据,这两句代码是永远不会被执行的。相当于从控制台读入数据永远不会结束,sourceClosed永远为false*/
            boolean result = hasTokenInBuffer();
            return revertState(result);
    }

    (2) 从文件中读取(FileInputStream)

     Scanner scanner1=new Scanner(new FileInputStream("/home/fengli/a.txt"));
    
     while (scanner1.hasNext()){
           System.out.println(scanner1.next());
     }

     在进入hasNext()方法:

    public boolean hasNext() {
            ensureOpen();
            saveState();
            while (!sourceClosed) {
                /*看buffer里面是否有东西,有就返回ture*/
                if (hasTokenInBuffer())
                    return revertState(true);
                
                /*没有就从System.in中读入数据。该方法可能会阻塞*/
                readInput();
            }
            
            /*用文件中读取,sourceClosed就可能为ture。所以这个方法就可以返回false*/
            boolean result = hasTokenInBuffer();
            return revertState(result);
    }

     

    1.3 输出处理

        可用System.out.println()或System.out.print()来向屏幕进行输出。jdk1.5新增了和C语言中printf函数类似的数据输出方法,

    System.out.printf(“格式控制部分”,表达式1,表达式2,……,表达式n)

        格式控制部分由格式控制符号:%d,%c,%f,%s和普通字符组成,普通字符原样输出。格式控制符用来输出表达式的值。

        %d:输出int类型数据值

        %c:输出char类型数据

        %f:输出浮点型数据,小数点部分最多保留6位

        %s:输出字符串数据

        %md:输出int型数据占m列

        %m.nf:输出的浮点型数据占m列,小数点保留n位

    格式字符串语法:

        每个格式控制以%开始,以空格或标点符号结尾。

        

     

    1.3输入输出实例--读入指定形状,输出指定形状

        实例为输出九九乘法表,源码如下:

    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		for(int i=1;i<=9;i++)
    		{
    			for(int j=1;j<=i;j++)
    			{
    				System.out.printf("%2d X%2d=%3d ",j,i,i*j);
    			}
    			System.out.println();
    		}
    	}
    }

        运行结果:

    2.从文件输入,输出

    2.1实现方法

        可通过重定向标准输入输出流的方法来实现从文件中输入输出数据。具体使用到的方法如下:

        

    static void setIn(InputStream in)//重定向标准输入
    static void setOut(PrintStream out) //重定向标准输出

       

    2.2从文件输入输出实例--拷贝

        通过重定向的方法,实现从一个文件拷贝东西到另外一个文件。

        代码如下:

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.PrintStream;
    import java.util.Scanner;
    
    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		/*
    		 * FileInputStream里面的路径可以写绝对路径又可以写相对路径,为了程序的移植性,推荐使用相对路径,相对路径
    		 * 的根路径是Copy
    		 */
    		FileInputStream fis = null;
    		PrintStream fos=null;
    		try {
    			fis = new FileInputStream("src/source");
    			fos=new PrintStream("src/dest");
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.setIn(fis);//重定向标准输入
    		
    		//接下来就和从标准输入流读入数据一样了
    		Scanner sc = new Scanner(System.in);
    		String s=sc.nextLine();
    		System.out.println(s);
    		
    		//重定向输出流
    		System.setOut(fos);
    		
    		//接下来就和从标准输出流读入数据一样了
    		System.out.println(s);
    	}
    
    }
    

     

     

     

     

     

     

     

     

     

    展开全文
  • Java输入输出

    千次阅读 2021-03-11 11:58:19
    1.什么是IOJava中I/O操作主要是指使用Java进行输入,输出操作.Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示...

    1.什么是IO

    Java中I/O操作主要是指使用Java进行输入,输出操作. Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。

    Java.io是大多数面向数据流的输入/输出类的主要软件包。此外,Java也对块传输提供支持,在核心库 java.nio中采用的便是块IO。

    流IO的好处是简单易用,缺点是效率较低。块IO效率很高,但编程比较复杂。

    JavaIO模型  :

    Java的IO模型设计非常优秀,它使用Decorator模式,按功能划分Stream,您可以动态装配这些Stream,以便获得您需要的功能。例如,您需要一个具有缓冲的文件输入流,则应当组合使用FileInputStream和BufferedInputStream。

    2.数据流的基本概念

    数据流是一串连续不断的数据的集合,就象水管里的水流,在水管的一端一点一点地供水,而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据,这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说,看不到数据流在写入时的分段情况,每次可以读取其中的任意长度的数据,但只能先读取前面的数据后,再读取后面的数据。不管写入时是将数据分多次写入,还是作为一个整体一次写入,读取时的效果都是完全一样的。

    “流是磁盘或其它外围设备中存储的数据的源点或终点。”

    在电脑上的数据有三种存储方式,一种是外存,一种是内存,一种是缓存。比如电脑上的硬盘,磁盘,U盘等都是外存,在电脑上有内存条,缓存是在CPU里面的。外存的存储量最大,其次是内存,最后是缓存,但是外存的数据的读取最慢,其次是内存,缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解,我们可以简单的理解为容器,即外存是一个容器,内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢?

    在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:

    标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流等等,java中将输入输出抽象称为流,就好像水管,将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流,将数据从内存写入外存中的称为输出流。

    流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。

    总结的基本概念如下:

    1) 数据流:

    一组有序,有起点和终点的字节的数据序列。包括输入流和输出流。

    1355473547_6986.jpg

    2) 输入流(Input  Stream):

    程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…),即是将数据源读入到程序的通信通道

    1333248748_3106.jpg

    3) 输出流:

    程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。

    1333248874_6866.jpg

    采用数据流的目的就是使得输出输入独立于设备。

    Input  Stream不关心数据源来自何种设备(键盘,文件,网络)

    Output  Stream不关心数据的目的是何种设备(键盘,文件,网络)

    4 数据流分类:

    流序列中的数据既可以是未经加工的原始二进制数据,也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种:

    1)  字节流:数据流中最小的数据单元是字节

    2)  字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节。

    3. 标准I/O

    Java程序可通过命令行参数与外界进行简短的信息交换,同时,也规定了与标准输入、输出设备,如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

    1. 命令行参数

    public class TestArgs {

    public static void main(String[] args) {

    for (int i = 0; i 

    System.out.println("args[" + i + "] is ");

    }

    }

    }

    运行命令:javaJava C VB

    运行结果:

    args[0] is

    args[1] is

    args[2] is

    2. 标准输入,输出数据流

    java系统自带的标准数据流:java.lang.System:

    java.lang.System

    public final class System  extends Object{

    static  PrintStream  err;//标准错误流(输出)

    static  InputStream  in;//标准输入(键盘输入流)

    static  PrintStream  out;//标准输出流(显示器输出流)

    }

    注意:

    (1)System类不能创建对象,只能直接使用它的三个静态成员。

    (2)每当main方法被执行时,就自动生成上述三个对象。

    1) 标准输出流 System.out

    System.out向标准输出设备输出数据,其数据类型为PrintStream。方法:

    Void print(参数)

    Void println(参数)

    2)标准输入流 System.in

    System.in读取标准输入设备数据(从标准输入获取数据,一般是键盘),其数 据类型为InputStream。方法:

    int read()  //返回ASCII码。若,返回值=-1,说明没有读取到任何字节读取工作结束。

    int read(byte[] b)//读入多个字节到缓冲区b中返回值是读入的字节数

    例如:

    import java.io.*;

    public class StandardInputOutput {

    public static void main(String args[]) {

    int b;

    try {

    System.out.println("please Input:");

    while ((b = System.in.read()) != -1) {

    System.out.print((char) b);

    }

    } catch (IOException e) {

    System.out.println(e.toString());

    }

    }

    }

    等待键盘输入,键盘输入什么,就打印出什么:

    1354093989_4632.jpg

    3)标准错误流

    System.err输出标准错误,其数据类型为PrintStream。可查阅API获得详细说明。

    标准输出通过System.out调用println方法输出参数并换行,而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法,包括输出参数类型为boolean、char、int、long、float和double。同时,也重载实现 了输出参数类型为char[]、String和Object的方法。其中,print(Object)和println(Object)方法在运行时将调 用参数Object的toString方法。

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStreamReader;

    public class StandardInputOutput {

    public static void main(String args[]) {

    String s;

    // 创建缓冲区阅读器从键盘逐行读入数据

    InputStreamReader ir = new InputStreamReader(System.in);

    BufferedReader in = new BufferedReader(ir);

    System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"

    + "\nWindows系统: ctrl-z 退出");

    try {

    // 读一行数据,并标准输出至显示器

    s = in.readLine();

    // readLine()方法运行时若发生I/O错误,将抛出IOException异常

    while (s != null) {

    System.out.println("Read: " + s);

    s = in.readLine();

    }

    // 关闭缓冲阅读器

    in.close();

    } catch (IOException e) { // Catch any IO exceptions.

    e.printStackTrace();

    }

    }

    }

    4.java.IO层次体系结构

    在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了

    Java I/O主要包括如下几个层次,包含三个部分:

    1.流式部分――IO的主体部分;

    2.非流式部分――主要包含一些辅助流式部分的类,如:File类、RandomAccessFile类和FileDescriptor等类;

    3.其他类--文件读取部分的与安全相关的类,如:SerializablePermission类,以及与本地操作系统相关的文件系统的类,如:FileSystem类和Win32FileSystem类和WinNTFileSystem类。

    主要的类如下:

    1. File(文件特征与管理):用于文件或者目录的描述信息,例如生成新目录,修改文件名,删除文件,判断文件所在路径等。

    2. InputStream(二进制格式操作):抽象类,基于字节的输入操作,是所有输入流的父类。定义了所有输入流都具有的共同特征。

    3. OutputStream(二进制格式操作):抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

    Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。

    4. Reader(文件格式操作):抽象类,基于字符的输入操作。

    5. Writer(文件格式操作):抽象类,基于字符的输出操作。

    6. RandomAccessFile(随机文件操作):它的功能丰富,可以从文件的任意位置进行存取(输入输出)操作。

    Java中IO流的体系结构如图:

    1355467587_4888.jpg

    5. 非流式文件类--File类

    在Java语言的java.io包中,由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类,因为它不负责数据的输入输出,而专门用来管理磁盘文件与目录。

    作用:File类主要用于命名文件、查询文件属性和处理文件目录。

    public    class   File   extends Object

    implements Serializable,Comparable

    {}

    File类共提供了三个不同的构造函数,以不同的参数形式灵活地接收文件和目录名信息。构造函数:

    1)File (String   pathname)

    例:File  f1=new File("FileTest1.txt"); //创建文件对象f1,f1所指的文件是在当前目录下创建的FileTest1.txt

    2)File (String  parent  ,  String child)

    例:File f2=new  File(“D:\\dir1","FileTest2.txt") ;//  注意:D:\\dir1目录事先必须存在,否则异常

    3)File (File    parent  , String child)

    例:File  f4=new File("\\dir3");

    File  f5=new File(f4,"FileTest5.txt");  //在如果 \\dir3目录不存在使用f4.mkdir()先创建

    一个对应于某磁盘文件或目录的File对象一经创建, 就可以通过调用它的方法来获得文件或目录的属性。

    1)public boolean exists( ) 判断文件或目录是否存在

    2)public boolean isFile( ) 判断是文件还是目录

    3)public boolean isDirectory( ) 判断是文件还是目录

    4)public String getName( ) 返回文件名或目录名

    5)public String getPath( ) 返回文件或目录的路径。

    6)public long length( ) 获取文件的长度

    7)public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。

    File类中还定义了一些对文件或目录进行管理、操作的方法,常用的方法有:

    1) public boolean renameTo( File newFile );    重命名文件

    2) public void delete( );   删除文件

    3)  public boolean mkdir( ); 创建目录

    例子:

    import java.io.File;

    import java.io.IOException;

    public class TestFile {

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

    File dir = new File("\\root");

    File f1 = new File(dir, "fileOne.txt");

    File f2 = new File(dir, "fileTwo.java");

    // 文件对象创建后,指定的文件或目录不一定物理上存在

    if (!dir.exists())

    dir.mkdir();

    if (!f1.exists())

    f1.createNewFile();

    if (!f2.exists())

    f2.createNewFile();

    System.out.println("f1's AbsolutePath=  " + f1.getAbsolutePath());

    System.out.println("f1 Canread=" + f1.canRead());

    System.out.println("f1's len= " + f1.length());

    String[] FL;

    int count = 0;

    FL = dir.list();

    for (int i = 0; i 

    count++;

    System.out.println(FL[i] + "is in \\root");

    }

    System.out.println("there are" + count + "file in //root");

    }

    }

    说明:File类的方法:

    (1) exists()测试磁盘中指定的文件或目录是否存在

    (2) mkdir()创建文件对象指定的目录(单层目录)

    (3) createNewFile()创建文件对象指定的文件

    (4) list()返回目录中所有文件名字符串

    6. Java.IO流类库

    1. io流的四个基本类

    java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类:InputStream、OutputStream及Reader、Writer类,它们分别处理字节流和字符流:

    基本数据流的I/O

    输入/输出

    字节流

    字符流

    输入流

    Inputstream

    Reader

    输出流

    OutputStream

    Writer

    IO框架:

    1160987d328c8cead727d37b3764be23.png

    Java中其他多种多样变化的流均是由它们派生出来的:

    1333250374_3564.gif

    1333250382_9126.gif

    1333250341_6152.gif

    1333250133_8675.gif

    JDK1.4版本开始引入了新I/O类库,它位于java.nio包中,新I/O类库利用通道和缓冲区等来提高I/O操作的效率。

    在java.io包中, java.io.InputStream 表示字节输入流, java.io.OutputStream表示字节输出流,处于java.io包最顶层。这两个类均为抽象类,也就是说它们不能被实例化,必须生成子类之后才能实现一定的功能。

    1. io流的具体分类

    一、按I/O类型来总体分类:

    1. Memory 1)从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream

    2)从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream

    2.Pipe管道实现管道的输入和输出(进程间通信): PipedReader、PipedWriter、PipedInputStream、PipedOutputStream

    3.File 文件流。对文件进行读、写操作 :FileReader、FileWriter、FileInputStream、FileOutputStream

    4. ObjectSerialization 对象输入、输出 :ObjectInputStream、ObjectOutputStream

    5.DataConversion数据流 按基本数据类型读、写(处理的数据是Java的基本类型(如布尔型,字节,整数和浮点数)):DataInputStream、DataOutputStream

    6.Printing 包含方便的打印方法 :PrintWriter、PrintStream

    7.Buffering缓冲 在读入或写出时,对数据进行缓存,以减少I/O的次数:BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream

    8.Filtering滤流,在数据进行读或写时进行过滤:FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过

    9.Concatenation合并输入 把多个输入流连接成一个输入流 :SequenceInputStream

    10.Counting计数  在读入数据时对行记数 :LineNumberReader、LineNumberInputStream

    11.Peeking Ahead 通过缓存机制,进行预读 :PushbackReader、PushbackInputStream

    12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流,或进行反向转换(Stream到Reader,Writer的转换类):InputStreamReader、OutputStreamWriter

    二、按数据来源(去向)分类:

    1、File(文件): FileInputStream, FileOutputStream, FileReader, FileWriter

    2、byte[]:ByteArrayInputStream, ByteArrayOutputStream

    3、Char[]: CharArrayReader, CharArrayWriter

    4、String: StringBufferInputStream, StringReader, StringWriter

    5、网络数据流:InputStream, OutputStream, Reader, Writer

    7. 字节流InputStream/OutputStream

    1. InputStream抽象类

    InputStream 为字节输入流,它本身为一个抽象类,必须依靠其子类实现各种功能,此抽象类是表示字节输入流的所有类的超类。 继承自InputStream  的流都是向程序中输入数据的,且数据单位为字节(8bit);

    InputStream是输入字节数据用的类,所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法:

    (1) public abstract int read( ):读取一个byte的数据,返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。

    (2) public int read(byte b[ ]):读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的

    (3) public int read(byte b[ ], int off, int len):从输入流中最多读取len个字节的数据,存放到偏移量为off的b数组中。

    (4) public int available( ):返回输入流中可以读取的字节数。注意:若输入阻塞,当前线程将被挂起,如果InputStream对象调用这个方法的话,它只会返回0,这个方法必须由继承InputStream类的子类对象调用才有用,

    (5) public long skip(long n):忽略输入流中的n个字节,返回值是实际忽略的字节数, 跳过一些字节来读取

    (6) public int close( ) :我们在使用完后,必须对我们打开的流进行关闭.

    主要的子类:

    1333250374_3564.gif

    1) FileInputStream把一个文件作为InputStream,实现对文件的读取操作

    2) ByteArrayInputStream:把内存中的一个缓冲区作为InputStream使用

    3) StringBufferInputStream:把一个String对象作为InputStream

    4) PipedInputStream:实现了pipe的概念,主要在线程中使用

    5) SequenceInputStream:把多个InputStream合并为一个InputStream

    2.OutputStream抽象类

    OutputStream提供了3个write方法来做数据的输出,这个是和InputStream是相对应的。

    1. public void write(byte b[ ]):将参数b中的字节写到输出流。

    2. public void write(byte b[ ], int off, int len) :将参数b的从偏移量off开始的len个字节写到输出流。

    3. public abstract void write(int b) :先将int转换为byte类型,把低字节写入到输出流中。

    4. public void flush( ) : 将数据缓冲区中数据全部输出,并清空缓冲区。

    5. public void close( ) : 关闭输出流并释放与流相关的系统资源。

    主要的子类:

    1333250382_9126.gif

    1) ByteArrayOutputStream:把信息存入内存中的一个缓冲区中

    2) FileOutputStream:把信息存入文件中

    3) PipedOutputStream:实现了pipe的概念,主要在线程中使用

    4) SequenceOutputStream:把多个OutStream合并为一个OutStream

    流结束的判断:方法read()的返回值为-1时;readLine()的返回值为null时。

    3. 文件输入流: FileInputStream类

    FileInputStream可以使用read()方法一次读入一个字节,并以int类型返回,或者是使用read()方法时读入至一个byte数组,byte数组的元素有多少个,就读入多少个字节。在将整个文件读取完成或写入完毕的过程中,这么一个byte数组通常被当作缓冲区,因为这么一个byte数组通常扮演承接数据的中间角色。

    1354189614_8795.jpg

    作用:以文件作为数据输入源的数据流。或者说是打开文件,从文件读数据到内存的类。

    使用方法(1)

    File  fin=new File("d:/abc.txt");

    FileInputStream in=new FileInputStream( fin);

    使用方法(2)

    FileInputStream  in=new  FileInputStream(“d: /abc.txt”);

    程序举例:

    将InputFromFile.java的程序的内容显示在显示器上

    1354189800_1523.jpg

    import java.io.IOException;

    import java.io.FileInputStream;

    ;

    public class TestFile {

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

    try{

    FileInputStream rf=new   FileInputStream("InputFromFile.java");

    int n=512;   byte  buffer[]=new  byte[n];

    while((rf.read(buffer,0,n)!=-1)&&(n>0)){

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

    }

    System.out.println();

    rf.close();

    } catch(IOException  IOe){

    System.out.println(IOe.toString());

    }

    }

    }

    4.文件输出流:FileOutputStream类

    作用:用来处理以文件作为数据输出目的数据流;或者说是从内存区读数据入文件

    FileOutputStream类用来处理以文件作为数据输出目的数据流;一个表示文件名的字符串,也可以是File或FileDescriptor对象。

    创建一个文件流对象有两种方法:

    方式1:

    File   f=new  File (“d:/myjava/write.txt ");

    FileOutputStream  out= new FileOutputStream (f);

    方式2:

    FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt ");

    方式3:构造函数将 FileDescriptor()对象作为其参数。

    FileDescriptor() fd=new FileDescriptor();

    FileOutputStream f2=new FileOutputStream(fd);

    方式4:构造函数将文件名作为其第一参数,将布尔值作为第二参数。

    FileOutputStream f=new FileOutputStream("d:/abc.txt",true);

    注意: (1)文件中写数据时,若文件已经存在,则覆盖存在的文件;(2)的读/写操作结束时,应调用close方法关闭流。

    程序举例:使用键盘输入一段文章,将文章保存在文件write.txt中

    1354190012_9885.jpg

    import java.io.IOException;

    import java.io.FileOutputStream;

    public class TestFile {

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

    try {

    System.out.println("please Input from      Keyboard");

    int count, n = 512;

    byte buffer[] = new byte[n];

    count = System.in.read(buffer);

    FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");

    wf.write(buffer, 0, count);

    wf.close(); // 当流写操作结束时,调用close方法关闭流。

    System.out.println("Save to the write.txt");

    } catch (IOException IOe) {

    System.out.println("File Write Error!");

    }

    }

    }

    5. FileInputStream流和FileOutputStream的应用

    利用程序将文件file1.txt 拷贝到file2.txt中。

    import java.io.File;

    import java.io.IOException;

    import java.io.FileOutputStream;

    import java.io.FileInputStream;

    public class TestFile {

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

    try {

    File inFile = new File("copy.java");

    File outFile = new File("copy2.java");

    FileInputStream finS = new FileInputStream(inFile);

    FileOutputStream foutS = new FileOutputStream(outFile);

    int c;

    while ((c = finS.read()) != -1) {

    foutS.write(c);

    }

    finS.close();

    foutS.close();

    } catch (IOException e) {

    System.err.println("FileStreamsTest: " + e);

    }

    }

    }

    6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream

    1355473479_8987.jpg

    计算机访问外部设备非常耗时。访问外存的频率越高,造成CPU闲置的概率就越大。为了减少访问外存的次数,应该在一次对外设的访问中,读写更多的数据。为此,除了程序和流节点间交换数据必需的读写机制外,还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区,一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

    BufferedInputStream:当向缓冲流写入数据时候,数据先写到缓冲区,待缓冲区写满后,系统一次性将数据发送给输出设备。

    BufferedOutputStream :当从向缓冲流读取数据时候,系统先从缓冲区读出数据,待缓冲区为空时,系统再从输入设备读取数据到缓冲区。

    1)将文件读入内存:

    将BufferedInputStream与FileInputStream相接

    FileInputStream in=new  FileInputStream( “file1.txt ” );

    BufferedInputStream bin=new  BufferedInputStream( in);

    2)将内存写入文件:

    将BufferedOutputStream与 FileOutputStream相接

    FileOutputStreamout=new FileOutputStream(“file1.txt”);

    BufferedOutputStream  bin=new BufferedInputStream(out);

    3)键盘输入流读到内存

    将BufferedReader与标准的数据流相接

    InputStreamReader sin=new InputStreamReader (System.in) ;

    BufferedReader bin=new             BufferedReader(sin);

    import java.io.*;

    public class ReadWriteToFile {

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

    InputStreamReader sin = new InputStreamReader(System.in);

    BufferedReader bin = new BufferedReader(sin);

    FileWriter out = new FileWriter("myfile.txt");

    BufferedWriter bout = new BufferedWriter(out);

    String s;

    while ((s = bin.readLine()).length() > 0) {

    bout.write(s, 0, s.length());

    }

    }

    }

    程序说明:

    从键盘读入字符,并写入到文件中BufferedReader类的方法:String readLine()

    作用:读一行字符串,以回车符为结束。

    BufferedWriter类的方法:bout.write(String s,offset,len)

    作用:从缓冲区将字符串s从offset开始,len长度的字符串写到某处。

    8. 字符流Writer/Reader

    Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。

    1. Reader抽象类

    用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。

    1333250341_6152.gif

    1) FileReader :与FileInputStream对应

    主要用来读取字符文件,使用缺省的字符编码,有三种构造函数:

    (1)将文件名作为字符串 :FileReader f=new FileReader(“c:/temp.txt”);

    (2)构造函数将File对象作为其参数。

    File f=new file(“c:/temp.txt”);

    FileReader f1=new FileReader(f);

    (3)  构造函数将FileDescriptor对象作为参数

    FileDescriptor() fd=new FileDescriptor()

    FileReader f2=new FileReader(fd);

    (1) 用指定字符数组作为参数:CharArrayReader(char[])

    (2) 将字符数组作为输入流:CharArrayReader(char[], int, int)

    读取字符串,构造函数如下: public StringReader(String s);

    2) CharArrayReader:与ByteArrayInputStream对应

    3) StringReader :与StringBufferInputStream对应

    4) InputStreamReader

    从输入流读取字节,在将它们转换成字符:Public inputstreamReader(inputstream is);

    5) FilterReader:允许过滤字符流

    protected filterReader(Reader r);

    6) BufferReader :接受Reader对象作为参数,并对其添加字符缓冲器,使用readline()方法可以读取一行。

    Public BufferReader(Reader r);

    主要方法:

    (1)  public int read() throws IOException; //读取一个字符,返回值为读取的字符

    (2)  public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中,返回值为实际读取的字符的数量*/

    (3)  public abstract int read(char cbuf[],int off,int len) throws IOException;

    /*读取len个字符,从数组cbuf[]的下标off处开始存放,返回值为实际读取的字符数量,该方法必须由子类实现*/

    2. Writer抽象类

    写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。 其子类如下:

    1333250133_8675.gif

    1) FileWrite: 与FileOutputStream对应

    将字符类型数据写入文件,使用缺省字符编码和缓冲器大小。

    Public FileWrite(file f);

    2)  chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。

    Public CharArrayWrite();

    3) PrintWrite:生成格式化输出

    public PrintWriter(outputstream os);

    4) filterWriter:用于写入过滤字符流

    protected FilterWriter(Writer w);

    5) PipedWriter:与PipedOutputStream对应

    6) StringWriter:无与之对应的以字节为导向的stream

    主要方法:

    (1)  public void write(int c) throws IOException; //将整型值c的低16位写入输出流

    (2)  public void write(char cbuf[]) throws IOException; //将字符数组cbuf[]写入输出流

    (3)  public abstract void write(char cbuf[],int off,int len) throws IOException; //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流

    (4)  public void write(String str) throws IOException; //将字符串str中的字符写入输出流

    (5)  public void write(String str,int off,int len) throws IOException; //将字符串str 中从索引off开始处的len个字符写入输出流

    (6)  flush( ) //刷空输出流,并输出所有被缓存的字节。

    (7)close()    关闭流 public abstract void close() throws IOException

    3 .InputStream与Reader差别 OutputStream与Writer差别

    InputStream和OutputStream类处理的是字节流,数据流中的最小单位是字节(8个bit)

    Reader与Writer处理的是字符流,在处理字符流时涉及了字符编码的转换问题

    import java.io.*;

    public class EncodeTest {

    private static void readBuff(byte [] buff) throws IOException {

    ByteArrayInputStream in =new ByteArrayInputStream(buff);

    int data;

    while((data=in.read())!=-1)   System.out.print(data+"  ");

    System.out.println();     in.close();     }

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

    System.out.println("内存中采用unicode字符编码:" );

    char   c='好';

    int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;

    System.out.println(""+lowBit+"   "+highBit);

    String s="好";

    System.out.println("本地操作系统默认字符编码:");

    readBuff(s.getBytes());

    System.out.println("采用GBK字符编码:");

    readBuff(s.getBytes("GBK"));

    System.out.println("采用UTF-8字符编码:");

    readBuff(s.getBytes("UTF-8"));      }

    }

    1354191297_8218.jpg

    Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符,然后在内存中为其分配内存

    Writer类能够将内存中的Unicode字符转换为其他编码类型的字符,再写到输出流中。

    9. FileWriter类(字符输出流类)

    构造方法:FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话,并创建。

    如: FileWriter fw = new FileWriter("C:\\1.txt");

    FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。

    如:FileWriter fw = new FileWriter("C:\\1.txt",ture); //表示在fw对文件再次写入时,会在该文件的结尾续写,并不会覆盖掉。

    主要方法:

    void write(String str)   //写入字符串。当执行完此方法后,字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。

    viod flush()                //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。

    viod close()               //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后,再写入或者刷新的话,会抛IOException异常。

    10. 如何选择IO流

    1)确定是数据源和数据目的(输入还是输出)

    源:输入流 InputStream Reader

    目的:输出流 OutputStream Writer

    2)明确操作的数据对象是否是纯文本

    是:字符流Reader,Writer

    否:字节流InputStream,OutputStream

    3)明确具体的设备。

    是硬盘文件:File++:

    读取:FileInputStream,, FileReader,

    写入:FileOutputStream,FileWriter

    是内存用数组

    byte[]:ByteArrayInputStream, ByteArrayOutputStream

    是char[]:CharArrayReader, CharArrayWriter

    是String:StringBufferInputStream(已过时,因为其只能用于String的每个字符都是8位的字符串), StringReader, StringWriter

    是网络用Socket流

    是键盘:用System.in(是一个InputStream对象)读取,用System.out(是一个OutoutStream对象)打印

    3)是否需要转换流

    是,就使用转换流,从Stream转化为Reader,Writer:InputStreamReader,OutputStreamWriter

    4)是否需要缓冲提高效率

    是就加上Buffered:BufferedInputStream, BufferedOuputStream, BuffereaReader, BufferedWriter

    5)是否需要格式化输出

    例:将一个文本文件中数据存储到另一个文件中。

    1)数据源和数据目的:读取流,InputStream Reader  输出:OutputStream Writer

    2)是否纯文本:是!这时就可以选择Reader Writer。

    3)设备:是硬盘文件。Reader体系中可以操作文件的对象是 FileReader FileWriter。

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

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

    4)是否需要提高效率:是,加Buffer

    BufferedReader bfr = new BufferedReader(new FileReader("a.txt");  );

    BufferedWriter bfw = new BufferedWriter(new FileWriter("b.txt");  );

    11. IOException异常类的子类

    1.public class  EOFException :

    非正常到达文件尾或输入流尾时,抛出这种类型的异常。

    2.public class FileNotFoundException:

    当文件找不到时,抛出的异常。

    3.public class InterruptedIOException:

    当I/O操作被中断时,抛出这种类型的异常。

    from: http://blog.csdn.net/hguisu/article/details/7418161

    展开全文
  • Java输入输出/异常处理

    千次阅读 2019-03-22 17:54:34
    处理输入输出操作时,库里的很多IO流类的方法都会抛出异常。 又称为例外,是特殊的运行错误对象。 Java中声明了很多异常类,每个异常类都代表了一种运行错误,类中包含了:该运行错误的信息;处理错误的方法。 每当...
    1. 异常处理:程序容错机制。
      将程序的主要逻辑于异常处理逻辑分离,发现异常,先抛出。
      处理输入输出操作时,库里的很多IO流类的方法都会抛出异常。
      又称为例外,是特殊的运行错误对象。
      Java中声明了很多异常类,每个异常类都代表了一种运行错误,类中包含了:该运行错误的信息;处理错误的方法。
      每当Java程序运行过程中发生了一个可识别的运行错误时,即该错误有一个异常类与之相对应时,系统都会产生一个异常类的对象,即产生一个异常。
      Java异常处理机制:
      将错误处理代码从常规代码中分离出来;
      按错误类型和差别分组;
      对无法预测的错误的捕获和处理;
      克服了传统方法的错误信息有限的问题;
      把错误传播给调用堆栈。
      错误的分类:
      错误:致命性,程序无法处理;Error类是所有错误类的父类;
      异常:非致命性,可编制程序捕获和处理;Exception类是所有异常类的父类。
      非检查型异常:
      不期望程序捕获的异常,在方法中不需要声明,编译器也不进行检查。
      继承自RuntimeException。引发RuntimeException的操作在Java应用程序中会频繁出现。例如,若每次使用对象时,都必须编写异常处理代码来检查null引用,则整个应用程序很快将会变成一个庞大的try-catch块。
      它们表示的问题不一定作物异常处理。
      检查型异常:其他类型的异常
      如果被调用的方法抛出一个类型为E的检查型异常,那么调用这必须捕获E或者也声明抛出E(或者E的一个父类),对此编译器要进行检查。
      非检查型异常:
    ArithmeticException  // 整数除法中除数为0
    NullPointException  //访问的对象还没有实力化
    NegativeArraySizeException  //创建数组时元素个数是负数
    ArrayIndexOutOfBounddsException  //访问数组元素时,数组下标越界
    

    检查型异常:

    ArrayStoreException  //程序试图向数组中存取错误类型的数据
    FileNotFoundException  //试图存取一个并不存在的文件
    IOException  // 通常的I/O错误
    

    异常的处理
    检查型异常的处理
    声明抛出异常
    不在当前方法内处理异常,可以使用throws子句声明将异常抛出到调用方法中;
    如果所有的方法都选择了抛出此异常,最后JVM将捕获它,输出相关的错误信息,并将**中止程序的运=行。
    捕获异常:使用try{} catch块{}, 捕获到所发生的异常,并进行处理。

    try {statements(s)} catch (exception){statements(s)}finally {statements(s)}
    

    // try语句: 其后跟随可能产生异常的代码块。
    catch语句:其后跟随异常处理语句,通常用到两个方法:
    getMessage() -返回一个字符串,对发生的异常进行描述。
    printStackTrace() - 给出方法的调用序列,一直到异常产生的位置。
    finally语句:不论在try代码段是否产生异常,finally后的程序代码段都会被执行。通常在这里释放内存以外的其他资源。

    声明自己的异常类:自定义所有异常类都必须是Exception的子类;

    public class MyExceptionName extends SuperclassOfException {
    	public MyException() {
    		super("Some string explaining the exception"); //描述异常信息
    	}
    }
    
    1. 输入输出流:
      java.io包的顶级层次结构:
      面向字符的流:专门用于处理字符数据;InputStream OutputStream
      面向字节的流:用于一般目的;Reader Writer
      面向字符的流:源或目标通常是文本文件;实现内部格式和文本文件中的外部格式之间的转换。
      内部格式:16-bit char 数据类型
      外部格式:UTF(Universal character set Tranforamtion Format):很多人称之为“Universal Text Format"包括ASCII码及非ASCII码字符,比如:斯拉夫(Cyrillic)字符,希腊字符,亚洲字符。
      面向字符的抽象流类—Reader和Writer
      java.io 包中所有字符流的抽象超类。
      Reader提供了输入字符的API。
      Writer提供了输出字符的API。
      它们的子类又可分为两大类:
      节点流:从数据源读入数据或往目的地写出数据;
      处理流:对数据执行某种处理;
      多数程序使用这两个抽象类的一系列子类来读入/写出文本信息
      例如:FileReader/FileWriter 用来读/写文本文件。

    面向字节的抽象流类 - - -InputStream 和 OutputStream
    是用来处理字节流的抽象基类,程序使用这两个类的子类来读写字节信息。
    分为节点流和处理流。

    标准输入输出流对象:
    System类的静态成员变量:
    包括:
    System.in: InputStream 类型的,代表标准输入流,默认状态对应于键盘输入。
    System.out:PrintStream 类型的,代表标准输出流,默认状态对应与显示器输出。
    System.eer:PrintStream类型的,代表标准错误信息输出流,默认状态对应于显示器输出。
    按类型输入/输出数据:
    printf方法:

    System.out.printf("%-12s %2d long" ,name , 1);
    System.out.printf("value = %2.2F",value );
    

    Scanner

    Scaner s = new Scanner(System.in);
    int n = s.nextInt();
    

    标准输入输出重定向(复制文件)

    import java.io.*;
    
    public class Redirecting {
    	public static void main(String[] args) throws IOException{
    		BufferedInputStream in = new BufferedInputStream(
    				new FileInputStream("Redirecting.java"));
    		PrintStream out = new PrintStream(new
    				BufferedOutputStream(new FileOutputStream("test.out")));
    		System.setIn(in);  System.setOut(out); System.setErr(out);
    		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    		String s;
    		while ((s=br.readLine())!= null) System.out.print(s);
    		in.close();
    		out.close();
    		
    	}
    }
    
    
    1. 文件读写:
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class FileWriterTester {
    	public static void main(String[] args) throws IOException {
    		//main方法中声明抛出异常
    		String fileName = "Hello.txt";
    		FileWriter writer = new FileWriter(fileName);
    		writer.write("hello! \n");
    		writer.write("This is my first file, \n");
    		writer.close();
    		
    	}
    }
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class FileWriterTester {
    	public static void main(String[] args)  {
    		//main方法中声明抛出异常
    		String fileName = "Hello.txt";
    		try {//将所有IO操作放入try块
    			FileWriter writer = new FileWriter(fileName);
    			writer.write("hello! \n");
    			writer.write("This is my first file, \n");
    			writer.close();
    		}
    		catch (IOException iox) {System.out.println("Porblen writing" + fileName);}
    		
    		
    	}
    }
    
    

    BufferedWriter 类
    FileWriter和BrfferedWriter 类都用于输出字符流,包含的方法几乎完全一样,但BufferedWriter多提供了一个newLine()方法用于换行。
    不同的系统对文字的换行方法不同,newLine()方法可以输出在当前计算机上正确的换行符。

    import java.io.*;
    
    public class BufferedReaderTester {
    	public static void main(String[] args) {
    		String fileName = "Hello.txt" , line;
    		try {
    			BufferedReader in = new BufferedReader(new FileReader(fileName));
    			line = in.readLine();
    			while (line != null);{
    			System.out.println(line); line = in.readLine();
    			}
    			in.close();
    		}
    		catch (IOException iox) {System.out.println("Problem reading" + fileName);}
    	
    	}
    	
    }
    
    1. 读写二进制文件
    2. File类:
      创建,删除文件;
      重命名文件;
      判断文件的读写权限及是否存在;
      设置和查询文件的最近修改时间等;
      构造文件流可以使用File类的对象作为参数。
    import java.io.*;
    
    public class FileTester {
    	public static void main(String[] args) {
    		File f = new File("Hello.txt");
    		if (f.exists()) f.delete();
    		else
    			try {
    				f.createNewFile();
    				
    			}
    			catch (Exception e) {
    				System.out.println(e.getMessage());
    			}
    	}
    }
    
    

    处理压缩文件:
    压缩流类
    GZIPOutputStream和ZipOutStream:可分别把数据压缩成GZIP格式和Zip格式;
    GZIPInputStream和ZipInputStream:解压。

    在这里插入代码片
    

    对象序列化:永久保留程序重点数据
    ObjectInputStream/ ObjectOutStream 类
    实现对象的读写:
    通过ObjectOutputStream把对象写入磁盘文件;
    通过ObjectInputStream把对象读入程序;
    不想保存对象的transient和static类型的变量;
    对象要想实现序列化,其所属的类必须实现Serializable接口。

    自定义读写
    Externalizable接口:API中的说明为public interface Externalization extends Serializable
    其中有两个方法writeExternal()readExternal(),因此实现该接口的类必须实现这两个方法。

    随机文件读写:
    RandonAccessFile类:
    可跳转到文件的任意位置读写文件;
    可在随机文件中插入数据,而不破坏该文件的其他数据;
    实现了DataInput和DataOutput接口,可使用普通的读写方法;
    有个位置指示器,指向当前读写处的位置。刚打开文件时,文件指示器指向文件的开头处。对文件指针的显式操作
    int skipByte(int n): 把文件指针向前移动指定的n个字节

    void seek (long):移动文件到指定的位置
    
    long getFilePointer(): 得到当前的文件指针
    

    在等长记录格式文件的随机读取时有很大优势,但仅限与操作文件,不能访问其它IO设备,如网络,内存映像等。

    展开全文
  • java 输入输出

    千次阅读 多人点赞 2020-06-18 21:57:53
    什么是字节 字节是指一小组相邻的二进制数码。通常是8位作为一个字节。它是构成信息的一个小单位,并作为一个整体来参加操作,比字小,是构成字的单位。 字节(Byte) 是一种计量单位,表示数据量的多少,它是计算机...
  • Java——输入输出

    千次阅读 2021-08-31 15:17:38
    本文主要介绍Java中如何进行输入输出操作
  • Java快速输入输出使用详解 一、背景:   Scanner类输入时,输入效率比较慢,输入数据大于10^5左右时(你觉得数据有点多时就用快速输入即可),某些题目会超时。所以需要输入快一点的方法。   一般情况下输入数据...
  • java输入输出--字节流处理

    千次阅读 2018-07-10 01:02:25
    字节流类为处理字节式输入输出提供了丰富的环境。 InputStream/OutputStream InputStream 是一个定义了 Java 字节流输入模式的抽象类。 该类的所有方法在出错条件下都将引发一个 IOException 异常。其声明格式...
  • JAVA笔试——输入输出集锦

    千次阅读 2019-06-17 20:09:53
    1.输入 Scanner reader = new Scanner(System.in) ; 读一个整数 int n = sc.nextInt(); 读一个字符串 String s = sc.next(); 读一个浮点数 double t = sc.nextDouble(); 读一整行 String s = sc....
  • 【小技巧】【牛客网】【JAVA】在线输入输出练习

    千次阅读 多人点赞 2020-08-08 13:35:12
    1. 一直输入模板 import java.util.*; public class Main{ public static void main(String[] args) { Scanner sc = new Scanner(System.in); while (sc.hasNext()) { //操作 } } } 2. 有组数或者输入个数 ...
  • LeetCode刷题 - Java常用输入输出

    千次阅读 2021-06-11 17:30:51
    LeetCode刷题 - Java常用输入输出 基本语法 导包 import java.util.Scanner; //或者直接导入下面两个包 import java.util.*; import java.io.*; 常用输入 Scanner sc = new Scanner(System.in); //读一个整数 int n...
  • Java 输入输出流】

    千次阅读 多人点赞 2021-04-15 17:02:47
    Java 输入输出流(I/O流)1 File类1.1 文件的属性1.2 目录2 文件字节输入输出流二级目录三级目录3 文件字符输入输出流二级目录三级目录4 缓冲流二级目录三级目录 概述:输入输出流提供一条通道程序,可以...
  • JAVA流式输入输出与文件处理.pdf

    千次阅读 2021-02-26 17:30:50
    JAVA流式输入输出与文件处理流式输入输出与文件处理实验目的(1) 掌握字节流和字符流的特点和处理差异;(2) 掌握过滤流的使用;(3) 掌握File类的使用;(4) 掌握随机文件的使用。(5) 掌握对象系列化的概念以及访问文件...
  • Java输入输出流详解

    万次阅读 多人点赞 2017-06-17 21:15:21
    Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出...
  • 赛码网输入输出整理(Java

    千次阅读 2020-08-27 10:11:13
    自己记录用。 1. 描述:给予两个整数a,b,计算a+b。 输入输入包含多组测试数据,每一行包含两个整数 a 和 b... 输入:1 3 输出:4 2 4 6 5 6 11 import java.io.*; import java.util.*; class Test { } p...
  • Java IO流的学习过程中,对 txt 形式的文本文件进行写入/写出操作时,出现了 中文乱码 的现象,经过不懈地努力下,查阅相关资料后得以解决。现记录一下自己的解决过程,希望能帮到大家。
  • Java输入/输出——File类详解

    千次阅读 2019-02-28 00:39:41
    本文主要讲述了Java输入输出(IO)方面的内容,IO是...Java的IO通过Java.IO 包下的类和接口来支持,主要包括输入/输出两种IO流,每种输入/输出流又可以分为字节流和字符流两大类,其中字节流自己为单位来处...
  • java牛客网 输入输出

    千次阅读 2018-08-29 14:39:19
    作者:管理员链接:https://www.nowcoder.com/discuss/276来源:牛客网...import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); whil...
  • 详解Java输入输出

    万次阅读 多人点赞 2018-07-02 10:05:11
    Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,...
  • Java输入/输出

    万次阅读 2018-05-06 14:29:58
    文本(Text)输入/输出 输出用PrintWriter类 try-with-resources来自动关闭资源 用Scanner来读取文本 流式处理 二进制(Binary)输入/输出 二进制输入/输出到文件 FilterInputStream/FilterOutputStream ...
  • java输入输出流的简单入门

    万次阅读 多人点赞 2019-03-30 19:17:24
    另一方面,程序在处理数据后,可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序,这就需要使用输出流。 通俗的解释就是,我当前程序为主,我要和其他的事物进行交流,所以我必须要搭一个通道...
  • ACM之Java输入输出

    千次阅读 2016-08-01 16:47:26
    一、Java之ACM注意点 ...3. 有些OJ上的题目会直接将OI上的题目拷贝过来,所以即便是题目中有输入和输出文件,可能也不需要,因为在OJ系统中一般是采用标准输入输出,不需要文件 4. 在有多行
  • java 输入输出流详解及分类

    千次阅读 多人点赞 2018-08-09 19:42:07
    –字节流是指8位的通用字节流,字节为基本单位,在java.io包中,对于字节流进行操作的类大部分继承于InputStream(输入字节流)类和OutputStream(输出字节流)类; –字符流是指16位的Unicode字符流,字符...
  • ACM中Java输入输出

    千次阅读 2018-08-05 18:10:28
    下面列出几种常用的输入输出方式。(输出统一用printwriter,系统的system.out太慢,结尾要释放缓存才能输出,不然数据放在缓存中输不出来) 1:Scanner 这个类最慢,但是最好用,因为这个类没有缓存处理,所以io...
  • 1)先开后关,先开的输入流,再开的输出流,通过读取输入流写入输出流中,那么应该先关输出流,再关输入流,但是一般关闭输入输出流操作都是在读写完成后的finally中执行的,所以即使先关输入流,再关输出流也不会...
  • Java基础】异常处理输入输出

    千次阅读 2016-05-24 16:12:06
    如果会,那么是什么时候执行(return前还是return后) 在Java的异常处理中,不论什么情形,finally中的逻辑一定会执行,也就是说try{}块里面有return,那么finally同样会执行的,执行时机就是try{}中的return 之前。...
  • 你真的懂Java怎么输出Hello World吗?

    万次阅读 多人点赞 2021-06-09 22:00:57
    你真的懂Java怎么输出Hello World吗?1. 你会不会输出"Hello World!"?2. 小生抛砖引玉,欢迎指正3. 总结 1. 你会不会输出"Hello World!"? 当我们学习一门编程语言的时候,我们都会先学如何输出Hello World! ????...
  • 4.java字符串和输入输出

    万次阅读 2018-11-09 01:50:36
    目录 1.String类 2.StringBuilder类 ...5.输入输出类 6.java格式化输出 1.String类 从概念上讲,java字符串就是Unicode字符序列。​​​​ String类提供处理Unicode代码点(即字符)的方法,以及用于处理...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 495,163
精华内容 198,065
关键字:

java的输入输出是以什么方式处理的

java 订阅